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

#include <ElectronEnergyRegressionEvaluate.h>

Public Types

enum  ElectronEnergyRegressionType {
  kNoTrkVar, kNoTrkVarV1, kWithTrkVar, kWithTrkVarV1,
  kWithTrkVarV2, kWithSubCluVar
}
 

Public Member Functions

double calculateRegressionEnergy (const reco::GsfElectron *ele, SuperClusterHelper &mySCHelper, double rho, double nvertices, bool printDebug=false)
 
double calculateRegressionEnergyUncertainty (const reco::GsfElectron *ele, SuperClusterHelper &mySCHelper, double rho, double nvertices, bool printDebug=false)
 
 ElectronEnergyRegressionEvaluate ()
 
void initialize (std::string weightsFile, ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type)
 
bool isInitialized () const
 
double regressionUncertaintyNoTrkVar (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
 
double regressionUncertaintyNoTrkVarV1 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, bool printDebug=false)
 
double regressionUncertaintyWithSubClusters (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
 
double regressionUncertaintyWithTrkVar (double electronP, double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double pt, double GsfTrackPIn, double fbrem, double Charge, double EoP, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
 
double regressionUncertaintyWithTrkVarV1 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, bool printDebug=false)
 
double regressionUncertaintyWithTrkVarV1 (std::vector< double > &inputvars, bool printDebug=false)
 
double regressionUncertaintyWithTrkVarV2 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, double detaIn, double dphiIn, double detaCalo, double dphiCalo, double GsfTrackChiSqr, double KFTrackNLayers, double ElectronEnergyOverPout, bool printDebug=false)
 
double regressionUncertaintyWithTrkVarV2 (std::vector< double > &inputvars, bool printDebug=false)
 
double regressionValueNoTrkVar (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
 
double regressionValueNoTrkVarV1 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, bool printDebug=false)
 
double regressionValueWithSubClusters (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
 
double regressionValueWithTrkVar (double electronP, double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double pt, double GsfTrackPIn, double fbrem, double Charge, double EoP, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
 
double regressionValueWithTrkVarV1 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, bool printDebug=false)
 
double regressionValueWithTrkVarV1 (std::vector< double > &inputvars, bool printDebug=false)
 
double regressionValueWithTrkVarV2 (double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, double detaIn, double dphiIn, double detaCalo, double dphiCalo, double GsfTrackChiSqr, double KFTrackNLayers, double ElectronEnergyOverPout, bool printDebug=false)
 
double regressionValueWithTrkVarV2 (std::vector< double > &inputvars, bool printDebug=false)
 
 ~ElectronEnergyRegressionEvaluate ()
 

Private Attributes

bool fIsInitialized
 
GBRForest * forestCorrection_eb
 
GBRForest * forestCorrection_ee
 
GBRForest * forestUncertainty_eb
 
GBRForest * forestUncertainty_ee
 
ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType fVersionType
 

Detailed Description

--> NOTE if you want to use this class as standalone without the CMSSW part you need to uncomment the below line and compile normally with scramv1 b Then you need just to load it in your root macro the lib with the correct path, eg: gSystem->Load("/data/benedet/CMSSW_5_2_2/lib/slc5_amd64_gcc462/pluginEGammaEGammaAnalysisTools.so");

Definition at line 31 of file ElectronEnergyRegressionEvaluate.h.

Member Enumeration Documentation

◆ ElectronEnergyRegressionType

enum ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType
Enumerator
kNoTrkVar 
kNoTrkVarV1 
kWithTrkVar 
kWithTrkVarV1 
kWithTrkVarV2 
kWithSubCluVar 

Definition at line 36 of file ElectronEnergyRegressionEvaluate.h.

36  {
37  kNoTrkVar,
38  kNoTrkVarV1,
39  kWithTrkVar,
40  kWithTrkVarV1,
41  kWithTrkVarV2,
42  kWithSubCluVar
43  };

Constructor & Destructor Documentation

◆ ElectronEnergyRegressionEvaluate()

ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionEvaluate ( )

Definition at line 14 of file ElectronEnergyRegressionEvaluate.cc.

15  : fIsInitialized(kFALSE),
16  fVersionType(kNoTrkVar),
17  forestCorrection_eb(nullptr),
18  forestCorrection_ee(nullptr),
19  forestUncertainty_eb(nullptr),
20  forestUncertainty_ee(nullptr) {}

◆ ~ElectronEnergyRegressionEvaluate()

ElectronEnergyRegressionEvaluate::~ElectronEnergyRegressionEvaluate ( )

Definition at line 22 of file ElectronEnergyRegressionEvaluate.cc.

22 {}

Member Function Documentation

◆ calculateRegressionEnergy()

double ElectronEnergyRegressionEvaluate::calculateRegressionEnergy ( const reco::GsfElectron *  ele,
SuperClusterHelper &  mySCHelper,
double  rho,
double  nvertices,
bool  printDebug = false 
)

Definition at line 47 of file ElectronEnergyRegressionEvaluate.cc.

48  {
49  if (!fIsInitialized) {
50  std::cout << "Error: Electron Energy Regression has not been initialized yet. return 0. \n";
51  return 0;
52  }
53 
54  if (printDebug) {
55  std::cout << "Regression Type: " << fVersionType << std::endl;
56  std::cout << "Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
57  }
58 
59  if (fVersionType == kNoTrkVar) {
60  return regressionValueNoTrkVar(mySCHelper.rawEnergy(),
61  mySCHelper.eta(),
62  mySCHelper.phi(),
63  mySCHelper.r9(),
64  mySCHelper.etaWidth(),
65  mySCHelper.phiWidth(),
66  mySCHelper.clustersSize(),
67  mySCHelper.hadronicOverEm(),
68  rho,
69  nvertices,
70  mySCHelper.seedEta(),
71  mySCHelper.seedPhi(),
72  mySCHelper.seedEnergy(),
73  mySCHelper.e3x3(),
74  mySCHelper.e5x5(),
75  mySCHelper.sigmaIetaIeta(),
76  mySCHelper.spp(),
77  mySCHelper.sep(),
78  mySCHelper.eMax(),
79  mySCHelper.e2nd(),
80  mySCHelper.eTop(),
81  mySCHelper.eBottom(),
82  mySCHelper.eLeft(),
83  mySCHelper.eRight(),
84  mySCHelper.e2x5Max(),
85  mySCHelper.e2x5Top(),
86  mySCHelper.e2x5Bottom(),
87  mySCHelper.e2x5Left(),
88  mySCHelper.e2x5Right(),
89  mySCHelper.ietaSeed(),
90  mySCHelper.iphiSeed(),
91  mySCHelper.etaCrySeed(),
92  mySCHelper.phiCrySeed(),
93  mySCHelper.preshowerEnergyOverRaw(),
94  printDebug);
95  }
96  if (fVersionType == kWithSubCluVar) {
97  return regressionValueWithSubClusters(mySCHelper.rawEnergy(),
98  mySCHelper.eta(),
99  mySCHelper.phi(),
100  mySCHelper.r9(),
101  mySCHelper.etaWidth(),
102  mySCHelper.phiWidth(),
103  mySCHelper.clustersSize(),
104  mySCHelper.hadronicOverEm(),
105  rho,
106  nvertices,
107  mySCHelper.seedEta(),
108  mySCHelper.seedPhi(),
109  mySCHelper.seedEnergy(),
110  mySCHelper.e3x3(),
111  mySCHelper.e5x5(),
112  mySCHelper.sigmaIetaIeta(),
113  mySCHelper.spp(),
114  mySCHelper.sep(),
115  mySCHelper.eMax(),
116  mySCHelper.e2nd(),
117  mySCHelper.eTop(),
118  mySCHelper.eBottom(),
119  mySCHelper.eLeft(),
120  mySCHelper.eRight(),
121  mySCHelper.e2x5Max(),
122  mySCHelper.e2x5Top(),
123  mySCHelper.e2x5Bottom(),
124  mySCHelper.e2x5Left(),
125  mySCHelper.e2x5Right(),
126  mySCHelper.ietaSeed(),
127  mySCHelper.iphiSeed(),
128  mySCHelper.etaCrySeed(),
129  mySCHelper.phiCrySeed(),
130  mySCHelper.preshowerEnergyOverRaw(),
131  ele->ecalDrivenSeed(),
132  ele->isEBEtaGap(),
133  ele->isEBPhiGap(),
134  ele->isEEDeeGap(),
135  mySCHelper.eSubClusters(),
136  mySCHelper.subClusterEnergy(1),
137  mySCHelper.subClusterEta(1),
138  mySCHelper.subClusterPhi(1),
139  mySCHelper.subClusterEmax(1),
140  mySCHelper.subClusterE3x3(1),
141  mySCHelper.subClusterEnergy(2),
142  mySCHelper.subClusterEta(2),
143  mySCHelper.subClusterPhi(2),
144  mySCHelper.subClusterEmax(2),
145  mySCHelper.subClusterE3x3(2),
146  mySCHelper.subClusterEnergy(3),
147  mySCHelper.subClusterEta(3),
148  mySCHelper.subClusterPhi(3),
149  mySCHelper.subClusterEmax(3),
150  mySCHelper.subClusterE3x3(3),
151  mySCHelper.nPreshowerClusters(),
152  mySCHelper.eESClusters(),
153  mySCHelper.esClusterEnergy(0),
154  mySCHelper.esClusterEta(0),
155  mySCHelper.esClusterPhi(0),
156  mySCHelper.esClusterEnergy(1),
157  mySCHelper.esClusterEta(1),
158  mySCHelper.esClusterPhi(1),
159  mySCHelper.esClusterEnergy(2),
160  mySCHelper.esClusterEta(2),
161  mySCHelper.esClusterPhi(2),
162  ele->isEB(),
163  printDebug);
164  } else if (fVersionType == kNoTrkVarV1) {
165  return regressionValueNoTrkVarV1(mySCHelper.rawEnergy(),
166  mySCHelper.eta(),
167  mySCHelper.phi(),
168  mySCHelper.r9(),
169  mySCHelper.etaWidth(),
170  mySCHelper.phiWidth(),
171  mySCHelper.clustersSize(),
172  mySCHelper.hadronicOverEm(),
173  rho,
174  nvertices,
175  mySCHelper.seedEta(),
176  mySCHelper.seedPhi(),
177  mySCHelper.seedEnergy(),
178  mySCHelper.e3x3(),
179  mySCHelper.e5x5(),
180  mySCHelper.sigmaIetaIeta(),
181  mySCHelper.spp(),
182  mySCHelper.sep(),
183  mySCHelper.eMax(),
184  mySCHelper.e2nd(),
185  mySCHelper.eTop(),
186  mySCHelper.eBottom(),
187  mySCHelper.eLeft(),
188  mySCHelper.eRight(),
189  mySCHelper.e2x5Max(),
190  mySCHelper.e2x5Top(),
191  mySCHelper.e2x5Bottom(),
192  mySCHelper.e2x5Left(),
193  mySCHelper.e2x5Right(),
194  mySCHelper.ietaSeed(),
195  mySCHelper.iphiSeed(),
196  mySCHelper.etaCrySeed(),
197  mySCHelper.phiCrySeed(),
198  mySCHelper.preshowerEnergyOverRaw(),
199  ele->ecalDrivenSeed(),
200  printDebug);
201  } else if (fVersionType == kWithTrkVarV1) {
202  return regressionValueWithTrkVarV1(mySCHelper.rawEnergy(),
203  mySCHelper.eta(),
204  mySCHelper.phi(),
205  mySCHelper.r9(),
206  mySCHelper.etaWidth(),
207  mySCHelper.phiWidth(),
208  mySCHelper.clustersSize(),
209  mySCHelper.hadronicOverEm(),
210  rho,
211  nvertices,
212  mySCHelper.seedEta(),
213  mySCHelper.seedPhi(),
214  mySCHelper.seedEnergy(),
215  mySCHelper.e3x3(),
216  mySCHelper.e5x5(),
217  mySCHelper.sigmaIetaIeta(),
218  mySCHelper.spp(),
219  mySCHelper.sep(),
220  mySCHelper.eMax(),
221  mySCHelper.e2nd(),
222  mySCHelper.eTop(),
223  mySCHelper.eBottom(),
224  mySCHelper.eLeft(),
225  mySCHelper.eRight(),
226  mySCHelper.e2x5Max(),
227  mySCHelper.e2x5Top(),
228  mySCHelper.e2x5Bottom(),
229  mySCHelper.e2x5Left(),
230  mySCHelper.e2x5Right(),
231  mySCHelper.ietaSeed(),
232  mySCHelper.iphiSeed(),
233  mySCHelper.etaCrySeed(),
234  mySCHelper.phiCrySeed(),
235  mySCHelper.preshowerEnergyOverRaw(),
236  ele->ecalDrivenSeed(),
237  ele->trackMomentumAtVtx().R(),
238  fmax(ele->fbrem(), -1.0),
239  ele->charge(),
240  fmin(ele->eSuperClusterOverP(), 20.0),
241  ele->trackMomentumError(),
242  ele->correctedEcalEnergyError(),
243  ele->classification(),
244  printDebug);
245  } else if (fVersionType == kWithTrkVarV2) {
246  return regressionValueWithTrkVarV2(
247  mySCHelper.rawEnergy(),
248  mySCHelper.eta(),
249  mySCHelper.phi(),
250  mySCHelper.r9(),
251  mySCHelper.etaWidth(),
252  mySCHelper.phiWidth(),
253  mySCHelper.clustersSize(),
254  mySCHelper.hadronicOverEm(),
255  rho,
256  nvertices,
257  mySCHelper.seedEta(),
258  mySCHelper.seedPhi(),
259  mySCHelper.seedEnergy(),
260  mySCHelper.e3x3(),
261  mySCHelper.e5x5(),
262  mySCHelper.sigmaIetaIeta(),
263  mySCHelper.spp(),
264  mySCHelper.sep(),
265  mySCHelper.eMax(),
266  mySCHelper.e2nd(),
267  mySCHelper.eTop(),
268  mySCHelper.eBottom(),
269  mySCHelper.eLeft(),
270  mySCHelper.eRight(),
271  mySCHelper.e2x5Max(),
272  mySCHelper.e2x5Top(),
273  mySCHelper.e2x5Bottom(),
274  mySCHelper.e2x5Left(),
275  mySCHelper.e2x5Right(),
276  mySCHelper.ietaSeed(),
277  mySCHelper.iphiSeed(),
278  mySCHelper.etaCrySeed(),
279  mySCHelper.phiCrySeed(),
280  mySCHelper.preshowerEnergyOverRaw(),
281  ele->ecalDrivenSeed(),
282  ele->trackMomentumAtVtx().R(),
283  fmax(ele->fbrem(), -1.0),
284  ele->charge(),
285  fmin(ele->eSuperClusterOverP(), 20.0),
286  ele->trackMomentumError(),
287  ele->correctedEcalEnergyError(),
288  ele->classification(),
289  fmin(std::abs(ele->deltaEtaSuperClusterTrackAtVtx()), 0.6),
290  ele->deltaPhiSuperClusterTrackAtVtx(),
291  ele->deltaEtaSeedClusterTrackAtCalo(),
292  ele->deltaPhiSeedClusterTrackAtCalo(),
293  ele->gsfTrack()->chi2() / ele->gsfTrack()->ndof(),
294  (ele->closestCtfTrackRef().isNonnull() ? ele->closestCtfTrackRef()->hitPattern().trackerLayersWithMeasurement()
295  : -1),
296  fmin(ele->eEleClusterOverPout(), 20.0),
297  printDebug);
298  } else {
299  std::cout << "Warning: Electron Regression Type " << fVersionType
300  << " is not supported. Reverting to default electron momentum.\n";
301  return ele->p();
302  }
303 }

References funct::abs(), reco::LeafCandidate::charge(), reco::GsfElectron::classification(), reco::GsfElectron::closestCtfTrackRef(), SuperClusterHelper::clustersSize(), reco::GsfElectron::correctedEcalEnergyError(), gather_cfg::cout, reco::GsfElectron::deltaEtaSeedClusterTrackAtCalo(), reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSeedClusterTrackAtCalo(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), SuperClusterHelper::e2nd(), SuperClusterHelper::e2x5Bottom(), SuperClusterHelper::e2x5Left(), SuperClusterHelper::e2x5Max(), SuperClusterHelper::e2x5Right(), SuperClusterHelper::e2x5Top(), SuperClusterHelper::e3x3(), SuperClusterHelper::e5x5(), SuperClusterHelper::eBottom(), reco::GsfElectron::ecalDrivenSeed(), reco::GsfElectron::eEleClusterOverPout(), SuperClusterHelper::eESClusters(), SuperClusterHelper::eLeft(), SuperClusterHelper::eMax(), SuperClusterHelper::eRight(), SuperClusterHelper::esClusterEnergy(), SuperClusterHelper::esClusterEta(), SuperClusterHelper::esClusterPhi(), SuperClusterHelper::eSubClusters(), reco::GsfElectron::eSuperClusterOverP(), SuperClusterHelper::eta(), reco::LeafCandidate::eta(), SuperClusterHelper::etaCrySeed(), SuperClusterHelper::etaWidth(), SuperClusterHelper::eTop(), reco::GsfElectron::fbrem(), fIsInitialized, fVersionType, reco::GsfElectron::gsfTrack(), SuperClusterHelper::hadronicOverEm(), SuperClusterHelper::ietaSeed(), SuperClusterHelper::iphiSeed(), reco::GsfElectron::isEB(), reco::GsfElectron::isEBEtaGap(), reco::GsfElectron::isEBPhiGap(), reco::GsfElectron::isEEDeeGap(), edm::Ref< C, T, F >::isNonnull(), kNoTrkVar, kNoTrkVarV1, kWithSubCluVar, kWithTrkVarV1, kWithTrkVarV2, SuperClusterHelper::nPreshowerClusters(), reco::LeafCandidate::p(), SuperClusterHelper::phi(), reco::LeafCandidate::phi(), SuperClusterHelper::phiCrySeed(), SuperClusterHelper::phiWidth(), SuperClusterHelper::preshowerEnergyOverRaw(), HLT_FULL_cff::printDebug, reco::LeafCandidate::pt(), SuperClusterHelper::r9(), SuperClusterHelper::rawEnergy(), regressionValueNoTrkVar(), regressionValueNoTrkVarV1(), regressionValueWithSubClusters(), regressionValueWithTrkVarV1(), regressionValueWithTrkVarV2(), rho, SuperClusterHelper::seedEnergy(), SuperClusterHelper::seedEta(), SuperClusterHelper::seedPhi(), SuperClusterHelper::sep(), SuperClusterHelper::sigmaIetaIeta(), SuperClusterHelper::spp(), SuperClusterHelper::subClusterE3x3(), SuperClusterHelper::subClusterEmax(), SuperClusterHelper::subClusterEnergy(), SuperClusterHelper::subClusterEta(), SuperClusterHelper::subClusterPhi(), reco::GsfElectron::trackMomentumAtVtx(), and reco::GsfElectron::trackMomentumError().

Referenced by ElectronRegressionEnergyProducer::filter().

◆ calculateRegressionEnergyUncertainty()

double ElectronEnergyRegressionEvaluate::calculateRegressionEnergyUncertainty ( const reco::GsfElectron *  ele,
SuperClusterHelper &  mySCHelper,
double  rho,
double  nvertices,
bool  printDebug = false 
)

Definition at line 305 of file ElectronEnergyRegressionEvaluate.cc.

306  {
307  if (!fIsInitialized) {
308  std::cout << "Error: Electron Energy Regression has not been initialized yet. return 0. \n";
309  return 0;
310  }
311 
312  if (printDebug) {
313  std::cout << "Regression Type: " << fVersionType << std::endl;
314  std::cout << "Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
315  }
316 
317  if (fVersionType == kNoTrkVar) {
318  return regressionUncertaintyNoTrkVar(mySCHelper.rawEnergy(),
319  mySCHelper.eta(),
320  mySCHelper.phi(),
321  mySCHelper.r9(),
322  mySCHelper.etaWidth(),
323  mySCHelper.phiWidth(),
324  mySCHelper.clustersSize(),
325  mySCHelper.hadronicOverEm(),
326  rho,
327  nvertices,
328  mySCHelper.seedEta(),
329  mySCHelper.seedPhi(),
330  mySCHelper.seedEnergy(),
331  mySCHelper.e3x3(),
332  mySCHelper.e5x5(),
333  mySCHelper.sigmaIetaIeta(),
334  mySCHelper.spp(),
335  mySCHelper.sep(),
336  mySCHelper.eMax(),
337  mySCHelper.e2nd(),
338  mySCHelper.eTop(),
339  mySCHelper.eBottom(),
340  mySCHelper.eLeft(),
341  mySCHelper.eRight(),
342  mySCHelper.e2x5Max(),
343  mySCHelper.e2x5Top(),
344  mySCHelper.e2x5Bottom(),
345  mySCHelper.e2x5Left(),
346  mySCHelper.e2x5Right(),
347  mySCHelper.ietaSeed(),
348  mySCHelper.iphiSeed(),
349  mySCHelper.etaCrySeed(),
350  mySCHelper.phiCrySeed(),
351  mySCHelper.preshowerEnergyOverRaw(),
352  printDebug);
353  }
354  if (fVersionType == kWithSubCluVar) {
355  return regressionUncertaintyWithSubClusters(mySCHelper.rawEnergy(),
356  mySCHelper.eta(),
357  mySCHelper.phi(),
358  mySCHelper.r9(),
359  mySCHelper.etaWidth(),
360  mySCHelper.phiWidth(),
361  mySCHelper.clustersSize(),
362  mySCHelper.hadronicOverEm(),
363  rho,
364  nvertices,
365  mySCHelper.seedEta(),
366  mySCHelper.seedPhi(),
367  mySCHelper.seedEnergy(),
368  mySCHelper.e3x3(),
369  mySCHelper.e5x5(),
370  mySCHelper.sigmaIetaIeta(),
371  mySCHelper.spp(),
372  mySCHelper.sep(),
373  mySCHelper.eMax(),
374  mySCHelper.e2nd(),
375  mySCHelper.eTop(),
376  mySCHelper.eBottom(),
377  mySCHelper.eLeft(),
378  mySCHelper.eRight(),
379  mySCHelper.e2x5Max(),
380  mySCHelper.e2x5Top(),
381  mySCHelper.e2x5Bottom(),
382  mySCHelper.e2x5Left(),
383  mySCHelper.e2x5Right(),
384  mySCHelper.ietaSeed(),
385  mySCHelper.iphiSeed(),
386  mySCHelper.etaCrySeed(),
387  mySCHelper.phiCrySeed(),
388  mySCHelper.preshowerEnergyOverRaw(),
389  ele->ecalDrivenSeed(),
390  ele->isEBEtaGap(),
391  ele->isEBPhiGap(),
392  ele->isEEDeeGap(),
393  mySCHelper.eSubClusters(),
394  mySCHelper.subClusterEnergy(1),
395  mySCHelper.subClusterEta(1),
396  mySCHelper.subClusterPhi(1),
397  mySCHelper.subClusterEmax(1),
398  mySCHelper.subClusterE3x3(1),
399  mySCHelper.subClusterEnergy(2),
400  mySCHelper.subClusterEta(2),
401  mySCHelper.subClusterPhi(2),
402  mySCHelper.subClusterEmax(2),
403  mySCHelper.subClusterE3x3(2),
404  mySCHelper.subClusterEnergy(3),
405  mySCHelper.subClusterEta(3),
406  mySCHelper.subClusterPhi(3),
407  mySCHelper.subClusterEmax(3),
408  mySCHelper.subClusterE3x3(3),
409  mySCHelper.nPreshowerClusters(),
410  mySCHelper.eESClusters(),
411  mySCHelper.esClusterEnergy(0),
412  mySCHelper.esClusterEta(0),
413  mySCHelper.esClusterPhi(0),
414  mySCHelper.esClusterEnergy(1),
415  mySCHelper.esClusterEta(1),
416  mySCHelper.esClusterPhi(1),
417  mySCHelper.esClusterEnergy(2),
418  mySCHelper.esClusterEta(2),
419  mySCHelper.esClusterPhi(2),
420  ele->isEB(),
421  printDebug);
422  } else if (fVersionType == kNoTrkVarV1) {
423  return regressionUncertaintyNoTrkVarV1(mySCHelper.rawEnergy(),
424  mySCHelper.eta(),
425  mySCHelper.phi(),
426  mySCHelper.r9(),
427  mySCHelper.etaWidth(),
428  mySCHelper.phiWidth(),
429  mySCHelper.clustersSize(),
430  mySCHelper.hadronicOverEm(),
431  rho,
432  nvertices,
433  mySCHelper.seedEta(),
434  mySCHelper.seedPhi(),
435  mySCHelper.seedEnergy(),
436  mySCHelper.e3x3(),
437  mySCHelper.e5x5(),
438  mySCHelper.sigmaIetaIeta(),
439  mySCHelper.spp(),
440  mySCHelper.sep(),
441  mySCHelper.eMax(),
442  mySCHelper.e2nd(),
443  mySCHelper.eTop(),
444  mySCHelper.eBottom(),
445  mySCHelper.eLeft(),
446  mySCHelper.eRight(),
447  mySCHelper.e2x5Max(),
448  mySCHelper.e2x5Top(),
449  mySCHelper.e2x5Bottom(),
450  mySCHelper.e2x5Left(),
451  mySCHelper.e2x5Right(),
452  mySCHelper.ietaSeed(),
453  mySCHelper.iphiSeed(),
454  mySCHelper.etaCrySeed(),
455  mySCHelper.phiCrySeed(),
456  mySCHelper.preshowerEnergyOverRaw(),
457  ele->ecalDrivenSeed(),
458  printDebug);
459  } else if (fVersionType == kWithTrkVarV1) {
460  return regressionUncertaintyWithTrkVarV1(mySCHelper.rawEnergy(),
461  mySCHelper.eta(),
462  mySCHelper.phi(),
463  mySCHelper.r9(),
464  mySCHelper.etaWidth(),
465  mySCHelper.phiWidth(),
466  mySCHelper.clustersSize(),
467  mySCHelper.hadronicOverEm(),
468  rho,
469  nvertices,
470  mySCHelper.seedEta(),
471  mySCHelper.seedPhi(),
472  mySCHelper.seedEnergy(),
473  mySCHelper.e3x3(),
474  mySCHelper.e5x5(),
475  mySCHelper.sigmaIetaIeta(),
476  mySCHelper.spp(),
477  mySCHelper.sep(),
478  mySCHelper.eMax(),
479  mySCHelper.e2nd(),
480  mySCHelper.eTop(),
481  mySCHelper.eBottom(),
482  mySCHelper.eLeft(),
483  mySCHelper.eRight(),
484  mySCHelper.e2x5Max(),
485  mySCHelper.e2x5Top(),
486  mySCHelper.e2x5Bottom(),
487  mySCHelper.e2x5Left(),
488  mySCHelper.e2x5Right(),
489  mySCHelper.ietaSeed(),
490  mySCHelper.iphiSeed(),
491  mySCHelper.etaCrySeed(),
492  mySCHelper.phiCrySeed(),
493  mySCHelper.preshowerEnergyOverRaw(),
494  ele->ecalDrivenSeed(),
495  ele->trackMomentumAtVtx().R(),
496  fmax(ele->fbrem(), -1.0),
497  ele->charge(),
498  fmin(ele->eSuperClusterOverP(), 20.0),
499  ele->trackMomentumError(),
500  ele->correctedEcalEnergyError(),
501  ele->classification(),
502  printDebug);
503  } else if (fVersionType == kWithTrkVarV2) {
504  return regressionUncertaintyWithTrkVarV2(
505  mySCHelper.rawEnergy(),
506  mySCHelper.eta(),
507  mySCHelper.phi(),
508  mySCHelper.r9(),
509  mySCHelper.etaWidth(),
510  mySCHelper.phiWidth(),
511  mySCHelper.clustersSize(),
512  mySCHelper.hadronicOverEm(),
513  rho,
514  nvertices,
515  mySCHelper.seedEta(),
516  mySCHelper.seedPhi(),
517  mySCHelper.seedEnergy(),
518  mySCHelper.e3x3(),
519  mySCHelper.e5x5(),
520  mySCHelper.sigmaIetaIeta(),
521  mySCHelper.spp(),
522  mySCHelper.sep(),
523  mySCHelper.eMax(),
524  mySCHelper.e2nd(),
525  mySCHelper.eTop(),
526  mySCHelper.eBottom(),
527  mySCHelper.eLeft(),
528  mySCHelper.eRight(),
529  mySCHelper.e2x5Max(),
530  mySCHelper.e2x5Top(),
531  mySCHelper.e2x5Bottom(),
532  mySCHelper.e2x5Left(),
533  mySCHelper.e2x5Right(),
534  mySCHelper.ietaSeed(),
535  mySCHelper.iphiSeed(),
536  mySCHelper.etaCrySeed(),
537  mySCHelper.phiCrySeed(),
538  mySCHelper.preshowerEnergyOverRaw(),
539  ele->ecalDrivenSeed(),
540  ele->trackMomentumAtVtx().R(),
541  fmax(ele->fbrem(), -1.0),
542  ele->charge(),
543  fmin(ele->eSuperClusterOverP(), 20.0),
544  ele->trackMomentumError(),
545  ele->correctedEcalEnergyError(),
546  ele->classification(),
547  fmin(std::abs(ele->deltaEtaSuperClusterTrackAtVtx()), 0.6),
548  ele->deltaPhiSuperClusterTrackAtVtx(),
549  ele->deltaEtaSeedClusterTrackAtCalo(),
550  ele->deltaPhiSeedClusterTrackAtCalo(),
551  ele->gsfTrack()->chi2() / ele->gsfTrack()->ndof(),
552  (ele->closestCtfTrackRef().isNonnull() ? ele->closestCtfTrackRef()->hitPattern().trackerLayersWithMeasurement()
553  : -1),
554  fmin(ele->eEleClusterOverPout(), 20.0),
555  printDebug);
556  } else {
557  std::cout << "Warning: Electron Regression Type " << fVersionType
558  << " is not supported. Reverting to default electron momentum.\n";
559  return ele->p();
560  }
561 }

References funct::abs(), reco::LeafCandidate::charge(), reco::GsfElectron::classification(), reco::GsfElectron::closestCtfTrackRef(), SuperClusterHelper::clustersSize(), reco::GsfElectron::correctedEcalEnergyError(), gather_cfg::cout, reco::GsfElectron::deltaEtaSeedClusterTrackAtCalo(), reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx(), reco::GsfElectron::deltaPhiSeedClusterTrackAtCalo(), reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx(), SuperClusterHelper::e2nd(), SuperClusterHelper::e2x5Bottom(), SuperClusterHelper::e2x5Left(), SuperClusterHelper::e2x5Max(), SuperClusterHelper::e2x5Right(), SuperClusterHelper::e2x5Top(), SuperClusterHelper::e3x3(), SuperClusterHelper::e5x5(), SuperClusterHelper::eBottom(), reco::GsfElectron::ecalDrivenSeed(), reco::GsfElectron::eEleClusterOverPout(), SuperClusterHelper::eESClusters(), SuperClusterHelper::eLeft(), SuperClusterHelper::eMax(), SuperClusterHelper::eRight(), SuperClusterHelper::esClusterEnergy(), SuperClusterHelper::esClusterEta(), SuperClusterHelper::esClusterPhi(), SuperClusterHelper::eSubClusters(), reco::GsfElectron::eSuperClusterOverP(), SuperClusterHelper::eta(), reco::LeafCandidate::eta(), SuperClusterHelper::etaCrySeed(), SuperClusterHelper::etaWidth(), SuperClusterHelper::eTop(), reco::GsfElectron::fbrem(), fIsInitialized, fVersionType, reco::GsfElectron::gsfTrack(), SuperClusterHelper::hadronicOverEm(), SuperClusterHelper::ietaSeed(), SuperClusterHelper::iphiSeed(), reco::GsfElectron::isEB(), reco::GsfElectron::isEBEtaGap(), reco::GsfElectron::isEBPhiGap(), reco::GsfElectron::isEEDeeGap(), edm::Ref< C, T, F >::isNonnull(), kNoTrkVar, kNoTrkVarV1, kWithSubCluVar, kWithTrkVarV1, kWithTrkVarV2, SuperClusterHelper::nPreshowerClusters(), reco::LeafCandidate::p(), SuperClusterHelper::phi(), reco::LeafCandidate::phi(), SuperClusterHelper::phiCrySeed(), SuperClusterHelper::phiWidth(), SuperClusterHelper::preshowerEnergyOverRaw(), HLT_FULL_cff::printDebug, reco::LeafCandidate::pt(), SuperClusterHelper::r9(), SuperClusterHelper::rawEnergy(), regressionUncertaintyNoTrkVar(), regressionUncertaintyNoTrkVarV1(), regressionUncertaintyWithSubClusters(), regressionUncertaintyWithTrkVarV1(), regressionUncertaintyWithTrkVarV2(), rho, SuperClusterHelper::seedEnergy(), SuperClusterHelper::seedEta(), SuperClusterHelper::seedPhi(), SuperClusterHelper::sep(), SuperClusterHelper::sigmaIetaIeta(), SuperClusterHelper::spp(), SuperClusterHelper::subClusterE3x3(), SuperClusterHelper::subClusterEmax(), SuperClusterHelper::subClusterEnergy(), SuperClusterHelper::subClusterEta(), SuperClusterHelper::subClusterPhi(), reco::GsfElectron::trackMomentumAtVtx(), and reco::GsfElectron::trackMomentumError().

Referenced by ElectronRegressionEnergyProducer::filter().

◆ initialize()

void ElectronEnergyRegressionEvaluate::initialize ( std::string  weightsFile,
ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType  type 
)

Definition at line 25 of file ElectronEnergyRegressionEvaluate.cc.

26  {
27  // Loading forest object according to different versions
28  TFile file(edm::FileInPath(weightsFile.c_str()).fullPath().c_str());
29 
30  forestCorrection_eb = (GBRForest *)file.Get("EBCorrection");
31  forestCorrection_ee = (GBRForest *)file.Get("EECorrection");
32  forestUncertainty_eb = (GBRForest *)file.Get("EBUncertainty");
33  forestUncertainty_ee = (GBRForest *)file.Get("EEUncertainty");
34 
35  // Just checking
36  assert(forestCorrection_eb);
37  assert(forestCorrection_ee);
38  assert(forestUncertainty_eb);
39  assert(forestUncertainty_ee);
40 
41  // Updating type and marking as initialized
42  fVersionType = type;
43  fIsInitialized = kTRUE;
44 }

References cms::cuda::assert(), FrontierConditions_GlobalTag_cff::file, fIsInitialized, forestCorrection_eb, forestCorrection_ee, forestUncertainty_eb, forestUncertainty_ee, contentValuesFiles::fullPath, fVersionType, and pfClustersFromHGC3DClusters_cfi::weightsFile.

Referenced by ElectronRegressionEnergyProducer::ElectronRegressionEnergyProducer(), and RegressionEnergyPatElectronProducer::RegressionEnergyPatElectronProducer().

◆ isInitialized()

bool ElectronEnergyRegressionEvaluate::isInitialized ( ) const
inline

Definition at line 47 of file ElectronEnergyRegressionEvaluate.h.

47 { return fIsInitialized; }

References fIsInitialized.

Referenced by ElectronRegressionEnergyProducer::filter(), and RegressionEnergyPatElectronProducer::produce().

◆ regressionUncertaintyNoTrkVar()

double ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVar ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
bool  printDebug = false 
)

