Trigger/TrigEvent/TrigCaloEvent/TrigCaloEvent/TrigCaloCluster.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGCALOCLUSTER_H
#define TRIGCALOCLUSTER_H
 
 
/*******************************************************
 
NAME:       TrigCaloCluster.h
PACKAGE:    Trigger/TrigEvent/TrigCaloEvent
AUTHORS:    Denis O. Damazio, Carlos Osuna, Xin Wu
 
PURPOSE:    Keep the important output variables
        from the Calorimeter LVL2 Trigger.
        Optionally seed ID Trigger and EF.
        Variables here should be RAW variables
        not corrected.
KNOWTOINHERIT:  TrigEmCluster, TrigTauCluster,
        TrigJetCluster
DATE:       October 17th, 2005
 
******************************************************/
 
// for printing out
#include <iostream>
#include "GaudiKernel/MsgStream.h"
// t have quantities per sample
#include "CaloGeoHelpers/CaloSampling.h"
// CLID for persistency
#include "AthenaKernel/CLASS_DEF.h"
#include "CxxUtils/copy_bounded.h"
#include <algorithm>
 
const int MAXSIZE = CaloSampling::CaloSample::Unknown;

class TrigCaloCluster {
 
public:
    TrigCaloCluster (float energy = 0.0, float eta = -10.0,
        float phi = -10.0, long roi_word = 0);
    ~TrigCaloCluster ();
    TrigCaloCluster ( const TrigCaloCluster* trigcalocluster );

    void print ( void ) const;
    void print ( MsgStream& log) const;
 
    // set methods
    inline void setRawEnergy( float energy  )
            { m_rawEnergy = energy;      };
        template <class ITERATOR>
        void setRawEnergies (ITERATOR beg, ITERATOR end)
        {
          auto out = CxxUtils::copy_bounded (beg, end,
                                             std::begin(m_rawEnergyS),
                                             std::end(m_rawEnergyS));
          std::fill (out, std::end(m_rawEnergyS), 0);
        }

    inline void setRawEt( float et          )
            { m_rawEt = et;              };

    inline void setRawEnergy( CaloSampling::CaloSample sample,
            float energy )
            { m_rawEnergyS[sample] = energy; };

    inline void setRawEta   ( float eta     )
            { m_rawEta    = eta;         };

    inline void setRawPhi   ( float phi     )
            { m_rawPhi    = phi;         };

    inline void setRoIword  ( long roiword   )
            { m_roiWord   = roiword;     };

    inline void setNCells   ( int ncells     )
            { m_numberUsedCells = ncells;};

    inline void setquality  ( unsigned int quality )
            { m_quality   = quality;     };
    
    // get methods
    inline float rawEnergy( ) const
            { return m_rawEnergy       ;};
        template <class ITERATOR>
        void rawEnergies (ITERATOR beg, ITERATOR end) const
        {
          auto out = CxxUtils::copy_bounded (std::begin(m_rawEnergyS),
                                             std::end(m_rawEnergyS),
                                             beg, end);
          std::fill (out, end, 0);
        }

    inline float rawEt    ( ) const
            { return m_rawEt           ;};

    inline float rawEnergy( CaloSampling::CaloSample sample ) const
            { return m_rawEnergyS[sample]; };

    inline float rawEta   ( ) const
            { return m_rawEta          ;};

    inline float rawPhi   ( ) const
            { return m_rawPhi          ;};

    inline long  RoIword  ( ) const
            { return m_roiWord         ;};

    inline int   nCells   ( ) const
            { return m_numberUsedCells ;};

    inline unsigned int quality  ( ) const
            { return m_quality         ;};
 
    // internal variables must be protected to be
    // modified in daughter classes like TrigEM/Tau Clusters.
protected:
    float m_rawEnergy;
    float m_rawEt;
    float m_rawEnergyS[MAXSIZE];
    float m_rawEta;
    float m_rawPhi;
    long  m_roiWord;
    int   m_numberUsedCells;
    unsigned int m_quality;
 
};
 
// stream output
std::string str( const TrigCaloCluster& d );
MsgStream& operator<< ( MsgStream& m, const TrigCaloCluster& d );
 
// comparison
bool operator== (const TrigCaloCluster& a, const TrigCaloCluster& b);
inline bool operator!= ( const TrigCaloCluster& a,
    const TrigCaloCluster& b ) { return !(a==b); }
 
void diff( const TrigCaloCluster& clus1, const TrigCaloCluster& clus2,
           std::map< std::string, double >& varChange );
 
CLASS_DEF ( TrigCaloCluster, 220079886, 1)
 
#endif