/data/refman/pasoursint/CMSSW_4_4_5_patch3/src/L1Trigger/GlobalCaloTrigger/interface/L1GctGlobalEnergyAlgos.h

Go to the documentation of this file.

#ifndef L1GCTGLOBALENERGYALGOS_H_
#define L1GCTGLOBALENERGYALGOS_H_

#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtTotal.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtHad.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctEtMiss.h"

#include "L1Trigger/GlobalCaloTrigger/interface/L1GctProcessor.h"
#include "L1Trigger/GlobalCaloTrigger/interface/L1GctMet.h"


#include <vector>

class L1GctWheelEnergyFpga;
class L1GctWheelJetFpga;
class L1GctGlobalHfSumAlgos;

class L1GctGlobalEnergyAlgos : public L1GctProcessor
{
public:
  
        typedef L1GctUnsignedInt< L1GctEtTotal::kEtTotalNBits   > etTotalType;
        typedef L1GctUnsignedInt<   L1GctEtHad::kEtHadNBits     > etHadType;
        typedef L1GctMet::etMissType     etMissType;
        typedef L1GctMet::etMissPhiType  etMissPhiType;
        typedef L1GctMet::etmiss_vec     etmiss_vec;
        typedef L1GctWheelEnergyFpga::etComponentType etComponentType;

        enum maxValues {
          etTotalMaxValue = L1GctEtTotal::kEtTotalMaxValue,
          etHadMaxValue   =   L1GctEtHad::kEtHadMaxValue,
          etMissMaxValue  =  L1GctEtMiss::kEtMissMaxValue
        };

         L1GctGlobalEnergyAlgos(std::vector<L1GctWheelEnergyFpga*> WheelFpga,
                               std::vector<L1GctWheelJetFpga*> WheelJetFpga);
        ~L1GctGlobalEnergyAlgos();

        friend std::ostream& operator << (std::ostream& os, const L1GctGlobalEnergyAlgos& fpga);

        void reset();

        virtual void fetchInput();

        virtual void process();

        void setBxRange(const int firstBx, const int numberOfBx);

        void setNextBx(const int bx);

        void setInputWheelEx(unsigned wheel, int energy, bool overflow);
        void setInputWheelEy(unsigned wheel, int energy, bool overflow);
        void setInputWheelEt(unsigned wheel, unsigned energy, bool overflow);
        void setInputWheelHt(unsigned wheel, unsigned energy, bool overflow);
        void setInputWheelHx(unsigned wheel, unsigned energy, bool overflow);
        void setInputWheelHy(unsigned wheel, unsigned energy, bool overflow);

        void setInputWheelJc(unsigned wheel, unsigned jcnum, unsigned count);

        L1GctWheelEnergyFpga* getPlusWheelFpga() const { return m_plusWheelFpga; }
        L1GctWheelEnergyFpga* getMinusWheelFpga() const { return m_minusWheelFpga; }
        L1GctWheelJetFpga* getPlusWheelJetFpga() const { return m_plusWheelJetFpga; }
        L1GctWheelJetFpga* getMinusWheelJetFpga() const { return m_minusWheelJetFpga; }
        L1GctGlobalHfSumAlgos* getHfSumProcessor() const { return m_hfSumProcessor; }

       inline std::vector< etComponentType > getInputExValPlusWheel() const { return m_exValPlusPipe.contents; }
       inline std::vector< etComponentType > getInputEyValPlusWheel() const { return m_eyValPlusPipe.contents; }
       inline std::vector< etComponentType > getInputExVlMinusWheel() const { return m_exVlMinusPipe.contents; }
       inline std::vector< etComponentType > getInputEyVlMinusWheel() const { return m_eyVlMinusPipe.contents; }
        inline std::vector< etTotalType > getInputEtValPlusWheel() const { return m_etValPlusPipe.contents; }
        inline std::vector< etHadType   > getInputHtValPlusWheel() const { return m_htValPlusPipe.contents; }
        inline std::vector< etComponentType > getInputHxValPlusWheel() const { return m_hxValPlusPipe.contents; }
        inline std::vector< etComponentType > getInputHyValPlusWheel() const { return m_hyValPlusPipe.contents; }
        inline std::vector< etTotalType > getInputEtVlMinusWheel() const { return m_etVlMinusPipe.contents; }
        inline std::vector< etHadType   > getInputHtVlMinusWheel() const { return m_htVlMinusPipe.contents; }
        inline std::vector< etComponentType > getInputHxVlMinusWheel() const { return m_hxVlMinusPipe.contents; }
        inline std::vector< etComponentType > getInputHyVlMinusWheel() const { return m_hyVlMinusPipe.contents; }