Definition at line 726 of file ElectronEnergyRegressionEvaluate.cc.

760  {
761  // Checking if instance has been initialized
762  if (fIsInitialized == kFALSE) {
763  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
764  return 0;
765  }
766 
767  // Checking if type is correct
768  if (!(fVersionType == kNoTrkVar)) {
769  std::cout << "Error: Regression VersionType " << fVersionType
770  << " is not supported to use function regressionValueNoTrkVar.\n";
771  return 0;
772  }
773 
774  // Now applying regression according to version and (endcap/barrel)
775  float *vals = (std::abs(scEta) <= 1.479) ? new float[38] : new float[31];
776  if (std::abs(scEta) <= 1.479) { // Barrel
777  vals[0] = SCRawEnergy;
778  vals[1] = scEta;
779  vals[2] = scPhi;
780  vals[3] = R9;
781  vals[4] = E5x5Seed / SCRawEnergy;
782  vals[5] = etawidth;
783  vals[6] = phiwidth;
784  vals[7] = NClusters;
785  vals[8] = HoE;
786  vals[9] = rho;
787  vals[10] = vertices;
788  vals[11] = EtaSeed - scEta;
789  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
790  vals[13] = ESeed / SCRawEnergy;
791  vals[14] = E3x3Seed / ESeed;
792  vals[15] = E5x5Seed / ESeed;
793  vals[16] = see;
794  vals[17] = spp;
795  vals[18] = sep;
796  vals[19] = EMaxSeed / ESeed;
797  vals[20] = E2ndSeed / ESeed;
798  vals[21] = ETopSeed / ESeed;
799  vals[22] = EBottomSeed / ESeed;
800  vals[23] = ELeftSeed / ESeed;
801  vals[24] = ERightSeed / ESeed;
802  vals[25] = E2x5MaxSeed / ESeed;
803  vals[26] = E2x5TopSeed / ESeed;
804  vals[27] = E2x5BottomSeed / ESeed;
805  vals[28] = E2x5LeftSeed / ESeed;
806  vals[29] = E2x5RightSeed / ESeed;
807  vals[30] = IEtaSeed;
808  vals[31] = IPhiSeed;
809  vals[32] = ((int)IEtaSeed) % 5;
810  vals[33] = ((int)IPhiSeed) % 2;
811  vals[34] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
812  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
813  vals[35] = ((int)IPhiSeed) % 20;
814  vals[36] = EtaCrySeed;
815  vals[37] = PhiCrySeed;
816  } else { // Endcap
817  vals[0] = SCRawEnergy;
818  vals[1] = scEta;
819  vals[2] = scPhi;
820  vals[3] = R9;
821  vals[4] = E5x5Seed / SCRawEnergy;
822  vals[5] = etawidth;
823  vals[6] = phiwidth;
824  vals[7] = NClusters;
825  vals[8] = HoE;
826  vals[9] = rho;
827  vals[10] = vertices;
828  vals[11] = EtaSeed - scEta;
829  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
830  vals[13] = ESeed / SCRawEnergy;
831  vals[14] = E3x3Seed / ESeed;
832  vals[15] = E5x5Seed / ESeed;
833  vals[16] = see;
834  vals[17] = spp;
835  vals[18] = sep;
836  vals[19] = EMaxSeed / ESeed;
837  vals[20] = E2ndSeed / ESeed;
838  vals[21] = ETopSeed / ESeed;
839  vals[22] = EBottomSeed / ESeed;
840  vals[23] = ELeftSeed / ESeed;
841  vals[24] = ERightSeed / ESeed;
842  vals[25] = E2x5MaxSeed / ESeed;
843  vals[26] = E2x5TopSeed / ESeed;
844  vals[27] = E2x5BottomSeed / ESeed;
845  vals[28] = E2x5LeftSeed / ESeed;
846  vals[29] = E2x5RightSeed / ESeed;
847  vals[30] = PreShowerOverRaw;
848  }
849 
850  // Now evaluating the regression
851  double regressionResult = 0;
852  Int_t BinIndex = -1;
853 
854  if (fVersionType == kNoTrkVar) {
855  if (std::abs(scEta) <= 1.479) {
856  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
857  BinIndex = 0;
858  } else {
859  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
860  BinIndex = 1;
861  }
862  }
863 
864  //print debug
865  if (printDebug) {
866  if (std::abs(scEta) <= 1.479) {
867  std::cout << "Barrel :";
868  for (unsigned int v = 0; v < 38; ++v)
869  std::cout << vals[v] << ", ";
870  std::cout << "\n";
871  } else {
872  std::cout << "Endcap :";
873  for (unsigned int v = 0; v < 31; ++v)
874  std::cout << vals[v] << ", ";
875  std::cout << "\n";
876  }
877  std::cout << "BinIndex : " << BinIndex << "\n";
878  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
879  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
880  }
881 
882  // Cleaning up and returning
883  delete[] vals;
884  return regressionResult;
885 }

References funct::abs(), funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kNoTrkVar, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergyUncertainty(), and RegressionEnergyPatElectronProducer::produce().

◆ regressionUncertaintyNoTrkVarV1()

double ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVarV1 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
bool  printDebug = false 
)

Definition at line 1051 of file ElectronEnergyRegressionEvaluate.cc.

