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 HcalPFCuts *cuts)
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 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 52 of file CaloTowersCreationAlgo.h.

Member Typedef Documentation

HcalDropChMap

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

private

Definition at line 386 of file CaloTowersCreationAlgo.h.

MetaTowerMap

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

private

Definition at line 380 of file CaloTowersCreationAlgo.h.

Member Enumeration Documentation

ctHitCategory

enum CaloTowersCreationAlgo::ctHitCategory

private

Enumerator
GoodChan
BadChan
RecoveredChan
ProblematicChan
IgnoredChan

Definition at line 396 of file CaloTowersCreationAlgo.h.

{ 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.

    : theEBthreshold(-1000.),
      theEEthreshold(-1000.),

      theUseEtEBTresholdFlag(false),
      theUseEtEETresholdFlag(false),
      theUseSymEBTresholdFlag(false),
      theUseSymEETresholdFlag(false),

      theHcalThreshold(-1000.),
      theHBthreshold(-1000.),
      theHBthreshold1(-1000.),
      theHBthreshold2(-1000.),
      theHESthreshold(-1000.),
      theHESthreshold1(-1000.),
      theHEDthreshold(-1000.),
      theHEDthreshold1(-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.),
      theEBEScale(50.),
      theEEEScale(50.),
      theHBEScale(50.),
      theHESEScale(50.),
      theHEDEScale(50.),
      theHOEScale(50.),
      theHF1EScale(50.),
      theHF2EScale(50.),
      theHcalTopology(nullptr),
      theGeometry(nullptr),
      theTowerConstituentsMap(nullptr),
      theHcalAcceptSeverityLevel(0),
      theRecoveredHcalHitsAreUsed(false),
      theRecoveredEcalHitsAreUsed(false),
      useRejectedHitsOnly(false),
      theHcalAcceptSeverityLevelForRejectedHit(0),
      useRejectedRecoveredHcalHits(0),
      useRejectedRecoveredEcalHits(0),
      missingHcalRescaleFactorForEcal(0.),
      theHOIsUsed(true),
      // (for momentum reconstruction algorithm)
      theMomConstrMethod(0),
      theMomHBDepth(0.),
      theMomHEDepth(0.),
      theMomEBDepth(0.),
      theMomEEDepth(0.),
      theHcalPhase(0) {}

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.

    : theEBthreshold(EBthreshold),
      theEEthreshold(EEthreshold),

      theUseEtEBTresholdFlag(useEtEBTreshold),
      theUseEtEETresholdFlag(useEtEETreshold),
      theUseSymEBTresholdFlag(useSymEBTreshold),
      theUseSymEETresholdFlag(useSymEETreshold),

      theHcalThreshold(HcalThreshold),
      theHBthreshold(HBthreshold),
      theHBthreshold1(HBthreshold1),
      theHBthreshold2(HBthreshold2),
      theHESthreshold(HESthreshold),
      theHESthreshold1(HESthreshold1),
      theHEDthreshold(HEDthreshold),
      theHEDthreshold1(HEDthreshold1),
      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),
      theEBEScale(50.),
      theEEEScale(50.),
      theHBEScale(50.),
      theHESEScale(50.),
      theHEDEScale(50.),
      theHOEScale(50.),
      theHF1EScale(50.),
      theHF2EScale(50.),
      theHcalTopology(nullptr),
      theGeometry(nullptr),
      theTowerConstituentsMap(nullptr),
      theHcalAcceptSeverityLevel(0),
      theRecoveredHcalHitsAreUsed(false),
      theRecoveredEcalHitsAreUsed(false),
      useRejectedHitsOnly(false),
      theHcalAcceptSeverityLevelForRejectedHit(0),
      useRejectedRecoveredHcalHits(0),
      useRejectedRecoveredEcalHits(0),
      missingHcalRescaleFactorForEcal(0.),
      theHOIsUsed(useHO),
      // (momentum reconstruction algorithm)
      theMomConstrMethod(momConstrMethod),
      theMomHBDepth(momHBDepth),
      theMomHEDepth(momHEDepth),
      theMomEBDepth(momEBDepth),
      theMomEEDepth(momEEDepth),
      theHcalPhase(hcalPhase) {}

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.

    : theEBthreshold(EBthreshold),
      theEEthreshold(EEthreshold),

      theUseEtEBTresholdFlag(useEtEBTreshold),
      theUseEtEETresholdFlag(useEtEETreshold),
      theUseSymEBTresholdFlag(useSymEBTreshold),
      theUseSymEETresholdFlag(useSymEETreshold),

      theHcalThreshold(HcalThreshold),
      theHBthreshold(HBthreshold),
      theHBthreshold1(HBthreshold1),
      theHBthreshold2(HBthreshold2),
      theHESthreshold(HESthreshold),
      theHESthreshold1(HESthreshold1),
      theHEDthreshold(HEDthreshold),
      theHEDthreshold1(HEDthreshold1),
      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),
      theEBEScale(50.),
      theEEEScale(50.),
      theHBEScale(50.),
      theHESEScale(50.),
      theHEDEScale(50.),
      theHOEScale(50.),
      theHF1EScale(50.),
      theHF2EScale(50.),
      theHcalTopology(nullptr),
      theGeometry(nullptr),
      theTowerConstituentsMap(nullptr),
      theHcalAcceptSeverityLevel(0),
      theRecoveredHcalHitsAreUsed(false),
      theRecoveredEcalHitsAreUsed(false),
      useRejectedHitsOnly(false),
      theHcalAcceptSeverityLevelForRejectedHit(0),
      useRejectedRecoveredHcalHits(0),
      useRejectedRecoveredEcalHits(0),
      missingHcalRescaleFactorForEcal(0.),
      theHOIsUsed(useHO),
      // (momentum reconstruction algorithm)
      theMomConstrMethod(momConstrMethod),
      theMomHBDepth(momHBDepth),
      theMomHEDepth(momHEDepth),
      theMomEBDepth(momEBDepth),
      theMomEEDepth(momEEDepth),
      theHcalPhase(hcalPhase) {
  // static int N = 0;
  // std::cout << "VI Algo " << ++N << std::endl;
  // nalgo=N;
}

Member Function Documentation

assignHitEcal()

void CaloTowersCreationAlgo::assignHitEcal ( const EcalRecHit *  recHit )

private

adds a single hit to the tower

Definition at line 776 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().

                                                                   {
  DetId detId = recHit->detid();

  unsigned int chStatusForCT;
  bool ecalIsBad = false;
  std::tie(chStatusForCT, ecalIsBad) = 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


  // 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);
  }

  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
  if (towerDetId.null())
    return;
  MetaTower& tower = find(towerDetId);

  // count bad cells and avoid double counting with those from DB (Recovered are counted bad)

  // somehow misses some
  // if ( (chStatusForCT == CaloTowersCreationAlgo::BadChan) & (!ecalIsBad) ) ++tower.numBadEcalCells;

  // a bit slower...
  if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
    auto thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel(detId);
    // check if the Ecal severity is ok to keep
    auto sevit = std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), thisEcalSevLvl);
    if (sevit == theEcalSeveritiesToBeExcluded.end())
      ++tower.numBadEcalCells;  // notinDB
  }

  //      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, float> mc(detId, e);
    tower.metaConstituents.push_back(mc);
  }
}  // end of assignHitEcal method

assignHitHcal()

void CaloTowersCreationAlgo::assignHitHcal ( const CaloRecHit *  recHit )

private

