CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Public Attributes | Private Types | Private Member Functions | Private Attributes
CaloTowersCreationAlgo Class Reference

#include <CaloTowersCreationAlgo.h>

Classes

struct  MetaTower
 

Public Member Functions

void begin ()
 
 CaloTowersCreationAlgo ()
 
 CaloTowersCreationAlgo (double EBthreshold, double EEthreshold, bool useEtEBTreshold, bool useEtEETreshold, bool useSymEBTreshold, bool useSymEETreshold, double HcalThreshold, double HBthreshold, double HBthreshold1, double HBthreshold2, double HESthreshold, double HESthreshold1, double HEDthreshold, double HEDthreshold1, double HOthreshold0, double HOthresholdPlus1, double HOthresholdMinus1, double HOthresholdPlus2, double HOthresholdMinus2, double HF1threshold, double HF2threshold, double EBweight, double EEweight, double HBweight, double HESweight, double HEDweight, double HOweight, double HF1weight, double HF2weight, double EcutTower, double EBSumThreshold, double EESumThreshold, bool useHO, int momConstrMethod, double momHBDepth, double momHEDepth, double momEBDepth, double momEEDepth, int hcalPhase=0)
 
 CaloTowersCreationAlgo (double EBthreshold, double EEthreshold, bool useEtEBTreshold, bool useEtEETreshold, bool useSymEBTreshold, bool useSymEETreshold, double HcalThreshold, double HBthreshold, double HBthreshold1, double HBthreshold2, double HESthreshold, double HESthreshold1, double HEDthreshold, double HEDthreshold1, double HOthreshold0, double HOthresholdPlus1, double HOthresholdMinus1, double HOthresholdPlus2, double HOthresholdMinus2, double HF1threshold, double HF2threshold, const std::vector< double > &EBGrid, const std::vector< double > &EBWeights, const std::vector< double > &EEGrid, const std::vector< double > &EEWeights, const std::vector< double > &HBGrid, const std::vector< double > &HBWeights, const std::vector< double > &HESGrid, const std::vector< double > &HESWeights, const std::vector< double > &HEDGrid, const std::vector< double > &HEDWeights, const std::vector< double > &HOGrid, const std::vector< double > &HOWeights, const std::vector< double > &HF1Grid, const std::vector< double > &HF1Weights, const std::vector< double > &HF2Grid, const std::vector< double > &HF2Weights, double EBweight, double EEweight, double HBweight, double HESweight, double HEDweight, double HOweight, double HF1weight, double HF2weight, double EcutTower, double EBSumThreshold, double EESumThreshold, bool useHO, int momConstrMethod, double momHBDepth, double momHEDepth, double momEBDepth, double momEEDepth, int hcalPhase=0)
 
std::tuple< unsigned int, bool > ecalChanStatusForCaloTower (const EcalRecHit *hit)
 
GlobalPoint emCrystalShwrPos (DetId detId, float fracDepth)
 
GlobalPoint emShwrLogWeightPos (const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double totEmE)
 
GlobalPoint emShwrPos (const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double totEmE)
 
void finish (CaloTowerCollection &destCollection)
 
GlobalPoint hadSegmentShwrPos (DetId detId, float fracDepth)
 
GlobalPoint hadShwPosFromCells (DetId frontCell, DetId backCell, float fracDepth)
 
GlobalPoint hadShwrPos (const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double hadE)
 
GlobalPoint hadShwrPos (CaloTowerDetId id, float fracDepth)
 
unsigned int hcalChanStatusForCaloTower (const CaloRecHit *hit)
 
void makeEcalBadChs ()
 
void makeHcalDropChMap ()
 
void process (const HBHERecHitCollection &hbhe)
 
void process (const HORecHitCollection &ho)
 
void process (const HFRecHitCollection &hf)
 
void process (const EcalRecHitCollection &ecal)
 
void process (const CaloTowerCollection &ctc)
 
void rescaleTowers (const CaloTowerCollection &ctInput, CaloTowerCollection &ctResult)
 
void setEBEScale (double scale)
 
void setEbHandle (const edm::Handle< EcalRecHitCollection > eb)
 
void setEcalChStatusFromDB (const EcalChannelStatus *s)
 
void setEcalSeveritiesToBeExcluded (const std::vector< int > &ecalSev)
 
void SetEcalSeveritiesToBeUsedInBadTowers (const std::vector< int > &ecalSev)
 
void setEcalSevLvlAlgo (const EcalSeverityLevelAlgo *a)
 
void setEEEScale (double scale)
 
void setEeHandle (const edm::Handle< EcalRecHitCollection > ee)
 
void setGeometry (const CaloTowerTopology *cttopo, const CaloTowerConstituentsMap *ctmap, const HcalTopology *htopo, const CaloGeometry *geo)
 
void setHBEScale (double scale)
 
void setHcalAcceptSeverityLevel (unsigned int level)
 
void setHcalAcceptSeverityLevelForRejectedHit (unsigned int level)
 
void setHcalChStatusFromDB (const HcalChannelQuality *s)
 
void setHcalSevLvlComputer (const HcalSeverityLevelComputer *c)
 
void setHEDEScale (double scale)
 
void setHESEScale (double scale)
 
void setHF1EScale (double scale)
 
void setHF2EScale (double scale)
 
void setHOEScale (double scale)
 
void setMissingHcalRescaleFactorForEcal (float factor)
 
void setRecoveredEcalHitsAreUsed (bool flag)
 
void setRecoveredHcalHitsAreUsed (bool flag)
 
void setThresFromDB (const EcalPFRecHitThresholds *EcalCuts, const HcalPFCuts *HcalCuts)
 
void setUseRejectedHitsOnly (bool flag)
 
void setUseRejectedRecoveredEcalHits (bool flag)
 
void setUseRejectedRecoveredHcalHits (bool flag)
 

Public Attributes

int nalgo = -1
 

Private Types

enum  ctHitCategory {
  GoodChan = 0, BadChan = 1, RecoveredChan = 2, ProblematicChan = 3,
  IgnoredChan = 99
}
 
typedef std::map< CaloTowerDetId, std::pair< short int, bool > > HcalDropChMap
 
typedef std::vector< MetaTower > MetaTowerMap
 

Private Member Functions

void assignHitEcal (const EcalRecHit *recHit)
 adds a single hit to the tower More...
 
void assignHitHcal (const CaloRecHit *recHit)
 
int compactTime (float time)
 
void convert (const CaloTowerDetId &id, const MetaTower &mt, CaloTowerCollection &collection)
 
MetaTower & find (const CaloTowerDetId &id)
 looks for a given tower in the internal cache. If it can't find it, it makes it. More...
 
void getThresholdAndWeight (const DetId &detId, double &threshold, double &weight) const
 helper method to look up the appropriate threshold & weight More...
 
void rescale (const CaloTower *ct)
 

Private Attributes

std::vector< unsigned short > ecalBadChs
 
const EcalPFRecHitThresholds * ecalCuts
 
const HcalPFCuts * hcalCuts
 
HcalDropChMap hcalDropChMap
 
std::vector< HcalDetId > ids_
 
float missingHcalRescaleFactorForEcal
 
double theEBEScale
 
std::vector< double > theEBGrid
 
edm::Handle< EcalRecHitCollection > theEbHandle
 
double theEBSumThreshold
 
double theEBthreshold
 
double theEBweight
 
std::vector< double > theEBWeights
 
const EcalChannelStatus * theEcalChStatus
 
std::vector< int > theEcalSeveritiesToBeExcluded
 
std::vector< int > theEcalSeveritiesToBeUsedInBadTowers
 
const EcalSeverityLevelAlgo * theEcalSevLvlAlgo
 
double theEcutTower
 
double theEEEScale
 
std::vector< double > theEEGrid
 
edm::Handle< EcalRecHitCollection > theEeHandle
 
double theEESumThreshold
 
double theEEthreshold
 
double theEEweight
 
std::vector< double > theEEWeights
 
const CaloGeometry * theGeometry
 
double theHBEScale
 
std::vector< double > theHBGrid
 
double theHBthreshold
 
double theHBthreshold1
 
double theHBthreshold2
 
double theHBweight
 
std::vector< double > theHBWeights
 
unsigned int theHcalAcceptSeverityLevel
 
unsigned int theHcalAcceptSeverityLevelForRejectedHit
 
const HcalChannelQuality * theHcalChStatus
 
int theHcalPhase
 
const HcalSeverityLevelComputer * theHcalSevLvlComputer
 
double theHcalThreshold
 
const HcalTopology * theHcalTopology
 
double theHEDEScale
 
std::vector< double > theHEDGrid
 
double theHEDthreshold
 
double theHEDthreshold1
 
double theHEDweight
 
std::vector< double > theHEDWeights
 
double theHESEScale
 
std::vector< double > theHESGrid
 
double theHESthreshold
 
double theHESthreshold1
 
double theHESweight
 
std::vector< double > theHESWeights
 
double theHF1EScale
 
std::vector< double > theHF1Grid
 
double theHF1threshold
 
double theHF1weight
 
std::vector< double > theHF1Weights
 
double theHF2EScale
 
std::vector< double > theHF2Grid
 
double theHF2threshold
 
double theHF2weight
 
std::vector< double > theHF2Weights
 
double theHOEScale
 
std::vector< double > theHOGrid
 
bool theHOIsUsed
 only affects energy and ET calculation. HO is still recorded in the tower More...
 
double theHOthreshold0
 
double theHOthresholdMinus1
 
double theHOthresholdMinus2
 
double theHOthresholdPlus1
 
double theHOthresholdPlus2
 
double theHOweight
 
std::vector< double > theHOWeights
 
int theMomConstrMethod
 
double theMomEBDepth
 
double theMomEEDepth
 
double theMomHBDepth
 
double theMomHEDepth
 
bool theRecoveredEcalHitsAreUsed
 
bool theRecoveredHcalHitsAreUsed
 
const CaloTowerConstituentsMap * theTowerConstituentsMap
 
const CaloSubdetectorGeometry * theTowerGeometry
 
MetaTowerMap theTowerMap
 
unsigned int theTowerMapSize = 0
 
const CaloTowerTopology * theTowerTopology
 
bool theUseEtEBTresholdFlag
 
bool theUseEtEETresholdFlag
 
bool theUseSymEBTresholdFlag
 
bool theUseSymEETresholdFlag
 
bool useRejectedHitsOnly
 
unsigned int useRejectedRecoveredEcalHits
 
unsigned int useRejectedRecoveredHcalHits
 

Detailed Description

Author
R. Wilkinson - Caltech

Definition at line 54 of file CaloTowersCreationAlgo.h.

Member Typedef Documentation

◆ HcalDropChMap

typedef std::map<CaloTowerDetId, std::pair<short int, bool> > CaloTowersCreationAlgo::HcalDropChMap
private

Definition at line 389 of file CaloTowersCreationAlgo.h.

◆ MetaTowerMap

typedef std::vector<MetaTower> CaloTowersCreationAlgo::MetaTowerMap
private

Definition at line 383 of file CaloTowersCreationAlgo.h.

Member Enumeration Documentation

◆ ctHitCategory

enum CaloTowersCreationAlgo::ctHitCategory
private
Enumerator
GoodChan 
BadChan 
RecoveredChan 
ProblematicChan 
IgnoredChan 

Definition at line 399 of file CaloTowersCreationAlgo.h.

399 { GoodChan = 0, BadChan = 1, RecoveredChan = 2, ProblematicChan = 3, IgnoredChan = 99 };

Constructor & Destructor Documentation

◆ CaloTowersCreationAlgo() [1/3]

CaloTowersCreationAlgo::CaloTowersCreationAlgo ( )

Definition at line 16 of file CaloTowersCreationAlgo.cc.

17  : theEBthreshold(-1000.),
18  theEEthreshold(-1000.),
19 
20  theUseEtEBTresholdFlag(false),
21  theUseEtEETresholdFlag(false),
22  theUseSymEBTresholdFlag(false),
23  theUseSymEETresholdFlag(false),
24 
25  theHcalThreshold(-1000.),
26  theHBthreshold(-1000.),
27  theHBthreshold1(-1000.),
28  theHBthreshold2(-1000.),
29  theHESthreshold(-1000.),
30  theHESthreshold1(-1000.),
31  theHEDthreshold(-1000.),
32  theHEDthreshold1(-1000.),
33  theHOthreshold0(-1000.),
34  theHOthresholdPlus1(-1000.),
35  theHOthresholdMinus1(-1000.),
36  theHOthresholdPlus2(-1000.),
37  theHOthresholdMinus2(-1000.),
38  theHF1threshold(-1000.),
39  theHF2threshold(-1000.),
40  theEBGrid(std::vector<double>(5, 10.)),
41  theEBWeights(std::vector<double>(5, 1.)),
42  theEEGrid(std::vector<double>(5, 10.)),
43  theEEWeights(std::vector<double>(5, 1.)),
44  theHBGrid(std::vector<double>(5, 10.)),
45  theHBWeights(std::vector<double>(5, 1.)),
46  theHESGrid(std::vector<double>(5, 10.)),
47  theHESWeights(std::vector<double>(5, 1.)),
48  theHEDGrid(std::vector<double>(5, 10.)),
49  theHEDWeights(std::vector<double>(5, 1.)),
50  theHOGrid(std::vector<double>(5, 10.)),
51  theHOWeights(std::vector<double>(5, 1.)),
52  theHF1Grid(std::vector<double>(5, 10.)),
53  theHF1Weights(std::vector<double>(5, 1.)),
54  theHF2Grid(std::vector<double>(5, 10.)),
55  theHF2Weights(std::vector<double>(5, 1.)),
56  theEBweight(1.),
57  theEEweight(1.),
58  theHBweight(1.),
59  theHESweight(1.),
60  theHEDweight(1.),
61  theHOweight(1.),
62  theHF1weight(1.),
63  theHF2weight(1.),
64  theEcutTower(-1000.),
65  theEBSumThreshold(-1000.),
66  theEESumThreshold(-1000.),
67  theEBEScale(50.),
68  theEEEScale(50.),
69  theHBEScale(50.),
70  theHESEScale(50.),
71  theHEDEScale(50.),
72  theHOEScale(50.),
73  theHF1EScale(50.),
74  theHF2EScale(50.),
75  theHcalTopology(nullptr),
76  theGeometry(nullptr),
77  theTowerConstituentsMap(nullptr),
78  theHcalAcceptSeverityLevel(0),
79  theRecoveredHcalHitsAreUsed(false),
80  theRecoveredEcalHitsAreUsed(false),
81  useRejectedHitsOnly(false),
82  theHcalAcceptSeverityLevelForRejectedHit(0),
83  useRejectedRecoveredHcalHits(0),
84  useRejectedRecoveredEcalHits(0),
85  missingHcalRescaleFactorForEcal(0.),
86  theHOIsUsed(true),
87  // (for momentum reconstruction algorithm)
88  theMomConstrMethod(0),
89  theMomHBDepth(0.),
90  theMomHEDepth(0.),
91  theMomEBDepth(0.),
92  theMomEEDepth(0.),
93  theHcalPhase(0) {}
CaloTowersCreationAlgo::theHBGrid
std::vector< double > theHBGrid
Definition: CaloTowersCreationAlgo.h:309
CaloTowersCreationAlgo::theHESGrid
std::vector< double > theHESGrid
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHEDGrid
std::vector< double > theHEDGrid
Definition: CaloTowersCreationAlgo.h:311
CaloTowersCreationAlgo::theHOWeights
std::vector< double > theHOWeights
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theEEGrid
std::vector< double > theEEGrid
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theEEWeights
std::vector< double > theEEWeights
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theHESWeights
std::vector< double > theHESWeights
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHF2Grid
std::vector< double > theHF2Grid
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHEDWeights
std::vector< double > theHEDWeights
Definition: CaloTowersCreationAlgo.h:311
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
CaloTowersCreationAlgo::theHOGrid
std::vector< double > theHOGrid
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theHF1Weights
std::vector< double > theHF1Weights
Definition: CaloTowersCreationAlgo.h:313
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
CaloTowersCreationAlgo::theHBWeights
std::vector< double > theHBWeights
Definition: CaloTowersCreationAlgo.h:309
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
CaloTowersCreationAlgo::theHF1Grid
std::vector< double > theHF1Grid
Definition: CaloTowersCreationAlgo.h:313
CaloTowersCreationAlgo::theEBGrid
std::vector< double > theEBGrid
Definition: CaloTowersCreationAlgo.h:307
CaloTowersCreationAlgo::theHF2Weights
std::vector< double > theHF2Weights
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
unsigned int theHcalAcceptSeverityLevelForRejectedHit
Definition: CaloTowersCreationAlgo.h:357
CaloTowersCreationAlgo::theEBWeights
std::vector< double > theEBWeights
Definition: CaloTowersCreationAlgo.h:307

◆ CaloTowersCreationAlgo() [2/3]

CaloTowersCreationAlgo::CaloTowersCreationAlgo ( double  EBthreshold,
double  EEthreshold,
bool  useEtEBTreshold,
bool  useEtEETreshold,
bool  useSymEBTreshold,
bool  useSymEETreshold,
double  HcalThreshold,
double  HBthreshold,
double  HBthreshold1,
double  HBthreshold2,
double  HESthreshold,
double  HESthreshold1,
double  HEDthreshold,
double  HEDthreshold1,
double  HOthreshold0,
double  HOthresholdPlus1,
double  HOthresholdMinus1,
double  HOthresholdPlus2,
double  HOthresholdMinus2,
double  HF1threshold,
double  HF2threshold,
double  EBweight,
double  EEweight,
double  HBweight,
double  HESweight,
double  HEDweight,
double  HOweight,
double  HF1weight,
double  HF2weight,
double  EcutTower,
double  EBSumThreshold,
double  EESumThreshold,
bool  useHO,
int  momConstrMethod,
double  momHBDepth,
double  momHEDepth,
double  momEBDepth,
double  momEEDepth,
int  hcalPhase = 0 
)

Definition at line 95 of file CaloTowersCreationAlgo.cc.

