/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODCaloEvent/xAODCaloEvent/versions/CaloCluster_v1.h

// Dear emacs, this is -*- c++ -*-
// $Id: CaloCluster_v1.h 693459 2015-09-07 12:37:02Z wlampl $
#ifndef XAODCALOEVENT_VERSIONS_CALOCLUSTER_V1_H
#define XAODCALOEVENT_VERSIONS_CALOCLUSTER_V1_H

// System include(s):
extern "C" {
#   include <stdint.h>
}
#include <bitset>

// xAOD include(s):
#include "xAODBase/IParticle.h"

//Defintion of CaloSamples (enum)
#include "CaloGeoHelpers/CaloSampling.h"

#include "xAODCaloEvent/CaloClusterBadChannelData.h"

#ifndef XAOD_ANALYSIS
#include "AthLinks/ElementLink.h"
#include "CaloEvent/CaloClusterCellLinkContainer.h"
#include "CaloEvent/CaloRecoStatus.h"
#endif // not XAOD_ANALYSIS

// Declare a dummy CaloClusterCellLink definition for standalone compilation:
#ifdef XAOD_ANALYSIS
class CaloClusterCellLink {};
typedef unsigned CaloRecoStatus;
#endif // XAOD_ANALYSIS

class CaloClusterChangeSignalState;

namespace xAOD {

   class CaloCluster_v1 : public IParticle {
     friend class ::CaloClusterChangeSignalState;

   public:

     typedef float flt_t;

     typedef CaloSampling::CaloSample CaloSample;


      enum ClusterSize {
         // electrons
         SW_55ele   = 1,
         SW_35ele   = 2,
         SW_37ele   = 3,
         // photons
         SW_55gam   = 4,
         SW_35gam   = 5,
         SW_37gam   = 6,
         // early converted photons
         SW_55Econv = 7,
         SW_35Econv = 8,
         SW_37Econv = 9,
         // soft electrons
         SW_softe   = 10,
         // topological clusters
         Topo_420   = 11,
         Topo_633   = 12,
         // transient cluster for AODCellContainer
         SW_7_11    = 13,
         CSize_Unknown = 99
      };

      enum MomentType {
         FIRST_PHI         = 101, 
         FIRST_ETA         = 102, 
         SECOND_R          = 201, 
         SECOND_LAMBDA     = 202, 

         DELTA_PHI         = 301,
         DELTA_THETA       = 302,
         DELTA_ALPHA       = 303,
         CENTER_X          = 401, 
         CENTER_Y          = 402, 
         CENTER_Z          = 403, 

         CENTER_MAG        = 404,
         CENTER_LAMBDA     = 501, 
         LATERAL           = 601, 
         LONGITUDINAL      = 602, 
         ENG_FRAC_EM       = 701, 
         ENG_FRAC_MAX      = 702, 

         ENG_FRAC_CORE     = 703,
         FIRST_ENG_DENS    = 804, 
         SECOND_ENG_DENS   = 805, 

         ISOLATION         = 806,
         ENG_BAD_CELLS     = 807,
         N_BAD_CELLS       = 808, 

         N_BAD_CELLS_CORR  = 809,
         BAD_CELLS_CORR_E  = 813,
         BADLARQ_FRAC      = 821,
         ENG_POS           = 822, 
         SIGNIFICANCE      = 823, 

         CELL_SIGNIFICANCE = 824,
         CELL_SIG_SAMPLING = 825,
         AVG_LAR_Q         = 826,
         AVG_TILE_Q        = 827,
         ENG_BAD_HV_CELLS  = 828,
         N_BAD_HV_CELLS    = 829, 
         EM_PROBABILITY    = 900, 
         HAD_WEIGHT        = 901, 
         OOC_WEIGHT        = 902, 
         DM_WEIGHT         = 903, 

         TILE_CONFIDENCE_LEVEL = 904,