Definition at line 538 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().

                                                                   {
  DetId detId = recHit->detid();
  DetId detIdF(detId);
  if (detId.det() == DetId::Hcal && theHcalTopology->getMergePositionFlag()) {
    detIdF = theHcalTopology->idFront(HcalDetId(detId));
#ifdef EDM_ML_DEBUG
    std::cout << "AssignHitHcal DetId " << HcalDetId(detId) << " Front " << HcalDetId(detIdF) << std::endl;
#endif
  }

  unsigned int chStatusForCT = hcalChanStatusForCaloTower(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 merged depths --> half into tower 28 and half into tower 29
  bool merge(false);
  if (detIdF.det() == DetId::Hcal && HcalDetId(detIdF).subdet() == HcalEndcap &&
      (theHcalPhase == 0 || theHcalPhase == 1) &&
      //HcalDetId(detId).depth()==3 &&
      HcalDetId(detIdF).ietaAbs() == theHcalTopology->lastHERing() - 1) {
    merge = theHcalTopology->mergedDepth29(HcalDetId(detIdF));
#ifdef EDM_ML_DEBUG
    std::cout << "Merge " << HcalDetId(detIdF) << ":" << merge << std::endl;
#endif
  }
  if (merge) {

    // bad channels are counted regardless of energy threshold

    if (chStatusForCT == CaloTowersCreationAlgo::BadChan) {
      CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
      if (towerDetId.null())
        return;
      MetaTower& tower28 = find(towerDetId);
      CaloTowerDetId towerDetId29(towerDetId.ieta() + towerDetId.zside(), towerDetId.iphi());
      MetaTower& tower29 = find(towerDetId29);
      tower28.numBadHcalCells += 1;
      tower29.numBadHcalCells += 1;
    }

    else if (0.5 * energy >= threshold) {  // not bad channel: use energy if above threshold

      CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
      if (towerDetId.null())
        return;
      MetaTower& tower28 = find(towerDetId);
      CaloTowerDetId towerDetId29(towerDetId.ieta() + towerDetId.zside(), towerDetId.iphi());
      MetaTower& tower29 = find(towerDetId29);

      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, float> 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 {
    HcalDetId hcalDetId(detId);


    if (hcalDetId.subdet() == HcalOuter) {
      CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
      if (towerDetId.null())
        return;
      MetaTower& tower = find(towerDetId);

      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, float> 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) {
        CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
        if (towerDetId.null())
          return;
        MetaTower& tower = find(towerDetId);
        tower.numBadHcalCells += 1;
      }

      else if (energy >= threshold) {
        CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
        if (towerDetId.null())
          return;
        MetaTower& tower = find(towerDetId);

        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, float> 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) {
        CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
        if (towerDetId.null())
          return;
        MetaTower& tower = find(towerDetId);
        tower.numBadHcalCells += 1;
      } else if (energy >= threshold) {
        CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(detId);
        if (towerDetId.null())
          return;
        MetaTower& tower = find(towerDetId);
        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)
        HcalDetId hcalDetId(detId);
        if (hcalDetId.subdet() == HcalEndcap) {
          if (theHcalPhase == 0) {
            if ((hcalDetId.depth() == 2 && hcalDetId.ietaAbs() >= 18 && hcalDetId.ietaAbs() < 27) ||
                (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 27) ||
                (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 16)) {
              tower.E_outer += e;
            }
          }
          //combine depths in phase0-like way
          else if (theHcalPhase == 1) {
            if ((hcalDetId.depth() >= 3 && hcalDetId.ietaAbs() >= 18 && hcalDetId.ietaAbs() < 26) ||
                (hcalDetId.depth() >= 4 && (hcalDetId.ietaAbs() == 26 || hcalDetId.ietaAbs() == 27)) ||
                (hcalDetId.depth() == 3 && hcalDetId.ietaAbs() == 17) ||
                (hcalDetId.depth() == 4 && hcalDetId.ietaAbs() == 16)) {
              tower.E_outer += e;
            }
          }
        }

        std::pair<DetId, float> 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 assignHitHcal method

begin()

void CaloTowersCreationAlgo::begin

(

void

)

Definition at line 372 of file CaloTowersCreationAlgo.cc.

References theTowerMap, and theTowerMapSize.

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

                                   {
  theTowerMap.clear();
  theTowerMapSize = 0;
  //hcalDropChMap.clear();
}

compactTime()

int CaloTowersCreationAlgo::compactTime ( float  time )

private

Definition at line 1651 of file CaloTowersCreationAlgo.cc.

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

Referenced by convert().

                                                  {
  const float timeUnit = 0.01;  // discretization (ns)

  if (time > 300.0)
    return 30000;
  if (time < -300.0)
    return -30000;

  return int(time / timeUnit + 0.5);
}

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 928 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(), 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().

                                                                                                                   {
  assert(id.rawId() != 0);

  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;

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

  std::vector<std::pair<DetId, float> > metaContains = mt.metaConstituents;
  if (id.ietaAbs() < theTowerTopology->firstHFRing() && E_em < ecalThres) {  // ignore EM threshold in HF
    E -= E_em;
    E_em = 0;
    std::vector<std::pair<DetId, float> > metaContains_noecal;

    for (std::vector<std::pair<DetId, float> >::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() < theTowerTopology->firstHFRing() && E_had < theHcalThreshold) {
    E -= E_had;

    if (theHOIsUsed && id.ietaAbs() <= theTowerTopology->lastHORing())
      E -= E_outer;  // not subtracted before, think it should be done

    E_had = 0;
    E_outer = 0;
    std::vector<std::pair<DetId, float> > metaContains_nohcal;

    for (std::vector<std::pair<DetId, float> >::iterator i = metaContains.begin(); i != metaContains.end(); ++i)
      if (i->first.det() != DetId::Hcal)
        metaContains_nohcal.push_back(*i);
    metaContains.swap(metaContains_nohcal);
  }

  if (metaContains.empty())
    return;

  if (missingHcalRescaleFactorForEcal > 0 && E_had == 0 && E_em > 0) {
    auto match = hcalDropChMap.find(id);
    if (match != hcalDropChMap.end() && match->second.second) {
      E_had = missingHcalRescaleFactorForEcal * E_em;
      E += E_had;
    }
  }

  double E_had_tot = (theHOIsUsed && id.ietaAbs() <= theTowerTopology->lastHORing()) ? E_had + E_outer : E_had;

  // create CaloTower using the selected algorithm

  GlobalPoint emPoint, hadPoint;

  // this is actually a 4D vector
  Basic3DVectorF towerP4;
  bool massless = true;
  // float mass1=0;
  float mass2 = 0;

  // conditional assignment of depths for barrel/endcap
  // Some additional tuning may be required in the transitional region
  // 14<|iEta|<19
  double momEmDepth = 0.;
  double momHadDepth = 0.;
  if (id.ietaAbs() <= 17) {
    momHadDepth = theMomHBDepth;
    momEmDepth = theMomEBDepth;
  } else {
    momHadDepth = theMomHEDepth;
    momEmDepth = theMomEEDepth;
  }

  switch (theMomConstrMethod) {
      // FIXME  : move to simple cartesian algebra
    case 0: {  // Simple 4-momentum assignment
      GlobalPoint p = theTowerGeometry->getGeometry(id)->getPosition();
      towerP4 = p.basicVector().unit();
      towerP4[3] = 1.f;  // energy
      towerP4 *= E;

      // 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() < theTowerTopology->firstHFRing()) {
        Basic3DVectorF emP4;
        if (E_em > 0) {
          emPoint = emShwrPos(metaContains, momEmDepth, E_em);
          emP4 = emPoint.basicVector().unit();
          emP4[3] = 1.f;  // energy
          towerP4 = emP4 * 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) {
          massless = (E_em <= 0);
          hadPoint = hadShwrPos(id, momHadDepth);
          auto lP4 = hadPoint.basicVector().unit();
          lP4[3] = 1.f;  // energy
          if (!massless) {
            auto diff = lP4 - emP4;
            mass2 = std::sqrt(E_em * E_had_tot * diff.mag2());
          }
          lP4 *= E_had_tot;
          towerP4 += lP4;
          /*
            if (!massless) {
               auto p = towerP4;
               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;
            }       
            */
          // 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();
        towerP4 = p.basicVector().unit();
        towerP4[3] = 1.f;  // energy
        towerP4 *= E;
        // 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() < theTowerTopology->firstHFRing()) {
        if (E_em > 0)
          emPoint = emShwrLogWeightPos(metaContains, momEmDepth, E_em);
        else
          emPoint = theTowerGeometry->getGeometry(id)->getPosition();
        towerP4 = emPoint.basicVector().unit();
        towerP4[3] = 1.f;  // energy
        towerP4 *= E;

        // double sumPf = 1.0/cosh(emPoint.eta());

        hadPoint = emPoint;
      } else {  // forward detector: use the CaloTower position
        GlobalPoint p = theTowerGeometry->getGeometry(id)->getPosition();
        towerP4 = p.basicVector().unit();
        towerP4[3] = 1.f;  // energy
        towerP4 *= E;

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

  // insert in collection (remove and return if below threshold)
  if UNLIKELY ((towerP4[3] == 0) & (E_outer > 0)) {
    float val = theHOIsUsed ? 0 : 1E-9;  // to keep backwards compatibility for theHOIsUsed == true
    collection.emplace_back(id,
                            E_em,
                            E_had,
                            E_outer,
                            -1,
                            -1,
                            CaloTower::PolarLorentzVector(val, hadPoint.eta(), hadPoint.phi(), 0),
                            emPoint,
                            hadPoint);
  } else {
    collection.emplace_back(
        id, E_em, E_had, E_outer, -1, -1, GlobalVector(towerP4), towerP4[3], mass2, emPoint, hadPoint);
  }
  auto& caloTower = collection.back();

  // if (!massless) std::cout << "massive " << id <<' ' << mass1 <<' ' << mass2 <<' ' <<  caloTower.mass() << std::endl;
  // std::cout << "CaloTowerVI " <<theMomConstrMethod <<' ' << id <<' '<< E_em <<' '<< E_had <<' '<< E_outer <<' '<< GlobalVector(towerP4) <<' '<< towerP4[3] <<' '<< emPoint <<' '<< hadPoint << std::endl;
  //if (towerP4[3]==0) std::cout << "CaloTowerVIzero " << theEcutTower << ' ' << collection.back().eta() <<' '<< collection.back().phi() << std::endl;

  if (caloTower.energy() < theEcutTower) {
    collection.pop_back();
    return;
  }

  // set the timings
  float ecalTime = (mt.emSumEForTime > 0) ? mt.emSumTimeTimesE / mt.emSumEForTime : -9999;
  float hcalTime = (mt.hadSumEForTime > 0) ? mt.hadSumTimeTimesE / mt.hadSumEForTime : -9999;
  caloTower.setEcalTime(compactTime(ecalTime));
  caloTower.setHcalTime(compactTime(hcalTime));
  //add topology info
  caloTower.setHcalSubdet(theTowerTopology->lastHBRing(),
                          theTowerTopology->lastHERing(),
                          theTowerTopology->lastHFRing(),
                          theTowerTopology->lastHORing());

  // 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
  HcalDropChMap::iterator dropChItr = hcalDropChMap.find(id);
  if (dropChItr != hcalDropChMap.end())
    numBadHcalChan += dropChItr->second.first;

  // for ECAL the number of all bad channels is obtained here -----------------------

  /*
    // old hyper slow algorithm    
    // 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);
      }
 
      // check if the Ecal severity is ok to keep
      std::vector<int>::const_iterator sevit = std::find(theEcalSeveritiesToBeExcluded.begin(),
                             theEcalSeveritiesToBeExcluded.end(),
                             thisEcalSevLvl);
      if (sevit!=theEcalSeveritiesToBeExcluded.end()) {
    ++numBadEcalChan;
      }

     }
     
     // compare with fast version
 
   //  hcal: 
    int inEcals[2] = {0,0};
    for (std::vector<std::pair<DetId,float> >::iterator i=metaContains.begin(); i!=metaContains.end(); ++i) {
      DetId detId = i->first;
      if(detId.det() == DetId::Ecal){
    if( detId.subdetId()==EcalBarrel ) inEcals[0] =1;
    else if( detId.subdetId()==EcalEndcap ) inEcals[1] =1;
      }
    }

     auto  numBadEcalChanNew = ecalBadChs[theTowerTopology->denseIndex(id)]+mt.numBadEcalCells; // - mt.numRecEcalCells
     if (int(numBadEcalChanNew)!=int(numBadEcalChan)) { 
       std::cout << "VI wrong " << ((inEcals[1]==1) ? "EE" : "" ) << id << " " << numBadEcalChanNew << " " << numBadEcalChan 
         << " " << mt.numBadEcalCells << " " << mt.numRecEcalCells << std::endl;
     }
     */

  numBadEcalChan = ecalBadChs[theTowerTopology->denseIndex(id)] + mt.numBadEcalCells;  // - mt.numRecEcalCells

  //--------------------------------------------------------------------------------------

  caloTower.setCaloTowerStatus(
      numBadHcalChan, numBadEcalChan, numRecHcalChan, numRecEcalChan, numProbHcalChan, numProbEcalChan);

  double maxCellE = -999.0;  // for storing the hottest cell E in the calotower

  std::vector<DetId> contains;
  contains.reserve(metaContains.size());
  for (std::vector<std::pair<DetId, float> >::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

  caloTower.setConstituents(std::move(contains));
  caloTower.setHottestCellE(maxCellE);

  // std::cout << "CaloTowerVI " << nalgo << ' ' << caloTower.id() << ((inEcals[1]==1) ? "EE " : " " )  << caloTower.pt() << ' ' << caloTower.et() << ' ' << caloTower.mass() << ' '
  //           << caloTower.constituentsSize() <<' '<< caloTower.towerStatusWord() << std::endl;
}

ecalChanStatusForCaloTower()

std::tuple< unsigned int, bool > CaloTowersCreationAlgo::ecalChanStatusForCaloTower

(

const EcalRecHit *

hit

)

Definition at line 1821 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().

                                                                                                     {
  // 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;

  EcalRecHit const& rh = *reinterpret_cast<EcalRecHit const*>(hit);
  int severityLevel = theEcalSevLvlAlgo->severityLevel(rh);

  //  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 isBad = (severityLevel == EcalSeverityLevel::kBad);

  bool isRecovered = (severityLevel == EcalSeverityLevel::kRecovered);

  // check if the severity is compatible with our configuration
  // This applies to the "default" tower cleaning
  std::vector<int>::const_iterator sevit =
      std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), severityLevel);
  bool accepted = (sevit == theEcalSeveritiesToBeExcluded.end());

  // For use with hits that were rejected in the regular reconstruction:
  // This is for creating calotowers with lower level of cleaning by merging
  // the information from the default towers and a collection of towers created from
  // bad rechits

  if (useRejectedHitsOnly) {
    if (!isRecovered) {
      if (accepted || std::find(theEcalSeveritiesToBeUsedInBadTowers.begin(),
                                theEcalSeveritiesToBeUsedInBadTowers.end(),
                                severityLevel) == theEcalSeveritiesToBeUsedInBadTowers.end())
        return std::make_tuple(CaloTowersCreationAlgo::IgnoredChan, isBad);
      // this hit was either already accepted, or is not eligible for inclusion
    } else {
      if (theRecoveredEcalHitsAreUsed || !useRejectedRecoveredEcalHits) {
        // skip recovered hits either because they were already used or because there was an explicit instruction
        return std::make_tuple(CaloTowersCreationAlgo::IgnoredChan, isBad);
        ;
      } else if (useRejectedRecoveredEcalHits) {
        return std::make_tuple(CaloTowersCreationAlgo::RecoveredChan, isBad);
      }

    }  // recovered channels

    // clasify channels as problematic
    return std::make_tuple(CaloTowersCreationAlgo::ProblematicChan, isBad);

  }  // treatment of rejected hits

  // for normal reconstruction
  if (severityLevel == EcalSeverityLevel::kGood)
    return std::make_tuple(CaloTowersCreationAlgo::GoodChan, false);

  if (isRecovered) {
    return std::make_tuple(
        (theRecoveredEcalHitsAreUsed) ? CaloTowersCreationAlgo::RecoveredChan : CaloTowersCreationAlgo::BadChan, true);
  } else {
    return std::make_tuple(accepted ? CaloTowersCreationAlgo::ProblematicChan : CaloTowersCreationAlgo::BadChan, isBad);
  }
}

emCrystalShwrPos()

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

Definition at line 1414 of file CaloTowersCreationAlgo.cc.

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

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

                                                                                 {
  auto cellGeometry = theGeometry->getGeometry(detId);
  GlobalPoint point = cellGeometry->getPosition();  // face of the cell

  if (fracDepth <= 0)
    return point;
  if (fracDepth > 1)
    fracDepth = 1;

  const GlobalPoint& backPoint = cellGeometry->getBackPoint();
  point += fracDepth * (backPoint - point);

  return point;
}

emShwrLogWeightPos()

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

Definition at line 1614 of file CaloTowersCreationAlgo.cc.

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

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, float> >::const_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);
}

emShwrPos()

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

Definition at line 1584 of file CaloTowersCreationAlgo.cc.

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

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, float> >::const_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);
}

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 912 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().

                                                                                         {
  if (theTowerMap.empty()) {
    theTowerMap.resize(theTowerTopology->sizeForDenseIndexing());
  }

  auto& mt = theTowerMap[theTowerTopology->denseIndex(detId)];

  if (mt.empty()) {
    mt.id = detId;
    mt.metaConstituents.reserve(detId.ietaAbs() < theTowerTopology->firstHFRing() ? 12 : 2);
    ++theTowerMapSize;
  }

  return mt;
}

finish()

void CaloTowersCreationAlgo::finish

(

CaloTowerCollection &

destCollection

)

Definition at line 408 of file CaloTowersCreationAlgo.cc.

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

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

                                                               {
  // now copy this map into the final collection
  result.reserve(theTowerMapSize);
  // auto k=0U;
  //  if (!theEbHandle.isValid()) std::cout << "VI ebHandle not valid" << std::endl;
  // if (!theEeHandle.isValid()) std::cout << "VI eeHandle not valid" << std::endl;

  for (auto const& mt : theTowerMap) {
    // 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 (!mt.empty()) {
      convert(mt.id, mt, result);
    }  // ++k;}
  }

  // assert(k==theTowerMapSize);
  // std::cout << "VI TowerMap " << theTowerMapSize << " " << k << std::endl;

  theTowerMap.clear();  // save the memory
  theTowerMapSize = 0;
}

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 1247 of file CaloTowersCreationAlgo.cc.

References hcalRecHitTable_cff::depth, HcalDetId::depth(), hcalRecHitTable_cff::detId, DetId::Ecal, EcalBarrel, 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().

                                                                                                              {
  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();
    int depth = hcalDetId.depth();

    if (subdet == HcalBarrel) {
      if (hcalCuts == nullptr) {  // this means cutsFromDB is false
        threshold = (depth == 1) ? theHBthreshold1 : (depth == 2) ? theHBthreshold2 : theHBthreshold;
      } else {  // hcalCuts is not nullptr, i.e. cutsFromDB is true
        const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
        threshold = item->noiseThreshold();
      }
      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()) {
        if (hcalCuts == nullptr) {  // this means cutsFromDB is false
          threshold = (depth == 1) ? theHESthreshold1 : theHESthreshold;
        } else {  // hcalCuts is not nullptr, i.e. cutsFromDB is true
          const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
          threshold = item->noiseThreshold();
        }
        weight = theHESweight;
        if (weight <= 0.) {
          ROOT::Math::Interpolator my(theHESGrid, theHESWeights, ROOT::Math::Interpolation::kAKIMA);
          weight = my.Eval(theHESEScale);
        }
      } else {
        if (hcalCuts == nullptr) {  // this means cutsFromDB is false
          threshold = (depth == 1) ? theHEDthreshold1 : theHEDthreshold;
        } else {  // hcalCuts is not nullptr, i.e. cutsFromDB is true
          const HcalPFCut* item = hcalCuts->getValues(hcalDetId.rawId());
          threshold = item->noiseThreshold();
        }
        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 {
    edm::LogError("CaloTowersCreationAlgo") << "Bad cell: " << det << std::endl;
  }
}

hadSegmentShwrPos()

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

Definition at line 1429 of file CaloTowersCreationAlgo.cc.

References hcalRecHitTable_cff::detId, and emCrystalShwrPos().

                                                                                  {
  // same code as above
  return emCrystalShwrPos(detId, fracDepth);
}

hadShwPosFromCells()

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

Definition at line 1557 of file CaloTowersCreationAlgo.cc.

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

Referenced by hadShwrPos().

                                                                                                           {
  // uses the "front" and "back" cells
  // to determine the axis. point set by the predefined depth.

  HcalDetId hid1(frontCellId), hid2(backCellId);
  if (theHcalTopology->getMergePositionFlag()) {
    hid1 = theHcalTopology->idFront(frontCellId);
#ifdef EDM_ML_DEBUG
    std::cout << "Front " << HcalDetId(frontCellId) << " " << hid1 << "\n";
#endif
    hid2 = theHcalTopology->idBack(backCellId);
#ifdef EDM_ML_DEBUG
    std::cout << "Back  " << HcalDetId(backCellId) << " " << hid2 << "\n";
#endif
  }

  auto frontCellGeometry = theGeometry->getGeometry(DetId(hid1));
  auto backCellGeometry = theGeometry->getGeometry(DetId(hid2));

  GlobalPoint point = frontCellGeometry->getPosition();
  const GlobalPoint& backPoint = backCellGeometry->getBackPoint();

  point += fracDepth * (backPoint - point);

  return point;
}

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 1473 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().

                                                                                      {
  // 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);
#ifdef EDM_ML_DEBUG
  std::cout << "hadShwrPos " << towerId << " frac " << fracDepth << std::endl;
#endif
  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() >= theTowerTopology->firstHFRing()) {
    // forward, take the geometry for long fibers
    frontCellId = HcalDetId(HcalForward, towerId.zside() * theTowerTopology->convertCTtoHcal(abs(iEta)), iPhi, 1);
    backCellId = HcalDetId(HcalForward, towerId.zside() * theTowerTopology->convertCTtoHcal(abs(iEta)), iPhi, 1);
  } else {
    //use constituents map
    std::vector<DetId> items = theTowerConstituentsMap->constituentsOf(towerId);
    int frontDepth = 1000;
    int backDepth = -1000;
    for (unsigned i = 0; i < items.size(); i++) {
      if (items[i].det() != DetId::Hcal)
        continue;
      HcalDetId hid(items[i]);
      if (hid.subdet() == HcalOuter)
        continue;
      if (!theHcalTopology->validHcal(hid, 2))
        continue;

      if (theHcalTopology->idFront(hid).depth() < frontDepth) {
        frontCellId = hid;
        frontDepth = theHcalTopology->idFront(hid).depth();
      }
      if (theHcalTopology->idBack(hid).depth() > backDepth) {
        backCellId = hid;
        backDepth = theHcalTopology->idBack(hid).depth();
      }
    }
#ifdef EDM_ML_DEBUG
    std::cout << "Front " << frontCellId << " Back " << backCellId << " Depths " << frontDepth << ":" << backDepth
              << std::endl;
#endif
    //fix for tower 28/29 - no tower 29 at highest depths
    if (towerId.ietaAbs() == theTowerTopology->lastHERing() && (theHcalPhase == 0 || theHcalPhase == 1)) {
      CaloTowerDetId towerId28(towerId.ieta() - towerId.zside(), towerId.iphi());
      std::vector<DetId> items28 = theTowerConstituentsMap->constituentsOf(towerId28);
#ifdef EDM_ML_DEBUG
      std::cout << towerId28 << " with " << items28.size() << " constituents:";
      for (unsigned k = 0; k < items28.size(); ++k)
        if (items28[k].det() == DetId::Hcal)
          std::cout << " " << HcalDetId(items28[k]);
      std::cout << std::endl;
#endif
      for (unsigned i = 0; i < items28.size(); i++) {
        if (items28[i].det() != DetId::Hcal)
          continue;
        HcalDetId hid(items28[i]);
        if (hid.subdet() == HcalOuter)
          continue;

        if (theHcalTopology->idBack(hid).depth() > backDepth) {
          backCellId = hid;
          backDepth = theHcalTopology->idBack(hid).depth();
        }
      }
    }
#ifdef EDM_ML_DEBUG
    std::cout << "Back " << backDepth << " ID " << backCellId << std::endl;
#endif
  }
  point = hadShwPosFromCells(DetId(frontCellId), DetId(backCellId), fracDepth);

  return point;
}

hcalChanStatusForCaloTower()

unsigned int CaloTowersCreationAlgo::hcalChanStatusForCaloTower

(

const CaloRecHit *

hit

)

Definition at line 1770 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().

                                                                                     {
  HcalDetId hid(hit->detid());
  DetId id = theHcalTopology->idFront(hid);
#ifdef EDM_ML_DEBUG
  std::cout << "ChanStatusForCaloTower for " << hid << " to " << HcalDetId(id) << std::endl;
#endif
  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;
    }
  }
}

makeEcalBadChs()

void CaloTowersCreationAlgo::makeEcalBadChs

(

)

Definition at line 1727 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().

                                            {
  // std::cout << "VI making EcalBadChs ";

  // for ECAL the number of all bad channels is obtained here -----------------------

  for (auto ind = 0U; ind < theTowerTopology->sizeForDenseIndexing(); ++ind) {
    auto& numBadEcalChan = ecalBadChs[ind];
    numBadEcalChan = 0;
    auto id = theTowerTopology->detIdFromDenseIndex(ind);

    // this is utterly slow... (can be optmized if really needed)

    // 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;

      auto thisEcalSevLvl = theEcalSevLvlAlgo->severityLevel(*ac_it);

      // check if the Ecal severity is ok to keep
      std::vector<int>::const_iterator sevit =
          std::find(theEcalSeveritiesToBeExcluded.begin(), theEcalSeveritiesToBeExcluded.end(), thisEcalSevLvl);
      if (sevit != theEcalSeveritiesToBeExcluded.end()) {
        ++numBadEcalChan;
      }
    }

    // if (0!=numBadEcalChan) std::cout << id << ":" << numBadEcalChan << ", ";
  }

  /*
  int tot=0;
  for (auto ind=0U; ind<theTowerTopology->sizeForDenseIndexing(); ++ind) {
    if (ecalBadChs[ind]!=0) ++tot; 
  }
  std::cout << " | " << tot << std::endl;
  */
}