138  : theEBthreshold(EBthreshold),
139  theEEthreshold(EEthreshold),
140 
141  theUseEtEBTresholdFlag(useEtEBTreshold),
142  theUseEtEETresholdFlag(useEtEETreshold),
143  theUseSymEBTresholdFlag(useSymEBTreshold),
144  theUseSymEETresholdFlag(useSymEETreshold),
145 
146  theHcalThreshold(HcalThreshold),
147  theHBthreshold(HBthreshold),
148  theHBthreshold1(HBthreshold1),
149  theHBthreshold2(HBthreshold2),
150  theHESthreshold(HESthreshold),
151  theHESthreshold1(HESthreshold1),
152  theHEDthreshold(HEDthreshold),
153  theHEDthreshold1(HEDthreshold1),
154  theHOthreshold0(HOthreshold0),
155  theHOthresholdPlus1(HOthresholdPlus1),
156  theHOthresholdMinus1(HOthresholdMinus1),
157  theHOthresholdPlus2(HOthresholdPlus2),
158  theHOthresholdMinus2(HOthresholdMinus2),
159  theHF1threshold(HF1threshold),
160  theHF2threshold(HF2threshold),
161  theEBGrid(std::vector<double>(5, 10.)),
162  theEBWeights(std::vector<double>(5, 1.)),
163  theEEGrid(std::vector<double>(5, 10.)),
164  theEEWeights(std::vector<double>(5, 1.)),
165  theHBGrid(std::vector<double>(5, 10.)),
166  theHBWeights(std::vector<double>(5, 1.)),
167  theHESGrid(std::vector<double>(5, 10.)),
168  theHESWeights(std::vector<double>(5, 1.)),
169  theHEDGrid(std::vector<double>(5, 10.)),
170  theHEDWeights(std::vector<double>(5, 1.)),
171  theHOGrid(std::vector<double>(5, 10.)),
172  theHOWeights(std::vector<double>(5, 1.)),
173  theHF1Grid(std::vector<double>(5, 10.)),
174  theHF1Weights(std::vector<double>(5, 1.)),
175  theHF2Grid(std::vector<double>(5, 10.)),
176  theHF2Weights(std::vector<double>(5, 1.)),
177  theEBweight(EBweight),
178  theEEweight(EEweight),
179  theHBweight(HBweight),
180  theHESweight(HESweight),
181  theHEDweight(HEDweight),
182  theHOweight(HOweight),
183  theHF1weight(HF1weight),
184  theHF2weight(HF2weight),
185  theEcutTower(EcutTower),
186  theEBSumThreshold(EBSumThreshold),
187  theEESumThreshold(EESumThreshold),
188  theEBEScale(50.),
189  theEEEScale(50.),
190  theHBEScale(50.),
191  theHESEScale(50.),
192  theHEDEScale(50.),
193  theHOEScale(50.),
194  theHF1EScale(50.),
195  theHF2EScale(50.),
196  theHcalTopology(nullptr),
197  theGeometry(nullptr),
198  theTowerConstituentsMap(nullptr),
199  theHcalAcceptSeverityLevel(0),
200  theRecoveredHcalHitsAreUsed(false),
201  theRecoveredEcalHitsAreUsed(false),
202  useRejectedHitsOnly(false),
203  theHcalAcceptSeverityLevelForRejectedHit(0),
204  useRejectedRecoveredHcalHits(0),
205  useRejectedRecoveredEcalHits(0),
206  missingHcalRescaleFactorForEcal(0.),
207  theHOIsUsed(useHO),
208  // (momentum reconstruction algorithm)
209  theMomConstrMethod(momConstrMethod),
210  theMomHBDepth(momHBDepth),
211  theMomHEDepth(momHEDepth),
212  theMomEBDepth(momEBDepth),
213  theMomEEDepth(momEEDepth),
214  theHcalPhase(hcalPhase) {}
CaloTowersCreationAlgo::theHBGrid
std::vector< double > theHBGrid
Definition: CaloTowersCreationAlgo.h:309
HLT_2024v14_cff.useHO
useHO
Definition: HLT_2024v14_cff.py:9302
CaloTowersCreationAlgo::theHESGrid
std::vector< double > theHESGrid
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHEDGrid
std::vector< double > theHEDGrid
Definition: CaloTowersCreationAlgo.h:311
CaloTowersCreationAlgo::theHOWeights
std::vector< double > theHOWeights
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theEEGrid
std::vector< double > theEEGrid
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theEEWeights
std::vector< double > theEEWeights
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theHESWeights
std::vector< double > theHESWeights
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHF2Grid
std::vector< double > theHF2Grid
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHEDWeights
std::vector< double > theHEDWeights
Definition: CaloTowersCreationAlgo.h:311
HLT_2024v14_cff.EESumThreshold
EESumThreshold
Definition: HLT_2024v14_cff.py:7133
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
CaloTowersCreationAlgo::theHOGrid
std::vector< double > theHOGrid
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theHF1Weights
std::vector< double > theHF1Weights
Definition: CaloTowersCreationAlgo.h:313
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
CaloTowersCreationAlgo::theHBWeights
std::vector< double > theHBWeights
Definition: CaloTowersCreationAlgo.h:309
HLT_2024v14_cff.EBSumThreshold
EBSumThreshold
Definition: HLT_2024v14_cff.py:7129
HLT_2024v14_cff.HcalThreshold
HcalThreshold
Definition: HLT_2024v14_cff.py:7166
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
HLT_2024v14_cff.EcutTower
EcutTower
Definition: HLT_2024v14_cff.py:7176
CaloTowersCreationAlgo::theHF1Grid
std::vector< double > theHF1Grid
Definition: CaloTowersCreationAlgo.h:313
CaloTowersCreationAlgo::theEBGrid
std::vector< double > theEBGrid
Definition: CaloTowersCreationAlgo.h:307
CaloTowersCreationAlgo::theHF2Weights
std::vector< double > theHF2Weights
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
unsigned int theHcalAcceptSeverityLevelForRejectedHit
Definition: CaloTowersCreationAlgo.h:357
CaloTowersCreationAlgo::theEBWeights
std::vector< double > theEBWeights
Definition: CaloTowersCreationAlgo.h:307

◆ CaloTowersCreationAlgo() [3/3]

CaloTowersCreationAlgo::CaloTowersCreationAlgo ( double  EBthreshold,
double  EEthreshold,
bool  useEtEBTreshold,
bool  useEtEETreshold,
bool  useSymEBTreshold,
bool  useSymEETreshold,
double  HcalThreshold,
double  HBthreshold,
double  HBthreshold1,
double  HBthreshold2,
double  HESthreshold,
double  HESthreshold1,
double  HEDthreshold,
double  HEDthreshold1,
double  HOthreshold0,
double  HOthresholdPlus1,
double  HOthresholdMinus1,
double  HOthresholdPlus2,
double  HOthresholdMinus2,
double  HF1threshold,
double  HF2threshold,
const std::vector< double > &  EBGrid,
const std::vector< double > &  EBWeights,
const std::vector< double > &  EEGrid,
const std::vector< double > &  EEWeights,
const std::vector< double > &  HBGrid,
const std::vector< double > &  HBWeights,
const std::vector< double > &  HESGrid,
const std::vector< double > &  HESWeights,
const std::vector< double > &  HEDGrid,
const std::vector< double > &  HEDWeights,
const std::vector< double > &  HOGrid,
const std::vector< double > &  HOWeights,
const std::vector< double > &  HF1Grid,
const std::vector< double > &  HF1Weights,
const std::vector< double > &  HF2Grid,
const std::vector< double > &  HF2Weights,
double  EBweight,
double  EEweight,
double  HBweight,
double  HESweight,
double  HEDweight,
double  HOweight,
double  HF1weight,
double  HF2weight,
double  EcutTower,
double  EBSumThreshold,
double  EESumThreshold,
bool  useHO,
int  momConstrMethod,
double  momHBDepth,
double  momHEDepth,
double  momEBDepth,
double  momEEDepth,
int  hcalPhase = 0 
)

Definition at line 216 of file CaloTowersCreationAlgo.cc.

274  : theEBthreshold(EBthreshold),
275  theEEthreshold(EEthreshold),
276 
277  theUseEtEBTresholdFlag(useEtEBTreshold),
278  theUseEtEETresholdFlag(useEtEETreshold),
279  theUseSymEBTresholdFlag(useSymEBTreshold),
280  theUseSymEETresholdFlag(useSymEETreshold),
281 
282  theHcalThreshold(HcalThreshold),
283  theHBthreshold(HBthreshold),
284  theHBthreshold1(HBthreshold1),
285  theHBthreshold2(HBthreshold2),
286  theHESthreshold(HESthreshold),
287  theHESthreshold1(HESthreshold1),
288  theHEDthreshold(HEDthreshold),
289  theHEDthreshold1(HEDthreshold1),
290  theHOthreshold0(HOthreshold0),
291  theHOthresholdPlus1(HOthresholdPlus1),
292  theHOthresholdMinus1(HOthresholdMinus1),
293  theHOthresholdPlus2(HOthresholdPlus2),
294  theHOthresholdMinus2(HOthresholdMinus2),
295  theHF1threshold(HF1threshold),
296  theHF2threshold(HF2threshold),
297  theEBGrid(EBGrid),
298  theEBWeights(EBWeights),
299  theEEGrid(EEGrid),
300  theEEWeights(EEWeights),
301  theHBGrid(HBGrid),
302  theHBWeights(HBWeights),
303  theHESGrid(HESGrid),
304  theHESWeights(HESWeights),
305  theHEDGrid(HEDGrid),
306  theHEDWeights(HEDWeights),
307  theHOGrid(HOGrid),
308  theHOWeights(HOWeights),
309  theHF1Grid(HF1Grid),
310  theHF1Weights(HF1Weights),
311  theHF2Grid(HF2Grid),
312  theHF2Weights(HF2Weights),
313  theEBweight(EBweight),
314  theEEweight(EEweight),
315  theHBweight(HBweight),
316  theHESweight(HESweight),
317  theHEDweight(HEDweight),
318  theHOweight(HOweight),
319  theHF1weight(HF1weight),
320  theHF2weight(HF2weight),
321  theEcutTower(EcutTower),
322  theEBSumThreshold(EBSumThreshold),
323  theEESumThreshold(EESumThreshold),
324  theEBEScale(50.),
325  theEEEScale(50.),
326  theHBEScale(50.),
327  theHESEScale(50.),
328  theHEDEScale(50.),
329  theHOEScale(50.),
330  theHF1EScale(50.),
331  theHF2EScale(50.),
332  theHcalTopology(nullptr),
333  theGeometry(nullptr),
334  theTowerConstituentsMap(nullptr),
335  theHcalAcceptSeverityLevel(0),
336  theRecoveredHcalHitsAreUsed(false),
337  theRecoveredEcalHitsAreUsed(false),
338  useRejectedHitsOnly(false),
339  theHcalAcceptSeverityLevelForRejectedHit(0),
340  useRejectedRecoveredHcalHits(0),
341  useRejectedRecoveredEcalHits(0),
342  missingHcalRescaleFactorForEcal(0.),
343  theHOIsUsed(useHO),
344  // (momentum reconstruction algorithm)
345  theMomConstrMethod(momConstrMethod),
346  theMomHBDepth(momHBDepth),
347  theMomHEDepth(momHEDepth),
348  theMomEBDepth(momEBDepth),
349  theMomEEDepth(momEEDepth),
350  theHcalPhase(hcalPhase) {
351  // static int N = 0;
352  // std::cout << "VI Algo " << ++N << std::endl;
353  // nalgo=N;
354 }
CaloTowersCreationAlgo::theHBGrid
std::vector< double > theHBGrid
Definition: CaloTowersCreationAlgo.h:309
HLT_2024v14_cff.useHO
useHO
Definition: HLT_2024v14_cff.py:9302
HLT_2024v14_cff.HF2Weights
HF2Weights
Definition: HLT_2024v14_cff.py:7145
CaloTowersCreationAlgo::theHESGrid
std::vector< double > theHESGrid
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHEDGrid
std::vector< double > theHEDGrid
Definition: CaloTowersCreationAlgo.h:311
CaloTowersCreationAlgo::theHOWeights
std::vector< double > theHOWeights
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theEEGrid
std::vector< double > theEEGrid
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theEEWeights
std::vector< double > theEEWeights
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theHESWeights
std::vector< double > theHESWeights
Definition: CaloTowersCreationAlgo.h:310
HLT_2024v14_cff.HOGrid
HOGrid
Definition: HLT_2024v14_cff.py:7180
CaloTowersCreationAlgo::theHF2Grid
std::vector< double > theHF2Grid
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHEDWeights
std::vector< double > theHEDWeights
Definition: CaloTowersCreationAlgo.h:311
HLT_2024v14_cff.EBWeights
EBWeights
Definition: HLT_2024v14_cff.py:7157
HLT_2024v14_cff.EESumThreshold
EESumThreshold
Definition: HLT_2024v14_cff.py:7133
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
HLT_2024v14_cff.HOWeights
HOWeights
Definition: HLT_2024v14_cff.py:7146
CaloTowersCreationAlgo::theHOGrid
std::vector< double > theHOGrid
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theHF1Weights
std::vector< double > theHF1Weights
Definition: CaloTowersCreationAlgo.h:313
HLT_2024v14_cff.HESGrid
HESGrid
Definition: HLT_2024v14_cff.py:7172
HLT_2024v14_cff.EEWeights
EEWeights
Definition: HLT_2024v14_cff.py:7143
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
HLT_2024v14_cff.HEDGrid
HEDGrid
Definition: HLT_2024v14_cff.py:7177
CaloTowersCreationAlgo::theHBWeights
std::vector< double > theHBWeights
Definition: CaloTowersCreationAlgo.h:309
HLT_2024v14_cff.HF2Grid
HF2Grid
Definition: HLT_2024v14_cff.py:7154
HLT_2024v14_cff.EBSumThreshold
EBSumThreshold
Definition: HLT_2024v14_cff.py:7129
HLT_2024v14_cff.EEGrid
EEGrid
Definition: HLT_2024v14_cff.py:7147
HLT_2024v14_cff.HcalThreshold
HcalThreshold
Definition: HLT_2024v14_cff.py:7166
HLT_2024v14_cff.HF1Grid
HF1Grid
Definition: HLT_2024v14_cff.py:7156
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
HLT_2024v14_cff.HBWeights
HBWeights
Definition: HLT_2024v14_cff.py:7151
HLT_2024v14_cff.EBGrid
EBGrid
Definition: HLT_2024v14_cff.py:7181
HLT_2024v14_cff.HF1Weights
HF1Weights
Definition: HLT_2024v14_cff.py:7170
HLT_2024v14_cff.EcutTower
EcutTower
Definition: HLT_2024v14_cff.py:7176
CaloTowersCreationAlgo::theHF1Grid
std::vector< double > theHF1Grid
Definition: CaloTowersCreationAlgo.h:313
HLT_2024v14_cff.HEDWeights
HEDWeights
Definition: HLT_2024v14_cff.py:7155
CaloTowersCreationAlgo::theEBGrid
std::vector< double > theEBGrid
Definition: CaloTowersCreationAlgo.h:307
CaloTowersCreationAlgo::theHF2Weights
std::vector< double > theHF2Weights
Definition: CaloTowersCreationAlgo.h:314
HLT_2024v14_cff.HBGrid
HBGrid
Definition: HLT_2024v14_cff.py:7139
CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
unsigned int theHcalAcceptSeverityLevelForRejectedHit
Definition: CaloTowersCreationAlgo.h:357
CaloTowersCreationAlgo::theEBWeights
std::vector< double > theEBWeights
Definition: CaloTowersCreationAlgo.h:307
HLT_2024v14_cff.HESWeights
HESWeights
Definition: HLT_2024v14_cff.py:7173

Member Function Documentation

◆ assignHitEcal()

void CaloTowersCreationAlgo::assignHitEcal ( const EcalRecHit *  recHit)
private

adds a single hit to the tower

Definition at line 779 of file CaloTowersCreationAlgo.cc.

References BadChan, hcalRecHitTable_cff::detId, MillePedeFileConverter_cfg::e, EcalBarrel, ecalChanStatusForCaloTower(), EcalEndcap, hcalRecHitTable_cff::energy, PVValHelper::eta, spr::find(), find(), CaloGeometry::getGeometry(), getThresholdAndWeight(), GoodChan, IgnoredChan, CaloTowersParam_cfi::mc, DetId::null(), ProblematicChan, rpcPointValidation_cfi::recHit, RecoveredChan, EcalSeverityLevelAlgo::severityLevel(), theEcalSeveritiesToBeExcluded, theEcalSevLvlAlgo, theGeometry, theTowerConstituentsMap, theUseEtEBTresholdFlag, theUseEtEETresholdFlag, theUseSymEBTresholdFlag, theUseSymEETresholdFlag, DiMuonV_cfg::threshold, l1tHGCalTowerProducer_cfi::tower, CaloTowerConstituentsMap::towerOf(), and mps_merge::weight.

Referenced by process().

779  {
780  DetId detId = recHit->detid();
781 
782  unsigned int chStatusForCT;
783  bool ecalIsBad = false;
784  std::tie(chStatusForCT, ecalIsBad) = ecalChanStatusForCaloTower(recHit);
785 
786  // this is for skipping channls: mostly needed for the creation of
787  // bad towers from hits i the bad channel collections.
788  if (chStatusForCT == CaloTowersCreationAlgo::IgnoredChan)
789  return;
790 
791  double threshold, weight;
792  getThresholdAndWeight(detId, threshold, weight);
793 
794  double energy = recHit->energy(); // original RecHit energy is used to apply thresholds
795  double e = energy * weight; // energies scaled by user weight: used in energy assignments
796 
798 
799  // For ECAL we count all bad channels after the metatower is complete
800 
801  // Include options for symmetric thresholds and cut on Et
802  // for ECAL RecHits
803 
804  bool passEmThreshold = false;
805 
806  if (detId.subdetId() == EcalBarrel) {
807  if (theUseEtEBTresholdFlag)
808  energy /= cosh((theGeometry->getGeometry(detId)->getPosition()).eta());
809  if (theUseSymEBTresholdFlag)
810  passEmThreshold = (fabs(energy) >= threshold);
811  else
812  passEmThreshold = (energy >= threshold);
813 
814  } else if (detId.subdetId() == EcalEndcap) {
815  if (theUseEtEETresholdFlag)
816  energy /= cosh((theGeometry->getGeometry(detId)->getPosition()).eta());
817  if (theUseSymEETresholdFlag)
818  passEmThreshold = (fabs(energy) >= threshold);
819  else
820  passEmThreshold = (energy >= threshold);
821  }
822 
823  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
824  if (towerDetId.null())
825  return;
826  MetaTower& tower = find(towerDetId);
827 
828  // count bad cells and avoid double counting with those from DB (Recovered are counted bad)
829 
830  // somehow misses some
831  // if ( (chStatusForCT == CaloTowersCreationAlgo::BadChan) & (!ecalIsBad) ) ++tower.numBadEcalCells;
832 
833  // a bit slower...
834  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
835  auto thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel(detId);
836  // check if the Ecal severity is ok to keep
837  auto sevit = std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), thisEcalSevLvl);
838  if (sevit == theEcalSeveritiesToBeExcluded.end())
839  ++tower.numBadEcalCells; // notinDB
840  }
841 
842  // if (chStatusForCT != CaloTowersCreationAlgo::BadChan && energy >= threshold) {
843  if (chStatusForCT != CaloTowersCreationAlgo::BadChan && passEmThreshold) {
844  tower.E_em += e;
845  tower.E += e;
846 
847  if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
848  tower.numRecEcalCells += 1;
849  } else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
850  tower.numProbEcalCells += 1;
851  }
852 
853  // change when full status info is available
854  // for now use only good channels
855 
856  // add e>0 check (new options allow e<0)
857  if (chStatusForCT == CaloTowersCreationAlgo::GoodChan && e > 0) {
858  tower.emSumTimeTimesE += (e * recHit->time());
859  tower.emSumEForTime += e; // see above
860  }
861 
862  std::pair<DetId, float> mc(detId, e);
863  tower.metaConstituents.push_back(mc);
864  }
865 } // end of assignHitEcal method
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
CaloTowersParam_cfi.mc
mc
Definition: CaloTowersParam_cfi.py:8
CaloTowersCreationAlgo::getThresholdAndWeight
void getThresholdAndWeight(const DetId &detId, double &threshold, double &weight) const
helper method to look up the appropriate threshold & weight
Definition: CaloTowersCreationAlgo.cc:1250
CaloTowerConstituentsMap::towerOf
CaloTowerDetId towerOf(const DetId &id) const
Get the tower id for this det id (or null if not known)
Definition: CaloTowerConstituentsMap.cc:27
weight
Definition: weight.py:1
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
CaloTowersCreationAlgo::find
MetaTower & find(const CaloTowerDetId &id)
looks for a given tower in the internal cache. If it can&#39;t find it, it makes it.
Definition: CaloTowersCreationAlgo.cc:915
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
hcalRecHitTable_cff.energy
energy
Definition: hcalRecHitTable_cff.py:13
EcalSeverityLevelAlgo::severityLevel
EcalSeverityLevel::SeverityLevel severityLevel(const DetId &id) const
Evaluate status from id use channelStatus from DB.
Definition: EcalSeverityLevelAlgo.cc:85
DetId::null
constexpr bool null() const
is this a null id ?
Definition: DetId.h:59
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
CaloGeometry::getGeometry
std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id.
Definition: CaloGeometry.cc:60
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:101
DetId
Definition: DetId.h:17
CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded
std::vector< int > theEcalSeveritiesToBeExcluded
Definition: CaloTowersCreationAlgo.h:349
CaloTowersCreationAlgo::theEcalSevLvlAlgo
const EcalSeverityLevelAlgo * theEcalSevLvlAlgo
Definition: CaloTowersCreationAlgo.h:343
CaloTowersCreationAlgo::ecalChanStatusForCaloTower
std::tuple< unsigned int, bool > ecalChanStatusForCaloTower(const EcalRecHit *hit)
Definition: CaloTowersCreationAlgo.cc:1832
mps_merge.weight
weight
Definition: mps_merge.py:88
l1tHGCalTowerProducer_cfi.tower
tower
Definition: l1tHGCalTowerProducer_cfi.py:4

◆ assignHitHcal()

void CaloTowersCreationAlgo::assignHitHcal ( const CaloRecHit *  recHit)
private

Definition at line 541 of file CaloTowersCreationAlgo.cc.

References BadChan, gather_cfg::cout, HcalDetId::depth(), DetId::det(), hcalRecHitTable_cff::detId, MillePedeFileConverter_cfg::e, CaloTowersCreationAlgo::MetaTower::E, CaloTowersCreationAlgo::MetaTower::E_had, CaloTowersCreationAlgo::MetaTower::E_outer, hcalRecHitTable_cff::energy, find(), HcalTopology::getMergePositionFlag(), getThresholdAndWeight(), GoodChan, CaloTowersCreationAlgo::MetaTower::hadSumEForTime, CaloTowersCreationAlgo::MetaTower::hadSumTimeTimesE, DetId::Hcal, hcalChanStatusForCaloTower(), HcalEndcap, HcalForward, HcalOuter, HcalTopology::idFront(), CaloTowerDetId::ieta(), HcalDetId::ietaAbs(), IgnoredChan, CaloTowerDetId::iphi(), HcalTopology::lastHERing(), CaloTowersParam_cfi::mc, merge(), HcalTopology::mergedDepth29(), CaloTowersCreationAlgo::MetaTower::metaConstituents, DetId::null(), CaloTowersCreationAlgo::MetaTower::numBadHcalCells, CaloTowersCreationAlgo::MetaTower::numProbHcalCells, CaloTowersCreationAlgo::MetaTower::numRecHcalCells, ProblematicChan, rpcPointValidation_cfi::recHit, RecoveredChan, HcalDetId::subdet(), theHcalPhase, theHcalTopology, theHOIsUsed, theTowerConstituentsMap, DiMuonV_cfg::threshold, l1tHGCalTowerProducer_cfi::tower, CaloTowerConstituentsMap::towerOf(), mps_merge::weight, and CaloTowerDetId::zside().