     VERTEX_FRACTION = 1000, 
     NVERTEX_FRACTION = 1001, 
     ETACALOFRAME  = 1100, 
     PHICALOFRAME  = 1101, 
     ETA1CALOFRAME = 1102, 
     PHI1CALOFRAME = 1103, 
     ETA2CALOFRAME = 1104, 
     PHI2CALOFRAME = 1105, 

         ENG_CALIB_TOT     = 10001,
         ENG_CALIB_OUT_L   = 10010, 
         ENG_CALIB_OUT_M   = 10011, 
         ENG_CALIB_OUT_T   = 10012, 
         ENG_CALIB_DEAD_L  = 10020, 
         ENG_CALIB_DEAD_M  = 10021, 
         ENG_CALIB_DEAD_T  = 10022,  

         ENG_CALIB_EMB0         = 10030,
         ENG_CALIB_EME0         = 10031,
         ENG_CALIB_TILEG3       = 10032,
         ENG_CALIB_DEAD_TOT     = 10040,
         ENG_CALIB_DEAD_EMB0    = 10041,
         ENG_CALIB_DEAD_TILE0   = 10042,
         ENG_CALIB_DEAD_TILEG3  = 10043,
         ENG_CALIB_DEAD_EME0    = 10044,
         ENG_CALIB_DEAD_HEC0    = 10045,
         ENG_CALIB_DEAD_FCAL    = 10046,
         ENG_CALIB_DEAD_LEAKAGE = 10047,
         ENG_CALIB_DEAD_UNCLASS = 10048,
         ENG_CALIB_FRAC_EM      = 10051,
         ENG_CALIB_FRAC_HAD     = 10052,
         ENG_CALIB_FRAC_REST    = 10053
      };

     enum State { 
       UNKNOWN             = -1,
       UNCALIBRATED        =  0,
       CALIBRATED          =  1,
       ALTCALIBRATED       =  2,
       NSTATES             =  3
     };
     

     CaloCluster_v1();

     CaloCluster_v1(const CaloCluster_v1& other);

     virtual ~CaloCluster_v1();

     CaloCluster_v1& operator=(const xAOD::CaloCluster_v1& other);


     virtual double           pt() const;
     virtual double           eta() const;
     virtual double           phi() const;
     virtual double           m() const;
     virtual double           e() const;
     virtual double           rapidity() const;

     typedef IParticle::FourMom_t FourMom_t;

     virtual const FourMom_t& p4() const;

     const FourMom_t& p4(const State s) const;
     
     virtual Type::ObjectType type() const;

     double et() const;

  // Cint has trouble with the types of these members.
  // Just hide them from reflex for now.
     /*
#ifndef __REFLEX__
   private:
     typedef flt_t (CaloCluster_v1::*GET_VALUE)() const;
     mutable GET_VALUE m_getE;
     mutable GET_VALUE m_getEta;
     GET_VALUE m_getPhi;
     GET_VALUE m_getM;
#endif
     */
   public:

     float eSample(const CaloSample sampling) const;
     float etaSample(const CaloSample sampling) const;
     float phiSample(const CaloSample sampling) const;
   
     float energy_max(const CaloSample sampling) const;
     float etamax(const CaloSample sampling) const;
     float phimax(const CaloSample sampling) const;

     float etasize(const CaloSample sampling) const;
     float phisize(const CaloSample sampling) const;
     




     float energyBE(const unsigned layer) const;

     float etaBE(const unsigned layer) const;
     float phiBE(const unsigned layer) const;

  
     bool setEnergy(const CaloSample sampling, const float e);
     bool setEta(const CaloSample sampling, const float eta);
     bool setPhi(const CaloSample sampling, const float phi );

     bool setEmax(const CaloSample sampling, const float eMax );
     bool setEtamax(const CaloSample sampling, const float etaMax );
     bool setPhimax(const CaloSample sampling, const float phiMax );  
     bool setEtasize(const CaloSample sampling, const float etaSize );
     bool setPhisize(const CaloSample sampling, const float phiSize );  