makeHcalDropChMap()

void CaloTowersCreationAlgo::makeHcalDropChMap

(

)

Definition at line 1666 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().

                                               {
  // 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.
  hcalDropChMap.clear();
  std::vector<DetId> allChanInStatusCont = theHcalChStatus->getAllChannels();

#ifdef EDM_ML_DEBUG
  std::cout << "DropChMap with " << allChanInStatusCont.size() << " channels" << std::endl;
#endif
  for (std::vector<DetId>::iterator it = allChanInStatusCont.begin(); it != allChanInStatusCont.end(); ++it) {
    const uint32_t dbStatusFlag = theHcalChStatus->getValues(*it)->getValue();
    if (theHcalSevLvlComputer->dropChannel(dbStatusFlag)) {
      DetId id = theHcalTopology->mergedDepthDetId(HcalDetId(*it));

      CaloTowerDetId twrId = theTowerConstituentsMap->towerOf(id);

      hcalDropChMap[twrId].first += 1;

      HcalDetId hid(*it);

      // special case for tower 29: if HCAL hit is in depth 3 add to twr 29 as well
      if (hid.subdet() == HcalEndcap && (theHcalPhase == 0 || theHcalPhase == 1) &&
          hid.ietaAbs() == theHcalTopology->lastHERing() - 1) {
        bool merge = theHcalTopology->mergedDepth29(hid);
        if (merge) {
          CaloTowerDetId twrId29(twrId.ieta() + twrId.zside(), twrId.iphi());
          hcalDropChMap[twrId29].first += 1;
        }
      }
    }
  }
  // now I know how many bad channels, but I also need to know if there's any good ones
  if (missingHcalRescaleFactorForEcal > 0) {
    for (auto& pair : hcalDropChMap) {
      if (pair.second.first == 0)
        continue;  // unexpected, but just in case
      int ngood = 0, nbad = 0;
      for (DetId id : theTowerConstituentsMap->constituentsOf(pair.first)) {
        if (id.det() != DetId::Hcal)
          continue;
        HcalDetId hid(id);
        if (hid.subdet() != HcalBarrel && hid.subdet() != HcalEndcap)
          continue;
        const uint32_t dbStatusFlag = theHcalChStatus->getValues(id)->getValue();
        if (dbStatusFlag == 0 || !theHcalSevLvlComputer->dropChannel(dbStatusFlag)) {
          ngood += 1;
        } else {
          nbad += 1;  // recount, since pair.second.first may include HO
        }
      }
      if (nbad > 0 && nbad >= ngood) {
        //uncomment for debug (may be useful to tune the criteria above)
        //CaloTowerDetId id(pair.first);
        //std::cout << "CaloTower at ieta = " << id.ieta() << ", iphi " << id.iphi() << ": set Hcal as not efficient (ngood =" << ngood << ", nbad = " << nbad << ")" << std::endl;
        pair.second.second = true;
      }
    }
  }
}

