l1t::Stage1Layer2TauAlgorithmImpPP Class Reference

#include <Stage1Layer2TauAlgorithmImp.h>

Inheritance diagram for l1t::Stage1Layer2TauAlgorithmImpPP:

Public Member Functions
void	processEvent (const std::vector< l1t::CaloEmCand > &EMCands, const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::Tau > *isoTaus, std::vector< l1t::Tau > *taus) override
	Stage1Layer2TauAlgorithmImpPP (CaloParamsHelper const *params)
	~Stage1Layer2TauAlgorithmImpPP () override=default
Public Member Functions inherited from l1t::Stage1Layer2TauAlgorithm
virtual	~Stage1Layer2TauAlgorithm ()

Private Member Functions
int	AssociatedJetPt (int ieta, int iphi, const std::vector< l1t::Jet > *jets) const
string	findNESW (int ieta, int iphi, int neta, int nphi) const
unsigned	isoLutIndex (unsigned int tauPt, unsigned int jetPt) const
double	JetIsolation (int et, int ieta, int iphi, const std::vector< l1t::Jet > &jets) const

Private Attributes
CaloParamsHelper const *const	params_

Additional Inherited Members
Public Attributes inherited from l1t::Stage1Layer2TauAlgorithm
std::vector< double >	regionPUSParams
std::string	regionPUSType

Detailed Description

Definition at line 30 of file Stage1Layer2TauAlgorithmImp.h.

Constructor & Destructor Documentation

Stage1Layer2TauAlgorithmImpPP::Stage1Layer2TauAlgorithmImpPP

(

CaloParamsHelper const *

params

)

Definition at line 24 of file Stage1Layer2TauAlgorithmImpPP.cc.

                                                                                           : params_(params)
{
}

l1t::Stage1Layer2TauAlgorithmImpPP::~Stage1Layer2TauAlgorithmImpPP ( )

overridedefault

Member Function Documentation

int l1t::Stage1Layer2TauAlgorithmImpPP::AssociatedJetPt ( int  ieta, int  iphi, const std::vector< l1t::Jet > *  jets  ) const

private

Definition at line 227 of file Stage1Layer2TauAlgorithmImpPP.cc.

References reco::btau::jetEta, reco::btau::jetPhi, and EnergyCorrector::pt.

Referenced by processEvent().

                                                                         {

  int pt = -1;


  for(JetBxCollection::const_iterator itJet = jets->begin();
      itJet != jets->end(); ++itJet){

    int jetEta = itJet->hwEta();
    int jetPhi = itJet->hwPhi();
    if ((jetEta == ieta) && (jetPhi == iphi)){
      pt = itJet->hwPt();
      break;
    }
  }

  // set output
  return pt;
}

string l1t::Stage1Layer2TauAlgorithmImpPP::findNESW ( int  ieta, int  iphi, int  neta, int  nphi  ) const

private

Definition at line 198 of file Stage1Layer2TauAlgorithmImpPP.cc.

References funct::abs(), spr::deltaEta, hiPixelPairStep_cff::deltaPhi, and L1CaloRegionDetId::N_PHI.

Referenced by processEvent().

                                                                                              {

  int deltaPhi = iphi - nphi;
  if (std::abs(deltaPhi) == L1CaloRegionDetId::N_PHI-1)
    deltaPhi = -deltaPhi/std::abs(deltaPhi); //18 regions in phi

  int deltaEta = ieta - neta;

  if ((std::abs(deltaPhi) +  std::abs(deltaEta)) < 2) {
    if (deltaEta==-1) {
      return "isEast";
    }
    else if (deltaEta==0) {
      if (deltaPhi==-1) {
    return "isNorth";
      }
      if (deltaPhi==1) {
    return "isSouth";
      }
    }
    else {
      return "isWest";
    }
  }

  return "999";

}

unsigned l1t::Stage1Layer2TauAlgorithmImpPP::isoLutIndex ( unsigned int  tauPt, unsigned int  jetPt  ) const

private

Definition at line 248 of file Stage1Layer2TauAlgorithmImpPP.cc.

References funct::pow().

Referenced by processEvent().

{
  //const unsigned int nbitsTau=9;  // number of bits used for et in LUT file (needed for left shift operation)
  //const unsigned int nbitsJet=9;

  const unsigned int nbitsTau=8;  // number of bits used for et in LUT file (needed for left shift operation)
  const unsigned int nbitsJet=8;

  const unsigned int maxJet = pow(2,nbitsJet)-1;
  const unsigned int maxTau = pow(2,nbitsTau)-1;

  if (nbitsTau < 9)
  {
    if (nbitsTau == 6)
      {
      tauPt=tauPt>>3;
      }
    else if (nbitsTau == 7)
      {
      tauPt=tauPt>>2;
      }
    else if (nbitsTau == 8)
      {
    tauPt=tauPt>>1;
      }
  }

  if (nbitsJet < 9)// no need to do shift if nbits>=9
  {
    if (nbitsJet == 6)
      {
      jetPt=jetPt>>3;
      }
    else if (nbitsJet == 7)
      {
      jetPt=jetPt>>2;
      }
    else if (nbitsJet == 8)
      {
    jetPt=jetPt>>1;
      }
  }

  if (jetPt>maxJet) jetPt=maxJet;
  if (tauPt>maxTau) tauPt=maxTau;

  unsigned int address= (jetPt << nbitsTau) + tauPt;
  return address;
}

