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

#include <HCALResponse.h>

Public Member Functions

double getHCALEnergyResponse (double e, int hit)
 
 HCALResponse (const edm::ParameterSet &pset, const RandomEngine *engine)
 
double responseHCAL (int _mip, double energy, double eta, int partype)
 
 ~HCALResponse ()
 

Private Member Functions

double cballShootNoNegative (double mu, double sigma, double aL, double nL, double aR, double nR)
 
double gaussShootNoNegative (double e, double sigma)
 
int getDet (int ieta)
 
double interEM (double e, int ie, int ieta)
 
double interHD (int mip, double e, int ie, int ieta, int det)
 
double interMU (double e, int ie, int ieta)
 

Private Attributes

int barrelMUeta
 
DoubleCrystalBallGenerator cball
 
bool debug
 
vec1 eGridEM
 
vec1 eGridHD [3]
 
vec1 eGridMU
 
int endcapMUeta
 
double eResponseCoefficient
 
double eResponseExponent
 
double eResponsePlateau [3]
 
double eResponseScale [3]
 
vec1 etaGridMU
 
double etaStep
 
int HDeta [4]
 
int maxEMe
 
int maxEMeta
 
int maxHDe [3]
 
int maxHDetas [3]
 
int maxMUbin
 
int maxMUe
 
int maxMUeta
 
vec2 meanEM
 
double muStep
 
int nPar
 
vec5 parameters
 
std::vector< std::string > parNames
 
const RandomEngine * random
 
double respFactorEM
 
vec3 responseMU
 
double RespPar [3][2][3]
 
vec2 sigmaEM
 
bool usemip
 

Detailed Description

Definition at line 29 of file HCALResponse.h.

Constructor & Destructor Documentation

HCALResponse::HCALResponse ( const edm::ParameterSet &  pset,
const RandomEngine *  engine 
)

Definition at line 17 of file HCALResponse.cc.

References abs, barrelMUeta, debug, eGridEM, eGridHD, eGridMU, endcapMUeta, eResponseCoefficient, eResponseExponent, eResponsePlateau, eResponseScale, etaGridMU, etaStep, edm::ParameterSet::getParameter(), HCAL, HDeta, i, j, gen::k, m, maxEMe, maxEMeta, maxHDe, maxHDetas, maxMUbin, maxMUe, maxMUeta, meanEM, muStep, nPar, AlCaHLTBitMon_ParallelJobs::p, parameters, parNames, respFactorEM, responseMU, RespPar, sigmaEM, AlCaHLTBitMon_QueryRunRegistry::string, tmp, usemip, and VFCAL.

