CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
FastL1GlobalAlgo Class Reference

#include <FastL1GlobalAlgo.h>

Public Member Functions

void CaloTowersDump (edm::Event const &e)
 
 FastL1GlobalAlgo (const edm::ParameterSet &)
 
void FillBitInfos ()
 
void FillEgammas (edm::Event const &)
 
void FillEgammasTP (edm::Event const &)
 
void FillJets (const edm::EventSetup &e)
 
void FillL1Regions (edm::Event const &e, const edm::EventSetup &c)
 
void FillL1RegionsTP (edm::Event const &e, const edm::EventSetup &c)
 
void FillMET ()
 
void FillMET (edm::Event const &e)
 
FastL1BitInfoCollection getBitInfos ()
 
std::vector< FastL1Region > GetCaloRegions ()
 
l1extra::L1JetParticleCollection getCenJets () const
 
l1extra::L1EmParticleCollection getEgammas () const
 
l1extra::L1JetParticleCollection getForJets () const
 
l1extra::L1EmParticleCollection getisoEgammas () const
 
l1extra::L1EtMissParticleCollection getMET () const
 
l1extra::L1JetParticleCollection getTauJets () const
 
void InitL1Regions ()
 
 ~FastL1GlobalAlgo ()
 

Private Member Functions

void addJet (int rgnId, bool taubit)
 
void checkMapping ()
 
void findJets ()
 
bool greaterEt (const reco::Candidate &a, const reco::Candidate &b)
 
double hcaletValue (const int ieta, const int compET)
 
int isEMCand (CaloTowerDetId cid, l1extra::L1EmParticle *p, const edm::Event &e)
 
bool isMaxEtRgn_Window33 (int rgnid)
 
bool isTauJet (int rgnid)
 
bool TauIsolation (int rgnid)
 

Private Attributes

FastL1BitInfoCollection m_BitInfos
 
l1extra::L1JetParticleCollection m_CenJets
 
bool m_DoBitInfo
 
l1extra::L1EmParticleCollection m_Egammas
 
l1extra::L1JetParticleCollection m_ForJets
 
bool m_GctIso
 
double m_hcaluncomp [33][256]
 
l1extra::L1EmParticleCollection m_isoEgammas
 
double m_IsolationEt
 
L1Config m_L1Config
 
l1extra::L1EtMissParticleCollection m_METs
 
std::vector< FastL1Region > m_Regions
 
FastL1RegionMap * m_RMap
 
l1extra::L1JetParticleCollection m_TauJets
 

Detailed Description

Description: Global algorithm.

Implementation: <Notes on="" implementation>="">

Definition at line 70 of file FastL1GlobalAlgo.h.

Constructor & Destructor Documentation

FastL1GlobalAlgo::FastL1GlobalAlgo ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 28 of file FastL1GlobalAlgo.cc.

References L1Config::CrystalEBThreshold, L1Config::CrystalEEThreshold, L1Config::DoEMCorr, L1Config::DoJetCorr, L1Config::EcalTPInput, L1Config::EMActiveLevel, L1Config::EmInputs, L1Config::EMLSB, L1Config::EMNoiseLevel, L1Config::EMSeedEnThreshold, L1Config::FGEBThreshold, L1Config::FGEEThreshold, edm::FileInPath::fullPath(), FastL1RegionMap::getFastL1RegionMap(), edm::ParameterSet::getParameter(), L1Config::HadActiveLevel, L1Config::HadNoiseLevel, L1Config::HcalLUT, L1Config::HcalTPInput, L1Config::hOeThreshold, i, j, L1Config::JetLSB, L1Config::JetSeedEtThreshold, m_DoBitInfo, m_GctIso, m_hcaluncomp, m_IsolationEt, m_L1Config, m_Regions, m_RMap, L1Config::MuonNoiseLevel, L1Config::noFGThreshold, L1Config::noTauVetoLevel, L1Config::QuietRegionThreshold, L1Config::TowerEBScale, L1Config::TowerEBThreshold, L1Config::TowerEEScale, L1Config::TowerEEThreshold, L1Config::TowerEMLSB, L1Config::TowerHadLSB, L1Config::TowerHBScale, L1Config::TowerHBThreshold, L1Config::TowerHEScale, L1Config::TowerHEThreshold, and L1Config::TowerInput.