Referenced by process().

541  {
542  DetId detId = recHit->detid();
543  DetId detIdF(detId);
544  if (detId.det() == DetId::Hcal && theHcalTopology->getMergePositionFlag()) {
545  detIdF = theHcalTopology->idFront(HcalDetId(detId));
546 #ifdef EDM_ML_DEBUG
547  std::cout << "AssignHitHcal DetId " << HcalDetId(detId) << " Front " << HcalDetId(detIdF) << std::endl;
548 #endif
549  }
550 
551  unsigned int chStatusForCT = hcalChanStatusForCaloTower(recHit);
552 
553  // this is for skipping channls: mostly needed for the creation of
554  // bad towers from hits i the bad channel collections.
555  if (chStatusForCT == CaloTowersCreationAlgo::IgnoredChan)
556  return;
557 
558  double threshold, weight;
559  getThresholdAndWeight(detId, threshold, weight);
560 
561  double energy = recHit->energy(); // original RecHit energy is used to apply thresholds
562  double e = energy * weight; // energies scaled by user weight: used in energy assignments
563 
564  // SPECIAL handling of tower 28 merged depths --> half into tower 28 and half into tower 29
565  bool merge(false);
566  if (detIdF.det() == DetId::Hcal && HcalDetId(detIdF).subdet() == HcalEndcap &&
567  (theHcalPhase == 0 || theHcalPhase == 1) &&
568  //HcalDetId(detId).depth()==3 &&
569  HcalDetId(detIdF).ietaAbs() == theHcalTopology->lastHERing() - 1) {
570  merge = theHcalTopology->mergedDepth29(HcalDetId(detIdF));
571 #ifdef EDM_ML_DEBUG
572  std::cout << "Merge " << HcalDetId(detIdF) << ":" << merge << std::endl;
573 #endif
574  }
575  if (merge) {
577 
578  // bad channels are counted regardless of energy threshold
579 
580  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
581  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
582  if (towerDetId.null())
583  return;
584  MetaTower& tower28 = find(towerDetId);
585  CaloTowerDetId towerDetId29(towerDetId.ieta() + towerDetId.zside(), towerDetId.iphi());
586  MetaTower& tower29 = find(towerDetId29);
587  tower28.numBadHcalCells += 1;
588  tower29.numBadHcalCells += 1;
589  }
590 
591  else if (0.5 * energy >= threshold) { // not bad channel: use energy if above threshold
592 
593  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
594  if (towerDetId.null())
595  return;
596  MetaTower& tower28 = find(towerDetId);
597  CaloTowerDetId towerDetId29(towerDetId.ieta() + towerDetId.zside(), towerDetId.iphi());
598  MetaTower& tower29 = find(towerDetId29);
599 
600  if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
601  tower28.numRecHcalCells += 1;
602  tower29.numRecHcalCells += 1;
603  } else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
604  tower28.numProbHcalCells += 1;
605  tower29.numProbHcalCells += 1;
606  }
607 
608  // NOTE DIVIDE BY 2!!!
609  double e28 = 0.5 * e;
610  double e29 = 0.5 * e;
611 
612  tower28.E_had += e28;
613  tower28.E += e28;
614  std::pair<DetId, float> mc(detId, e28);
615  tower28.metaConstituents.push_back(mc);
616 
617  tower29.E_had += e29;
618  tower29.E += e29;
619  tower29.metaConstituents.push_back(mc);
620 
621  // time info: do not use in averaging if timing error is found: need
622  // full set of status info to implement: use only "good" channels for now
623 
624  if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
625  tower28.hadSumTimeTimesE += (e28 * recHit->time());
626  tower28.hadSumEForTime += e28;
627  tower29.hadSumTimeTimesE += (e29 * recHit->time());
628  tower29.hadSumEForTime += e29;
629  }
630 
631  // store the energy in layer 3 also in E_outer
632  tower28.E_outer += e28;
633  tower29.E_outer += e29;
634  } // not a "bad" hit
635  } // end of special case
636 
637  else {
638  HcalDetId hcalDetId(detId);
639 
641 
642  if (hcalDetId.subdet() == HcalOuter) {
643  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
644  if (towerDetId.null())
645  return;
646  MetaTower& tower = find(towerDetId);
647 
648  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
649  if (theHOIsUsed)
650  tower.numBadHcalCells += 1;
651  }
652 
653  else if (energy >= threshold) {
654  tower.E_outer += e; // store HO energy even if HO is not used
655  // add energy of the tower and/or flag if theHOIsUsed
656  if (theHOIsUsed) {
657  tower.E += e;
658 
659  if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
660  tower.numRecHcalCells += 1;
661  } else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
662  tower.numProbHcalCells += 1;
663  }
664  } // HO is used
665 
666  // add HO to constituents even if it is not used: JetMET wants to keep these towers
667  std::pair<DetId, float> mc(detId, e);
668  tower.metaConstituents.push_back(mc);
669 
670  } // not a bad channel, energy above threshold
671 
672  } // HO hit
673 
674  // HF calculates EM fraction differently
675  else if (hcalDetId.subdet() == HcalForward) {
676  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
677  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
678  if (towerDetId.null())
679  return;
680  MetaTower& tower = find(towerDetId);
681  tower.numBadHcalCells += 1;
682  }
683 
684  else if (energy >= threshold) {
685  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
686  if (towerDetId.null())
687  return;
688  MetaTower& tower = find(towerDetId);
689 
690  if (hcalDetId.depth() == 1) {
691  // long fiber, so E_EM = E(Long) - E(Short)
692  tower.E_em += e;
693  } else {
694  // short fiber, EHAD = 2 * E(Short)
695  tower.E_em -= e;
696  tower.E_had += 2. * e;
697  }
698  tower.E += e;
699  if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
700  tower.numRecHcalCells += 1;
701  } else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
702  tower.numProbHcalCells += 1;
703  }
704 
705  // put the timing in HCAL -> have to check timing errors when available
706  // for now use only good channels
707  if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
708  tower.hadSumTimeTimesE += (e * recHit->time());
709  tower.hadSumEForTime += e;
710  }
711 
712  std::pair<DetId, float> mc(detId, e);
713  tower.metaConstituents.push_back(mc);
714 
715  } // not a bad HF channel, energy above threshold
716 
717  } // HF hit
718 
719  else {
720  // HCAL situation normal in HB/HE
721  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
722  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
723  if (towerDetId.null())
724  return;
725  MetaTower& tower = find(towerDetId);
726  tower.numBadHcalCells += 1;
727  } else if (energy >= threshold) {
728  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
729  if (towerDetId.null())
730  return;
731  MetaTower& tower = find(towerDetId);
732  tower.E_had += e;
733  tower.E += e;
734  if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
735  tower.numRecHcalCells += 1;
736  } else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
737  tower.numProbHcalCells += 1;
738  }
739 
740  // Timing information: need specific accessors
741  // for now use only good channels
742  if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
743  tower.hadSumTimeTimesE += (e * recHit->time());
744  tower.hadSumEForTime += e;
745  }
746  // store energy in highest depth for towers 18-27 (for electron,photon ID in endcap)
747  // also, store energy in HE part of tower 16 (for JetMET cleanup)
748  HcalDetId hcalDetId(detId);
749  if (hcalDetId.subdet() == HcalEndcap) {
750  if (theHcalPhase == 0) {
751  if ((hcalDetId.depth() == 2 && hcalDetId.ietaAbs() >= 18 && hcalDetId.ietaAbs() < 27) ||
752  (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 27) ||
753  (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 16)) {
754  tower.E_outer += e;
755  }
756  }
757  //combine depths in phase0-like way
758  else if (theHcalPhase == 1) {
759  if ((hcalDetId.depth() >= 3 && hcalDetId.ietaAbs() >= 18 && hcalDetId.ietaAbs() < 26) ||
760  (hcalDetId.depth() >= 4 && (hcalDetId.ietaAbs() == 26 || hcalDetId.ietaAbs() == 27)) ||
761  (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 17) ||
762  (hcalDetId.depth() == 4 && hcalDetId.ietaAbs() == 16)) {
763  tower.E_outer += e;
764  }
765  }
766  }
767 
768  std::pair<DetId, float> mc(detId, e);
769  tower.metaConstituents.push_back(mc);
770 
771  } // not a "bad" channel, energy above threshold
772 
773  } // channel in HBHE (excluding twrs 28,29)
774 
775  } // recHit normal case (not in HE towers 28,29)
776 
777 } // end of assignHitHcal method
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
CaloTowersParam_cfi.mc
mc
Definition: CaloTowersParam_cfi.py:8
HcalTopology::mergedDepth29
bool mergedDepth29(HcalDetId id) const
Definition: HcalTopology.h:108
merge
Definition: merge.py:1
HcalTopology::getMergePositionFlag
bool getMergePositionFlag() const
Definition: HcalTopology.h:164
merge
int merge(int argc, char *argv[])
Definition: DiMuonVmerge.cc:28
CaloTowersCreationAlgo::getThresholdAndWeight
void getThresholdAndWeight(const DetId &detId, double &threshold, double &weight) const
helper method to look up the appropriate threshold & weight
Definition: CaloTowersCreationAlgo.cc:1250
HcalDetId::ietaAbs
constexpr int ietaAbs() const
get the absolute value of the cell ieta
Definition: HcalDetId.h:148
CaloTowerConstituentsMap::towerOf
CaloTowerDetId towerOf(const DetId &id) const
Get the tower id for this det id (or null if not known)
Definition: CaloTowerConstituentsMap.cc:27
weight
Definition: weight.py:1
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
CaloTowersCreationAlgo::find
MetaTower & find(const CaloTowerDetId &id)
looks for a given tower in the internal cache. If it can&#39;t find it, it makes it.
Definition: CaloTowersCreationAlgo.cc:915
hcalRecHitTable_cff.energy
energy
Definition: hcalRecHitTable_cff.py:13
DetId::null
constexpr bool null() const
is this a null id ?
Definition: DetId.h:59
HcalDetId::subdet
constexpr HcalSubdetector subdet() const
get the subdetector
Definition: HcalDetId.h:138
CaloTowersCreationAlgo::hcalChanStatusForCaloTower
unsigned int hcalChanStatusForCaloTower(const CaloRecHit *hit)
Definition: CaloTowersCreationAlgo.cc:1781
HcalTopology::idFront
HcalDetId idFront(const HcalDetId &id) const
Definition: HcalTopology.h:167
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:101
DetId
Definition: DetId.h:17
CaloTowerDetId::iphi
int iphi() const
get the tower iphi
Definition: CaloTowerDetId.cc:30
CaloTowerDetId::ieta
int ieta() const
get the tower ieta
Definition: CaloTowerDetId.h:30
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
CaloTowerDetId::zside
int zside() const
get the z-side of the tower (1/-1)
Definition: CaloTowerDetId.h:26
HcalTopology::lastHERing
int lastHERing() const
Definition: HcalTopology.h:91
gather_cfg.cout
cout
Definition: gather_cfg.py:144
mps_merge.weight
weight
Definition: mps_merge.py:88
l1tHGCalTowerProducer_cfi.tower
tower
Definition: l1tHGCalTowerProducer_cfi.py:4

◆ begin()

void CaloTowersCreationAlgo::begin ( void  )

Definition at line 375 of file CaloTowersCreationAlgo.cc.

References theTowerMap, and theTowerMapSize.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

375  {
376  theTowerMap.clear();
377  theTowerMapSize = 0;
378  //hcalDropChMap.clear();
379 }

◆ compactTime()

int CaloTowersCreationAlgo::compactTime ( float  time)
private

Definition at line 1662 of file CaloTowersCreationAlgo.cc.

References createfilelist::int, and hcalRecHitTable_cff::time.

Referenced by convert().

1662  {
1663  const float timeUnit = 0.01; // discretization (ns)
1664 
1665  if (time > 300.0)
1666  return 30000;
1667  if (time < -300.0)
1668  return -30000;
1669 
1670  return int(time / timeUnit + 0.5);
1671 }
hcalRecHitTable_cff.time
time
Definition: hcalRecHitTable_cff.py:14

◆ convert()

void CaloTowersCreationAlgo::convert ( const CaloTowerDetId &  id,
const MetaTower &  mt,
CaloTowerCollection &  collection 
)
private

if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*sumPf, emPoint.eta(), emPoint.phi(), 0);

Definition at line 931 of file CaloTowersCreationAlgo.cc.

References cms::cuda::assert(), PV3DBase< T, PVType, FrameType >::basicVector(), universalConfigTemplate::collection, compactTime(), edm::contains(), CaloTowerTopology::denseIndex(), change_name::diff, DetId::Ecal, ecalBadChs, digitizers_cfi::ecalTime, emShwrLogWeightPos(), emShwrPos(), PV3DBase< T, PVType, FrameType >::eta(), CaloTowerTopology::firstHFRing(), CaloSubdetectorGeometry::getGeometry(), hadShwrPos(), DetId::Hcal, hcalDropChMap, HcalOuter, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::ietaAbs(), ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), CaloTowerTopology::lastHBRing(), CaloTowerTopology::lastHERing(), CaloTowerTopology::lastHFRing(), CaloTowerTopology::lastHORing(), match(), Basic3DVector< T >::mathVector(), missingHcalRescaleFactorForEcal, eostools::move(), TtSemiLepEvtBuilder_cfi::mt, AlCaHLTBitMon_ParallelJobs::p, PV3DBase< T, PVType, FrameType >::phi(), nano_mu_digi_cff::rawId, edm::second(), mathSSE::sqrt(), HcalDetId::subdet(), theEBSumThreshold, theEcutTower, theEESumThreshold, theHcalThreshold, theHOIsUsed, theMomConstrMethod, theMomEBDepth, theMomEEDepth, theMomHBDepth, theMomHEDepth, theTowerGeometry, theTowerTopology, Basic3DVector< T >::unit(), UNLIKELY, heppy_batch::val, and trackerHitRTTI::vector.

Referenced by finish().