17  : random(engine), cball(random) {
18  //switches
19  debug = pset.getParameter<bool>("debug");
20  usemip = pset.getParameter<bool>("usemip");
21 
22 //values for "old" response parameterizations
23 //--------------------------------------------------------------------
24  RespPar[HCAL][0][0] = pset.getParameter<double>("HadronBarrelResolution_Stochastic");
25  RespPar[HCAL][0][1] = pset.getParameter<double>("HadronBarrelResolution_Constant");
26  RespPar[HCAL][0][2] = pset.getParameter<double>("HadronBarrelResolution_Noise");
27 
28  RespPar[HCAL][1][0] = pset.getParameter<double>("HadronEndcapResolution_Stochastic");
29  RespPar[HCAL][1][1] = pset.getParameter<double>("HadronEndcapResolution_Constant");
30  RespPar[HCAL][1][2] = pset.getParameter<double>("HadronEndcapResolution_Noise");
31 
32  RespPar[VFCAL][0][0] = pset.getParameter<double>("HadronForwardResolution_Stochastic");
33  RespPar[VFCAL][0][1] = pset.getParameter<double>("HadronForwardResolution_Constant");
34  RespPar[VFCAL][0][2] = pset.getParameter<double>("HadronForwardResolution_Noise");
35 
36  RespPar[VFCAL][1][0] = pset.getParameter<double>("ElectronForwardResolution_Stochastic");
37  RespPar[VFCAL][1][1] = pset.getParameter<double>("ElectronForwardResolution_Constant");
38  RespPar[VFCAL][1][2] = pset.getParameter<double>("ElectronForwardResolution_Noise");
39 
40  eResponseScale[0] = pset.getParameter<double>("eResponseScaleHB");
41  eResponseScale[1] = pset.getParameter<double>("eResponseScaleHE");
42  eResponseScale[2] = pset.getParameter<double>("eResponseScaleHF");
43 
44  eResponsePlateau[0] = pset.getParameter<double>("eResponsePlateauHB");
45  eResponsePlateau[1] = pset.getParameter<double>("eResponsePlateauHE");
46  eResponsePlateau[2] = pset.getParameter<double>("eResponsePlateauHF");
47 
48  eResponseExponent = pset.getParameter<double>("eResponseExponent");
49  eResponseCoefficient = pset.getParameter<double>("eResponseCoefficient");
50 
51 //pion parameters
52 //--------------------------------------------------------------------
53  //energy values
54  maxHDe[0] = pset.getParameter<int>("maxHBe");
55  maxHDe[1] = pset.getParameter<int>("maxHEe");
56  maxHDe[2] = pset.getParameter<int>("maxHFe");
57  eGridHD[0] = pset.getParameter<vec1>("eGridHB");
58  eGridHD[1] = pset.getParameter<vec1>("eGridHE");
59  eGridHD[2] = pset.getParameter<vec1>("eGridHF");
60 
61  //region eta indices calculated from eta values
62  etaStep = pset.getParameter<double>("etaStep");
63  //eta boundaries
64  HDeta[0] = abs((int)(pset.getParameter<double>("HBeta") / etaStep));
65  HDeta[1] = abs((int)(pset.getParameter<double>("HEeta") / etaStep));
66  HDeta[2] = abs((int)(pset.getParameter<double>("HFeta") / etaStep));
67  HDeta[3] = abs((int)(pset.getParameter<double>("maxHDeta") / etaStep)); //add 1 because this is the max index
68  //eta ranges
69  maxHDetas[0] = HDeta[1] - HDeta[0];
70  maxHDetas[1] = HDeta[2] - HDeta[1];
71  maxHDetas[2] = HDeta[3] - HDeta[2];
72 
73  //parameter info
74  nPar = pset.getParameter<int>("nPar");
75  parNames = pset.getParameter<std::vector<std::string> >("parNames");
76  std::string detNames[] = {"_HB","_HE","_HF"};
77  std::string mipNames[] = {"_mip","_nomip",""};
78 
79  //setup parameters (5D vector)
80  parameters = vec5(nPar,vec4(3,vec3(3)));
81  for(int p = 0; p < nPar; p++){ //loop over parameters
82  for(int m = 0; m < 3; m++){ //loop over mip, nomip, total
83  for(int d = 0; d < 3; d++){ //loop over dets: HB, HE, HF
84  //get from python
85  std::string pname = parNames[p] + detNames[d] + mipNames[m];
86  vec1 tmp = pset.getParameter<vec1>(pname);
87 
88  //resize vector for energy range of det d
89  parameters[p][m][d].resize(maxHDe[d]);
90 
91  for(int i = 0; i < maxHDe[d]; i++){ //loop over energy for det d
92  //resize vector for eta range of det d
93  parameters[p][m][d][i].resize(maxHDetas[d]);
94 
95  for(int j = 0; j < maxHDetas[d]; j++){ //loop over eta for det d
96  //fill in parameters vector from python
97  parameters[p][m][d][i][j] = tmp[i*maxHDetas[d] + j];
98  }
99  }
100  }
101  }
102  }
103 
104 // MUON probability histos for bin size = 0.25 GeV (0-10 GeV, 40 bins)
105 //--------------------------------------------------------------------
106  muStep = pset.getParameter<double>("muStep");
107  maxMUe = pset.getParameter<int>("maxMUe");
108  maxMUeta = pset.getParameter<int>("maxMUeta");
109  maxMUbin = pset.getParameter<int>("maxMUbin");
110  eGridMU = pset.getParameter<vec1>("eGridMU");
111  etaGridMU = pset.getParameter<vec1>("etaGridMU");
112  vec1 _responseMU[2] = {pset.getParameter<vec1>("responseMUBarrel"),pset.getParameter<vec1>("responseMUEndcap")};
113 
114  //get muon region eta indices from the eta grid
115  double _barrelMUeta = pset.getParameter<double>("barrelMUeta");
116  double _endcapMUeta = pset.getParameter<double>("endcapMUeta");
117  barrelMUeta = endcapMUeta = maxMUeta;
118  for(int i = 0; i < maxMUeta; i++) {
119  if(fabs(_barrelMUeta) <= etaGridMU[i]) { barrelMUeta = i; break; }
120  }
121  for(int i = 0; i < maxMUeta; i++) {
122  if(fabs(_endcapMUeta) <= etaGridMU[i]) { endcapMUeta = i; break; }
123  }
124  int maxMUetas[] = {endcapMUeta - barrelMUeta, maxMUeta - endcapMUeta};
125 
126  //initialize 3D vector
127  responseMU = vec3(maxMUe,vec2(maxMUeta,vec1(maxMUbin,0)));
128 
129  //fill in 3D vector
130  //(complementary cumulative distribution functions, from normalized response distributions)
131  int loc, eta_loc;
132  loc = eta_loc = -1;
133  for(int i = 0; i < maxMUe; i++){
134  for(int j = 0; j < maxMUeta; j++){
135  //check location - barrel, endcap, or forward
136  if(j==barrelMUeta) {loc = 0; eta_loc = barrelMUeta;}
137  else if(j==endcapMUeta) {loc = 1; eta_loc = endcapMUeta;}
138 
139  for(int k = 0; k < maxMUbin; k++){
140  responseMU[i][j][k] = _responseMU[loc][i*maxMUetas[loc]*maxMUbin + (j-eta_loc)*maxMUbin + k];
141 
142  if(debug) {
143  //cout.width(6);
144  LogInfo("FastCalorimetry") << " responseMU " << i << " " << j << " " << k << " = "
145  << responseMU[i][j][k] << std::endl;
146  }
147  }
148  }
149  }
150 
151 // values for EM response in HF
152 //--------------------------------------------------------------------
153  maxEMe = pset.getParameter<int>("maxEMe");
154  maxEMeta = maxHDetas[2];
155  respFactorEM = pset.getParameter<double>("respFactorEM");
156  eGridEM = pset.getParameter<vec1>("eGridEM");
157 
158  // e-gamma mean response and sigma in HF
159  vec1 _meanEM = pset.getParameter<vec1>("meanEM");
160  vec1 _sigmaEM = pset.getParameter<vec1>("sigmaEM");
161 
162  //fill in 2D vectors (w/ correction factor applied)
163  meanEM = vec2(maxEMe,vec1(maxEMeta,0));
164  sigmaEM = vec2(maxEMe,vec1(maxEMeta,0));
165  for(int i = 0; i < maxEMe; i++){
166  for(int j = 0; j < maxEMeta; j++){
167  meanEM[i][j] = respFactorEM * _meanEM[i*maxEMeta + j];
168  sigmaEM[i][j] = respFactorEM * _sigmaEM[i*maxEMeta + j];
169  }
170  }
171 
172 }
HCALResponse::etaStep
double etaStep
Definition: HCALResponse.h:77
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
HCALResponse::RespPar
double RespPar[3][2][3]
Definition: HCALResponse.h:65
i
int i
Definition: DBlmapReader.cc:9
HCALResponse::maxHDe
int maxHDe[3]
Definition: HCALResponse.h:75
HCALResponse::random
const RandomEngine * random
Definition: HCALResponse.h:106
HCALResponse::HDeta
int HDeta[4]
Definition: HCALResponse.h:79
HCALResponse::eResponseCoefficient
double eResponseCoefficient
Definition: HCALResponse.h:71
HCALResponse::eResponseScale
double eResponseScale[3]
Definition: HCALResponse.h:68
HCALResponse::parNames
std::vector< std::string > parNames
Definition: HCALResponse.h:94
abs
#define abs(x)
Definition: mlp_lapack.h:159
HCALResponse::eResponseExponent
double eResponseExponent
Definition: HCALResponse.h:70
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
vec5
std::vector< vec4 > vec5
Definition: HCALResponse.h:19
vec3
std::vector< vec2 > vec3
Definition: HCALResponse.h:17
HCALResponse::eGridHD
vec1 eGridHD[3]
Definition: HCALResponse.h:86
vec1
std::vector< double > vec1
Definition: HCALResponse.h:15
HCALResponse::muStep
double muStep
Definition: HCALResponse.h:81
j
int j
Definition: DBlmapReader.cc:9
vec4
std::vector< vec3 > vec4
Definition: HCALResponse.h:18
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:81
HCALResponse::respFactorEM
double respFactorEM
Definition: HCALResponse.h:83
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
HCALResponse::maxHDetas
int maxHDetas[3]
Definition: HCALResponse.h:79
HCALResponse::cball
DoubleCrystalBallGenerator cball
Definition: HCALResponse.h:109
vec2
std::vector< vec1 > vec2
Definition: HCALResponse.h:16
HCALResponse::eResponsePlateau
double eResponsePlateau[3]
Definition: HCALResponse.h:69
HCALResponse::~HCALResponse ( )
inline

