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_*/