931  {
932  assert(id.rawId() != 0);
933 
934  double ecalThres = (id.ietaAbs() <= 17) ? (theEBSumThreshold) : (theEESumThreshold);
935  double E = mt.E;
936  double E_em = mt.E_em;
937  double E_had = mt.E_had;
938  double E_outer = mt.E_outer;
939 
940  // Note: E_outer is used to save HO energy OR energy in the outermost depths in endcap region
941  // In the methods with separate treatment of EM and HAD components:
942  // - HO is not used to determine direction, however HO energy is added to get "total had energy"
943  // => Check if the tower is within HO coverage before adding E_outer to the "total had" energy
944  // else the energy will be double counted
945  // When summing up the energy of the tower these checks are performed in the loops over RecHits
946 
947  std::vector<std::pair<DetId, float> > metaContains = mt.metaConstituents;
948  if (id.ietaAbs() < theTowerTopology->firstHFRing() && E_em < ecalThres) { // ignore EM threshold in HF
949  E -= E_em;
950  E_em = 0;
951  std::vector<std::pair<DetId, float> > metaContains_noecal;
952 
953  for (std::vector<std::pair<DetId, float> >::iterator i = metaContains.begin(); i != metaContains.end(); ++i)
954  if (i->first.det() != DetId::Ecal)
955  metaContains_noecal.push_back(*i);
956  metaContains.swap(metaContains_noecal);
957  }
958  if (id.ietaAbs() < theTowerTopology->firstHFRing() && E_had < theHcalThreshold) {
959  E -= E_had;
960 
961  if (theHOIsUsed && id.ietaAbs() <= theTowerTopology->lastHORing())
962  E -= E_outer; // not subtracted before, think it should be done
963 
964  E_had = 0;
965  E_outer = 0;
966  std::vector<std::pair<DetId, float> > metaContains_nohcal;
967 
968  for (std::vector<std::pair<DetId, float> >::iterator i = metaContains.begin(); i != metaContains.end(); ++i)
969  if (i->first.det() != DetId::Hcal)
970  metaContains_nohcal.push_back(*i);
971  metaContains.swap(metaContains_nohcal);
972  }
973 
974  if (metaContains.empty())
975  return;
976 
977  if (missingHcalRescaleFactorForEcal > 0 && E_had == 0 && E_em > 0) {
978  auto match = hcalDropChMap.find(id);
979  if (match != hcalDropChMap.end() && match->second.second) {
980  E_had = missingHcalRescaleFactorForEcal * E_em;
981  E += E_had;
982  }
983  }
984 
985  double E_had_tot = (theHOIsUsed && id.ietaAbs() <= theTowerTopology->lastHORing()) ? E_had + E_outer : E_had;
986 
987  // create CaloTower using the selected algorithm
988 
989  GlobalPoint emPoint, hadPoint;
990 
991  // this is actually a 4D vector
992  Basic3DVectorF towerP4;
993  bool massless = true;
994  // float mass1=0;
995  float mass2 = 0;
996 
997  // conditional assignment of depths for barrel/endcap
998  // Some additional tuning may be required in the transitional region
999  // 14<|iEta|<19
1000  double momEmDepth = 0.;
1001  double momHadDepth = 0.;
1002  if (id.ietaAbs() <= 17) {
1003  momHadDepth = theMomHBDepth;
1004  momEmDepth = theMomEBDepth;
1005  } else {
1006  momHadDepth = theMomHEDepth;
1007  momEmDepth = theMomEEDepth;
1008  }
1009 
1010  switch (theMomConstrMethod) {
1011  // FIXME : move to simple cartesian algebra
1012  case 0: { // Simple 4-momentum assignment
1013  GlobalPoint p = theTowerGeometry->getGeometry(id)->getPosition();
1014  towerP4 = p.basicVector().unit();
1015  towerP4.mathVector()[3] = 1.f; // energy
1016  towerP4 *= E;
1017 
1018  // double pf=1.0/cosh(p.eta());
1019  // if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0);
1020 
1021  emPoint = p;
1022  hadPoint = p;
1023  } // end case 0
1024  break;
1025 
1026  case 1: { // separate 4-vectors for ECAL, HCAL, add to get the 4-vector of the tower (=>tower has mass!)
1027  if (id.ietaAbs() < theTowerTopology->firstHFRing()) {
1028  Basic3DVectorF emP4;
1029  if (E_em > 0) {
1030  emPoint = emShwrPos(metaContains, momEmDepth, E_em);
1031  emP4 = emPoint.basicVector().unit();
1032  emP4.mathVector()[3] = 1.f; // energy
1033  towerP4 = emP4 * E_em;
1034 
1035  // double emPf = 1.0/cosh(emPoint.eta());
1036  // towerP4 += CaloTower::PolarLorentzVector(E_em*emPf, emPoint.eta(), emPoint.phi(), 0);
1037  }
1038  if ((E_had + E_outer) > 0) {
1039  massless = (E_em <= 0);
1040  hadPoint = hadShwrPos(id, momHadDepth);
1041  auto lP4 = hadPoint.basicVector().unit();
1042  lP4.mathVector()[3] = 1.f; // energy
1043  if (!massless) {
1044  auto diff = lP4 - emP4;
1045  mass2 = std::sqrt(E_em * E_had_tot * diff.mag2());
1046  }
1047  lP4 *= E_had_tot;
1048  towerP4 += lP4;
1049  /*
1050  if (!massless) {
1051  auto p = towerP4;
1052  double m2 = double(p[3]*p[3]) - double(p[0]*p[0])+double(p[1]*p[1])+double(p[2]*p[2]); mass1 = m2>0 ? std::sqrt(m2) : 0;
1053  }
1054  */
1055  // double hadPf = 1.0/cosh(hadPoint.eta());
1056  // if (E_had_tot>0) {
1057  // towerP4 += CaloTower::PolarLorentzVector(E_had_tot*hadPf, hadPoint.eta(), hadPoint.phi(), 0);
1058  // }
1059  }
1060  } else { // forward detector: use the CaloTower position
1061  GlobalPoint p = theTowerGeometry->getGeometry(id)->getPosition();
1062  towerP4 = p.basicVector().unit();
1063  towerP4.mathVector()[3] = 1.f; // energy
1064  towerP4 *= E;
1065  // double pf=1.0/cosh(p.eta());
1066  // if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0); // simple momentum assignment, same position
1067  emPoint = p;
1068  hadPoint = p;
1069  }
1070  } // end case 1
1071  break;
1072 
1073  case 2: { // use ECAL position for the tower (when E_cal>0), else default CaloTower position (massless tower)
1074  if (id.ietaAbs() < theTowerTopology->firstHFRing()) {
1075  if (E_em > 0)
1076  emPoint = emShwrLogWeightPos(metaContains, momEmDepth, E_em);
1077  else
1078  emPoint = theTowerGeometry->getGeometry(id)->getPosition();
1079  towerP4 = emPoint.basicVector().unit();
1080  towerP4.mathVector()[3] = 1.f; // energy
1081  towerP4 *= E;
1082 
1083  // double sumPf = 1.0/cosh(emPoint.eta());
1085 
1086  hadPoint = emPoint;
1087  } else { // forward detector: use the CaloTower position
1088  GlobalPoint p = theTowerGeometry->getGeometry(id)->getPosition();
1089  towerP4 = p.basicVector().unit();
1090  towerP4.mathVector()[3] = 1.f; // energy
1091  towerP4 *= E;
1092 
1093  // double pf=1.0/cosh(p.eta());
1094  // if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0); // simple momentum assignment, same position
1095  emPoint = p;
1096  hadPoint = p;
1097  }
1098  } // end case 2
1099  break;
1100 
1101  } // end of decision on p4 reconstruction method
1102 
1103  // insert in collection (remove and return if below threshold)
1104  if UNLIKELY ((towerP4[3] == 0) & (E_outer > 0)) {
1105  float val = theHOIsUsed ? 0 : 1E-9; // to keep backwards compatibility for theHOIsUsed == true
1106  collection.emplace_back(id,
1107  E_em,
1108  E_had,
1109  E_outer,
1110  -1,
1111  -1,
1112  CaloTower::PolarLorentzVector(val, hadPoint.eta(), hadPoint.phi(), 0),
1113  emPoint,
1114  hadPoint);
1115  } else {
1116  collection.emplace_back(
1117  id, E_em, E_had, E_outer, -1, -1, GlobalVector(towerP4), towerP4[3], mass2, emPoint, hadPoint);
1118  }
1119  auto& caloTower = collection.back();
1120 
1121  // if (!massless) std::cout << "massive " << id <<' ' << mass1 <<' ' << mass2 <<' ' << caloTower.mass() << std::endl;
1122  // std::cout << "CaloTowerVI " <<theMomConstrMethod <<' ' << id <<' '<< E_em <<' '<< E_had <<' '<< E_outer <<' '<< GlobalVector(towerP4) <<' '<< towerP4[3] <<' '<< emPoint <<' '<< hadPoint << std::endl;
1123  //if (towerP4[3]==0) std::cout << "CaloTowerVIzero " << theEcutTower << ' ' << collection.back().eta() <<' '<< collection.back().phi() << std::endl;
1124 
1125  if (caloTower.energy() < theEcutTower) {
1126  collection.pop_back();
1127  return;
1128  }
1129 
1130  // set the timings
1131  float ecalTime = (mt.emSumEForTime > 0) ? mt.emSumTimeTimesE / mt.emSumEForTime : -9999;
1132  float hcalTime = (mt.hadSumEForTime > 0) ? mt.hadSumTimeTimesE / mt.hadSumEForTime : -9999;
1133  caloTower.setEcalTime(compactTime(ecalTime));
1134  caloTower.setHcalTime(compactTime(hcalTime));
1135  //add topology info
1136  caloTower.setHcalSubdet(theTowerTopology->lastHBRing(),
1137  theTowerTopology->lastHERing(),
1138  theTowerTopology->lastHFRing(),
1139  theTowerTopology->lastHORing());
1140 
1141  // set the CaloTower status word =====================================
1142  // Channels must be counter exclusively in the defined cathegories
1143  // "Bad" channels (not used in energy assignment) can be flagged during
1144  // CaloTower creation only if specified in the configuration file
1145 
1146  unsigned int numBadHcalChan = mt.numBadHcalCells;
1147  // unsigned int numBadEcalChan = mt.numBadEcalCells;
1148  unsigned int numBadEcalChan = 0; //
1149 
1150  unsigned int numRecHcalChan = mt.numRecHcalCells;
1151  unsigned int numRecEcalChan = mt.numRecEcalCells;
1152  unsigned int numProbHcalChan = mt.numProbHcalCells;
1153  unsigned int numProbEcalChan = mt.numProbEcalCells;
1154 
1155  // now add dead/off/... channels not used in RecHit reconstruction for HCAL
1156  HcalDropChMap::iterator dropChItr = hcalDropChMap.find(id);
1157  if (dropChItr != hcalDropChMap.end())
1158  numBadHcalChan += dropChItr->second.first;
1159 
1160  // for ECAL the number of all bad channels is obtained here -----------------------
1161 
1162  /*
1163  // old hyper slow algorithm
1164  // get all possible constituents of the tower
1165  std::vector<DetId> allConstituents = theTowerConstituentsMap->constituentsOf(id);
1166 
1167  for (std::vector<DetId>::iterator ac_it=allConstituents.begin();
1168  ac_it!=allConstituents.end(); ++ac_it) {
1169 
1170  if (ac_it->det()!=DetId::Ecal) continue;
1171 
1172  int thisEcalSevLvl = -999;
1173 
1174  if (ac_it->subdetId() == EcalBarrel && theEbHandle.isValid()) {
1175  thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel( *ac_it, *theEbHandle);//, *theEcalChStatus);
1176  }
1177  else if (ac_it->subdetId() == EcalEndcap && theEeHandle.isValid()) {
1178  thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel( *ac_it, *theEeHandle);//, *theEcalChStatus);
1179  }
1180 
1181  // check if the Ecal severity is ok to keep
1182  std::vector<int>::const_iterator sevit = std::find(theEcalSeveritiesToBeExcluded.begin(),
1183  theEcalSeveritiesToBeExcluded.end(),
1184  thisEcalSevLvl);
1185  if (sevit!=theEcalSeveritiesToBeExcluded.end()) {
1186  ++numBadEcalChan;
1187  }
1188 
1189  }
1190 
1191  // compare with fast version
1192 
1193  // hcal:
1194  int inEcals[2] = {0,0};
1195  for (std::vector<std::pair<DetId,float> >::iterator i=metaContains.begin(); i!=metaContains.end(); ++i) {
1196  DetId detId = i->first;
1197  if(detId.det() == DetId::Ecal){
1198  if( detId.subdetId()==EcalBarrel ) inEcals[0] =1;
1199  else if( detId.subdetId()==EcalEndcap ) inEcals[1] =1;
1200  }
1201  }
1202 
1203  auto numBadEcalChanNew = ecalBadChs[theTowerTopology->denseIndex(id)]+mt.numBadEcalCells; // - mt.numRecEcalCells
1204  if (int(numBadEcalChanNew)!=int(numBadEcalChan)) {
1205  std::cout << "VI wrong " << ((inEcals[1]==1) ? "EE" : "" ) << id << " " << numBadEcalChanNew << " " << numBadEcalChan
1206  << " " << mt.numBadEcalCells << " " << mt.numRecEcalCells << std::endl;
1207  }
1208  */
1209 
1210  numBadEcalChan = ecalBadChs[theTowerTopology->denseIndex(id)] + mt.numBadEcalCells; // - mt.numRecEcalCells
1211 
1212  //--------------------------------------------------------------------------------------
1213 
1214  caloTower.setCaloTowerStatus(
1215  numBadHcalChan, numBadEcalChan, numRecHcalChan, numRecEcalChan, numProbHcalChan, numProbEcalChan);
1216 
1217  double maxCellE = -999.0; // for storing the hottest cell E in the calotower
1218 
1219  std::vector<DetId> contains;
1220  contains.reserve(metaContains.size());
1221  for (std::vector<std::pair<DetId, float> >::iterator i = metaContains.begin(); i != metaContains.end(); ++i) {
1222  contains.push_back(i->first);
1223 
1224  if (maxCellE < i->second) {
1225  // need an extra check because of the funny towers that are empty except for the presence of an HO
1226  // hit in the constituents (JetMET wanted them saved)
1227  // This constituent is only used for storing the tower, but should not be concidered as a hot cell canditate for
1228  // configurations with useHO = false
1229 
1230  if (i->first.det() == DetId::Ecal) { // ECAL
1231  maxCellE = i->second;
1232  } else { // HCAL
1233  if (HcalDetId(i->first).subdet() != HcalOuter)
1234  maxCellE = i->second;
1235  else if (theHOIsUsed)
1236  maxCellE = i->second;
1237  }
1238 
1239  } // found higher E cell
1240 
1241  } // loop over matacontains
1242 
1243  caloTower.setConstituents(std::move(contains));
1244  caloTower.setHottestCellE(maxCellE);
1245 
1246  // std::cout << "CaloTowerVI " << nalgo << ' ' << caloTower.id() << ((inEcals[1]==1) ? "EE " : " " ) << caloTower.pt() << ' ' << caloTower.et() << ' ' << caloTower.mass() << ' '
1247  // << caloTower.constituentsSize() <<' '<< caloTower.towerStatusWord() << std::endl;
1248 }
mps_fire.i
i
Definition: mps_fire.py:429
edm::contains
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:37
nano_mu_digi_cff.rawId
rawId
Definition: nano_mu_digi_cff.py:58
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
CaloTowerTopology::lastHFRing
int lastHFRing() const
Definition: CaloTowerTopology.h:41
cms::cuda::assert
assert(be >=bs)
CaloTowerTopology::lastHERing
int lastHERing() const
Definition: CaloTowerTopology.h:39
CaloTowerTopology::lastHORing
int lastHORing() const
Definition: CaloTowerTopology.h:43
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::ietaAbs
ALPAKA_FN_ACC ALPAKA_FN_INLINE uint32_t ietaAbs(uint32_t id)
Definition: KernelHelpers.dev.cc:12
HcalDetId::subdet
constexpr HcalSubdetector subdet() const
get the subdetector
Definition: HcalDetId.h:138
CaloTowersCreationAlgo::theTowerGeometry
const CaloSubdetectorGeometry * theTowerGeometry
Definition: CaloTowersCreationAlgo.h:333
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:23
digitizers_cfi.ecalTime
ecalTime
Definition: digitizers_cfi.py:78
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
change_name.diff
diff
Definition: change_name.py:13
Basic3DVector::mathVector
MathVector const & mathVector() const
Definition: extBasic3DVector.h:91
PV3DBase::basicVector
const BasicVectorType & basicVector() const
Definition: PV3DBase.h:53
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
CaloSubdetectorGeometry::getGeometry
virtual std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id. Should return false if not found.
Definition: CaloSubdetectorGeometry.cc:36
CaloTowersCreationAlgo::hadShwrPos
GlobalPoint hadShwrPos(const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double hadE)
CaloTowersCreationAlgo::ecalBadChs
std::vector< unsigned short > ecalBadChs
Definition: CaloTowersCreationAlgo.h:394
CaloTowersCreationAlgo::emShwrPos
GlobalPoint emShwrPos(const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double totEmE)
Definition: CaloTowersCreationAlgo.cc:1595
CaloTowerTopology::firstHFRing
int firstHFRing() const
Definition: CaloTowerTopology.h:40
CaloTowerTopology::denseIndex
uint32_t denseIndex(const DetId &id) const
Definition: CaloTowerTopology.cc:236
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
Basic3DVector::unit
Basic3DVector unit() const
Definition: extBasic3DVector.h:154
UNLIKELY
#define UNLIKELY(x)
Definition: Likely.h:21
TtSemiLepEvtBuilder_cfi.mt
mt
Definition: TtSemiLepEvtBuilder_cfi.py:47
heppy_batch.val
val
Definition: heppy_batch.py:351
ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if
if(threadIdxLocalY==0 &&threadIdxLocalX==0)
Definition: CAPixelDoubletsAlgos.h:173
eostools.move
def move(src, dest)
Definition: eostools.py:511
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
GlobalVector
Global3DVector GlobalVector
Definition: GlobalVector.h:10
CaloTowersCreationAlgo::emShwrLogWeightPos
GlobalPoint emShwrLogWeightPos(const std::vector< std::pair< DetId, float >> &metaContains, float fracDepth, double totEmE)
Definition: CaloTowersCreationAlgo.cc:1625
CaloTowerTopology::lastHBRing
int lastHBRing() const
Definition: CaloTowerTopology.h:37
reco::Candidate::PolarLorentzVector
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
Definition: Candidate.h:38

◆ ecalChanStatusForCaloTower()

std::tuple< unsigned int, bool > CaloTowersCreationAlgo::ecalChanStatusForCaloTower ( const EcalRecHit *  hit)

Definition at line 1832 of file CaloTowersCreationAlgo.cc.

References BadChan, runTheMatrix::const, spr::find(), GoodChan, IgnoredChan, EcalSeverityLevel::kBad, EcalSeverityLevel::kGood, EcalSeverityLevel::kRecovered, ProblematicChan, RecoveredChan, interestingDetIdCollectionProducer_cfi::severityLevel, EcalSeverityLevelAlgo::severityLevel(), theEcalSeveritiesToBeExcluded, theEcalSeveritiesToBeUsedInBadTowers, theEcalSevLvlAlgo, theRecoveredEcalHitsAreUsed, useRejectedHitsOnly, and useRejectedRecoveredEcalHits.

Referenced by assignHitEcal().

1832  {
1833  // const DetId id = hit->detid();
1834 
1835  // uint16_t dbStatus = theEcalChStatus->find(id)->getStatusCode();
1836  // uint32_t rhFlags = hit->flags();
1837  // int severityLevel = theEcalSevLvlAlgo->severityLevel(rhFlags, dbStatus);
1838  // The methods above will become private and cannot be usef for flagging ecal spikes.
1839  // Use the recommended interface - we leave the parameters for spilke removal to be specified by ECAL.
1840 
1841  // int severityLevel = 999;
1842 
1843  EcalRecHit const& rh = *reinterpret_cast<EcalRecHit const*>(hit);
1844  int severityLevel = theEcalSevLvlAlgo->severityLevel(rh);
1845 
1846  // if (id.subdetId() == EcalBarrel) severityLevel = theEcalSevLvlAlgo->severityLevel( id, *theEbHandle);//, *theEcalChStatus);
1847  // else if (id.subdetId() == EcalEndcap) severityLevel = theEcalSevLvlAlgo->severityLevel( id, *theEeHandle);//, *theEcalChStatus);
1848 
1849  // there should be no other ECAL types used in this reconstruction
1850 
1851  // The definition of ECAL severity levels uses categories that
1852  // are similar to the defined for CaloTower. (However, the categorization
1853  // for CaloTowers depends on the specified maximum acceptabel severity and therefore cannnot
1854  // be exact correspondence between the two. ECAL has additional categories describing modes of failure.)
1855  // This approach is different from the initial idea and from
1856  // the implementation for HCAL. Still make the logic similar to HCAL so that one has the ability to
1857  // exclude problematic channels as defined by ECAL.
1858  // For definitions of ECAL severity levels see RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h
1859 
1860  bool isBad = (severityLevel == EcalSeverityLevel::kBad);
1861 
1862  bool isRecovered = (severityLevel == EcalSeverityLevel::kRecovered);
1863 
1864  // check if the severity is compatible with our configuration
1865  // This applies to the "default" tower cleaning
1866  std::vector<int>::const_iterator sevit =
1867  std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), severityLevel);
1868  bool accepted = (sevit == theEcalSeveritiesToBeExcluded.end());
1869 
1870  // For use with hits that were rejected in the regular reconstruction:
1871  // This is for creating calotowers with lower level of cleaning by merging
1872  // the information from the default towers and a collection of towers created from
1873  // bad rechits
1874 
1875  if (useRejectedHitsOnly) {
1876  if (!isRecovered) {
1877  if (accepted || std::find(theEcalSeveritiesToBeUsedInBadTowers.begin(),
1878  theEcalSeveritiesToBeUsedInBadTowers.end(),
1879  severityLevel) == theEcalSeveritiesToBeUsedInBadTowers.end())
1880  return std::make_tuple(CaloTowersCreationAlgo::IgnoredChan, isBad);
1881  // this hit was either already accepted, or is not eligible for inclusion
1882  } else {
1883  if (theRecoveredEcalHitsAreUsed || !useRejectedRecoveredEcalHits) {
1884  // skip recovered hits either because they were already used or because there was an explicit instruction
1885  return std::make_tuple(CaloTowersCreationAlgo::IgnoredChan, isBad);
1886  ;
1887  } else if (useRejectedRecoveredEcalHits) {
1888  return std::make_tuple(CaloTowersCreationAlgo::RecoveredChan, isBad);
1889  }
1890 
1891  } // recovered channels
1892 
1893  // clasify channels as problematic
1894  return std::make_tuple(CaloTowersCreationAlgo::ProblematicChan, isBad);
1895 
1896  } // treatment of rejected hits
1897 
1898  // for normal reconstruction
1899  if (severityLevel == EcalSeverityLevel::kGood)
1900  return std::make_tuple(CaloTowersCreationAlgo::GoodChan, false);
1901 
1902  if (isRecovered) {
1903  return std::make_tuple(
1904  (theRecoveredEcalHitsAreUsed) ? CaloTowersCreationAlgo::RecoveredChan : CaloTowersCreationAlgo::BadChan, true);
1905  } else {
1906  return std::make_tuple(accepted ? CaloTowersCreationAlgo::ProblematicChan : CaloTowersCreationAlgo::BadChan, isBad);
1907  }
1908 }
CaloTowersCreationAlgo::theEcalSeveritiesToBeUsedInBadTowers
std::vector< int > theEcalSeveritiesToBeUsedInBadTowers
Definition: CaloTowersCreationAlgo.h:358
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
EcalSeverityLevelAlgo::severityLevel
EcalSeverityLevel::SeverityLevel severityLevel(const DetId &id) const
Evaluate status from id use channelStatus from DB.
Definition: EcalSeverityLevelAlgo.cc:85
CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded
std::vector< int > theEcalSeveritiesToBeExcluded
Definition: CaloTowersCreationAlgo.h:349
CaloTowersCreationAlgo::theEcalSevLvlAlgo
const EcalSeverityLevelAlgo * theEcalSevLvlAlgo
Definition: CaloTowersCreationAlgo.h:343
interestingDetIdCollectionProducer_cfi.severityLevel
severityLevel
Definition: interestingDetIdCollectionProducer_cfi.py:10

◆ emCrystalShwrPos()

GlobalPoint CaloTowersCreationAlgo::emCrystalShwrPos ( DetId  detId,
float  fracDepth 
)

Definition at line 1425 of file CaloTowersCreationAlgo.cc.

References hcalRecHitTable_cff::detId, CaloGeometry::getGeometry(), point, and theGeometry.

Referenced by emShwrLogWeightPos(), emShwrPos(), and hadSegmentShwrPos().

1425  {
1426  auto cellGeometry = theGeometry->getGeometry(detId);
1427  GlobalPoint point = cellGeometry->getPosition(); // face of the cell
1428 
1429  if (fracDepth <= 0)
1430  return point;
1431  if (fracDepth > 1)
1432  fracDepth = 1;
1433 
1434  const GlobalPoint& backPoint = cellGeometry->getBackPoint();
1435  point += fracDepth * (backPoint - point);
1436 
1437  return point;
1438 }
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
CaloGeometry::getGeometry
std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id.
Definition: CaloGeometry.cc:60
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5

◆ emShwrLogWeightPos()

GlobalPoint CaloTowersCreationAlgo::emShwrLogWeightPos ( const std::vector< std::pair< DetId, float >> &  metaContains,
float  fracDepth,
double  totEmE 
)

Definition at line 1625 of file CaloTowersCreationAlgo.cc.

References DetId::Ecal, emCrystalShwrPos(), dqm-mbProfile::log, AlCaHLTBitMon_ParallelJobs::p, and mps_merge::weight.

Referenced by convert().