Definition at line 33 of file HCALResponse.h.

33 { }

Member Function Documentation

double HCALResponse::cballShootNoNegative ( double  mu,
double  sigma,
double  aL,
double  nL,
double  aR,
double  nR 
)
private

Definition at line 454 of file HCALResponse.cc.

References cball, dbtoconf::out, and DoubleCrystalBallGenerator::shoot().

Referenced by interHD().

454  {
455  double out = cball.shoot(mu,sigma,aL,nL,aR,nR);
456  if (mu >= 0.) {
457  while (out < 0.) out = cball.shoot(mu,sigma,aL,nL,aR,nR);
458  }
459  //else give up on re-trying, otherwise too much time can be lost before emeas comes out positive
460 
461  return out;
462 }
RPCpg::mu
const int mu
Definition: Constants.h:23
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
HCALResponse::cball
DoubleCrystalBallGenerator cball
Definition: HCALResponse.h:109
DoubleCrystalBallGenerator::shoot
double shoot(double mu, double sigma, double aL, double nL, double aR, double nR)
Definition: DoubleCrystalBallGenerator.cc:11
double HCALResponse::gaussShootNoNegative ( double  e,
double  sigma 
)
private

Definition at line 443 of file HCALResponse.cc.

References RandomEngine::gaussShoot(), dbtoconf::out, and random.