1086  {
1087  // Checking if instance has been initialized
1088  if (fIsInitialized == kFALSE) {
1089  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1090  return 0;
1091  }
1092 
1093  // Checking if type is correct
1094  if (!(fVersionType == kNoTrkVarV1)) {
1095  std::cout << "Error: Regression VersionType " << fVersionType
1096  << " is not supported to use function regressionValueNoTrkVar.\n";
1097  return 0;
1098  }
1099 
1100  // Now applying regression according to version and (endcap/barrel)
1101  float *vals = (std::abs(scEta) <= 1.479) ? new float[39] : new float[32];
1102  if (std::abs(scEta) <= 1.479) { // Barrel
1103  vals[0] = SCRawEnergy;
1104  vals[1] = scEta;
1105  vals[2] = scPhi;
1106  vals[3] = R9;
1107  vals[4] = E5x5Seed / SCRawEnergy;
1108  vals[5] = etawidth;
1109  vals[6] = phiwidth;
1110  vals[7] = NClusters;
1111  vals[8] = HoE;
1112  vals[9] = rho;
1113  vals[10] = vertices;
1114  vals[11] = EtaSeed - scEta;
1115  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1116  vals[13] = ESeed / SCRawEnergy;
1117  vals[14] = E3x3Seed / ESeed;
1118  vals[15] = E5x5Seed / ESeed;
1119  vals[16] = see;
1120  vals[17] = spp;
1121  vals[18] = sep;
1122  vals[19] = EMaxSeed / ESeed;
1123  vals[20] = E2ndSeed / ESeed;
1124  vals[21] = ETopSeed / ESeed;
1125  vals[22] = EBottomSeed / ESeed;
1126  vals[23] = ELeftSeed / ESeed;
1127  vals[24] = ERightSeed / ESeed;
1128  vals[25] = E2x5MaxSeed / ESeed;
1129  vals[26] = E2x5TopSeed / ESeed;
1130  vals[27] = E2x5BottomSeed / ESeed;
1131  vals[28] = E2x5LeftSeed / ESeed;
1132  vals[29] = E2x5RightSeed / ESeed;
1133  vals[30] = IsEcalDriven;
1134  vals[31] = IEtaSeed;
1135  vals[32] = IPhiSeed;
1136  vals[33] = ((int)IEtaSeed) % 5;
1137  vals[34] = ((int)IPhiSeed) % 2;
1138  vals[35] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
1139  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
1140  vals[36] = ((int)IPhiSeed) % 20;
1141  vals[37] = EtaCrySeed;
1142  vals[38] = PhiCrySeed;
1143  } else { // Endcap
1144  vals[0] = SCRawEnergy;
1145  vals[1] = scEta;
1146  vals[2] = scPhi;
1147  vals[3] = R9;
1148  vals[4] = E5x5Seed / SCRawEnergy;
1149  vals[5] = etawidth;
1150  vals[6] = phiwidth;
1151  vals[7] = NClusters;
1152  vals[8] = HoE;
1153  vals[9] = rho;
1154  vals[10] = vertices;
1155  vals[11] = EtaSeed - scEta;
1156  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1157  vals[13] = ESeed / SCRawEnergy;
1158  vals[14] = E3x3Seed / ESeed;
1159  vals[15] = E5x5Seed / ESeed;
1160  vals[16] = see;
1161  vals[17] = spp;
1162  vals[18] = sep;
1163  vals[19] = EMaxSeed / ESeed;
1164  vals[20] = E2ndSeed / ESeed;
1165  vals[21] = ETopSeed / ESeed;
1166  vals[22] = EBottomSeed / ESeed;
1167  vals[23] = ELeftSeed / ESeed;
1168  vals[24] = ERightSeed / ESeed;
1169  vals[25] = E2x5MaxSeed / ESeed;
1170  vals[26] = E2x5TopSeed / ESeed;
1171  vals[27] = E2x5BottomSeed / ESeed;
1172  vals[28] = E2x5LeftSeed / ESeed;
1173  vals[29] = E2x5RightSeed / ESeed;
1174  vals[30] = IsEcalDriven;
1175  vals[31] = PreShowerOverRaw;
1176  }
1177 
1178  // Now evaluating the regression
1179  double regressionResult = 0;
1180  Int_t BinIndex = -1;
1181 
1182  if (fVersionType == kNoTrkVarV1) {
1183  if (std::abs(scEta) <= 1.479) {
1184  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
1185  BinIndex = 0;
1186  } else {
1187  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
1188  BinIndex = 1;
1189  }
1190  }
1191 
1192  //print debug
1193  if (printDebug) {
1194  if (std::abs(scEta) <= 1.479) {
1195  std::cout << "Barrel :";
1196  for (unsigned int v = 0; v < 39; ++v)
1197  std::cout << vals[v] << ", ";
1198  std::cout << "\n";
1199  } else {
1200  std::cout << "Endcap :";
1201  for (unsigned int v = 0; v < 32; ++v)
1202  std::cout << vals[v] << ", ";
1203  std::cout << "\n";
1204  }
1205  std::cout << "BinIndex : " << BinIndex << "\n";
1206  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
1207  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
1208  }
1209 
1210  // Cleaning up and returning
1211  delete[] vals;
1212  return regressionResult;
1213 }

References funct::abs(), funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kNoTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergyUncertainty().

◆ regressionUncertaintyWithSubClusters()

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithSubClusters ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
double  isEcalDriven,
double  isEtaGap,
double  isPhiGap,
double  isDeeGap,
double  ESubs,
double  ESub1,
double  EtaSub1,
double  PhiSub1,
double  EMaxSub1,
double  E3x3Sub1,
double  ESub2,
double  EtaSub2,
double  PhiSub2,
double  EMaxSub2,
double  E3x3Sub2,
double  ESub3,
double  EtaSub3,
double  PhiSub3,
double  EMaxSub3,
double  E3x3Sub3,
double  NPshwClusters,
double  EPshwSubs,
double  EPshwSub1,
double  EtaPshwSub1,
double  PhiPshwSub1,
double  EPshwSub2,
double  EtaPshwSub2,
double  PhiPshwSub2,
double  EPshwSub3,
double  EtaPshwSub3,
double  PhiPshwSub3,
bool  isEB,
bool  printDebug = false 
)

Definition at line 3327 of file ElectronEnergyRegressionEvaluate.cc.

3393  {
3394  // Checking if instance has been initialized
3395  if (fIsInitialized == kFALSE) {
3396  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
3397  return 0;
3398  }
3399 
3400  // Checking if type is correct
3401  if (!(fVersionType == kWithSubCluVar)) {
3402  std::cout << "Error: Regression VersionType " << fVersionType
3403  << " is not supported to use function regressionValueWithSubClusters.\n";
3404  return 0;
3405  }
3406 
3407  // Now applying regression according to version and (endcap/barrel)
3408  float *vals = (isEB) ? new float[61] : new float[65];
3409  if (isEB) { // Barrel
3410  vals[0] = rho;
3411  vals[1] = vertices;
3412  vals[2] = isEcalDriven;
3413  vals[3] = isEtaGap;
3414  vals[4] = isPhiGap;
3415  vals[5] = isDeeGap;
3416  vals[6] = SCRawEnergy;
3417  vals[7] = scEta;
3418  vals[8] = scPhi;
3419  vals[9] = R9;
3420  vals[10] = etawidth;
3421  vals[11] = phiwidth;
3422  vals[12] = NClusters;
3423  vals[13] = HoE;
3424  vals[14] = EtaSeed - scEta;
3425  vals[15] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
3426  vals[16] = ESeed / SCRawEnergy;
3427  vals[17] = E3x3Seed / ESeed;
3428  vals[18] = E5x5Seed / SCRawEnergy;
3429  vals[19] = E5x5Seed / ESeed;
3430  vals[20] = EMaxSeed / ESeed;
3431  vals[21] = E2ndSeed / ESeed;
3432  vals[22] = ETopSeed / ESeed;
3433  vals[23] = EBottomSeed / ESeed;
3434  vals[24] = ELeftSeed / ESeed;
3435  vals[25] = ERightSeed / ESeed;
3436  vals[26] = E2x5MaxSeed / ESeed;
3437  vals[27] = E2x5TopSeed / ESeed;
3438  vals[28] = E2x5BottomSeed / ESeed;
3439  vals[29] = E2x5LeftSeed / ESeed;
3440  vals[30] = E2x5RightSeed / ESeed;
3441  vals[31] = see;
3442  vals[32] = spp;
3443  vals[33] = sep;
3444  vals[34] = phiwidth / etawidth;
3445  vals[35] = (ELeftSeed + ERightSeed == 0. ? 0. : (ELeftSeed - ERightSeed) / (ELeftSeed + ERightSeed));
3446  vals[36] = (ETopSeed + EBottomSeed == 0. ? 0. : (ETopSeed - EBottomSeed) / (ETopSeed + EBottomSeed));
3447  vals[37] = ESubs / SCRawEnergy;
3448  vals[38] = ESub1 / SCRawEnergy;
3449  vals[39] = (NClusters <= 1 ? 999. : EtaSub1 - EtaSeed);
3450  vals[40] = (NClusters <= 1 ? 999. : atan2(sin(PhiSub1 - PhiSeed), cos(PhiSub1 - PhiSeed)));
3451  vals[41] = (NClusters <= 1 ? 0. : EMaxSub1 / ESub1);
3452  vals[42] = (NClusters <= 1 ? 0. : E3x3Sub1 / ESub1);
3453  vals[43] = ESub2 / SCRawEnergy;
3454  vals[44] = (NClusters <= 2 ? 999. : EtaSub2 - EtaSeed);
3455  vals[45] = (NClusters <= 2 ? 999. : atan2(sin(PhiSub2 - PhiSeed), cos(PhiSub2 - PhiSeed)));
3456  vals[46] = (NClusters <= 2 ? 0. : EMaxSub2 / ESub2);
3457  vals[47] = (NClusters <= 2 ? 0. : E3x3Sub2 / ESub2);
3458  vals[48] = ESub3 / SCRawEnergy;
3459  vals[49] = (NClusters <= 3 ? 999. : EtaSub3 - EtaSeed);
3460  vals[50] = (NClusters <= 3 ? 999. : atan2(sin(PhiSub3 - PhiSeed), cos(PhiSub3 - PhiSeed)));
3461  vals[51] = (NClusters <= 3 ? 0. : EMaxSub3 / ESub3);
3462  vals[52] = (NClusters <= 3 ? 0. : E3x3Sub3 / ESub3);
3463  vals[53] = IEtaSeed;
3464  vals[54] = ((int)IEtaSeed) % 5;
3465  vals[55] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
3466  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
3467  vals[56] = IPhiSeed;
3468  vals[57] = ((int)IPhiSeed) % 2;
3469  vals[58] = ((int)IPhiSeed) % 20;
3470  vals[59] = EtaCrySeed;
3471  vals[60] = PhiCrySeed;
3472  } else { // Endcap
3473  vals[0] = rho;
3474  vals[1] = vertices;
3475  vals[2] = isEcalDriven;
3476  vals[3] = isEtaGap;
3477  vals[4] = isPhiGap;
3478  vals[5] = isDeeGap;
3479  vals[6] = SCRawEnergy;
3480  vals[7] = scEta;
3481  vals[8] = scPhi;
3482  vals[9] = R9;
3483  vals[10] = etawidth;
3484  vals[11] = phiwidth;
3485  vals[12] = NClusters;
3486  vals[13] = HoE;
3487  vals[14] = EtaSeed - scEta;
3488  vals[15] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
3489  vals[16] = ESeed / SCRawEnergy;
3490  vals[17] = E3x3Seed / ESeed;
3491  vals[18] = E5x5Seed / SCRawEnergy;
3492  vals[19] = E5x5Seed / ESeed;
3493  vals[20] = EMaxSeed / ESeed;
3494  vals[21] = E2ndSeed / ESeed;
3495  vals[22] = ETopSeed / ESeed;
3496  vals[23] = EBottomSeed / ESeed;
3497  vals[24] = ELeftSeed / ESeed;
3498  vals[25] = ERightSeed / ESeed;
3499  vals[26] = E2x5MaxSeed / ESeed;
3500  vals[27] = E2x5TopSeed / ESeed;
3501  vals[28] = E2x5BottomSeed / ESeed;
3502  vals[29] = E2x5LeftSeed / ESeed;
3503  vals[30] = E2x5RightSeed / ESeed;
3504  vals[31] = see;
3505  vals[32] = spp;
3506  vals[33] = sep;
3507  vals[34] = phiwidth / etawidth;
3508  vals[35] = (ELeftSeed + ERightSeed == 0. ? 0. : (ELeftSeed - ERightSeed) / (ELeftSeed + ERightSeed));
3509  vals[36] = (ETopSeed + EBottomSeed == 0. ? 0. : (ETopSeed - EBottomSeed) / (ETopSeed + EBottomSeed));
3510  vals[37] = ESubs / SCRawEnergy;
3511  vals[38] = ESub1 / SCRawEnergy;
3512  vals[39] = (NClusters <= 1 ? 999. : EtaSub1 - EtaSeed);
3513  vals[40] = (NClusters <= 1 ? 999. : atan2(sin(PhiSub1 - PhiSeed), cos(PhiSub1 - PhiSeed)));
3514  vals[41] = (NClusters <= 1 ? 0. : EMaxSub1 / ESub1);
3515  vals[42] = (NClusters <= 1 ? 0. : E3x3Sub1 / ESub1);
3516  vals[43] = ESub2 / SCRawEnergy;
3517  vals[44] = (NClusters <= 2 ? 999. : EtaSub2 - EtaSeed);
3518  vals[45] = (NClusters <= 2 ? 999. : atan2(sin(PhiSub2 - PhiSeed), cos(PhiSub2 - PhiSeed)));
3519  vals[46] = (NClusters <= 2 ? 0. : EMaxSub2 / ESub2);
3520  vals[47] = (NClusters <= 2 ? 0. : E3x3Sub2 / ESub2);
3521  vals[48] = ESub3 / SCRawEnergy;
3522  vals[49] = (NClusters <= 3 ? 999. : EtaSub3 - EtaSeed);
3523  vals[50] = (NClusters <= 3 ? 999. : atan2(sin(PhiSub3 - PhiSeed), cos(PhiSub3 - PhiSeed)));
3524  vals[51] = (NClusters <= 3 ? 0. : EMaxSub3 / ESub3);
3525  vals[52] = (NClusters <= 3 ? 0. : E3x3Sub3 / ESub3);
3526  vals[53] = PreShowerOverRaw;
3527  vals[54] = NPshwClusters;
3528  vals[55] = EPshwSubs / SCRawEnergy;
3529  vals[56] = EPshwSub1 / SCRawEnergy;
3530  vals[57] = (NPshwClusters <= 0 ? 999. : EtaPshwSub1 - EtaSeed);
3531  vals[58] = (NPshwClusters <= 0 ? 999. : atan2(sin(PhiPshwSub1 - PhiSeed), cos(PhiPshwSub1 - PhiSeed)));
3532  vals[59] = EPshwSub2 / SCRawEnergy;
3533  vals[60] = (NPshwClusters <= 1 ? 999. : EtaPshwSub2 - EtaSeed);
3534  vals[61] = (NPshwClusters <= 1 ? 999. : atan2(sin(PhiPshwSub2 - PhiSeed), cos(PhiPshwSub2 - PhiSeed)));
3535  vals[62] = EPshwSub3 / SCRawEnergy;
3536  vals[63] = (NPshwClusters <= 2 ? 999. : EtaPshwSub3 - EtaSeed);
3537  vals[64] = (NPshwClusters <= 2 ? 999. : atan2(sin(PhiPshwSub3 - PhiSeed), cos(PhiPshwSub3 - PhiSeed)));
3538  }
3539 
3540  // Now evaluating the regression
3541  double regressionResult = 0;
3542  Int_t BinIndex = -1;
3543 
3544  if (fVersionType == kWithSubCluVar) {
3545  if (isEB) {
3546  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
3547  BinIndex = 0;
3548  } else {
3549  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
3550  BinIndex = 1;
3551  }
3552  }
3553 
3554  //print debug
3555  if (printDebug) {
3556  if (isEB) {
3557  std::cout << "Barrel :";
3558  for (unsigned int v = 0; v < 38; ++v)
3559  std::cout << vals[v] << ", ";
3560  std::cout << "\n";
3561  } else {
3562  std::cout << "Endcap :";
3563  for (unsigned int v = 0; v < 31; ++v)
3564  std::cout << vals[v] << ", ";
3565  std::cout << "\n";
3566  }
3567  std::cout << "BinIndex : " << BinIndex << "\n";
3568  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
3569  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
3570  }
3571 
3572  // Cleaning up and returning
3573  delete[] vals;
3574  return regressionResult;
3575 }

References funct::abs(), funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithSubCluVar, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergyUncertainty(), and RegressionEnergyPatElectronProducer::produce().

◆ regressionUncertaintyWithTrkVar()

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVar ( double  electronP,
double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  pt,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
bool  printDebug = false 
)

Definition at line 1389 of file ElectronEnergyRegressionEvaluate.cc.

1429  {
1430  // Checking if instance has been initialized
1431  if (fIsInitialized == kFALSE) {
1432  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1433  return 0;
1434  }
1435 
1436  // Checking if fVersionType is correct
1437  assert(fVersionType == kWithTrkVar);
1438 
1439  float *vals = (std::abs(scEta) <= 1.479) ? new float[43] : new float[36];
1440  if (std::abs(scEta) <= 1.479) { // Barrel
1441  vals[0] = SCRawEnergy;
1442  vals[1] = scEta;
1443  vals[2] = scPhi;
1444  vals[3] = R9;
1445  vals[4] = E5x5Seed / SCRawEnergy;
1446  vals[5] = etawidth;
1447  vals[6] = phiwidth;
1448  vals[7] = NClusters;
1449  vals[8] = HoE;
1450  vals[9] = rho;
1451  vals[10] = vertices;
1452  vals[11] = EtaSeed - scEta;
1453  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1454  vals[13] = ESeed / SCRawEnergy;
1455  vals[14] = E3x3Seed / ESeed;
1456  vals[15] = E5x5Seed / ESeed;
1457  vals[16] = see;
1458  vals[17] = spp;
1459  vals[18] = sep;
1460  vals[19] = EMaxSeed / ESeed;
1461  vals[20] = E2ndSeed / ESeed;
1462  vals[21] = ETopSeed / ESeed;
1463  vals[22] = EBottomSeed / ESeed;
1464  vals[23] = ELeftSeed / ESeed;
1465  vals[24] = ERightSeed / ESeed;
1466  vals[25] = E2x5MaxSeed / ESeed;
1467  vals[26] = E2x5TopSeed / ESeed;
1468  vals[27] = E2x5BottomSeed / ESeed;
1469  vals[28] = E2x5LeftSeed / ESeed;
1470  vals[29] = E2x5RightSeed / ESeed;
1471  vals[30] = pt;
1472  vals[31] = GsfTrackPIn;
1473  vals[32] = fbrem;
1474  vals[33] = Charge;
1475  vals[34] = EoP;
1476  vals[35] = IEtaSeed;
1477  vals[36] = IPhiSeed;
1478  vals[37] = ((int)IEtaSeed) % 5;
1479  vals[38] = ((int)IPhiSeed) % 2;
1480  vals[39] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
1481  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
1482  vals[40] = ((int)IPhiSeed) % 20;
1483  vals[41] = EtaCrySeed;
1484  vals[42] = PhiCrySeed;
1485  }
1486 
1487  else { // Endcap
1488  vals[0] = SCRawEnergy;
1489  vals[1] = scEta;
1490  vals[2] = scPhi;
1491  vals[3] = R9;
1492  vals[4] = E5x5Seed / SCRawEnergy;
1493  vals[5] = etawidth;
1494  vals[6] = phiwidth;
1495  vals[7] = NClusters;
1496  vals[8] = HoE;
1497  vals[9] = rho;
1498  vals[10] = vertices;
1499  vals[11] = EtaSeed - scEta;
1500  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1501  vals[13] = ESeed / SCRawEnergy;
1502  vals[14] = E3x3Seed / ESeed;
1503  vals[15] = E5x5Seed / ESeed;
1504  vals[16] = see;
1505  vals[17] = spp;
1506  vals[18] = sep;
1507  vals[19] = EMaxSeed / ESeed;
1508  vals[20] = E2ndSeed / ESeed;
1509  vals[21] = ETopSeed / ESeed;
1510  vals[22] = EBottomSeed / ESeed;
1511  vals[23] = ELeftSeed / ESeed;
1512  vals[24] = ERightSeed / ESeed;
1513  vals[25] = E2x5MaxSeed / ESeed;
1514  vals[26] = E2x5TopSeed / ESeed;
1515  vals[27] = E2x5BottomSeed / ESeed;
1516  vals[28] = E2x5LeftSeed / ESeed;
1517  vals[29] = E2x5RightSeed / ESeed;
1518  vals[30] = pt;
1519  vals[31] = GsfTrackPIn;
1520  vals[32] = fbrem;
1521  vals[33] = Charge;
1522  vals[34] = EoP;
1523  vals[35] = PreShowerOverRaw;
1524  }
1525 
1526  // Now evaluating the regression
1527  double regressionResult = 0;
1528 
1529  if (fVersionType == kWithTrkVar) {
1530  if (std::abs(scEta) <= 1.479)
1531  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
1532  else
1533  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
1534  }
1535 
1536  //print debug
1537  if (printDebug) {
1538  if (scEta <= 1.479) {
1539  std::cout << "Barrel :";
1540  for (unsigned int v = 0; v < 43; ++v)
1541  std::cout << vals[v] << ", ";
1542  std::cout << "\n";
1543  } else {
1544  std::cout << "Endcap :";
1545  for (unsigned int v = 0; v < 36; ++v)
1546  std::cout << vals[v] << ", ";
1547  std::cout << "\n";
1548  }
1549  std::cout << "pt = " << pt << " : SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw
1550  << std::endl;
1551  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
1552  }
1553 
1554  // Cleaning up and returning
1555  delete[] vals;
1556  return regressionResult;
1557 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVar, HLT_FULL_cff::printDebug, DiDispStaMuonMonitor_cfi::pt, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by RegressionEnergyPatElectronProducer::produce().

◆ regressionUncertaintyWithTrkVarV1() [1/2]

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  TrackMomentumError,
double  EcalEnergyError,
int  Classification,
bool  printDebug = false 
)