1627  {
1628  double emX = 0.0;
1629  double emY = 0.0;
1630  double emZ = 0.0;
1631 
1632  double weight = 0;
1633  double sumWeights = 0;
1634  double sumEmE = 0; // add crystals with E/E_EM > 1.5%
1635  double crystalThresh = 0.015 * emE;
1636 
1637  std::vector<std::pair<DetId, float> >::const_iterator mc_it = metaContains.begin();
1638  for (; mc_it != metaContains.end(); ++mc_it) {
1639  if (mc_it->second < 0)
1640  continue;
1641  if (mc_it->first.det() == DetId::Ecal && mc_it->second > crystalThresh)
1642  sumEmE += mc_it->second;
1643  }
1644 
1645  for (mc_it = metaContains.begin(); mc_it != metaContains.end(); ++mc_it) {
1646  if (mc_it->first.det() != DetId::Ecal || mc_it->second < crystalThresh)
1647  continue;
1648 
1649  GlobalPoint p = emCrystalShwrPos(mc_it->first, fracDepth);
1650 
1651  weight = 4.2 + log(mc_it->second / sumEmE);
1652  sumWeights += weight;
1653 
1654  emX += p.x() * weight;
1655  emY += p.y() * weight;
1656  emZ += p.z() * weight;
1657  }
1658 
1659  return GlobalPoint(emX / sumWeights, emY / sumWeights, emZ / sumWeights);
1660 }
CaloTowersCreationAlgo::emCrystalShwrPos
GlobalPoint emCrystalShwrPos(DetId detId, float fracDepth)
Definition: CaloTowersCreationAlgo.cc:1425
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
weight
Definition: weight.py:1
mps_merge.weight
weight
Definition: mps_merge.py:88
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153

◆ emShwrPos()

GlobalPoint CaloTowersCreationAlgo::emShwrPos ( const std::vector< std::pair< DetId, float >> &  metaContains,
float  fracDepth,
double  totEmE 
)

Definition at line 1595 of file CaloTowersCreationAlgo.cc.

References MillePedeFileConverter_cfg::e, DetId::Ecal, emCrystalShwrPos(), and AlCaHLTBitMon_ParallelJobs::p.

Referenced by convert().

1597  {
1598  if (emE <= 0)
1599  return GlobalPoint(0, 0, 0);
1600 
1601  double emX = 0.0;
1602  double emY = 0.0;
1603  double emZ = 0.0;
1604 
1605  double eSum = 0;
1606 
1607  std::vector<std::pair<DetId, float> >::const_iterator mc_it = metaContains.begin();
1608  for (; mc_it != metaContains.end(); ++mc_it) {
1609  if (mc_it->first.det() != DetId::Ecal)
1610  continue;
1611  GlobalPoint p = emCrystalShwrPos(mc_it->first, fracDepth);
1612  double e = mc_it->second;
1613 
1614  if (e > 0) {
1615  emX += p.x() * e;
1616  emY += p.y() * e;
1617  emZ += p.z() * e;
1618  eSum += e;
1619  }
1620  }
1621 
1622  return GlobalPoint(emX / eSum, emY / eSum, emZ / eSum);
1623 }
CaloTowersCreationAlgo::emCrystalShwrPos
GlobalPoint emCrystalShwrPos(DetId detId, float fracDepth)
Definition: CaloTowersCreationAlgo.cc:1425
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153

◆ find()

CaloTowersCreationAlgo::MetaTower & CaloTowersCreationAlgo::find ( const CaloTowerDetId &  id)
private

looks for a given tower in the internal cache. If it can't find it, it makes it.

Definition at line 915 of file CaloTowersCreationAlgo.cc.

References CaloTowerTopology::denseIndex(), hcalRecHitTable_cff::detId, CaloTowerTopology::firstHFRing(), TtSemiLepEvtBuilder_cfi::mt, CaloTowerTopology::sizeForDenseIndexing(), theTowerMap, theTowerMapSize, and theTowerTopology.

Referenced by assignHitEcal(), assignHitHcal(), and rescale().

915  {
916  if (theTowerMap.empty()) {
917  theTowerMap.resize(theTowerTopology->sizeForDenseIndexing());
918  }
919 
920  auto& mt = theTowerMap[theTowerTopology->denseIndex(detId)];
921 
922  if (mt.empty()) {
923  mt.id = detId;
924  mt.metaConstituents.reserve(detId.ietaAbs() < theTowerTopology->firstHFRing() ? 12 : 2);
925  ++theTowerMapSize;
926  }
927 
928  return mt;
929 }
CaloTowerTopology::sizeForDenseIndexing
uint32_t sizeForDenseIndexing() const
Definition: CaloTowerTopology.h:56
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
CaloTowerTopology::firstHFRing
int firstHFRing() const
Definition: CaloTowerTopology.h:40
CaloTowerTopology::denseIndex
uint32_t denseIndex(const DetId &id) const
Definition: CaloTowerTopology.cc:236
TtSemiLepEvtBuilder_cfi.mt
mt
Definition: TtSemiLepEvtBuilder_cfi.py:47

◆ finish()

void CaloTowersCreationAlgo::finish ( CaloTowerCollection &  destCollection)

Definition at line 411 of file CaloTowersCreationAlgo.cc.

References convert(), TtSemiLepEvtBuilder_cfi::mt, mps_fire::result, theTowerMap, and theTowerMapSize.

Referenced by progressbar.ProgressBar::__next__(), and CaloTowersCreator::produce().

411  {
412  // now copy this map into the final collection
413  result.reserve(theTowerMapSize);
414  // auto k=0U;
415  // if (!theEbHandle.isValid()) std::cout << "VI ebHandle not valid" << std::endl;
416  // if (!theEeHandle.isValid()) std::cout << "VI eeHandle not valid" << std::endl;
417 
418  for (auto const& mt : theTowerMap) {
419  // Convert only if there is at least one constituent in the metatower.
420  // The check of constituents size in the coverted tower is still needed!
421  if (!mt.empty()) {
422  convert(mt.id, mt, result);
423  } // ++k;}
424  }
425 
426  // assert(k==theTowerMapSize);
427  // std::cout << "VI TowerMap " << theTowerMapSize << " " << k << std::endl;
428 
429  theTowerMap.clear(); // save the memory
430  theTowerMapSize = 0;
431 }
mps_fire.result
result
Definition: mps_fire.py:311
CaloTowersCreationAlgo::convert
void convert(const CaloTowerDetId &id, const MetaTower &mt, CaloTowerCollection &collection)
Definition: CaloTowersCreationAlgo.cc:931
TtSemiLepEvtBuilder_cfi.mt
mt
Definition: TtSemiLepEvtBuilder_cfi.py:47

◆ getThresholdAndWeight()

void CaloTowersCreationAlgo::getThresholdAndWeight ( const DetId &  detId,
double &  threshold,
double &  weight 
) const
private

helper method to look up the appropriate threshold & weight

Definition at line 1250 of file CaloTowersCreationAlgo.cc.

References hcalRecHitTable_cff::depth, HcalDetId::depth(), hcalRecHitTable_cff::detId, DetId::Ecal, EcalBarrel, ecalCuts, EcalEndcap, HcalTopology::firstHEDoublePhiRing(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalBarrel, hcalCuts, HcalEndcap, HcalForward, HcalOuter, HcalDetId::ieta(), HcalDetId::ietaAbs(), fftjetcommon_cfi::Interpolator, B2GTnPMonitor_cfi::item, DetId::rawId(), HcalDetId::subdet(), theEBEScale, theEBGrid, theEBthreshold, theEBweight, theEBWeights, theEEEScale, theEEGrid, theEEthreshold, theEEweight, theEEWeights, theHBEScale, theHBGrid, theHBthreshold, theHBthreshold1, theHBthreshold2, theHBweight, theHBWeights, theHcalTopology, theHEDEScale, theHEDGrid, theHEDthreshold, theHEDthreshold1, theHEDweight, theHEDWeights, theHESEScale, theHESGrid, theHESthreshold, theHESthreshold1, theHESweight, theHESWeights, theHF1EScale, theHF1Grid, theHF1threshold, theHF1weight, theHF1Weights, theHF2EScale, theHF2Grid, theHF2threshold, theHF2weight, theHF2Weights, theHOEScale, theHOGrid, theHOthreshold0, theHOthresholdMinus1, theHOthresholdMinus2, theHOthresholdPlus1, theHOthresholdPlus2, theHOweight, theHOWeights, and DiMuonV_cfg::threshold.

Referenced by assignHitEcal(), assignHitHcal(), rescale(), and rescaleTowers().

1250  {
1251  DetId::Detector det = detId.det();
1252  weight = 0; // in case the hit is not identified
1253 
1254  if (det == DetId::Ecal) {
1255  // may or may not be EB. We'll find out.
1256 
1257  EcalSubdetector subdet = (EcalSubdetector)(detId.subdetId());
1258  if (subdet == EcalBarrel) {
1259  if (ecalCuts == nullptr) { // this means that ecalRecHitThresh_ is false
1260  threshold = theEBthreshold;
1261  } else {
1262  threshold = (*ecalCuts)[detId];
1263  }
1264  weight = theEBweight;
1265  if (weight <= 0.) {
1266  ROOT::Math::Interpolator my(theEBGrid, theEBWeights, ROOT::Math::Interpolation::kAKIMA);
1267  weight = my.Eval(theEBEScale);
1268  }
1269  } else if (subdet == EcalEndcap) {
1270  if (ecalCuts == nullptr) {
1271  threshold = theEEthreshold;
1272  } else {
1273  threshold = (*ecalCuts)[detId];
1274  }
1275  weight = theEEweight;
1276  if (weight <= 0.) {
1277  ROOT::Math::Interpolator my(theEEGrid, theEEWeights, ROOT::Math::Interpolation::kAKIMA);
1278  weight = my.Eval(theEEEScale);
1279  }
1280  }
1281  } else if (det == DetId::Hcal) {
1282  HcalDetId hcalDetId(detId);
1283  HcalSubdetector subdet = hcalDetId.subdet();
1284  int depth = hcalDetId.depth();
1285 
1286  if (subdet == HcalBarrel) {
1287  if (hcalCuts == nullptr) { // this means cutsFromDB is false
1288  threshold = (depth == 1) ? theHBthreshold1 : (depth == 2) ? theHBthreshold2 : theHBthreshold;
1289  } else { // hcalCuts is not nullptr, i.e. cutsFromDB is true
1290  const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
1291  threshold = item->noiseThreshold();
1292  }
1293  weight = theHBweight;
1294  if (weight <= 0.) {
1295  ROOT::Math::Interpolator my(theHBGrid, theHBWeights, ROOT::Math::Interpolation::kAKIMA);
1296  weight = my.Eval(theHBEScale);
1297  }
1298  }
1299 
1300  else if (subdet == HcalEndcap) {
1301  // check if it's single or double tower
1302  if (hcalDetId.ietaAbs() < theHcalTopology->firstHEDoublePhiRing()) {
1303  if (hcalCuts == nullptr) { // this means cutsFromDB is false
1304  threshold = (depth == 1) ? theHESthreshold1 : theHESthreshold;
1305  } else { // hcalCuts is not nullptr, i.e. cutsFromDB is true
1306  const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
1307  threshold = item->noiseThreshold();
1308  }
1309  weight = theHESweight;
1310  if (weight <= 0.) {
1311  ROOT::Math::Interpolator my(theHESGrid, theHESWeights, ROOT::Math::Interpolation::kAKIMA);
1312  weight = my.Eval(theHESEScale);
1313  }
1314  } else {
1315  if (hcalCuts == nullptr) { // this means cutsFromDB is false
1316  threshold = (depth == 1) ? theHEDthreshold1 : theHEDthreshold;
1317  } else { // hcalCuts is not nullptr, i.e. cutsFromDB is true
1318  const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
1319  threshold = item->noiseThreshold();
1320  }
1321  weight = theHEDweight;
1322  if (weight <= 0.) {
1323  ROOT::Math::Interpolator my(theHEDGrid, theHEDWeights, ROOT::Math::Interpolation::kAKIMA);
1324  weight = my.Eval(theHEDEScale);
1325  }
1326  }
1327  }
1328 
1329  else if (subdet == HcalOuter) {
1330  //check if it's ring 0 or +1 or +2 or -1 or -2
1331  if (hcalDetId.ietaAbs() <= 4)
1332  threshold = theHOthreshold0;
1333  else if (hcalDetId.ieta() < 0) {
1334  // set threshold for ring -1 or -2
1335  threshold = (hcalDetId.ietaAbs() <= 10) ? theHOthresholdMinus1 : theHOthresholdMinus2;
1336  } else {
1337  // set threshold for ring +1 or +2
1338  threshold = (hcalDetId.ietaAbs() <= 10) ? theHOthresholdPlus1 : theHOthresholdPlus2;
1339  }
1340  weight = theHOweight;
1341  if (weight <= 0.) {
1342  ROOT::Math::Interpolator my(theHOGrid, theHOWeights, ROOT::Math::Interpolation::kAKIMA);
1343  weight = my.Eval(theHOEScale);
1344  }
1345  }
1346 
1347  else if (subdet == HcalForward) {
1348  if (hcalDetId.depth() == 1) {
1349  threshold = theHF1threshold;
1350  weight = theHF1weight;
1351  if (weight <= 0.) {
1352  ROOT::Math::Interpolator my(theHF1Grid, theHF1Weights, ROOT::Math::Interpolation::kAKIMA);
1353  weight = my.Eval(theHF1EScale);
1354  }
1355  } else {
1356  threshold = theHF2threshold;
1357  weight = theHF2weight;
1358  if (weight <= 0.) {
1359  ROOT::Math::Interpolator my(theHF2Grid, theHF2Weights, ROOT::Math::Interpolation::kAKIMA);
1360  weight = my.Eval(theHF2EScale);
1361  }
1362  }
1363  }
1364  } else {
1365  edm::LogError("CaloTowersCreationAlgo") << "Bad cell: " << det << std::endl;
1366  }
1367 }
CaloTowersCreationAlgo::theHBGrid
std::vector< double > theHBGrid
Definition: CaloTowersCreationAlgo.h:309
CaloTowersCreationAlgo::theHESGrid
std::vector< double > theHESGrid
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHEDGrid
std::vector< double > theHEDGrid
Definition: CaloTowersCreationAlgo.h:311
weight
Definition: weight.py:1
CaloTowersCreationAlgo::theHOWeights
std::vector< double > theHOWeights
Definition: CaloTowersCreationAlgo.h:312
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:129
CaloTowersCreationAlgo::theEEGrid
std::vector< double > theEEGrid
Definition: CaloTowersCreationAlgo.h:308
B2GTnPMonitor_cfi.item
item
Definition: B2GTnPMonitor_cfi.py:148
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:161
CaloTowersCreationAlgo::ecalCuts
const EcalPFRecHitThresholds * ecalCuts
Definition: CaloTowersCreationAlgo.h:327
CaloTowersCreationAlgo::theEEWeights
std::vector< double > theEEWeights
Definition: CaloTowersCreationAlgo.h:308
CaloTowersCreationAlgo::theHESWeights
std::vector< double > theHESWeights
Definition: CaloTowersCreationAlgo.h:310
CaloTowersCreationAlgo::theHF2Grid
std::vector< double > theHF2Grid
Definition: CaloTowersCreationAlgo.h:314
CaloTowersCreationAlgo::theHEDWeights
std::vector< double > theHEDWeights
Definition: CaloTowersCreationAlgo.h:311
HcalSubdetector
HcalSubdetector
Definition: HcalAssistant.h:31
CaloTowersCreationAlgo::theHOGrid
std::vector< double > theHOGrid
Definition: CaloTowersCreationAlgo.h:312
CaloTowersCreationAlgo::theHF1Weights
std::vector< double > theHF1Weights
Definition: CaloTowersCreationAlgo.h:313
fftjetcommon_cfi.Interpolator
Interpolator
Definition: fftjetcommon_cfi.py:188
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
CaloTowersCreationAlgo::theHBWeights
std::vector< double > theHBWeights
Definition: CaloTowersCreationAlgo.h:309
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:101
DetId::Detector
Detector
Definition: DetId.h:24
HcalTopology::firstHEDoublePhiRing
int firstHEDoublePhiRing() const
Definition: HcalTopology.h:98
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
hcalRecHitTable_cff.depth
depth
Definition: hcalRecHitTable_cff.py:17
CaloTowersCreationAlgo::theHF1Grid
std::vector< double > theHF1Grid
Definition: CaloTowersCreationAlgo.h:313
CaloTowersCreationAlgo::theEBGrid
std::vector< double > theEBGrid
Definition: CaloTowersCreationAlgo.h:307
CaloTowersCreationAlgo::theHF2Weights
std::vector< double > theHF2Weights
Definition: CaloTowersCreationAlgo.h:314
EcalSubdetector
EcalSubdetector
Definition: EcalSubdetector.h:10
CaloTowersCreationAlgo::theEBWeights
std::vector< double > theEBWeights
Definition: CaloTowersCreationAlgo.h:307

◆ hadSegmentShwrPos()

GlobalPoint CaloTowersCreationAlgo::hadSegmentShwrPos ( DetId  detId,
float  fracDepth 
)

Definition at line 1440 of file CaloTowersCreationAlgo.cc.

References hcalRecHitTable_cff::detId, and emCrystalShwrPos().

1440  {
1441  // same code as above
1442  return emCrystalShwrPos(detId, fracDepth);
1443 }
CaloTowersCreationAlgo::emCrystalShwrPos
GlobalPoint emCrystalShwrPos(DetId detId, float fracDepth)
Definition: CaloTowersCreationAlgo.cc:1425
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12

◆ hadShwPosFromCells()

GlobalPoint CaloTowersCreationAlgo::hadShwPosFromCells ( DetId  frontCell,
DetId  backCell,
float  fracDepth 
)

Definition at line 1568 of file CaloTowersCreationAlgo.cc.

References gather_cfg::cout, CaloGeometry::getGeometry(), HcalTopology::getMergePositionFlag(), HcalTopology::idBack(), HcalTopology::idFront(), point, theGeometry, and theHcalTopology.

Referenced by hadShwrPos().

1568  {
1569  // uses the "front" and "back" cells
1570  // to determine the axis. point set by the predefined depth.
1571 
1572  HcalDetId hid1(frontCellId), hid2(backCellId);
1573  if (theHcalTopology->getMergePositionFlag()) {
1574  hid1 = theHcalTopology->idFront(frontCellId);
1575 #ifdef EDM_ML_DEBUG
1576  std::cout << "Front " << HcalDetId(frontCellId) << " " << hid1 << "\n";
1577 #endif
1578  hid2 = theHcalTopology->idBack(backCellId);
1579 #ifdef EDM_ML_DEBUG
1580  std::cout << "Back " << HcalDetId(backCellId) << " " << hid2 << "\n";
1581 #endif
1582  }
1583 
1584  auto frontCellGeometry = theGeometry->getGeometry(DetId(hid1));
1585  auto backCellGeometry = theGeometry->getGeometry(DetId(hid2));
1586 
1587  GlobalPoint point = frontCellGeometry->getPosition();
1588  const GlobalPoint& backPoint = backCellGeometry->getBackPoint();
1589 
1590  point += fracDepth * (backPoint - point);
1591 
1592  return point;
1593 }
HcalTopology::getMergePositionFlag
bool getMergePositionFlag() const
Definition: HcalTopology.h:164
HcalTopology::idFront
HcalDetId idFront(const HcalDetId &id) const
Definition: HcalTopology.h:167
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
HcalTopology::idBack
HcalDetId idBack(const HcalDetId &id) const
Definition: HcalTopology.h:168
CaloGeometry::getGeometry
std::shared_ptr< const CaloCellGeometry > getGeometry(const DetId &id) const
Get the cell geometry of a given detector id.
Definition: CaloGeometry.cc:60
DetId
Definition: DetId.h:17
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
gather_cfg.cout
cout
Definition: gather_cfg.py:144
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5

◆ hadShwrPos() [1/2]

GlobalPoint CaloTowersCreationAlgo::hadShwrPos ( const std::vector< std::pair< DetId, float >> &  metaContains,
float  fracDepth,
double  hadE 
)

Referenced by convert().

◆ hadShwrPos() [2/2]

GlobalPoint CaloTowersCreationAlgo::hadShwrPos ( CaloTowerDetId  id,
float  fracDepth 
)

Definition at line 1484 of file CaloTowersCreationAlgo.cc.

References funct::abs(), CaloTowerConstituentsMap::constituentsOf(), CaloTowerTopology::convertCTtoHcal(), gather_cfg::cout, HcalDetId::depth(), CaloTowerTopology::firstHFRing(), hadShwPosFromCells(), DetId::Hcal, HcalForward, HcalOuter, mps_fire::i, HcalTopology::idBack(), HcalTopology::idFront(), l1tPhase2CaloJetEmulator_cfi::iEta, mps_monitormerge::items, dqmdumpme::k, CaloTowerTopology::lastHERing(), point, HcalDetId::subdet(), theHcalPhase, theHcalTopology, theTowerConstituentsMap, theTowerTopology, ecaldqm::towerId(), and HcalTopology::validHcal().

1484  {
1485  // set depth using geometry of cells that are associated with the
1486  // tower (regardless if they have non-zero energies)
1487 
1488  // if (hadE <= 0) return GlobalPoint(0, 0, 0);
1489 #ifdef EDM_ML_DEBUG
1490  std::cout << "hadShwrPos " << towerId << " frac " << fracDepth << std::endl;
1491 #endif
1492  if (fracDepth < 0)
1493  fracDepth = 0;
1494  else if (fracDepth > 1)
1495  fracDepth = 1;
1496 
1497  GlobalPoint point(0, 0, 0);
1498 
1499  int iEta = towerId.ieta();
1500  int iPhi = towerId.iphi();
1501 
1502  HcalDetId frontCellId, backCellId;
1503 
1504  if (towerId.ietaAbs() >= theTowerTopology->firstHFRing()) {
1505  // forward, take the geometry for long fibers
1506  frontCellId = HcalDetId(HcalForward, towerId.zside() * theTowerTopology->convertCTtoHcal(abs(iEta)), iPhi, 1);
1507  backCellId = HcalDetId(HcalForward, towerId.zside() * theTowerTopology->convertCTtoHcal(abs(iEta)), iPhi, 1);
1508  } else {
1509  //use constituents map
1510  std::vector<DetId> items = theTowerConstituentsMap->constituentsOf(towerId);
1511  int frontDepth = 1000;
1512  int backDepth = -1000;
1513  for (unsigned i = 0; i < items.size(); i++) {
1514  if (items[i].det() != DetId::Hcal)
1515  continue;
1516  HcalDetId hid(items[i]);
1517  if (hid.subdet() == HcalOuter)
1518  continue;
1519  if (!theHcalTopology->validHcal(hid, 2))
1520  continue;
1521 
1522  if (theHcalTopology->idFront(hid).depth() < frontDepth) {
1523  frontCellId = hid;
1524  frontDepth = theHcalTopology->idFront(hid).depth();
1525  }
1526  if (theHcalTopology->idBack(hid).depth() > backDepth) {
1527  backCellId = hid;
1528  backDepth = theHcalTopology->idBack(hid).depth();
1529  }
1530  }
1531 #ifdef EDM_ML_DEBUG
1532  std::cout << "Front " << frontCellId << " Back " << backCellId << " Depths " << frontDepth << ":" << backDepth
1533  << std::endl;
1534 #endif
1535  //fix for tower 28/29 - no tower 29 at highest depths
1536  if (towerId.ietaAbs() == theTowerTopology->lastHERing() && (theHcalPhase == 0 || theHcalPhase == 1)) {
1537  CaloTowerDetId towerId28(towerId.ieta() - towerId.zside(), towerId.iphi());
1538  std::vector<DetId> items28 = theTowerConstituentsMap->constituentsOf(towerId28);
1539 #ifdef EDM_ML_DEBUG
1540  std::cout << towerId28 << " with " << items28.size() << " constituents:";
1541  for (unsigned k = 0; k < items28.size(); ++k)
1542  if (items28[k].det() == DetId::Hcal)
1543  std::cout << " " << HcalDetId(items28[k]);
1544  std::cout << std::endl;
1545 #endif
1546  for (unsigned i = 0; i < items28.size(); i++) {
1547  if (items28[i].det() != DetId::Hcal)
1548  continue;
1549  HcalDetId hid(items28[i]);
1550  if (hid.subdet() == HcalOuter)
1551  continue;
1552 
1553  if (theHcalTopology->idBack(hid).depth() > backDepth) {
1554  backCellId = hid;
1555  backDepth = theHcalTopology->idBack(hid).depth();
1556  }
1557  }
1558  }
1559 #ifdef EDM_ML_DEBUG
1560  std::cout << "Back " << backDepth << " ID " << backCellId << std::endl;
1561 #endif
1562  }
1563  point = hadShwPosFromCells(DetId(frontCellId), DetId(backCellId), fracDepth);
1564 
1565  return point;
1566 }
mps_fire.i
i
Definition: mps_fire.py:429
CaloTowerTopology::lastHERing
int lastHERing() const
Definition: CaloTowerTopology.h:39
HcalTopology::idFront
HcalDetId idFront(const HcalDetId &id) const
Definition: HcalTopology.h:167
ecaldqm::towerId
unsigned towerId(DetId const &, EcalElectronicsMapping const *)
Definition: EcalDQMCommonUtils.cc:77
CaloTowerTopology::convertCTtoHcal
int convertCTtoHcal(int ct_ieta) const
Definition: CaloTowerTopology.cc:68
HcalTopology::idBack
HcalDetId idBack(const HcalDetId &id) const
Definition: HcalTopology.h:168
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
DetId
Definition: DetId.h:17
mps_monitormerge.items
list items
Definition: mps_monitormerge.py:29
l1tPhase2CaloJetEmulator_cfi.iEta
iEta
Definition: l1tPhase2CaloJetEmulator_cfi.py:24
CaloTowersCreationAlgo::hadShwPosFromCells
GlobalPoint hadShwPosFromCells(DetId frontCell, DetId backCell, float fracDepth)
Definition: CaloTowersCreationAlgo.cc:1568
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
HcalTopology::validHcal
bool validHcal(const HcalDetId &id) const
Definition: HcalTopology.cc:171
CaloTowerTopology::firstHFRing
int firstHFRing() const
Definition: CaloTowerTopology.h:40
gather_cfg.cout
cout
Definition: gather_cfg.py:144
CaloTowerConstituentsMap::constituentsOf
std::vector< DetId > constituentsOf(const CaloTowerDetId &id) const
Get the constituent detids for this tower id ( not yet implemented )
Definition: CaloTowerConstituentsMap.cc:70
point
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
Definition: invegas.h:5
HcalDetId::depth
constexpr int depth() const
get the tower depth
Definition: HcalDetId.h:164

◆ hcalChanStatusForCaloTower()

unsigned int CaloTowersCreationAlgo::hcalChanStatusForCaloTower ( const CaloRecHit *  hit)

Definition at line 1781 of file CaloTowersCreationAlgo.cc.

References BadChan, gather_cfg::cout, HcalSeverityLevelComputer::getSeverityLevel(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), GoodChan, HcalTopology::idFront(), IgnoredChan, ProblematicChan, RecoveredChan, HcalSeverityLevelComputer::recoveredRecHit(), interestingDetIdCollectionProducer_cfi::severityLevel, theHcalAcceptSeverityLevel, theHcalAcceptSeverityLevelForRejectedHit, theHcalChStatus, theHcalSevLvlComputer, theHcalTopology, theRecoveredHcalHitsAreUsed, useRejectedHitsOnly, and useRejectedRecoveredHcalHits.

Referenced by assignHitHcal().

1781  {
1782  HcalDetId hid(hit->detid());
1783  DetId id = theHcalTopology->idFront(hid);
1784 #ifdef EDM_ML_DEBUG
1785  std::cout << "ChanStatusForCaloTower for " << hid << " to " << HcalDetId(id) << std::endl;
1786 #endif
1787  const uint32_t recHitFlag = hit->flags();
1788  const uint32_t dbStatusFlag = theHcalChStatus->getValues(id)->getValue();
1789 
1790  int severityLevel = theHcalSevLvlComputer->getSeverityLevel(id, recHitFlag, dbStatusFlag);
1791  bool isRecovered = theHcalSevLvlComputer->recoveredRecHit(id, recHitFlag);
1792 
1793  // For use with hits rejected in the default reconstruction
1794  if (useRejectedHitsOnly) {
1795  if (!isRecovered) {
1796  if (severityLevel <= int(theHcalAcceptSeverityLevel) ||
1797  severityLevel > int(theHcalAcceptSeverityLevelForRejectedHit))
1798  return CaloTowersCreationAlgo::IgnoredChan;
1799  // this hit was either already accepted or is worse than
1800  } else {
1801  if (theRecoveredHcalHitsAreUsed || !useRejectedRecoveredHcalHits) {
1802  // skip recovered hits either because they were already used or because there was an explicit instruction
1803  return CaloTowersCreationAlgo::IgnoredChan;
1804  } else if (useRejectedRecoveredHcalHits) {
1805  return CaloTowersCreationAlgo::RecoveredChan;
1806  }
1807 
1808  } // recovered channels
1809 
1810  // clasify channels as problematic: no good hits are supposed to be present in the
1811  // extra rechit collections
1812  return CaloTowersCreationAlgo::ProblematicChan;
1813 
1814  } // treatment of rejected hits
1815 
1816  // this is for the regular reconstruction sequence
1817 
1818  if (severityLevel == 0)
1819  return CaloTowersCreationAlgo::GoodChan;
1820 
1821  if (isRecovered) {
1822  return (theRecoveredHcalHitsAreUsed) ? CaloTowersCreationAlgo::RecoveredChan : CaloTowersCreationAlgo::BadChan;
1823  } else {
1824  if (severityLevel > int(theHcalAcceptSeverityLevel)) {
1825  return CaloTowersCreationAlgo::BadChan;
1826  } else {
1827  return CaloTowersCreationAlgo::ProblematicChan;
1828  }
1829  }
1830 }
CaloTowersCreationAlgo::theHcalChStatus
const HcalChannelQuality * theHcalChStatus
Definition: CaloTowersCreationAlgo.h:337
HcalSeverityLevelComputer::recoveredRecHit
bool recoveredRecHit(const DetId &myid, const uint32_t &myflag) const
Definition: HcalSeverityLevelComputer.cc:363
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:161
HcalTopology::idFront
HcalDetId idFront(const HcalDetId &id) const
Definition: HcalTopology.h:167
HcalChannelStatus::getValue
uint32_t getValue() const
Definition: HcalChannelStatus.h:60
CaloTowersCreationAlgo::theHcalSevLvlComputer
const HcalSeverityLevelComputer * theHcalSevLvlComputer
Definition: CaloTowersCreationAlgo.h:340
DetId
Definition: DetId.h:17
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
HcalSeverityLevelComputer::getSeverityLevel
int getSeverityLevel(const DetId &myid, const uint32_t &myflag, const uint32_t &mystatus) const
Definition: HcalSeverityLevelComputer.cc:304
gather_cfg.cout
cout
Definition: gather_cfg.py:144
CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
unsigned int theHcalAcceptSeverityLevelForRejectedHit
Definition: CaloTowersCreationAlgo.h:357
interestingDetIdCollectionProducer_cfi.severityLevel
severityLevel
Definition: interestingDetIdCollectionProducer_cfi.py:10

◆ makeEcalBadChs()

void CaloTowersCreationAlgo::makeEcalBadChs ( )

Definition at line 1738 of file CaloTowersCreationAlgo.cc.

References CaloTowerConstituentsMap::constituentsOf(), CaloTowerTopology::detIdFromDenseIndex(), DetId::Ecal, ecalBadChs, spr::find(), EcalSeverityLevelAlgo::severityLevel(), CaloTowerTopology::sizeForDenseIndexing(), theEcalSeveritiesToBeExcluded, theEcalSevLvlAlgo, theTowerConstituentsMap, theTowerTopology, and mitigatedMETSequence_cff::U.

Referenced by CaloTowersCreator::produce().

1738  {
1739  // std::cout << "VI making EcalBadChs ";
1740 
1741  // for ECAL the number of all bad channels is obtained here -----------------------
1742 
1743  for (auto ind = 0U; ind < theTowerTopology->sizeForDenseIndexing(); ++ind) {
1744  auto& numBadEcalChan = ecalBadChs[ind];
1745  numBadEcalChan = 0;
1746  auto id = theTowerTopology->detIdFromDenseIndex(ind);
1747 
1748  // this is utterly slow... (can be optmized if really needed)
1749 
1750  // get all possible constituents of the tower
1751  std::vector<DetId> allConstituents = theTowerConstituentsMap->constituentsOf(id);
1752 
1753  for (std::vector<DetId>::iterator ac_it = allConstituents.begin(); ac_it != allConstituents.end(); ++ac_it) {
1754  if (ac_it->det() != DetId::Ecal)
1755  continue;
1756 
1757  auto thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel(*ac_it);
1758 
1759  // check if the Ecal severity is ok to keep
1760  std::vector<int>::const_iterator sevit =
1761  std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), thisEcalSevLvl);
1762  if (sevit != theEcalSeveritiesToBeExcluded.end()) {
1763  ++numBadEcalChan;
1764  }
1765  }
1766 
1767  // if (0!=numBadEcalChan) std::cout << id << ":" << numBadEcalChan << ", ";
1768  }
1769 
1770  /*
1771  int tot=0;
1772  for (auto ind=0U; ind<theTowerTopology->sizeForDenseIndexing(); ++ind) {
1773  if (ecalBadChs[ind]!=0) ++tot;
1774  }
1775  std::cout << " | " << tot << std::endl;
1776  */
1777 }
CaloTowerTopology::sizeForDenseIndexing
uint32_t sizeForDenseIndexing() const
Definition: CaloTowerTopology.h:56
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
mitigatedMETSequence_cff.U
U
Definition: mitigatedMETSequence_cff.py:36
EcalSeverityLevelAlgo::severityLevel
EcalSeverityLevel::SeverityLevel severityLevel(const DetId &id) const
Evaluate status from id use channelStatus from DB.
Definition: EcalSeverityLevelAlgo.cc:85
CaloTowerTopology::detIdFromDenseIndex
CaloTowerDetId detIdFromDenseIndex(uint32_t din) const
Definition: CaloTowerTopology.cc:248
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded
std::vector< int > theEcalSeveritiesToBeExcluded
Definition: CaloTowersCreationAlgo.h:349
CaloTowersCreationAlgo::ecalBadChs
std::vector< unsigned short > ecalBadChs
Definition: CaloTowersCreationAlgo.h:394
CaloTowersCreationAlgo::theEcalSevLvlAlgo
const EcalSeverityLevelAlgo * theEcalSevLvlAlgo
Definition: CaloTowersCreationAlgo.h:343
CaloTowerConstituentsMap::constituentsOf
std::vector< DetId > constituentsOf(const CaloTowerDetId &id) const
Get the constituent detids for this tower id ( not yet implemented )
Definition: CaloTowerConstituentsMap.cc:70