Referenced by getHCALEnergyResponse(), interEM(), and interHD().

443  {
444  double out = random->gaussShoot(e,sigma);
445  if (e >= 0.) {
446  while (out < 0.) out = random->gaussShoot(e,sigma);
447  }
448  //else give up on re-trying, otherwise too much time can be lost before emeas comes out positive
449 
450  return out;
451 }
HCALResponse::random
const RandomEngine * random
Definition: HCALResponse.h:106
RandomEngine::gaussShoot
double gaussShoot(double mean=0.0, double sigma=1.0) const
Definition: RandomEngine.h:37
dbtoconf.out
tuple out
Definition: dbtoconf.py:99
int HCALResponse::getDet ( int  ieta)
private

Definition at line 432 of file HCALResponse.cc.

References HDeta.

Referenced by responseHCAL().

432  {
433  int d;
434  for(d = 0; d < 2; d++){
435  if(ieta < HDeta[d+1]){
436  break;
437  }
438  }
439  return d;
440 }
HCALResponse::HDeta
int HDeta[4]
Definition: HCALResponse.h:79
double HCALResponse::getHCALEnergyResponse ( double  e,
int  hit 
)

Definition at line 407 of file HCALResponse.cc.

References trackerHits::c, eResponseCoefficient, eResponseExponent, eResponsePlateau, eResponseScale, create_public_lumi_plots::exp, gaussShootNoNegative(), HCAL, hcforward, create_public_lumi_plots::log, n, AlCaHLTBitMon_ParallelJobs::p, dtDQMClient_cfg::resolution, RespPar, alignCSCRings::s, mathSSE::sqrt(), and VFCAL.

Referenced by CalorimetryManager::HDShowerSimulation(), and CalorimetryManager::reconstructHCAL().