Definition at line 1736 of file ElectronEnergyRegressionEvaluate.cc.

1778  {
1779  // Checking if instance has been initialized
1780  if (fIsInitialized == kFALSE) {
1781  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1782  return 0;
1783  }
1784 
1785  // Checking if fVersionType is correct
1786  assert(fVersionType == kWithTrkVarV1);
1787 
1788  float *vals = (std::abs(scEta) <= 1.479) ? new float[46] : new float[39];
1789  if (std::abs(scEta) <= 1.479) { // Barrel
1790  vals[0] = SCRawEnergy;
1791  vals[1] = scEta;
1792  vals[2] = scPhi;
1793  vals[3] = R9;
1794  vals[4] = E5x5Seed / SCRawEnergy;
1795  vals[5] = etawidth;
1796  vals[6] = phiwidth;
1797  vals[7] = NClusters;
1798  vals[8] = HoE;
1799  vals[9] = rho;
1800  vals[10] = vertices;
1801  vals[11] = EtaSeed - scEta;
1802  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1803  vals[13] = ESeed / SCRawEnergy;
1804  vals[14] = E3x3Seed / ESeed;
1805  vals[15] = E5x5Seed / ESeed;
1806  vals[16] = see;
1807  vals[17] = spp;
1808  vals[18] = sep;
1809  vals[19] = EMaxSeed / ESeed;
1810  vals[20] = E2ndSeed / ESeed;
1811  vals[21] = ETopSeed / ESeed;
1812  vals[22] = EBottomSeed / ESeed;
1813  vals[23] = ELeftSeed / ESeed;
1814  vals[24] = ERightSeed / ESeed;
1815  vals[25] = E2x5MaxSeed / ESeed;
1816  vals[26] = E2x5TopSeed / ESeed;
1817  vals[27] = E2x5BottomSeed / ESeed;
1818  vals[28] = E2x5LeftSeed / ESeed;
1819  vals[29] = E2x5RightSeed / ESeed;
1820  vals[30] = IsEcalDriven;
1821  vals[31] = GsfTrackPIn;
1822  vals[32] = fbrem;
1823  vals[33] = Charge;
1824  vals[34] = EoP;
1825  vals[35] = TrackMomentumError / GsfTrackPIn;
1826  vals[36] = EcalEnergyError / SCRawEnergy;
1827  vals[37] = Classification;
1828  vals[38] = IEtaSeed;
1829  vals[39] = IPhiSeed;
1830  vals[40] = ((int)IEtaSeed) % 5;
1831  vals[41] = ((int)IPhiSeed) % 2;
1832  vals[42] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
1833  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
1834  vals[43] = ((int)IPhiSeed) % 20;
1835  vals[44] = EtaCrySeed;
1836  vals[45] = PhiCrySeed;
1837  }
1838 
1839  else { // Endcap
1840  vals[0] = SCRawEnergy;
1841  vals[1] = scEta;
1842  vals[2] = scPhi;
1843  vals[3] = R9;
1844  vals[4] = E5x5Seed / SCRawEnergy;
1845  vals[5] = etawidth;
1846  vals[6] = phiwidth;
1847  vals[7] = NClusters;
1848  vals[8] = HoE;
1849  vals[9] = rho;
1850  vals[10] = vertices;
1851  vals[11] = EtaSeed - scEta;
1852  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1853  vals[13] = ESeed / SCRawEnergy;
1854  vals[14] = E3x3Seed / ESeed;
1855  vals[15] = E5x5Seed / ESeed;
1856  vals[16] = see;
1857  vals[17] = spp;
1858  vals[18] = sep;
1859  vals[19] = EMaxSeed / ESeed;
1860  vals[20] = E2ndSeed / ESeed;
1861  vals[21] = ETopSeed / ESeed;
1862  vals[22] = EBottomSeed / ESeed;
1863  vals[23] = ELeftSeed / ESeed;
1864  vals[24] = ERightSeed / ESeed;
1865  vals[25] = E2x5MaxSeed / ESeed;
1866  vals[26] = E2x5TopSeed / ESeed;
1867  vals[27] = E2x5BottomSeed / ESeed;
1868  vals[28] = E2x5LeftSeed / ESeed;
1869  vals[29] = E2x5RightSeed / ESeed;
1870  vals[30] = IsEcalDriven;
1871  vals[31] = GsfTrackPIn;
1872  vals[32] = fbrem;
1873  vals[33] = Charge;
1874  vals[34] = EoP;
1875  vals[35] = TrackMomentumError / GsfTrackPIn;
1876  vals[36] = EcalEnergyError / SCRawEnergy;
1877  vals[37] = Classification;
1878  vals[38] = PreShowerOverRaw;
1879  }
1880 
1881  // Now evaluating the regression
1882  double regressionResult = 0;
1883 
1884  if (fVersionType == kWithTrkVarV1) {
1885  if (std::abs(scEta) <= 1.479)
1886  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
1887  else
1888  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
1889  }
1890 
1891  //print debug
1892  if (printDebug) {
1893  if (std::abs(scEta) <= 1.479) {
1894  std::cout << "Barrel :";
1895  for (unsigned int v = 0; v < 46; ++v)
1896  std::cout << vals[v] << ", ";
1897  std::cout << "\n";
1898  } else {
1899  std::cout << "Endcap :";
1900  for (unsigned int v = 0; v < 39; ++v)
1901  std::cout << vals[v] << ", ";
1902  std::cout << "\n";
1903  }
1904  std::cout << " SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
1905  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
1906  }
1907 
1908  // Cleaning up and returning
1909  delete[] vals;
1910  return regressionResult;
1911 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergyUncertainty().

◆ regressionUncertaintyWithTrkVarV1() [2/2]

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1 ( std::vector< double > &  inputvars,
bool  printDebug = false 
)

Definition at line 2094 of file ElectronEnergyRegressionEvaluate.cc.

2095  {
2096  // Checking if instance has been initialized
2097  if (fIsInitialized == kFALSE) {
2098  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
2099  return 0;
2100  }
2101 
2102  // Checking if fVersionType is correct
2103  assert(fVersionType == kWithTrkVarV1);
2104 
2105  // Checking if fVersionType is correct
2106  assert(inputvars.size() == 42);
2107 
2108  double SCRawEnergy = inputvars[0];
2109  double scEta = inputvars[1];
2110  double scPhi = inputvars[2];
2111  double R9 = inputvars[3];
2112  double etawidth = inputvars[4];
2113  double phiwidth = inputvars[5];
2114  double NClusters = inputvars[6];
2115  double HoE = inputvars[7];
2116  double rho = inputvars[8];
2117  double vertices = inputvars[9];
2118  double EtaSeed = inputvars[10];
2119  double PhiSeed = inputvars[11];
2120  double ESeed = inputvars[12];
2121  double E3x3Seed = inputvars[13];
2122  double E5x5Seed = inputvars[14];
2123  double see = inputvars[15];
2124  double spp = inputvars[16];
2125  double sep = inputvars[17];
2126  double EMaxSeed = inputvars[18];
2127  double E2ndSeed = inputvars[19];
2128  double ETopSeed = inputvars[20];
2129  double EBottomSeed = inputvars[21];
2130  double ELeftSeed = inputvars[22];
2131  double ERightSeed = inputvars[23];
2132  double E2x5MaxSeed = inputvars[24];
2133  double E2x5TopSeed = inputvars[25];
2134  double E2x5BottomSeed = inputvars[26];
2135  double E2x5LeftSeed = inputvars[27];
2136  double E2x5RightSeed = inputvars[28];
2137  double IEtaSeed = inputvars[29];
2138  double IPhiSeed = inputvars[30];
2139  double EtaCrySeed = inputvars[31];
2140  double PhiCrySeed = inputvars[32];
2141  double PreShowerOverRaw = inputvars[33];
2142  int IsEcalDriven = inputvars[34];
2143  double GsfTrackPIn = inputvars[35];
2144  double fbrem = inputvars[36];
2145  double Charge = inputvars[37];
2146  double EoP = inputvars[38];
2147  double TrackMomentumError = inputvars[39];
2148  double EcalEnergyError = inputvars[40];
2149  int Classification = inputvars[41];
2150 
2151  float *vals = (std::abs(scEta) <= 1.479) ? new float[46] : new float[39];
2152  if (std::abs(scEta) <= 1.479) { // Barrel
2153  vals[0] = SCRawEnergy;
2154  vals[1] = scEta;
2155  vals[2] = scPhi;
2156  vals[3] = R9;
2157  vals[4] = E5x5Seed / SCRawEnergy;
2158  vals[5] = etawidth;
2159  vals[6] = phiwidth;
2160  vals[7] = NClusters;
2161  vals[8] = HoE;
2162  vals[9] = rho;
2163  vals[10] = vertices;
2164  vals[11] = EtaSeed - scEta;
2165  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2166  vals[13] = ESeed / SCRawEnergy;
2167  vals[14] = E3x3Seed / ESeed;
2168  vals[15] = E5x5Seed / ESeed;
2169  vals[16] = see;
2170  vals[17] = spp;
2171  vals[18] = sep;
2172  vals[19] = EMaxSeed / ESeed;
2173  vals[20] = E2ndSeed / ESeed;
2174  vals[21] = ETopSeed / ESeed;
2175  vals[22] = EBottomSeed / ESeed;
2176  vals[23] = ELeftSeed / ESeed;
2177  vals[24] = ERightSeed / ESeed;
2178  vals[25] = E2x5MaxSeed / ESeed;
2179  vals[26] = E2x5TopSeed / ESeed;
2180  vals[27] = E2x5BottomSeed / ESeed;
2181  vals[28] = E2x5LeftSeed / ESeed;
2182  vals[29] = E2x5RightSeed / ESeed;
2183  vals[30] = IsEcalDriven;
2184  vals[31] = GsfTrackPIn;
2185  vals[32] = fbrem;
2186  vals[33] = Charge;
2187  vals[34] = EoP;
2188  vals[35] = TrackMomentumError / GsfTrackPIn;
2189  vals[36] = EcalEnergyError / SCRawEnergy;
2190  vals[37] = Classification;
2191  vals[38] = IEtaSeed;
2192  vals[39] = IPhiSeed;
2193  vals[40] = ((int)IEtaSeed) % 5;
2194  vals[41] = ((int)IPhiSeed) % 2;
2195  vals[42] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2196  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2197  vals[43] = ((int)IPhiSeed) % 20;
2198  vals[44] = EtaCrySeed;
2199  vals[45] = PhiCrySeed;
2200  }
2201 
2202  else { // Endcap
2203  vals[0] = SCRawEnergy;
2204  vals[1] = scEta;
2205  vals[2] = scPhi;
2206  vals[3] = R9;
2207  vals[4] = E5x5Seed / SCRawEnergy;
2208  vals[5] = etawidth;
2209  vals[6] = phiwidth;
2210  vals[7] = NClusters;
2211  vals[8] = HoE;
2212  vals[9] = rho;
2213  vals[10] = vertices;
2214  vals[11] = EtaSeed - scEta;
2215  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2216  vals[13] = ESeed / SCRawEnergy;
2217  vals[14] = E3x3Seed / ESeed;
2218  vals[15] = E5x5Seed / ESeed;
2219  vals[16] = see;
2220  vals[17] = spp;
2221  vals[18] = sep;
2222  vals[19] = EMaxSeed / ESeed;
2223  vals[20] = E2ndSeed / ESeed;
2224  vals[21] = ETopSeed / ESeed;
2225  vals[22] = EBottomSeed / ESeed;
2226  vals[23] = ELeftSeed / ESeed;
2227  vals[24] = ERightSeed / ESeed;
2228  vals[25] = E2x5MaxSeed / ESeed;
2229  vals[26] = E2x5TopSeed / ESeed;
2230  vals[27] = E2x5BottomSeed / ESeed;
2231  vals[28] = E2x5LeftSeed / ESeed;
2232  vals[29] = E2x5RightSeed / ESeed;
2233  vals[30] = IsEcalDriven;
2234  vals[31] = GsfTrackPIn;
2235  vals[32] = fbrem;
2236  vals[33] = Charge;
2237  vals[34] = EoP;
2238  vals[35] = TrackMomentumError / GsfTrackPIn;
2239  vals[36] = EcalEnergyError / SCRawEnergy;
2240  vals[37] = Classification;
2241  vals[38] = PreShowerOverRaw;
2242  }
2243 
2244  // Now evaluating the regression
2245  double regressionResult = 0;
2246 
2247  if (fVersionType == kWithTrkVarV1) {
2248  if (std::abs(scEta) <= 1.479)
2249  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
2250  else
2251  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
2252  }
2253 
2254  //print debug
2255  if (printDebug) {
2256  if (std::abs(scEta) <= 1.479) {
2257  std::cout << "Barrel :";
2258  for (unsigned int v = 0; v < 46; ++v)
2259  std::cout << vals[v] << ", ";
2260  std::cout << "\n";
2261  } else {
2262  std::cout << "Endcap :";
2263  for (unsigned int v = 0; v < 39; ++v)
2264  std::cout << vals[v] << ", ";
2265  std::cout << "\n";
2266  }
2267  std::cout << " SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
2268  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
2269  }
2270 
2271  // Cleaning up and returning
2272  delete[] vals;
2273  return regressionResult;
2274 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

◆ regressionUncertaintyWithTrkVarV2() [1/2]

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  TrackMomentumError,
double  EcalEnergyError,
int  Classification,
double  detaIn,
double  dphiIn,
double  detaCalo,
double  dphiCalo,
double  GsfTrackChiSqr,
double  KFTrackNLayers,
double  ElectronEnergyOverPout,
bool  printDebug = false 
)

Definition at line 2474 of file ElectronEnergyRegressionEvaluate.cc.

2523  {
2524  // Checking if instance has been initialized
2525  if (fIsInitialized == kFALSE) {
2526  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
2527  return 0;
2528  }
2529 
2530  // Checking if fVersionType is correct
2531  assert(fVersionType == kWithTrkVarV2);
2532 
2533  float *vals = (std::abs(scEta) <= 1.479) ? new float[53] : new float[46];
2534  if (std::abs(scEta) <= 1.479) { // Barrel
2535  vals[0] = SCRawEnergy;
2536  vals[1] = scEta;
2537  vals[2] = scPhi;
2538  vals[3] = R9;
2539  vals[4] = E5x5Seed / SCRawEnergy;
2540  vals[5] = etawidth;
2541  vals[6] = phiwidth;
2542  vals[7] = NClusters;
2543  vals[8] = HoE;
2544  vals[9] = rho;
2545  vals[10] = vertices;
2546  vals[11] = EtaSeed - scEta;
2547  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2548  vals[13] = ESeed / SCRawEnergy;
2549  vals[14] = E3x3Seed / ESeed;
2550  vals[15] = E5x5Seed / ESeed;
2551  vals[16] = see;
2552  vals[17] = spp;
2553  vals[18] = sep;
2554  vals[19] = EMaxSeed / ESeed;
2555  vals[20] = E2ndSeed / ESeed;
2556  vals[21] = ETopSeed / ESeed;
2557  vals[22] = EBottomSeed / ESeed;
2558  vals[23] = ELeftSeed / ESeed;
2559  vals[24] = ERightSeed / ESeed;
2560  vals[25] = E2x5MaxSeed / ESeed;
2561  vals[26] = E2x5TopSeed / ESeed;
2562  vals[27] = E2x5BottomSeed / ESeed;
2563  vals[28] = E2x5LeftSeed / ESeed;
2564  vals[29] = E2x5RightSeed / ESeed;
2565  vals[30] = IsEcalDriven;
2566  vals[31] = GsfTrackPIn;
2567  vals[32] = fbrem;
2568  vals[33] = Charge;
2569  vals[34] = EoP;
2570  vals[35] = TrackMomentumError / GsfTrackPIn;
2571  vals[36] = EcalEnergyError / SCRawEnergy;
2572  vals[37] = Classification;
2573  vals[38] = detaIn;
2574  vals[39] = dphiIn;
2575  vals[40] = detaCalo;
2576  vals[41] = dphiCalo;
2577  vals[42] = GsfTrackChiSqr;
2578  vals[43] = KFTrackNLayers;
2579  vals[44] = ElectronEnergyOverPout;
2580  vals[45] = IEtaSeed;
2581  vals[46] = IPhiSeed;
2582  vals[47] = ((int)IEtaSeed) % 5;
2583  vals[48] = ((int)IPhiSeed) % 2;
2584  vals[49] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2585  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2586  vals[50] = ((int)IPhiSeed) % 20;
2587  vals[51] = EtaCrySeed;
2588  vals[52] = PhiCrySeed;
2589  }
2590 
2591  else { // Endcap
2592  vals[0] = SCRawEnergy;
2593  vals[1] = scEta;
2594  vals[2] = scPhi;
2595  vals[3] = R9;
2596  vals[4] = E5x5Seed / SCRawEnergy;
2597  vals[5] = etawidth;
2598  vals[6] = phiwidth;
2599  vals[7] = NClusters;
2600  vals[8] = HoE;
2601  vals[9] = rho;
2602  vals[10] = vertices;
2603  vals[11] = EtaSeed - scEta;
2604  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2605  vals[13] = ESeed / SCRawEnergy;
2606  vals[14] = E3x3Seed / ESeed;
2607  vals[15] = E5x5Seed / ESeed;
2608  vals[16] = see;
2609  vals[17] = spp;
2610  vals[18] = sep;
2611  vals[19] = EMaxSeed / ESeed;
2612  vals[20] = E2ndSeed / ESeed;
2613  vals[21] = ETopSeed / ESeed;
2614  vals[22] = EBottomSeed / ESeed;
2615  vals[23] = ELeftSeed / ESeed;
2616  vals[24] = ERightSeed / ESeed;
2617  vals[25] = E2x5MaxSeed / ESeed;
2618  vals[26] = E2x5TopSeed / ESeed;
2619  vals[27] = E2x5BottomSeed / ESeed;
2620  vals[28] = E2x5LeftSeed / ESeed;
2621  vals[29] = E2x5RightSeed / ESeed;
2622  vals[30] = IsEcalDriven;
2623  vals[31] = GsfTrackPIn;
2624  vals[32] = fbrem;
2625  vals[33] = Charge;
2626  vals[34] = EoP;
2627  vals[35] = TrackMomentumError / GsfTrackPIn;
2628  vals[36] = EcalEnergyError / SCRawEnergy;
2629  vals[37] = Classification;
2630  vals[38] = detaIn;
2631  vals[39] = dphiIn;
2632  vals[40] = detaCalo;
2633  vals[41] = dphiCalo;
2634  vals[42] = GsfTrackChiSqr;
2635  vals[43] = KFTrackNLayers;
2636  vals[44] = ElectronEnergyOverPout;
2637  vals[45] = PreShowerOverRaw;
2638  }
2639 
2640  // Now evaluating the regression
2641  double regressionResult = 0;
2642 
2643  if (fVersionType == kWithTrkVarV2) {
2644  if (std::abs(scEta) <= 1.479)
2645  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
2646  else
2647  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
2648  }
2649 
2650  //print debug
2651  if (printDebug) {
2652  if (std::abs(scEta) <= 1.479) {
2653  std::cout << "Barrel :";
2654  for (unsigned int v = 0; v < 53; ++v)
2655  std::cout << vals[v] << ", ";
2656  std::cout << "\n";
2657  } else {
2658  std::cout << "Endcap :";
2659  for (unsigned int v = 0; v < 46; ++v)
2660  std::cout << vals[v] << ", ";
2661  std::cout << "\n";
2662  }
2663  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
2664  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
2665  }
2666 
2667  // Cleaning up and returning
2668  delete[] vals;
2669  return regressionResult;
2670 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV2, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergyUncertainty().

◆ regressionUncertaintyWithTrkVarV2() [2/2]

double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2 ( std::vector< double > &  inputvars,
bool  printDebug = false 
)

Definition at line 2874 of file ElectronEnergyRegressionEvaluate.cc.

2875  {
2876  // Checking if instance has been initialized
2877  if (fIsInitialized == kFALSE) {
2878  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
2879  return 0;
2880  }
2881 
2882  // Checking if fVersionType is correct
2883  assert(fVersionType == kWithTrkVarV2);
2884 
2885  // Checking if fVersionType is correct
2886  assert(inputvars.size() == 49);
2887 
2888  double SCRawEnergy = inputvars[0];
2889  double scEta = inputvars[1];
2890  double scPhi = inputvars[2];
2891  double R9 = inputvars[3];
2892  double etawidth = inputvars[4];
2893  double phiwidth = inputvars[5];
2894  double NClusters = inputvars[6];
2895  double HoE = inputvars[7];
2896  double rho = inputvars[8];
2897  double vertices = inputvars[9];
2898  double EtaSeed = inputvars[10];
2899  double PhiSeed = inputvars[11];
2900  double ESeed = inputvars[12];
2901  double E3x3Seed = inputvars[13];
2902  double E5x5Seed = inputvars[14];
2903  double see = inputvars[15];
2904  double spp = inputvars[16];
2905  double sep = inputvars[17];
2906  double EMaxSeed = inputvars[18];
2907  double E2ndSeed = inputvars[19];
2908  double ETopSeed = inputvars[20];
2909  double EBottomSeed = inputvars[21];
2910  double ELeftSeed = inputvars[22];
2911  double ERightSeed = inputvars[23];
2912  double E2x5MaxSeed = inputvars[24];
2913  double E2x5TopSeed = inputvars[25];
2914  double E2x5BottomSeed = inputvars[26];
2915  double E2x5LeftSeed = inputvars[27];
2916  double E2x5RightSeed = inputvars[28];
2917  double IEtaSeed = inputvars[29];
2918  double IPhiSeed = inputvars[30];
2919  double EtaCrySeed = inputvars[31];
2920  double PhiCrySeed = inputvars[32];
2921  double PreShowerOverRaw = inputvars[33];
2922  int IsEcalDriven = inputvars[34];
2923  double GsfTrackPIn = inputvars[35];
2924  double fbrem = inputvars[36];
2925  double Charge = inputvars[37];
2926  double EoP = inputvars[38];
2927  double TrackMomentumError = inputvars[39];
2928  double EcalEnergyError = inputvars[40];
2929  int Classification = inputvars[41];
2930  double detaIn = inputvars[42];
2931  double dphiIn = inputvars[43];
2932  double detaCalo = inputvars[44];
2933  double dphiCalo = inputvars[45];
2934  double GsfTrackChiSqr = inputvars[46];
2935  double KFTrackNLayers = inputvars[47];
2936  double ElectronEnergyOverPout = inputvars[48];
2937 
2938  float *vals = (std::abs(scEta) <= 1.479) ? new float[53] : new float[46];
2939  if (std::abs(scEta) <= 1.479) { // Barrel
2940  vals[0] = SCRawEnergy;
2941  vals[1] = scEta;
2942  vals[2] = scPhi;
2943  vals[3] = R9;
2944  vals[4] = E5x5Seed / SCRawEnergy;
2945  vals[5] = etawidth;
2946  vals[6] = phiwidth;
2947  vals[7] = NClusters;
2948  vals[8] = HoE;
2949  vals[9] = rho;
2950  vals[10] = vertices;
2951  vals[11] = EtaSeed - scEta;
2952  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2953  vals[13] = ESeed / SCRawEnergy;
2954  vals[14] = E3x3Seed / ESeed;
2955  vals[15] = E5x5Seed / ESeed;
2956  vals[16] = see;
2957  vals[17] = spp;
2958  vals[18] = sep;
2959  vals[19] = EMaxSeed / ESeed;
2960  vals[20] = E2ndSeed / ESeed;
2961  vals[21] = ETopSeed / ESeed;
2962  vals[22] = EBottomSeed / ESeed;
2963  vals[23] = ELeftSeed / ESeed;
2964  vals[24] = ERightSeed / ESeed;
2965  vals[25] = E2x5MaxSeed / ESeed;
2966  vals[26] = E2x5TopSeed / ESeed;
2967  vals[27] = E2x5BottomSeed / ESeed;
2968  vals[28] = E2x5LeftSeed / ESeed;
2969  vals[29] = E2x5RightSeed / ESeed;
2970  vals[30] = IsEcalDriven;
2971  vals[31] = GsfTrackPIn;
2972  vals[32] = fbrem;
2973  vals[33] = Charge;
2974  vals[34] = EoP;
2975  vals[35] = TrackMomentumError / GsfTrackPIn;
2976  vals[36] = EcalEnergyError / SCRawEnergy;
2977  vals[37] = Classification;
2978  vals[38] = detaIn;
2979  vals[39] = dphiIn;
2980  vals[40] = detaCalo;
2981  vals[41] = dphiCalo;
2982  vals[42] = GsfTrackChiSqr;
2983  vals[43] = KFTrackNLayers;
2984  vals[44] = ElectronEnergyOverPout;
2985  vals[45] = IEtaSeed;
2986  vals[46] = IPhiSeed;
2987  vals[47] = ((int)IEtaSeed) % 5;
2988  vals[48] = ((int)IPhiSeed) % 2;
2989  vals[49] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2990  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2991  vals[50] = ((int)IPhiSeed) % 20;
2992  vals[51] = EtaCrySeed;
2993  vals[52] = PhiCrySeed;
2994  }
2995 
2996  else { // Endcap
2997  vals[0] = SCRawEnergy;
2998  vals[1] = scEta;
2999  vals[2] = scPhi;
3000  vals[3] = R9;
3001  vals[4] = E5x5Seed / SCRawEnergy;
3002  vals[5] = etawidth;
3003  vals[6] = phiwidth;
3004  vals[7] = NClusters;
3005  vals[8] = HoE;
3006  vals[9] = rho;
3007  vals[10] = vertices;
3008  vals[11] = EtaSeed - scEta;
3009  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
3010  vals[13] = ESeed / SCRawEnergy;
3011  vals[14] = E3x3Seed / ESeed;
3012  vals[15] = E5x5Seed / ESeed;
3013  vals[16] = see;
3014  vals[17] = spp;
3015  vals[18] = sep;
3016  vals[19] = EMaxSeed / ESeed;
3017  vals[20] = E2ndSeed / ESeed;
3018  vals[21] = ETopSeed / ESeed;
3019  vals[22] = EBottomSeed / ESeed;
3020  vals[23] = ELeftSeed / ESeed;
3021  vals[24] = ERightSeed / ESeed;
3022  vals[25] = E2x5MaxSeed / ESeed;
3023  vals[26] = E2x5TopSeed / ESeed;
3024  vals[27] = E2x5BottomSeed / ESeed;
3025  vals[28] = E2x5LeftSeed / ESeed;
3026  vals[29] = E2x5RightSeed / ESeed;
3027  vals[30] = IsEcalDriven;
3028  vals[31] = GsfTrackPIn;
3029  vals[32] = fbrem;
3030  vals[33] = Charge;
3031  vals[34] = EoP;
3032  vals[35] = TrackMomentumError / GsfTrackPIn;
3033  vals[36] = EcalEnergyError / SCRawEnergy;
3034  vals[37] = Classification;
3035  vals[38] = detaIn;
3036  vals[39] = dphiIn;
3037  vals[40] = detaCalo;
3038  vals[41] = dphiCalo;
3039  vals[42] = GsfTrackChiSqr;
3040  vals[43] = KFTrackNLayers;
3041  vals[44] = ElectronEnergyOverPout;
3042  vals[45] = PreShowerOverRaw;
3043  }
3044 
3045  // Now evaluating the regression
3046  double regressionResult = 0;
3047 
3048  if (fVersionType == kWithTrkVarV2) {
3049  if (std::abs(scEta) <= 1.479)
3050  regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
3051  else
3052  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
3053  }
3054 
3055  //print debug
3056  if (printDebug) {
3057  if (std::abs(scEta) <= 1.479) {
3058  std::cout << "Barrel :";
3059  for (unsigned int v = 0; v < 53; ++v)
3060  std::cout << vals[v] << ", ";
3061  std::cout << "\n";
3062  } else {
3063  std::cout << "Endcap :";
3064  for (unsigned int v = 0; v < 46; ++v)
3065  std::cout << vals[v] << ", ";
3066  std::cout << "\n";
3067  }
3068  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
3069  std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
3070  }
3071 
3072  // Cleaning up and returning
3073  delete[] vals;
3074  return regressionResult;
3075 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestUncertainty_eb, forestUncertainty_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV2, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

◆ regressionValueNoTrkVar()

double ElectronEnergyRegressionEvaluate::regressionValueNoTrkVar ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
bool  printDebug = false 
)

Definition at line 564 of file ElectronEnergyRegressionEvaluate.cc.

598  {
599  // Checking if instance has been initialized
600  if (fIsInitialized == kFALSE) {
601  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
602  return 0;
603  }
604 
605  // Checking if type is correct
606  if (!(fVersionType == kNoTrkVar)) {
607  std::cout << "Error: Regression VersionType " << fVersionType
608  << " is not supported to use function regressionValueNoTrkVar.\n";
609  return 0;
610  }
611  assert(forestCorrection_ee);
612 
613  // Now applying regression according to version and (endcap/barrel)
614  float *vals = (std::abs(scEta) <= 1.479) ? new float[38] : new float[31];
615  if (std::abs(scEta) <= 1.479) { // Barrel
616  vals[0] = SCRawEnergy;
617  vals[1] = scEta;
618  vals[2] = scPhi;
619  vals[3] = R9;
620  vals[4] = E5x5Seed / SCRawEnergy;
621  vals[5] = etawidth;
622  vals[6] = phiwidth;
623  vals[7] = NClusters;
624  vals[8] = HoE;
625  vals[9] = rho;
626  vals[10] = vertices;
627  vals[11] = EtaSeed - scEta;
628  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
629  vals[13] = ESeed / SCRawEnergy;
630  vals[14] = E3x3Seed / ESeed;
631  vals[15] = E5x5Seed / ESeed;
632  vals[16] = see;
633  vals[17] = spp;
634  vals[18] = sep;
635  vals[19] = EMaxSeed / ESeed;
636  vals[20] = E2ndSeed / ESeed;
637  vals[21] = ETopSeed / ESeed;
638  vals[22] = EBottomSeed / ESeed;
639  vals[23] = ELeftSeed / ESeed;
640  vals[24] = ERightSeed / ESeed;
641  vals[25] = E2x5MaxSeed / ESeed;
642  vals[26] = E2x5TopSeed / ESeed;
643  vals[27] = E2x5BottomSeed / ESeed;
644  vals[28] = E2x5LeftSeed / ESeed;
645  vals[29] = E2x5RightSeed / ESeed;
646  vals[30] = IEtaSeed;
647  vals[31] = IPhiSeed;
648  vals[32] = ((int)IEtaSeed) % 5;
649  vals[33] = ((int)IPhiSeed) % 2;
650  vals[34] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
651  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
652  vals[35] = ((int)IPhiSeed) % 20;
653  vals[36] = EtaCrySeed;
654  vals[37] = PhiCrySeed;
655  } else { // Endcap
656  vals[0] = SCRawEnergy;
657  vals[1] = scEta;
658  vals[2] = scPhi;
659  vals[3] = R9;
660  vals[4] = E5x5Seed / SCRawEnergy;
661  vals[5] = etawidth;
662  vals[6] = phiwidth;
663  vals[7] = NClusters;
664  vals[8] = HoE;
665  vals[9] = rho;
666  vals[10] = vertices;
667  vals[11] = EtaSeed - scEta;
668  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
669  vals[13] = ESeed / SCRawEnergy;
670  vals[14] = E3x3Seed / ESeed;
671  vals[15] = E5x5Seed / ESeed;
672  vals[16] = see;
673  vals[17] = spp;
674  vals[18] = sep;
675  vals[19] = EMaxSeed / ESeed;
676  vals[20] = E2ndSeed / ESeed;
677  vals[21] = ETopSeed / ESeed;
678  vals[22] = EBottomSeed / ESeed;
679  vals[23] = ELeftSeed / ESeed;
680  vals[24] = ERightSeed / ESeed;
681  vals[25] = E2x5MaxSeed / ESeed;
682  vals[26] = E2x5TopSeed / ESeed;
683  vals[27] = E2x5BottomSeed / ESeed;
684  vals[28] = E2x5LeftSeed / ESeed;
685  vals[29] = E2x5RightSeed / ESeed;
686  vals[30] = PreShowerOverRaw;
687  }
688 
689  // Now evaluating the regression
690  double regressionResult = 0;
691  Int_t BinIndex = -1;
692 
693  if (fVersionType == kNoTrkVar) {
694  if (std::abs(scEta) <= 1.479) {
695  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
696  BinIndex = 0;
697  } else {
698  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
699  BinIndex = 1;
700  }
701  }
702 
703  //print debug
704  if (printDebug) {
705  if (std::abs(scEta) <= 1.479) {
706  std::cout << "Barrel :";
707  for (unsigned int v = 0; v < 38; ++v)
708  std::cout << vals[v] << ", ";
709  std::cout << "\n";
710  } else {
711  std::cout << "Endcap :";
712  for (unsigned int v = 0; v < 31; ++v)
713  std::cout << vals[v] << ", ";
714  std::cout << "\n";
715  }
716  std::cout << "BinIndex : " << BinIndex << "\n";
717  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
718  std::cout << "regression energy = " << regressionResult << std::endl;
719  }
720 
721  // Cleaning up and returning
722  delete[] vals;
723  return regressionResult;
724 }

References funct::abs(), cms::cuda::assert(), funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kNoTrkVar, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergy(), and RegressionEnergyPatElectronProducer::produce().

◆ regressionValueNoTrkVarV1()

double ElectronEnergyRegressionEvaluate::regressionValueNoTrkVarV1 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
bool  printDebug = false 
)

Definition at line 887 of file ElectronEnergyRegressionEvaluate.cc.

922  {
923  // Checking if instance has been initialized
924  if (fIsInitialized == kFALSE) {
925  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
926  return 0;
927  }
928 
929  // Checking if type is correct
930  if (!(fVersionType == kNoTrkVarV1)) {
931  std::cout << "Error: Regression VersionType " << fVersionType
932  << " is not supported to use function regressionValueNoTrkVar.\n";
933  return 0;
934  }
935 
936  // Now applying regression according to version and (endcap/barrel)
937  float *vals = (std::abs(scEta) <= 1.479) ? new float[39] : new float[32];
938  if (std::abs(scEta) <= 1.479) { // Barrel
939  vals[0] = SCRawEnergy;
940  vals[1] = scEta;
941  vals[2] = scPhi;
942  vals[3] = R9;
943  vals[4] = E5x5Seed / SCRawEnergy;
944  vals[5] = etawidth;
945  vals[6] = phiwidth;
946  vals[7] = NClusters;
947  vals[8] = HoE;
948  vals[9] = rho;
949  vals[10] = vertices;
950  vals[11] = EtaSeed - scEta;
951  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
952  vals[13] = ESeed / SCRawEnergy;
953  vals[14] = E3x3Seed / ESeed;
954  vals[15] = E5x5Seed / ESeed;
955  vals[16] = see;
956  vals[17] = spp;
957  vals[18] = sep;
958  vals[19] = EMaxSeed / ESeed;
959  vals[20] = E2ndSeed / ESeed;
960  vals[21] = ETopSeed / ESeed;
961  vals[22] = EBottomSeed / ESeed;
962  vals[23] = ELeftSeed / ESeed;
963  vals[24] = ERightSeed / ESeed;
964  vals[25] = E2x5MaxSeed / ESeed;
965  vals[26] = E2x5TopSeed / ESeed;
966  vals[27] = E2x5BottomSeed / ESeed;
967  vals[28] = E2x5LeftSeed / ESeed;
968  vals[29] = E2x5RightSeed / ESeed;
969  vals[30] = IsEcalDriven;
970  vals[31] = IEtaSeed;
971  vals[32] = IPhiSeed;
972  vals[33] = ((int)IEtaSeed) % 5;
973  vals[34] = ((int)IPhiSeed) % 2;
974  vals[35] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
975  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
976  vals[36] = ((int)IPhiSeed) % 20;
977  vals[37] = EtaCrySeed;
978  vals[38] = PhiCrySeed;
979  } else { // Endcap
980  vals[0] = SCRawEnergy;
981  vals[1] = scEta;
982  vals[2] = scPhi;
983  vals[3] = R9;
984  vals[4] = E5x5Seed / SCRawEnergy;
985  vals[5] = etawidth;
986  vals[6] = phiwidth;
987  vals[7] = NClusters;
988  vals[8] = HoE;
989  vals[9] = rho;
990  vals[10] = vertices;
991  vals[11] = EtaSeed - scEta;
992  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
993  vals[13] = ESeed / SCRawEnergy;
994  vals[14] = E3x3Seed / ESeed;
995  vals[15] = E5x5Seed / ESeed;
996  vals[16] = see;
997  vals[17] = spp;
998  vals[18] = sep;
999  vals[19] = EMaxSeed / ESeed;
1000  vals[20] = E2ndSeed / ESeed;
1001  vals[21] = ETopSeed / ESeed;
1002  vals[22] = EBottomSeed / ESeed;
1003  vals[23] = ELeftSeed / ESeed;
1004  vals[24] = ERightSeed / ESeed;
1005  vals[25] = E2x5MaxSeed / ESeed;
1006  vals[26] = E2x5TopSeed / ESeed;
1007  vals[27] = E2x5BottomSeed / ESeed;
1008  vals[28] = E2x5LeftSeed / ESeed;
1009  vals[29] = E2x5RightSeed / ESeed;
1010  vals[30] = IsEcalDriven;
1011  vals[31] = PreShowerOverRaw;
1012  }
1013 
1014  // Now evaluating the regression
1015  double regressionResult = 0;
1016  Int_t BinIndex = -1;
1017 
1018  if (fVersionType == kNoTrkVarV1) {
1019  if (std::abs(scEta) <= 1.479) {
1020  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
1021  BinIndex = 0;
1022  } else {
1023  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
1024  BinIndex = 1;
1025  }
1026  }
1027 
1028  //print debug
1029  if (printDebug) {
1030  if (std::abs(scEta) <= 1.479) {
1031  std::cout << "Barrel :";
1032  for (unsigned int v = 0; v < 39; ++v)
1033  std::cout << vals[v] << ", ";
1034  std::cout << "\n";
1035  } else {
1036  std::cout << "Endcap :";
1037  for (unsigned int v = 0; v < 32; ++v)
1038  std::cout << vals[v] << ", ";
1039  std::cout << "\n";
1040  }
1041  std::cout << "BinIndex : " << BinIndex << "\n";
1042  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
1043  std::cout << "regression energy = " << regressionResult << std::endl;
1044  }
1045 
1046  // Cleaning up and returning
1047  delete[] vals;
1048  return regressionResult;
1049 }

References funct::abs(), funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kNoTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergy().

◆ regressionValueWithSubClusters()

double ElectronEnergyRegressionEvaluate::regressionValueWithSubClusters ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
double  isEcalDriven,
double  isEtaGap,
double  isPhiGap,
double  isDeeGap,
double  ESubs,
double  ESub1,
double  EtaSub1,
double  PhiSub1,
double  EMaxSub1,
double  E3x3Sub1,
double  ESub2,
double  EtaSub2,
double  PhiSub2,
double  EMaxSub2,
double  E3x3Sub2,
double  ESub3,
double  EtaSub3,
double  PhiSub3,
double  EMaxSub3,
double  E3x3Sub3,
double  NPshwClusters,
double  EPshwSubs,
double  EPshwSub1,
double  EtaPshwSub1,
double  PhiPshwSub1,
double  EPshwSub2,
double  EtaPshwSub2,
double  PhiPshwSub2,
double  EPshwSub3,
double  EtaPshwSub3,
double  PhiPshwSub3,
bool  isEB,
bool  printDebug = false 
)

