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/interface/L1GctUnsignedInt.h"
#include "L1Trigger/GlobalCaloTrigger/interface/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_*/