407  {
408  //response
409  double s = eResponseScale[hit];
410  double n = eResponseExponent;
411  double p = eResponsePlateau[hit];
412  double c = eResponseCoefficient;
413 
414  double response = e * p / (1+c*exp(n * log(s/e)));
415 
416  if(response<0.) response = 0.;
417 
418  //resolution
419  double resolution;
420  if(hit==hcforward)
421  resolution = e *sqrt( RespPar[VFCAL][1][0]*RespPar[VFCAL][1][0] / e + RespPar[VFCAL][1][1]*RespPar[VFCAL][1][1] );
422  else
423  resolution = e * sqrt( RespPar[HCAL][hit][0]*RespPar[HCAL][hit][0]/(e) + RespPar[HCAL][hit][1]*RespPar[HCAL][hit][1] );
424 
425  //random smearing
426  double rndm = gaussShootNoNegative(response,resolution);
427 
428  return rndm;
429 }
HCALResponse::RespPar
double RespPar[3][2][3]
Definition: HCALResponse.h:65
create_public_lumi_plots.exp
tuple exp
Definition: create_public_lumi_plots.py:1104
HCALResponse::eResponseCoefficient
double eResponseCoefficient
Definition: HCALResponse.h:71
HCALResponse::eResponseScale
double eResponseScale[3]
Definition: HCALResponse.h:68
create_public_lumi_plots.log
log
Definition: create_public_lumi_plots.py:1119
HCALResponse::eResponseExponent
double eResponseExponent
Definition: HCALResponse.h:70
HCALResponse::gaussShootNoNegative
double gaussShootNoNegative(double e, double sigma)
Definition: HCALResponse.cc:443
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
dtDQMClient_cfg.resolution
tuple resolution
Definition: dtDQMClient_cfg.py:21
HCALResponse::eResponsePlateau
double eResponsePlateau[3]
Definition: HCALResponse.h:69
double HCALResponse::interEM ( double  e,
int  ie,
int  ieta 
)
private

Definition at line 369 of file HCALResponse.cc.

References debug, alignCSCRings::e, eGridEM, gaussShootNoNegative(), timingPdfMaker::mean, meanEM, and sigmaEM.

Referenced by responseHCAL().

369  {
370  double y1 = meanEM[ie][ieta];
371  double y2 = meanEM[ie+1][ieta];
372  double x1 = eGridEM[ie];
373  double x2 = eGridEM[ie+1];
374 
375  if(debug) {
376  // cout.width(6);
377  LogInfo("FastCalorimetry") << std::endl
378  << " HCALResponse::interEM mean " << std::endl
379  << " x, x1-x2, y1-y2 = "
380  << e << ", " << x1 <<"-" << x2 << " " << y1 <<"-" << y2 << std::endl;
381  }
382 
383  //linear interpolation
384  double mean = (y1*(x2-e) + y2*(e-x1))/(x2-x1);
385 
386  y1 = sigmaEM[ie][ieta];
387  y2 = sigmaEM[ie+1][ieta];
388 
389  if(debug) {
390  // cout.width(6);
391  LogInfo("FastCalorimetry") << std::endl
392  << " HCALResponse::interEM sigma" << std::endl
393  << " x, x1-x2, y1-y2 = "
394  << e << ", " << x1 <<"-" << x2 << " " << y1 <<"-" << y2 << std::endl;
395  }
396 
397  //linear interpolation
398  double sigma = (y1*(x2-e) + y2*(e-x1))/(x2-x1);
399 
400  //random smearing
401  double rndm = gaussShootNoNegative(mean,sigma);
402 
403  return rndm;
404 }
HCALResponse::gaussShootNoNegative
double gaussShootNoNegative(double e, double sigma)
Definition: HCALResponse.cc:443
double HCALResponse::interHD ( int  mip,
double  e,
int  ie,
int  ieta,
int  det 
)
private

Definition at line 317 of file HCALResponse.cc.

References cballShootNoNegative(), alignCSCRings::e, eGridHD, gaussShootNoNegative(), timingPdfMaker::mean, nPar, AlCaHLTBitMon_ParallelJobs::p, parameters, and tmp.

Referenced by responseHCAL().

