CaloCellPacker_400_500.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: CaloCellPacker_400_500.h,v 1.3 2009-03-19 01:42:14 ssnyder Exp $
 
#ifndef CALOCELLPACKER_400_500_H
#define CALOCELLPACKER_400_500_H
 
 
#include "CaloCellPackerUtils.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "LArRecEvent/LArCell.h"
#include "TileEvent/TileCell.h"
#include "AthAllocators/DataPool.h"
#include "CaloEvent/CaloCompactCellContainer.h"
class CaloCellContainer;
class CaloCell;
class CaloCellPacker_400_500_test;
namespace SG {
  class ThinningDecisionBase;
}
 
class CaloCellPacker_400_500
{
public:
  void pack (const CaloCellContainer& cells,
             CaloCompactCellContainer& packed,
             const SG::ThinningDecisionBase* dec,
             int version) const;
 
 
  void unpack (const CaloCompactCellContainer& packed,
               const std::vector<CaloCompactCellContainer::value_type>&vheader,
               CaloCellContainer& cells,
               DataPool<LArCell>& larpool,
               DataPool<TileCell>& tilepool) const;
 
private:
 
  //==========================================================================
 
  struct header400 {
    int m_length;                      // Header length, in units of int.
 
    int m_version;                     // Version code (ICaloCompactCellTool).
 
    int m_ncells_larem;
    int m_ncells_larhec;
    int m_ncells_larfcal;
    int m_ncells_tile;
 
    unsigned int m_qualy_mask;        // Quality.
    unsigned int m_egain_mask;        // LAr gain.
    unsigned int m_esign_mask;        // LAr energy sign bit.
    unsigned int m_crtae_mask;        // LAr cbrt(energy).
    unsigned int m_egain_tile_mask;   // Tile gain.
    unsigned int m_esign_tile_mask;   // Tile energy sign bit.
    unsigned int m_crtae_tile_mask;   // Tile cbrt(energy).
    unsigned int m_tsign_mask;        // Time sign bit.
    unsigned int m_logat_mask;        // log(time).
 
    int m_qabad;                      // Bad quality flag.
    int m_enlow;                      // LAr low gain.
    int m_enmed;                      // LAr medium gain.
    int m_enhig;                      // LAr high gain.
    int m_ehhig;                      // LAr high gain with 50 GeV range.
    int m_glow;                       // Tile low range.
    int m_ghigh;                      // Tile high range.
 
    int m_seq_larem;
    int m_seq_larhec;
    int m_seq_larfcal;
    int m_seq_tile;
 
    float m_e1_norm_res;              // Normal LAr energy range.
    float m_e1_high_res;              // High gain LAr energy range.
    float m_high_tile;                // High gain tile energy range.
    float m_low_tile;                 // Low gain tile energy range.
    float m_t0;                       // Lower time range.
    float m_t1;                       // Upper time range.
  };
 
 
  struct header500
    : public header400
  {
    // The number of provenance entries (in 16-bit units).
    // In order to know from where to start reading provenance.
    unsigned int m_lengthProvenance;
  };
 
 
  struct header501
    : public header500
  {
    // A bitmask for additional status information.
    // Added for version 501.
    unsigned int m_status;
 
    enum {
      // Set if the cells are not in subcalo order.
      STATUS_UNORDERED = (1 << 0),
      // Set if the cells are SuperCell
      STATUS_IS_SUPERCELL = (1 << 1)
    };
  };
 
 
  typedef header501 header;
 
 
  struct pars500
    : public header
  {
    int m_qgood;
 
    unsigned int m_nseq_max;
    unsigned int m_prov_max;
    unsigned int m_prov_max_tile;
 
    double m_cbrt_e1_norm_res;       // cbrt(e1_norm_res)
    double m_cbrt_e1_high_res;       // cbrt(e1_high_res)
    double m_cbrt_low_tile;          // cbrt(low_tile)
    double m_cbrt_high_tile;         // cbrt(high_tile)
    double m_log_t0;                 // log(t0)
    double m_log_t1;                 // log(t1)
 
    CaloCellPackerUtils::Bitfield m_hash_field;
    CaloCellPackerUtils::Bitfield m_nseq_field;
    CaloCellPackerUtils::Bitfield m_prov_field;
 
    CaloCellPackerUtils::Bitfield m_egain_field;
    CaloCellPackerUtils::Bitfield m_qualy_field;
    CaloCellPackerUtils::Floatfield m_logat_field;
    CaloCellPackerUtils::Floatfield2 m_crtae_norm_field;
    CaloCellPackerUtils::Floatfield2 m_crtae_high_field;
    CaloCellPackerUtils::Floatfield2 m_crtae_tile_low_field;
    CaloCellPackerUtils::Floatfield2 m_crtae_tile_high_field;
    CaloCellPackerUtils::Bitfield m_egain_tile_field;
 
    CaloCellPackerUtils::Bitfield m_tile_qual1_field;
    CaloCellPackerUtils::Bitfield m_tile_qual2_field;
 
    // Some errors are flagged by setting all bits on; the resulting packed
    // values are stored in @c m_lar_dummy and @c m_tile_dummy.
    // These are, however, still valid encodings.  If we would legitimately
    // pack a value that gives the dummy word, we replace it with @c subst,
    // which has the low bit of the energy cleared.  This effectively reduces
    // the range on the low side slightly.
    CaloCompactCell::value_type m_lar_dummy;
    CaloCompactCell::value_type m_lar_dummy_subst;
    CaloCompactCell::value_type m_tile_dummy;
    CaloCompactCell::value_type m_tile_dummy_subst;
  };
 
 
  void init_header (header& header, int version) const;
 
 
  void clear_header (header& header) const;
 
 
  void init_derived (pars500& pars) const;
 
 
  //==========================================================================
 
 
  void pack_time (float time,
                  CaloCompactCellContainer::compact_output_iterator& it,
                  const pars500& pars) const;
 
 
  void pack_lar (const CaloCell* cell,
                 CaloCell_ID::SUBCALO subcalo,
                 CaloCompactCellContainer::compact_output_iterator& it,
                 const pars500& pars) const;
 
 
  void pack_tile (const TileCell* cell,
                  CaloCompactCellContainer::compact_output_iterator& it,
                  const pars500& pars) const;
 
 
  void finish_seq (unsigned int hash,
                   unsigned int nseq,
                   CaloCompactCellContainer::compact_output_iterator& it,
                   CaloCell_ID::SUBCALO subcalo,
                   pars500& pars) const;
 
 
  void write_header (const header& header,
                     CaloCompactCellContainer& packed) const;
 
 
  //==========================================================================
 
 
  double unpack_time (CaloCompactCellContainer::compact_input_iterator& it,
                      const pars500& pars) const;
 
 
  CaloCell* unpack_lar (CaloCompactCellContainer::compact_input_iterator& it,
                        CaloCell_ID::SUBCALO subcalo,
                        LArCell* cell,
                        const pars500& pars,
                        uint16_t provenance) const;
 
 
  TileCell unpack_tile (CaloCompactCellContainer::compact_input_iterator& it,
                        const CaloDetDescrElement* dde,
                        const pars500& pars,
                        uint16_t provenance) const;
 
  friend class CaloCellPacker_400_500_test;
};
 
 
#endif // not CALOCELLPACKER_400_500_H