29 {
30  m_RMap = FastL1RegionMap::getFastL1RegionMap();
31 
32  // Get L1 config
33  m_L1Config.DoEMCorr = iConfig.getParameter<bool>("DoEMCorr");
34  m_L1Config.DoJetCorr = iConfig.getParameter<bool>("DoJetCorr");
35  m_DoBitInfo = iConfig.getParameter<bool>("DoBitInfo");
36  m_GctIso = iConfig.getParameter<bool>("GctIso");
37  m_IsolationEt = iConfig.getParameter<double>("IsolationEt");
38 
39  // get uncompressed hcal et
40  m_L1Config.HcalLUT = iConfig.getParameter<edm::FileInPath>("HcalLUT");
41 
42  m_L1Config.EMSeedEnThreshold = iConfig.getParameter<double>("EMSeedEnThreshold");
43  m_L1Config.EMActiveLevel = iConfig.getParameter<double>("EMActiveLevel");
44  m_L1Config.HadActiveLevel = iConfig.getParameter<double>("HadActiveLevel");
45  m_L1Config.noTauVetoLevel = iConfig.getParameter<double>("noTauVetoLevel");
46  m_L1Config.hOeThreshold = iConfig.getParameter<double>("hOeThreshold");
47  m_L1Config.FGEBThreshold = iConfig.getParameter<double>("FGEBThreshold");
48  m_L1Config.FGEEThreshold = iConfig.getParameter<double>("FGEEThreshold");
49 
50  m_L1Config.MuonNoiseLevel = iConfig.getParameter<double>("MuonNoiseLevel");
51  m_L1Config.EMNoiseLevel = iConfig.getParameter<double>("EMNoiseLevel");
52  m_L1Config.HadNoiseLevel = iConfig.getParameter<double>("HadNoiseLevel");
53  m_L1Config.QuietRegionThreshold = iConfig.getParameter<double>("QuietRegionThreshold");
54  m_L1Config.JetSeedEtThreshold = iConfig.getParameter<double>("JetSeedEtThreshold");
55 
56  m_L1Config.TowerEMLSB = iConfig.getParameter<double>("TowerEMLSB");
57  m_L1Config.TowerHadLSB = iConfig.getParameter<double>("TowerHadLSB");
58  m_L1Config.EMLSB = iConfig.getParameter<double>("EMLSB");
59  m_L1Config.JetLSB = iConfig.getParameter<double>("JetLSB");
60 
61  m_L1Config.CrystalEBThreshold = iConfig.getParameter<double>("CrystalEBThreshold");
62  m_L1Config.CrystalEEThreshold = iConfig.getParameter<double>("CrystalEEThreshold");
63 
64  m_L1Config.TowerEBThreshold = iConfig.getParameter<double>("TowerEBThreshold");
65  m_L1Config.TowerEEThreshold = iConfig.getParameter<double>("TowerEEThreshold");
66  m_L1Config.TowerHBThreshold = iConfig.getParameter<double>("TowerHBThreshold");
67  m_L1Config.TowerHEThreshold = iConfig.getParameter<double>("TowerHEThreshold");
68 
69  m_L1Config.TowerEBScale = iConfig.getParameter<double>("TowerEBScale");
70  m_L1Config.TowerEEScale = iConfig.getParameter<double>("TowerEEScale");
71  m_L1Config.TowerHBScale = iConfig.getParameter<double>("TowerHBScale");
72  m_L1Config.TowerHEScale = iConfig.getParameter<double>("TowerHEScale");
73 
74  m_L1Config.noFGThreshold = iConfig.getParameter<double>("noFGThreshold");
75 
76  m_L1Config.EmInputs = iConfig.getParameter <std::vector<edm::InputTag> >("EmInputs");
77  m_L1Config.TowerInput = iConfig.getParameter<edm::InputTag>("TowerInput");
78 
79  m_L1Config.EcalTPInput = iConfig.getParameter<edm::InputTag>("EcalTPInput");
80  m_L1Config.HcalTPInput = iConfig.getParameter<edm::InputTag>("HcalTPInput");
81 
82 
83  //Load Hcal LUT file
84  std::ifstream userfile;
85  const std::string userfileName = m_L1Config.HcalLUT.fullPath();
86  userfile.open(userfileName.c_str());
87  static const int etabound = 32;
88  static const int tpgmax = 256;
89  for (int i=0; i<tpgmax; i++) {
90  for(int j = 1; j <=etabound; j++) {
91  userfile >> m_hcaluncomp[j][i];
92  }
93  }
94  userfile.close();
95 
96 
97  FastL1Region tr;
98  for (int i=0;i<396;i++)
99  m_Regions.push_back(tr);
100 
101 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
L1Config::FGEBThreshold
double FGEBThreshold
Definition: FastL1Region.h:67
L1Config::FGEEThreshold
double FGEEThreshold
Definition: FastL1Region.h:68
i
int i
Definition: DBlmapReader.cc:9
L1Config::TowerEEScale
double TowerEEScale
Definition: FastL1Region.h:86
L1Config::HadActiveLevel
double HadActiveLevel
Definition: FastL1Region.h:61
L1Config::noTauVetoLevel
double noTauVetoLevel
Definition: FastL1Region.h:65
L1Config::QuietRegionThreshold
double QuietRegionThreshold
Definition: FastL1Region.h:70
L1Config::hOeThreshold
double hOeThreshold
Definition: FastL1Region.h:66
L1Config::EmInputs
std::vector< edm::InputTag > EmInputs
Definition: FastL1Region.h:90
FastL1RegionMap::getFastL1RegionMap
static FastL1RegionMap * getFastL1RegionMap()
Definition: FastL1RegionMap.cc:33
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
L1Config::EMActiveLevel
double EMActiveLevel
Definition: FastL1Region.h:60
L1Config::TowerEBScale
double TowerEBScale
Definition: FastL1Region.h:85
L1Config::TowerHEThreshold
double TowerHEThreshold
Definition: FastL1Region.h:83
L1Config::TowerInput
edm::InputTag TowerInput
Definition: FastL1Region.h:91
L1Config::HadNoiseLevel
double HadNoiseLevel
Definition: FastL1Region.h:63
L1Config::TowerHEScale
double TowerHEScale
Definition: FastL1Region.h:88
L1Config::TowerHBScale
double TowerHBScale
Definition: FastL1Region.h:87
L1Config::TowerEMLSB
double TowerEMLSB
Definition: FastL1Region.h:75
L1Config::TowerHBThreshold
double TowerHBThreshold
Definition: FastL1Region.h:82
L1Config::CrystalEBThreshold
double CrystalEBThreshold
Definition: FastL1Region.h:72
L1Config::JetSeedEtThreshold
double JetSeedEtThreshold
Definition: FastL1Region.h:57
L1Config::noFGThreshold
double noFGThreshold
Definition: FastL1Region.h:69
FastL1GlobalAlgo::m_hcaluncomp
double m_hcaluncomp[33][256]
Definition: FastL1GlobalAlgo.h:135
j
int j
Definition: DBlmapReader.cc:9
L1Config::HcalTPInput
edm::InputTag HcalTPInput
Definition: FastL1Region.h:94
L1Config::EcalTPInput
edm::InputTag EcalTPInput
Definition: FastL1Region.h:93
L1Config::TowerEEThreshold
double TowerEEThreshold
Definition: FastL1Region.h:81
L1Config::EMNoiseLevel
double EMNoiseLevel
Definition: FastL1Region.h:62
L1Config::DoJetCorr
bool DoJetCorr
Definition: FastL1Region.h:54
L1Config::TowerHadLSB
double TowerHadLSB
Definition: FastL1Region.h:76
L1Config::EMLSB
double EMLSB
Definition: FastL1Region.h:77
L1Config::JetLSB
double JetLSB
Definition: FastL1Region.h:78
L1Config::CrystalEEThreshold
double CrystalEEThreshold
Definition: FastL1Region.h:73
L1Config::MuonNoiseLevel
double MuonNoiseLevel
Definition: FastL1Region.h:71
L1Config::EMSeedEnThreshold
double EMSeedEnThreshold
Definition: FastL1Region.h:58
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
edm::FileInPath::fullPath
std::string fullPath() const
Definition: FileInPath.cc:170
L1Config::TowerEBThreshold
double TowerEBThreshold
Definition: FastL1Region.h:80
L1Config::HcalLUT
edm::FileInPath HcalLUT
Definition: FastL1Region.h:96
L1Config::DoEMCorr
bool DoEMCorr
Definition: FastL1Region.h:55
FastL1GlobalAlgo::~FastL1GlobalAlgo ( )

Definition at line 103 of file FastL1GlobalAlgo.cc.

104 {
105 }

Member Function Documentation

void FastL1GlobalAlgo::addJet ( int  rgnId,
bool  taubit 
)
private

Definition at line 208 of file FastL1GlobalAlgo.cc.

References abs, corrJetEt(), funct::cos(), L1Config::DoJetCorr, eta(), funct::exp(), GCTEnergyTrunc(), FastL1RegionMap::getRegionCenterEtaPhi(), myspace::greaterEt(), L1Config::JetLSB, m_CenJets, m_DoBitInfo, m_ForJets, m_L1Config, m_Regions, m_RMap, m_TauJets, L1Config::noTauVetoLevel, L1TEmulatorMonitor_cff::p, phi, funct::sin(), python.multivaluedict::sort(), and theta().

Referenced by findJets().

208  {
209  std::pair<double, double> p = m_RMap->getRegionCenterEtaPhi(iRgn);
210 
211  //double e = m_Regions.at(iRgn).GetJetE();
212  //double et = GCTEnergyTrunc(m_Regions.at(iRgn).GetJetEt(), m_L1Config.JetLSB, false);
213  double et = m_Regions.at(iRgn).GetJetEt();
214 
215  double eta = p.first;
216  double phi = p.second;
217 
218  if (m_L1Config.DoJetCorr) {
219  et = GCTEnergyTrunc(corrJetEt(et,eta), m_L1Config.JetLSB, false);
220  } else {
221  et = GCTEnergyTrunc(et, m_L1Config.JetLSB, false);
222  }
223 
224  double theta = 2.*atan(exp(-eta));
225  double ex = et*cos(phi);
226  double ey = et*sin(phi);
227  //double ex = e*sin(theta)*cos(phi);
228  //double ey = e*sin(theta)*sin(phi);
229  double e = ex/sin(theta)/cos(phi);
230  double ez = e*cos(theta);
231 
232  if (m_DoBitInfo){
233  m_Regions[iRgn].BitInfo.setEt(et);
234  m_Regions[iRgn].BitInfo.setEnergy(e);
235  }
236 
237  reco::Particle::LorentzVector rp4(ex,ey,ez,e);
238  l1extra::L1JetParticle tjet(rp4);
239 
240  if (et>=5.) {
241  if (m_DoBitInfo) m_Regions[iRgn].BitInfo.setHard(true);
242  if (m_DoBitInfo) m_Regions[iRgn].BitInfo.setSoft(false);
243  if ((taubit || et>m_L1Config.noTauVetoLevel) && (std::abs(eta)<3.0) ) {
244  m_TauJets.push_back(tjet);
245  // sort by et
246  std::sort(m_TauJets.begin(),m_TauJets.end(), myspace::greaterEt);
247  } else {
248  if (std::abs(eta)<3.0) {
249  m_CenJets.push_back(tjet);
250  std::sort(m_CenJets.begin(),m_CenJets.end(), myspace::greaterEt);
251  } else {
252  m_ForJets.push_back(tjet);
253  std::sort(m_ForJets.begin(),m_ForJets.end(), myspace::greaterEt);
254  }
255  }
256  }
257  else{
258  if (m_DoBitInfo) m_Regions[iRgn].BitInfo.setSoft(true);
259  if (m_DoBitInfo) m_Regions[iRgn].BitInfo.setHard(false);
260  }
261 }
corrJetEt
double corrJetEt(double et, double eta)
Definition: FastL1Region.cc:833
FastL1GlobalAlgo::m_TauJets
l1extra::L1JetParticleCollection m_TauJets
Definition: FastL1GlobalAlgo.h:120
L1Config::noTauVetoLevel
double noTauVetoLevel
Definition: FastL1Region.h:65
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:161
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
abs
#define abs(x)
Definition: mlp_lapack.h:159
funct::exp
Exp< T >::type exp(const T &t)
Definition: Exp.h:22
eta
T eta() const
Definition: Basic3DVectorLD.h:168
FastL1GlobalAlgo::m_CenJets
l1extra::L1JetParticleCollection m_CenJets
Definition: FastL1GlobalAlgo.h:121
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
GCTEnergyTrunc
double GCTEnergyTrunc(double et, double LSB=1., bool doEM=false)
Definition: FastL1Region.cc:1041
myspace::greaterEt
bool greaterEt(const reco::Candidate &a, const reco::Candidate &b)
Definition: FastL1GlobalAlgo.cc:148
L1Config::DoJetCorr
bool DoJetCorr
Definition: FastL1Region.h:54
L1TEmulatorMonitor_cff.p
tuple p
Definition: L1TEmulatorMonitor_cff.py:48
L1Config::JetLSB
double JetLSB
Definition: FastL1Region.h:78
FastL1GlobalAlgo::m_ForJets
l1extra::L1JetParticleCollection m_ForJets
Definition: FastL1GlobalAlgo.h:122
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
phi
Definition: DDAxes.h:10
void FastL1GlobalAlgo::CaloTowersDump ( edm::Event const &  e)

Definition at line 111 of file FastL1GlobalAlgo.cc.

References edm::Event::getByLabel(), collect_tpl::input, j, m_L1Config, and L1Config::TowerInput.

111  {
112  /*
113  std::vector<edm::Handle<CaloTowerCollection> > prods;
114 
115  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << "Start!";
116  e.getManyByType(prods);
117 
118  std::vector<edm::Handle<CaloTowerCollection> >::iterator i;
119 
120  for (i=prods.begin(); i!=prods.end(); i++) {
121  const CaloTowerCollection& c=*(*i);
122 
123  for (CaloTowerCollection::const_iterator j=c.begin(); j!=c.end(); j++) {
124  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << *j;
125  }
126  }
127  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << "End!";
128  */
129 
130 
131  edm::Handle<CaloTowerCollection> input;
132 
133  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << "Start!";
134  e.getByLabel(m_L1Config.TowerInput,input);
135 
136  for (CaloTowerCollection::const_iterator j=input->begin(); j!=input->end(); j++) {
137  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << *j;
138  }
139 
140  edm::LogInfo("FastL1GlobalAlgo::CaloTowersDump") << "End!";
141 }
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:81
L1Config::TowerInput
edm::InputTag TowerInput
Definition: FastL1Region.h:91
j
int j
Definition: DBlmapReader.cc:9
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
void FastL1GlobalAlgo::checkMapping ( )
private

Definition at line 1341 of file FastL1GlobalAlgo.cc.

References FastL1RegionMap::convertFromECal_to_HCal_iphi(), gather_cfg::cout, FastL1RegionMap::getRegionCenterEtaPhi(), FastL1RegionMap::getRegionEtaPhiIndex(), FastL1RegionMap::getRegionIndex(), FastL1RegionMap::getRegionTowerIndex(), i, j, and m_RMap.

1341  {
1342 
1343  // loop over towers ieta,iphi
1344  for (int j=1;j<=72;j++) {
1345  for (int i=-28; i<=28; i++) {
1346  if (i==0) continue;
1347  int iRgn = m_RMap->getRegionIndex(i,j);
1348  std::pair<double, double> RgnEtaPhi = m_RMap->getRegionCenterEtaPhi(iRgn);
1349  //int iTwr = m_RMap->getRegionTowerIndex(i,j);
1350  std::pair<int, int> iRgnEtaPhi = m_RMap->getRegionEtaPhiIndex(iRgn);
1351  std::pair<int, int> iRgnEtaPhi2 = m_RMap->getRegionEtaPhiIndex(std::pair<int, int>(i,j));
1352 
1353  std::cout<<"---------------------------------------------------------------------------"<<std::endl;
1354  std::cout<<"Region: "<<iRgn<<" | "<<RgnEtaPhi.first<<", "<<RgnEtaPhi.second*180./3.141<<std::endl;
1355  std::cout<<" - "<<iRgnEtaPhi.first<<", "<<iRgnEtaPhi.second<<std::endl;
1356  std::cout<<" - "<<iRgnEtaPhi2.first<<", "<<iRgnEtaPhi2.second<<std::endl;
1357  std::cout<<" Tower: "<<i<<", "<<m_RMap->convertFromECal_to_HCal_iphi(j)<<std::endl;
1358  std::cout<<" TowerId: "<<m_RMap->getRegionTowerIndex(i,j)<<std::endl;
1359 
1360  }
1361  }
1362 
1363 }
i
int i
Definition: DBlmapReader.cc:9
FastL1RegionMap::getRegionIndex
int getRegionIndex(int ieta, int iphi)
Definition: FastL1RegionMap.cc:213
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
FastL1RegionMap::getRegionTowerIndex
int getRegionTowerIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:175
j
int j
Definition: DBlmapReader.cc:9
FastL1RegionMap::convertFromECal_to_HCal_iphi
int convertFromECal_to_HCal_iphi(int iphi_ecal)
Definition: FastL1RegionMap.cc:313
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
FastL1RegionMap::getRegionEtaPhiIndex
std::pair< int, int > getRegionEtaPhiIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:62
void FastL1GlobalAlgo::FillBitInfos ( )

Definition at line 832 of file FastL1GlobalAlgo.cc.

References i, m_BitInfos, m_DoBitInfo, and m_Regions.

Referenced by FastL1CaloSim::produce().

832  {
833  if (m_DoBitInfo){
834  m_BitInfos.clear();
835  for (int i=0; i<396; i++) {
836  m_BitInfos.push_back(m_Regions[i].getBitInfo());
837  }
838  }
839 }
i
int i
Definition: DBlmapReader.cc:9
FastL1GlobalAlgo::m_BitInfos
FastL1BitInfoCollection m_BitInfos
Definition: FastL1GlobalAlgo.h:125
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
void FastL1GlobalAlgo::FillEgammas ( edm::Event const &  e)

Definition at line 304 of file FastL1GlobalAlgo.cc.

References edm::Event::getByLabel(), myspace::greaterEt(), collect_tpl::input, isEMCand(), m_Egammas, m_isoEgammas, m_L1Config, python.multivaluedict::sort(), and L1Config::TowerInput.

Referenced by FastL1CaloSim::produce().

304  {
305  m_Egammas.clear();
306  m_isoEgammas.clear();
307 
308  //std::vector< edm::Handle<CaloTowerCollection> > input;
309  //e.getManyByType(input);
310  edm::Handle<CaloTowerCollection> input;
311  e.getByLabel(m_L1Config.TowerInput,input);
312 
313  //std::vector< edm::Handle<CaloTowerCollection> >::iterator j;
314  //for (j=input.begin(); j!=input.end(); j++) {
315  // const CaloTowerCollection& c=*(*j);
316 
317  l1extra::L1EmParticle* ph = new l1extra::L1EmParticle();
318  //l1extra::L1EmParticle ph;
319  //for (CaloTowerCollection::const_iterator cnd=c.begin(); cnd!=c.end(); cnd++) {
320  for (CaloTowerCollection::const_iterator cnd=input->begin(); cnd!=input->end(); cnd++) {
321  reco::Particle::LorentzVector rp4(0.,0.,0.,0.);
322  //l1extra::L1EmParticle* ph = new l1extra::L1EmParticle(rp4);
323  *ph = l1extra::L1EmParticle(rp4);
324 
325  CaloTowerDetId cid = cnd->id();
326 
327  int emTag = isEMCand(cid,ph,e);
328 
329  // 1 = non-iso EM, 2 = iso EM
330  if (emTag==1) {
331  m_Egammas.push_back(*ph);
332  } else if (emTag==2) {
333  m_isoEgammas.push_back(*ph);
334  }
335 
336  }
337  //}
338 
339  std::sort(m_Egammas.begin(),m_Egammas.end(), myspace::greaterEt);
340  std::sort(m_isoEgammas.begin(),m_isoEgammas.end(), myspace::greaterEt);
341 
342  delete ph;
343 }
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:81
FastL1GlobalAlgo::isEMCand
int isEMCand(CaloTowerDetId cid, l1extra::L1EmParticle *p, const edm::Event &e)
Definition: FastL1GlobalAlgo.cc:932
L1Config::TowerInput
edm::InputTag TowerInput
Definition: FastL1Region.h:91
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
myspace::greaterEt
bool greaterEt(const reco::Candidate &a, const reco::Candidate &b)
Definition: FastL1GlobalAlgo.cc:148
FastL1GlobalAlgo::m_isoEgammas
l1extra::L1EmParticleCollection m_isoEgammas
Definition: FastL1GlobalAlgo.h:124
FastL1GlobalAlgo::m_Egammas
l1extra::L1EmParticleCollection m_Egammas
Definition: FastL1GlobalAlgo.h:123
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
void FastL1GlobalAlgo::FillEgammasTP ( edm::Event const &  e)

Definition at line 266 of file FastL1GlobalAlgo.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), myspace::greaterEt(), i, isEMCand(), m_Egammas, m_isoEgammas, m_Regions, and python.multivaluedict::sort().