Definition at line 3077 of file ElectronEnergyRegressionEvaluate.cc.

3143  {
3144  // Checking if instance has been initialized
3145  if (fIsInitialized == kFALSE) {
3146  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
3147  return 0;
3148  }
3149 
3150  // Checking if type is correct
3151  if (!(fVersionType == kWithSubCluVar)) {
3152  std::cout << "Error: Regression VersionType " << fVersionType
3153  << " is not supported to use function regressionValueWithSubClusters.\n";
3154  return 0;
3155  }
3156 
3157  // Now applying regression according to version and (endcap/barrel)
3158  float *vals = (isEB) ? new float[61] : new float[65];
3159  if (isEB) { // Barrel
3160  vals[0] = rho;
3161  vals[1] = vertices;
3162  vals[2] = isEcalDriven;
3163  vals[3] = isEtaGap;
3164  vals[4] = isPhiGap;
3165  vals[5] = isDeeGap;
3166  vals[6] = SCRawEnergy;
3167  vals[7] = scEta;
3168  vals[8] = scPhi;
3169  vals[9] = R9;
3170  vals[10] = etawidth;
3171  vals[11] = phiwidth;
3172  vals[12] = NClusters;
3173  vals[13] = HoE;
3174  vals[14] = EtaSeed - scEta;
3175  vals[15] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
3176  vals[16] = ESeed / SCRawEnergy;
3177  vals[17] = E3x3Seed / ESeed;
3178  vals[18] = E5x5Seed / SCRawEnergy;
3179  vals[19] = E5x5Seed / ESeed;
3180  vals[20] = EMaxSeed / ESeed;
3181  vals[21] = E2ndSeed / ESeed;
3182  vals[22] = ETopSeed / ESeed;
3183  vals[23] = EBottomSeed / ESeed;
3184  vals[24] = ELeftSeed / ESeed;
3185  vals[25] = ERightSeed / ESeed;
3186  vals[26] = E2x5MaxSeed / ESeed;
3187  vals[27] = E2x5TopSeed / ESeed;
3188  vals[28] = E2x5BottomSeed / ESeed;
3189  vals[29] = E2x5LeftSeed / ESeed;
3190  vals[30] = E2x5RightSeed / ESeed;
3191  vals[31] = see;
3192  vals[32] = spp;
3193  vals[33] = sep;
3194  vals[34] = phiwidth / etawidth;
3195  vals[35] = (ELeftSeed + ERightSeed == 0. ? 0. : (ELeftSeed - ERightSeed) / (ELeftSeed + ERightSeed));
3196  vals[36] = (ETopSeed + EBottomSeed == 0. ? 0. : (ETopSeed - EBottomSeed) / (ETopSeed + EBottomSeed));
3197  vals[37] = ESubs / SCRawEnergy;
3198  vals[38] = ESub1 / SCRawEnergy;
3199  vals[39] = (NClusters <= 1 ? 999. : EtaSub1 - EtaSeed);
3200  vals[40] = (NClusters <= 1 ? 999. : atan2(sin(PhiSub1 - PhiSeed), cos(PhiSub1 - PhiSeed)));
3201  vals[41] = (NClusters <= 1 ? 0. : EMaxSub1 / ESub1);
3202  vals[42] = (NClusters <= 1 ? 0. : E3x3Sub1 / ESub1);
3203  vals[43] = ESub2 / SCRawEnergy;
3204  vals[44] = (NClusters <= 2 ? 999. : EtaSub2 - EtaSeed);
3205  vals[45] = (NClusters <= 2 ? 999. : atan2(sin(PhiSub2 - PhiSeed), cos(PhiSub2 - PhiSeed)));
3206  vals[46] = (NClusters <= 2 ? 0. : EMaxSub2 / ESub2);
3207  vals[47] = (NClusters <= 2 ? 0. : E3x3Sub2 / ESub2);
3208  vals[48] = ESub3 / SCRawEnergy;
3209  vals[49] = (NClusters <= 3 ? 999. : EtaSub3 - EtaSeed);
3210  vals[50] = (NClusters <= 3 ? 999. : atan2(sin(PhiSub3 - PhiSeed), cos(PhiSub3 - PhiSeed)));
3211  vals[51] = (NClusters <= 3 ? 0. : EMaxSub3 / ESub3);
3212  vals[52] = (NClusters <= 3 ? 0. : E3x3Sub3 / ESub3);
3213  vals[53] = IEtaSeed;
3214  vals[54] = ((int)IEtaSeed) % 5;
3215  vals[55] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
3216  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
3217  vals[56] = IPhiSeed;
3218  vals[57] = ((int)IPhiSeed) % 2;
3219  vals[58] = ((int)IPhiSeed) % 20;
3220  vals[59] = EtaCrySeed;
3221  vals[60] = PhiCrySeed;
3222  } else { // Endcap
3223  vals[0] = rho;
3224  vals[1] = vertices;
3225  vals[2] = isEcalDriven;
3226  vals[3] = isEtaGap;
3227  vals[4] = isPhiGap;
3228  vals[5] = isDeeGap;
3229  vals[6] = SCRawEnergy;
3230  vals[7] = scEta;
3231  vals[8] = scPhi;
3232  vals[9] = R9;
3233  vals[10] = etawidth;
3234  vals[11] = phiwidth;
3235  vals[12] = NClusters;
3236  vals[13] = HoE;
3237  vals[14] = EtaSeed - scEta;
3238  vals[15] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
3239  vals[16] = ESeed / SCRawEnergy;
3240  vals[17] = E3x3Seed / ESeed;
3241  vals[18] = E5x5Seed / SCRawEnergy;
3242  vals[19] = E5x5Seed / ESeed;
3243  vals[20] = EMaxSeed / ESeed;
3244  vals[21] = E2ndSeed / ESeed;
3245  vals[22] = ETopSeed / ESeed;
3246  vals[23] = EBottomSeed / ESeed;
3247  vals[24] = ELeftSeed / ESeed;
3248  vals[25] = ERightSeed / ESeed;
3249  vals[26] = E2x5MaxSeed / ESeed;
3250  vals[27] = E2x5TopSeed / ESeed;
3251  vals[28] = E2x5BottomSeed / ESeed;
3252  vals[29] = E2x5LeftSeed / ESeed;
3253  vals[30] = E2x5RightSeed / ESeed;
3254  vals[31] = see;
3255  vals[32] = spp;
3256  vals[33] = sep;
3257  vals[34] = phiwidth / etawidth;
3258  vals[35] = (ELeftSeed + ERightSeed == 0. ? 0. : (ELeftSeed - ERightSeed) / (ELeftSeed + ERightSeed));
3259  vals[36] = (ETopSeed + EBottomSeed == 0. ? 0. : (ETopSeed - EBottomSeed) / (ETopSeed + EBottomSeed));
3260  vals[37] = ESubs / SCRawEnergy;
3261  vals[38] = ESub1 / SCRawEnergy;
3262  vals[39] = (NClusters <= 1 ? 999. : EtaSub1 - EtaSeed);
3263  vals[40] = (NClusters <= 1 ? 999. : atan2(sin(PhiSub1 - PhiSeed), cos(PhiSub1 - PhiSeed)));
3264  vals[41] = (NClusters <= 1 ? 0. : EMaxSub1 / ESub1);
3265  vals[42] = (NClusters <= 1 ? 0. : E3x3Sub1 / ESub1);
3266  vals[43] = ESub2 / SCRawEnergy;
3267  vals[44] = (NClusters <= 2 ? 999. : EtaSub2 - EtaSeed);
3268  vals[45] = (NClusters <= 2 ? 999. : atan2(sin(PhiSub2 - PhiSeed), cos(PhiSub2 - PhiSeed)));
3269  vals[46] = (NClusters <= 2 ? 0. : EMaxSub2 / ESub2);
3270  vals[47] = (NClusters <= 2 ? 0. : E3x3Sub2 / ESub2);
3271  vals[48] = ESub3 / SCRawEnergy;
3272  vals[49] = (NClusters <= 3 ? 999. : EtaSub3 - EtaSeed);
3273  vals[50] = (NClusters <= 3 ? 999. : atan2(sin(PhiSub3 - PhiSeed), cos(PhiSub3 - PhiSeed)));
3274  vals[51] = (NClusters <= 3 ? 0. : EMaxSub3 / ESub3);
3275  vals[52] = (NClusters <= 3 ? 0. : E3x3Sub3 / ESub3);
3276  vals[53] = PreShowerOverRaw;
3277  vals[54] = NPshwClusters;
3278  vals[55] = EPshwSubs / SCRawEnergy;
3279  vals[56] = EPshwSub1 / SCRawEnergy;
3280  vals[57] = (NPshwClusters == 0 ? 999. : EtaPshwSub1 - EtaSeed);
3281  vals[58] = (NPshwClusters == 0 ? 999. : atan2(sin(PhiPshwSub1 - PhiSeed), cos(PhiPshwSub1 - PhiSeed)));
3282  vals[59] = EPshwSub2 / SCRawEnergy;
3283  vals[60] = (NPshwClusters <= 1 ? 999. : EtaPshwSub2 - EtaSeed);
3284  vals[61] = (NPshwClusters <= 1 ? 999. : atan2(sin(PhiPshwSub2 - PhiSeed), cos(PhiPshwSub2 - PhiSeed)));
3285  vals[62] = EPshwSub3 / SCRawEnergy;
3286  vals[63] = (NPshwClusters <= 2 ? 999. : EtaPshwSub3 - EtaSeed);
3287  vals[64] = (NPshwClusters <= 2 ? 999. : atan2(sin(PhiPshwSub3 - PhiSeed), cos(PhiPshwSub3 - PhiSeed)));
3288  }
3289 
3290  // Now evaluating the regression
3291  double regressionResult = 0;
3292  Int_t BinIndex = -1;
3293 
3294  if (fVersionType == kWithSubCluVar) {
3295  if (isEB) {
3296  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
3297  BinIndex = 0;
3298  } else {
3299  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
3300  BinIndex = 1;
3301  }
3302  }
3303 
3304  //print debug
3305  if (printDebug) {
3306  if (isEB) {
3307  std::cout << "Barrel :";
3308  for (unsigned int v = 0; v < 61; ++v)
3309  std::cout << v << "=" << vals[v] << ", ";
3310  std::cout << "\n";
3311  } else {
3312  std::cout << "Endcap :";
3313  for (unsigned int v = 0; v < 65; ++v)
3314  std::cout << v << "=" << vals[v] << ", ";
3315  std::cout << "\n";
3316  }
3317  std::cout << "BinIndex : " << BinIndex << "\n";
3318  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
3319  std::cout << "regression energy = " << regressionResult << std::endl;
3320  }
3321 
3322  // Cleaning up and returning
3323  delete[] vals;
3324  return regressionResult;
3325 }