317  {
318  double y1, y2;
319 
320  double x1 = eGridHD[det][ie];
321  double x2 = eGridHD[det][ie+1];
322 
323  vec1 pars(nPar,0);
324 
325  //calculate all parameters
326  for(int p = 0; p < nPar; p++){
327  y1 = parameters[p][mip][det][ie][ieta];
328  y2 = parameters[p][mip][det][ie+1][ieta];
329 
330  //par-specific checks
331  double custom = 0;
332  bool use_custom = false;
333 
334  //do not let mu or sigma get extrapolated below zero for low energies
335  //especially important for HF since extrapolation is used for E < 15 GeV
336  if((p==0 || p==1) && e < x1){
337  double tmp = (y1*x2-y2*x1)/(x2-x1); //extrapolate down to e=0
338  if(tmp<0) { //require mu,sigma > 0 for E > 0
339  custom = y1*e/x1;
340  use_custom = true;
341  }
342  }
343  //tail parameters have lower bounds - never extrapolate down
344  else if((p==2 || p==3 || p==4 || p==5)){
345  if(e < x1 && y1 < y2){
346  custom = y1;
347  use_custom = true;
348  }
349  else if(e > x2 && y2 < y1){
350  custom = y2;
351  use_custom = true;
352  }
353  }
354 
355  //linear interpolation
356  if(use_custom) pars[p] = custom;
357  else pars[p] = (y1*(x2-e) + y2*(e-x1))/(x2-x1);
358  }
359 
360  //random smearing
361  double mean = 0;
362  if(nPar==6) mean = cballShootNoNegative(pars[0],pars[1],pars[2],pars[3],pars[4],pars[5]);
363  else if(nPar==2) mean = gaussShootNoNegative(pars[0],pars[1]); //gaussian fallback
364 
365  return mean;
366 }
HCALResponse::gaussShootNoNegative
double gaussShootNoNegative(double e, double sigma)
Definition: HCALResponse.cc:443
HCALResponse::eGridHD
vec1 eGridHD[3]
Definition: HCALResponse.h:86
vec1
std::vector< double > vec1
Definition: HCALResponse.h:15
HCALResponse::cballShootNoNegative
double cballShootNoNegative(double mu, double sigma, double aL, double nL, double aR, double nR)
Definition: HCALResponse.cc:454
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
tmp
std::vector< std::vector< double > > tmp
Definition: MVATrainer.cc:100
double HCALResponse::interMU ( double  e,
int  ie,
int  ieta 
)
private

Definition at line 271 of file HCALResponse.cc.

References debug, alignCSCRings::e, eGridMU, RandomEngine::flatShoot(), i, maxMUbin, timingPdfMaker::mean, muStep, random, responseMU, and x.

Referenced by responseHCAL().

271  {
272  double x = random->flatShoot();
273 
274  int bin1 = maxMUbin;
275  for(int i = 0; i < maxMUbin; i++) {
276  if(x > responseMU[ie][ieta][i]) {
277  bin1 = i-1;
278  break;
279  }
280  }
281  int bin2 = maxMUbin;
282  for(int i = 0; i < maxMUbin; i++) {
283  if(x > responseMU[ie+1][ieta][i]) {
284  bin2 = i-1;
285  break;
286  }
287  }
288 
289  double x1 = eGridMU[ie];
290  double x2 = eGridMU[ie+1];
291  double y1 = (bin1 + random->flatShoot()) * muStep;
292  double y2 = (bin2 + random->flatShoot()) * muStep;
293 
294  if(debug) {
295  // cout.width(6);
296  LogInfo("FastCalorimetry") << std::endl
297  << " HCALResponse::interMU " << std::endl
298  << " x, x1-x2, y1-y2 = "
299  << e << ", " << x1 <<"-" << x2 << " " << y1 <<"-" << y2 << std::endl;
300 
301  }
302 
303  //linear interpolation
304  double mean = (y1*(x2-e) + y2*(e-x1))/(x2-x1);
305 
306  if(debug) {
307  //cout.width(6);
308  LogInfo("FastCalorimetry") << std::endl
309  << " HCALResponse::interMU " << std::endl
310  << " e, ie, ieta = " << e << " " << ie << " " << ieta << std::endl
311  << " response = " << mean << std::endl;
312  }
313 
314  return mean;
315 }
i
int i
Definition: DBlmapReader.cc:9
HCALResponse::random
const RandomEngine * random
Definition: HCALResponse.h:106
HCALResponse::muStep
double muStep
Definition: HCALResponse.h:81
RandomEngine::flatShoot
double flatShoot(double xmin=0.0, double xmax=1.0) const
Definition: RandomEngine.h:30
x
Definition: DDAxes.h:10
double HCALResponse::responseHCAL ( int  _mip,
double  energy,
double  eta,
int  partype 
)

Definition at line 175 of file HCALResponse.cc.

References abs, debug, eGridEM, eGridHD, eGridMU, relval_parameters_module::energy, etaGridMU, etaStep, getDet(), HDeta, i, interEM(), interHD(), interMU(), maxEMe, maxEMeta, maxHDe, maxHDetas, maxMUe, maxMUeta, timingPdfMaker::mean, and usemip.

Referenced by CalorimetryManager::HDShowerSimulation(), and CalorimetryManager::reconstructHCAL().