process() [1/5]

void CaloTowersCreationAlgo::process

(

const HBHERecHitCollection &

hbhe

)

Definition at line 378 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::hbhe.

Referenced by CaloTowersCreator::produce().

                                                                     {
  for (HBHERecHitCollection::const_iterator hbheItr = hbhe.begin(); hbheItr != hbhe.end(); ++hbheItr)
    assignHitHcal(&(*hbheItr));
}

process() [2/5]

void CaloTowersCreationAlgo::process

(

const HORecHitCollection &

ho

)

Definition at line 383 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::ho.

                                                                 {
  for (HORecHitCollection::const_iterator hoItr = ho.begin(); hoItr != ho.end(); ++hoItr)
    assignHitHcal(&(*hoItr));
}

process() [3/5]

void CaloTowersCreationAlgo::process

(

const HFRecHitCollection &

hf

)

Definition at line 388 of file CaloTowersCreationAlgo.cc.

References assignHitHcal(), and photonIsolationHIProducer_cfi::hf.

                                                                 {
  for (HFRecHitCollection::const_iterator hfItr = hf.begin(); hfItr != hf.end(); ++hfItr)
    assignHitHcal(&(*hfItr));
}

process() [4/5]

void CaloTowersCreationAlgo::process

(

const EcalRecHitCollection &

ecal

)