     void insertMoment( MomentType type, double value );

     bool retrieveMoment( MomentType type, double& value ) const;

     double getMomentValue( MomentType type) const;




     void setEta0(flt_t);
     flt_t eta0() const;

     void setPhi0(flt_t);
     flt_t phi0() const;

     void setTime(flt_t);
     flt_t time() const;

     unsigned samplingPattern() const; 
     void  setSamplingPattern(const unsigned sp, const bool clearSamplingVars=false);

     void clearSamplingData();

     unsigned nSamples() const;
     
     bool hasSampling(const CaloSample s) const;


     ClusterSize clusterSize() const; 
     void  setClusterSize(const ClusterSize);

     bool inBarrel() const;
     bool inEndcap() const;


     void setE(flt_t);
     void setEta(flt_t);
     void setPhi(flt_t);
     void setM(flt_t);


     flt_t rawE() const; 
     void  setRawE(flt_t);
     flt_t rawEta() const; 
     void  setRawEta(flt_t);
     flt_t rawPhi() const; 
     void  setRawPhi(flt_t);
     flt_t rawM() const; 
     void  setRawM(flt_t);

     flt_t altE() const; 
     void  setAltE(flt_t);
     flt_t altEta() const;
     void  setAltEta(flt_t);
     flt_t altPhi() const;
     void  setAltPhi(flt_t);
     flt_t altM() const; 
     void  setAltM(flt_t);                

     flt_t calE() const;
     void  setCalE(flt_t);
     flt_t calEta() const;
     void  setCalEta(flt_t);
     flt_t calPhi() const;
     void  setCalPhi(flt_t);
     flt_t calM() const;
     void  setCalM(flt_t);
#ifndef XAOD_ANALYSIS
   private:
#endif
     bool setSignalState(const State s) const;
   public:
     State signalState() const {return m_signalState;}

     double pt(const State s) const;

     double e(const State s) const;

     double eta(const State s) const;

     double phi(const State s) const;



     unsigned int getClusterEtaSize() const;

     unsigned int getClusterPhiSize() const;

     void setBadChannelList(const CaloClusterBadChannelList& bcl); 
     const CaloClusterBadChannelList& badChannelList() const;
     

     //For debugging only...
     //std::vector<std::pair<std::string,float> > getAllMoments();

   private:
     unsigned m_samplingPattern;
     mutable FourMom_t m_p4[xAOD::CaloCluster_v1::NSTATES];
     mutable std::bitset<xAOD::CaloCluster_v1::NSTATES> m_p4Cached;

     mutable double m_pt[xAOD::CaloCluster_v1::NSTATES];
     mutable std::bitset<xAOD::CaloCluster_v1::NSTATES> m_ptCached;

     mutable State m_signalState;
     CaloClusterCellLink* m_cellLinks;

     bool m_ownCellLinks;

     CaloRecoStatus m_recoStatus;

     unsigned sampVarIdx(const CaloSample) const;

     float getSamplVarFromAcc(Accessor<std::vector<float > >& acc, 
                  const CaloSample sampling, const float errorvalue=-999) const; //FIXME find a better errorcode

     bool setSamplVarFromAcc(Accessor<std::vector<float> >& acc, 
                 const CaloSample sampling, const float value);
   public:
#ifndef XAOD_ANALYSIS

     void addCellLink(CaloClusterCellLink* CCCL) {
       if (m_ownCellLinks && m_cellLinks) {
     //Delete link if there is one
     delete m_cellLinks;
       }

       m_cellLinks=CCCL;
       m_ownCellLinks=true;
     }
     //bool createCellElemLink(const std::string& CCCL_key, const size_t index);

     bool setLink(CaloClusterCellLinkContainer* CCCL,
                  IProxyDictWithPool* sg = nullptr);

