/data/refman/pasoursint/CMSSW_5_3_9_patch3/src/L1Trigger/GlobalCaloTrigger/interface/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 <boost/cstdint.hpp> //for uint16_t
#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();
   
  void setNeighbourJetFinders(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);

  virtual void fetchInput() = 0;

  virtual void process() = 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:

  virtual void resetProcessor();
  virtual void resetPipelines();

  virtual void setupObjects();

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