L1GctJetFinderBase.h

Go to the documentation of this file.

#ifndef L1GCTJETFINDERBASE_H_
#define L1GCTJETFINDERBASE_H_
 
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctJetCand.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctInternEtSum.h"
#include "DataFormats/L1GlobalCaloTrigger/interface/L1GctInternHtMiss.h"
 
#include "L1Trigger/GlobalCaloTrigger/interface/L1GctProcessor.h"
#include "L1Trigger/GlobalCaloTrigger/interface/L1GctRegion.h"
#include "L1Trigger/GlobalCaloTrigger/interface/L1GctJet.h"
 
#include "L1Trigger/GlobalCaloTrigger/src/L1GctUnsignedInt.h"
#include "L1Trigger/GlobalCaloTrigger/src/L1GctJetCount.h"
 
#include <vector>
 
class L1GctInternJetData;
class L1GctJetFinderParams;
class L1GctJetEtCalibrationLut;
class L1GctChannelMask;
class L1CaloRegion;
 
/*
 * \author Jim Brooke & Greg Heath
 * \date June 2006
 */
 
class L1GctJetFinderBase : public L1GctProcessor {
public:
  //Typedefs
  typedef unsigned long int ULong;
  typedef unsigned short int UShort;
  typedef std::vector<L1GctRegion> RegionsVector;
  typedef std::vector<L1GctJet> RawJetVector;
  typedef std::vector<L1GctJetCand> JetVector;
  typedef Pipeline<L1GctJet> RawJetPipeline;
  typedef L1GctUnsignedInt<L1GctInternEtSum::kTotEtOrHtNBits> etTotalType;
  typedef L1GctUnsignedInt<L1GctInternEtSum::kTotEtOrHtNBits> etHadType;
  typedef L1GctTwosComplement<L1GctInternEtSum::kJetMissEtNBits> etCompInternJfType;
  typedef L1GctTwosComplement<L1GctInternHtMiss::kJetMissHtNBits> htCompInternJfType;
 
  enum maxValues {
    etTotalMaxValue = L1GctInternEtSum::kTotEtOrHtMaxValue,
    htTotalMaxValue = L1GctInternEtSum::kTotEtOrHtMaxValue
  };
 
  // For HF-based triggers we sum the Et in the two "inner" (large eta) rings;
  // and count towers over threshold based on the "fineGrain" bit from the RCT.
  // Define a data type to transfer the result of all calculations.
  // The results are defined as L1GctJetCount types since they don't have
  // a separate overFlow bit. An overflow condition gives value=max.
 
  struct hfTowerSumsType {
    enum numberOfBits { kHfEtSumBits = 8, kHfCountBits = 5 };
 
    L1GctJetCount<kHfEtSumBits> etSum0;
    L1GctJetCount<kHfEtSumBits> etSum1;
    L1GctJetCount<kHfCountBits> nOverThreshold0;
    L1GctJetCount<kHfCountBits> nOverThreshold1;
 
    // Define some constructors and an addition operator for our data type
    hfTowerSumsType() : etSum0(0), etSum1(0), nOverThreshold0(0), nOverThreshold1(0) {}
    hfTowerSumsType(unsigned e0, unsigned e1, unsigned n0, unsigned n1)
        : etSum0(e0), etSum1(e1), nOverThreshold0(n0), nOverThreshold1(n1) {}
    hfTowerSumsType(L1GctJetCount<kHfEtSumBits> e0,
                    L1GctJetCount<kHfEtSumBits> e1,
                    L1GctJetCount<kHfCountBits> n0,
                    L1GctJetCount<kHfCountBits> n1)
        : etSum0(e0), etSum1(e1), nOverThreshold0(n0), nOverThreshold1(n1) {}
 
    void reset() {
      etSum0.reset();
      etSum1.reset();
      nOverThreshold0.reset();
      nOverThreshold1.reset();
    }
 