Definition at line 393 of file CaloTowersCreationAlgo.cc.

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

                                                                   {
  for (EcalRecHitCollection::const_iterator ecItr = ec.begin(); ecItr != ec.end(); ++ecItr)
    assignHitEcal(&(*ecItr));
}

process() [5/5]

void CaloTowersCreationAlgo::process

(

const CaloTowerCollection &

ctc

)

Definition at line 402 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));
  }
}

rescale()

void CaloTowersCreationAlgo::rescale ( const CaloTower *  ct )

private

Definition at line 868 of file CaloTowersCreationAlgo.cc.

References CaloTower::constituent(), CaloTower::constituentsSize(), HcalDetId::depth(), hcalRecHitTable_cff::detId, DetId::Ecal, CaloTower::ecalTime(), CaloTower::emEnergy(), find(), getThresholdAndWeight(), CaloTower::hadEnergy(), HcalForward, HcalOuter, CaloTower::hcalTime(), mps_fire::i, CaloTower::id(), CaloTowersParam_cfi::mc, DetId::null(), CaloTower::outerEnergy(), HcalDetId::subdet(), theTowerConstituentsMap, DiMuonV_cfg::threshold, l1tHGCalTowerProducer_cfi::tower, CaloTowerConstituentsMap::towerOf(), and mps_merge::weight.