◆ makeHcalDropChMap()

void CaloTowersCreationAlgo::makeHcalDropChMap ( )

Definition at line 1677 of file CaloTowersCreationAlgo.cc.

References CaloTowerConstituentsMap::constituentsOf(), gather_cfg::cout, HcalSeverityLevelComputer::dropChannel(), HcalCondObjectContainer< Item >::getAllChannels(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalBarrel, hcalDropChMap, HcalEndcap, CaloTowerDetId::ieta(), HcalDetId::ietaAbs(), CaloTowerDetId::iphi(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, HcalTopology::lastHERing(), HcalTopology::mergedDepth29(), HcalTopology::mergedDepthDetId(), missingHcalRescaleFactorForEcal, HcalDetId::subdet(), theHcalChStatus, theHcalPhase, theHcalSevLvlComputer, theHcalTopology, theTowerConstituentsMap, CaloTowerConstituentsMap::towerOf(), and CaloTowerDetId::zside().

Referenced by CaloTowersCreator::produce().

1677  {
1678  // This method fills the map of number of dead channels for the calotower,
1679  // The key of the map is CaloTowerDetId.
1680  // By definition these channels are not going to be in the RecHit collections.
1681  hcalDropChMap.clear();
1682  std::vector<DetId> allChanInStatusCont = theHcalChStatus->getAllChannels();
1683 
1684 #ifdef EDM_ML_DEBUG
1685  std::cout << "DropChMap with " << allChanInStatusCont.size() << " channels" << std::endl;
1686 #endif
1687  for (std::vector<DetId>::iterator it = allChanInStatusCont.begin(); it != allChanInStatusCont.end(); ++it) {
1688  const uint32_t dbStatusFlag = theHcalChStatus->getValues(*it)->getValue();
1689  if (theHcalSevLvlComputer->dropChannel(dbStatusFlag)) {
1690  DetId id = theHcalTopology->mergedDepthDetId(HcalDetId(*it));
1691 
1692  CaloTowerDetId twrId = theTowerConstituentsMap->towerOf(id);
1693 
1694  hcalDropChMap[twrId].first += 1;
1695 
1696  HcalDetId hid(*it);
1697 
1698  // special case for tower 29: if HCAL hit is in depth 3 add to twr 29 as well
1699  if (hid.subdet() == HcalEndcap && (theHcalPhase == 0 || theHcalPhase == 1) &&
1700  hid.ietaAbs() == theHcalTopology->lastHERing() - 1) {
1701  bool merge = theHcalTopology->mergedDepth29(hid);
1702  if (merge) {
1703  CaloTowerDetId twrId29(twrId.ieta() + twrId.zside(), twrId.iphi());
1704  hcalDropChMap[twrId29].first += 1;
1705  }
1706  }
1707  }
1708  }
1709  // now I know how many bad channels, but I also need to know if there's any good ones
1710  if (missingHcalRescaleFactorForEcal > 0) {
1711  for (auto& pair : hcalDropChMap) {
1712  if (pair.second.first == 0)
1713  continue; // unexpected, but just in case
1714  int ngood = 0, nbad = 0;
1715  for (DetId id : theTowerConstituentsMap->constituentsOf(pair.first)) {
1716  if (id.det() != DetId::Hcal)
1717  continue;
1718  HcalDetId hid(id);
1719  if (hid.subdet() != HcalBarrel && hid.subdet() != HcalEndcap)
1720  continue;
1721  const uint32_t dbStatusFlag = theHcalChStatus->getValues(id)->getValue();
1722  if (dbStatusFlag == 0 || !theHcalSevLvlComputer->dropChannel(dbStatusFlag)) {
1723  ngood += 1;
1724  } else {
1725  nbad += 1; // recount, since pair.second.first may include HO
1726  }
1727  }
1728  if (nbad > 0 && nbad >= ngood) {
1729  //uncomment for debug (may be useful to tune the criteria above)
1730  //CaloTowerDetId id(pair.first);
1731  //std::cout << "CaloTower at ieta = " << id.ieta() << ", iphi " << id.iphi() << ": set Hcal as not efficient (ngood =" << ngood << ", nbad = " << nbad << ")" << std::endl;
1732  pair.second.second = true;
1733  }
1734  }
1735  }
1736 }
HcalTopology::mergedDepth29
bool mergedDepth29(HcalDetId id) const
Definition: HcalTopology.h:108
merge
Definition: merge.py:1
CaloTowersCreationAlgo::theHcalChStatus
const HcalChannelQuality * theHcalChStatus
Definition: CaloTowersCreationAlgo.h:337
CaloTowerConstituentsMap::towerOf
CaloTowerDetId towerOf(const DetId &id) const
Get the tower id for this det id (or null if not known)
Definition: CaloTowerConstituentsMap.cc:27
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:161
HcalCondObjectContainer::getAllChannels
std::vector< DetId > getAllChannels() const
Definition: HcalCondObjectContainer.h:314
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
HcalChannelStatus::getValue
uint32_t getValue() const
Definition: HcalChannelStatus.h:60
CaloTowersCreationAlgo::theHcalSevLvlComputer
const HcalSeverityLevelComputer * theHcalSevLvlComputer
Definition: CaloTowersCreationAlgo.h:340
DetId
Definition: DetId.h:17
CaloTowerDetId::iphi
int iphi() const
get the tower iphi
Definition: CaloTowerDetId.cc:30
CaloTowerDetId::ieta
int ieta() const
get the tower ieta
Definition: CaloTowerDetId.h:30
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
HcalTopology::mergedDepthDetId
HcalDetId mergedDepthDetId(const HcalDetId &id) const
Definition: HcalTopology.h:163
ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it
auto & it
Definition: splitVertices.h:28
CaloTowerDetId::zside
int zside() const
get the z-side of the tower (1/-1)
Definition: CaloTowerDetId.h:26
HcalTopology::lastHERing
int lastHERing() const
Definition: HcalTopology.h:91
gather_cfg.cout
cout
Definition: gather_cfg.py:144
CaloTowerConstituentsMap::constituentsOf
std::vector< DetId > constituentsOf(const CaloTowerDetId &id) const
Get the constituent detids for this tower id ( not yet implemented )
Definition: CaloTowerConstituentsMap.cc:70
HcalSeverityLevelComputer::dropChannel
bool dropChannel(const uint32_t &mystatus) const
Definition: HcalSeverityLevelComputer.cc:395

◆ process() [1/5]

void CaloTowersCreationAlgo::process ( const HBHERecHitCollection &  hbhe)

Definition at line 381 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::hbhe.

Referenced by CaloTowersCreator::produce().

381  {
382  for (HBHERecHitCollection::const_iterator hbheItr = hbhe.begin(); hbheItr != hbhe.end(); ++hbheItr)
383  assignHitHcal(&(*hbheItr));
384 }
CaloTowersCreationAlgo::assignHitHcal
void assignHitHcal(const CaloRecHit *recHit)
Definition: CaloTowersCreationAlgo.cc:541
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:80
photonIsolationHIProducer_cfi.hbhe
hbhe
Definition: photonIsolationHIProducer_cfi.py:8

◆ process() [2/5]

void CaloTowersCreationAlgo::process ( const HORecHitCollection &  ho)

Definition at line 386 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::ho.

386  {
387  for (HORecHitCollection::const_iterator hoItr = ho.begin(); hoItr != ho.end(); ++hoItr)
388  assignHitHcal(&(*hoItr));
389 }
CaloTowersCreationAlgo::assignHitHcal
void assignHitHcal(const CaloRecHit *recHit)
Definition: CaloTowersCreationAlgo.cc:541
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:80
photonIsolationHIProducer_cfi.ho
ho
Definition: photonIsolationHIProducer_cfi.py:10

◆ process() [3/5]

void CaloTowersCreationAlgo::process ( const HFRecHitCollection &  hf)

Definition at line 391 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::hf.

391  {
392  for (HFRecHitCollection::const_iterator hfItr = hf.begin(); hfItr != hf.end(); ++hfItr)
393  assignHitHcal(&(*hfItr));
394 }
CaloTowersCreationAlgo::assignHitHcal
void assignHitHcal(const CaloRecHit *recHit)
Definition: CaloTowersCreationAlgo.cc:541
edm::SortedCollection::const_iterator
std::vector< T >::const_iterator const_iterator
Definition: SortedCollection.h:80
photonIsolationHIProducer_cfi.hf
hf
Definition: photonIsolationHIProducer_cfi.py:9

◆ process() [4/5]

void CaloTowersCreationAlgo::process ( const EcalRecHitCollection &  ecal)

Definition at line 396 of file CaloTowersCreationAlgo.cc.

References assignHitEcal(), edm::SortedCollection< T, SORT >::begin(), and edm::SortedCollection< T, SORT >::end().

396  {
397  for (EcalRecHitCollection::const_iterator ecItr = ec.begin(); ecItr != ec.end(); ++ecItr)
398  assignHitEcal(&(*ecItr));
399 }
edm::SortedCollection< EcalRecHit >::const_iterator
std::vector< EcalRecHit >::const_iterator const_iterator
Definition: SortedCollection.h:80
CaloTowersCreationAlgo::assignHitEcal
void assignHitEcal(const EcalRecHit *recHit)
adds a single hit to the tower
Definition: CaloTowersCreationAlgo.cc:779

◆ process() [5/5]

void CaloTowersCreationAlgo::process ( const CaloTowerCollection &  ctc)

Definition at line 405 of file CaloTowersCreationAlgo.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), and rescale().

405  {
406  for (CaloTowerCollection::const_iterator ctcItr = ctc.begin(); ctcItr != ctc.end(); ++ctcItr) {
407  rescale(&(*ctcItr));
408  }
409 }
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:80
CaloTowersCreationAlgo::rescale
void rescale(const CaloTower *ct)
Definition: CaloTowersCreationAlgo.cc:871
edm::SortedCollection::begin
const_iterator begin() const
Definition: SortedCollection.h:262
edm::SortedCollection::end
const_iterator end() const
Definition: SortedCollection.h:267

◆ rescale()

void CaloTowersCreationAlgo::rescale ( const CaloTower *  ct)
private

Definition at line 871 of file CaloTowersCreationAlgo.cc.

References hgcalPlots::ct, HcalDetId::depth(), hcalRecHitTable_cff::detId, DetId::Ecal, find(), getThresholdAndWeight(), HcalForward, HcalOuter, mps_fire::i, CaloTowersParam_cfi::mc, DetId::null(), HcalDetId::subdet(), theTowerConstituentsMap, DiMuonV_cfg::threshold, l1tHGCalTowerProducer_cfi::tower, CaloTowerConstituentsMap::towerOf(), and mps_merge::weight.

Referenced by process().

871  {
872  double threshold, weight;
873  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(ct->id());
874  if (towerDetId.null())
875  return;
876  MetaTower& tower = find(towerDetId);
877 
878  tower.E_em = 0.;
879  tower.E_had = 0.;
880  tower.E_outer = 0.;
881  for (unsigned int i = 0; i < ct->constituentsSize(); i++) {
882  DetId detId = ct->constituent(i);
883  getThresholdAndWeight(detId, threshold, weight);
884  DetId::Detector det = detId.det();
885  if (det == DetId::Ecal) {
886  tower.E_em = ct->emEnergy() * weight;
887  } else {
888  HcalDetId hcalDetId(detId);
889  if (hcalDetId.subdet() == HcalForward) {
890  if (hcalDetId.depth() == 1)
891  tower.E_em = ct->emEnergy() * weight;
892  if (hcalDetId.depth() == 2)
893  tower.E_had = ct->hadEnergy() * weight;
894  } else if (hcalDetId.subdet() == HcalOuter) {
895  tower.E_outer = ct->outerEnergy() * weight;
896  } else {
897  tower.E_had = ct->hadEnergy() * weight;
898  }
899  }
900  tower.E = tower.E_had + tower.E_em + tower.E_outer;
901 
902  // this is to be compliant with the new MetaTower setup
903  // used only for the default simple vector assignment
904  std::pair<DetId, float> mc(detId, 0);
905  tower.metaConstituents.push_back(mc);
906  }
907 
908  // preserve time inforamtion
909  tower.emSumTimeTimesE = ct->ecalTime();
910  tower.hadSumTimeTimesE = ct->hcalTime();
911  tower.emSumEForTime = 1.0;
912  tower.hadSumEForTime = 1.0;
913 }
CaloTowersParam_cfi.mc
mc
Definition: CaloTowersParam_cfi.py:8
mps_fire.i
i
Definition: mps_fire.py:429
CaloTowersCreationAlgo::getThresholdAndWeight
void getThresholdAndWeight(const DetId &detId, double &threshold, double &weight) const
helper method to look up the appropriate threshold & weight
Definition: CaloTowersCreationAlgo.cc:1250
CaloTowerConstituentsMap::towerOf
CaloTowerDetId towerOf(const DetId &id) const
Get the tower id for this det id (or null if not known)
Definition: CaloTowerConstituentsMap.cc:27
weight
Definition: weight.py:1
CaloTowersCreationAlgo::find
MetaTower & find(const CaloTowerDetId &id)
looks for a given tower in the internal cache. If it can&#39;t find it, it makes it.
Definition: CaloTowersCreationAlgo.cc:915
DetId::null
constexpr bool null() const
is this a null id ?
Definition: DetId.h:59
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
hcalRecHitTable_cff.detId
detId
Definition: hcalRecHitTable_cff.py:12
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:101
DetId
Definition: DetId.h:17
DetId::Detector
Detector
Definition: DetId.h:24
mps_merge.weight
weight
Definition: mps_merge.py:88
l1tHGCalTowerProducer_cfi.tower
tower
Definition: l1tHGCalTowerProducer_cfi.py:4

◆ rescaleTowers()

void CaloTowersCreationAlgo::rescaleTowers ( const CaloTowerCollection &  ctInput,
CaloTowerCollection &  ctResult 
)

Definition at line 433 of file CaloTowersCreationAlgo.cc.

References CaloTower::addConstituents(), edm::SortedCollection< T, SORT >::begin(), edm::contains(), DetId::det(), DetId::Ecal, edm::SortedCollection< T, SORT >::end(), PV3DBase< T, PVType, FrameType >::eta(), CaloTowerTopology::firstHERing(), CaloTowerTopology::firstHFRing(), getThresholdAndWeight(), DetId::Hcal, HcalOuter, CaloTowerDetId::ietaAbs(), CaloTowerTopology::lastHBRing(), CaloTowerTopology::lastHERing(), CaloTowerTopology::lastHFRing(), CaloTowerTopology::lastHORing(), PV3DBase< T, PVType, FrameType >::phi(), edm::SortedCollection< T, SORT >::push_back(), CaloTower::setCaloTowerStatus(), CaloTower::setEcalTime(), CaloTower::setHcalSubdet(), CaloTower::setHcalTime(), HcalDetId::subdet(), theHF1weight, theHF2weight, theHOIsUsed, theTowerTopology, DiMuonV_cfg::threshold, and mps_merge::weight.

Referenced by CaloTowersReCreator::produce().

433  {
434  for (CaloTowerCollection::const_iterator ctcItr = ctc.begin(); ctcItr != ctc.end(); ++ctcItr) {
435  CaloTowerDetId twrId = ctcItr->id();
436  double newE_em = ctcItr->emEnergy();
437  double newE_had = ctcItr->hadEnergy();
438  double newE_outer = ctcItr->outerEnergy();
439 
440  double threshold = 0.0; // not used: we do not change thresholds
441  double weight = 1.0;
442 
443  // HF
444  if (ctcItr->ietaAbs() >= theTowerTopology->firstHFRing()) {
445  double E_short = 0.5 * newE_had; // from the definitions for HF
446  double E_long = newE_em + 0.5 * newE_had; //
447  // scale
448  E_long *= theHF1weight;
449  E_short *= theHF2weight;
450  // convert
451  newE_em = E_long - E_short;
452  newE_had = 2.0 * E_short;
453  }
454 
455  else { // barrel/endcap
456 
457  // find if its in EB, or EE; determine from first ecal constituent found
458  for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
459  DetId constId = ctcItr->constituent(iConst);
460  if (constId.det() != DetId::Ecal)
461  continue;
462  getThresholdAndWeight(constId, threshold, weight);
463  newE_em *= weight;
464  break;
465  }
466  // HO
467  for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
468  DetId constId = ctcItr->constituent(iConst);
469  if (constId.det() != DetId::Hcal)
470  continue;
471  if (HcalDetId(constId).subdet() != HcalOuter)
472  continue;
473  getThresholdAndWeight(constId, threshold, weight);
474  newE_outer *= weight;
475  break;
476  }
477  // HB/HE
478  for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
479  DetId constId = ctcItr->constituent(iConst);
480  if (constId.det() != DetId::Hcal)
481  continue;
482  if (HcalDetId(constId).subdet() == HcalOuter)
483  continue;
484  getThresholdAndWeight(constId, threshold, weight);
485  newE_had *= weight;
486  if (ctcItr->ietaAbs() > theTowerTopology->firstHERing())
487  newE_outer *= weight;
488  break;
489  }
490 
491  } // barrel/endcap region
492 
493  // now make the new tower
494 
495  double newE_hadTot =
496  (theHOIsUsed && twrId.ietaAbs() <= theTowerTopology->lastHORing()) ? newE_had + newE_outer : newE_had;
497 
498  GlobalPoint emPoint = ctcItr->emPosition();
499  GlobalPoint hadPoint = ctcItr->emPosition();
500 
501  double f_em = 1.0 / cosh(emPoint.eta());
502  double f_had = 1.0 / cosh(hadPoint.eta());
503 
504  CaloTower::PolarLorentzVector towerP4;
505 
506  if (ctcItr->ietaAbs() < theTowerTopology->firstHFRing()) {
507  if (newE_em > 0)
508  towerP4 += CaloTower::PolarLorentzVector(newE_em * f_em, emPoint.eta(), emPoint.phi(), 0);
509  if (newE_hadTot > 0)
510  towerP4 += CaloTower::PolarLorentzVector(newE_hadTot * f_had, hadPoint.eta(), hadPoint.phi(), 0);
511  } else {
512  double newE_tot = newE_em + newE_had;
513  // for HF we use common point for ecal, hcal shower positions regardless of the method
514  if (newE_tot > 0)
515  towerP4 += CaloTower::PolarLorentzVector(newE_tot * f_had, hadPoint.eta(), hadPoint.phi(), 0);
516  }
517 
518  CaloTower rescaledTower(twrId, newE_em, newE_had, newE_outer, -1, -1, towerP4, emPoint, hadPoint);
519  // copy the timings, have to convert back to int, 1 unit = 0.01 ns
520  rescaledTower.setEcalTime(int(ctcItr->ecalTime() * 100.0 + 0.5));
521  rescaledTower.setHcalTime(int(ctcItr->hcalTime() * 100.0 + 0.5));
522  //add topology info
523  rescaledTower.setHcalSubdet(theTowerTopology->lastHBRing(),
524  theTowerTopology->lastHERing(),
525  theTowerTopology->lastHFRing(),
526  theTowerTopology->lastHORing());
527 
528  std::vector<DetId> contains;
529  for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
530  contains.push_back(ctcItr->constituent(iConst));
531  }
532  rescaledTower.addConstituents(contains);
533 
534  rescaledTower.setCaloTowerStatus(ctcItr->towerStatusWord());
535 
536  ctcResult.push_back(rescaledTower);
537 
538  } // end of loop over towers
539 }
edm::contains
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:37
CaloTowerDetId::ietaAbs
int ietaAbs() const
get the absolute value of the tower ieta
Definition: CaloTowerDetId.h:28
CaloTowersCreationAlgo::getThresholdAndWeight
void getThresholdAndWeight(const DetId &detId, double &threshold, double &weight) const
helper method to look up the appropriate threshold & weight
Definition: CaloTowersCreationAlgo.cc:1250
PV3DBase::phi
Geom::Phi< T > phi() const
Definition: PV3DBase.h:66
reco::LeafCandidate::PolarLorentzVector
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
Definition: LeafCandidate.h:25
PV3DBase::eta
T eta() const
Definition: PV3DBase.h:73
edm::SortedCollection< CaloTower >::const_iterator
std::vector< CaloTower >::const_iterator const_iterator
Definition: SortedCollection.h:80
weight
Definition: weight.py:1
CaloTowerTopology::lastHFRing
int lastHFRing() const
Definition: CaloTowerTopology.h:41
DetId::det
constexpr Detector det() const
get the detector field from this detid
Definition: DetId.h:46
CaloTowerTopology::lastHERing
int lastHERing() const
Definition: CaloTowerTopology.h:39
CaloTowerTopology::lastHORing
int lastHORing() const
Definition: CaloTowerTopology.h:43
HcalDetId::subdet
constexpr HcalSubdetector subdet() const
get the subdetector
Definition: HcalDetId.h:138
CaloTowerTopology::firstHERing
int firstHERing() const
Definition: CaloTowerTopology.h:38
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
CaloTowersCreationAlgo::theHOIsUsed
bool theHOIsUsed
only affects energy and ET calculation. HO is still recorded in the tower
Definition: CaloTowersCreationAlgo.h:367
DiMuonV_cfg.threshold
threshold
Definition: DiMuonV_cfg.py:101
DetId
Definition: DetId.h:17
CaloTowerTopology::firstHFRing
int firstHFRing() const
Definition: CaloTowerTopology.h:40
mps_merge.weight
weight
Definition: mps_merge.py:88
CaloTowerTopology::lastHBRing
int lastHBRing() const
Definition: CaloTowerTopology.h:37
reco::Candidate::PolarLorentzVector
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
Definition: Candidate.h:38