double l1t::Stage1Layer2TauAlgorithmImpPP::JetIsolation ( int  et, int  ieta, int  iphi, const std::vector< l1t::Jet > &  jets  ) const

private

Definition at line 179 of file Stage1Layer2TauAlgorithmImpPP.cc.

References stringResolutionProvider_cfi::et, and metsig::jet.

Referenced by processEvent().

                                                                  {

  for(JetBxCollection::const_iterator jet = jets.begin();
      jet != jets.end(); jet++) {

    if (ieta==jet->hwEta() && iphi==jet->hwPhi()){

      double isolation = (double) (jet->hwPt() - et);
      return isolation/et;
    }
  }

  // set output
  return 999.;
}

void l1t::Stage1Layer2TauAlgorithmImpPP::processEvent ( const std::vector< l1t::CaloEmCand > &  EMCands, const std::vector< l1t::CaloRegion > &  regions, std::vector< l1t::Tau > *  isoTaus, std::vector< l1t::Tau > *  taus  )

overridevirtual

Implements l1t::Stage1Layer2TauAlgorithm.

Definition at line 30 of file Stage1Layer2TauAlgorithmImpPP.cc.

References funct::abs(), AssociatedJetPt(), l1t::LUT::data(), spr::deltaEta, hiPixelPairStep_cff::deltaPhi, findNESW(), isoLutIndex(), l1t::CaloParamsHelper::isoTauEtaMax(), l1t::CaloParamsHelper::isoTauEtaMin(), JetIsolation(), l1t::CaloParamsHelper::jetSeedThreshold(), l1t::LUT::maxSize(), L1CaloRegionDetId::N_PHI, params_, jets_cff::quality, l1t::RegionCorrection(), l1t::SortTaus(), l1t::CaloParamsHelper::tauIsolationLUT(), l1t::CaloParamsHelper::tauMaxJetIsolationA(), l1t::CaloParamsHelper::tauMaxJetIsolationB(), l1t::CaloParamsHelper::tauMaxPtTauVeto(), l1t::CaloParamsHelper::tauMinPtJetIsolationB(), l1t::CaloParamsHelper::tauNeighbourThreshold(), l1t::CaloParamsHelper::tauSeedThreshold(), l1t::TauToGtEtaScales(), l1t::TauToGtPtScales(), l1t::CaloParamsHelper::towerLsbSum(), and l1t::TwelveByTwelveFinder().

                                                        {

  double towerLsb = params_->towerLsbSum();

  int tauSeedThreshold= floor( params_->tauSeedThreshold()/towerLsb + 0.5); // convert GeV to HW units
  int tauNeighbourThreshold= floor( params_->tauNeighbourThreshold()/towerLsb + 0.5); // convert GeV to HW units
  int jetSeedThreshold= floor( params_->jetSeedThreshold()/towerLsb + 0.5); // convert GeV to HW units
  int tauMaxPtTauVeto = floor( params_->tauMaxPtTauVeto()/towerLsb + 0.5);
  int tauMinPtJetIsolationB = floor( params_->tauMinPtJetIsolationB()/towerLsb + 0.5);
  int isoTauEtaMin = params_->isoTauEtaMin();
  int isoTauEtaMax = params_->isoTauEtaMax();
  double tauMaxJetIsolationB = params_->tauMaxJetIsolationB();
  double tauMaxJetIsolationA = params_->tauMaxJetIsolationA();

  std::vector<l1t::CaloRegion> subRegions;


  //Region Correction will return uncorrected subregions if
  //regionPUSType is set to None in the config
  RegionCorrection(regions, &subRegions, params_);



  // ----- need to cluster jets in order to compute jet isolation ----
  std::vector<l1t::Jet> unCorrJets;
  //slidingWindowJetFinder(jetSeedThreshold, subRegions, unCorrJets);
  TwelveByTwelveFinder(jetSeedThreshold, &subRegions, &unCorrJets);

  std::vector<l1t::Tau> preGtTaus;
  std::vector<l1t::Tau> preSortTaus;
  std::vector<l1t::Tau> sortedTaus;
  std::vector<l1t::Tau> preGtIsoTaus;
  std::vector<l1t::Tau> preSortIsoTaus;
  std::vector<l1t::Tau> sortedIsoTaus;

  for(CaloRegionBxCollection::const_iterator region = subRegions.begin();
      region != subRegions.end(); region++) {

    int regionEt = region->hwPt();
    if(regionEt < tauSeedThreshold) continue;

    int regionEta = region->hwEta();
    if(regionEta < 4 || regionEta > 17)
      continue; // Taus cannot come from HF
    int regionPhi = region->hwPhi();

    //int associatedSecondRegionEt =
    //  AssociatedSecondRegionEt(region->hwEta(), region->hwPhi(),
    //                 *subRegions);

    int tauEt=regionEt;
    int isoFlag=0;  // is 1 if it passes the relative jet iso requirement
    int quality = 1;  //doesn't really mean anything and isn't used

    int highestNeighborEt=0;
    int highestNeighborEta=999;
    int highestNeighborPhi=999;
    int highestNeighborTauVeto=999;

    //Find neighbor with highest Et
    for(CaloRegionBxCollection::const_iterator neighbor = subRegions.begin();
    neighbor != subRegions.end(); neighbor++) {

      int neighborPhi = neighbor->hwPhi();
      int neighborEta = neighbor->hwEta();
      if(neighborEta < 4 || neighborEta > 17)
    continue; // Taus cannot come from HF

      int deltaPhi = regionPhi - neighborPhi;
      if (std::abs(deltaPhi) == L1CaloRegionDetId::N_PHI-1)
    deltaPhi = -deltaPhi/std::abs(deltaPhi); //18 regions in phi

      deltaPhi = std::abs(deltaPhi);
      int deltaEta = std::abs(regionEta - neighborEta);

      if (deltaPhi + deltaEta > 0 && deltaPhi + deltaEta < 2) {  //nondiagonal neighbors
    if (neighbor->hwPt() > highestNeighborEt) {
      highestNeighborEt = neighbor->hwPt();
      highestNeighborEta = neighbor->hwEta();
      highestNeighborPhi = neighbor->hwPhi();
      int neighborTauVeto = neighbor->hwQual() & 0x1; // tauVeto should be the first bit of quality integer
      highestNeighborTauVeto = neighborTauVeto;
    }
      }
    }


    string NESW = findNESW(regionEta, regionPhi, highestNeighborEta, highestNeighborPhi);

    if((tauEt > highestNeighborEt && (NESW=="isEast" || NESW=="isNorth"))
       || (tauEt >= highestNeighborEt && (NESW=="isSouth" || NESW=="isWest"))
       || highestNeighborEt == 0 ) {

      if (highestNeighborEt >= tauNeighbourThreshold) tauEt += highestNeighborEt;

      int regionTauVeto = region->hwQual() & 0x1;  // tauVeto should be the first bit of quality integer

      // compute relative jet isolation
      if (region->hwEta() >= isoTauEtaMin && region->hwEta() <= isoTauEtaMax ){
    if ((highestNeighborTauVeto == 0 && regionTauVeto == 0) || tauEt > tauMaxPtTauVeto) {
      bool useIsolLut=true;
      if (useIsolLut){
        int jetEt=AssociatedJetPt(region->hwEta(), region->hwPhi(),&unCorrJets);
        if (jetEt>0){
          unsigned int MAX_LUT_ADDRESS = params_->tauIsolationLUT()->maxSize()-1;
          unsigned int lutAddress = isoLutIndex(tauEt,jetEt);
          if (tauEt >0){
        if (lutAddress > MAX_LUT_ADDRESS) lutAddress = MAX_LUT_ADDRESS;
        isoFlag= params_->tauIsolationLUT()->data(lutAddress);
          }
        }else{ // no associated jet
          isoFlag=1;
        }
      }else{
        double jetIsolation = JetIsolation(tauEt, region->hwEta(), region->hwPhi(), unCorrJets);
        if (jetIsolation < tauMaxJetIsolationA || (tauEt >= tauMinPtJetIsolationB && jetIsolation < tauMaxJetIsolationB)
        || (std::abs(jetIsolation - 999.) < 0.1) ) isoFlag=1;
      }
    }
      }


      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > tauLorentz(0,0,0,0);

      l1t::Tau theTau(*&tauLorentz, tauEt, region->hwEta(), region->hwPhi(), quality, isoFlag);

      preGtTaus.push_back(theTau);
      if(isoFlag)
    preGtIsoTaus.push_back(theTau);
    }
  }
  TauToGtPtScales(params_, &preGtTaus, &preSortTaus);
  TauToGtPtScales(params_, &preGtIsoTaus, &preSortIsoTaus);

  SortTaus(&preSortTaus, &sortedTaus);
  SortTaus(&preSortIsoTaus, &sortedIsoTaus);

  TauToGtEtaScales(params_, &sortedTaus, taus);
  TauToGtEtaScales(params_, &sortedIsoTaus, isoTaus);
}

Member Data Documentation

CaloParamsHelper const* const l1t::Stage1Layer2TauAlgorithmImpPP::params_

private

Definition at line 41 of file Stage1Layer2TauAlgorithmImp.h.

Referenced by processEvent().