    hfTowerSumsType operator+(const hfTowerSumsType& rhs) const {
      hfTowerSumsType temp((this->etSum0 + rhs.etSum0),
                           (this->etSum1 + rhs.etSum1),
                           (this->nOverThreshold0 + rhs.nOverThreshold0),
                           (this->nOverThreshold1 + rhs.nOverThreshold1));
      return temp;
    }
  };
 
  typedef L1GctJet::lutPtr lutPtr;
  typedef std::vector<lutPtr> lutPtrVector;
 
  //Statics
  static const unsigned int MAX_JETS_OUT;    
  static const unsigned int COL_OFFSET;      
  static const unsigned int N_JF_PER_WHEEL;  
  static const unsigned int
      N_EXTRA_REGIONS_ETA00;  
 
  L1GctJetFinderBase(int id);
 
  ~L1GctJetFinderBase() override;
 
  void setNeighbourJetFinders(const std::vector<L1GctJetFinderBase*>& neighbours);
 
  void setJetFinderParams(const L1GctJetFinderParams* jfpars);
 
  void setJetEtCalibrationLuts(const lutPtrVector& jfluts);
 
  void setEnergySumMasks(const L1GctChannelMask* chmask);
 
  void setupTauAlgo(const bool useImprovedAlgo, const bool ignoreVetoBitsForIsolation) {
    m_useImprovedTauAlgo = useImprovedAlgo;
    m_ignoreTauVetoBitsForIsolation = ignoreVetoBitsForIsolation;
  }
 
  bool setupOk() const {
    return m_idInRange && m_gotNeighbourPointers && m_gotJetFinderParams && m_gotJetEtCalLuts && m_gotChannelMask;
  }
 
  friend std::ostream& operator<<(std::ostream& os, const L1GctJetFinderBase& algo);
 
  void fetchInput() override = 0;
 
  void process() override = 0;
 
  void setInputRegion(const L1CaloRegion& region);
 
  RegionsVector getInputRegions() const { return m_inputRegions; }
 
  RegionsVector getSentProtoJets() const { return m_sentProtoJets; }
 
  RegionsVector getRcvdProtoJets() const { return m_rcvdProtoJets; }
 
  RegionsVector getKeptProtoJets() const { return m_keptProtoJets; }
 
  RawJetVector getRawJets() const { return m_outputJetsPipe.contents; }
 
  std::vector<L1GctInternJetData> getInternalJets() const;
 
  std::vector<L1GctInternEtSum> getInternalEtSums() const;
  std::vector<L1GctInternHtMiss> getInternalHtMiss() const;
 
  const lutPtrVector getJetEtCalLuts() const { return m_jetEtCalLuts; }
 
  // The hardware output quantities
  JetVector getJets() const { return m_sortedJets; }  
  // The hardware output quantities - refactored
  etTotalType getEtSum() const { return m_outputEtSum; }  
  etCompInternJfType getExSum() const {
    return m_outputExSum;
  }  
  etCompInternJfType getEySum() const {
    return m_outputEySum;
  }  
  etHadType getHtSum() const { return m_outputHtSum; }  
  htCompInternJfType getHxSum() const {
    return m_outputHxSum;
  }  
  htCompInternJfType getHySum() const {
    return m_outputHySum;
  }  
 
  hfTowerSumsType getHfSums() const {
    return m_outputHfSums;
  }  
 
  // Access to threshold and cut values
  unsigned getCenJetSeed() const { return m_CenJetSeed; }
  unsigned getFwdJetSeed() const { return m_FwdJetSeed; }
  unsigned getTauJetSeed() const { return m_TauJetSeed; }
  unsigned getEtaBoundry() const { return m_EtaBoundry; }
  unsigned getTauIsolationThreshold() const { return m_tauIsolationThreshold; }
  unsigned getHttSumJetThreshold() const { return m_HttSumJetThreshold; }
  unsigned getHtmSumJetThreshold() const { return m_HtmSumJetThreshold; }
 
protected:
  void resetProcessor() override;
  void resetPipelines() override;
 
  void setupObjects() override;
 
protected:
  enum fetchType { TOP, BOT, TOPBOT };
 
  int m_id;
 