Referenced by FastL1CaloSim::produce().

266  {
267  m_Egammas.clear();
268  m_isoEgammas.clear();
269 
270  l1extra::L1EmParticle* ph = new l1extra::L1EmParticle();
271  //l1extra::L1EmParticle ph;
272  for (int i=0; i<396; i++) {
273  CaloTowerCollection towers = m_Regions[i].GetCaloTowers();
274 
275  for (CaloTowerCollection::const_iterator cnd=towers.begin(); cnd!=towers.end(); cnd++) {
276  if (cnd->emEt()<0.01 && cnd->hadEt()<0.01) continue;
277  //if (cnd->emEt()<0.01) continue;
278 
279  reco::Particle::LorentzVector rp4(0.,0.,0.,0.);
280  // l1extra::L1EmParticle* ph = new l1extra::L1EmParticle(rp4);
281  *ph = l1extra::L1EmParticle(rp4);
282 
283  CaloTowerDetId cid = cnd->id();
284 
285  int emTag = isEMCand(cid,ph,e);
286 
287  // 1 = non-iso EM, 2 = iso EM
288  if (emTag==1) {
289  m_Egammas.push_back(*ph);
290  } else if (emTag==2) {
291  m_isoEgammas.push_back(*ph);
292  }
293 
294  }
295  std::sort(m_Egammas.begin(),m_Egammas.end(), myspace::greaterEt);
296  std::sort(m_isoEgammas.begin(),m_isoEgammas.end(), myspace::greaterEt);
297  }
298  delete ph;
299 }
i
int i
Definition: DBlmapReader.cc:9
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:81
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
FastL1GlobalAlgo::isEMCand
int isEMCand(CaloTowerDetId cid, l1extra::L1EmParticle *p, const edm::Event &e)
Definition: FastL1GlobalAlgo.cc:932
myspace::greaterEt
bool greaterEt(const reco::Candidate &a, const reco::Candidate &b)
Definition: FastL1GlobalAlgo.cc:148
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:302
FastL1GlobalAlgo::m_isoEgammas
l1extra::L1EmParticleCollection m_isoEgammas
Definition: FastL1GlobalAlgo.h:124
FastL1GlobalAlgo::m_Egammas
l1extra::L1EmParticleCollection m_Egammas
Definition: FastL1GlobalAlgo.h:123
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:295
void FastL1GlobalAlgo::FillJets ( const edm::EventSetup &  e)
inline

Definition at line 93 of file FastL1GlobalAlgo.h.

References findJets().

Referenced by FastL1CaloSim::produce().

93 { findJets(); };
void FastL1GlobalAlgo::FillL1Regions ( edm::Event const &  e,
const edm::EventSetup &  c 
)

Definition at line 750 of file FastL1GlobalAlgo.cc.

References abs, L1Config::EmInputs, edm::EventSetup::get(), edm::Event::getByLabel(), FastL1RegionMap::getRegionEtaPhiIndex(), FastL1RegionMap::getRegionTowerIndex(), i, InitL1Regions(), collect_tpl::input, m_L1Config, m_Regions, m_RMap, edm::ESHandle< class >::product(), and L1Config::TowerInput.

Referenced by FastL1CaloSim::produce().

751 {
752  InitL1Regions();
753 
754  edm::Handle<CaloTowerCollection> input;
755  e.getByLabel(m_L1Config.TowerInput,input);
756 
757  edm::ESHandle<CaloTowerConstituentsMap> cttopo;
758  c.get<IdealGeometryRecord>().get(cttopo);
759  const CaloTowerConstituentsMap* theTowerConstituentsMap = cttopo.product();
760 
761  edm::ESHandle<CaloTopology> calotopo;
762  c.get<CaloTopologyRecord>().get(calotopo);
763 
764  edm::ESHandle<CaloGeometry> cGeom;
765  //c.get<IdealGeometryRecord>().get(cGeom);
766  c.get<CaloGeometryRecord>().get(cGeom);
767 
768  edm::Handle<EcalRecHitCollection> ec1;
769  e.getByLabel(m_L1Config.EmInputs.at(1),ec1);
770 
771  edm::Handle<EcalRecHitCollection> ec0;
772  e.getByLabel(m_L1Config.EmInputs.at(0),ec0);
773 
774  // ascii visualisation of mapping
775  //m_RMap->display();
776 
777 
778  // works for barrel/endcap region only right now!
779  //std::vector< edm::Handle<CaloTowerCollection> > input;
780  //e.getManyByType(input);
781  //edm::Handle<CaloTowerCollection> input;
782  //e.getByLabel(m_L1Config.TowerInput,input);
783 
784  //std::vector< edm::Handle<CaloTowerCollection> >::iterator j;
785  //for (j=input.begin(); j!=input.end(); j++) {
786  // const CaloTowerCollection& c=*(*j);
787 
788  // for (CaloTowerCollection::const_iterator cnd=c.begin(); cnd!=c.end(); cnd++) {
789  for (CaloTowerCollection::const_iterator cnd=input->begin(); cnd!=input->end(); cnd++) {
790 
791  CaloTowerDetId cid = cnd->id();
792  std::pair<int, int> pep = m_RMap->getRegionEtaPhiIndex(cid);
793 
794  int rgnid = 999;
795  int twrid = 999;
796 
797  if (std::abs(pep.first)<=22) {
798  rgnid = pep.second*22 + pep.first;
799  twrid = m_RMap->getRegionTowerIndex(cid);
800  //std::cout << rgnid << " " << twrid << std::endl;
801  //std::cout << cnd->emEt() << " " << cnd->hadEt() << std::endl;
802  }
803 
804  if (rgnid<396 && twrid<16) {
805  m_Regions[rgnid].FillTower_Scaled(*cnd,twrid,true,cGeom);
806  m_Regions[rgnid].SetRegionBits(e);
807  }
808 
809  }
810 
811  //}
812 
813  // Fill EM Crystals
814  for (int i=0; i<396; i++) {
815 
816  //m_Regions[i].FillEMCrystals(e,iConfig,m_RMap);
817  m_Regions[i].FillEMCrystals(theTowerConstituentsMap,
818  &(*calotopo),
819  &(*cGeom),
820  &(*ec0), &(*ec1),
821  m_RMap);
822 
823  }
824 
825  //checkMapping();
826 
827 }
i
int i
Definition: DBlmapReader.cc:9
L1Config::EmInputs
std::vector< edm::InputTag > EmInputs
Definition: FastL1Region.h:90
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:81
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
abs
#define abs(x)
Definition: mlp_lapack.h:159
FastL1RegionMap::getRegionTowerIndex
int getRegionTowerIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:175
L1Config::TowerInput
edm::InputTag TowerInput
Definition: FastL1Region.h:91
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:62
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
FastL1RegionMap::getRegionEtaPhiIndex
std::pair< int, int > getRegionEtaPhiIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:62
void FastL1GlobalAlgo::FillL1RegionsTP ( edm::Event const &  e,
const edm::EventSetup &  c 
)

Definition at line 531 of file FastL1GlobalAlgo.cc.

References abs, corrEmEt(), L1Config::DoEMCorr, L1Config::EcalTPInput, L1Config::EMLSB, eta(), fastmath::etaphi(), edm::EventSetup::get(), edm::Event::getByLabel(), FastL1RegionMap::getRegionCenterEtaPhi(), FastL1RegionMap::getRegionIndex(), FastL1RegionMap::getRegionTowerIndex(), hcaletValue(), L1Config::HcalTPInput, L1Config::hOeThreshold, i, InitL1Regions(), j, m_L1Config, m_Regions, m_RMap, L1Config::noFGThreshold, phi, and matplotRender::t.

Referenced by FastL1CaloSim::produce().