References funct::abs(), funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithSubCluVar, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergy(), and RegressionEnergyPatElectronProducer::produce().

◆ regressionValueWithTrkVar()

double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVar ( double  electronP,
double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  pt,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
bool  printDebug = false 
)

Definition at line 1217 of file ElectronEnergyRegressionEvaluate.cc.

1257  {
1258  // Checking if instance has been initialized
1259  if (fIsInitialized == kFALSE) {
1260  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1261  return 0;
1262  }
1263 
1264  // Checking if fVersionType is correct
1265  assert(fVersionType == kWithTrkVar);
1266 
1267  float *vals = (std::abs(scEta) <= 1.479) ? new float[43] : new float[36];
1268  if (std::abs(scEta) <= 1.479) { // Barrel
1269  vals[0] = SCRawEnergy;
1270  vals[1] = scEta;
1271  vals[2] = scPhi;
1272  vals[3] = R9;
1273  vals[4] = E5x5Seed / SCRawEnergy;
1274  vals[5] = etawidth;
1275  vals[6] = phiwidth;
1276  vals[7] = NClusters;
1277  vals[8] = HoE;
1278  vals[9] = rho;
1279  vals[10] = vertices;
1280  vals[11] = EtaSeed - scEta;
1281  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1282  vals[13] = ESeed / SCRawEnergy;
1283  vals[14] = E3x3Seed / ESeed;
1284  vals[15] = E5x5Seed / ESeed;
1285  vals[16] = see;
1286  vals[17] = spp;
1287  vals[18] = sep;
1288  vals[19] = EMaxSeed / ESeed;
1289  vals[20] = E2ndSeed / ESeed;
1290  vals[21] = ETopSeed / ESeed;
1291  vals[22] = EBottomSeed / ESeed;
1292  vals[23] = ELeftSeed / ESeed;
1293  vals[24] = ERightSeed / ESeed;
1294  vals[25] = E2x5MaxSeed / ESeed;
1295  vals[26] = E2x5TopSeed / ESeed;
1296  vals[27] = E2x5BottomSeed / ESeed;
1297  vals[28] = E2x5LeftSeed / ESeed;
1298  vals[29] = E2x5RightSeed / ESeed;
1299  vals[30] = pt;
1300  vals[31] = GsfTrackPIn;
1301  vals[32] = fbrem;
1302  vals[33] = Charge;
1303  vals[34] = EoP;
1304  vals[35] = IEtaSeed;
1305  vals[36] = IPhiSeed;
1306  vals[37] = ((int)IEtaSeed) % 5;
1307  vals[38] = ((int)IPhiSeed) % 2;
1308  vals[39] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
1309  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
1310  vals[40] = ((int)IPhiSeed) % 20;
1311  vals[41] = EtaCrySeed;
1312  vals[42] = PhiCrySeed;
1313  }
1314 
1315  else { // Endcap
1316  vals[0] = SCRawEnergy;
1317  vals[1] = scEta;
1318  vals[2] = scPhi;
1319  vals[3] = R9;
1320  vals[4] = E5x5Seed / SCRawEnergy;
1321  vals[5] = etawidth;
1322  vals[6] = phiwidth;
1323  vals[7] = NClusters;
1324  vals[8] = HoE;
1325  vals[9] = rho;
1326  vals[10] = vertices;
1327  vals[11] = EtaSeed - scEta;
1328  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1329  vals[13] = ESeed / SCRawEnergy;
1330  vals[14] = E3x3Seed / ESeed;
1331  vals[15] = E5x5Seed / ESeed;
1332  vals[16] = see;
1333  vals[17] = spp;
1334  vals[18] = sep;
1335  vals[19] = EMaxSeed / ESeed;
1336  vals[20] = E2ndSeed / ESeed;
1337  vals[21] = ETopSeed / ESeed;
1338  vals[22] = EBottomSeed / ESeed;
1339  vals[23] = ELeftSeed / ESeed;
1340  vals[24] = ERightSeed / ESeed;
1341  vals[25] = E2x5MaxSeed / ESeed;
1342  vals[26] = E2x5TopSeed / ESeed;
1343  vals[27] = E2x5BottomSeed / ESeed;
1344  vals[28] = E2x5LeftSeed / ESeed;
1345  vals[29] = E2x5RightSeed / ESeed;
1346  vals[30] = pt;
1347  vals[31] = GsfTrackPIn;
1348  vals[32] = fbrem;
1349  vals[33] = Charge;
1350  vals[34] = EoP;
1351  vals[35] = PreShowerOverRaw;
1352  }
1353 
1354  // Now evaluating the regression
1355  double regressionResult = 0;
1356 
1357  if (fVersionType == kWithTrkVar) {
1358  if (std::abs(scEta) <= 1.479)
1359  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
1360  else
1361  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
1362  }
1363 
1364  //print debug
1365  if (printDebug) {
1366  if (scEta <= 1.479) {
1367  std::cout << "Barrel :";
1368  for (unsigned int v = 0; v < 43; ++v)
1369  std::cout << vals[v] << ", ";
1370  std::cout << "\n";
1371  } else {
1372  std::cout << "Endcap :";
1373  for (unsigned int v = 0; v < 36; ++v)
1374  std::cout << vals[v] << ", ";
1375  std::cout << "\n";
1376  }
1377  std::cout << "pt = " << pt << " : SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw
1378  << std::endl;
1379  std::cout << "regression energy = " << regressionResult << std::endl;
1380  }
1381 
1382  // Cleaning up and returning
1383  delete[] vals;
1384  return regressionResult;
1385 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVar, HLT_FULL_cff::printDebug, DiDispStaMuonMonitor_cfi::pt, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by RegressionEnergyPatElectronProducer::produce().

◆ regressionValueWithTrkVarV1() [1/2]

double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV1 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  TrackMomentumError,
double  EcalEnergyError,
int  Classification,
bool  printDebug = false 
)

Definition at line 1559 of file ElectronEnergyRegressionEvaluate.cc.