◆ setEBEScale()

void CaloTowersCreationAlgo::setEBEScale ( double  scale)

Definition at line 1369 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theEBEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1369  {
1370  if (scale > 0.00001)
1371  *&theEBEScale = scale;
1372  else
1373  *&theEBEScale = 50.;
1374 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setEbHandle()

void CaloTowersCreationAlgo::setEbHandle ( const edm::Handle< EcalRecHitCollection >  eb)
inline

Definition at line 247 of file CaloTowersCreationAlgo.h.

References theEbHandle.

Referenced by CaloTowersCreator::produce().

247 { theEbHandle = eb; }
CaloTowersCreationAlgo::theEbHandle
edm::Handle< EcalRecHitCollection > theEbHandle
Definition: CaloTowersCreationAlgo.h:403

◆ setEcalChStatusFromDB()

void CaloTowersCreationAlgo::setEcalChStatusFromDB ( const EcalChannelStatus *  s)
inline

Definition at line 171 of file CaloTowersCreationAlgo.h.

References alignCSCRings::s, and theEcalChStatus.

Referenced by CaloTowersCreator::produce().

171 { theEcalChStatus = s; }
CaloTowersCreationAlgo::theEcalChStatus
const EcalChannelStatus * theEcalChStatus
Definition: CaloTowersCreationAlgo.h:336

◆ setEcalSeveritiesToBeExcluded()

void CaloTowersCreationAlgo::setEcalSeveritiesToBeExcluded ( const std::vector< int > &  ecalSev)
inline

Definition at line 213 of file CaloTowersCreationAlgo.h.

References theEcalSeveritiesToBeExcluded.

Referenced by CaloTowersCreator::produce().

213 { theEcalSeveritiesToBeExcluded = ecalSev; }
CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded
std::vector< int > theEcalSeveritiesToBeExcluded
Definition: CaloTowersCreationAlgo.h:349

◆ SetEcalSeveritiesToBeUsedInBadTowers()

void CaloTowersCreationAlgo::SetEcalSeveritiesToBeUsedInBadTowers ( const std::vector< int > &  ecalSev)
inline

Definition at line 235 of file CaloTowersCreationAlgo.h.

References theEcalSeveritiesToBeUsedInBadTowers.

Referenced by CaloTowersCreator::produce().

235  {
236  theEcalSeveritiesToBeUsedInBadTowers = ecalSev;
237  }
CaloTowersCreationAlgo::theEcalSeveritiesToBeUsedInBadTowers
std::vector< int > theEcalSeveritiesToBeUsedInBadTowers
Definition: CaloTowersCreationAlgo.h:358

◆ setEcalSevLvlAlgo()

void CaloTowersCreationAlgo::setEcalSevLvlAlgo ( const EcalSeverityLevelAlgo *  a)
inline

Definition at line 223 of file CaloTowersCreationAlgo.h.

References a, and theEcalSevLvlAlgo.

Referenced by CaloTowersCreator::produce().

223 { theEcalSevLvlAlgo = a; }
CaloTowersCreationAlgo::theEcalSevLvlAlgo
const EcalSeverityLevelAlgo * theEcalSevLvlAlgo
Definition: CaloTowersCreationAlgo.h:343
a
double a
Definition: hdecay.h:121

◆ setEEEScale()

void CaloTowersCreationAlgo::setEEEScale ( double  scale)

Definition at line 1376 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theEEEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1376  {
1377  if (scale > 0.00001)
1378  *&theEEEScale = scale;
1379  else
1380  *&theEEEScale = 50.;
1381 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setEeHandle()

void CaloTowersCreationAlgo::setEeHandle ( const edm::Handle< EcalRecHitCollection >  ee)
inline

Definition at line 248 of file CaloTowersCreationAlgo.h.

References theEeHandle.

Referenced by CaloTowersCreator::produce().

248 { theEeHandle = ee; }
CaloTowersCreationAlgo::theEeHandle
edm::Handle< EcalRecHitCollection > theEeHandle
Definition: CaloTowersCreationAlgo.h:404

◆ setGeometry()

void CaloTowersCreationAlgo::setGeometry ( const CaloTowerTopology *  cttopo,
const CaloTowerConstituentsMap *  ctmap,
const HcalTopology *  htopo,
const CaloGeometry *  geo 
)

Definition at line 361 of file CaloTowersCreationAlgo.cc.

References DetId::Calo, ecalBadChs, CaloGeometry::getSubdetectorGeometry(), CaloTowerTopology::sizeForDenseIndexing(), CaloTowerDetId::SubdetId, theGeometry, theHcalTopology, theTowerConstituentsMap, theTowerGeometry, and theTowerTopology.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

364  {
365  theTowerTopology = cttopo;
366  theTowerConstituentsMap = ctmap;
367  theHcalTopology = htopo;
368  theGeometry = geo;
369  theTowerGeometry = geo->getSubdetectorGeometry(DetId::Calo, CaloTowerDetId::SubdetId);
370 
371  //initialize ecal bad channel map
372  ecalBadChs.resize(theTowerTopology->sizeForDenseIndexing(), 0);
373 }
CaloTowerTopology::sizeForDenseIndexing
uint32_t sizeForDenseIndexing() const
Definition: CaloTowerTopology.h:56
CaloTowersCreationAlgo::theTowerGeometry
const CaloSubdetectorGeometry * theTowerGeometry
Definition: CaloTowersCreationAlgo.h:333
CaloTowerDetId::SubdetId
static const int SubdetId
Definition: CaloTowerDetId.h:34
CaloTowersCreationAlgo::theGeometry
const CaloGeometry * theGeometry
Definition: CaloTowersCreationAlgo.h:331
CaloTowersCreationAlgo::theTowerConstituentsMap
const CaloTowerConstituentsMap * theTowerConstituentsMap
Definition: CaloTowersCreationAlgo.h:332
CaloTowersCreationAlgo::theTowerTopology
const CaloTowerTopology * theTowerTopology
Definition: CaloTowersCreationAlgo.h:329
CaloTowersCreationAlgo::theHcalTopology
const HcalTopology * theHcalTopology
Definition: CaloTowersCreationAlgo.h:330
CaloTowersCreationAlgo::ecalBadChs
std::vector< unsigned short > ecalBadChs
Definition: CaloTowersCreationAlgo.h:394
CaloGeometry::getSubdetectorGeometry
const CaloSubdetectorGeometry * getSubdetectorGeometry(const DetId &id) const
access the subdetector geometry for the given subdetector directly
Definition: CaloGeometry.cc:34

◆ setHBEScale()

void CaloTowersCreationAlgo::setHBEScale ( double  scale)

Definition at line 1383 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHBEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1383  {
1384  if (scale > 0.00001)
1385  *&theHBEScale = scale;
1386  else
1387  *&theHBEScale = 50.;
1388 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setHcalAcceptSeverityLevel()

void CaloTowersCreationAlgo::setHcalAcceptSeverityLevel ( unsigned int  level)
inline

Definition at line 212 of file CaloTowersCreationAlgo.h.

References personalPlayback::level, and theHcalAcceptSeverityLevel.

Referenced by CaloTowersCreator::produce().

212 { theHcalAcceptSeverityLevel = level; }

◆ setHcalAcceptSeverityLevelForRejectedHit()

void CaloTowersCreationAlgo::setHcalAcceptSeverityLevelForRejectedHit ( unsigned int  level)
inline

Definition at line 231 of file CaloTowersCreationAlgo.h.

References personalPlayback::level, and theHcalAcceptSeverityLevelForRejectedHit.

Referenced by CaloTowersCreator::produce().

231  {
232  theHcalAcceptSeverityLevelForRejectedHit = level;
233  }
CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
unsigned int theHcalAcceptSeverityLevelForRejectedHit
Definition: CaloTowersCreationAlgo.h:357

◆ setHcalChStatusFromDB()

void CaloTowersCreationAlgo::setHcalChStatusFromDB ( const HcalChannelQuality *  s)
inline

Definition at line 170 of file CaloTowersCreationAlgo.h.

References alignCSCRings::s, and theHcalChStatus.

Referenced by CaloTowersCreator::produce().

170 { theHcalChStatus = s; }
CaloTowersCreationAlgo::theHcalChStatus
const HcalChannelQuality * theHcalChStatus
Definition: CaloTowersCreationAlgo.h:337

◆ setHcalSevLvlComputer()

void CaloTowersCreationAlgo::setHcalSevLvlComputer ( const HcalSeverityLevelComputer *  c)
inline

Definition at line 220 of file CaloTowersCreationAlgo.h.

References DummyCfis::c, and theHcalSevLvlComputer.

Referenced by CaloTowersCreator::produce().

220 { theHcalSevLvlComputer = c; };
CaloTowersCreationAlgo::theHcalSevLvlComputer
const HcalSeverityLevelComputer * theHcalSevLvlComputer
Definition: CaloTowersCreationAlgo.h:340

◆ setHEDEScale()

void CaloTowersCreationAlgo::setHEDEScale ( double  scale)

Definition at line 1397 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHEDEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1397  {
1398  if (scale > 0.00001)
1399  *&theHEDEScale = scale;
1400  else
1401  *&theHEDEScale = 50.;
1402 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setHESEScale()

void CaloTowersCreationAlgo::setHESEScale ( double  scale)

Definition at line 1390 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHESEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1390  {
1391  if (scale > 0.00001)
1392  *&theHESEScale = scale;
1393  else
1394  *&theHESEScale = 50.;
1395 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setHF1EScale()

void CaloTowersCreationAlgo::setHF1EScale ( double  scale)

Definition at line 1411 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHF1EScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1411  {
1412  if (scale > 0.00001)
1413  *&theHF1EScale = scale;
1414  else
1415  *&theHF1EScale = 50.;
1416 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setHF2EScale()

void CaloTowersCreationAlgo::setHF2EScale ( double  scale)

Definition at line 1418 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHF2EScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1418  {
1419  if (scale > 0.00001)
1420  *&theHF2EScale = scale;
1421  else
1422  *&theHF2EScale = 50.;
1423 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setHOEScale()

void CaloTowersCreationAlgo::setHOEScale ( double  scale)

Definition at line 1404 of file CaloTowersCreationAlgo.cc.

References l1tEGammaCrystalsEmulatorProducer_cfi::scale, and theHOEScale.

Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().

1404  {
1405  if (scale > 0.00001)
1406  *&theHOEScale = scale;
1407  else
1408  *&theHOEScale = 50.;
1409 }
l1tEGammaCrystalsEmulatorProducer_cfi.scale
scale
Definition: l1tEGammaCrystalsEmulatorProducer_cfi.py:10

◆ setMissingHcalRescaleFactorForEcal()

void CaloTowersCreationAlgo::setMissingHcalRescaleFactorForEcal ( float  factor)
inline

Definition at line 241 of file CaloTowersCreationAlgo.h.

References missingHcalRescaleFactorForEcal.

Referenced by CaloTowersCreator::CaloTowersCreator().

241 { missingHcalRescaleFactorForEcal = factor; };
factor
factor
Definition: SiPixelDynamicInefficiency_PayloadInspector.cc:52

◆ setRecoveredEcalHitsAreUsed()

void CaloTowersCreationAlgo::setRecoveredEcalHitsAreUsed ( bool  flag)
inline

Definition at line 217 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and theRecoveredEcalHitsAreUsed.

Referenced by CaloTowersCreator::produce().

217 { theRecoveredEcalHitsAreUsed = flag; };

◆ setRecoveredHcalHitsAreUsed()

void CaloTowersCreationAlgo::setRecoveredHcalHitsAreUsed ( bool  flag)
inline

Definition at line 216 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and theRecoveredHcalHitsAreUsed.

Referenced by CaloTowersCreator::produce().

216 { theRecoveredHcalHitsAreUsed = flag; };

◆ setThresFromDB()

void CaloTowersCreationAlgo::setThresFromDB ( const EcalPFRecHitThresholds *  EcalCuts,
const HcalPFCuts *  HcalCuts 
)

Definition at line 356 of file CaloTowersCreationAlgo.cc.

References ecalCuts, and hcalCuts.

Referenced by CaloTowersCreator::beginRun().

356  {
357  ecalCuts = EcalCuts;
358  hcalCuts = HcalCuts;
359 }
CaloTowersCreationAlgo::ecalCuts
const EcalPFRecHitThresholds * ecalCuts
Definition: CaloTowersCreationAlgo.h:327

◆ setUseRejectedHitsOnly()

void CaloTowersCreationAlgo::setUseRejectedHitsOnly ( bool  flag)
inline

Definition at line 229 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedHitsOnly.

Referenced by CaloTowersCreator::produce().

229 { useRejectedHitsOnly = flag; }

◆ setUseRejectedRecoveredEcalHits()

void CaloTowersCreationAlgo::setUseRejectedRecoveredEcalHits ( bool  flag)
inline

Definition at line 240 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedRecoveredEcalHits.

Referenced by CaloTowersCreator::produce().

240 { useRejectedRecoveredEcalHits = flag; };

◆ setUseRejectedRecoveredHcalHits()

void CaloTowersCreationAlgo::setUseRejectedRecoveredHcalHits ( bool  flag)
inline

Definition at line 239 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedRecoveredHcalHits.

Referenced by CaloTowersCreator::produce().

239 { useRejectedRecoveredHcalHits = flag; };

Member Data Documentation

◆ ecalBadChs

std::vector<unsigned short> CaloTowersCreationAlgo::ecalBadChs
private

Definition at line 394 of file CaloTowersCreationAlgo.h.

Referenced by convert(), makeEcalBadChs(), and setGeometry().

◆ ecalCuts

const EcalPFRecHitThresholds* CaloTowersCreationAlgo::ecalCuts
private

Definition at line 327 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setThresFromDB().

◆ hcalCuts

const HcalPFCuts* CaloTowersCreationAlgo::hcalCuts
private

Definition at line 328 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setThresFromDB().

◆ hcalDropChMap

HcalDropChMap CaloTowersCreationAlgo::hcalDropChMap
private

Definition at line 390 of file CaloTowersCreationAlgo.h.

Referenced by convert(), and makeHcalDropChMap().

◆ ids_

std::vector<HcalDetId> CaloTowersCreationAlgo::ids_
private

Definition at line 408 of file CaloTowersCreationAlgo.h.

◆ missingHcalRescaleFactorForEcal

float CaloTowersCreationAlgo::missingHcalRescaleFactorForEcal
private

Definition at line 364 of file CaloTowersCreationAlgo.h.

Referenced by convert(), makeHcalDropChMap(), and setMissingHcalRescaleFactorForEcal().

◆ nalgo

int CaloTowersCreationAlgo::nalgo = -1

Definition at line 56 of file CaloTowersCreationAlgo.h.

◆ theEBEScale

double CaloTowersCreationAlgo::theEBEScale
private

Definition at line 319 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setEBEScale().

◆ theEBGrid

std::vector<double> CaloTowersCreationAlgo::theEBGrid
private

Definition at line 307 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEbHandle

edm::Handle<EcalRecHitCollection> CaloTowersCreationAlgo::theEbHandle
private

Definition at line 403 of file CaloTowersCreationAlgo.h.

Referenced by setEbHandle().

◆ theEBSumThreshold

double CaloTowersCreationAlgo::theEBSumThreshold
private

Definition at line 317 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theEBthreshold

double CaloTowersCreationAlgo::theEBthreshold
private

Definition at line 296 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEBweight

double CaloTowersCreationAlgo::theEBweight
private

Definition at line 315 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEBWeights

std::vector<double> CaloTowersCreationAlgo::theEBWeights
private

Definition at line 307 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEcalChStatus

const EcalChannelStatus* CaloTowersCreationAlgo::theEcalChStatus
private

Definition at line 336 of file CaloTowersCreationAlgo.h.

Referenced by setEcalChStatusFromDB().

◆ theEcalSeveritiesToBeExcluded

std::vector<int> CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded
private

Definition at line 349 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal(), ecalChanStatusForCaloTower(), makeEcalBadChs(), and setEcalSeveritiesToBeExcluded().

◆ theEcalSeveritiesToBeUsedInBadTowers

std::vector<int> CaloTowersCreationAlgo::theEcalSeveritiesToBeUsedInBadTowers
private

Definition at line 358 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and SetEcalSeveritiesToBeUsedInBadTowers().

◆ theEcalSevLvlAlgo

const EcalSeverityLevelAlgo* CaloTowersCreationAlgo::theEcalSevLvlAlgo
private

Definition at line 343 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal(), ecalChanStatusForCaloTower(), makeEcalBadChs(), and setEcalSevLvlAlgo().

◆ theEcutTower

double CaloTowersCreationAlgo::theEcutTower
private

Definition at line 317 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theEEEScale

double CaloTowersCreationAlgo::theEEEScale
private

Definition at line 320 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setEEEScale().

◆ theEEGrid

std::vector<double> CaloTowersCreationAlgo::theEEGrid
private

Definition at line 308 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEeHandle

edm::Handle<EcalRecHitCollection> CaloTowersCreationAlgo::theEeHandle
private

Definition at line 404 of file CaloTowersCreationAlgo.h.

Referenced by setEeHandle().

◆ theEESumThreshold

double CaloTowersCreationAlgo::theEESumThreshold
private

Definition at line 317 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theEEthreshold

double CaloTowersCreationAlgo::theEEthreshold
private

Definition at line 296 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEEweight

double CaloTowersCreationAlgo::theEEweight
private

Definition at line 315 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theEEWeights

std::vector<double> CaloTowersCreationAlgo::theEEWeights
private

Definition at line 308 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theGeometry

const CaloGeometry* CaloTowersCreationAlgo::theGeometry
private

Definition at line 331 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal(), emCrystalShwrPos(), hadShwPosFromCells(), and setGeometry().

◆ theHBEScale

double CaloTowersCreationAlgo::theHBEScale
private

Definition at line 321 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHBEScale().

◆ theHBGrid

std::vector<double> CaloTowersCreationAlgo::theHBGrid
private

Definition at line 309 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHBthreshold

double CaloTowersCreationAlgo::theHBthreshold
private

Definition at line 302 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHBthreshold1

double CaloTowersCreationAlgo::theHBthreshold1
private

Definition at line 302 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHBthreshold2

double CaloTowersCreationAlgo::theHBthreshold2
private

Definition at line 302 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHBweight

double CaloTowersCreationAlgo::theHBweight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHBWeights

std::vector<double> CaloTowersCreationAlgo::theHBWeights
private

Definition at line 309 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHcalAcceptSeverityLevel

unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevel
private

Definition at line 348 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevel().

◆ theHcalAcceptSeverityLevelForRejectedHit

unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit
private

Definition at line 357 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevelForRejectedHit().

◆ theHcalChStatus

const HcalChannelQuality* CaloTowersCreationAlgo::theHcalChStatus
private

Definition at line 337 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), makeHcalDropChMap(), and setHcalChStatusFromDB().

◆ theHcalPhase

int CaloTowersCreationAlgo::theHcalPhase
private

Definition at line 406 of file CaloTowersCreationAlgo.h.

Referenced by assignHitHcal(), hadShwrPos(), and makeHcalDropChMap().

◆ theHcalSevLvlComputer

const HcalSeverityLevelComputer* CaloTowersCreationAlgo::theHcalSevLvlComputer
private

Definition at line 340 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), makeHcalDropChMap(), and setHcalSevLvlComputer().

◆ theHcalThreshold

double CaloTowersCreationAlgo::theHcalThreshold
private

Definition at line 300 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theHcalTopology

const HcalTopology* CaloTowersCreationAlgo::theHcalTopology
private

Definition at line 330 of file CaloTowersCreationAlgo.h.

Referenced by assignHitHcal(), getThresholdAndWeight(), hadShwPosFromCells(), hadShwrPos(), hcalChanStatusForCaloTower(), makeHcalDropChMap(), and setGeometry().

◆ theHEDEScale

double CaloTowersCreationAlgo::theHEDEScale
private

Definition at line 323 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHEDEScale().

◆ theHEDGrid

std::vector<double> CaloTowersCreationAlgo::theHEDGrid
private

Definition at line 311 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHEDthreshold

double CaloTowersCreationAlgo::theHEDthreshold
private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHEDthreshold1

double CaloTowersCreationAlgo::theHEDthreshold1
private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHEDweight

double CaloTowersCreationAlgo::theHEDweight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHEDWeights

std::vector<double> CaloTowersCreationAlgo::theHEDWeights
private

Definition at line 311 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHESEScale

double CaloTowersCreationAlgo::theHESEScale
private

Definition at line 322 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHESEScale().

◆ theHESGrid

std::vector<double> CaloTowersCreationAlgo::theHESGrid
private

Definition at line 310 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHESthreshold

double CaloTowersCreationAlgo::theHESthreshold
private

Definition at line 303 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHESthreshold1

double CaloTowersCreationAlgo::theHESthreshold1
private

Definition at line 303 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHESweight

double CaloTowersCreationAlgo::theHESweight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHESWeights

std::vector<double> CaloTowersCreationAlgo::theHESWeights
private

Definition at line 310 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF1EScale

double CaloTowersCreationAlgo::theHF1EScale
private

Definition at line 325 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHF1EScale().

◆ theHF1Grid

std::vector<double> CaloTowersCreationAlgo::theHF1Grid
private

Definition at line 313 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF1threshold

double CaloTowersCreationAlgo::theHF1threshold
private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF1weight

double CaloTowersCreationAlgo::theHF1weight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and rescaleTowers().

◆ theHF1Weights

std::vector<double> CaloTowersCreationAlgo::theHF1Weights
private

Definition at line 313 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF2EScale

double CaloTowersCreationAlgo::theHF2EScale
private

Definition at line 326 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHF2EScale().

◆ theHF2Grid

std::vector<double> CaloTowersCreationAlgo::theHF2Grid
private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF2threshold

double CaloTowersCreationAlgo::theHF2threshold
private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHF2weight

double CaloTowersCreationAlgo::theHF2weight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and rescaleTowers().

◆ theHF2Weights

std::vector<double> CaloTowersCreationAlgo::theHF2Weights
private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOEScale

double CaloTowersCreationAlgo::theHOEScale
private

Definition at line 324 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHOEScale().

◆ theHOGrid

std::vector<double> CaloTowersCreationAlgo::theHOGrid
private

Definition at line 312 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOIsUsed

bool CaloTowersCreationAlgo::theHOIsUsed
private

only affects energy and ET calculation. HO is still recorded in the tower

Definition at line 367 of file CaloTowersCreationAlgo.h.

Referenced by assignHitHcal(), convert(), and rescaleTowers().

◆ theHOthreshold0

double CaloTowersCreationAlgo::theHOthreshold0
private

Definition at line 305 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOthresholdMinus1

double CaloTowersCreationAlgo::theHOthresholdMinus1
private

Definition at line 305 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOthresholdMinus2

double CaloTowersCreationAlgo::theHOthresholdMinus2
private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOthresholdPlus1

double CaloTowersCreationAlgo::theHOthresholdPlus1
private

Definition at line 305 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOthresholdPlus2

double CaloTowersCreationAlgo::theHOthresholdPlus2
private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOweight

double CaloTowersCreationAlgo::theHOweight
private

Definition at line 316 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theHOWeights

std::vector<double> CaloTowersCreationAlgo::theHOWeights
private

Definition at line 312 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

◆ theMomConstrMethod

int CaloTowersCreationAlgo::theMomConstrMethod
private

Definition at line 371 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theMomEBDepth

double CaloTowersCreationAlgo::theMomEBDepth
private

Definition at line 374 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theMomEEDepth

double CaloTowersCreationAlgo::theMomEEDepth
private

Definition at line 375 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theMomHBDepth

double CaloTowersCreationAlgo::theMomHBDepth
private

Definition at line 372 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theMomHEDepth

double CaloTowersCreationAlgo::theMomHEDepth
private

Definition at line 373 of file CaloTowersCreationAlgo.h.

Referenced by convert().

◆ theRecoveredEcalHitsAreUsed

bool CaloTowersCreationAlgo::theRecoveredEcalHitsAreUsed
private

Definition at line 352 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and setRecoveredEcalHitsAreUsed().

◆ theRecoveredHcalHitsAreUsed

bool CaloTowersCreationAlgo::theRecoveredHcalHitsAreUsed
private

Definition at line 351 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setRecoveredHcalHitsAreUsed().

◆ theTowerConstituentsMap

const CaloTowerConstituentsMap* CaloTowersCreationAlgo::theTowerConstituentsMap
private

Definition at line 332 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal(), assignHitHcal(), hadShwrPos(), makeEcalBadChs(), makeHcalDropChMap(), rescale(), and setGeometry().

◆ theTowerGeometry

const CaloSubdetectorGeometry* CaloTowersCreationAlgo::theTowerGeometry
private

Definition at line 333 of file CaloTowersCreationAlgo.h.

Referenced by convert(), and setGeometry().

◆ theTowerMap

MetaTowerMap CaloTowersCreationAlgo::theTowerMap
private

Definition at line 384 of file CaloTowersCreationAlgo.h.

Referenced by begin(), find(), and finish().

◆ theTowerMapSize

unsigned int CaloTowersCreationAlgo::theTowerMapSize = 0
private

Definition at line 385 of file CaloTowersCreationAlgo.h.

Referenced by begin(), find(), and finish().

◆ theTowerTopology

const CaloTowerTopology* CaloTowersCreationAlgo::theTowerTopology
private

Definition at line 329 of file CaloTowersCreationAlgo.h.

Referenced by convert(), find(), hadShwrPos(), makeEcalBadChs(), rescaleTowers(), and setGeometry().

◆ theUseEtEBTresholdFlag

bool CaloTowersCreationAlgo::theUseEtEBTresholdFlag
private

Definition at line 297 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

◆ theUseEtEETresholdFlag

bool CaloTowersCreationAlgo::theUseEtEETresholdFlag
private

Definition at line 297 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

◆ theUseSymEBTresholdFlag

bool CaloTowersCreationAlgo::theUseSymEBTresholdFlag
private

Definition at line 298 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

◆ theUseSymEETresholdFlag

bool CaloTowersCreationAlgo::theUseSymEETresholdFlag
private

Definition at line 298 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

◆ useRejectedHitsOnly

bool CaloTowersCreationAlgo::useRejectedHitsOnly
private

Definition at line 356 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), hcalChanStatusForCaloTower(), and setUseRejectedHitsOnly().

◆ useRejectedRecoveredEcalHits

unsigned int CaloTowersCreationAlgo::useRejectedRecoveredEcalHits
private

Definition at line 361 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and setUseRejectedRecoveredEcalHits().

◆ useRejectedRecoveredHcalHits

unsigned int CaloTowersCreationAlgo::useRejectedRecoveredHcalHits
private

Definition at line 360 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setUseRejectedRecoveredHcalHits().

Generated for CMSSW Reference Manual by doxygen 1.8.14