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(const std::vector<L1GctWheelEnergyFpga*>& WheelFpga,
                         const std::vector<L1GctWheelJetFpga*>& WheelJetFpga);
  ~L1GctGlobalEnergyAlgos() override;

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

  void reset();

  void fetchInput() override;

  void process() override;

  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:
  void resetProcessor() override;
  void resetPipelines() override;

  void setupObjects() override {}

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