532 {
533  //edm::ESHandle<CaloTowerConstituentsMap> cttopo;
534  //s.get<IdealGeometryRecord>().get(cttopo);
535  //const CaloTowerConstituentsMap* theTowerConstituentsMap = cttopo.product();
536 
537  InitL1Regions();
538 
539  edm::ESHandle<CaloGeometry> cGeom;
540  //c.get<IdealGeometryRecord>().get(cGeom);
541  s.get<CaloGeometryRecord>().get(cGeom);
542 
543  edm::Handle<EcalTrigPrimDigiCollection> ETPinput;
544  e.getByLabel(m_L1Config.EcalTPInput,ETPinput);
545 
546  edm::Handle<HcalTrigPrimDigiCollection> HTPinput;
547  e.getByLabel(m_L1Config.HcalTPInput,HTPinput);
548 
549  //CaloTowerCollection towers;
550  int hEtV [396][16] = {{0}};
551  int hFGV [396][16] = {{0}};
552  int hiEtaV[396][16] = {{0}};
553  int hiPhiV[396][16] = {{0}};
554  for (HcalTrigPrimDigiCollection::const_iterator hTP=HTPinput->begin();
555  hTP!=HTPinput->end(); hTP++) {
556 
557  int rgnid = 999;
558  int twrid = 999;
559 
560  int hiphi = hTP->id().iphi();
561  int hieta = hTP->id().ieta();
562 
563  /*
564  if(abs(hieta) > 20 && hiphi%2 == 0) hiphi--;
565  std::pair<int, int> prim_tower_feed; // prim tower indeces iEta +/- 1~32, iPhi (+) 1~72
566  prim_tower_feed.first = hieta;
567  prim_tower_feed.second = hiphi;
568  std::pair<int, int> rct_index = m_RMap-> getRegionEtaPhiIndex(prim_tower_feed); // convert prim tower indeces into RCT indeces ieta 0~21, iphi 0~17
569  rgnid = rct_index.second*22 + rct_index.first; // converting fastL1 obsolete RCT numbering
570  */
571 
572  rgnid = m_RMap->getRegionIndex(hieta,hiphi);
573  twrid = m_RMap->getRegionTowerIndex(hieta,hiphi);
574 
575  /*
576  if (std::abs(htwrid.ieta())>28) {
577  std::cout<<htwrid.ieta()<<" "<<htwrid.iphi()<<" "<<rgnid<<" "<<twrid<<" "<<std::endl;
578  }
579  */
580 
581  /*
582  if (hTP->SOI_compressedEt()>0) {
583  std::cout<<"hcalTP >>> "<<hTP->SOI_compressedEt()<<" "<<hTP->SOI_fineGrain()<<" "
584  <<rgnid<<" "<<twrid<<std::endl;
585  }
586  */
587  if(rgnid < 396 && twrid < 16){
588  hEtV[rgnid][twrid] = (int)hTP->SOI_compressedEt();
589  hFGV[rgnid][twrid] = (int)hTP->SOI_fineGrain();
590  hiEtaV[rgnid][twrid] = hieta;
591  hiPhiV[rgnid][twrid] = hiphi;
592  }
593  }
594 
595 
596  int emEtV [396][16] = {{0}};
597  int emFGV [396][16] = {{0}};
598  int emiEtaV[396][16] = {{0}};
599  int emiPhiV[396][16] = {{0}};
600  //double emEtaV[396][16] = {0.};
601  for (EcalTrigPrimDigiCollection::const_iterator eTP=ETPinput->begin();
602  eTP!=ETPinput->end(); eTP++) {
603 
604  int eieta = eTP->id().ieta();
605 
606  if(abs(eieta)> 28) continue; // no crystal in HF
607  else{
608  int eiphi = eTP->id().iphi();
609  //int teiphi = eiphi;
610 
611  int rgnid = 999;
612  int twrid = 999;
613 
614  //if(abs(eieta) > 20 && eiphi%2 == 0) teiphi=eiphi-1;
615 
616  /*
617  if(abs(eieta) > 20 && eiphi%2 == 0) eiphi--;
618  std::pair<int, int> prim_tower_feed; // prim tower indeces iEta +/- 1~28, iPhi (+) 1~72
619  prim_tower_feed.first = eieta;
620  prim_tower_feed.second = eiphi;
621  std::pair<int, int> rct_index = m_RMap-> getRegionEtaPhiIndex(prim_tower_feed); // convert prim tower indeces into RCT indeces ieta 0~21, iphi 0~17
622  rgnid = rct_index.second*22 + rct_index.first; // converting fastL1 obsolete RCT numbering
623  */
624 
625  /*
626  rgnid = m_RMap->getRegionIndex(eieta,eiphi);
627  twrid = m_RMap->getRegionTowerIndex(eieta,eiphi);
628 
629  if (eTP->compressedEt()>0) {
630  std::cout<<"ecalTP *** "<<eTP->compressedEt()<<" "<<eTP->fineGrain()<<" "
631  <<rgnid<<" "<<twrid<<std::endl;
632  }
633  */
634  if(rgnid < 396 && twrid < 16){
635  emEtV[rgnid][twrid] = (int)eTP->compressedEt();
636  emFGV[rgnid][twrid] = (int)eTP->fineGrain();
637  emiEtaV[rgnid][twrid] = eieta;
638  emiPhiV[rgnid][twrid] = eiphi;
639 
640  //edm::ESHandle<CaloGeometry> cGeom;
641  //s.get<IdealGeometryRecord>().get(cGeom);
642 
643  //CaloTowerDetId towerDetId = CaloTowerDetId( eieta, teiphi);
644  //CaloTowerDetId towerDetId2 = CaloTowerDetId( eieta, eiphi);
645  //const GlobalPoint gP1 = cGeom->getPosition(towerDetId);
646  //const GlobalPoint gP12 = cGeom->getPosition(towerDetId2);
647  //double eta = gP1.eta();
648 
649  //if(abs(eieta) > 20)
650  //std::cout<<eiphi<<" "<<gP1.phi()<<" "<<eieta<<" "<<gP1.eta()<<" "<<std::endl;
651 
652  //double phi = gP1.phi();
653  //emEtaV[rgnid][twrid] = eta;
654  }
655  } // else
656  } // ecalTP
657 
658 
659  for (int i=0; i<396; i++) {
660  for (int j=0; j<16; j++) {
661  if (emEtV[i][j]>0 || hEtV[i][j]>0) {
662 
663 
664  std::pair<double, double> etaphi
665  = m_RMap->getRegionCenterEtaPhi(i);
666  double eta = etaphi.first;
667  double phi = etaphi.second;
668 
669 
670  double emEt = ((double) emEtV[i][j]) * m_L1Config.EMLSB;
671  //double hadEt = ((double )hEtV[i][j]) * m_L1Config.JetLSB * cos(2.*atan(exp(-hiEtaV[i][j])));
672  int iAbsTwrEta = std::abs(hiEtaV[i][j]);
673  //double hadEt = ((double )hcaletValue(iAbsTwrEta, hEtV[i][j])) * m_L1Config.JetLSB;
674  double hadEt = ((double )hcaletValue(iAbsTwrEta, hEtV[i][j]));
675  //double hadEt = hEtV[i][j] * m_L1Config.JetLSB;
676 
677  if (m_L1Config.DoEMCorr) {
678  //emEt = corrEmEt(emEt,emEtaV[i][j]);
679  emEt = corrEmEt(emEt,std::abs(emiEtaV[i][j]));
680  }
681 
682  double et = emEt + hadEt;
683  edm::ESHandle<CaloGeometry> cGeom;
684  //s.get<IdealGeometryRecord>().get(cGeom);
685  s.get<CaloGeometryRecord>().get(cGeom);
686 
687 
688  //math::RhoEtaPhiVector lvec(et,eta,phi);
689  math::XYZTLorentzVector lvec(et,eta,phi,0.);
690  //math::PtEtaPhiMLorentzVector lvec(et,eta,phi,0.);
691 
692  CaloTowerDetId towerDetId;
693  if (emEtV[i][j]>0)
694  towerDetId = CaloTowerDetId(emiEtaV[i][j],emiPhiV[i][j]);
695  else
696  towerDetId = CaloTowerDetId(hiEtaV[i][j],hiPhiV[i][j]);
697 
698  GlobalPoint gP = cGeom->getPosition(towerDetId);
699  CaloTower t = CaloTower(towerDetId,
700  emEt, hadEt, 0.,
701  0, 0, lvec,
702  gP, gP);
703 
704  //m_Regions[i].FillTower_Scaled(t,j,false);
705  m_Regions[i].FillTower_Scaled(t,j,true,cGeom);
706 
707  /*
708  if (et>0) {
709  std::cout<<"+++ "<<emEt<<" "<<hadEt<<" "
710  <<i<<" "<<j<<" "
711  <<std::endl<<"-- "
712  <<t.emEt()<<" "<<t.hadEt()<<" "
713  <<t.eta()<<" "<<t.phi()<<" "
714  <<std::endl;
715  }
716  */
717 
718 
719  // Explicitely take care of integer boolean conversion
720  if (emEt > 3.0 && emEt < m_L1Config.noFGThreshold && (int)emFGV[i][j]!=0)
721  m_Regions[i].SetFGBit(j,true);
722  else
723  m_Regions[i].SetFGBit(j,false);
724 
725  if (emEt > 3.0){
726  if (emEt < 60. && hadEt/emEt > m_L1Config.hOeThreshold)
727  m_Regions[i].SetHOEBit(j,true);
728  else
729  m_Regions[i].SetHOEBit(j,false);
730  }
731  else
732  m_Regions[i].SetHOEBit(j,false);
733 
734  m_Regions[i].SetRegionBits(e);
735  }
736 
737 
738  }
739  }
740 
741 
742 
743 
744 
745 
746 }
i
int i
Definition: DBlmapReader.cc:9
edm::HandleBase::id
ProductID id() const
Definition: HandleBase.cc:15
L1Config::hOeThreshold
double hOeThreshold
Definition: FastL1Region.h:66
FastL1RegionMap::getRegionIndex
int getRegionIndex(int ieta, int iphi)
Definition: FastL1RegionMap.cc:213
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:81
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
abs
#define abs(x)
Definition: mlp_lapack.h:159
FastL1RegionMap::getRegionTowerIndex
int getRegionTowerIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:175
eta
T eta() const
Definition: Basic3DVectorLD.h:168
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:30
fastmath::etaphi
std::pair< T, T > etaphi(T x, T y, T z)
Definition: FastMath.h:128
L1Config::noFGThreshold
double noFGThreshold
Definition: FastL1Region.h:69
j
int j
Definition: DBlmapReader.cc:9
L1Config::HcalTPInput
edm::InputTag HcalTPInput
Definition: FastL1Region.h:94
L1Config::EcalTPInput
edm::InputTag EcalTPInput
Definition: FastL1Region.h:93
corrEmEt
double corrEmEt(double et, int eta)
Definition: FastL1Region.cc:991
FastL1GlobalAlgo::hcaletValue
double hcaletValue(const int ieta, const int compET)
Definition: FastL1GlobalAlgo.cc:1366
L1Config::EMLSB
double EMLSB
Definition: FastL1Region.h:77
asciidump.s
string s
Definition: asciidump.py:422
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
edm::ProductID::id
ProductIndex id() const
Definition: ProductID.h:39
L1Config::DoEMCorr
bool DoEMCorr
Definition: FastL1Region.h:55
phi
Definition: DDAxes.h:10
void FastL1GlobalAlgo::FillMET ( )

Definition at line 463 of file FastL1GlobalAlgo.cc.

References funct::cos(), fastmath::etaphi(), FastL1RegionMap::getRegionCenterEtaPhi(), i, l1extra::L1EtMissParticle::kMET, m_METs, m_Regions, m_RMap, phi, funct::sin(), and mathSSE::sqrt().

Referenced by FastL1CaloSim::produce().

463  {
464  m_METs.clear();
465 
466  //double sum_e = 0.0;
467  double sum_et = 0.0;
468  double sum_ex = 0.0;
469  double sum_ey = 0.0;
470  //double sum_ez = 0.0;
471 
472  for (int i=0; i<396; i++) {
473  std::pair<double, double> etaphi = m_RMap->getRegionCenterEtaPhi(i);
474  double phi = etaphi.second;
475  //double eta = etaphi.first;
476  //double theta = 2.*atan(exp(-eta));
477 
478  double et = m_Regions[i].SumEt();
479  //double e = m_Regions[i].SumE();
480 
481  //sum_et += et;
482  //sum_et += RCTEnergyTrunc(et,0.5,2048);
483  //sum_et += et;
484  //sum_ex += RCTEnergyTrunc(et*cos(phi),0.5,2048);
485  //sum_ey += RCTEnergyTrunc(et*sin(phi),0.5,2048);
486  sum_ex += et*cos(phi);
487  sum_ey += et*sin(phi);
488  //sum_ex += e*sin(theta)*cos(phi);
489  //sum_ey += e*sin(theta)*sin(phi);
490  //sum_e += e;
491  //sum_e += RCTEnergyTrunc(et/sin(theta),0.5,2048);
492  //sum_ez += RCTEnergyTrunc(et*cos(theta)/sin(theta),0.5,2048);
493  //sum_e += et/sin(theta);
494  //sum_ez += et*cos(theta)/sin(theta);
495  //sum_ez += e*cos(theta);
496  //sum_et += e*sin(theta);
497  }
498 
499  //sum_et = RCTEnergyTrunc(std::sqrt(sum_ex*sum_ex + sum_ey*sum_ey),0.5,2048);
500  sum_et = std::sqrt(sum_ex*sum_ex + sum_ey*sum_ey);
501 
502  //reco::Particle::LorentzVector rp4(-sum_ex,-sum_ey,-sum_ez,sum_e);
503  reco::Particle::LorentzVector rp4(-sum_ex,-sum_ey,0.,std::sqrt(sum_ex*sum_ex + sum_ey*sum_ey));
504  //edm::LogInfo("********** FastL1GlobalAlgo::FillMET()")<<rp4.mass()<<std::endl;
505  //m_MET = l1extra::L1EtMissParticle(rp4,sum_et,0.);
506  m_METs.push_back(l1extra::L1EtMissParticle(rp4,l1extra::L1EtMissParticle::kMET,sum_et));
507 
508 }
i
int i
Definition: DBlmapReader.cc:9
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:28
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
fastmath::etaphi
std::pair< T, T > etaphi(T x, T y, T z)
Definition: FastMath.h:128
FastL1GlobalAlgo::m_METs
l1extra::L1EtMissParticleCollection m_METs
Definition: FastL1GlobalAlgo.h:119
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
phi
Definition: DDAxes.h:10
void FastL1GlobalAlgo::FillMET ( edm::Event const &  e)

Definition at line 347 of file FastL1GlobalAlgo.cc.

References abs, funct::cos(), eta(), funct::exp(), edm::Event::getByLabel(), collect_tpl::input, l1extra::L1EtMissParticle::kMET, m_L1Config, m_METs, phi, RCTEnergyTrunc(), funct::sin(), mathSSE::sqrt(), theta(), L1Config::TowerEBScale, L1Config::TowerEBThreshold, L1Config::TowerEEScale, L1Config::TowerEEThreshold, L1Config::TowerHBScale, L1Config::TowerHBThreshold, L1Config::TowerHEScale, and L1Config::TowerInput.