175  {
176  int ieta = abs((int)(eta / etaStep)) ;
177  int ie = -1;
178 
179  int mip;
180  if(usemip) mip = _mip;
181  else mip = 2; //ignore mip, use only overall (mip + nomip) parameters
182 
183  double mean = 0;
184 
185  // e/gamma in HF
186  if(partype == 0) {
187  //check eta
188  ieta -= HDeta[2]; // HF starts at ieta=30 till ieta=51
189  // but resp.vector from index=0 through 20
190  if(ieta >= maxEMeta ) ieta = maxEMeta-1;
191  else if(ieta < 0) ieta = 0;
192 
193  //find energy range
194  for (int i = 0; i < maxEMe; i++) {
195  if(energy < eGridEM[i]) {
196  if(i == 0) ie = 0; // less than minimal - back extrapolation with the 1st interval
197  else ie = i-1;
198  break;
199  }
200  }
201  if(ie == -1) ie = maxEMe - 2; // more than maximum - extrapolation with last interval
202 
203  //do smearing
204  mean = interEM(energy, ie, ieta);
205  }
206 
207  // hadrons
208  else if(partype == 1) {
209  //check eta and det
210  int det = getDet(ieta);
211  int deta = ieta - HDeta[det];
212  if(deta >= maxHDetas[det]) deta = maxHDetas[det] - 1;
213  else if(deta < 0 ) deta = 0;
214 
215  //find energy range
216  for (int i = 0; i < maxHDe[det]; i++) {
217  if(energy < eGridHD[det][i]) {
218  if(i == 0) ie = 0; // less than minimal - back extrapolation with the 1st interval
219  else ie = i-1;
220  break;
221  }
222  }
223  if(ie == -1) ie = maxHDe[det] - 2; // more than maximum - extrapolation with last interval
224 
225  //do smearing
226  mean = interHD(mip, energy, ie, deta, det);
227  }
228 
229 
230  // muons
231  else if(partype == 2) {
232  //check eta
233  ieta = maxMUeta;
234  for(int i = 0; i < maxMUeta; i++) {
235  if(fabs(eta) < etaGridMU[i]) {
236  ieta = i;
237  break;
238  }
239  }
240  if(ieta < 0) ieta = 0;
241 
242  if(ieta < maxMUeta) { // HB-HE
243  //find energy range
244  for (int i = 0; i < maxMUe; i++) {
245  if(energy < eGridMU[i]) {
246  if(i == 0) ie = 0; // less than minimal - back extrapolation with the 1st interval
247  else ie = i-1;
248  break;
249  }
250  }
251  if(ie == -1) ie = maxMUe - 2; // more than maximum - extrapolation with last interval
252 
253  //do smearing
254  mean = interMU(energy, ie, ieta);
255  if(mean > energy) mean = energy;
256  }
257  }
258 
259  // debugging
260  if(debug) {
261  // cout.width(6);
262  LogInfo("FastCalorimetry") << std::endl
263  << " HCALResponse::responseHCAL, partype = " << partype
264  << " E, eta = " << energy << " " << eta
265  << " mean = " << mean << std::endl;
266  }
267 
268  return mean;
269 }
HCALResponse::etaStep
double etaStep
Definition: HCALResponse.h:77
i
int i
Definition: DBlmapReader.cc:9
HCALResponse::maxHDe
int maxHDe[3]
Definition: HCALResponse.h:75
HCALResponse::interHD
double interHD(int mip, double e, int ie, int ieta, int det)
Definition: HCALResponse.cc:317
HCALResponse::HDeta
int HDeta[4]
Definition: HCALResponse.h:79
HCALResponse::getDet
int getDet(int ieta)
Definition: HCALResponse.cc:432
abs
#define abs(x)
Definition: mlp_lapack.h:159
eta
T eta() const
Definition: Basic3DVectorLD.h:179
HCALResponse::interEM
double interEM(double e, int ie, int ieta)
Definition: HCALResponse.cc:369
HCALResponse::interMU
double interMU(double e, int ie, int ieta)
Definition: HCALResponse.cc:271
HCALResponse::eGridHD
vec1 eGridHD[3]
Definition: HCALResponse.h:86
HCALResponse::maxHDetas
int maxHDetas[3]
Definition: HCALResponse.h:79
relval_parameters_module.energy
string energy
Definition: relval_parameters_module.py:29

Member Data Documentation