        inline std::vector< etMissType >    getEtMissColl()    const { return m_outputEtMiss.contents; }
        inline std::vector< etMissPhiType > getEtMissPhiColl() const { return m_outputEtMissPhi.contents; }
        inline std::vector< etTotalType >   getEtSumColl()     const { return m_outputEtSum.contents; }
        inline std::vector< etHadType >     getEtHadColl()     const { return m_outputEtHad.contents; }
        inline std::vector< etMissType >    getHtMissColl()    const { return m_outputHtMiss.contents; }
        inline std::vector< etMissPhiType > getHtMissPhiColl() const { return m_outputHtMissPhi.contents; }

        void setJetFinderParams(const L1GctJetFinderParams* const jfpars);
        void setHtMissScale(const L1CaloEtScale* const scale);

        // get the missing Ht LUT (used by L1GctPrintLuts)
        const L1GctHtMissLut* getHtMissLut() const { return m_mhtComponents.getHtMissLut(); }

        bool setupOk() const;
  
 protected:
        virtual void resetProcessor();
        virtual void resetPipelines();

        virtual void setupObjects() {}
        
 private:
        // Here are the algorithm types we get our inputs from
        L1GctWheelEnergyFpga* m_plusWheelFpga;
        L1GctWheelEnergyFpga* m_minusWheelFpga;
        L1GctWheelJetFpga* m_plusWheelJetFpga;
        L1GctWheelJetFpga* m_minusWheelJetFpga;

        // Here's the class that does the Hf sums
        L1GctGlobalHfSumAlgos* m_hfSumProcessor;

        // Missing Et and missing Ht
        L1GctMet m_metComponents;
        L1GctMet m_mhtComponents;

        // input data
        etComponentType m_exValPlusWheel;
        etComponentType m_eyValPlusWheel;
        etTotalType m_etValPlusWheel;
        etHadType   m_htValPlusWheel;
        etComponentType m_hxValPlusWheel;
        etComponentType m_hyValPlusWheel;

        etComponentType m_exVlMinusWheel;
        etComponentType m_eyVlMinusWheel;
        etTotalType m_etVlMinusWheel;
        etHadType   m_htVlMinusWheel;
        etComponentType m_hxVlMinusWheel;
        etComponentType m_hyVlMinusWheel;

        // stored copies of input data
        Pipeline< etComponentType > m_exValPlusPipe;
        Pipeline< etComponentType > m_eyValPlusPipe;
        Pipeline< etTotalType > m_etValPlusPipe;
        Pipeline< etHadType >   m_htValPlusPipe;
        Pipeline< etComponentType > m_hxValPlusPipe;
        Pipeline< etComponentType > m_hyValPlusPipe;

        Pipeline< etComponentType > m_exVlMinusPipe;
        Pipeline< etComponentType > m_eyVlMinusPipe;
        Pipeline< etTotalType > m_etVlMinusPipe;
        Pipeline< etHadType >   m_htVlMinusPipe;
        Pipeline< etComponentType > m_hxVlMinusPipe;
        Pipeline< etComponentType > m_hyVlMinusPipe;

        // output data
        Pipeline<etMissType>    m_outputEtMiss;
        Pipeline<etMissPhiType> m_outputEtMissPhi;
        Pipeline<etTotalType>   m_outputEtSum;
        Pipeline<etHadType>     m_outputEtHad;
        Pipeline<etMissType>    m_outputHtMiss;
        Pipeline<etMissPhiType> m_outputHtMissPhi;

        bool m_setupOk;

};

std::ostream& operator << (std::ostream& os, const L1GctGlobalEnergyAlgos& fpga);

#endif /*L1GCTGLOBALENERGYALGOS_H_*/