347  {
348  m_METs.clear();
349 
350  //std::vector< edm::Handle<CaloTowerCollection> > input;
351  //e.getManyByType(input);
352  edm::Handle<CaloTowerCollection> input;
353  e.getByLabel(m_L1Config.TowerInput,input);
354 
355  double sum_hade = 0.0;
356  double sum_hadet = 0.0;
357  double sum_hadex = 0.0;
358  double sum_hadey = 0.0;
359  double sum_hadez = 0.0;
360  double sum_e = 0.0;
361  double sum_et = 0.0;
362  double sum_ex = 0.0;
363  double sum_ey = 0.0;
364  double sum_ez = 0.0;
365 
366  //std::vector< edm::Handle<CaloTowerCollection> >::iterator i;
367 
368  //for (i=input.begin(); i!=input.end(); i++) {
369  // const CaloTowerCollection& c=*(*i);
370 
371  // for (CaloTowerCollection::const_iterator candidate=c.begin(); candidate!=c.end(); candidate++) {
372  for (CaloTowerCollection::const_iterator candidate=input->begin(); candidate!=input->end(); candidate++) {
373  //double eme = candidate->emEnergy();
374  //double hade = candidate->hadEnergy();
375  double eme = candidate->emEt();
376  double hade = candidate->hadEt();
377 
378  double EThres = 0.;
379  double HThres = 0.;
380  double EBthres = m_L1Config.TowerEBThreshold;
381  double HBthres = m_L1Config.TowerHBThreshold;
382  double EEthres = m_L1Config.TowerEBThreshold;
383  double HEthres = m_L1Config.TowerEEThreshold;
384 
385  //if(std::abs(candidate->eta())<1.479) {
386  if(std::abs(candidate->eta())<2.322) {
387  EThres = EBthres;
388  } else {
389  EThres = EEthres;
390  }
391  //if(std::abs(candidate->eta())<1.305) {
392  if(std::abs(candidate->eta())<2.322) {
393  HThres = HBthres;
394  } else {
395  HThres = HEthres;
396  }
397 
398  // rescale energies
399  double emScale = 1.0;
400  double hadScale = 1.0;
401  if (std::abs(candidate->eta()>1.3050) && std::abs(candidate->eta())<3.0) {
402  hadScale = m_L1Config.TowerHEScale;
403  emScale = m_L1Config.TowerEEScale;
404  }
405  if (std::abs(candidate->eta()<1.3050)) {
406  hadScale = m_L1Config.TowerHBScale;
407  emScale = m_L1Config.TowerEBScale;
408  }
409  eme *= emScale;
410  hade *= hadScale;
411 
412  if (eme>=EThres || hade>=HThres) {
413  double phi = candidate->phi();
414  double eta = candidate->eta();
415  //double et = candidate->et();
416  //double e = candidate->energy();
417  double theta = 2.*atan(exp(-eta));
418  double et = 0.;
419  double e = 0.;
420  double had_et = 0.;
421  double had_e = 0.;
422 
423  if (eme>=EThres) {
424  et += candidate->emEt();
425  e += candidate->emEnergy();
426  }
427  if (hade>=HThres) {
428  et += candidate->hadEt();
429  e += candidate->hadEnergy();
430  had_et += candidate->hadEt();
431  had_e += candidate->hadEnergy();
432  }
433 
434  //sum_et += et;
435  sum_et += RCTEnergyTrunc(et,1.0,1024);
436  sum_ex += et*cos(phi);
437  sum_ey += et*sin(phi);
438  //sum_ex += e*sin(theta)*cos(phi);
439  //sum_ey += e*sin(theta)*sin(phi);
440  //sum_e += e;
441  sum_e += et/sin(theta);
442  sum_ez += et*cos(theta)/sin(theta);
443 
444  sum_hadet += had_et;
445  sum_hadex += had_et*cos(phi);
446  sum_hadey += had_et*sin(phi);
447  //sum_hadex += had_e*sin(theta)*cos(phi);
448  //sum_hadey += had_e*sin(theta)*sin(phi);
449  //sum_hade += had_e;
450  sum_hade += had_et/sin(theta);
451  sum_hadez += had_et*cos(theta)/sin(theta);
452  }
453  }
454  //}
455 
456  reco::Particle::LorentzVector rp4(-sum_ex,-sum_ey,0.,std::sqrt(sum_ex*sum_ex + sum_ey*sum_ey));
457  //m_MET = l1extra::L1EtMissParticle(rp4,sum_et,0.);
458  m_METs.push_back(l1extra::L1EtMissParticle(rp4,l1extra::L1EtMissParticle::kMET,sum_et));
459 }
L1Config::TowerEEScale
double TowerEEScale
Definition: FastL1Region.h:86
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:81
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:161
abs
#define abs(x)
Definition: mlp_lapack.h:159
funct::exp
Exp< T >::type exp(const T &t)
Definition: Exp.h:22
L1Config::TowerEBScale
double TowerEBScale
Definition: FastL1Region.h:85
L1Config::TowerInput
edm::InputTag TowerInput
Definition: FastL1Region.h:91
eta
T eta() const
Definition: Basic3DVectorLD.h:168
L1Config::TowerHEScale
double TowerHEScale
Definition: FastL1Region.h:88
L1Config::TowerHBScale
double TowerHBScale
Definition: FastL1Region.h:87
L1Config::TowerHBThreshold
double TowerHBThreshold
Definition: FastL1Region.h:82
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:28
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
FastL1GlobalAlgo::m_METs
l1extra::L1EtMissParticleCollection m_METs
Definition: FastL1GlobalAlgo.h:119
collect_tpl.input
tuple input
Definition: collect_tpl.py:10
L1Config::TowerEEThreshold
double TowerEEThreshold
Definition: FastL1Region.h:81
RCTEnergyTrunc
double RCTEnergyTrunc(double et, double Resol=1., double thres=1024.)
Definition: FastL1Region.cc:1026
L1Config::TowerEBThreshold
double TowerEBThreshold
Definition: FastL1Region.h:80
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
phi
Definition: DDAxes.h:10
void FastL1GlobalAlgo::findJets ( )
private

Definition at line 155 of file FastL1GlobalAlgo.cc.

References addJet(), eta(), FastL1RegionMap::getRegionCenterEtaPhi(), i, isMaxEtRgn_Window33(), isTauJet(), L1Config::JetSeedEtThreshold, m_CenJets, m_DoBitInfo, m_ForJets, m_GctIso, m_L1Config, m_Regions, m_RMap, m_TauJets, L1TEmulatorMonitor_cff::p, phi, and TauIsolation().

Referenced by FillJets().

155  {
156 
157  m_TauJets.clear();
158  m_CenJets.clear();
159  m_ForJets.clear();
160 
161  for (int i=0; i<396; i++) {
162  // barrel/endcap part only:
163  //if ((i%22)>3 && (i%22)<18) {
164  std::pair<double, double> p = m_RMap->getRegionCenterEtaPhi(i);
165 
166  //if (m_Regions.at(i).SumEt()>0.)
167  // std::cout<<"******** TEST "<<i<<": "<<m_Regions.at(i).SumEt()<<std::endl;
168 
169  double eta = p.first;
170  double phi = p.second;
171  if (m_DoBitInfo){
172  m_Regions[i].BitInfo.setEta(eta);
173  m_Regions[i].BitInfo.setPhi(phi);
174  }
175 
176  if (m_Regions.at(i).SumEt()>m_L1Config.JetSeedEtThreshold) {
177  if (isMaxEtRgn_Window33(i)) {
178  if (m_GctIso == true) {
179  if (TauIsolation(i) && (i%22)>3 && (i%22)<18 ) {
180  addJet(i,true);
181  } else {
182  addJet(i,false);
183  }
184  } else {
185  if (isTauJet(i) && (i%22)>3 && (i%22)<18 ) {
186  addJet(i,true);
187  } else {
188  addJet(i,false);
189  }
190  }
191  if (m_DoBitInfo) m_Regions[i].BitInfo.setMaxEt(true);
192  }
193  else {
194  if (m_DoBitInfo) m_Regions[i].BitInfo.setMaxEt(false);
195  }
196  if (m_DoBitInfo) m_Regions[i].BitInfo.setSumEtBelowThres (false);
197  } else {
198  if (m_DoBitInfo) m_Regions[i].BitInfo.setSumEtBelowThres (true);
199  }
200  //}
201  }
202 
203 }
i
int i
Definition: DBlmapReader.cc:9
FastL1GlobalAlgo::m_TauJets
l1extra::L1JetParticleCollection m_TauJets
Definition: FastL1GlobalAlgo.h:120
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
eta
T eta() const
Definition: Basic3DVectorLD.h:168
FastL1GlobalAlgo::m_CenJets
l1extra::L1JetParticleCollection m_CenJets
Definition: FastL1GlobalAlgo.h:121
FastL1GlobalAlgo::isTauJet
bool isTauJet(int rgnid)
Definition: FastL1GlobalAlgo.cc:843
L1Config::JetSeedEtThreshold
double JetSeedEtThreshold
Definition: FastL1Region.h:57
FastL1GlobalAlgo::isMaxEtRgn_Window33
bool isMaxEtRgn_Window33(int rgnid)
Definition: FastL1GlobalAlgo.cc:1186
FastL1GlobalAlgo::TauIsolation
bool TauIsolation(int rgnid)
Definition: FastL1GlobalAlgo.cc:1373
L1TEmulatorMonitor_cff.p
tuple p
Definition: L1TEmulatorMonitor_cff.py:48
FastL1GlobalAlgo::addJet
void addJet(int rgnId, bool taubit)
Definition: FastL1GlobalAlgo.cc:208
FastL1GlobalAlgo::m_ForJets
l1extra::L1JetParticleCollection m_ForJets
Definition: FastL1GlobalAlgo.h:122
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
phi
Definition: DDAxes.h:10
FastL1BitInfoCollection FastL1GlobalAlgo::getBitInfos ( )
inline

Definition at line 84 of file FastL1GlobalAlgo.h.

References m_BitInfos.

Referenced by FastL1CaloSim::produce().

84 { return m_BitInfos; }
FastL1GlobalAlgo::m_BitInfos
FastL1BitInfoCollection m_BitInfos
Definition: FastL1GlobalAlgo.h:125
std::vector<FastL1Region> FastL1GlobalAlgo::GetCaloRegions ( )
inline

Definition at line 100 of file FastL1GlobalAlgo.h.

References m_Regions.

100 {return m_Regions;}//KP
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
l1extra::L1JetParticleCollection FastL1GlobalAlgo::getCenJets ( ) const
inline

Definition at line 80 of file FastL1GlobalAlgo.h.

References m_CenJets.

Referenced by FastL1CaloSim::produce().

80 { return m_CenJets; }
FastL1GlobalAlgo::m_CenJets
l1extra::L1JetParticleCollection m_CenJets
Definition: FastL1GlobalAlgo.h:121
l1extra::L1EmParticleCollection FastL1GlobalAlgo::getEgammas ( ) const
inline

Definition at line 82 of file FastL1GlobalAlgo.h.

References m_Egammas.

Referenced by FastL1CaloSim::produce().

82 { return m_Egammas; }
FastL1GlobalAlgo::m_Egammas
l1extra::L1EmParticleCollection m_Egammas
Definition: FastL1GlobalAlgo.h:123
l1extra::L1JetParticleCollection FastL1GlobalAlgo::getForJets ( ) const
inline

Definition at line 81 of file FastL1GlobalAlgo.h.

References m_ForJets.

Referenced by FastL1CaloSim::produce().

81 { return m_ForJets; }
FastL1GlobalAlgo::m_ForJets
l1extra::L1JetParticleCollection m_ForJets
Definition: FastL1GlobalAlgo.h:122
l1extra::L1EmParticleCollection FastL1GlobalAlgo::getisoEgammas ( ) const
inline

Definition at line 83 of file FastL1GlobalAlgo.h.

References m_isoEgammas.

Referenced by FastL1CaloSim::produce().

83 { return m_isoEgammas; }
FastL1GlobalAlgo::m_isoEgammas
l1extra::L1EmParticleCollection m_isoEgammas
Definition: FastL1GlobalAlgo.h:124
l1extra::L1EtMissParticleCollection FastL1GlobalAlgo::getMET ( ) const
inline

Definition at line 78 of file FastL1GlobalAlgo.h.

References m_METs.

Referenced by FastL1CaloSim::produce().

78 { return m_METs; }
FastL1GlobalAlgo::m_METs
l1extra::L1EtMissParticleCollection m_METs
Definition: FastL1GlobalAlgo.h:119
l1extra::L1JetParticleCollection FastL1GlobalAlgo::getTauJets ( ) const
inline

Definition at line 79 of file FastL1GlobalAlgo.h.

References m_TauJets.

Referenced by FastL1CaloSim::produce().

79 { return m_TauJets; }
FastL1GlobalAlgo::m_TauJets
l1extra::L1JetParticleCollection m_TauJets
Definition: FastL1GlobalAlgo.h:120
bool FastL1GlobalAlgo::greaterEt ( const reco::Candidate &  a,
const reco::Candidate &  b 
)
private
double FastL1GlobalAlgo::hcaletValue ( const int  ieta,
const int  compET 
)
private

Definition at line 1366 of file FastL1GlobalAlgo.cc.

References m_hcaluncomp.

Referenced by FillL1RegionsTP().

1366  {
1367  double etvalue = m_hcaluncomp[ieta][compET];//*cos(eta_ave);
1368  return etvalue;
1369 }
FastL1GlobalAlgo::m_hcaluncomp
double m_hcaluncomp[33][256]
Definition: FastL1GlobalAlgo.h:135
void FastL1GlobalAlgo::InitL1Regions ( )

Definition at line 511 of file FastL1GlobalAlgo.cc.

References trackerHits::c, FastL1RegionMap::getRegionEtaPhiIndex(), i, m_DoBitInfo, m_L1Config, m_Regions, m_RMap, and L1TEmulatorMonitor_cff::p.

Referenced by FillL1Regions(), and FillL1RegionsTP().

512 {
513  m_Regions.clear();
514  m_Regions = std::vector<FastL1Region>(396); // ieta: 1-22, iphi: 1-18
515 
516  // init regions
517  for (int i=0; i<396; i++) {
518  m_Regions[i].SetParameters(m_L1Config);
519  m_Regions[i].SetDoBitInfo(m_DoBitInfo);
520  std::pair<int, int> p = m_RMap->getRegionEtaPhiIndex(i);
521  m_Regions[i].SetEtaPhiIndex(p.first,p.second,i);
522  CaloTower c;
523  for (int twrid=0; twrid<16; twrid++) {
524  m_Regions[i].FillTowerZero(c,twrid);
525  }
526  }
527 }
i
int i
Definition: DBlmapReader.cc:9
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
L1TEmulatorMonitor_cff.p
tuple p
Definition: L1TEmulatorMonitor_cff.py:48
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
FastL1RegionMap::getRegionEtaPhiIndex
std::pair< int, int > getRegionEtaPhiIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:62
int FastL1GlobalAlgo::isEMCand ( CaloTowerDetId  cid,
l1extra::L1EmParticle *  p,
const edm::Event &  e 
)
private

