|
|
|
#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 HESthreshold, double HEDthreshold, 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) | |
| CaloTowersCreationAlgo (double EBthreshold, double EEthreshold, bool useEtEBTreshold, bool useEtEETreshold, bool useSymEBTreshold, bool useSymEETreshold, double HcalThreshold, double HBthreshold, double HESthreshold, double HEDthreshold, double HOthreshold0, double HOthresholdPlus1, double HOthresholdMinus1, double HOthresholdPlus2, double HOthresholdMinus2, double HF1threshold, double HF2threshold, std::vector< double > EBGrid, std::vector< double > EBWeights, std::vector< double > EEGrid, std::vector< double > EEWeights, std::vector< double > HBGrid, std::vector< double > HBWeights, std::vector< double > HESGrid, std::vector< double > HESWeights, std::vector< double > HEDGrid, std::vector< double > HEDWeights, std::vector< double > HOGrid, std::vector< double > HOWeights, std::vector< double > HF1Grid, std::vector< double > HF1Weights, std::vector< double > HF2Grid, 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) | |
| unsigned int | ecalChanStatusForCaloTower (const CaloRecHit *hit) |
| GlobalPoint | emCrystalShwrPos (DetId detId, float fracDepth) |
| GlobalPoint | emShwrLogWeightPos (std::vector< std::pair< DetId, double > > &metaContains, float fracDepth, double totEmE) |
| GlobalPoint | emShwrPos (std::vector< std::pair< DetId, double > > &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 (std::vector< std::pair< DetId, double > > &metaContains, float fracDepth, double hadE) |
| GlobalPoint | hadShwrPos (CaloTowerDetId id, float fracDepth) |
| unsigned int | hcalChanStatusForCaloTower (const CaloRecHit *hit) |
| void | makeHcalDropChMap () |
| void | process (const HFRecHitCollection &hf) |
| void | process (const HBHERecHitCollection &hbhe) |
| void | process (const HORecHitCollection &ho) |
| 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 | setEcalAcceptSeverityLevel (unsigned int level) |
| void | setEcalAcceptSeverityLevelForRejectedHit (unsigned int level) |
| void | setEcalChStatusFromDB (const EcalChannelStatus *s) |
| void | setEcalSevLvlAlgo (const EcalSeverityLevelAlgo *a) |
| void | setEEEScale (double scale) |
| void | setEeHandle (const edm::Handle< EcalRecHitCollection > ee) |
| void | setGeometry (const CaloTowerConstituentsMap *cttopo, 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 | setRecoveredEcalHitsAreUsed (bool flag) |
| void | setRecoveredHcalHitsAreUsed (bool flag) |
| void | setUseRejectedHitsOnly (bool flag) |
| void | setUseRejectedRecoveredEcalHits (bool flag) |
| void | setUseRejectedRecoveredHcalHits (bool flag) |
Private Types | |
| enum | ctHitCategory { GoodChan = 0, BadChan = 1, RecoveredChan = 2, ProblematicChan = 3, IgnoredChan = 99 } |
| typedef std::map < CaloTowerDetId, MetaTower > | MetaTowerMap |
Private Member Functions | |
| void | assignHit (const CaloRecHit *recHit) |
| adds a single hit to the tower | |
| int | compactTime (float time) |
| CaloTower | convert (const CaloTowerDetId &id, const MetaTower &mt) |
| MetaTower & | find (const CaloTowerDetId &id) |
| looks for a given tower in the internal cache. If it can't find it, it makes it. | |
| void | getThresholdAndWeight (const DetId &detId, double &threshold, double &weight) const |
| helper method to look up the appropriate threshold & weight | |
| void | rescale (const CaloTower *ct) |
Private Attributes | |
| std::map< CaloTowerDetId, int > | hcalDropChMap |
| double | theEBEScale |
| std::vector< double > | theEBGrid |
| edm::Handle< EcalRecHitCollection > | theEbHandle |
| double | theEBSumThreshold |
| double | theEBthreshold |
| double | theEBweight |
| std::vector< double > | theEBWeights |
| unsigned int | theEcalAcceptSeverityLevel |
| unsigned int | theEcalAcceptSeverityLevelForRejectedHit |
| const EcalChannelStatus * | theEcalChStatus |
| 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 | theHBweight |
| std::vector< double > | theHBWeights |
| unsigned int | theHcalAcceptSeverityLevel |
| unsigned int | theHcalAcceptSeverityLevelForRejectedHit |
| const HcalChannelQuality * | theHcalChStatus |
| const HcalSeverityLevelComputer * | theHcalSevLvlComputer |
| double | theHcalThreshold |
| const HcalTopology * | theHcalTopology |
| double | theHEDEScale |
| std::vector< double > | theHEDGrid |
| double | theHEDthreshold |
| double | theHEDweight |
| std::vector< double > | theHEDWeights |
| double | theHESEScale |
| std::vector< double > | theHESGrid |
| double | theHESthreshold |
| 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 | |
| double | theHOthreshold0 |
| double | theHOthresholdMinus1 |
| double | theHOthresholdMinus2 |
| double | theHOthresholdPlus1 |
| double | theHOthresholdPlus2 |
| double | theHOweight |
| std::vector< double > | theHOWeights |
| int | theMomConstrMethod |
| double | theMomEBDepth |
| double | theMomEEDepth |
| double | theMomEmDepth |
| double | theMomHadDepth |
| double | theMomHBDepth |
| double | theMomHEDepth |
| bool | theRecoveredEcalHitsAreUsed |
| bool | theRecoveredHcalHitsAreUsed |
| const CaloTowerConstituentsMap * | theTowerConstituentsMap |
| const CaloSubdetectorGeometry * | theTowerGeometry |
| MetaTowerMap | theTowerMap |
| bool | theUseEtEBTresholdFlag |
| bool | theUseEtEETresholdFlag |
| bool | theUseSymEBTresholdFlag |
| bool | theUseSymEETresholdFlag |
| bool | useRejectedHitsOnly |
| unsigned int | useRejectedRecoveredEcalHits |
| unsigned int | useRejectedRecoveredHcalHits |
typedef std::map<CaloTowerDetId, MetaTower> CaloTowersCreationAlgo::MetaTowerMap [private] |
Definition at line 318 of file CaloTowersCreationAlgo.h.
enum CaloTowersCreationAlgo::ctHitCategory [private] |
Definition at line 328 of file CaloTowersCreationAlgo.h.
{GoodChan = 0, BadChan = 1, RecoveredChan = 2, ProblematicChan = 3, IgnoredChan = 99 };
| CaloTowersCreationAlgo::CaloTowersCreationAlgo | ( | ) |
Definition at line 12 of file CaloTowersCreationAlgo.cc.
: theEBthreshold(-1000.), theEEthreshold(-1000.), theUseEtEBTresholdFlag(false), theUseEtEETresholdFlag(false), theUseSymEBTresholdFlag(false), theUseSymEETresholdFlag(false), theHcalThreshold(-1000.), theHBthreshold(-1000.), theHESthreshold(-1000.), theHEDthreshold(-1000.), theHOthreshold0(-1000.), theHOthresholdPlus1(-1000.), theHOthresholdMinus1(-1000.), theHOthresholdPlus2(-1000.), theHOthresholdMinus2(-1000.), theHF1threshold(-1000.), theHF2threshold(-1000.), theEBGrid(std::vector<double>(5,10.)), theEBWeights(std::vector<double>(5,1.)), theEEGrid(std::vector<double>(5,10.)), theEEWeights(std::vector<double>(5,1.)), theHBGrid(std::vector<double>(5,10.)), theHBWeights(std::vector<double>(5,1.)), theHESGrid(std::vector<double>(5,10.)), theHESWeights(std::vector<double>(5,1.)), theHEDGrid(std::vector<double>(5,10.)), theHEDWeights(std::vector<double>(5,1.)), theHOGrid(std::vector<double>(5,10.)), theHOWeights(std::vector<double>(5,1.)), theHF1Grid(std::vector<double>(5,10.)), theHF1Weights(std::vector<double>(5,1.)), theHF2Grid(std::vector<double>(5,10.)), theHF2Weights(std::vector<double>(5,1.)), theEBweight(1.), theEEweight(1.), theHBweight(1.), theHESweight(1.), theHEDweight(1.), theHOweight(1.), theHF1weight(1.), theHF2weight(1.), theEcutTower(-1000.), theEBSumThreshold(-1000.), theEESumThreshold(-1000.), theHcalTopology(0), theGeometry(0), theTowerConstituentsMap(0), theHOIsUsed(true), // (for momentum reconstruction algorithm) theMomConstrMethod(0), theMomHBDepth(0.), theMomHEDepth(0.), theMomEBDepth(0.), theMomEEDepth(0.) { }
| CaloTowersCreationAlgo::CaloTowersCreationAlgo | ( | double | EBthreshold, |
| double | EEthreshold, | ||
| bool | useEtEBTreshold, | ||
| bool | useEtEETreshold, | ||
| bool | useSymEBTreshold, | ||
| bool | useSymEETreshold, | ||
| double | HcalThreshold, | ||
| double | HBthreshold, | ||
| double | HESthreshold, | ||
| double | HEDthreshold, | ||
| 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 | ||
| ) |
Definition at line 73 of file CaloTowersCreationAlgo.cc.
: theEBthreshold(EBthreshold), theEEthreshold(EEthreshold), theUseEtEBTresholdFlag(useEtEBTreshold), theUseEtEETresholdFlag(useEtEETreshold), theUseSymEBTresholdFlag(useSymEBTreshold), theUseSymEETresholdFlag(useSymEETreshold), theHcalThreshold(HcalThreshold), theHBthreshold(HBthreshold), theHESthreshold(HESthreshold), theHEDthreshold(HEDthreshold), theHOthreshold0(HOthreshold0), theHOthresholdPlus1(HOthresholdPlus1), theHOthresholdMinus1(HOthresholdMinus1), theHOthresholdPlus2(HOthresholdPlus2), theHOthresholdMinus2(HOthresholdMinus2), theHF1threshold(HF1threshold), theHF2threshold(HF2threshold), theEBGrid(std::vector<double>(5,10.)), theEBWeights(std::vector<double>(5,1.)), theEEGrid(std::vector<double>(5,10.)), theEEWeights(std::vector<double>(5,1.)), theHBGrid(std::vector<double>(5,10.)), theHBWeights(std::vector<double>(5,1.)), theHESGrid(std::vector<double>(5,10.)), theHESWeights(std::vector<double>(5,1.)), theHEDGrid(std::vector<double>(5,10.)), theHEDWeights(std::vector<double>(5,1.)), theHOGrid(std::vector<double>(5,10.)), theHOWeights(std::vector<double>(5,1.)), theHF1Grid(std::vector<double>(5,10.)), theHF1Weights(std::vector<double>(5,1.)), theHF2Grid(std::vector<double>(5,10.)), theHF2Weights(std::vector<double>(5,1.)), theEBweight(EBweight), theEEweight(EEweight), theHBweight(HBweight), theHESweight(HESweight), theHEDweight(HEDweight), theHOweight(HOweight), theHF1weight(HF1weight), theHF2weight(HF2weight), theEcutTower(EcutTower), theEBSumThreshold(EBSumThreshold), theEESumThreshold(EESumThreshold), theHOIsUsed(useHO), // (momentum reconstruction algorithm) theMomConstrMethod(momConstrMethod), theMomHBDepth(momHBDepth), theMomHEDepth(momHEDepth), theMomEBDepth(momEBDepth), theMomEEDepth(momEEDepth) { }
| CaloTowersCreationAlgo::CaloTowersCreationAlgo | ( | double | EBthreshold, |
| double | EEthreshold, | ||
| bool | useEtEBTreshold, | ||
| bool | useEtEETreshold, | ||
| bool | useSymEBTreshold, | ||
| bool | useSymEETreshold, | ||
| double | HcalThreshold, | ||
| double | HBthreshold, | ||
| double | HESthreshold, | ||
| double | HEDthreshold, | ||
| double | HOthreshold0, | ||
| double | HOthresholdPlus1, | ||
| double | HOthresholdMinus1, | ||
| double | HOthresholdPlus2, | ||
| double | HOthresholdMinus2, | ||
| double | HF1threshold, | ||
| double | HF2threshold, | ||
| std::vector< double > | EBGrid, | ||
| std::vector< double > | EBWeights, | ||
| std::vector< double > | EEGrid, | ||
| std::vector< double > | EEWeights, | ||
| std::vector< double > | HBGrid, | ||
| std::vector< double > | HBWeights, | ||
| std::vector< double > | HESGrid, | ||
| std::vector< double > | HESWeights, | ||
| std::vector< double > | HEDGrid, | ||
| std::vector< double > | HEDWeights, | ||
| std::vector< double > | HOGrid, | ||
| std::vector< double > | HOWeights, | ||
| std::vector< double > | HF1Grid, | ||
| std::vector< double > | HF1Weights, | ||
| std::vector< double > | HF2Grid, | ||
| 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 | ||
| ) |
Definition at line 154 of file CaloTowersCreationAlgo.cc.
: theEBthreshold(EBthreshold), theEEthreshold(EEthreshold), theUseEtEBTresholdFlag(useEtEBTreshold), theUseEtEETresholdFlag(useEtEETreshold), theUseSymEBTresholdFlag(useSymEBTreshold), theUseSymEETresholdFlag(useSymEETreshold), theHcalThreshold(HcalThreshold), theHBthreshold(HBthreshold), theHESthreshold(HESthreshold), theHEDthreshold(HEDthreshold), theHOthreshold0(HOthreshold0), theHOthresholdPlus1(HOthresholdPlus1), theHOthresholdMinus1(HOthresholdMinus1), theHOthresholdPlus2(HOthresholdPlus2), theHOthresholdMinus2(HOthresholdMinus2), theHF1threshold(HF1threshold), theHF2threshold(HF2threshold), theEBGrid(EBGrid), theEBWeights(EBWeights), theEEGrid(EEGrid), theEEWeights(EEWeights), theHBGrid(HBGrid), theHBWeights(HBWeights), theHESGrid(HESGrid), theHESWeights(HESWeights), theHEDGrid(HEDGrid), theHEDWeights(HEDWeights), theHOGrid(HOGrid), theHOWeights(HOWeights), theHF1Grid(HF1Grid), theHF1Weights(HF1Weights), theHF2Grid(HF2Grid), theHF2Weights(HF2Weights), theEBweight(EBweight), theEEweight(EEweight), theHBweight(HBweight), theHESweight(HESweight), theHEDweight(HEDweight), theHOweight(HOweight), theHF1weight(HF1weight), theHF2weight(HF2weight), theEcutTower(EcutTower), theEBSumThreshold(EBSumThreshold), theEESumThreshold(EESumThreshold), theHOIsUsed(useHO), // (momentum reconstruction algorithm) theMomConstrMethod(momConstrMethod), theMomHBDepth(momHBDepth), theMomHEDepth(momHEDepth), theMomEBDepth(momEBDepth), theMomEEDepth(momEEDepth) { }
| void CaloTowersCreationAlgo::assignHit | ( | const CaloRecHit * | recHit | ) | [private] |
adds a single hit to the tower
Definition at line 414 of file CaloTowersCreationAlgo.cc.
References BadChan, HcalDetId::depth(), DetId::det(), CaloRecHit::detid(), ExpressReco_HICollisions_FallBack::e, CaloTowersCreationAlgo::MetaTower::E, CaloTowersCreationAlgo::MetaTower::E_em, CaloTowersCreationAlgo::MetaTower::E_had, CaloTowersCreationAlgo::MetaTower::E_outer, DetId::Ecal, EcalBarrel, ecalChanStatusForCaloTower(), EcalEndcap, CaloTowersCreationAlgo::MetaTower::emSumEForTime, CaloTowersCreationAlgo::MetaTower::emSumTimeTimesE, CaloRecHit::energy(), relval_parameters_module::energy, eta(), find(), CaloGeometry::getGeometry(), CaloCellGeometry::getPosition(), getThresholdAndWeight(), GoodChan, CaloTowersCreationAlgo::MetaTower::hadSumEForTime, CaloTowersCreationAlgo::MetaTower::hadSumTimeTimesE, DetId::Hcal, hcalChanStatusForCaloTower(), HcalEndcap, HcalForward, HcalOuter, CaloTowerDetId::ieta(), HcalDetId::ietaAbs(), IgnoredChan, CaloTowerDetId::iphi(), CaloTowersCreationAlgo::MetaTower::metaConstituents, DetId::null(), CaloTowersCreationAlgo::MetaTower::numBadHcalCells, CaloTowersCreationAlgo::MetaTower::numProbEcalCells, CaloTowersCreationAlgo::MetaTower::numProbHcalCells, CaloTowersCreationAlgo::MetaTower::numRecEcalCells, CaloTowersCreationAlgo::MetaTower::numRecHcalCells, ProblematicChan, RecoveredChan, HcalDetId::subdet(), DetId::subdetId(), theGeometry, theHOIsUsed, theTowerConstituentsMap, theUseEtEBTresholdFlag, theUseEtEETresholdFlag, theUseSymEBTresholdFlag, theUseSymEETresholdFlag, crabWrap::threshold, CaloRecHit::time(), CaloTowerConstituentsMap::towerOf(), CommonMethods::weight(), and CaloTowerDetId::zside().
Referenced by process().
{
DetId detId = recHit->detid();
unsigned int chStatusForCT = (detId.det()==DetId::Hcal)?
hcalChanStatusForCaloTower(recHit) :
ecalChanStatusForCaloTower(recHit);
// this is for skipping channls: mostly needed for the creation of
// bad towers from hits i the bad channel collections.
if (chStatusForCT==CaloTowersCreationAlgo::IgnoredChan) return;
double threshold, weight;
getThresholdAndWeight(detId, threshold, weight);
double energy = recHit->energy(); // original RecHit energy is used to apply thresholds
double e = energy * weight; // energies scaled by user weight: used in energy assignments
// SPECIAL handling of tower 28/depth 3 --> half into tower 28 and half into tower 29
if (detId.det()==DetId::Hcal &&
HcalDetId(detId).subdet()==HcalEndcap &&
HcalDetId(detId).depth()==3 &&
HcalDetId(detId).ietaAbs()==28) {
CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
if (towerDetId.null()) return;
MetaTower & tower28 = find(towerDetId);
CaloTowerDetId towerDetId29 = CaloTowerDetId(towerDetId.ieta()+
towerDetId.zside(),
towerDetId.iphi());
MetaTower & tower29 = find(towerDetId29);
// bad channels are counted regardless of energy threshold
if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
tower28.numBadHcalCells += 1;
tower29.numBadHcalCells += 1;
}
else if (0.5*energy >= threshold) { // not bad channel: use energy if above threshold
if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
tower28.numRecHcalCells += 1;
tower29.numRecHcalCells += 1;
}
else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
tower28.numProbHcalCells += 1;
tower29.numProbHcalCells += 1;
}
// NOTE DIVIDE BY 2!!!
double e28 = 0.5 * e;
double e29 = 0.5 * e;
tower28.E_had += e28;
tower28.E += e28;
std::pair<DetId,double> mc(detId,e28);
tower28.metaConstituents.push_back(mc);
tower29.E_had += e29;
tower29.E += e29;
tower29.metaConstituents.push_back(mc);
// time info: do not use in averaging if timing error is found: need
// full set of status info to implement: use only "good" channels for now
if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
tower28.hadSumTimeTimesE += ( e28 * recHit->time() );
tower28.hadSumEForTime += e28;
tower29.hadSumTimeTimesE += ( e29 * recHit->time() );
tower29.hadSumEForTime += e29;
}
// store the energy in layer 3 also in E_outer
tower28.E_outer += e28;
tower29.E_outer += e29;
} // not a "bad" hit
} // end of special case
else {
CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
if (towerDetId.null()) return;
MetaTower & tower = find(towerDetId);
DetId::Detector det = detId.det();
if (det == DetId::Ecal) {
// For ECAL we count all bad channels after the metatower is complete
// Include options for symmetric thresholds and cut on Et
// for ECAL RecHits
bool passEmThreshold = false;
if (detId.subdetId() == EcalBarrel) {
if (theUseEtEBTresholdFlag) energy /= cosh( (theGeometry->getGeometry(detId)->getPosition()).eta() ) ;
if (theUseSymEBTresholdFlag) passEmThreshold = (fabs(energy) >= threshold);
else passEmThreshold = (energy >= threshold);
}
else if (detId.subdetId() == EcalEndcap) {
if (theUseEtEETresholdFlag) energy /= cosh( (theGeometry->getGeometry(detId)->getPosition()).eta() ) ;
if (theUseSymEETresholdFlag) passEmThreshold = (fabs(energy) >= threshold);
else passEmThreshold = (energy >= threshold);
}
// if (chStatusForCT != CaloTowersCreationAlgo::BadChan && energy >= threshold) {
if (chStatusForCT != CaloTowersCreationAlgo::BadChan && passEmThreshold) {
tower.E_em += e;
tower.E += e;
if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
tower.numRecEcalCells += 1;
}
else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
tower.numProbEcalCells += 1;
}
// change when full status info is available
// for now use only good channels
// add e>0 check (new options allow e<0)
if (chStatusForCT == CaloTowersCreationAlgo::GoodChan && e>0 ) {
tower.emSumTimeTimesE += ( e * recHit->time() );
tower.emSumEForTime += e; // see above
}
std::pair<DetId,double> mc(detId,e);
tower.metaConstituents.push_back(mc);
}
} // end of ECAL
// HCAL
else {
HcalDetId hcalDetId(detId);
if(hcalDetId.subdet() == HcalOuter) {
if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
if (theHOIsUsed) tower.numBadHcalCells += 1;
}
else if (energy >= threshold) {
tower.E_outer += e; // store HO energy even if HO is not used
// add energy of the tower and/or flag if theHOIsUsed
if(theHOIsUsed) {
tower.E += e;
if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
tower.numRecHcalCells += 1;
}
else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
tower.numProbHcalCells += 1;
}
} // HO is used
// add HO to constituents even if it is not used: JetMET wants to keep these towers
std::pair<DetId,double> mc(detId,e);
tower.metaConstituents.push_back(mc);
} // not a bad channel, energy above threshold
} // HO hit
// HF calculates EM fraction differently
else if(hcalDetId.subdet() == HcalForward) {
if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
tower.numBadHcalCells += 1;
}
else if (energy >= threshold) {
if (hcalDetId.depth() == 1) {
// long fiber, so E_EM = E(Long) - E(Short)
tower.E_em += e;
}
else {
// short fiber, EHAD = 2 * E(Short)
tower.E_em -= e;
tower.E_had += 2. * e;
}
tower.E += e;
if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
tower.numRecHcalCells += 1;
}
else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
tower.numProbHcalCells += 1;
}
// put the timing in HCAL -> have to check timing errors when available
// for now use only good channels
if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
tower.hadSumTimeTimesE += ( e * recHit->time() );
tower.hadSumEForTime += e;
}
std::pair<DetId,double> mc(detId,e);
tower.metaConstituents.push_back(mc);
} // not a bad HF channel, energy above threshold
} // HF hit
else {
// HCAL situation normal in HB/HE
if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
tower.numBadHcalCells += 1;
}
else if (energy >= threshold) {
tower.E_had += e;
tower.E += e;
if (chStatusForCT == CaloTowersCreationAlgo::RecoveredChan) {
tower.numRecHcalCells += 1;
}
else if (chStatusForCT == CaloTowersCreationAlgo::ProblematicChan) {
tower.numProbHcalCells += 1;
}
// Timing information: need specific accessors
// for now use only good channels
if (chStatusForCT == CaloTowersCreationAlgo::GoodChan) {
tower.hadSumTimeTimesE += ( e * recHit->time() );
tower.hadSumEForTime += e;
}
// store energy in highest depth for towers 18-27 (for electron,photon ID in endcap)
// also, store energy in HE part of tower 16 (for JetMET cleanup)
if (HcalDetId(detId).subdet()==HcalEndcap) {
if ( (HcalDetId(detId).depth()==2 && HcalDetId(detId).ietaAbs()>=18 && HcalDetId(detId).ietaAbs()<27) ||
(HcalDetId(detId).depth()==3 && HcalDetId(detId).ietaAbs()==27) ||
(HcalDetId(detId).depth()==3 && HcalDetId(detId).ietaAbs()==16) ) {
tower.E_outer += e;
}
}
std::pair<DetId,double> mc(detId,e);
tower.metaConstituents.push_back(mc);
} // not a "bad" channel, energy above threshold
} // channel in HBHE (excluding twrs 28,29)
}
} // recHit normal case (not in HE towers 28,29)
} // end of assignHit method
| void CaloTowersCreationAlgo::begin | ( | void | ) |
Definition at line 251 of file CaloTowersCreationAlgo.cc.
References hcalDropChMap, and theTowerMap.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
theTowerMap.clear();
hcalDropChMap.clear();
}
| int CaloTowersCreationAlgo::compactTime | ( | float | time | ) | [private] |
| CaloTower CaloTowersCreationAlgo::convert | ( | const CaloTowerDetId & | id, |
| const MetaTower & | mt | ||
| ) | [private] |
Definition at line 747 of file CaloTowersCreationAlgo.cc.
References CaloTower::addConstituents(), compactTime(), CaloTowerConstituentsMap::constituentsOf(), edm::contains(), CaloTowersCreationAlgo::MetaTower::E, CaloTowersCreationAlgo::MetaTower::E_em, CaloTowersCreationAlgo::MetaTower::E_had, CaloTowersCreationAlgo::MetaTower::E_outer, DetId::Ecal, EcalBarrel, EcalEndcap, emShwrLogWeightPos(), emShwrPos(), CaloTowersCreationAlgo::MetaTower::emSumEForTime, CaloTowersCreationAlgo::MetaTower::emSumTimeTimesE, PV3DBase< T, PVType, FrameType >::eta(), CaloSubdetectorGeometry::getGeometry(), CaloCellGeometry::getPosition(), hadShwrPos(), CaloTowersCreationAlgo::MetaTower::hadSumEForTime, CaloTowersCreationAlgo::MetaTower::hadSumTimeTimesE, DetId::Hcal, hcalDropChMap, HcalOuter, i, if(), edm::HandleBase::isValid(), EcalSeverityLevelAlgo::kRecovered, CaloTowersCreationAlgo::MetaTower::metaConstituents, CaloTowersCreationAlgo::MetaTower::numBadHcalCells, CaloTowersCreationAlgo::MetaTower::numProbEcalCells, CaloTowersCreationAlgo::MetaTower::numProbHcalCells, CaloTowersCreationAlgo::MetaTower::numRecEcalCells, CaloTowersCreationAlgo::MetaTower::numRecHcalCells, L1TEmulatorMonitor_cff::p, PV3DBase< T, PVType, FrameType >::phi(), edm::second(), CaloTower::setCaloTowerStatus(), CaloTower::setEcalTime(), CaloTower::setHcalTime(), CaloTower::setHottestCellE(), EcalSeverityLevelAlgo::severityLevel(), HcalDetId::subdet(), theEbHandle, theEBSumThreshold, theEcalAcceptSeverityLevel, theEcalChStatus, theEcalSevLvlAlgo, theEeHandle, theEESumThreshold, theHcalThreshold, theHOIsUsed, theMomConstrMethod, theMomEBDepth, theMomEEDepth, theMomEmDepth, theMomHadDepth, theMomHBDepth, theMomHEDepth, theRecoveredEcalHitsAreUsed, theTowerConstituentsMap, and theTowerGeometry.
Referenced by finish().
{
double ecalThres=(id.ietaAbs()<=17)?(theEBSumThreshold):(theEESumThreshold);
double E=mt.E;
double E_em=mt.E_em;
double E_had=mt.E_had;
double E_outer=mt.E_outer;
// conditional assignment of depths for barrel/endcap
// Some additional tuning may be required in the transitional region
// 14<|iEta|<19
if (id.ietaAbs()<=17) {
theMomHadDepth = theMomHBDepth;
theMomEmDepth = theMomEBDepth;
}
else {
theMomHadDepth = theMomHEDepth;
theMomEmDepth = theMomEEDepth;
}
// Note: E_outer is used to save HO energy OR energy in the outermost depths in endcap region
// In the methods with separate treatment of EM and HAD components:
// - HO is not used to determine direction, however HO energy is added to get "total had energy"
// => Check if the tower is within HO coverage before adding E_outer to the "total had" energy
// else the energy will be double counted
// When summing up the energy of the tower these checks are performed in the loops over RecHits
float ecalTime = (mt.emSumEForTime>0)? mt.emSumTimeTimesE/mt.emSumEForTime : -9999;
float hcalTime = (mt.hadSumEForTime>0)? mt.hadSumTimeTimesE/mt.hadSumEForTime : -9999;
std::vector<std::pair<DetId,double> > metaContains=mt.metaConstituents;
if (id.ietaAbs()<=29 && E_em<ecalThres) { // ignore EM threshold in HF
E-=E_em;
E_em=0;
std::vector<std::pair<DetId,double> > metaContains_noecal;
for (std::vector<std::pair<DetId,double> >::iterator i=metaContains.begin(); i!=metaContains.end(); ++i)
if (i->first.det()!=DetId::Ecal) metaContains_noecal.push_back(*i);
metaContains.swap(metaContains_noecal);
}
if (id.ietaAbs()<=29 && E_had<theHcalThreshold) {
E-=E_had;
if (theHOIsUsed && id.ietaAbs()<16) E-=E_outer; // not subtracted before, think it should be done
E_had=0;
E_outer=0;
std::vector<std::pair<DetId,double> > metaContains_nohcal;
for (std::vector<std::pair<DetId,double> >::iterator i=metaContains.begin(); i!=metaContains.end(); ++i)
if (i->first.det()!=DetId::Hcal) metaContains_nohcal.push_back(*i);
metaContains.swap(metaContains_nohcal);
}
double E_had_tot = (theHOIsUsed && id.ietaAbs()<16)? E_had+E_outer : E_had;
// create CaloTower using the selected algorithm
GlobalPoint emPoint, hadPoint;
CaloTower::PolarLorentzVector towerP4;
switch (theMomConstrMethod) {
case 0 :
{ // Simple 4-momentum assignment
GlobalPoint p=theTowerGeometry->getGeometry(id)->getPosition();
double pf=1.0/cosh(p.eta());
if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0);
emPoint = p;
hadPoint = p;
} // end case 0
break;
case 1 :
{ // separate 4-vectors for ECAL, HCAL, add to get the 4-vector of the tower (=>tower has mass!)
if (id.ietaAbs()<=29) {
if (E_em>0) {
emPoint = emShwrPos(metaContains, theMomEmDepth, E_em);
double emPf = 1.0/cosh(emPoint.eta());
towerP4 += CaloTower::PolarLorentzVector(E_em*emPf, emPoint.eta(), emPoint.phi(), 0);
}
if ( (E_had + E_outer) >0) {
hadPoint = hadShwrPos(id, theMomHadDepth);
double hadPf = 1.0/cosh(hadPoint.eta());
if (E_had_tot>0) {
towerP4 += CaloTower::PolarLorentzVector(E_had_tot*hadPf, hadPoint.eta(), hadPoint.phi(), 0);
}
}
}
else { // forward detector: use the CaloTower position
GlobalPoint p=theTowerGeometry->getGeometry(id)->getPosition();
double pf=1.0/cosh(p.eta());
if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0); // simple momentum assignment, same position
emPoint = p;
hadPoint = p;
}
} // end case 1
break;
case 2:
{ // use ECAL position for the tower (when E_cal>0), else default CaloTower position (massless tower)
if (id.ietaAbs()<=29) {
if (E_em>0) emPoint = emShwrLogWeightPos(metaContains, theMomEmDepth, E_em);
else emPoint = theTowerGeometry->getGeometry(id)->getPosition();
double sumPf = 1.0/cosh(emPoint.eta());
if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*sumPf, emPoint.eta(), emPoint.phi(), 0);
hadPoint = emPoint;
}
else { // forward detector: use the CaloTower position
GlobalPoint p=theTowerGeometry->getGeometry(id)->getPosition();
double pf=1.0/cosh(p.eta());
if (E>0) towerP4 = CaloTower::PolarLorentzVector(E*pf, p.eta(), p.phi(), 0); // simple momentum assignment, same position
emPoint = p;
hadPoint = p;
}
} // end case 2
break;
} // end of decision on p4 reconstruction method
CaloTower retval(id, E_em, E_had, E_outer, -1, -1, towerP4, emPoint, hadPoint);
// set the timings
retval.setEcalTime(compactTime(ecalTime));
retval.setHcalTime(compactTime(hcalTime));
// set the CaloTower status word =====================================
// Channels must be counter exclusively in the defined cathegories
// "Bad" channels (not used in energy assignment) can be flagged during
// CaloTower creation only if specified in the configuration file
unsigned int numBadHcalChan = mt.numBadHcalCells;
// unsigned int numBadEcalChan = mt.numBadEcalCells;
unsigned int numBadEcalChan = 0; //
unsigned int numRecHcalChan = mt.numRecHcalCells;
unsigned int numRecEcalChan = mt.numRecEcalCells;
unsigned int numProbHcalChan = mt.numProbHcalCells;
unsigned int numProbEcalChan = mt.numProbEcalCells;
// now add dead/off/... channels not used in RecHit reconstruction for HCAL
if (hcalDropChMap.find(id) != hcalDropChMap.end()) numBadHcalChan += hcalDropChMap[id];
// for ECAL the number of all bad channels is obtained here -----------------------
// get all possible constituents of the tower
std::vector<DetId> allConstituents = theTowerConstituentsMap->constituentsOf(id);
for (std::vector<DetId>::iterator ac_it=allConstituents.begin();
ac_it!=allConstituents.end(); ++ac_it) {
if (ac_it->det()!=DetId::Ecal) continue;
int thisEcalSevLvl = -999;
if (ac_it->subdetId() == EcalBarrel && theEbHandle.isValid()) {
thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel( *ac_it, *theEbHandle, *theEcalChStatus);
}
else if (ac_it->subdetId() == EcalEndcap && theEeHandle.isValid()) {
thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel( *ac_it, *theEeHandle, *theEcalChStatus);
}
// "bad" include "recovered" if the flag not to use them was set
// this is consistent with the treatment of what channels are accepted
if (thisEcalSevLvl>int(theEcalAcceptSeverityLevel) ||
( thisEcalSevLvl==EcalSeverityLevelAlgo::kRecovered && !theRecoveredEcalHitsAreUsed) ) {
++numBadEcalChan;
}
}
//--------------------------------------------------------------------------------------
retval.setCaloTowerStatus(numBadHcalChan, numBadEcalChan,
numRecHcalChan, numRecEcalChan,
numProbHcalChan, numProbEcalChan);
double maxCellE = -999.0; // for storing the hottest cell E in the calotower
std::vector<DetId> contains;
for (std::vector<std::pair<DetId,double> >::iterator i=metaContains.begin(); i!=metaContains.end(); ++i) {
contains.push_back(i->first);
if (maxCellE < i->second) {
// need an extra check because of the funny towers that are empty except for the presence of an HO
// hit in the constituents (JetMET wanted them saved)
// This constituent is only used for storing the tower, but should not be concidered as a hot cell canditate for
// configurations with useHO = false
if (i->first.det()==DetId::Ecal) { // ECAL
maxCellE = i->second;
}
else { // HCAL
if (HcalDetId(i->first).subdet() != HcalOuter)
maxCellE = i->second;
else if (theHOIsUsed) maxCellE = i->second;
}
} // found higher E cell
} // loop over matacontains
retval.addConstituents(contains);
retval.setHottestCellE(maxCellE);
return retval;
}
| unsigned int CaloTowersCreationAlgo::ecalChanStatusForCaloTower | ( | const CaloRecHit * | hit | ) |
Definition at line 1458 of file CaloTowersCreationAlgo.cc.
References BadChan, CaloRecHit::detid(), EcalBarrel, EcalEndcap, GoodChan, IgnoredChan, EcalSeverityLevelAlgo::kGood, EcalSeverityLevelAlgo::kRecovered, ProblematicChan, RecoveredChan, EcalSeverityLevelAlgo::severityLevel(), theEbHandle, theEcalAcceptSeverityLevel, theEcalAcceptSeverityLevelForRejectedHit, theEcalChStatus, theEcalSevLvlAlgo, theEeHandle, theRecoveredEcalHitsAreUsed, useRejectedHitsOnly, and useRejectedRecoveredEcalHits.
Referenced by assignHit().
{
const DetId id = hit->detid();
// uint16_t dbStatus = theEcalChStatus->find(id)->getStatusCode();
// uint32_t rhFlags = hit->flags();
// int severityLevel = theEcalSevLvlAlgo->severityLevel(rhFlags, dbStatus);
// The methods above will become private and cannot be usef for flagging ecal spikes.
// Use the recommended interface - we leave the parameters for spilke removal to be specified by ECAL.
int severityLevel = 999;
if (id.subdetId() == EcalBarrel) severityLevel = theEcalSevLvlAlgo->severityLevel( id, *theEbHandle, *theEcalChStatus);
else if (id.subdetId() == EcalEndcap) severityLevel = theEcalSevLvlAlgo->severityLevel( id, *theEeHandle, *theEcalChStatus);
// there should be no other ECAL types used in this reconstruction
// The definition of ECAL severity levels uses categories that
// are similar to the defined for CaloTower. (However, the categorization
// for CaloTowers depends on the specified maximum acceptabel severity and therefore cannnot
// be exact correspondence between the two. ECAL has additional categories describing modes of failure.)
// This approach is different from the initial idea and from
// the implementation for HCAL. Still make the logic similar to HCAL so that one has the ability to
// exclude problematic channels as defined by ECAL.
// For definitions of ECAL severity levels see RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h
bool isRecovered = (severityLevel == EcalSeverityLevelAlgo::kRecovered);
// for use with rejected by the regular reconstruction hits
if (useRejectedHitsOnly) {
if (!isRecovered) {
if (severityLevel <= int(theEcalAcceptSeverityLevel) ||
severityLevel > int(theEcalAcceptSeverityLevelForRejectedHit)) return CaloTowersCreationAlgo::IgnoredChan;
// this hit was either accepted already, or counted as bad under the conditions
}
else {
if (theRecoveredEcalHitsAreUsed || !useRejectedRecoveredEcalHits) {
// skip recovered hits either because they were already used or because there was an explicit instruction
return CaloTowersCreationAlgo::IgnoredChan;
}
else if (useRejectedRecoveredEcalHits) {
return CaloTowersCreationAlgo::RecoveredChan;
}
} // recovered channels
// clasify channels as problematic
return CaloTowersCreationAlgo::ProblematicChan;
} // treatment of rejected hits
// for normal reconstruction
if (severityLevel == EcalSeverityLevelAlgo::kGood) return CaloTowersCreationAlgo::GoodChan;
if (isRecovered) {
return (theRecoveredEcalHitsAreUsed) ?
CaloTowersCreationAlgo::RecoveredChan : CaloTowersCreationAlgo::BadChan;
}
else {
if (severityLevel > int(theEcalAcceptSeverityLevel)) {
return CaloTowersCreationAlgo::BadChan;
}
else {
return CaloTowersCreationAlgo::ProblematicChan;
}
}
}
| GlobalPoint CaloTowersCreationAlgo::emCrystalShwrPos | ( | DetId | detId, |
| float | fracDepth | ||
| ) |
Definition at line 1113 of file CaloTowersCreationAlgo.cc.
References CaloCellGeometry::getCorners(), CaloGeometry::getGeometry(), CaloCellGeometry::getPosition(), point, theGeometry, ExpressReco_HICollisions_FallBack::x, ExpressReco_HICollisions_FallBack::y, and z.
Referenced by emShwrLogWeightPos(), and emShwrPos().
{
const CaloCellGeometry* cellGeometry = theGeometry->getGeometry(detId);
GlobalPoint point = cellGeometry->getPosition(); // face of the cell
if (fracDepth<0) fracDepth=0;
else if (fracDepth>1) fracDepth=1;
if (fracDepth>0.0) {
CaloCellGeometry::CornersVec cv = cellGeometry->getCorners();
GlobalPoint backPoint = GlobalPoint( 0.25*( cv[4].x() + cv[5].x() + cv[6].x() + cv[7].x() ),
0.25*( cv[4].y() + cv[5].y() + cv[6].y() + cv[7].y() ),
0.25*( cv[4].z() + cv[5].z() + cv[6].z() + cv[7].z() ) );
point += fracDepth * (backPoint-point);
}
return point;
}
| GlobalPoint CaloTowersCreationAlgo::emShwrLogWeightPos | ( | std::vector< std::pair< DetId, double > > & | metaContains, |
| float | fracDepth, | ||
| double | totEmE | ||
| ) |
Definition at line 1300 of file CaloTowersCreationAlgo.cc.
References DetId::Ecal, emCrystalShwrPos(), funct::log(), L1TEmulatorMonitor_cff::p, CommonMethods::weight(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().
Referenced by convert().
{
double emX = 0.0;
double emY = 0.0;
double emZ = 0.0;
double weight = 0;
double sumWeights = 0;
double sumEmE = 0; // add crystals with E/E_EM > 1.5%
double crystalThresh = 0.015 * emE;
std::vector<std::pair<DetId,double> >::iterator mc_it = metaContains.begin();
for (; mc_it!=metaContains.end(); ++mc_it) {
if (mc_it->second < 0) continue;
if (mc_it->first.det() == DetId::Ecal && mc_it->second > crystalThresh) sumEmE += mc_it->second;
}
for (mc_it = metaContains.begin(); mc_it!=metaContains.end(); ++mc_it) {
if (mc_it->first.det() != DetId::Ecal || mc_it->second < crystalThresh) continue;
GlobalPoint p = emCrystalShwrPos(mc_it->first, fracDepth);
weight = 4.2 + log(mc_it->second/sumEmE);
sumWeights += weight;
emX += p.x() * weight;
emY += p.y() * weight;
emZ += p.z() * weight;
}
return GlobalPoint(emX/sumWeights, emY/sumWeights, emZ/sumWeights);
}
| GlobalPoint CaloTowersCreationAlgo::emShwrPos | ( | std::vector< std::pair< DetId, double > > & | metaContains, |
| float | fracDepth, | ||
| double | totEmE | ||
| ) |
Definition at line 1270 of file CaloTowersCreationAlgo.cc.
References ExpressReco_HICollisions_FallBack::e, DetId::Ecal, emCrystalShwrPos(), L1TEmulatorMonitor_cff::p, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().
Referenced by convert().
{
if (emE<=0) return GlobalPoint(0,0,0);
double emX = 0.0;
double emY = 0.0;
double emZ = 0.0;
double eSum = 0;
std::vector<std::pair<DetId,double> >::iterator mc_it = metaContains.begin();
for (; mc_it!=metaContains.end(); ++mc_it) {
if (mc_it->first.det() != DetId::Ecal) continue;
GlobalPoint p = emCrystalShwrPos(mc_it->first, fracDepth);
double e = mc_it->second;
if (e>0) {
emX += p.x() * e;
emY += p.y() * e;
emZ += p.z() * e;
eSum += e;
}
}
return GlobalPoint(emX/eSum, emY/eSum, emZ/eSum);
}
| 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 732 of file CaloTowersCreationAlgo.cc.
References matplotRender::t, and theTowerMap.
Referenced by assignHit(), and rescale().
{
MetaTowerMap::iterator itr = theTowerMap.find(detId);
if(itr == theTowerMap.end()) {
// need to build a new tower
MetaTower t;
// store it in the map
theTowerMap.insert(std::pair<CaloTowerDetId, CaloTowersCreationAlgo::MetaTower>(detId, t));
itr = theTowerMap.find(detId);
}
return itr->second;
}
| void CaloTowersCreationAlgo::finish | ( | CaloTowerCollection & | destCollection | ) |
Definition at line 293 of file CaloTowersCreationAlgo.cc.
References CaloTower::constituentsSize(), convert(), reco::LeafCandidate::energy(), edm::SortedCollection< T, SORT >::push_back(), theEcutTower, and theTowerMap.
Referenced by CaloTowersCreator::produce().
{
// now copy this map into the final collection
for(MetaTowerMap::const_iterator mapItr = theTowerMap.begin();
mapItr != theTowerMap.end(); ++mapItr) {
// Convert only if there is at least one constituent in the metatower.
// The check of constituents size in the coverted tower is still needed!
if ( (mapItr->second).metaConstituents.size()<1) continue;
CaloTower ct=convert(mapItr->first,mapItr->second);
if (ct.constituentsSize()>0 && ct.energy()>theEcutTower) {
result.push_back(ct);
}
}
theTowerMap.clear(); // save the memory
}
| void CaloTowersCreationAlgo::getThresholdAndWeight | ( | const DetId & | detId, |
| double & | threshold, | ||
| double & | weight | ||
| ) | const [private] |
helper method to look up the appropriate threshold & weight
Definition at line 974 of file CaloTowersCreationAlgo.cc.
References gather_cfg::cout, HcalDetId::depth(), DetId::det(), DetId::Ecal, EcalBarrel, EcalEndcap, HcalTopology::firstHEDoublePhiRing(), DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, HcalDetId::ieta(), HcalDetId::ietaAbs(), HcalDetId::subdet(), DetId::subdetId(), theEBEScale, theEBGrid, theEBthreshold, theEBweight, theEBWeights, theEEEScale, theEEGrid, theEEthreshold, theEEweight, theEEWeights, theHBEScale, theHBGrid, theHBthreshold, theHBweight, theHBWeights, theHcalTopology, theHEDEScale, theHEDGrid, theHEDthreshold, theHEDweight, theHEDWeights, theHESEScale, theHESGrid, theHESthreshold, theHESweight, theHESWeights, theHF1EScale, theHF1Grid, theHF1threshold, theHF1weight, theHF1Weights, theHF2EScale, theHF2Grid, theHF2threshold, theHF2weight, theHF2Weights, theHOEScale, theHOGrid, theHOthreshold0, theHOthresholdMinus1, theHOthresholdMinus2, theHOthresholdPlus1, theHOthresholdPlus2, theHOweight, and theHOWeights.
Referenced by assignHit(), rescale(), and rescaleTowers().
{
DetId::Detector det = detId.det();
weight=0; // in case the hit is not identified
if(det == DetId::Ecal) {
// may or may not be EB. We'll find out.
EcalSubdetector subdet = (EcalSubdetector)(detId.subdetId());
if(subdet == EcalBarrel) {
threshold = theEBthreshold;
weight = theEBweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theEBGrid,theEBWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theEBEScale);
}
}
else if(subdet == EcalEndcap) {
threshold = theEEthreshold;
weight = theEEweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theEEGrid,theEEWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theEEEScale);
}
}
}
else if(det == DetId::Hcal) {
HcalDetId hcalDetId(detId);
HcalSubdetector subdet = hcalDetId.subdet();
if(subdet == HcalBarrel) {
threshold = theHBthreshold;
weight = theHBweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHBGrid,theHBWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHBEScale);
}
}
else if(subdet == HcalEndcap) {
// check if it's single or double tower
if(hcalDetId.ietaAbs() < theHcalTopology->firstHEDoublePhiRing()) {
threshold = theHESthreshold;
weight = theHESweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHESGrid,theHESWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHESEScale);
}
}
else {
threshold = theHEDthreshold;
weight = theHEDweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHEDGrid,theHEDWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHEDEScale);
}
}
}
else if(subdet == HcalOuter) {
//check if it's ring 0 or +1 or +2 or -1 or -2
if(hcalDetId.ietaAbs() <= 4) threshold = theHOthreshold0;
else if(hcalDetId.ieta() < 0) {
// set threshold for ring -1 or -2
threshold = (hcalDetId.ietaAbs() <= 10) ? theHOthresholdMinus1 : theHOthresholdMinus2;
} else {
// set threshold for ring +1 or +2
threshold = (hcalDetId.ietaAbs() <= 10) ? theHOthresholdPlus1 : theHOthresholdPlus2;
}
weight = theHOweight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHOGrid,theHOWeights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHOEScale);
}
}
else if(subdet == HcalForward) {
if(hcalDetId.depth() == 1) {
threshold = theHF1threshold;
weight = theHF1weight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHF1Grid,theHF1Weights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHF1EScale);
}
} else {
threshold = theHF2threshold;
weight = theHF2weight;
if (weight <= 0.) {
ROOT::Math::Interpolator my(theHF2Grid,theHF2Weights,ROOT::Math::Interpolation::kAKIMA);
weight = my.Eval(theHF2EScale);
}
}
}
}
else {
std::cout << "BAD CELL det " << det << std::endl;
}
}
| GlobalPoint CaloTowersCreationAlgo::hadSegmentShwrPos | ( | DetId | detId, |
| float | fracDepth | ||
| ) |
Definition at line 1131 of file CaloTowersCreationAlgo.cc.
References CaloCellGeometry::getCorners(), CaloGeometry::getGeometry(), CaloCellGeometry::getPosition(), point, theGeometry, ExpressReco_HICollisions_FallBack::x, ExpressReco_HICollisions_FallBack::y, and z.
Referenced by hadShwrPos().
{
const CaloCellGeometry* cellGeometry = theGeometry->getGeometry(detId);
GlobalPoint point = cellGeometry->getPosition(); // face of the cell
if (fracDepth<0) fracDepth=0;
else if (fracDepth>1) fracDepth=1;
if (fracDepth>0.0) {
CaloCellGeometry::CornersVec cv = cellGeometry->getCorners();
GlobalPoint backPoint = GlobalPoint( 0.25*( cv[4].x() + cv[5].x() + cv[6].x() + cv[7].x() ),
0.25*( cv[4].y() + cv[5].y() + cv[6].y() + cv[7].y() ),
0.25*( cv[4].z() + cv[5].z() + cv[6].z() + cv[7].z() ) );
point += fracDepth * (backPoint-point);
}
return point;
}
| GlobalPoint CaloTowersCreationAlgo::hadShwPosFromCells | ( | DetId | frontCell, |
| DetId | backCell, | ||
| float | fracDepth | ||
| ) |
Definition at line 1248 of file CaloTowersCreationAlgo.cc.
References CaloCellGeometry::getCorners(), CaloGeometry::getGeometry(), CaloCellGeometry::getPosition(), point, theGeometry, ExpressReco_HICollisions_FallBack::x, ExpressReco_HICollisions_FallBack::y, and z.
Referenced by hadShwrPos().
{
// uses the "front" and "back" cells
// to determine the axis. point set by the predefined depth.
const CaloCellGeometry* frontCellGeometry = theGeometry->getGeometry(DetId(frontCellId));
const CaloCellGeometry* backCellGeometry = theGeometry->getGeometry(DetId(backCellId));
GlobalPoint point = frontCellGeometry->getPosition();
CaloCellGeometry::CornersVec cv = backCellGeometry->getCorners();
GlobalPoint backPoint = GlobalPoint(0.25 * (cv[4].x() + cv[5].x() + cv[6].x() + cv[7].x()),
0.25 * (cv[4].y() + cv[5].y() + cv[6].y() + cv[7].y()),
0.25 * (cv[4].z() + cv[5].z() + cv[6].z() + cv[7].z()));
point += fracDepth * (backPoint - point);
return point;
}
| GlobalPoint CaloTowersCreationAlgo::hadShwrPos | ( | std::vector< std::pair< DetId, double > > & | metaContains, |
| float | fracDepth, | ||
| double | hadE | ||
| ) |
Definition at line 1150 of file CaloTowersCreationAlgo.cc.
References hadSegmentShwrPos(), DetId::Hcal, HcalOuter, L1TEmulatorMonitor_cff::p, HcalDetId::subdet(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().
Referenced by convert().
{
// this is based on available RecHits, can lead to different actual depths if
// hits in multi-depth towers are not all there
if (hadE<=0) return GlobalPoint(0,0,0);
double hadX = 0.0;
double hadY = 0.0;
double hadZ = 0.0;
int nConst = 0;
std::vector<std::pair<DetId,double> >::iterator mc_it = metaContains.begin();
for (; mc_it!=metaContains.end(); ++mc_it) {
if (mc_it->first.det() != DetId::Hcal) continue;
// do not use HO for deirection calculations for now
if (HcalDetId(mc_it->first).subdet() == HcalOuter) continue;
++nConst;
GlobalPoint p = hadSegmentShwrPos(mc_it->first, fracDepth);
// longitudinal segmentation: do not weight by energy,
// get the geometrical position
hadX += p.x();
hadY += p.y();
hadZ += p.z();
}
return GlobalPoint(hadX/nConst, hadY/nConst, hadZ/nConst);
}
| GlobalPoint CaloTowersCreationAlgo::hadShwrPos | ( | CaloTowerDetId | id, |
| float | fracDepth | ||
| ) |
Definition at line 1183 of file CaloTowersCreationAlgo.cc.
References hadShwPosFromCells(), HcalBarrel, HcalEndcap, HcalForward, CaloTowerDetId::ieta(), CaloTowerDetId::ietaAbs(), CaloTowerDetId::iphi(), and point.
{
// set depth using geometry of cells that are associated with the
// tower (regardless if they have non-zero energies)
// if (hadE <= 0) return GlobalPoint(0, 0, 0);
if (fracDepth < 0) fracDepth = 0;
else if (fracDepth > 1) fracDepth = 1;
GlobalPoint point(0,0,0);
int iEta = towerId.ieta();
int iPhi = towerId.iphi();
HcalDetId frontCellId, backCellId;
if (towerId.ietaAbs() <= 14) {
// barrel, one depth only
frontCellId = HcalDetId(HcalBarrel, iEta, iPhi, 1);
backCellId = HcalDetId(HcalBarrel, iEta, iPhi, 1);
}
else if (towerId.ietaAbs() == 15) {
// barrel, two depths
frontCellId = HcalDetId(HcalBarrel, iEta, iPhi, 1);
backCellId = HcalDetId(HcalBarrel, iEta, iPhi, 2);
}
else if (towerId.ietaAbs() == 16) {
// barrel and endcap: two depths HB, one depth HE
frontCellId = HcalDetId(HcalBarrel, iEta, iPhi, 1);
backCellId = HcalDetId(HcalEndcap, iEta, iPhi, 3); // this cell is in endcap!
}
else if (towerId.ietaAbs() == 17) {
// endcap, one depth only
frontCellId = HcalDetId(HcalEndcap, iEta, iPhi, 1);
backCellId = HcalDetId(HcalEndcap, iEta, iPhi, 1);
}
else if (towerId.ietaAbs() >= 18 && towerId.ietaAbs() <= 26) {
// endcap: two depths
frontCellId = HcalDetId(HcalEndcap, iEta, iPhi, 1);
backCellId = HcalDetId(HcalEndcap, iEta, iPhi, 2);
}
else if (towerId.ietaAbs() <= 29) {
// endcap: three depths
frontCellId = HcalDetId(HcalEndcap, iEta, iPhi, 1);
// there is no iEta=29 for depth 3
if (iEta == 29) iEta = 28;
if (iEta == -29) iEta = -28;
backCellId = HcalDetId(HcalEndcap, iEta, iPhi, 3);
}
else if (towerId.ietaAbs() >= 30) {
// forward, take the goemetry for long fibers
frontCellId = HcalDetId(HcalForward, iEta, iPhi, 1);
backCellId = HcalDetId(HcalForward, iEta, iPhi, 1);
}
else {
// should not get here
return point;
}
point = hadShwPosFromCells(DetId(frontCellId), DetId(backCellId), fracDepth);
return point;
}
| unsigned int CaloTowersCreationAlgo::hcalChanStatusForCaloTower | ( | const CaloRecHit * | hit | ) |
Definition at line 1397 of file CaloTowersCreationAlgo.cc.
References BadChan, CaloRecHit::detid(), CaloRecHit::flags(), HcalSeverityLevelComputer::getSeverityLevel(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), GoodChan, IgnoredChan, ProblematicChan, RecoveredChan, HcalSeverityLevelComputer::recoveredRecHit(), theHcalAcceptSeverityLevel, theHcalAcceptSeverityLevelForRejectedHit, theHcalChStatus, theHcalSevLvlComputer, theRecoveredHcalHitsAreUsed, useRejectedHitsOnly, and useRejectedRecoveredHcalHits.
Referenced by assignHit().
{
const DetId id = hit->detid();
const uint32_t recHitFlag = hit->flags();
const uint32_t dbStatusFlag = theHcalChStatus->getValues(id)->getValue();
int severityLevel = theHcalSevLvlComputer->getSeverityLevel(id, recHitFlag, dbStatusFlag);
bool isRecovered = theHcalSevLvlComputer->recoveredRecHit(id, recHitFlag);
// For use with hits rejected in the default reconstruction
if (useRejectedHitsOnly) {
if (!isRecovered) {
if (severityLevel <= int(theHcalAcceptSeverityLevel) ||
severityLevel > int(theHcalAcceptSeverityLevelForRejectedHit)) return CaloTowersCreationAlgo::IgnoredChan;
// this hit was either already accepted or is worse than
}
else {
if (theRecoveredHcalHitsAreUsed || !useRejectedRecoveredHcalHits) {
// skip recovered hits either because they were already used or because there was an explicit instruction
return CaloTowersCreationAlgo::IgnoredChan;
}
else if (useRejectedRecoveredHcalHits) {
return CaloTowersCreationAlgo::RecoveredChan;
}
} // recovered channels
// clasify channels as problematic: no good hits are supposed to be present in the
// extra rechit collections
return CaloTowersCreationAlgo::ProblematicChan;
} // treatment of rejected hits
// this is for the regular reconstruction sequence
if (severityLevel == 0) return CaloTowersCreationAlgo::GoodChan;
if (isRecovered) {
return (theRecoveredHcalHitsAreUsed) ?
CaloTowersCreationAlgo::RecoveredChan : CaloTowersCreationAlgo::BadChan;
}
else {
if (severityLevel > int(theHcalAcceptSeverityLevel)) {
return CaloTowersCreationAlgo::BadChan;
}
else {
return CaloTowersCreationAlgo::ProblematicChan;
}
}
}
| void CaloTowersCreationAlgo::makeHcalDropChMap | ( | ) |
Definition at line 1359 of file CaloTowersCreationAlgo.cc.
References HcalDetId::depth(), HcalSeverityLevelComputer::dropChannel(), HcalCondObjectContainer< Item >::getAllChannels(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), hcalDropChMap, HcalEndcap, CaloTowerDetId::ieta(), HcalDetId::ietaAbs(), CaloTowerDetId::iphi(), HcalDetId::subdet(), theHcalChStatus, theHcalSevLvlComputer, theTowerConstituentsMap, CaloTowerConstituentsMap::towerOf(), and CaloTowerDetId::zside().
Referenced by CaloTowersCreator::produce().
{
// This method fills the map of number of dead channels for the calotower,
// The key of the map is CaloTowerDetId.
// By definition these channels are not going to be in the RecHit collections.
std::vector<DetId> allChanInStatusCont = theHcalChStatus->getAllChannels();
for (std::vector<DetId>::iterator it = allChanInStatusCont.begin(); it!=allChanInStatusCont.end(); ++it) {
const uint32_t dbStatusFlag = theHcalChStatus->getValues(*it)->getValue();
if (theHcalSevLvlComputer->dropChannel(dbStatusFlag)) {
CaloTowerDetId twrId = theTowerConstituentsMap->towerOf(*it);
hcalDropChMap[twrId] +=1;
// special case for tower 29: if HCAL hit is in depth 3 add to twr 29 as well
if (HcalDetId(*it).subdet()==HcalEndcap &&
HcalDetId(*it).depth()==3 &&
HcalDetId(*it).ietaAbs()==28) {
CaloTowerDetId twrId29 = CaloTowerDetId(twrId.ieta()+twrId.zside(), twrId.iphi());
hcalDropChMap[twrId29] +=1;
}
}
}
return;
}
| void CaloTowersCreationAlgo::process | ( | const HFRecHitCollection & | hf | ) |
| void CaloTowersCreationAlgo::process | ( | const EcalRecHitCollection & | ecal | ) |
| void CaloTowersCreationAlgo::process | ( | const CaloTowerCollection & | ctc | ) |
Definition at line 284 of file CaloTowersCreationAlgo.cc.
References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), and rescale().
{
for(CaloTowerCollection::const_iterator ctcItr = ctc.begin();
ctcItr != ctc.end(); ++ctcItr) {
rescale(&(*ctcItr));
}
}
| void CaloTowersCreationAlgo::process | ( | const HBHERecHitCollection & | hbhe | ) |
Definition at line 256 of file CaloTowersCreationAlgo.cc.
References assignHit(), edm::SortedCollection< T, SORT >::begin(), and edm::SortedCollection< T, SORT >::end().
Referenced by CaloTowersCreator::produce().
{
for(HBHERecHitCollection::const_iterator hbheItr = hbhe.begin();
hbheItr != hbhe.end(); ++hbheItr)
assignHit(&(*hbheItr));
}
| void CaloTowersCreationAlgo::process | ( | const HORecHitCollection & | ho | ) |
| void CaloTowersCreationAlgo::rescale | ( | const CaloTower * | ct | ) | [private] |
Definition at line 682 of file CaloTowersCreationAlgo.cc.
References CaloTower::constituent(), CaloTower::constituentsSize(), HcalDetId::depth(), DetId::det(), CaloTowersCreationAlgo::MetaTower::E, CaloTowersCreationAlgo::MetaTower::E_em, CaloTowersCreationAlgo::MetaTower::E_had, CaloTowersCreationAlgo::MetaTower::E_outer, DetId::Ecal, CaloTower::ecalTime(), CaloTower::emEnergy(), CaloTowersCreationAlgo::MetaTower::emSumEForTime, CaloTowersCreationAlgo::MetaTower::emSumTimeTimesE, find(), getThresholdAndWeight(), CaloTower::hadEnergy(), CaloTowersCreationAlgo::MetaTower::hadSumEForTime, CaloTowersCreationAlgo::MetaTower::hadSumTimeTimesE, HcalForward, HcalOuter, CaloTower::hcalTime(), i, CaloTower::id(), CaloTowersCreationAlgo::MetaTower::metaConstituents, CaloTower::outerEnergy(), HcalDetId::subdet(), crabWrap::threshold, and CommonMethods::weight().
Referenced by process().
{
double threshold, weight;
CaloTowerDetId towerDetId = ct->id();
// if (towerDetId.null()) return;
MetaTower & tower = find(towerDetId);
tower.E_em = 0.;
tower.E_had = 0.;
tower.E_outer = 0.;
for (unsigned int i=0; i<ct->constituentsSize(); i++) {
DetId detId = ct->constituent(i);
getThresholdAndWeight(detId, threshold, weight);
DetId::Detector det = detId.det();
if(det == DetId::Ecal) {
tower.E_em = ct->emEnergy()*weight;
}
else {
HcalDetId hcalDetId(detId);
if(hcalDetId.subdet() == HcalForward) {
if (hcalDetId.depth()==1) tower.E_em = ct->emEnergy()*weight;
if (hcalDetId.depth()==2) tower.E_had = ct->hadEnergy()*weight;
}
else if(hcalDetId.subdet() == HcalOuter) {
tower.E_outer = ct->outerEnergy()*weight;
}
else {
tower.E_had = ct->hadEnergy()*weight;
}
}
tower.E = tower.E_had+tower.E_em+tower.E_outer;
// this is to be compliant with the new MetaTower setup
// used only for the default simple vector assignment
std::pair<DetId, double> mc(detId, 0);
tower.metaConstituents.push_back(mc);
}
// preserve time inforamtion
tower.emSumTimeTimesE = ct->ecalTime();
tower.hadSumTimeTimesE = ct->hcalTime();
tower.emSumEForTime = 1.0;
tower.hadSumEForTime = 1.0;
}
| void CaloTowersCreationAlgo::rescaleTowers | ( | const CaloTowerCollection & | ctInput, |
| CaloTowerCollection & | ctResult | ||
| ) |
Definition at line 311 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(), getThresholdAndWeight(), DetId::Hcal, HcalOuter, CaloTowerDetId::ietaAbs(), PV3DBase< T, PVType, FrameType >::phi(), edm::SortedCollection< T, SORT >::push_back(), CaloTower::setCaloTowerStatus(), CaloTower::setEcalTime(), CaloTower::setHcalTime(), HcalDetId::subdet(), theHF1weight, theHF2weight, theHOIsUsed, crabWrap::threshold, and CommonMethods::weight().
Referenced by CaloTowersReCreator::produce().
{
for (CaloTowerCollection::const_iterator ctcItr = ctc.begin();
ctcItr != ctc.end(); ++ctcItr) {
CaloTowerDetId twrId = ctcItr->id();
double newE_em = ctcItr->emEnergy();
double newE_had = ctcItr->hadEnergy();
double newE_outer = ctcItr->outerEnergy();
double threshold = 0.0; // not used: we do not change thresholds
double weight = 1.0;
// HF
if (ctcItr->ietaAbs()>=30) {
double E_short = 0.5 * newE_had; // from the definitions for HF
double E_long = newE_em + 0.5 * newE_had; //
// scale
E_long *= theHF1weight;
E_short *= theHF2weight;
// convert
newE_em = E_long - E_short;
newE_had = 2.0 * E_short;
}
else { // barrel/endcap
// find if its in EB, or EE; determine from first ecal constituent found
for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
DetId constId = ctcItr->constituent(iConst);
if (constId.det()!=DetId::Ecal) continue;
getThresholdAndWeight(constId, threshold, weight);
newE_em *= weight;
break;
}
// HO
for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
DetId constId = ctcItr->constituent(iConst);
if (constId.det()!=DetId::Hcal) continue;
if (HcalDetId(constId).subdet()!=HcalOuter) continue;
getThresholdAndWeight(constId, threshold, weight);
newE_outer *= weight;
break;
}
// HB/HE
for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
DetId constId = ctcItr->constituent(iConst);
if (constId.det()!=DetId::Hcal) continue;
if (HcalDetId(constId).subdet()==HcalOuter) continue;
getThresholdAndWeight(constId, threshold, weight);
newE_had *= weight;
if (ctcItr->ietaAbs()>16) newE_outer *= weight;
break;
}
} // barrel/endcap region
// now make the new tower
double newE_hadTot = (theHOIsUsed && twrId.ietaAbs()<16)? newE_had+newE_outer : newE_had;
GlobalPoint emPoint = ctcItr->emPosition();
GlobalPoint hadPoint = ctcItr->emPosition();
double f_em = 1.0/cosh(emPoint.eta());
double f_had = 1.0/cosh(hadPoint.eta());
CaloTower::PolarLorentzVector towerP4;
if (ctcItr->ietaAbs()<30) {
if (newE_em>0) towerP4 += CaloTower::PolarLorentzVector(newE_em*f_em, emPoint.eta(), emPoint.phi(), 0);
if (newE_hadTot>0) towerP4 += CaloTower::PolarLorentzVector(newE_hadTot*f_had, hadPoint.eta(), hadPoint.phi(), 0);
}
else {
double newE_tot = newE_em + newE_had;
// for HF we use common point for ecal, hcal shower positions regardless of the method
if (newE_tot>0) towerP4 += CaloTower::PolarLorentzVector(newE_tot*f_had, hadPoint.eta(), hadPoint.phi(), 0);
}
CaloTower rescaledTower(twrId, newE_em, newE_had, newE_outer, -1, -1, towerP4, emPoint, hadPoint);
// copy the timings, have to convert back to int, 1 unit = 0.01 ns
rescaledTower.setEcalTime( int(ctcItr->ecalTime()*100.0 + 0.5) );
rescaledTower.setHcalTime( int(ctcItr->hcalTime()*100.0 + 0.5) );
std::vector<DetId> contains;
for (unsigned int iConst = 0; iConst < ctcItr->constituentsSize(); ++iConst) {
contains.push_back(ctcItr->constituent(iConst));
}
rescaledTower.addConstituents(contains);
rescaledTower.setCaloTowerStatus(ctcItr->towerStatusWord());
ctcResult.push_back(rescaledTower);
} // end of loop over towers
}
| void CaloTowersCreationAlgo::setEBEScale | ( | double | scale | ) |
Definition at line 1072 of file CaloTowersCreationAlgo.cc.
References theEBEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theEBEScale = scale;
else *&theEBEScale = 50.;
}
| void CaloTowersCreationAlgo::setEbHandle | ( | const edm::Handle< EcalRecHitCollection > | eb | ) | [inline] |
Definition at line 183 of file CaloTowersCreationAlgo.h.
References theEbHandle.
Referenced by CaloTowersCreator::produce().
{ theEbHandle = eb; }
| void CaloTowersCreationAlgo::setEcalAcceptSeverityLevel | ( | unsigned int | level | ) | [inline] |
Definition at line 152 of file CaloTowersCreationAlgo.h.
References testEve_cfg::level, and theEcalAcceptSeverityLevel.
Referenced by CaloTowersCreator::produce().
| void CaloTowersCreationAlgo::setEcalAcceptSeverityLevelForRejectedHit | ( | unsigned int | level | ) | [inline] |
Definition at line 172 of file CaloTowersCreationAlgo.h.
References testEve_cfg::level, and theEcalAcceptSeverityLevelForRejectedHit.
Referenced by CaloTowersCreator::produce().
| void CaloTowersCreationAlgo::setEcalChStatusFromDB | ( | const EcalChannelStatus * | s | ) | [inline] |
Definition at line 110 of file CaloTowersCreationAlgo.h.
References asciidump::s, and theEcalChStatus.
Referenced by CaloTowersCreator::produce().
{ theEcalChStatus = s; }
| void CaloTowersCreationAlgo::setEcalSevLvlAlgo | ( | const EcalSeverityLevelAlgo * | a | ) | [inline] |
Definition at line 162 of file CaloTowersCreationAlgo.h.
References a, and theEcalSevLvlAlgo.
Referenced by CaloTowersCreator::produce().
{ theEcalSevLvlAlgo = a; }
| void CaloTowersCreationAlgo::setEEEScale | ( | double | scale | ) |
Definition at line 1077 of file CaloTowersCreationAlgo.cc.
References theEEEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theEEEScale = scale;
else *&theEEEScale = 50.;
}
| void CaloTowersCreationAlgo::setEeHandle | ( | const edm::Handle< EcalRecHitCollection > | ee | ) | [inline] |
Definition at line 184 of file CaloTowersCreationAlgo.h.
References theEeHandle.
Referenced by CaloTowersCreator::produce().
{ theEeHandle = ee; }
| void CaloTowersCreationAlgo::setGeometry | ( | const CaloTowerConstituentsMap * | cttopo, |
| const HcalTopology * | htopo, | ||
| const CaloGeometry * | geo | ||
| ) |
Definition at line 244 of file CaloTowersCreationAlgo.cc.
References DetId::Calo, CaloGeometry::getSubdetectorGeometry(), CaloTowerDetId::SubdetId, theGeometry, theHcalTopology, theTowerConstituentsMap, and theTowerGeometry.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
theTowerConstituentsMap=ctt;
theHcalTopology = topo;
theGeometry = geo;
theTowerGeometry=geo->getSubdetectorGeometry(DetId::Calo,CaloTowerDetId::SubdetId);
}
| void CaloTowersCreationAlgo::setHBEScale | ( | double | scale | ) |
Definition at line 1082 of file CaloTowersCreationAlgo.cc.
References theHBEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHBEScale = scale;
else *&theHBEScale = 50.;
}
| void CaloTowersCreationAlgo::setHcalAcceptSeverityLevel | ( | unsigned int | level | ) | [inline] |
Definition at line 151 of file CaloTowersCreationAlgo.h.
References testEve_cfg::level, and theHcalAcceptSeverityLevel.
Referenced by CaloTowersCreator::produce().
| void CaloTowersCreationAlgo::setHcalAcceptSeverityLevelForRejectedHit | ( | unsigned int | level | ) | [inline] |
Definition at line 171 of file CaloTowersCreationAlgo.h.
References testEve_cfg::level, and theHcalAcceptSeverityLevelForRejectedHit.
Referenced by CaloTowersCreator::produce().
| void CaloTowersCreationAlgo::setHcalChStatusFromDB | ( | const HcalChannelQuality * | s | ) | [inline] |
Definition at line 109 of file CaloTowersCreationAlgo.h.
References asciidump::s, and theHcalChStatus.
Referenced by CaloTowersCreator::produce().
{ theHcalChStatus = s; }
| void CaloTowersCreationAlgo::setHcalSevLvlComputer | ( | const HcalSeverityLevelComputer * | c | ) | [inline] |
Definition at line 159 of file CaloTowersCreationAlgo.h.
References trackerHits::c, and theHcalSevLvlComputer.
Referenced by CaloTowersCreator::produce().
{theHcalSevLvlComputer = c; };
| void CaloTowersCreationAlgo::setHEDEScale | ( | double | scale | ) |
Definition at line 1092 of file CaloTowersCreationAlgo.cc.
References theHEDEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHEDEScale = scale;
else *&theHEDEScale = 50.;
}
| void CaloTowersCreationAlgo::setHESEScale | ( | double | scale | ) |
Definition at line 1087 of file CaloTowersCreationAlgo.cc.
References theHESEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHESEScale = scale;
else *&theHESEScale = 50.;
}
| void CaloTowersCreationAlgo::setHF1EScale | ( | double | scale | ) |
Definition at line 1102 of file CaloTowersCreationAlgo.cc.
References theHF1EScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHF1EScale = scale;
else *&theHF1EScale = 50.;
}
| void CaloTowersCreationAlgo::setHF2EScale | ( | double | scale | ) |
Definition at line 1107 of file CaloTowersCreationAlgo.cc.
References theHF2EScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHF2EScale = scale;
else *&theHF2EScale = 50.;
}
| void CaloTowersCreationAlgo::setHOEScale | ( | double | scale | ) |
Definition at line 1097 of file CaloTowersCreationAlgo.cc.
References theHOEScale.
Referenced by CaloTowersReCreator::produce(), and CaloTowersCreator::produce().
{
if (scale>0.00001) *&theHOEScale = scale;
else *&theHOEScale = 50.;
}
| void CaloTowersCreationAlgo::setRecoveredEcalHitsAreUsed | ( | bool | flag | ) | [inline] |
Definition at line 156 of file CaloTowersCreationAlgo.h.
References theRecoveredEcalHitsAreUsed.
Referenced by CaloTowersCreator::produce().
{theRecoveredEcalHitsAreUsed = flag; };
| void CaloTowersCreationAlgo::setRecoveredHcalHitsAreUsed | ( | bool | flag | ) | [inline] |
Definition at line 155 of file CaloTowersCreationAlgo.h.
References theRecoveredHcalHitsAreUsed.
Referenced by CaloTowersCreator::produce().
{theRecoveredHcalHitsAreUsed = flag; };
| void CaloTowersCreationAlgo::setUseRejectedHitsOnly | ( | bool | flag | ) | [inline] |
Definition at line 169 of file CaloTowersCreationAlgo.h.
References useRejectedHitsOnly.
Referenced by CaloTowersCreator::produce().
{ useRejectedHitsOnly = flag; }
| void CaloTowersCreationAlgo::setUseRejectedRecoveredEcalHits | ( | bool | flag | ) | [inline] |
Definition at line 175 of file CaloTowersCreationAlgo.h.
References useRejectedRecoveredEcalHits.
Referenced by CaloTowersCreator::produce().
{useRejectedRecoveredEcalHits = flag; };
| void CaloTowersCreationAlgo::setUseRejectedRecoveredHcalHits | ( | bool | flag | ) | [inline] |
Definition at line 174 of file CaloTowersCreationAlgo.h.
References useRejectedRecoveredHcalHits.
Referenced by CaloTowersCreator::produce().
{useRejectedRecoveredHcalHits = flag; };
std::map<CaloTowerDetId, int> CaloTowersCreationAlgo::hcalDropChMap [private] |
Definition at line 323 of file CaloTowersCreationAlgo.h.
Referenced by begin(), convert(), and makeHcalDropChMap().
double CaloTowersCreationAlgo::theEBEScale [private] |
Definition at line 256 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setEBEScale().
std::vector<double> CaloTowersCreationAlgo::theEBGrid [private] |
Definition at line 244 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
Definition at line 333 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setEbHandle().
double CaloTowersCreationAlgo::theEBSumThreshold [private] |
Definition at line 254 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theEBthreshold [private] |
Definition at line 234 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theEBweight [private] |
Definition at line 252 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theEBWeights [private] |
Definition at line 244 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
unsigned int CaloTowersCreationAlgo::theEcalAcceptSeverityLevel [private] |
Definition at line 284 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setEcalAcceptSeverityLevel().
unsigned int CaloTowersCreationAlgo::theEcalAcceptSeverityLevelForRejectedHit [private] |
Definition at line 293 of file CaloTowersCreationAlgo.h.
Referenced by ecalChanStatusForCaloTower(), and setEcalAcceptSeverityLevelForRejectedHit().
const EcalChannelStatus* CaloTowersCreationAlgo::theEcalChStatus [private] |
Definition at line 270 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setEcalChStatusFromDB().
const EcalSeverityLevelAlgo* CaloTowersCreationAlgo::theEcalSevLvlAlgo [private] |
Definition at line 277 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setEcalSevLvlAlgo().
double CaloTowersCreationAlgo::theEcutTower [private] |
Definition at line 254 of file CaloTowersCreationAlgo.h.
Referenced by finish().
double CaloTowersCreationAlgo::theEEEScale [private] |
Definition at line 257 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setEEEScale().
std::vector<double> CaloTowersCreationAlgo::theEEGrid [private] |
Definition at line 245 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
Definition at line 334 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setEeHandle().
double CaloTowersCreationAlgo::theEESumThreshold [private] |
Definition at line 254 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theEEthreshold [private] |
Definition at line 234 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theEEweight [private] |
Definition at line 252 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theEEWeights [private] |
Definition at line 245 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
const CaloGeometry* CaloTowersCreationAlgo::theGeometry [private] |
Definition at line 265 of file CaloTowersCreationAlgo.h.
Referenced by assignHit(), emCrystalShwrPos(), hadSegmentShwrPos(), hadShwPosFromCells(), and setGeometry().
double CaloTowersCreationAlgo::theHBEScale [private] |
Definition at line 258 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHBEScale().
std::vector<double> CaloTowersCreationAlgo::theHBGrid [private] |
Definition at line 246 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHBthreshold [private] |
Definition at line 241 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHBweight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theHBWeights [private] |
Definition at line 246 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevel [private] |
Definition at line 283 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevel().
unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit [private] |
Definition at line 292 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevelForRejectedHit().
const HcalChannelQuality* CaloTowersCreationAlgo::theHcalChStatus [private] |
Definition at line 271 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), makeHcalDropChMap(), and setHcalChStatusFromDB().
const HcalSeverityLevelComputer* CaloTowersCreationAlgo::theHcalSevLvlComputer [private] |
Definition at line 274 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), makeHcalDropChMap(), and setHcalSevLvlComputer().
double CaloTowersCreationAlgo::theHcalThreshold [private] |
Definition at line 239 of file CaloTowersCreationAlgo.h.
Referenced by convert().
const HcalTopology* CaloTowersCreationAlgo::theHcalTopology [private] |
Definition at line 264 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setGeometry().
double CaloTowersCreationAlgo::theHEDEScale [private] |
Definition at line 260 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHEDEScale().
std::vector<double> CaloTowersCreationAlgo::theHEDGrid [private] |
Definition at line 248 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHEDthreshold [private] |
Definition at line 241 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHEDweight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theHEDWeights [private] |
Definition at line 248 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHESEScale [private] |
Definition at line 259 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHESEScale().
std::vector<double> CaloTowersCreationAlgo::theHESGrid [private] |
Definition at line 247 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHESthreshold [private] |
Definition at line 241 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHESweight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theHESWeights [private] |
Definition at line 247 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF1EScale [private] |
Definition at line 262 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHF1EScale().
std::vector<double> CaloTowersCreationAlgo::theHF1Grid [private] |
Definition at line 250 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF1threshold [private] |
Definition at line 243 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF1weight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and rescaleTowers().
std::vector<double> CaloTowersCreationAlgo::theHF1Weights [private] |
Definition at line 250 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF2EScale [private] |
Definition at line 263 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHF2EScale().
std::vector<double> CaloTowersCreationAlgo::theHF2Grid [private] |
Definition at line 251 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF2threshold [private] |
Definition at line 243 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHF2weight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and rescaleTowers().
std::vector<double> CaloTowersCreationAlgo::theHF2Weights [private] |
Definition at line 251 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOEScale [private] |
Definition at line 261 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight(), and setHOEScale().
std::vector<double> CaloTowersCreationAlgo::theHOGrid [private] |
Definition at line 249 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
bool CaloTowersCreationAlgo::theHOIsUsed [private] |
only affects energy and ET calculation. HO is still recorded in the tower
Definition at line 299 of file CaloTowersCreationAlgo.h.
Referenced by assignHit(), convert(), and rescaleTowers().
double CaloTowersCreationAlgo::theHOthreshold0 [private] |
Definition at line 242 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOthresholdMinus1 [private] |
Definition at line 242 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOthresholdMinus2 [private] |
Definition at line 243 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOthresholdPlus1 [private] |
Definition at line 242 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOthresholdPlus2 [private] |
Definition at line 243 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
double CaloTowersCreationAlgo::theHOweight [private] |
Definition at line 253 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
std::vector<double> CaloTowersCreationAlgo::theHOWeights [private] |
Definition at line 249 of file CaloTowersCreationAlgo.h.
Referenced by getThresholdAndWeight().
int CaloTowersCreationAlgo::theMomConstrMethod [private] |
Definition at line 303 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomEBDepth [private] |
Definition at line 309 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomEEDepth [private] |
Definition at line 310 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomEmDepth [private] |
Definition at line 304 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomHadDepth [private] |
Definition at line 305 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomHBDepth [private] |
Definition at line 307 of file CaloTowersCreationAlgo.h.
Referenced by convert().
double CaloTowersCreationAlgo::theMomHEDepth [private] |
Definition at line 308 of file CaloTowersCreationAlgo.h.
Referenced by convert().
bool CaloTowersCreationAlgo::theRecoveredEcalHitsAreUsed [private] |
Definition at line 287 of file CaloTowersCreationAlgo.h.
Referenced by convert(), ecalChanStatusForCaloTower(), and setRecoveredEcalHitsAreUsed().
bool CaloTowersCreationAlgo::theRecoveredHcalHitsAreUsed [private] |
Definition at line 286 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), and setRecoveredHcalHitsAreUsed().
const CaloTowerConstituentsMap* CaloTowersCreationAlgo::theTowerConstituentsMap [private] |
Definition at line 266 of file CaloTowersCreationAlgo.h.
Referenced by assignHit(), convert(), makeHcalDropChMap(), and setGeometry().
const CaloSubdetectorGeometry* CaloTowersCreationAlgo::theTowerGeometry [private] |
Definition at line 267 of file CaloTowersCreationAlgo.h.
Referenced by convert(), and setGeometry().
Definition at line 319 of file CaloTowersCreationAlgo.h.
bool CaloTowersCreationAlgo::theUseEtEBTresholdFlag [private] |
Definition at line 235 of file CaloTowersCreationAlgo.h.
Referenced by assignHit().
bool CaloTowersCreationAlgo::theUseEtEETresholdFlag [private] |
Definition at line 235 of file CaloTowersCreationAlgo.h.
Referenced by assignHit().
bool CaloTowersCreationAlgo::theUseSymEBTresholdFlag [private] |
Definition at line 236 of file CaloTowersCreationAlgo.h.
Referenced by assignHit().
bool CaloTowersCreationAlgo::theUseSymEETresholdFlag [private] |
Definition at line 236 of file CaloTowersCreationAlgo.h.
Referenced by assignHit().
bool CaloTowersCreationAlgo::useRejectedHitsOnly [private] |
Definition at line 291 of file CaloTowersCreationAlgo.h.
Referenced by ecalChanStatusForCaloTower(), hcalChanStatusForCaloTower(), and setUseRejectedHitsOnly().
unsigned int CaloTowersCreationAlgo::useRejectedRecoveredEcalHits [private] |
Definition at line 295 of file CaloTowersCreationAlgo.h.
Referenced by ecalChanStatusForCaloTower(), and setUseRejectedRecoveredEcalHits().
unsigned int CaloTowersCreationAlgo::useRejectedRecoveredHcalHits [private] |
Definition at line 294 of file CaloTowersCreationAlgo.h.
Referenced by hcalChanStatusForCaloTower(), and setUseRejectedRecoveredHcalHits().
1.7.3