     const CaloClusterCellLink* getCellLinks() const;

     CaloClusterCellLink* getCellLinks() {
       return m_cellLinks;
     }

     bool addCell(const unsigned index, const double weight) {
       if (!m_cellLinks) return false;
       return m_cellLinks->addCell(index,weight);
     }

      bool removeCell(const CaloCell* ptr);


     size_t size() const {return getCellLinks()->size();}

     typedef CaloClusterCellLink::const_iterator const_cell_iterator; 
     //Fixme: Check ret-val of getCellLinks (might be NULL);
     const_cell_iterator cell_begin() const { 
       const CaloClusterCellLink* links=getCellLinks();
       if (!links) 
     return CaloClusterCellLink::dummyIt;
       else
     return links->begin();
     }
     const_cell_iterator cell_end() const { 
       const CaloClusterCellLink* links=getCellLinks();
       if (!links) 
     return CaloClusterCellLink::dummyIt;
       else
     return getCellLinks()->end();
     } 
     
     typedef CaloClusterCellLink::iterator cell_iterator; 
     //Fixme: Check ret-val of getCellLinks (might be NULL);
     cell_iterator cell_begin() { return getCellLinks()->begin();}
     cell_iterator cell_end() { return getCellLinks()->end();} 

     typedef const_cell_iterator const_iterator;
     typedef cell_iterator iterator;
     const_iterator begin() const { return cell_begin(); }
     const_iterator end() const { return cell_end(); }
     iterator begin() { return cell_begin(); }
     iterator end() { return cell_end(); }

     void reweightCell(cell_iterator it, const double weight) {it.reweight(weight);}
     
     CaloRecoStatus& recoStatus() {return m_recoStatus;}

     const CaloRecoStatus& recoStatus() const {return m_recoStatus;}

#endif

      void toPersistent();

   }; // class CaloCluster_v1


  inline  double CaloCluster_v1::et() const {
    if (this->m()==0) 
      return this->pt();
    else
      return this->p4().Et();
  }

  inline unsigned CaloCluster_v1::samplingPattern() const {
    return m_samplingPattern;
  }

  inline unsigned CaloCluster_v1::sampVarIdx(const CaloCluster_v1::CaloSample s) const {
    const uint32_t& pattern= m_samplingPattern;
    //std::cout << "Pattern=" << std::hex << pattern << std::dec << ", Sampling=" << s << std::endl;
    if ((pattern & (0x1U << s))==0)
      return CaloSampling::Unknown;
    else {
      if (s==0) return 0; //shifting a 32-bit int by 32 bits is undefined behavior! 
      return __builtin_popcount(pattern << (32-s)); 
      //Explanation: Need to get the number of bit (=samples) before the sampling in question
      //Shift to the left, so bits after the sampling in question fall off the 32bit integer
      //Then use gcc builtin popcount to count the numbers of 1 in the rest
      //AFAIK, this builtin is available for gcc, icc and clang (as well on ARM)
    }
  }


  inline unsigned CaloCluster_v1::nSamples() const {
    const uint32_t pattern=samplingPattern();
    return  __builtin_popcount(pattern);
  }


  inline bool CaloCluster_v1::hasSampling(const CaloSample s) const {
   const unsigned pattern=samplingPattern();
   return (pattern & (0x1U<<(uint32_t)s));
 }


  inline bool CaloCluster_v1::inBarrel() const {
       return (m_samplingPattern & CaloSampling::barrelPattern());
  }
     
  
  inline bool CaloCluster_v1::inEndcap() const {
    return (m_samplingPattern & CaloSampling::endcapPattern());
  }


  inline double CaloCluster_v1::getMomentValue( CaloCluster_v1::MomentType type) const {
    double value=-999;
    this->retrieveMoment(type,value);
    return value;
  }

} // namespace xAOD

#endif // XAODCALOEVENT_VERSIONS_CALOCLUSTER_V1_H

---