int HCALResponse::barrelMUeta
private

Definition at line 79 of file HCALResponse.h.

Referenced by HCALResponse().

DoubleCrystalBallGenerator HCALResponse::cball
private

Definition at line 109 of file HCALResponse.h.

Referenced by cballShootNoNegative().

bool HCALResponse::debug
private

Definition at line 59 of file HCALResponse.h.

Referenced by pkg.AbstractPkg::generate(), pkg.AbstractPkg::get_kwds(), HCALResponse(), interEM(), interMU(), responseHCAL(), and pkg.AbstractPkg::write().

vec1 HCALResponse::eGridEM
private

Definition at line 87 of file HCALResponse.h.

Referenced by HCALResponse(), interEM(), and responseHCAL().

vec1 HCALResponse::eGridHD[3]
private

Definition at line 86 of file HCALResponse.h.

Referenced by HCALResponse(), interHD(), and responseHCAL().

vec1 HCALResponse::eGridMU
private

Definition at line 88 of file HCALResponse.h.

Referenced by HCALResponse(), interMU(), and responseHCAL().

int HCALResponse::endcapMUeta
private

Definition at line 79 of file HCALResponse.h.

Referenced by HCALResponse().

double HCALResponse::eResponseCoefficient
private

Definition at line 71 of file HCALResponse.h.

Referenced by getHCALEnergyResponse(), and HCALResponse().

double HCALResponse::eResponseExponent
private

Definition at line 70 of file HCALResponse.h.

Referenced by getHCALEnergyResponse(), and HCALResponse().

double HCALResponse::eResponsePlateau[3]
private

Definition at line 69 of file HCALResponse.h.

Referenced by getHCALEnergyResponse(), and HCALResponse().

double HCALResponse::eResponseScale[3]
private

Definition at line 68 of file HCALResponse.h.

Referenced by getHCALEnergyResponse(), and HCALResponse().

vec1 HCALResponse::etaGridMU
private

Definition at line 89 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

double HCALResponse::etaStep
private

Definition at line 77 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::HDeta[4]
private

Definition at line 79 of file HCALResponse.h.

Referenced by getDet(), HCALResponse(), and responseHCAL().

int HCALResponse::maxEMe
private

Definition at line 74 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::maxEMeta
private

Definition at line 74 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::maxHDe[3]
private

Definition at line 75 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::maxHDetas[3]
private

Definition at line 79 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::maxMUbin
private

Definition at line 74 of file HCALResponse.h.

Referenced by HCALResponse(), and interMU().

int HCALResponse::maxMUe
private

Definition at line 74 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

int HCALResponse::maxMUeta
private

Definition at line 74 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

vec2 HCALResponse::meanEM
private

Definition at line 99 of file HCALResponse.h.

Referenced by HCALResponse(), and interEM().

double HCALResponse::muStep
private

Definition at line 81 of file HCALResponse.h.

Referenced by HCALResponse(), and interMU().

int HCALResponse::nPar
private

Definition at line 93 of file HCALResponse.h.

Referenced by HCALResponse(), and interHD().

vec5 HCALResponse::parameters
private

Definition at line 95 of file HCALResponse.h.

Referenced by HCALResponse(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::inputTags(), interHD(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::properties(), and Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor::recursePSetProperties().

std::vector<std::string> HCALResponse::parNames
private

Definition at line 94 of file HCALResponse.h.

Referenced by HCALResponse().

const RandomEngine* HCALResponse::random
private

Definition at line 106 of file HCALResponse.h.

Referenced by gaussShootNoNegative(), and interMU().

double HCALResponse::respFactorEM
private

Definition at line 83 of file HCALResponse.h.

Referenced by HCALResponse().

vec3 HCALResponse::responseMU
private

Definition at line 103 of file HCALResponse.h.

Referenced by HCALResponse(), and interMU().

double HCALResponse::RespPar[3][2][3]
private

Definition at line 65 of file HCALResponse.h.

Referenced by getHCALEnergyResponse(), and HCALResponse().

vec2 HCALResponse::sigmaEM
private

Definition at line 99 of file HCALResponse.h.

Referenced by HCALResponse(), and interEM().

bool HCALResponse::usemip
private

Definition at line 59 of file HCALResponse.h.

Referenced by HCALResponse(), and responseHCAL().

Generated for CMSSW Reference Manual by doxygen 1.8.5