Definition at line 932 of file FastL1GlobalAlgo.cc.

References trackerHits::c, funct::cos(), L1Config::EMLSB, L1Config::EMSeedEnThreshold, funct::exp(), GCTEnergyTrunc(), FastL1RegionMap::getRegionCenterEtaPhi(), FastL1RegionMap::getRegionIndex(), FastL1RegionMap::getRegionTowerIndex(), FastL1RegionMap::GetTowerEastEtaPhi(), FastL1RegionMap::GetTowerNEEtaPhi(), FastL1RegionMap::GetTowerNorthEtaPhi(), FastL1RegionMap::GetTowerNWEtaPhi(), FastL1RegionMap::GetTowerSEEtaPhi(), FastL1RegionMap::GetTowerSouthEtaPhi(), FastL1RegionMap::GetTowerSWEtaPhi(), FastL1RegionMap::GetTowerWestEtaPhi(), CaloTowerDetId::ieta(), CaloTowerDetId::iphi(), m_L1Config, m_Regions, m_RMap, max(), python.Vispa.Plugins.EdmBrowser.EdmDataAccessor::ne(), L1Config::QuietRegionThreshold, funct::sin(), and L1Config::TowerEBThreshold.

Referenced by FillEgammas(), and FillEgammasTP().

932  {
933 
934  // center tower
935  int crgn = m_RMap->getRegionIndex(cid);
936  int ctwr = m_RMap->getRegionTowerIndex(cid);
937 
938  // crystals only in barrel/endcap part
939  if ((crgn%22)<4 || (crgn%22)>17) return 0;
940  if (crgn>395 || crgn < 0 || ctwr > 15 || ctwr < 0) return 0;
941 
942  CaloTowerCollection c = m_Regions.at(crgn).GetCaloTowers();
943  double cenEt = c[ctwr].et();
944  //double cenEt = RCTEnergyTrunc(c[ctwr].et(),0.5,64);
945  //double cenE = c[ctwr].emEnergy();
946 
947  // Using region position rather than tower position
948  std::pair<double, double> crpos = m_RMap->getRegionCenterEtaPhi(crgn);
949  //double cenEta = c[ctwr].eta();
950  //double cenPhi = c[ctwr].phi();
951  double cenEta = crpos.first;
952  double cenPhi = crpos.second;
953 
954  double cenFGbit = m_Regions.at(crgn).GetFGBit(ctwr);
955  double cenHOEbit = m_Regions.at(crgn).GetHOEBit(ctwr);
956 
957  if (cenEt<m_L1Config.TowerEBThreshold) return 0;
958 
959  // check fine grain bit
960  if (cenFGbit) return 0;
961 
962  // check H/E bit
963  if (cenHOEbit) return 0;
964 
965  // check neighbours
966  std::pair<int, int> no = m_RMap->GetTowerNorthEtaPhi(cid.ieta(),cid.iphi());
967  std::pair<int, int> so = m_RMap->GetTowerSouthEtaPhi(cid.ieta(),cid.iphi());
968  std::pair<int, int> we = m_RMap->GetTowerWestEtaPhi(cid.ieta(),cid.iphi());
969  std::pair<int, int> ea = m_RMap->GetTowerEastEtaPhi(cid.ieta(),cid.iphi());
970  std::pair<int, int> nw = m_RMap->GetTowerNWEtaPhi(cid.ieta(),cid.iphi());
971  std::pair<int, int> ne = m_RMap->GetTowerNEEtaPhi(cid.ieta(),cid.iphi());
972  std::pair<int, int> sw = m_RMap->GetTowerSWEtaPhi(cid.ieta(),cid.iphi());
973  std::pair<int, int> se = m_RMap->GetTowerSEEtaPhi(cid.ieta(),cid.iphi());
974  if (no.first>29 || no.first<-29 || no.second>72 || no.second<0) return 0;
975  if (so.first>29 || so.first<-29 || so.second>72 || so.second<0) return 0;
976  if (we.first>29 || we.first<-29 || we.second>72 || we.second<0) return 0;
977  if (ea.first>29 || ea.first<-29 || ea.second>72 || ea.second<0) return 0;
978  if (nw.first>29 || nw.first<-29 || nw.second>72 || nw.second<0) return 0;
979  if (ne.first>29 || ne.first<-29 || ne.second>72 || ne.second<0) return 0;
980  if (sw.first>29 || sw.first<-29 || sw.second>72 || sw.second<0) return 0;
981  if (se.first>29 || se.first<-29 || se.second>72 || se.second<0) return 0;
982 
983  int notwr = m_RMap->getRegionTowerIndex(no);
984  int norgn = m_RMap->getRegionIndex(no.first,no.second);
985  int sotwr = m_RMap->getRegionTowerIndex(so);
986  int sorgn = m_RMap->getRegionIndex(so.first,so.second);
987  int wetwr = m_RMap->getRegionTowerIndex(we);
988  int wergn = m_RMap->getRegionIndex(we.first,we.second);
989  int eatwr = m_RMap->getRegionTowerIndex(ea);
990  int eargn = m_RMap->getRegionIndex(ea.first,ea.second);
991  int setwr = m_RMap->getRegionTowerIndex(se);
992  int sergn = m_RMap->getRegionIndex(se.first,sw.second);
993  int swtwr = m_RMap->getRegionTowerIndex(sw);
994  int swrgn = m_RMap->getRegionIndex(sw.first,sw.second);
995  int netwr = m_RMap->getRegionTowerIndex(ne);
996  int nergn = m_RMap->getRegionIndex(ne.first,ne.second);
997  int nwtwr = m_RMap->getRegionTowerIndex(nw);
998  int nwrgn = m_RMap->getRegionIndex(nw.first,nw.second);
999 
1000  //
1001  if (norgn>395 || norgn < 0 || notwr > 15 || notwr < 0) return 0;
1002  c = m_Regions[norgn].GetCaloTowers();
1003  double noEt = c[notwr].et();
1004  //double noEt = RCTEnergyTrunc(c[notwr].et(),0.5,64);
1005  //double noE = c[notwr].emEnergy();
1006  // check fine grain bit
1007  bool noFGbit = m_Regions[norgn].GetFGBit(notwr);
1008  // check H/E bit
1009  bool noHOEbit = m_Regions[norgn].GetHOEBit(notwr);
1010 
1011  //
1012  if (sorgn>395 || sorgn < 0 || sotwr > 15 || sotwr < 0) return 0;
1013  c = m_Regions[sorgn].GetCaloTowers();
1014  double soEt = c[sotwr].et();
1015  //double soEt = RCTEnergyTrunc(c[sotwr].et(),0.5,64);
1016  //double soE = c[sotwr].emEnergy();
1017  // check fine grain bit
1018  bool soFGbit = m_Regions[sorgn].GetFGBit(sotwr);
1019  // check H/E bit
1020  bool soHOEbit = m_Regions[sorgn].GetHOEBit(sotwr);
1021 
1022  //
1023  if (wergn>395 || wergn < 0 || wetwr > 15 || wetwr < 0) return 0;
1024  c = m_Regions[wergn].GetCaloTowers();
1025  double weEt = c[wetwr].et();
1026  //double weEt = RCTEnergyTrunc(c[wetwr].et(),0.5,64);
1027  //double weE = c[wetwr].emEnergy();
1028  // check fine grain bit
1029  bool weFGbit = m_Regions[wergn].GetFGBit(wetwr);
1030  // check H/E bit
1031  bool weHOEbit = m_Regions[wergn].GetHOEBit(wetwr);
1032 
1033  //
1034  if (eargn>395 || eargn < 0 || eatwr > 15 || eatwr < 0) return 0;
1035  c = m_Regions[eargn].GetCaloTowers();
1036  double eaEt = c[eatwr].et();
1037  //double eaEt = RCTEnergyTrunc(c[eatwr].et(),0.5,64);
1038  //double eaE = c[eatwr].emEnergy();
1039  // check fine grain bit
1040  bool eaFGbit = m_Regions[eargn].GetFGBit(eatwr);
1041  // check H/E bit
1042  bool eaHOEbit = m_Regions[eargn].GetHOEBit(eatwr);
1043 
1044  //
1045  if (nwrgn>395 || nwrgn < 0 || nwtwr > 15 || nwtwr < 0) return 0;
1046  c = m_Regions[nwrgn].GetCaloTowers();
1047  double nwEt = c[nwtwr].et();
1048  //double nwEt = RCTEnergyTrunc(c[nwtwr].et(),0.5,64);
1049  //double nwE = c[nwtwr].emEnergy();
1050  // check fine grain bit
1051  bool nwFGbit = m_Regions[nwrgn].GetFGBit(nwtwr);
1052  // check H/E bit
1053  bool nwHOEbit = m_Regions[nwrgn].GetHOEBit(nwtwr);
1054 
1055  //
1056  if (nergn>395 || nergn < 0 || netwr > 15 || netwr < 0) return 0;
1057  c = m_Regions[nergn].GetCaloTowers();
1058  double neEt = c[netwr].et();
1059  //double neEt = RCTEnergyTrunc(c[netwr].et(),0.5,64);
1060  //double neE = c[netwr].emEnergy();
1061  // check fine grain bit
1062  bool neFGbit = m_Regions[nergn].GetFGBit(netwr);
1063  // check H/E bit
1064  bool neHOEbit = m_Regions[nergn].GetHOEBit(netwr);
1065 
1066  //
1067  if (swrgn>395 || swrgn < 0 || swtwr > 15 || swtwr < 0) return 0;
1068  c = m_Regions[swrgn].GetCaloTowers();
1069  double swEt = c[swtwr].et();
1070  //double swEt = RCTEnergyTrunc(c[swtwr].et(),0.5,64);
1071  //double swE = c[swtwr].emEnergy();
1072  // check fine grain bit
1073  bool swFGbit = m_Regions[swrgn].GetFGBit(swtwr);
1074  // check H/E bit
1075  bool swHOEbit = m_Regions[swrgn].GetHOEBit(swtwr);
1076 
1077  //
1078  if (sergn>395 || sergn < 0 || setwr > 15 || setwr < 0) return 0;
1079  c = m_Regions[sergn].GetCaloTowers();
1080  double seEt = c[setwr].et();
1081  //double seEt = RCTEnergyTrunc(c[setwr].et(),0.5,64);
1082  //double seE = c[setwr].emEnergy();
1083  // check fine grain bit
1084  bool seFGbit = m_Regions[sergn].GetFGBit(setwr);
1085  // check H/E bit
1086  bool seHOEbit = m_Regions[sergn].GetHOEBit(setwr);
1087 
1088 
1089  // check if highest et tower
1090  bool isHit = false;
1091  if ( cenEt > noEt && cenEt >= soEt && cenEt > weEt &&
1092  cenEt >= eaEt && cenEt > nwEt && cenEt > neEt &&
1093  cenEt >= swEt && cenEt >= seEt ) isHit = true;
1094  else
1095  return 0;
1096 
1097  // find highest neighbour
1098  double hitEt = cenEt;
1099  //double hitE = cenE;
1100  double maxEt = std::max(noEt,std::max(soEt,std::max(weEt,eaEt)));
1101  //double maxE = std::max(noE,std::max(soE,std::max(weE,eaE)));
1102 
1103  // check 2 tower Et
1104  float emEtThres = m_L1Config.EMSeedEnThreshold;
1105 
1106  // at this point candidate is at least non-iso Egamma
1107  //double eme = (hitE+maxE);
1108  //double eme = (hitE+maxE);
1109  double emet = (hitEt+maxEt);
1110 
1111  /*
1112  if (m_L1Config.DoEMCorr) {
1113  emet = GCTEnergyTrunc(corrEmEt(emet,cenEta),m_L1Config.EMLSB, true);
1114  //emet = GCTEnergyTrunc(emet,m_L1Config.EMLSB, true);
1115  } else {
1116  emet = GCTEnergyTrunc(emet,m_L1Config.EMLSB, true);
1117  }
1118  */
1119  emet = GCTEnergyTrunc(emet,m_L1Config.EMLSB, true);
1120 
1121  if ((emet)<emEtThres) return 0;
1122 
1123  double emtheta = 2.*atan(exp(-cenEta));
1124  //double emet = eme*sin(emtheta);
1125  double emex = emet*cos(cenPhi);
1126  double emey = emet*sin(cenPhi);
1127  //double emex = eme*sin(emtheta)*cos(cenPhi);
1128  //double emey = eme*sin(emtheta)*sin(cenPhi);
1129  double eme = emex/sin(emtheta)/cos(cenPhi);
1130  double emez = eme*cos(emtheta);
1131 
1132 
1133  reco::Particle::LorentzVector rp4(emex,emey,emez,eme);
1134  //reco::Particle::Point rp3(0.,0.,0.);
1135  //reco::Particle::Charge q(0);
1136  //*ph = reco::Photon(q,rp4,rp3);
1137  *ph = l1extra::L1EmParticle(rp4);
1138  //ph = l1extra::L1EmParticle(rp4);
1139 
1140  //std::cout<<"EM eme : "<<eme<<std::endl;
1141  //std::cout<<"EM rp4.et(): "<<rp4.Et()<<std::endl;
1142  //std::cout<<"EM ph->et() : "<<ph->et()<<std::endl;
1143 
1144  //if (emet>0.) {
1145  // std::cout << "em region et, eta, phi: "<< emet<<" "<< cenEta<<" "<< cenPhi<<" " << std::endl;
1146  // std::cout << "em lv et, eta, phi: "<< ph->et()<<" "<< ph->eta()<<" "<< ph->phi()<<" " << std::endl;
1147  //}
1148 
1149  // check isolation FG bits
1150  if (noFGbit || soFGbit || weFGbit || eaFGbit ||
1151  nwFGbit || neFGbit || swFGbit || seFGbit ||
1152  noHOEbit || soHOEbit || weHOEbit || eaHOEbit ||
1153  nwHOEbit || neHOEbit || swHOEbit || seHOEbit)
1154  return 1;
1155 
1156  // check isolation corners
1157  //double corThres = 0.4;
1158  //double quietThres = m_L1Config.EMNoiseLevel;
1159  double quietThres = m_L1Config.QuietRegionThreshold;
1160  bool isoVeto1 = false,isoVeto2 = false,isoVeto3 = false,isoVeto4 = false;
1161  if (swEt>quietThres || weEt>quietThres || nwEt>quietThres || noEt>quietThres || neEt>quietThres ) {
1162  //if ((swEt + weEt + nwEt + noEt + neEt)/cenEt > corThres)
1163  isoVeto1 = true;
1164  }
1165  if (neEt>quietThres || eaEt>quietThres || seEt>quietThres || soEt>quietThres || swEt>quietThres ) {
1166  //if ((neEt + eaEt + seEt + soEt + swEt)/cenEt > corThres)
1167  isoVeto2 = true;
1168  }
1169  if (nwEt>quietThres || noEt>quietThres || neEt>quietThres || eaEt>quietThres || seEt>quietThres ) {
1170  //if ((nwEt + noEt + neEt + eaEt + seEt)/cenEt > corThres)
1171  isoVeto3 = true;
1172  }
1173  if (seEt>quietThres || soEt>quietThres || swEt>quietThres || weEt>quietThres || nwEt>quietThres ) {
1174  //if ((seEt + soEt + swEt + weEt + nwEt)/cenEt > corThres)
1175  isoVeto4 = true;
1176  }
1177  if (isoVeto1 && isoVeto2 && isoVeto3 && isoVeto4)
1178  return 1;
1179 
1180  return 2;
1181 }
FastL1RegionMap::GetTowerNEEtaPhi
std::pair< int, int > GetTowerNEEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:395
FastL1RegionMap::GetTowerNWEtaPhi
std::pair< int, int > GetTowerNWEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:380
FastL1RegionMap::GetTowerSEEtaPhi
std::pair< int, int > GetTowerSEEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:427
L1Config::QuietRegionThreshold
double QuietRegionThreshold
Definition: FastL1Region.h:70
FastL1RegionMap::getRegionIndex
int getRegionIndex(int ieta, int iphi)
Definition: FastL1RegionMap.cc:213
FastL1RegionMap::getRegionCenterEtaPhi
std::pair< double, double > getRegionCenterEtaPhi(int iRgn)
Definition: FastL1RegionMap.cc:252
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
FastL1RegionMap::getRegionTowerIndex
int getRegionTowerIndex(std::pair< int, int > iEtaPhi)
Definition: FastL1RegionMap.cc:175
FastL1RegionMap::GetTowerSWEtaPhi
std::pair< int, int > GetTowerSWEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:412
funct::exp
Exp< T >::type exp(const T &t)
Definition: Exp.h:22
FastL1RegionMap::GetTowerWestEtaPhi
std::pair< int, int > GetTowerWestEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:358
FastL1RegionMap::GetTowerSouthEtaPhi
std::pair< int, int > GetTowerSouthEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:349
max
const T & max(const T &a, const T &b)
Definition: MaterialBudgetTrackerHistos.cc:4
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
CaloTowerDetId::iphi
int iphi() const
get the tower iphi
Definition: CaloTowerDetId.cc:33
GCTEnergyTrunc
double GCTEnergyTrunc(double et, double LSB=1., bool doEM=false)
Definition: FastL1Region.cc:1041
FastL1RegionMap::GetTowerNorthEtaPhi
std::pair< int, int > GetTowerNorthEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:340
L1Config::EMLSB
double EMLSB
Definition: FastL1Region.h:77
L1Config::EMSeedEnThreshold
double EMSeedEnThreshold
Definition: FastL1Region.h:58
FastL1RegionMap::GetTowerEastEtaPhi
std::pair< int, int > GetTowerEastEtaPhi(int ieta, int iphi)
Definition: FastL1RegionMap.cc:369
FastL1GlobalAlgo::m_RMap
FastL1RegionMap * m_RMap
Definition: FastL1GlobalAlgo.h:128
CaloTowerDetId::ieta
int ieta() const
get the tower ieta
Definition: CaloTowerDetId.h:32
L1Config::TowerEBThreshold
double TowerEBThreshold
Definition: FastL1Region.h:80
reco::Particle::LorentzVector
math::XYZTLorentzVector LorentzVector
Lorentz vector.
Definition: Particle.h:26
bool FastL1GlobalAlgo::isMaxEtRgn_Window33 ( int  rgnid)
private