Referenced by process().

                                                        {
  double threshold, weight;
  CaloTowerDetId towerDetId = theTowerConstituentsMap->towerOf(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, float> 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;
}

rescaleTowers()

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

Definition at line 430 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().

                                                                                                         {
  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() >= theTowerTopology->firstHFRing()) {
      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() > theTowerTopology->firstHERing())
          newE_outer *= weight;
        break;
      }

    }  // barrel/endcap region

    // now make the new tower

    double newE_hadTot =
        (theHOIsUsed && twrId.ietaAbs() <= theTowerTopology->lastHORing()) ? 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() < theTowerTopology->firstHFRing()) {
      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));
    //add topology info
    rescaledTower.setHcalSubdet(theTowerTopology->lastHBRing(),
                                theTowerTopology->lastHERing(),
                                theTowerTopology->lastHFRing(),
                                theTowerTopology->lastHORing());

    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
}

setEBEScale()

void CaloTowersCreationAlgo::setEBEScale

(

double

scale

)

Definition at line 1358 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theEBEScale.

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

                                                     {
  if (scale > 0.00001)
    *&theEBEScale = scale;
  else
    *&theEBEScale = 50.;
}

setEbHandle()

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

inline

Definition at line 245 of file CaloTowersCreationAlgo.h.

References theEbHandle.

Referenced by CaloTowersCreator::produce().

{ theEbHandle = eb; }

setEcalChStatusFromDB()

void CaloTowersCreationAlgo::setEcalChStatusFromDB ( const EcalChannelStatus *  s )

inline

Definition at line 169 of file CaloTowersCreationAlgo.h.

References alignCSCRings::s, and theEcalChStatus.

Referenced by CaloTowersCreator::produce().

{ theEcalChStatus = s; }

setEcalSeveritiesToBeExcluded()

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

inline

Definition at line 211 of file CaloTowersCreationAlgo.h.

References theEcalSeveritiesToBeExcluded.

Referenced by CaloTowersCreator::produce().

{ theEcalSeveritiesToBeExcluded = ecalSev; }

SetEcalSeveritiesToBeUsedInBadTowers()

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

inline

Definition at line 233 of file CaloTowersCreationAlgo.h.

References theEcalSeveritiesToBeUsedInBadTowers.

Referenced by CaloTowersCreator::produce().

                                                                           {
    theEcalSeveritiesToBeUsedInBadTowers = ecalSev;
  }

setEcalSevLvlAlgo()

void CaloTowersCreationAlgo::setEcalSevLvlAlgo ( const EcalSeverityLevelAlgo *  a )

inline

Definition at line 221 of file CaloTowersCreationAlgo.h.

References a, and theEcalSevLvlAlgo.

Referenced by CaloTowersCreator::produce().

{ theEcalSevLvlAlgo = a; }

setEEEScale()

void CaloTowersCreationAlgo::setEEEScale

(

double

scale

)

Definition at line 1365 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theEEEScale.

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

                                                     {
  if (scale > 0.00001)
    *&theEEEScale = scale;
  else
    *&theEEEScale = 50.;
}

setEeHandle()

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

inline

Definition at line 246 of file CaloTowersCreationAlgo.h.

References theEeHandle.

Referenced by CaloTowersCreator::produce().

{ theEeHandle = ee; }

setGeometry()

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

Definition at line 358 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().

                                                                  {
  theTowerTopology = cttopo;
  theTowerConstituentsMap = ctmap;
  theHcalTopology = htopo;
  theGeometry = geo;
  theTowerGeometry = geo->getSubdetectorGeometry(DetId::Calo, CaloTowerDetId::SubdetId);

  //initialize ecal bad channel map
  ecalBadChs.resize(theTowerTopology->sizeForDenseIndexing(), 0);
}

setHBEScale()

void CaloTowersCreationAlgo::setHBEScale

(

double

scale

)

Definition at line 1372 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHBEScale.

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

                                                     {
  if (scale > 0.00001)
    *&theHBEScale = scale;
  else
    *&theHBEScale = 50.;
}

setHcalAcceptSeverityLevel()

void CaloTowersCreationAlgo::setHcalAcceptSeverityLevel ( unsigned int  level )

inline

Definition at line 210 of file CaloTowersCreationAlgo.h.

References personalPlayback::level, and theHcalAcceptSeverityLevel.

Referenced by CaloTowersCreator::produce().

{ theHcalAcceptSeverityLevel = level; }

setHcalAcceptSeverityLevelForRejectedHit()

void CaloTowersCreationAlgo::setHcalAcceptSeverityLevelForRejectedHit ( unsigned int  level )

inline

Definition at line 229 of file CaloTowersCreationAlgo.h.

References personalPlayback::level, and theHcalAcceptSeverityLevelForRejectedHit.

Referenced by CaloTowersCreator::produce().

                                                                    {
    theHcalAcceptSeverityLevelForRejectedHit = level;
  }

setHcalChStatusFromDB()

void CaloTowersCreationAlgo::setHcalChStatusFromDB ( const HcalChannelQuality *  s )

inline

Definition at line 168 of file CaloTowersCreationAlgo.h.

References alignCSCRings::s, and theHcalChStatus.

Referenced by CaloTowersCreator::produce().

{ theHcalChStatus = s; }

setHcalSevLvlComputer()

void CaloTowersCreationAlgo::setHcalSevLvlComputer ( const HcalSeverityLevelComputer *  c )

inline

Definition at line 218 of file CaloTowersCreationAlgo.h.

References HltBtagPostValidation_cff::c, and theHcalSevLvlComputer.

Referenced by CaloTowersCreator::produce().

{ theHcalSevLvlComputer = c; };

setHEDEScale()

void CaloTowersCreationAlgo::setHEDEScale

(

double

scale

)

Definition at line 1386 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHEDEScale.

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

                                                      {
  if (scale > 0.00001)
    *&theHEDEScale = scale;
  else
    *&theHEDEScale = 50.;
}

setHESEScale()

void CaloTowersCreationAlgo::setHESEScale

(

double

scale

)

Definition at line 1379 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHESEScale.

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

                                                      {
  if (scale > 0.00001)
    *&theHESEScale = scale;
  else
    *&theHESEScale = 50.;
}

setHF1EScale()

void CaloTowersCreationAlgo::setHF1EScale

(

double

scale

)

Definition at line 1400 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHF1EScale.

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

                                                      {
  if (scale > 0.00001)
    *&theHF1EScale = scale;
  else
    *&theHF1EScale = 50.;
}

setHF2EScale()

void CaloTowersCreationAlgo::setHF2EScale

(

double

scale

)