1601  {
1602  // Checking if instance has been initialized
1603  if (fIsInitialized == kFALSE) {
1604  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1605  return 0;
1606  }
1607 
1608  // Checking if fVersionType is correct
1609  assert(fVersionType == kWithTrkVarV1);
1610 
1611  float *vals = (std::abs(scEta) <= 1.479) ? new float[46] : new float[39];
1612  if (std::abs(scEta) <= 1.479) { // Barrel
1613  vals[0] = SCRawEnergy;
1614  vals[1] = scEta;
1615  vals[2] = scPhi;
1616  vals[3] = R9;
1617  vals[4] = E5x5Seed / SCRawEnergy;
1618  vals[5] = etawidth;
1619  vals[6] = phiwidth;
1620  vals[7] = NClusters;
1621  vals[8] = HoE;
1622  vals[9] = rho;
1623  vals[10] = vertices;
1624  vals[11] = EtaSeed - scEta;
1625  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1626  vals[13] = ESeed / SCRawEnergy;
1627  vals[14] = E3x3Seed / ESeed;
1628  vals[15] = E5x5Seed / ESeed;
1629  vals[16] = see;
1630  vals[17] = spp;
1631  vals[18] = sep;
1632  vals[19] = EMaxSeed / ESeed;
1633  vals[20] = E2ndSeed / ESeed;
1634  vals[21] = ETopSeed / ESeed;
1635  vals[22] = EBottomSeed / ESeed;
1636  vals[23] = ELeftSeed / ESeed;
1637  vals[24] = ERightSeed / ESeed;
1638  vals[25] = E2x5MaxSeed / ESeed;
1639  vals[26] = E2x5TopSeed / ESeed;
1640  vals[27] = E2x5BottomSeed / ESeed;
1641  vals[28] = E2x5LeftSeed / ESeed;
1642  vals[29] = E2x5RightSeed / ESeed;
1643  vals[30] = IsEcalDriven;
1644  vals[31] = GsfTrackPIn;
1645  vals[32] = fbrem;
1646  vals[33] = Charge;
1647  vals[34] = EoP;
1648  vals[35] = TrackMomentumError / GsfTrackPIn;
1649  vals[36] = EcalEnergyError / SCRawEnergy;
1650  vals[37] = Classification;
1651  vals[38] = IEtaSeed;
1652  vals[39] = IPhiSeed;
1653  vals[40] = ((int)IEtaSeed) % 5;
1654  vals[41] = ((int)IPhiSeed) % 2;
1655  vals[42] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
1656  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
1657  vals[43] = ((int)IPhiSeed) % 20;
1658  vals[44] = EtaCrySeed;
1659  vals[45] = PhiCrySeed;
1660  }
1661 
1662  else { // Endcap
1663  vals[0] = SCRawEnergy;
1664  vals[1] = scEta;
1665  vals[2] = scPhi;
1666  vals[3] = R9;
1667  vals[4] = E5x5Seed / SCRawEnergy;
1668  vals[5] = etawidth;
1669  vals[6] = phiwidth;
1670  vals[7] = NClusters;
1671  vals[8] = HoE;
1672  vals[9] = rho;
1673  vals[10] = vertices;
1674  vals[11] = EtaSeed - scEta;
1675  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1676  vals[13] = ESeed / SCRawEnergy;
1677  vals[14] = E3x3Seed / ESeed;
1678  vals[15] = E5x5Seed / ESeed;
1679  vals[16] = see;
1680  vals[17] = spp;
1681  vals[18] = sep;
1682  vals[19] = EMaxSeed / ESeed;
1683  vals[20] = E2ndSeed / ESeed;
1684  vals[21] = ETopSeed / ESeed;
1685  vals[22] = EBottomSeed / ESeed;
1686  vals[23] = ELeftSeed / ESeed;
1687  vals[24] = ERightSeed / ESeed;
1688  vals[25] = E2x5MaxSeed / ESeed;
1689  vals[26] = E2x5TopSeed / ESeed;
1690  vals[27] = E2x5BottomSeed / ESeed;
1691  vals[28] = E2x5LeftSeed / ESeed;
1692  vals[29] = E2x5RightSeed / ESeed;
1693  vals[30] = IsEcalDriven;
1694  vals[31] = GsfTrackPIn;
1695  vals[32] = fbrem;
1696  vals[33] = Charge;
1697  vals[34] = EoP;
1698  vals[35] = TrackMomentumError / GsfTrackPIn;
1699  vals[36] = EcalEnergyError / SCRawEnergy;
1700  vals[37] = Classification;
1701  vals[38] = PreShowerOverRaw;
1702  }
1703 
1704  // Now evaluating the regression
1705  double regressionResult = 0;
1706 
1707  if (fVersionType == kWithTrkVarV1) {
1708  if (std::abs(scEta) <= 1.479)
1709  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
1710  else
1711  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
1712  }
1713 
1714  //print debug
1715  if (printDebug) {
1716  if (std::abs(scEta) <= 1.479) {
1717  std::cout << "Barrel :";
1718  for (unsigned int v = 0; v < 46; ++v)
1719  std::cout << vals[v] << ", ";
1720  std::cout << "\n";
1721  } else {
1722  std::cout << "Endcap :";
1723  for (unsigned int v = 0; v < 39; ++v)
1724  std::cout << vals[v] << ", ";
1725  std::cout << "\n";
1726  }
1727  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
1728  std::cout << "regression energy = " << regressionResult << std::endl;
1729  }
1730 
1731  // Cleaning up and returning
1732  delete[] vals;
1733  return regressionResult;
1734 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergy().

◆ regressionValueWithTrkVarV1() [2/2]

double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV1 ( std::vector< double > &  inputvars,
bool  printDebug = false 
)

Definition at line 1913 of file ElectronEnergyRegressionEvaluate.cc.

1913  {
1914  // Checking if instance has been initialized
1915  if (fIsInitialized == kFALSE) {
1916  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
1917  return 0;
1918  }
1919 
1920  // Checking if fVersionType is correct
1921  assert(fVersionType == kWithTrkVarV1);
1922 
1923  // Checking if fVersionType is correct
1924  assert(inputvars.size() == 42);
1925 
1926  double SCRawEnergy = inputvars[0];
1927  double scEta = inputvars[1];
1928  double scPhi = inputvars[2];
1929  double R9 = inputvars[3];
1930  double etawidth = inputvars[4];
1931  double phiwidth = inputvars[5];
1932  double NClusters = inputvars[6];
1933  double HoE = inputvars[7];
1934  double rho = inputvars[8];
1935  double vertices = inputvars[9];
1936  double EtaSeed = inputvars[10];
1937  double PhiSeed = inputvars[11];
1938  double ESeed = inputvars[12];
1939  double E3x3Seed = inputvars[13];
1940  double E5x5Seed = inputvars[14];
1941  double see = inputvars[15];
1942  double spp = inputvars[16];
1943  double sep = inputvars[17];
1944  double EMaxSeed = inputvars[18];
1945  double E2ndSeed = inputvars[19];
1946  double ETopSeed = inputvars[20];
1947  double EBottomSeed = inputvars[21];
1948  double ELeftSeed = inputvars[22];
1949  double ERightSeed = inputvars[23];
1950  double E2x5MaxSeed = inputvars[24];
1951  double E2x5TopSeed = inputvars[25];
1952  double E2x5BottomSeed = inputvars[26];
1953  double E2x5LeftSeed = inputvars[27];
1954  double E2x5RightSeed = inputvars[28];
1955  double IEtaSeed = inputvars[29];
1956  double IPhiSeed = inputvars[30];
1957  double EtaCrySeed = inputvars[31];
1958  double PhiCrySeed = inputvars[32];
1959  double PreShowerOverRaw = inputvars[33];
1960  int IsEcalDriven = inputvars[34];
1961  double GsfTrackPIn = inputvars[35];
1962  double fbrem = inputvars[36];
1963  double Charge = inputvars[37];
1964  double EoP = inputvars[38];
1965  double TrackMomentumError = inputvars[39];
1966  double EcalEnergyError = inputvars[40];
1967  int Classification = inputvars[41];
1968 
1969  float *vals = (std::abs(scEta) <= 1.479) ? new float[46] : new float[39];
1970  if (std::abs(scEta) <= 1.479) { // Barrel
1971  vals[0] = SCRawEnergy;
1972  vals[1] = scEta;
1973  vals[2] = scPhi;
1974  vals[3] = R9;
1975  vals[4] = E5x5Seed / SCRawEnergy;
1976  vals[5] = etawidth;
1977  vals[6] = phiwidth;
1978  vals[7] = NClusters;
1979  vals[8] = HoE;
1980  vals[9] = rho;
1981  vals[10] = vertices;
1982  vals[11] = EtaSeed - scEta;
1983  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
1984  vals[13] = ESeed / SCRawEnergy;
1985  vals[14] = E3x3Seed / ESeed;
1986  vals[15] = E5x5Seed / ESeed;
1987  vals[16] = see;
1988  vals[17] = spp;
1989  vals[18] = sep;
1990  vals[19] = EMaxSeed / ESeed;
1991  vals[20] = E2ndSeed / ESeed;
1992  vals[21] = ETopSeed / ESeed;
1993  vals[22] = EBottomSeed / ESeed;
1994  vals[23] = ELeftSeed / ESeed;
1995  vals[24] = ERightSeed / ESeed;
1996  vals[25] = E2x5MaxSeed / ESeed;
1997  vals[26] = E2x5TopSeed / ESeed;
1998  vals[27] = E2x5BottomSeed / ESeed;
1999  vals[28] = E2x5LeftSeed / ESeed;
2000  vals[29] = E2x5RightSeed / ESeed;
2001  vals[30] = IsEcalDriven;
2002  vals[31] = GsfTrackPIn;
2003  vals[32] = fbrem;
2004  vals[33] = Charge;
2005  vals[34] = EoP;
2006  vals[35] = TrackMomentumError / GsfTrackPIn;
2007  vals[36] = EcalEnergyError / SCRawEnergy;
2008  vals[37] = Classification;
2009  vals[38] = IEtaSeed;
2010  vals[39] = IPhiSeed;
2011  vals[40] = ((int)IEtaSeed) % 5;
2012  vals[41] = ((int)IPhiSeed) % 2;
2013  vals[42] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2014  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2015  vals[43] = ((int)IPhiSeed) % 20;
2016  vals[44] = EtaCrySeed;
2017  vals[45] = PhiCrySeed;
2018  }
2019 
2020  else { // Endcap
2021  vals[0] = SCRawEnergy;
2022  vals[1] = scEta;
2023  vals[2] = scPhi;
2024  vals[3] = R9;
2025  vals[4] = E5x5Seed / SCRawEnergy;
2026  vals[5] = etawidth;
2027  vals[6] = phiwidth;
2028  vals[7] = NClusters;
2029  vals[8] = HoE;
2030  vals[9] = rho;
2031  vals[10] = vertices;
2032  vals[11] = EtaSeed - scEta;
2033  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2034  vals[13] = ESeed / SCRawEnergy;
2035  vals[14] = E3x3Seed / ESeed;
2036  vals[15] = E5x5Seed / ESeed;
2037  vals[16] = see;
2038  vals[17] = spp;
2039  vals[18] = sep;
2040  vals[19] = EMaxSeed / ESeed;
2041  vals[20] = E2ndSeed / ESeed;
2042  vals[21] = ETopSeed / ESeed;
2043  vals[22] = EBottomSeed / ESeed;
2044  vals[23] = ELeftSeed / ESeed;
2045  vals[24] = ERightSeed / ESeed;
2046  vals[25] = E2x5MaxSeed / ESeed;
2047  vals[26] = E2x5TopSeed / ESeed;
2048  vals[27] = E2x5BottomSeed / ESeed;
2049  vals[28] = E2x5LeftSeed / ESeed;
2050  vals[29] = E2x5RightSeed / ESeed;
2051  vals[30] = IsEcalDriven;
2052  vals[31] = GsfTrackPIn;
2053  vals[32] = fbrem;
2054  vals[33] = Charge;
2055  vals[34] = EoP;
2056  vals[35] = TrackMomentumError / GsfTrackPIn;
2057  vals[36] = EcalEnergyError / SCRawEnergy;
2058  vals[37] = Classification;
2059  vals[38] = PreShowerOverRaw;
2060  }
2061 
2062  // Now evaluating the regression
2063  double regressionResult = 0;
2064 
2065  if (fVersionType == kWithTrkVarV1) {
2066  if (std::abs(scEta) <= 1.479)
2067  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
2068  else
2069  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
2070  }
2071 
2072  //print debug
2073  if (printDebug) {
2074  if (std::abs(scEta) <= 1.479) {
2075  std::cout << "Barrel :";
2076  for (unsigned int v = 0; v < 46; ++v)
2077  std::cout << vals[v] << ", ";
2078  std::cout << "\n";
2079  } else {
2080  std::cout << "Endcap :";
2081  for (unsigned int v = 0; v < 39; ++v)
2082  std::cout << vals[v] << ", ";
2083  std::cout << "\n";
2084  }
2085  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
2086  std::cout << "regression energy = " << regressionResult << std::endl;
2087  }
2088 
2089  // Cleaning up and returning
2090  delete[] vals;
2091  return regressionResult;
2092 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV1, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

◆ regressionValueWithTrkVarV2() [1/2]

double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2 ( double  SCRawEnergy,
double  scEta,
double  scPhi,
double  R9,
double  etawidth,
double  phiwidth,
double  NClusters,
double  HoE,
double  rho,
double  vertices,
double  EtaSeed,
double  PhiSeed,
double  ESeed,
double  E3x3Seed,
double  E5x5Seed,
double  see,
double  spp,
double  sep,
double  EMaxSeed,
double  E2ndSeed,
double  ETopSeed,
double  EBottomSeed,
double  ELeftSeed,
double  ERightSeed,
double  E2x5MaxSeed,
double  E2x5TopSeed,
double  E2x5BottomSeed,
double  E2x5LeftSeed,
double  E2x5RightSeed,
double  IEtaSeed,
double  IPhiSeed,
double  EtaCrySeed,
double  PhiCrySeed,
double  PreShowerOverRaw,
int  IsEcalDriven,
double  GsfTrackPIn,
double  fbrem,
double  Charge,
double  EoP,
double  TrackMomentumError,
double  EcalEnergyError,
int  Classification,
double  detaIn,
double  dphiIn,
double  detaCalo,
double  dphiCalo,
double  GsfTrackChiSqr,
double  KFTrackNLayers,
double  ElectronEnergyOverPout,
bool  printDebug = false 
)

Definition at line 2276 of file ElectronEnergyRegressionEvaluate.cc.

2325  {
2326  // Checking if instance has been initialized
2327  if (fIsInitialized == kFALSE) {
2328  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
2329  return 0;
2330  }
2331 
2332  // Checking if fVersionType is correct
2333  assert(fVersionType == kWithTrkVarV2);
2334 
2335  float *vals = (std::abs(scEta) <= 1.479) ? new float[53] : new float[46];
2336  if (std::abs(scEta) <= 1.479) { // Barrel
2337  vals[0] = SCRawEnergy;
2338  vals[1] = scEta;
2339  vals[2] = scPhi;
2340  vals[3] = R9;
2341  vals[4] = E5x5Seed / SCRawEnergy;
2342  vals[5] = etawidth;
2343  vals[6] = phiwidth;
2344  vals[7] = NClusters;
2345  vals[8] = HoE;
2346  vals[9] = rho;
2347  vals[10] = vertices;
2348  vals[11] = EtaSeed - scEta;
2349  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2350  vals[13] = ESeed / SCRawEnergy;
2351  vals[14] = E3x3Seed / ESeed;
2352  vals[15] = E5x5Seed / ESeed;
2353  vals[16] = see;
2354  vals[17] = spp;
2355  vals[18] = sep;
2356  vals[19] = EMaxSeed / ESeed;
2357  vals[20] = E2ndSeed / ESeed;
2358  vals[21] = ETopSeed / ESeed;
2359  vals[22] = EBottomSeed / ESeed;
2360  vals[23] = ELeftSeed / ESeed;
2361  vals[24] = ERightSeed / ESeed;
2362  vals[25] = E2x5MaxSeed / ESeed;
2363  vals[26] = E2x5TopSeed / ESeed;
2364  vals[27] = E2x5BottomSeed / ESeed;
2365  vals[28] = E2x5LeftSeed / ESeed;
2366  vals[29] = E2x5RightSeed / ESeed;
2367  vals[30] = IsEcalDriven;
2368  vals[31] = GsfTrackPIn;
2369  vals[32] = fbrem;
2370  vals[33] = Charge;
2371  vals[34] = EoP;
2372  vals[35] = TrackMomentumError / GsfTrackPIn;
2373  vals[36] = EcalEnergyError / SCRawEnergy;
2374  vals[37] = Classification;
2375  vals[38] = detaIn;
2376  vals[39] = dphiIn;
2377  vals[40] = detaCalo;
2378  vals[41] = dphiCalo;
2379  vals[42] = GsfTrackChiSqr;
2380  vals[43] = KFTrackNLayers;
2381  vals[44] = ElectronEnergyOverPout;
2382  vals[45] = IEtaSeed;
2383  vals[46] = IPhiSeed;
2384  vals[47] = ((int)IEtaSeed) % 5;
2385  vals[48] = ((int)IPhiSeed) % 2;
2386  vals[49] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2387  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2388  vals[50] = ((int)IPhiSeed) % 20;
2389  vals[51] = EtaCrySeed;
2390  vals[52] = PhiCrySeed;
2391  }
2392 
2393  else { // Endcap
2394  vals[0] = SCRawEnergy;
2395  vals[1] = scEta;
2396  vals[2] = scPhi;
2397  vals[3] = R9;
2398  vals[4] = E5x5Seed / SCRawEnergy;
2399  vals[5] = etawidth;
2400  vals[6] = phiwidth;
2401  vals[7] = NClusters;
2402  vals[8] = HoE;
2403  vals[9] = rho;
2404  vals[10] = vertices;
2405  vals[11] = EtaSeed - scEta;
2406  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2407  vals[13] = ESeed / SCRawEnergy;
2408  vals[14] = E3x3Seed / ESeed;
2409  vals[15] = E5x5Seed / ESeed;
2410  vals[16] = see;
2411  vals[17] = spp;
2412  vals[18] = sep;
2413  vals[19] = EMaxSeed / ESeed;
2414  vals[20] = E2ndSeed / ESeed;
2415  vals[21] = ETopSeed / ESeed;
2416  vals[22] = EBottomSeed / ESeed;
2417  vals[23] = ELeftSeed / ESeed;
2418  vals[24] = ERightSeed / ESeed;
2419  vals[25] = E2x5MaxSeed / ESeed;
2420  vals[26] = E2x5TopSeed / ESeed;
2421  vals[27] = E2x5BottomSeed / ESeed;
2422  vals[28] = E2x5LeftSeed / ESeed;
2423  vals[29] = E2x5RightSeed / ESeed;
2424  vals[30] = IsEcalDriven;
2425  vals[31] = GsfTrackPIn;
2426  vals[32] = fbrem;
2427  vals[33] = Charge;
2428  vals[34] = EoP;
2429  vals[35] = TrackMomentumError / GsfTrackPIn;
2430  vals[36] = EcalEnergyError / SCRawEnergy;
2431  vals[37] = Classification;
2432  vals[38] = detaIn;
2433  vals[39] = dphiIn;
2434  vals[40] = detaCalo;
2435  vals[41] = dphiCalo;
2436  vals[42] = GsfTrackChiSqr;
2437  vals[43] = KFTrackNLayers;
2438  vals[44] = ElectronEnergyOverPout;
2439  vals[45] = PreShowerOverRaw;
2440  }
2441 
2442  // Now evaluating the regression
2443  double regressionResult = 0;
2444 
2445  if (fVersionType == kWithTrkVarV2) {
2446  if (std::abs(scEta) <= 1.479)
2447  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
2448  else
2449  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
2450  }
2451 
2452  //print debug
2453  if (printDebug) {
2454  if (std::abs(scEta) <= 1.479) {
2455  std::cout << "Barrel :";
2456  for (unsigned int v = 0; v < 53; ++v)
2457  std::cout << vals[v] << ", ";
2458  std::cout << "\n";
2459  } else {
2460  std::cout << "Endcap :";
2461  for (unsigned int v = 0; v < 46; ++v)
2462  std::cout << vals[v] << ", ";
2463  std::cout << "\n";
2464  }
2465  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
2466  std::cout << "regression energy = " << regressionResult << std::endl;
2467  }
2468 
2469  // Cleaning up and returning
2470  delete[] vals;
2471  return regressionResult;
2472 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV2, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Referenced by calculateRegressionEnergy().

◆ regressionValueWithTrkVarV2() [2/2]

double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2 ( std::vector< double > &  inputvars,
bool  printDebug = false 
)

Definition at line 2672 of file ElectronEnergyRegressionEvaluate.cc.

2672  {
2673  // Checking if instance has been initialized
2674  if (fIsInitialized == kFALSE) {
2675  printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
2676  return 0;
2677  }
2678 
2679  // Checking if fVersionType is correct
2680  assert(fVersionType == kWithTrkVarV2);
2681 
2682  // Checking if fVersionType is correct
2683  assert(inputvars.size() == 49);
2684 
2685  double SCRawEnergy = inputvars[0];
2686  double scEta = inputvars[1];
2687  double scPhi = inputvars[2];
2688  double R9 = inputvars[3];
2689  double etawidth = inputvars[4];
2690  double phiwidth = inputvars[5];
2691  double NClusters = inputvars[6];
2692  double HoE = inputvars[7];
2693  double rho = inputvars[8];
2694  double vertices = inputvars[9];
2695  double EtaSeed = inputvars[10];
2696  double PhiSeed = inputvars[11];
2697  double ESeed = inputvars[12];
2698  double E3x3Seed = inputvars[13];
2699  double E5x5Seed = inputvars[14];
2700  double see = inputvars[15];
2701  double spp = inputvars[16];
2702  double sep = inputvars[17];
2703  double EMaxSeed = inputvars[18];
2704  double E2ndSeed = inputvars[19];
2705  double ETopSeed = inputvars[20];
2706  double EBottomSeed = inputvars[21];
2707  double ELeftSeed = inputvars[22];
2708  double ERightSeed = inputvars[23];
2709  double E2x5MaxSeed = inputvars[24];
2710  double E2x5TopSeed = inputvars[25];
2711  double E2x5BottomSeed = inputvars[26];
2712  double E2x5LeftSeed = inputvars[27];
2713  double E2x5RightSeed = inputvars[28];
2714  double IEtaSeed = inputvars[29];
2715  double IPhiSeed = inputvars[30];
2716  double EtaCrySeed = inputvars[31];
2717  double PhiCrySeed = inputvars[32];
2718  double PreShowerOverRaw = inputvars[33];
2719  int IsEcalDriven = inputvars[34];
2720  double GsfTrackPIn = inputvars[35];
2721  double fbrem = inputvars[36];
2722  double Charge = inputvars[37];
2723  double EoP = inputvars[38];
2724  double TrackMomentumError = inputvars[39];
2725  double EcalEnergyError = inputvars[40];
2726  int Classification = inputvars[41];
2727  double detaIn = inputvars[42];
2728  double dphiIn = inputvars[43];
2729  double detaCalo = inputvars[44];
2730  double dphiCalo = inputvars[45];
2731  double GsfTrackChiSqr = inputvars[46];
2732  double KFTrackNLayers = inputvars[47];
2733  double ElectronEnergyOverPout = inputvars[48];
2734 
2735  float *vals = (std::abs(scEta) <= 1.479) ? new float[53] : new float[46];
2736  if (std::abs(scEta) <= 1.479) { // Barrel
2737  vals[0] = SCRawEnergy;
2738  vals[1] = scEta;
2739  vals[2] = scPhi;
2740  vals[3] = R9;
2741  vals[4] = E5x5Seed / SCRawEnergy;
2742  vals[5] = etawidth;
2743  vals[6] = phiwidth;
2744  vals[7] = NClusters;
2745  vals[8] = HoE;
2746  vals[9] = rho;
2747  vals[10] = vertices;
2748  vals[11] = EtaSeed - scEta;
2749  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2750  vals[13] = ESeed / SCRawEnergy;
2751  vals[14] = E3x3Seed / ESeed;
2752  vals[15] = E5x5Seed / ESeed;
2753  vals[16] = see;
2754  vals[17] = spp;
2755  vals[18] = sep;
2756  vals[19] = EMaxSeed / ESeed;
2757  vals[20] = E2ndSeed / ESeed;
2758  vals[21] = ETopSeed / ESeed;
2759  vals[22] = EBottomSeed / ESeed;
2760  vals[23] = ELeftSeed / ESeed;
2761  vals[24] = ERightSeed / ESeed;
2762  vals[25] = E2x5MaxSeed / ESeed;
2763  vals[26] = E2x5TopSeed / ESeed;
2764  vals[27] = E2x5BottomSeed / ESeed;
2765  vals[28] = E2x5LeftSeed / ESeed;
2766  vals[29] = E2x5RightSeed / ESeed;
2767  vals[30] = IsEcalDriven;
2768  vals[31] = GsfTrackPIn;
2769  vals[32] = fbrem;
2770  vals[33] = Charge;
2771  vals[34] = EoP;
2772  vals[35] = TrackMomentumError / GsfTrackPIn;
2773  vals[36] = EcalEnergyError / SCRawEnergy;
2774  vals[37] = Classification;
2775  vals[38] = detaIn;
2776  vals[39] = dphiIn;
2777  vals[40] = detaCalo;
2778  vals[41] = dphiCalo;
2779  vals[42] = GsfTrackChiSqr;
2780  vals[43] = KFTrackNLayers;
2781  vals[44] = ElectronEnergyOverPout;
2782  vals[45] = IEtaSeed;
2783  vals[46] = IPhiSeed;
2784  vals[47] = ((int)IEtaSeed) % 5;
2785  vals[48] = ((int)IPhiSeed) % 2;
2786  vals[49] = (std::abs(IEtaSeed) <= 25) * (((int)IEtaSeed) % 25) +
2787  (std::abs(IEtaSeed) > 25) * (((int)(IEtaSeed - 25 * std::abs(IEtaSeed) / IEtaSeed)) % 20);
2788  vals[50] = ((int)IPhiSeed) % 20;
2789  vals[51] = EtaCrySeed;
2790  vals[52] = PhiCrySeed;
2791  }
2792 
2793  else { // Endcap
2794  vals[0] = SCRawEnergy;
2795  vals[1] = scEta;
2796  vals[2] = scPhi;
2797  vals[3] = R9;
2798  vals[4] = E5x5Seed / SCRawEnergy;
2799  vals[5] = etawidth;
2800  vals[6] = phiwidth;
2801  vals[7] = NClusters;
2802  vals[8] = HoE;
2803  vals[9] = rho;
2804  vals[10] = vertices;
2805  vals[11] = EtaSeed - scEta;
2806  vals[12] = atan2(sin(PhiSeed - scPhi), cos(PhiSeed - scPhi));
2807  vals[13] = ESeed / SCRawEnergy;
2808  vals[14] = E3x3Seed / ESeed;
2809  vals[15] = E5x5Seed / ESeed;
2810  vals[16] = see;
2811  vals[17] = spp;
2812  vals[18] = sep;
2813  vals[19] = EMaxSeed / ESeed;
2814  vals[20] = E2ndSeed / ESeed;
2815  vals[21] = ETopSeed / ESeed;
2816  vals[22] = EBottomSeed / ESeed;
2817  vals[23] = ELeftSeed / ESeed;
2818  vals[24] = ERightSeed / ESeed;
2819  vals[25] = E2x5MaxSeed / ESeed;
2820  vals[26] = E2x5TopSeed / ESeed;
2821  vals[27] = E2x5BottomSeed / ESeed;
2822  vals[28] = E2x5LeftSeed / ESeed;
2823  vals[29] = E2x5RightSeed / ESeed;
2824  vals[30] = IsEcalDriven;
2825  vals[31] = GsfTrackPIn;
2826  vals[32] = fbrem;
2827  vals[33] = Charge;
2828  vals[34] = EoP;
2829  vals[35] = TrackMomentumError / GsfTrackPIn;
2830  vals[36] = EcalEnergyError / SCRawEnergy;
2831  vals[37] = Classification;
2832  vals[38] = detaIn;
2833  vals[39] = dphiIn;
2834  vals[40] = detaCalo;
2835  vals[41] = dphiCalo;
2836  vals[42] = GsfTrackChiSqr;
2837  vals[43] = KFTrackNLayers;
2838  vals[44] = ElectronEnergyOverPout;
2839  vals[45] = PreShowerOverRaw;
2840  }
2841 
2842  // Now evaluating the regression
2843  double regressionResult = 0;
2844 
2845  if (fVersionType == kWithTrkVarV2) {
2846  if (std::abs(scEta) <= 1.479)
2847  regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
2848  else
2849  regressionResult = (SCRawEnergy * (1 + PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
2850  }
2851 
2852  //print debug
2853  if (printDebug) {
2854  if (std::abs(scEta) <= 1.479) {
2855  std::cout << "Barrel :";
2856  for (unsigned int v = 0; v < 53; ++v)
2857  std::cout << vals[v] << ", ";
2858  std::cout << "\n";
2859  } else {
2860  std::cout << "Endcap :";
2861  for (unsigned int v = 0; v < 46; ++v)
2862  std::cout << vals[v] << ", ";
2863  std::cout << "\n";
2864  }
2865  std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
2866  std::cout << "regression energy = " << regressionResult << std::endl;
2867  }
2868 
2869  // Cleaning up and returning
2870  delete[] vals;
2871  return regressionResult;
2872 }

References funct::abs(), cms::cuda::assert(), PixelTestBeamValidation_cfi::Charge, funct::cos(), gather_cfg::cout, fIsInitialized, forestCorrection_eb, forestCorrection_ee, fVersionType, GBRForest::GetResponse(), createfilelist::int, kWithTrkVarV2, HLT_FULL_cff::printDebug, rho, funct::sin(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

Member Data Documentation

◆ fIsInitialized

bool ElectronEnergyRegressionEvaluate::fIsInitialized
private

Definition at line 641 of file ElectronEnergyRegressionEvaluate.h.

Referenced by calculateRegressionEnergy(), calculateRegressionEnergyUncertainty(), initialize(), isInitialized(), regressionUncertaintyNoTrkVar(), regressionUncertaintyNoTrkVarV1(), regressionUncertaintyWithSubClusters(), regressionUncertaintyWithTrkVar(), regressionUncertaintyWithTrkVarV1(), regressionUncertaintyWithTrkVarV2(), regressionValueNoTrkVar(), regressionValueNoTrkVarV1(), regressionValueWithSubClusters(), regressionValueWithTrkVar(), regressionValueWithTrkVarV1(), and regressionValueWithTrkVarV2().

◆ forestCorrection_eb

GBRForest* ElectronEnergyRegressionEvaluate::forestCorrection_eb
private

Definition at line 643 of file ElectronEnergyRegressionEvaluate.h.

Referenced by initialize(), regressionValueNoTrkVar(), regressionValueNoTrkVarV1(), regressionValueWithSubClusters(), regressionValueWithTrkVar(), regressionValueWithTrkVarV1(), and regressionValueWithTrkVarV2().

◆ forestCorrection_ee

GBRForest* ElectronEnergyRegressionEvaluate::forestCorrection_ee
private

Definition at line 644 of file ElectronEnergyRegressionEvaluate.h.

Referenced by initialize(), regressionValueNoTrkVar(), regressionValueNoTrkVarV1(), regressionValueWithSubClusters(), regressionValueWithTrkVar(), regressionValueWithTrkVarV1(), and regressionValueWithTrkVarV2().

◆ forestUncertainty_eb

GBRForest* ElectronEnergyRegressionEvaluate::forestUncertainty_eb
private

Definition at line 646 of file ElectronEnergyRegressionEvaluate.h.

Referenced by initialize(), regressionUncertaintyNoTrkVar(), regressionUncertaintyNoTrkVarV1(), regressionUncertaintyWithSubClusters(), regressionUncertaintyWithTrkVar(), regressionUncertaintyWithTrkVarV1(), and regressionUncertaintyWithTrkVarV2().

◆ forestUncertainty_ee

GBRForest* ElectronEnergyRegressionEvaluate::forestUncertainty_ee
private

Definition at line 647 of file ElectronEnergyRegressionEvaluate.h.

Referenced by initialize(), regressionUncertaintyNoTrkVar(), regressionUncertaintyNoTrkVarV1(), regressionUncertaintyWithSubClusters(), regressionUncertaintyWithTrkVar(), regressionUncertaintyWithTrkVarV1(), and regressionUncertaintyWithTrkVarV2().

◆ fVersionType

ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType ElectronEnergyRegressionEvaluate::fVersionType
private

Definition at line 642 of file ElectronEnergyRegressionEvaluate.h.

Referenced by calculateRegressionEnergy(), calculateRegressionEnergyUncertainty(), initialize(), regressionUncertaintyNoTrkVar(), regressionUncertaintyNoTrkVarV1(), regressionUncertaintyWithSubClusters(), regressionUncertaintyWithTrkVar(), regressionUncertaintyWithTrkVarV1(), regressionUncertaintyWithTrkVarV2(), regressionValueNoTrkVar(), regressionValueNoTrkVarV1(), regressionValueWithSubClusters(), regressionValueWithTrkVar(), regressionValueWithTrkVarV1(), and regressionValueWithTrkVarV2().

reco::GsfElectron::deltaEtaSeedClusterTrackAtCalo
float deltaEtaSeedClusterTrackAtCalo() const
Definition: GsfElectron.h:233
ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1
double regressionUncertaintyWithTrkVarV1(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:1736
SuperClusterHelper::phi
float phi() const
Definition: SuperClusterHelper.h:26
SuperClusterHelper::sigmaIetaIeta
float sigmaIetaIeta() const
Definition: SuperClusterHelper.h:31
HLT_FULL_cff.printDebug
printDebug
Definition: HLT_FULL_cff.py:35519
reco::GsfElectron::isEB
bool isEB() const
Definition: GsfElectron.h:335
SuperClusterHelper::e2x5Right
float e2x5Right() const
Definition: SuperClusterHelper.h:46
reco::GsfElectron::gsfTrack
GsfTrackRef gsfTrack() const override
reference to a GsfTrack
Definition: GsfElectron.h:163
SuperClusterHelper::spp
float spp()
Definition: SuperClusterHelper.cc:124
ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVarV1
double regressionUncertaintyNoTrkVarV1(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:1051
SuperClusterHelper::subClusterE3x3
float subClusterE3x3(unsigned i) const
Definition: SuperClusterHelper.cc:164
SuperClusterHelper::etaWidth
float etaWidth() const
Definition: SuperClusterHelper.h:27
reco::GsfElectron::deltaPhiSuperClusterTrackAtVtx
float deltaPhiSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:235
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV1
double regressionValueWithTrkVarV1(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:1559
SuperClusterHelper::eRight
float eRight() const
Definition: SuperClusterHelper.h:41
contentValuesFiles.fullPath
fullPath
Definition: contentValuesFiles.py:64
SuperClusterHelper::hadronicOverEm
float hadronicOverEm() const
Definition: SuperClusterHelper.h:30
ElectronEnergyRegressionEvaluate::forestCorrection_ee
GBRForest * forestCorrection_ee
Definition: ElectronEnergyRegressionEvaluate.h:644
GBRForest
Definition: GBRForest.h:25
gather_cfg.cout
cout
Definition: gather_cfg.py:144
SuperClusterHelper::seedEnergy
float seedEnergy() const
Definition: SuperClusterHelper.h:54
SuperClusterHelper::e2x5Max
float e2x5Max() const
Definition: SuperClusterHelper.h:42
cms::cuda::assert
assert(be >=bs)
SuperClusterHelper::esClusterPhi
float esClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:176
reco::GsfElectron::deltaPhiSeedClusterTrackAtCalo
float deltaPhiSeedClusterTrackAtCalo() const
Definition: GsfElectron.h:236
ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVar
double regressionUncertaintyNoTrkVar(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:726
reco::LeafCandidate::pt
double pt() const final
transverse momentum
Definition: LeafCandidate.h:146
findQualityFiles.v
v
Definition: findQualityFiles.py:179
ElectronEnergyRegressionEvaluate::kWithTrkVarV1
Definition: ElectronEnergyRegressionEvaluate.h:40
SuperClusterHelper::nPreshowerClusters
float nPreshowerClusters() const
Definition: SuperClusterHelper.h:93
SuperClusterHelper::sep
float sep()
Definition: SuperClusterHelper.cc:129
SuperClusterHelper::iphiSeed
int iphiSeed()
Definition: SuperClusterHelper.h:59
reco::GsfElectron::fbrem
float fbrem() const
Definition: GsfElectron.h:732
SuperClusterHelper::subClusterEnergy
float subClusterEnergy(unsigned i) const
Definition: SuperClusterHelper.cc:148
ElectronEnergyRegressionEvaluate::kNoTrkVarV1
Definition: ElectronEnergyRegressionEvaluate.h:38
pfClustersFromHGC3DClusters_cfi.weightsFile
weightsFile
Definition: pfClustersFromHGC3DClusters_cfi.py:19
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
GBRForest::GetResponse
double GetResponse(const float *vector) const
Definition: GBRForest.h:49
edm::FileInPath
Definition: FileInPath.h:64
SuperClusterHelper::eMax
float eMax() const
Definition: SuperClusterHelper.h:36
SuperClusterHelper::eESClusters
float eESClusters() const
Definition: SuperClusterHelper.h:94
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2
double regressionValueWithTrkVarV2(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, double detaIn, double dphiIn, double detaCalo, double dphiCalo, double GsfTrackChiSqr, double KFTrackNLayers, double ElectronEnergyOverPout, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:2276
ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2
double regressionUncertaintyWithTrkVarV2(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, double GsfTrackPIn, double fbrem, double Charge, double EoP, double TrackMomentumError, double EcalEnergyError, int Classification, double detaIn, double dphiIn, double detaCalo, double dphiCalo, double GsfTrackChiSqr, double KFTrackNLayers, double ElectronEnergyOverPout, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:2474
SuperClusterHelper::clustersSize
float clustersSize() const
Definition: SuperClusterHelper.h:29
ElectronEnergyRegressionEvaluate::regressionValueNoTrkVar
double regressionValueNoTrkVar(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:564
reco::GsfElectron::trackMomentumAtVtx
math::XYZVectorF trackMomentumAtVtx() const
Definition: GsfElectron.h:275
reco::GsfElectron::ecalDrivenSeed
bool ecalDrivenSeed() const
Definition: GsfElectron.h:165
SuperClusterHelper::e2x5Bottom
float e2x5Bottom() const
Definition: SuperClusterHelper.h:44
reco::GsfElectron::isEEDeeGap
bool isEEDeeGap() const
Definition: GsfElectron.h:343
SuperClusterHelper::e2nd
float e2nd() const
Definition: SuperClusterHelper.h:37
reco::GsfElectron::correctedEcalEnergyError
float correctedEcalEnergyError() const
Definition: GsfElectron.h:805
ElectronEnergyRegressionEvaluate::kNoTrkVar
Definition: ElectronEnergyRegressionEvaluate.h:37
SuperClusterHelper::rawEnergy
float rawEnergy() const
Definition: SuperClusterHelper.h:24
SuperClusterHelper::phiWidth
float phiWidth() const
Definition: SuperClusterHelper.h:28
DDAxes::rho
SuperClusterHelper::esClusterEta
float esClusterEta(unsigned i) const
Definition: SuperClusterHelper.cc:172
SuperClusterHelper::e2x5Top
float e2x5Top() const
Definition: SuperClusterHelper.h:43
ElectronEnergyRegressionEvaluate::regressionValueNoTrkVarV1
double regressionValueNoTrkVarV1(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, int IsEcalDriven, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:887
ElectronEnergyRegressionEvaluate::fIsInitialized
bool fIsInitialized
Definition: ElectronEnergyRegressionEvaluate.h:641
SuperClusterHelper::eSubClusters
float eSubClusters() const
Definition: SuperClusterHelper.h:87
ElectronEnergyRegressionEvaluate::kWithSubCluVar
Definition: ElectronEnergyRegressionEvaluate.h:42
SuperClusterHelper::eta
float eta() const
Definition: SuperClusterHelper.h:25
reco::GsfElectron::deltaEtaSuperClusterTrackAtVtx
float deltaEtaSuperClusterTrackAtVtx() const
Definition: GsfElectron.h:232
ElectronEnergyRegressionEvaluate::regressionUncertaintyWithSubClusters
double regressionUncertaintyWithSubClusters(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:3327
reco::LeafCandidate::eta
double eta() const final
momentum pseudorapidity
Definition: LeafCandidate.h:152
SuperClusterHelper::e2x5Left
float e2x5Left() const
Definition: SuperClusterHelper.h:45
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
gainCalibHelper::gainCalibPI::type
type
Definition: SiPixelGainCalibHelper.h:40
createfilelist.int
int
Definition: createfilelist.py:10
SuperClusterHelper::phiCrySeed
float phiCrySeed()
Definition: SuperClusterHelper.h:67
FrontierConditions_GlobalTag_cff.file
file
Definition: FrontierConditions_GlobalTag_cff.py:13
SuperClusterHelper::seedEta
float seedEta() const
Definition: SuperClusterHelper.h:52
SuperClusterHelper::preshowerEnergyOverRaw
float preshowerEnergyOverRaw() const
Definition: SuperClusterHelper.h:33
SuperClusterHelper::esClusterEnergy
float esClusterEnergy(unsigned i) const
Definition: SuperClusterHelper.cc:168
reco::LeafCandidate::charge
int charge() const final
electric charge
Definition: LeafCandidate.h:106
reco::GsfElectron::isEBEtaGap
bool isEBEtaGap() const
Definition: GsfElectron.h:340
reco::GsfElectron::closestCtfTrackRef
virtual TrackRef closestCtfTrackRef() const
Definition: GsfElectron.h:187
SuperClusterHelper::ietaSeed
int ietaSeed()
Definition: SuperClusterHelper.h:55
ElectronEnergyRegressionEvaluate::fVersionType
ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType fVersionType
Definition: ElectronEnergyRegressionEvaluate.h:642
ElectronEnergyRegressionEvaluate::forestCorrection_eb
GBRForest * forestCorrection_eb
Definition: ElectronEnergyRegressionEvaluate.h:643
reco::LeafCandidate::phi
double phi() const final
momentum azimuthal angle
Definition: LeafCandidate.h:148
SuperClusterHelper::subClusterEmax
float subClusterEmax(unsigned i) const
Definition: SuperClusterHelper.cc:160
ElectronEnergyRegressionEvaluate::regressionValueWithSubClusters
double regressionValueWithSubClusters(double SCRawEnergy, double scEta, double scPhi, double R9, double etawidth, double phiwidth, double NClusters, double HoE, double rho, double vertices, double EtaSeed, double PhiSeed, double ESeed, double E3x3Seed, double E5x5Seed, double see, double spp, double sep, double EMaxSeed, double E2ndSeed, double ETopSeed, double EBottomSeed, double ELeftSeed, double ERightSeed, double E2x5MaxSeed, double E2x5TopSeed, double E2x5BottomSeed, double E2x5LeftSeed, double E2x5RightSeed, double IEtaSeed, double IPhiSeed, double EtaCrySeed, double PhiCrySeed, double PreShowerOverRaw, double isEcalDriven, double isEtaGap, double isPhiGap, double isDeeGap, double ESubs, double ESub1, double EtaSub1, double PhiSub1, double EMaxSub1, double E3x3Sub1, double ESub2, double EtaSub2, double PhiSub2, double EMaxSub2, double E3x3Sub2, double ESub3, double EtaSub3, double PhiSub3, double EMaxSub3, double E3x3Sub3, double NPshwClusters, double EPshwSubs, double EPshwSub1, double EtaPshwSub1, double PhiPshwSub1, double EPshwSub2, double EtaPshwSub2, double PhiPshwSub2, double EPshwSub3, double EtaPshwSub3, double PhiPshwSub3, bool isEB, bool printDebug=false)
Definition: ElectronEnergyRegressionEvaluate.cc:3077
SuperClusterHelper::subClusterPhi
float subClusterPhi(unsigned i) const
Definition: SuperClusterHelper.cc:156
reco::LeafCandidate::p
double p() const final
magnitude of momentum vector
Definition: LeafCandidate.h:123
SuperClusterHelper::e5x5
float e5x5() const
Definition: SuperClusterHelper.h:35
reco::GsfElectron::eSuperClusterOverP
float eSuperClusterOverP() const
Definition: GsfElectron.h:228
reco::GsfElectron::classification
Classification classification() const
Definition: GsfElectron.h:728
PixelTestBeamValidation_cfi.Charge
Charge
Definition: PixelTestBeamValidation_cfi.py:91
reco::GsfElectron::eEleClusterOverPout
float eEleClusterOverPout() const
Definition: GsfElectron.h:231
ElectronEnergyRegressionEvaluate::forestUncertainty_eb
GBRForest * forestUncertainty_eb
Definition: ElectronEnergyRegressionEvaluate.h:646
reco::GsfElectron::isEBPhiGap
bool isEBPhiGap() const
Definition: GsfElectron.h:341
SuperClusterHelper::eTop
float eTop() const
Definition: SuperClusterHelper.h:38
reco::GsfElectron::trackMomentumError
float trackMomentumError() const
Definition: GsfElectron.h:806
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ElectronEnergyRegressionEvaluate::kWithTrkVarV2
Definition: ElectronEnergyRegressionEvaluate.h:41
SuperClusterHelper::etaCrySeed
float etaCrySeed()
Definition: SuperClusterHelper.h:63
SuperClusterHelper::subClusterEta
float subClusterEta(unsigned i) const
Definition: SuperClusterHelper.cc:152
SuperClusterHelper::eBottom
float eBottom() const
Definition: SuperClusterHelper.h:39
SuperClusterHelper::r9
float r9() const
Definition: SuperClusterHelper.h:47
ElectronEnergyRegressionEvaluate::forestUncertainty_ee
GBRForest * forestUncertainty_ee
Definition: ElectronEnergyRegressionEvaluate.h:647
ElectronEnergyRegressionEvaluate::kWithTrkVar
Definition: ElectronEnergyRegressionEvaluate.h:39
SuperClusterHelper::seedPhi
float seedPhi() const
Definition: SuperClusterHelper.h:53
SuperClusterHelper::eLeft
float eLeft() const
Definition: SuperClusterHelper.h:40
SuperClusterHelper::e3x3
float e3x3() const
Definition: SuperClusterHelper.h:34
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
Generated for CMSSW Reference Manual by doxygen 1.8.16