Definition at line 1186 of file FastL1GlobalAlgo.cc.

References m_Regions, and evf::utils::sid.

Referenced by findJets().

1186  {
1187 
1188  int nwid = m_Regions.at(crgn).GetNWId();
1189  int nid = m_Regions.at(crgn).GetNorthId();
1190  int neid = m_Regions.at(crgn).GetNEId();
1191  int wid = m_Regions.at(crgn).GetWestId();
1192  int eid = m_Regions.at(crgn).GetEastId();
1193  int swid = m_Regions.at(crgn).GetSWId();
1194  int sid = m_Regions.at(crgn).GetSouthId();
1195  int seid = m_Regions.at(crgn).GetSEId();
1196 
1197 
1198  //Use 3x2 window at eta borders!
1199  // east border:
1200  if ((crgn%22)==21) {
1201 
1202  if (nwid==999 || nid==999 || swid==999 || sid==999 || wid==999 ) {
1203  return false;
1204  }
1205 
1206  double cenet = m_Regions.at(crgn).SumEt();
1207  double nwet = m_Regions[nwid].SumEt();
1208  double noet = m_Regions[nid].SumEt();
1209  double weet = m_Regions[wid].SumEt();
1210  double swet = m_Regions[swid].SumEt();
1211  double soet = m_Regions[sid].SumEt();
1212 
1213  if ( cenet > nwet && cenet > noet &&
1214  cenet >= weet && cenet >= soet &&
1215  cenet >= swet )
1216  {
1217 
1218  double cene = m_Regions.at(crgn).SumE();
1219  double nwe = m_Regions[nwid].SumE();
1220  double noe = m_Regions[nid].SumE();
1221  double wee = m_Regions[wid].SumE();
1222  double swe = m_Regions[swid].SumE();
1223  double soe = m_Regions[sid].SumE();
1224 
1225  // if region is central: jet energy is sum of 3x3 region
1226  // surrounding the central region
1227  double jE = cene + nwe + noe + wee + swe + soe;
1228  double jEt = cenet + nwet + noet + weet + swet + soet;
1229 
1230 
1231  m_Regions.at(crgn).SetJetE(jE);
1232  m_Regions.at(crgn).SetJetEt(jEt);
1233 
1234  m_Regions.at(crgn).SetJetE3x3(cene);
1235  m_Regions.at(crgn).SetJetEt3x3(cenet);
1236 
1237  return true;
1238  } else { return false; }
1239 
1240  }
1241 
1242 
1243  // west border:
1244  if ((crgn%22)==0) {
1245 
1246  if (neid==999 || nid==999 || seid==999 || sid==999 || eid==999 ) {
1247  return false;
1248  }
1249 
1250  double cenet = m_Regions.at(crgn).SumEt();
1251  double neet = m_Regions[neid].SumEt();
1252  double noet = m_Regions[nid].SumEt();
1253  double eaet = m_Regions[eid].SumEt();
1254  double seet = m_Regions[seid].SumEt();
1255  double soet = m_Regions[sid].SumEt();
1256 
1257  if ( cenet > neet && cenet > noet &&
1258  cenet >= eaet && cenet >= soet &&
1259  cenet >= seet )
1260  {
1261 
1262  double cene = m_Regions.at(crgn).SumE();
1263  double nee = m_Regions[neid].SumE();
1264  double noe = m_Regions[nid].SumE();
1265  double eae = m_Regions[eid].SumE();
1266  double see = m_Regions[seid].SumE();
1267  double soe = m_Regions[sid].SumE();
1268 
1269  // if region is central: jet energy is sum of 3x3 region
1270  // surrounding the central region
1271  double jE = cene + nee + noe + eae + see + soe;
1272  double jEt = cenet + neet + noet + eaet + seet + soet;
1273 
1274  m_Regions.at(crgn).SetJetE(jE);
1275  m_Regions.at(crgn).SetJetEt(jEt);
1276 
1277  m_Regions.at(crgn).SetJetE3x3(cene);
1278  m_Regions.at(crgn).SetJetEt3x3(cenet);
1279 
1280  return true;
1281  } else { return false; }
1282 
1283  }
1284 
1285 
1286  if (nwid==999 || neid==999 || nid==999 || swid==999 || seid==999 || sid==999 || wid==999 ||
1287  eid==999 ) {
1288  //std::cerr << "FastL1GlobalAlgo::isMaxEtRgn_Window33(): RegionId out of bounds: " << std::endl
1289  // << nwid << " " << nid << " " << neid << " " << std::endl
1290  // << wid << " " << crgn << " " << eid << " " << std::endl
1291  // << swid << " " << sid << " " << seid << " " << std::endl;
1292  return false;
1293  }
1294 
1295 
1296  double cenet = m_Regions.at(crgn).SumEt();
1297  double nwet = m_Regions[nwid].SumEt();
1298  double noet = m_Regions[nid].SumEt();
1299  double neet = m_Regions[neid].SumEt();
1300  double weet = m_Regions[wid].SumEt();
1301  double eaet = m_Regions[eid].SumEt();
1302  double swet = m_Regions[swid].SumEt();
1303  double soet = m_Regions[sid].SumEt();
1304  double seet = m_Regions[seid].SumEt();
1305 
1306  if ( cenet > nwet && cenet > noet &&
1307  cenet > neet && cenet >= eaet &&
1308  cenet > weet && cenet >= soet &&
1309  cenet >= swet && cenet >= seet )
1310  {
1311 
1312  double cene = m_Regions.at(crgn).SumE();
1313  double nwe = m_Regions[nwid].SumE();
1314  double noe = m_Regions[nid].SumE();
1315  double nee = m_Regions[neid].SumE();
1316  double wee = m_Regions[wid].SumE();
1317  double eae = m_Regions[eid].SumE();
1318  double swe = m_Regions[swid].SumE();
1319  double soe = m_Regions[sid].SumE();
1320  double see = m_Regions[seid].SumE();
1321 
1322  // if region is central: jet energy is sum of 3x3 region
1323  // surrounding the central region
1324  double jE = cene + nwe + noe + nee + wee + eae + swe + soe + see;
1325  double jEt = cenet + nwet + noet + neet + weet + eaet + swet + soet + seet;
1326 
1327 
1328  m_Regions.at(crgn).SetJetE(jE);
1329  m_Regions.at(crgn).SetJetEt(jEt);
1330 
1331  m_Regions.at(crgn).SetJetE3x3(cene);
1332  m_Regions.at(crgn).SetJetEt3x3(cenet);
1333 
1334  return true;
1335  } else { return false; }
1336 
1337 }
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
bool FastL1GlobalAlgo::isTauJet ( int  rgnid)
private

Definition at line 843 of file FastL1GlobalAlgo.cc.

References m_DoBitInfo, m_Regions, and evf::utils::sid.

Referenced by findJets().