Definition at line 1407 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHF2EScale.

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

                                                      {
  if (scale > 0.00001)
    *&theHF2EScale = scale;
  else
    *&theHF2EScale = 50.;
}

setHOEScale()

void CaloTowersCreationAlgo::setHOEScale

(

double

scale

)

Definition at line 1393 of file CaloTowersCreationAlgo.cc.

References pfClustersFromCombinedCaloHF_cfi::scale, and theHOEScale.

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

                                                     {
  if (scale > 0.00001)
    *&theHOEScale = scale;
  else
    *&theHOEScale = 50.;
}

setMissingHcalRescaleFactorForEcal()

void CaloTowersCreationAlgo::setMissingHcalRescaleFactorForEcal ( float  factor )

inline

Definition at line 239 of file CaloTowersCreationAlgo.h.

References missingHcalRescaleFactorForEcal.

Referenced by CaloTowersCreator::CaloTowersCreator().

{ missingHcalRescaleFactorForEcal = factor; };

setRecoveredEcalHitsAreUsed()

void CaloTowersCreationAlgo::setRecoveredEcalHitsAreUsed ( bool  flag )

inline

Definition at line 215 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and theRecoveredEcalHitsAreUsed.

Referenced by CaloTowersCreator::produce().

{ theRecoveredEcalHitsAreUsed = flag; };

setRecoveredHcalHitsAreUsed()

void CaloTowersCreationAlgo::setRecoveredHcalHitsAreUsed ( bool  flag )

inline

Definition at line 214 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and theRecoveredHcalHitsAreUsed.

Referenced by CaloTowersCreator::produce().

{ theRecoveredHcalHitsAreUsed = flag; };

setThresFromDB()

void CaloTowersCreationAlgo::setThresFromDB

(

const HcalPFCuts *

cuts

)

Definition at line 356 of file CaloTowersCreationAlgo.cc.

References hcalCuts.

Referenced by CaloTowersCreator::beginRun().

{ hcalCuts = cuts; }

setUseRejectedHitsOnly()

void CaloTowersCreationAlgo::setUseRejectedHitsOnly ( bool  flag )

inline

Definition at line 227 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedHitsOnly.

Referenced by CaloTowersCreator::produce().

{ useRejectedHitsOnly = flag; }

setUseRejectedRecoveredEcalHits()

void CaloTowersCreationAlgo::setUseRejectedRecoveredEcalHits ( bool  flag )

inline

Definition at line 238 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedRecoveredEcalHits.

Referenced by CaloTowersCreator::produce().

{ useRejectedRecoveredEcalHits = flag; };

setUseRejectedRecoveredHcalHits()

void CaloTowersCreationAlgo::setUseRejectedRecoveredHcalHits ( bool  flag )

inline

Definition at line 237 of file CaloTowersCreationAlgo.h.

References RemoveAddSevLevel::flag, and useRejectedRecoveredHcalHits.

Referenced by CaloTowersCreator::produce().

{ useRejectedRecoveredHcalHits = flag; };

Member Data Documentation

ecalBadChs

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

private

Definition at line 391 of file CaloTowersCreationAlgo.h.

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

hcalCuts

const HcalPFCuts* CaloTowersCreationAlgo::hcalCuts

private

Definition at line 325 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setThresFromDB().

hcalDropChMap

HcalDropChMap CaloTowersCreationAlgo::hcalDropChMap

private

Definition at line 387 of file CaloTowersCreationAlgo.h.

Referenced by convert(), and makeHcalDropChMap().

ids_

std::vector<HcalDetId> CaloTowersCreationAlgo::ids_

private

Definition at line 405 of file CaloTowersCreationAlgo.h.

missingHcalRescaleFactorForEcal

float CaloTowersCreationAlgo::missingHcalRescaleFactorForEcal

private

Definition at line 361 of file CaloTowersCreationAlgo.h.

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

nalgo

int CaloTowersCreationAlgo::nalgo = -1

Definition at line 54 of file CaloTowersCreationAlgo.h.

theEBEScale

double CaloTowersCreationAlgo::theEBEScale

private

Definition at line 317 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setEBEScale().

theEBGrid

std::vector<double> CaloTowersCreationAlgo::theEBGrid

private

Definition at line 305 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEbHandle

edm::Handle<EcalRecHitCollection> CaloTowersCreationAlgo::theEbHandle

private

Definition at line 400 of file CaloTowersCreationAlgo.h.

Referenced by setEbHandle().

theEBSumThreshold

double CaloTowersCreationAlgo::theEBSumThreshold

private

Definition at line 315 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theEBthreshold

double CaloTowersCreationAlgo::theEBthreshold

private

Definition at line 294 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEBweight

double CaloTowersCreationAlgo::theEBweight

private

Definition at line 313 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEBWeights

std::vector<double> CaloTowersCreationAlgo::theEBWeights

private

Definition at line 305 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEcalChStatus

const EcalChannelStatus* CaloTowersCreationAlgo::theEcalChStatus

private

Definition at line 333 of file CaloTowersCreationAlgo.h.

Referenced by setEcalChStatusFromDB().

theEcalSeveritiesToBeExcluded

std::vector<int> CaloTowersCreationAlgo::theEcalSeveritiesToBeExcluded

private

Definition at line 346 of file CaloTowersCreationAlgo.h.

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

theEcalSeveritiesToBeUsedInBadTowers

std::vector<int> CaloTowersCreationAlgo::theEcalSeveritiesToBeUsedInBadTowers

private

Definition at line 355 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and SetEcalSeveritiesToBeUsedInBadTowers().

theEcalSevLvlAlgo

const EcalSeverityLevelAlgo* CaloTowersCreationAlgo::theEcalSevLvlAlgo

private

Definition at line 340 of file CaloTowersCreationAlgo.h.

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

theEcutTower

double CaloTowersCreationAlgo::theEcutTower

private

Definition at line 315 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theEEEScale

double CaloTowersCreationAlgo::theEEEScale

private

Definition at line 318 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setEEEScale().

theEEGrid

std::vector<double> CaloTowersCreationAlgo::theEEGrid

private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEeHandle

edm::Handle<EcalRecHitCollection> CaloTowersCreationAlgo::theEeHandle

private

Definition at line 401 of file CaloTowersCreationAlgo.h.

Referenced by setEeHandle().

theEESumThreshold

double CaloTowersCreationAlgo::theEESumThreshold

private

Definition at line 315 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theEEthreshold

double CaloTowersCreationAlgo::theEEthreshold

private

Definition at line 294 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEEweight

double CaloTowersCreationAlgo::theEEweight

private

Definition at line 313 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theEEWeights

std::vector<double> CaloTowersCreationAlgo::theEEWeights

private

Definition at line 306 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theGeometry

const CaloGeometry* CaloTowersCreationAlgo::theGeometry

private

Definition at line 328 of file CaloTowersCreationAlgo.h.

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

theHBEScale

double CaloTowersCreationAlgo::theHBEScale

private

Definition at line 319 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHBEScale().

theHBGrid

std::vector<double> CaloTowersCreationAlgo::theHBGrid

private

Definition at line 307 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHBthreshold

double CaloTowersCreationAlgo::theHBthreshold

private

Definition at line 300 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHBthreshold1

double CaloTowersCreationAlgo::theHBthreshold1

private

Definition at line 300 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHBthreshold2

double CaloTowersCreationAlgo::theHBthreshold2

private

Definition at line 300 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHBweight

double CaloTowersCreationAlgo::theHBweight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHBWeights

std::vector<double> CaloTowersCreationAlgo::theHBWeights

private

Definition at line 307 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHcalAcceptSeverityLevel

unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevel

private

Definition at line 345 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevel().

theHcalAcceptSeverityLevelForRejectedHit

unsigned int CaloTowersCreationAlgo::theHcalAcceptSeverityLevelForRejectedHit

private