  std::vector<L1GctJetFinderBase*> m_neighbourJetFinders;
 
  bool m_idInRange;
 
  bool m_gotNeighbourPointers;
 
  bool m_gotJetFinderParams;
 
  bool m_gotJetEtCalLuts;
 
  bool m_gotChannelMask;
 
  bool m_positiveEtaWheel;
 
  unsigned m_minColThisJf;
  unsigned m_CenJetSeed;
  unsigned m_FwdJetSeed;
  unsigned m_TauJetSeed;
  unsigned m_EtaBoundry;
 
  lutPtrVector m_jetEtCalLuts;
 
  // If the following parameter is set to false, the tau identification
  // is just based on the RCT tau veto bits from the nine regions
  bool m_useImprovedTauAlgo;
 
  // If useImprovedTauAlgo is true, these two parameters affect
  // the operation of the algorithm.
 
  // We can require the tau veto bits to be off in all nine regions,
  // or just in the central region.
  bool m_ignoreTauVetoBitsForIsolation;
 
  // In the improved tau algorithm, we require no more than one tower energy to be
  // above the isolation threshold, in the eight regions surrounding the central one.
  unsigned m_tauIsolationThreshold;
 
  // Thresholds on individual jet energies used in HTT and HTM summing
  unsigned m_HttSumJetThreshold;
  unsigned m_HtmSumJetThreshold;
 
  // Masks for restricting the eta range of energy sums
  bool m_EttMask[11];
  bool m_EtmMask[11];
  bool m_HttMask[11];
  bool m_HtmMask[11];
 
  RegionsVector m_inputRegions;
 
  RegionsVector m_sentProtoJets;
  RegionsVector m_rcvdProtoJets;
  RegionsVector m_keptProtoJets;
 
  RawJetVector m_outputJets;
  JetVector m_sortedJets;
 
  etTotalType m_outputEtSum;
  etCompInternJfType m_outputExSum;
  etCompInternJfType m_outputEySum;
  etHadType m_outputHtSum;
  htCompInternJfType m_outputHxSum;
  htCompInternJfType m_outputHySum;
 
  hfTowerSumsType m_outputHfSums;
 
  //PROTECTED METHODS
  // Return the values of constants that might be changed by different jetFinders.
  // Each jetFinder must define the constants as private and copy the
  // function definitions below.
  virtual unsigned maxRegionsIn() const { return MAX_REGIONS_IN; }
  virtual unsigned centralCol0() const { return CENTRAL_COL0; }
  virtual unsigned nCols() const { return N_COLS; }
 
  void fetchProtoJetsFromNeighbour(const fetchType ft);
  void sortJets();
  void doEnergySums();
 
  etTotalType calcEtStrip(const UShort strip) const;
 
  etTotalType calcHtStrip(const UShort strip) const;
 
  void doEtSums();
 
  void doHtSums();
 
  hfTowerSumsType calcHfSums() const;
 
private:
  static const unsigned int MAX_REGIONS_IN;  
  static const unsigned int N_COLS;
  static const unsigned int CENTRAL_COL0;
 
  RawJetPipeline m_outputJetsPipe;
 
  Pipeline<etTotalType> m_outputEtSumPipe;
  Pipeline<etCompInternJfType> m_outputExSumPipe;
  Pipeline<etCompInternJfType> m_outputEySumPipe;
  Pipeline<etHadType> m_outputHtSumPipe;
  Pipeline<htCompInternJfType> m_outputHxSumPipe;
  Pipeline<htCompInternJfType> m_outputHySumPipe;
 
  template <int kBitsInput, int kBitsOutput>
  L1GctTwosComplement<kBitsOutput> etComponentForJetFinder(const L1GctUnsignedInt<kBitsInput>& etStrip0,
                                                           const unsigned& fact0,
                                                           const L1GctUnsignedInt<kBitsInput>& etStrip1,
                                                           const unsigned& fact1);
};
 
std::ostream& operator<<(std::ostream& os, const L1GctJetFinderBase& algo);
 
#endif /*L1GCTJETFINDERBASE_H_*/