843  {
844 
845  // Barrel and Endcap only
846  if ((cRgn%22)<4 || (cRgn%22)>17)
847  return false;
848 
849  int shower_shape = 0;
850  int et_isolation = 0;
851 
852  if (m_Regions[cRgn].GetTauBit()) {
853  shower_shape = 1;
854  //if (m_DoBitInfo) m_Regions[cRgn].BitInfo.setTauVeto(true);
855  } else {
856  shower_shape = 0;
857  //if (m_DoBitInfo) m_Regions[cRgn].BitInfo.setTauVeto(false);
858  }
859 
860  int nwid = m_Regions[cRgn].GetNWId();
861  int nid = m_Regions[cRgn].GetNorthId();
862  int neid = m_Regions[cRgn].GetNEId();
863  int wid = m_Regions[cRgn].GetWestId();
864  int eid = m_Regions[cRgn].GetEastId();
865  int swid = m_Regions[cRgn].GetSWId();
866  int sid = m_Regions[cRgn].GetSouthId();
867  int seid = m_Regions[cRgn].GetSEId();
868 
869  //Use 3x2 window at eta borders!
870  // west border:
871  if ((cRgn%22)==4) {
872  if (m_Regions[nid].GetTauBit() ||
873  m_Regions[neid].GetTauBit() ||
874  m_Regions[eid].GetTauBit() ||
875  m_Regions[seid].GetTauBit() ||
876  m_Regions[sid].GetTauBit() ) {
877  et_isolation = 1;
878  }
879  }
880 
881  // east border:
882  if ((cRgn%22)==17) {
883  if (m_Regions[nid].GetTauBit() ||
884  m_Regions[nwid].GetTauBit() ||
885  m_Regions[wid].GetTauBit() ||
886  m_Regions[swid].GetTauBit() ||
887  m_Regions[sid].GetTauBit() ) {
888  et_isolation = 1;
889  }
890  }
891 
892  if ( (cRgn%22)>4 && (cRgn%22)<17){ // non-border
893  if (nwid==999 || neid==999 || nid==999 || swid==999 || seid==999 || sid==999 || wid==999 ||
894  eid==999 ) {
895  return false;
896  }
897 
898  if (m_Regions[nwid].GetTauBit() ||
899  m_Regions[nid].GetTauBit() ||
900  m_Regions[neid].GetTauBit() ||
901  m_Regions[wid].GetTauBit() ||
902  m_Regions[eid].GetTauBit() ||
903  m_Regions[swid].GetTauBit() ||
904  m_Regions[seid].GetTauBit() ||
905  m_Regions[sid].GetTauBit() ) {
906  et_isolation = 1;
907  }
908  } // non-border
909 
910  if (m_DoBitInfo) {
911  if (et_isolation == 1) {
912  //std::cout<<"*********************************"<<std::endl;
913  //std::cout<<"Rgn iso veto: "<<et_isolation<<std::endl;
914  m_Regions[cRgn].BitInfo.setIsolationVeto(true);
915  } else {
916  m_Regions[cRgn].BitInfo.setIsolationVeto(false);
917  }
918  // if (shower_shape == 1) {
919  //std::cout<<"###############################"<<std::endl;
920  //std::cout<<"Rgn shower veto: "<<shower_shape<<std::endl;
921  //}
922  }
923 
924  if (et_isolation == 1 || shower_shape == 1) return false;
925  else return true;
926 
927 }
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127
bool FastL1GlobalAlgo::TauIsolation ( int  rgnid)
private

Definition at line 1373 of file FastL1GlobalAlgo.cc.

References m_DoBitInfo, m_IsolationEt, m_Regions, and evf::utils::sid.

Referenced by findJets().

1373  {
1374 
1375  if ((cRgn%22)<4 || (cRgn%22)>17) return false;
1376 
1377  double iso_threshold = m_IsolationEt; // arbitrarily set
1378  int shower_shape = 0;
1379  int et_isolation = 0;
1380  unsigned int iso_count = 0;
1381 
1382  int nwid = m_Regions[cRgn].GetNWId();
1383  int nid = m_Regions[cRgn].GetNorthId();
1384  int neid = m_Regions[cRgn].GetNEId();
1385  int wid = m_Regions[cRgn].GetWestId();
1386  int eid = m_Regions[cRgn].GetEastId();
1387  int swid = m_Regions[cRgn].GetSWId();
1388  int sid = m_Regions[cRgn].GetSouthId();
1389  int seid = m_Regions[cRgn].GetSEId();
1390 
1391  if (m_Regions[cRgn].GetTauBit()) { // check center
1392  shower_shape = 1;
1393  //if (m_DoBitInfo) m_Regions[cRgn].BitInfo.setTauVeto(true);
1394  }
1395 
1396  if((cRgn%22)==4 || (cRgn%22)==17 ) {
1397  // west border
1398  if ((cRgn%22)==4) {
1399  if( m_Regions[neid].SumEt() > iso_threshold){
1400  iso_count ++;
1401  if (m_Regions[neid].GetTauBit()) iso_count++;
1402  }
1403  if( m_Regions[nid].SumEt() > iso_threshold){
1404  iso_count ++;
1405  if (m_Regions[nid].GetTauBit()) iso_count++;
1406  }
1407  if( m_Regions[eid].SumEt() > iso_threshold){
1408  iso_count ++;
1409  if (m_Regions[eid].GetTauBit()) iso_count++;
1410  }
1411  if( m_Regions[seid].SumEt() > iso_threshold){
1412  iso_count ++;
1413  if (m_Regions[seid].GetTauBit()) iso_count++;
1414  }
1415  if( m_Regions[sid].SumEt() > iso_threshold){
1416  iso_count ++;
1417  if (m_Regions[sid].GetTauBit()) iso_count++;
1418  }
1419  } // west bd
1420 
1421  // east border:
1422  if ((cRgn%22)==17) {
1423  if( m_Regions[nwid].SumEt() > iso_threshold){
1424  iso_count ++;
1425  if (m_Regions[nwid].GetTauBit()) iso_count++;
1426  }
1427  if( m_Regions[nid].SumEt() > iso_threshold){
1428  iso_count ++;
1429  if (m_Regions[nid].GetTauBit()) iso_count++;
1430  }
1431  if( m_Regions[wid].SumEt() > iso_threshold){
1432  iso_count ++;
1433  if (m_Regions[wid].GetTauBit()) iso_count++;
1434  }
1435  if( m_Regions[swid].SumEt() > iso_threshold){
1436  iso_count ++;
1437  if (m_Regions[swid].GetTauBit()) iso_count++;
1438  }
1439  if( m_Regions[sid].SumEt() > iso_threshold){
1440  iso_count ++;
1441  if (m_Regions[sid].GetTauBit()) iso_count++;
1442  }
1443  } // east bd
1444 
1445  }
1446 
1447  if ( (cRgn%22)>4 && (cRgn%22)<17){ // non-border
1448  if (nwid==999 || neid==999 || nid==999 || swid==999 || seid==999 || sid==999 || wid==999 ||
1449  eid==999 ) {
1450  return false;
1451  }
1452 
1453  if( m_Regions[neid].SumEt() > iso_threshold){
1454  iso_count ++;
1455  if (m_Regions[neid].GetTauBit()) iso_count++;
1456  }
1457  if( m_Regions[nid].SumEt() > iso_threshold){
1458  iso_count ++;
1459  if (m_Regions[nid].GetTauBit()) iso_count++;
1460  }
1461  if( m_Regions[eid].SumEt() > iso_threshold){
1462  iso_count ++;
1463  if (m_Regions[eid].GetTauBit()) iso_count++;
1464  }
1465  if( m_Regions[seid].SumEt() > iso_threshold){
1466  iso_count ++;
1467  if (m_Regions[seid].GetTauBit()) iso_count++;
1468  }
1469  if( m_Regions[sid].SumEt() > iso_threshold){
1470  iso_count ++;
1471  if (m_Regions[sid].GetTauBit()) iso_count++;
1472  }
1473  if( m_Regions[nwid].SumEt() > iso_threshold){
1474  iso_count ++;
1475  if (m_Regions[nwid].GetTauBit()) iso_count++;
1476  }
1477  if( m_Regions[wid].SumEt() > iso_threshold){
1478  iso_count ++;
1479  if (m_Regions[wid].GetTauBit()) iso_count++;
1480  }
1481  if( m_Regions[swid].SumEt() > iso_threshold){
1482  iso_count ++;
1483  if (m_Regions[swid].GetTauBit()) iso_count++;
1484  }
1485  }// non-border
1486 
1487 
1488  if (iso_count >= 2 ){
1489  et_isolation = 1;
1490  }
1491  else {
1492  et_isolation = 0;
1493  }
1494 
1495  if (m_DoBitInfo){
1496  if (et_isolation == 1)
1497  m_Regions[cRgn].BitInfo.setIsolationVeto (true);
1498  else
1499  m_Regions[cRgn].BitInfo.setIsolationVeto (false);
1500  }
1501 
1502  if (et_isolation == 1 || shower_shape == 1) return false;
1503  else return true;
1504 
1505 }//
FastL1GlobalAlgo::m_Regions
std::vector< FastL1Region > m_Regions
Definition: FastL1GlobalAlgo.h:127

Member Data Documentation

FastL1BitInfoCollection FastL1GlobalAlgo::m_BitInfos
private

Definition at line 125 of file FastL1GlobalAlgo.h.

Referenced by FillBitInfos(), and getBitInfos().

l1extra::L1JetParticleCollection FastL1GlobalAlgo::m_CenJets
private

Definition at line 121 of file FastL1GlobalAlgo.h.

Referenced by addJet(), findJets(), and getCenJets().

bool FastL1GlobalAlgo::m_DoBitInfo
private

Definition at line 129 of file FastL1GlobalAlgo.h.

Referenced by addJet(), FastL1GlobalAlgo(), FillBitInfos(), findJets(), InitL1Regions(), isTauJet(), and TauIsolation().

l1extra::L1EmParticleCollection FastL1GlobalAlgo::m_Egammas
private

Definition at line 123 of file FastL1GlobalAlgo.h.

Referenced by FillEgammas(), FillEgammasTP(), and getEgammas().

l1extra::L1JetParticleCollection FastL1GlobalAlgo::m_ForJets
private

Definition at line 122 of file FastL1GlobalAlgo.h.

Referenced by addJet(), findJets(), and getForJets().

bool FastL1GlobalAlgo::m_GctIso
private

Definition at line 131 of file FastL1GlobalAlgo.h.

Referenced by FastL1GlobalAlgo(), and findJets().

double FastL1GlobalAlgo::m_hcaluncomp[33][256]
private

Definition at line 135 of file FastL1GlobalAlgo.h.

Referenced by FastL1GlobalAlgo(), and hcaletValue().

l1extra::L1EmParticleCollection FastL1GlobalAlgo::m_isoEgammas
private

Definition at line 124 of file FastL1GlobalAlgo.h.

Referenced by FillEgammas(), FillEgammasTP(), and getisoEgammas().

double FastL1GlobalAlgo::m_IsolationEt
private

Definition at line 132 of file FastL1GlobalAlgo.h.

Referenced by FastL1GlobalAlgo(), and TauIsolation().

L1Config FastL1GlobalAlgo::m_L1Config
private

Definition at line 134 of file FastL1GlobalAlgo.h.

Referenced by addJet(), CaloTowersDump(), FastL1GlobalAlgo(), FillEgammas(), FillL1Regions(), FillL1RegionsTP(), FillMET(), findJets(), InitL1Regions(), and isEMCand().

l1extra::L1EtMissParticleCollection FastL1GlobalAlgo::m_METs
private

Definition at line 119 of file FastL1GlobalAlgo.h.

Referenced by FillMET(), and getMET().

std::vector<FastL1Region> FastL1GlobalAlgo::m_Regions
private

Definition at line 127 of file FastL1GlobalAlgo.h.

Referenced by addJet(), FastL1GlobalAlgo(), FillBitInfos(), FillEgammasTP(), FillL1Regions(), FillL1RegionsTP(), FillMET(), findJets(), GetCaloRegions(), InitL1Regions(), isEMCand(), isMaxEtRgn_Window33(), isTauJet(), and TauIsolation().

FastL1RegionMap* FastL1GlobalAlgo::m_RMap
private

Definition at line 128 of file FastL1GlobalAlgo.h.

Referenced by addJet(), checkMapping(), FastL1GlobalAlgo(), FillL1Regions(), FillL1RegionsTP(), FillMET(), findJets(), InitL1Regions(), and isEMCand().

l1extra::L1JetParticleCollection FastL1GlobalAlgo::m_TauJets
private

Definition at line 120 of file FastL1GlobalAlgo.h.

Referenced by addJet(), findJets(), and getTauJets().

Generated for CMSSW Reference Manual by doxygen 1.8.5