Definition at line 354 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setHcalAcceptSeverityLevelForRejectedHit().

theHcalChStatus

const HcalChannelQuality* CaloTowersCreationAlgo::theHcalChStatus

private

Definition at line 334 of file CaloTowersCreationAlgo.h.

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

theHcalPhase

int CaloTowersCreationAlgo::theHcalPhase

private

Definition at line 403 of file CaloTowersCreationAlgo.h.

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

theHcalSevLvlComputer

const HcalSeverityLevelComputer* CaloTowersCreationAlgo::theHcalSevLvlComputer

private

Definition at line 337 of file CaloTowersCreationAlgo.h.

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

theHcalThreshold

double CaloTowersCreationAlgo::theHcalThreshold

private

Definition at line 298 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theHcalTopology

const HcalTopology* CaloTowersCreationAlgo::theHcalTopology

private

Definition at line 327 of file CaloTowersCreationAlgo.h.

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

theHEDEScale

double CaloTowersCreationAlgo::theHEDEScale

private

Definition at line 321 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHEDEScale().

theHEDGrid

std::vector<double> CaloTowersCreationAlgo::theHEDGrid

private

Definition at line 309 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHEDthreshold

double CaloTowersCreationAlgo::theHEDthreshold

private

Definition at line 302 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHEDthreshold1

double CaloTowersCreationAlgo::theHEDthreshold1

private

Definition at line 302 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHEDweight

double CaloTowersCreationAlgo::theHEDweight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHEDWeights

std::vector<double> CaloTowersCreationAlgo::theHEDWeights

private

Definition at line 309 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHESEScale

double CaloTowersCreationAlgo::theHESEScale

private

Definition at line 320 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHESEScale().

theHESGrid

std::vector<double> CaloTowersCreationAlgo::theHESGrid

private

Definition at line 308 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHESthreshold

double CaloTowersCreationAlgo::theHESthreshold

private

Definition at line 301 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHESthreshold1

double CaloTowersCreationAlgo::theHESthreshold1

private

Definition at line 301 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHESweight

double CaloTowersCreationAlgo::theHESweight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHESWeights

std::vector<double> CaloTowersCreationAlgo::theHESWeights

private

Definition at line 308 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF1EScale

double CaloTowersCreationAlgo::theHF1EScale

private

Definition at line 323 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHF1EScale().

theHF1Grid

std::vector<double> CaloTowersCreationAlgo::theHF1Grid

private

Definition at line 311 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF1threshold

double CaloTowersCreationAlgo::theHF1threshold

private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF1weight

double CaloTowersCreationAlgo::theHF1weight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and rescaleTowers().

theHF1Weights

std::vector<double> CaloTowersCreationAlgo::theHF1Weights

private

Definition at line 311 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF2EScale

double CaloTowersCreationAlgo::theHF2EScale

private

Definition at line 324 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHF2EScale().

theHF2Grid

std::vector<double> CaloTowersCreationAlgo::theHF2Grid

private

Definition at line 312 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF2threshold

double CaloTowersCreationAlgo::theHF2threshold

private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHF2weight

double CaloTowersCreationAlgo::theHF2weight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and rescaleTowers().

theHF2Weights

std::vector<double> CaloTowersCreationAlgo::theHF2Weights

private

Definition at line 312 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOEScale

double CaloTowersCreationAlgo::theHOEScale

private

Definition at line 322 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight(), and setHOEScale().

theHOGrid

std::vector<double> CaloTowersCreationAlgo::theHOGrid

private

Definition at line 310 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 364 of file CaloTowersCreationAlgo.h.

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

theHOthreshold0

double CaloTowersCreationAlgo::theHOthreshold0

private

Definition at line 303 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOthresholdMinus1

double CaloTowersCreationAlgo::theHOthresholdMinus1

private

Definition at line 303 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOthresholdMinus2

double CaloTowersCreationAlgo::theHOthresholdMinus2

private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOthresholdPlus1

double CaloTowersCreationAlgo::theHOthresholdPlus1

private

Definition at line 303 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOthresholdPlus2

double CaloTowersCreationAlgo::theHOthresholdPlus2

private

Definition at line 304 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOweight

double CaloTowersCreationAlgo::theHOweight

private

Definition at line 314 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theHOWeights

std::vector<double> CaloTowersCreationAlgo::theHOWeights

private

Definition at line 310 of file CaloTowersCreationAlgo.h.

Referenced by getThresholdAndWeight().

theMomConstrMethod

int CaloTowersCreationAlgo::theMomConstrMethod

private

Definition at line 368 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theMomEBDepth

double CaloTowersCreationAlgo::theMomEBDepth

private

Definition at line 371 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theMomEEDepth

double CaloTowersCreationAlgo::theMomEEDepth

private

Definition at line 372 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theMomHBDepth

double CaloTowersCreationAlgo::theMomHBDepth

private

Definition at line 369 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theMomHEDepth

double CaloTowersCreationAlgo::theMomHEDepth

private

Definition at line 370 of file CaloTowersCreationAlgo.h.

Referenced by convert().

theRecoveredEcalHitsAreUsed

bool CaloTowersCreationAlgo::theRecoveredEcalHitsAreUsed

private

Definition at line 349 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and setRecoveredEcalHitsAreUsed().

theRecoveredHcalHitsAreUsed

bool CaloTowersCreationAlgo::theRecoveredHcalHitsAreUsed

private

Definition at line 348 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setRecoveredHcalHitsAreUsed().

theTowerConstituentsMap

const CaloTowerConstituentsMap* CaloTowersCreationAlgo::theTowerConstituentsMap

private

Definition at line 329 of file CaloTowersCreationAlgo.h.

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

theTowerGeometry

const CaloSubdetectorGeometry* CaloTowersCreationAlgo::theTowerGeometry

private

Definition at line 330 of file CaloTowersCreationAlgo.h.

Referenced by convert(), and setGeometry().

theTowerMap

MetaTowerMap CaloTowersCreationAlgo::theTowerMap

private

Definition at line 381 of file CaloTowersCreationAlgo.h.

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

theTowerMapSize

unsigned int CaloTowersCreationAlgo::theTowerMapSize = 0

private

Definition at line 382 of file CaloTowersCreationAlgo.h.

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

theTowerTopology

const CaloTowerTopology* CaloTowersCreationAlgo::theTowerTopology

private

Definition at line 326 of file CaloTowersCreationAlgo.h.

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

theUseEtEBTresholdFlag

bool CaloTowersCreationAlgo::theUseEtEBTresholdFlag

private

Definition at line 295 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

theUseEtEETresholdFlag

bool CaloTowersCreationAlgo::theUseEtEETresholdFlag

private

Definition at line 295 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

theUseSymEBTresholdFlag

bool CaloTowersCreationAlgo::theUseSymEBTresholdFlag

private

Definition at line 296 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

theUseSymEETresholdFlag

bool CaloTowersCreationAlgo::theUseSymEETresholdFlag

private

Definition at line 296 of file CaloTowersCreationAlgo.h.

Referenced by assignHitEcal().

useRejectedHitsOnly

bool CaloTowersCreationAlgo::useRejectedHitsOnly

private

Definition at line 353 of file CaloTowersCreationAlgo.h.

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

useRejectedRecoveredEcalHits

unsigned int CaloTowersCreationAlgo::useRejectedRecoveredEcalHits

private

Definition at line 358 of file CaloTowersCreationAlgo.h.

Referenced by ecalChanStatusForCaloTower(), and setUseRejectedRecoveredEcalHits().

useRejectedRecoveredHcalHits

unsigned int CaloTowersCreationAlgo::useRejectedRecoveredHcalHits

private

Definition at line 357 of file CaloTowersCreationAlgo.h.

Referenced by hcalChanStatusForCaloTower(), and setUseRejectedRecoveredHcalHits().