00001 #include "EgammaAnalysis/ElectronTools/interface/ElectronEnergyRegressionEvaluate.h"
00002 #include <cmath>
00003 #include <cassert>
00004
00005 #ifndef STANDALONE
00006 #include "RecoEcal/EgammaCoreTools/interface/EcalClusterLazyTools.h"
00007 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
00008 #include "RecoEgamma/EgammaTools/interface/EcalClusterLocal.h"
00009 #include "DataFormats/EgammaCandidates/interface/GsfElectron.h"
00010 #include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
00011 #include "DataFormats/EcalDetId/interface/EBDetId.h"
00012 #include "DataFormats/EcalDetId/interface/EEDetId.h"
00013 #include "FWCore/ParameterSet/interface/FileInPath.h"
00014 #endif
00015
00016 ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionEvaluate() :
00017 fIsInitialized(kFALSE),
00018 fVersionType(kNoTrkVar),
00019 forestCorrection_eb(0),
00020 forestCorrection_ee(0),
00021 forestUncertainty_eb(0),
00022 forestUncertainty_ee(0) {
00023 }
00024
00025 ElectronEnergyRegressionEvaluate::~ElectronEnergyRegressionEvaluate() {}
00026
00027
00028
00029 void ElectronEnergyRegressionEvaluate::initialize(std::string weightsFile,
00030 ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type) {
00031
00032
00033 TFile file(edm::FileInPath(weightsFile.c_str()).fullPath().c_str());
00034
00035 forestCorrection_eb = (GBRForest*) file.Get("EBCorrection");
00036 forestCorrection_ee = (GBRForest*) file.Get("EECorrection");
00037 forestUncertainty_eb = (GBRForest*) file.Get("EBUncertainty");
00038 forestUncertainty_ee = (GBRForest*) file.Get("EEUncertainty");
00039
00040
00041 assert(forestCorrection_eb);
00042 assert(forestCorrection_ee);
00043 assert(forestUncertainty_eb);
00044 assert(forestUncertainty_ee);
00045
00046
00047 fVersionType = type;
00048 fIsInitialized = kTRUE;
00049
00050 }
00051
00052
00053
00054 #ifndef STANDALONE
00055 double ElectronEnergyRegressionEvaluate::calculateRegressionEnergy(const reco::GsfElectron *ele,
00056 SuperClusterHelper& mySCHelper,
00057 double rho, double nvertices,
00058 bool printDebug) {
00059
00060 if (!fIsInitialized) {
00061 std::cout << "Error: Electron Energy Regression has not been initialized yet. return 0. \n";
00062 return 0;
00063 }
00064
00065
00066 if (printDebug) {
00067 std::cout << "Regression Type: " << fVersionType << std::endl;
00068 std::cout << "Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
00069 }
00070
00071 if (fVersionType == kNoTrkVar) {
00072 return regressionValueNoTrkVar(
00073 mySCHelper.rawEnergy(),
00074 mySCHelper.eta(),
00075 mySCHelper.phi(),
00076 mySCHelper.r9(),
00077 mySCHelper.etaWidth(),
00078 mySCHelper.phiWidth(),
00079 mySCHelper.clustersSize(),
00080 mySCHelper.hadronicOverEm(),
00081 rho,
00082 nvertices,
00083 mySCHelper.seedEta(),
00084 mySCHelper.seedPhi(),
00085 mySCHelper.seedEnergy(),
00086 mySCHelper.e3x3(),
00087 mySCHelper.e5x5(),
00088 mySCHelper.sigmaIetaIeta(),
00089 mySCHelper.spp(),
00090 mySCHelper.sep(),
00091 mySCHelper.eMax(),
00092 mySCHelper.e2nd(),
00093 mySCHelper.eTop(),
00094 mySCHelper.eBottom(),
00095 mySCHelper.eLeft(),
00096 mySCHelper.eRight(),
00097 mySCHelper.e2x5Max(),
00098 mySCHelper.e2x5Top(),
00099 mySCHelper.e2x5Bottom(),
00100 mySCHelper.e2x5Left(),
00101 mySCHelper.e2x5Right(),
00102 mySCHelper.ietaSeed(),
00103 mySCHelper.iphiSeed(),
00104 mySCHelper.etaCrySeed(),
00105 mySCHelper.phiCrySeed(),
00106 mySCHelper.preshowerEnergyOverRaw(),
00107 printDebug
00108 );
00109 }
00110 if (fVersionType == kWithSubCluVar) {
00111 return regressionValueWithSubClusters(
00112 mySCHelper.rawEnergy(),
00113 mySCHelper.eta(),
00114 mySCHelper.phi(),
00115 mySCHelper.r9(),
00116 mySCHelper.etaWidth(),
00117 mySCHelper.phiWidth(),
00118 mySCHelper.clustersSize(),
00119 mySCHelper.hadronicOverEm(),
00120 rho,
00121 nvertices,
00122 mySCHelper.seedEta(),
00123 mySCHelper.seedPhi(),
00124 mySCHelper.seedEnergy(),
00125 mySCHelper.e3x3(),
00126 mySCHelper.e5x5(),
00127 mySCHelper.sigmaIetaIeta(),
00128 mySCHelper.spp(),
00129 mySCHelper.sep(),
00130 mySCHelper.eMax(),
00131 mySCHelper.e2nd(),
00132 mySCHelper.eTop(),
00133 mySCHelper.eBottom(),
00134 mySCHelper.eLeft(),
00135 mySCHelper.eRight(),
00136 mySCHelper.e2x5Max(),
00137 mySCHelper.e2x5Top(),
00138 mySCHelper.e2x5Bottom(),
00139 mySCHelper.e2x5Left(),
00140 mySCHelper.e2x5Right(),
00141 mySCHelper.ietaSeed(),
00142 mySCHelper.iphiSeed(),
00143 mySCHelper.etaCrySeed(),
00144 mySCHelper.phiCrySeed(),
00145 mySCHelper.preshowerEnergyOverRaw(),
00146 ele->ecalDrivenSeed(),
00147 ele->isEBEtaGap(),
00148 ele->isEBPhiGap(),
00149 ele->isEEDeeGap(),
00150 mySCHelper.eSubClusters(),
00151 mySCHelper.subClusterEnergy(1),
00152 mySCHelper.subClusterEta(1),
00153 mySCHelper.subClusterPhi(1),
00154 mySCHelper.subClusterEmax(1),
00155 mySCHelper.subClusterE3x3(1),
00156 mySCHelper.subClusterEnergy(2),
00157 mySCHelper.subClusterEta(2),
00158 mySCHelper.subClusterPhi(2),
00159 mySCHelper.subClusterEmax(2),
00160 mySCHelper.subClusterE3x3(2),
00161 mySCHelper.subClusterEnergy(3),
00162 mySCHelper.subClusterEta(3),
00163 mySCHelper.subClusterPhi(3),
00164 mySCHelper.subClusterEmax(3),
00165 mySCHelper.subClusterE3x3(3),
00166 mySCHelper.nPreshowerClusters(),
00167 mySCHelper.eESClusters(),
00168 mySCHelper.esClusterEnergy(0),
00169 mySCHelper.esClusterEta(0),
00170 mySCHelper.esClusterPhi(0),
00171 mySCHelper.esClusterEnergy(1),
00172 mySCHelper.esClusterEta(1),
00173 mySCHelper.esClusterPhi(1),
00174 mySCHelper.esClusterEnergy(2),
00175 mySCHelper.esClusterEta(2),
00176 mySCHelper.esClusterPhi(2),
00177 ele->isEB(),
00178 printDebug
00179 );
00180 }
00181 else if (fVersionType == kNoTrkVarV1) {
00182 return regressionValueNoTrkVarV1(
00183 mySCHelper.rawEnergy(),
00184 mySCHelper.eta(),
00185 mySCHelper.phi(),
00186 mySCHelper.r9(),
00187 mySCHelper.etaWidth(),
00188 mySCHelper.phiWidth(),
00189 mySCHelper.clustersSize(),
00190 mySCHelper.hadronicOverEm(),
00191 rho,
00192 nvertices,
00193 mySCHelper.seedEta(),
00194 mySCHelper.seedPhi(),
00195 mySCHelper.seedEnergy(),
00196 mySCHelper.e3x3(),
00197 mySCHelper.e5x5(),
00198 mySCHelper.sigmaIetaIeta(),
00199 mySCHelper.spp(),
00200 mySCHelper.sep(),
00201 mySCHelper.eMax(),
00202 mySCHelper.e2nd(),
00203 mySCHelper.eTop(),
00204 mySCHelper.eBottom(),
00205 mySCHelper.eLeft(),
00206 mySCHelper.eRight(),
00207 mySCHelper.e2x5Max(),
00208 mySCHelper.e2x5Top(),
00209 mySCHelper.e2x5Bottom(),
00210 mySCHelper.e2x5Left(),
00211 mySCHelper.e2x5Right(),
00212 mySCHelper.ietaSeed(),
00213 mySCHelper.iphiSeed(),
00214 mySCHelper.etaCrySeed(),
00215 mySCHelper.phiCrySeed(),
00216 mySCHelper.preshowerEnergyOverRaw(),
00217 ele->ecalDrivenSeed(),
00218 printDebug
00219 );
00220 }
00221 else if (fVersionType == kWithTrkVarV1) {
00222 return regressionValueWithTrkVarV1(
00223 mySCHelper.rawEnergy(),
00224 mySCHelper.eta(),
00225 mySCHelper.phi(),
00226 mySCHelper.r9(),
00227 mySCHelper.etaWidth(),
00228 mySCHelper.phiWidth(),
00229 mySCHelper.clustersSize(),
00230 mySCHelper.hadronicOverEm(),
00231 rho,
00232 nvertices,
00233 mySCHelper.seedEta(),
00234 mySCHelper.seedPhi(),
00235 mySCHelper.seedEnergy(),
00236 mySCHelper.e3x3(),
00237 mySCHelper.e5x5(),
00238 mySCHelper.sigmaIetaIeta(),
00239 mySCHelper.spp(),
00240 mySCHelper.sep(),
00241 mySCHelper.eMax(),
00242 mySCHelper.e2nd(),
00243 mySCHelper.eTop(),
00244 mySCHelper.eBottom(),
00245 mySCHelper.eLeft(),
00246 mySCHelper.eRight(),
00247 mySCHelper.e2x5Max(),
00248 mySCHelper.e2x5Top(),
00249 mySCHelper.e2x5Bottom(),
00250 mySCHelper.e2x5Left(),
00251 mySCHelper.e2x5Right(),
00252 mySCHelper.ietaSeed(),
00253 mySCHelper.iphiSeed(),
00254 mySCHelper.etaCrySeed(),
00255 mySCHelper.phiCrySeed(),
00256 mySCHelper.preshowerEnergyOverRaw(),
00257 ele->ecalDrivenSeed(),
00258 ele->trackMomentumAtVtx().R(),
00259 fmax(ele->fbrem(),-1.0),
00260 ele->charge(),
00261 fmin(ele->eSuperClusterOverP(), 20.0),
00262 ele->trackMomentumError(),
00263 ele->correctedEcalEnergyError(),
00264 ele->classification(),
00265 printDebug
00266 );
00267 }
00268 else if (fVersionType == kWithTrkVarV2) {
00269 return regressionValueWithTrkVarV2(
00270 mySCHelper.rawEnergy(),
00271 mySCHelper.eta(),
00272 mySCHelper.phi(),
00273 mySCHelper.r9(),
00274 mySCHelper.etaWidth(),
00275 mySCHelper.phiWidth(),
00276 mySCHelper.clustersSize(),
00277 mySCHelper.hadronicOverEm(),
00278 rho,
00279 nvertices,
00280 mySCHelper.seedEta(),
00281 mySCHelper.seedPhi(),
00282 mySCHelper.seedEnergy(),
00283 mySCHelper.e3x3(),
00284 mySCHelper.e5x5(),
00285 mySCHelper.sigmaIetaIeta(),
00286 mySCHelper.spp(),
00287 mySCHelper.sep(),
00288 mySCHelper.eMax(),
00289 mySCHelper.e2nd(),
00290 mySCHelper.eTop(),
00291 mySCHelper.eBottom(),
00292 mySCHelper.eLeft(),
00293 mySCHelper.eRight(),
00294 mySCHelper.e2x5Max(),
00295 mySCHelper.e2x5Top(),
00296 mySCHelper.e2x5Bottom(),
00297 mySCHelper.e2x5Left(),
00298 mySCHelper.e2x5Right(),
00299 mySCHelper.ietaSeed(),
00300 mySCHelper.iphiSeed(),
00301 mySCHelper.etaCrySeed(),
00302 mySCHelper.phiCrySeed(),
00303 mySCHelper.preshowerEnergyOverRaw(),
00304 ele->ecalDrivenSeed(),
00305 ele->trackMomentumAtVtx().R(),
00306 fmax(ele->fbrem(),-1.0),
00307 ele->charge(),
00308 fmin(ele->eSuperClusterOverP(), 20.0),
00309 ele->trackMomentumError(),
00310 ele->correctedEcalEnergyError(),
00311 ele->classification(),
00312 fmin(fabs(ele->deltaEtaSuperClusterTrackAtVtx()), 0.6),
00313 ele->deltaPhiSuperClusterTrackAtVtx(),
00314 ele->deltaEtaSeedClusterTrackAtCalo(),
00315 ele->deltaPhiSeedClusterTrackAtCalo(),
00316 ele->gsfTrack()->chi2() / ele->gsfTrack()->ndof(),
00317 (ele->closestCtfTrackRef().isNonnull() ? ele->closestCtfTrackRef()->hitPattern().trackerLayersWithMeasurement() : -1),
00318 fmin(ele->eEleClusterOverPout(),20.0),
00319 printDebug
00320 );
00321 }
00322 else {
00323 std::cout << "Warning: Electron Regression Type " << fVersionType << " is not supported. Reverting to default electron momentum.\n";
00324 return ele->p();
00325 }
00326
00327
00328 }
00329
00330 double ElectronEnergyRegressionEvaluate::calculateRegressionEnergyUncertainty(const reco::GsfElectron *ele,
00331 SuperClusterHelper& mySCHelper,
00332 double rho, double nvertices,
00333 bool printDebug) {
00334
00335 if (!fIsInitialized) {
00336 std::cout << "Error: Electron Energy Regression has not been initialized yet. return 0. \n";
00337 return 0;
00338 }
00339
00340
00341 if (printDebug) {
00342 std::cout << "Regression Type: " << fVersionType << std::endl;
00343 std::cout << "Electron : " << ele->pt() << " " << ele->eta() << " " << ele->phi() << "\n";
00344 }
00345
00346 if (fVersionType == kNoTrkVar) {
00347 return regressionUncertaintyNoTrkVar(
00348 mySCHelper.rawEnergy(),
00349 mySCHelper.eta(),
00350 mySCHelper.phi(),
00351 mySCHelper.r9(),
00352 mySCHelper.etaWidth(),
00353 mySCHelper.phiWidth(),
00354 mySCHelper.clustersSize(),
00355 mySCHelper.hadronicOverEm(),
00356 rho,
00357 nvertices,
00358 mySCHelper.seedEta(),
00359 mySCHelper.seedPhi(),
00360 mySCHelper.seedEnergy(),
00361 mySCHelper.e3x3(),
00362 mySCHelper.e5x5(),
00363 mySCHelper.sigmaIetaIeta(),
00364 mySCHelper.spp(),
00365 mySCHelper.sep(),
00366 mySCHelper.eMax(),
00367 mySCHelper.e2nd(),
00368 mySCHelper.eTop(),
00369 mySCHelper.eBottom(),
00370 mySCHelper.eLeft(),
00371 mySCHelper.eRight(),
00372 mySCHelper.e2x5Max(),
00373 mySCHelper.e2x5Top(),
00374 mySCHelper.e2x5Bottom(),
00375 mySCHelper.e2x5Left(),
00376 mySCHelper.e2x5Right(),
00377 mySCHelper.ietaSeed(),
00378 mySCHelper.iphiSeed(),
00379 mySCHelper.etaCrySeed(),
00380 mySCHelper.phiCrySeed(),
00381 mySCHelper.preshowerEnergyOverRaw(),
00382 printDebug
00383 );
00384 }
00385 if (fVersionType == kWithSubCluVar) {
00386 return regressionUncertaintyWithSubClusters(
00387 mySCHelper.rawEnergy(),
00388 mySCHelper.eta(),
00389 mySCHelper.phi(),
00390 mySCHelper.r9(),
00391 mySCHelper.etaWidth(),
00392 mySCHelper.phiWidth(),
00393 mySCHelper.clustersSize(),
00394 mySCHelper.hadronicOverEm(),
00395 rho,
00396 nvertices,
00397 mySCHelper.seedEta(),
00398 mySCHelper.seedPhi(),
00399 mySCHelper.seedEnergy(),
00400 mySCHelper.e3x3(),
00401 mySCHelper.e5x5(),
00402 mySCHelper.sigmaIetaIeta(),
00403 mySCHelper.spp(),
00404 mySCHelper.sep(),
00405 mySCHelper.eMax(),
00406 mySCHelper.e2nd(),
00407 mySCHelper.eTop(),
00408 mySCHelper.eBottom(),
00409 mySCHelper.eLeft(),
00410 mySCHelper.eRight(),
00411 mySCHelper.e2x5Max(),
00412 mySCHelper.e2x5Top(),
00413 mySCHelper.e2x5Bottom(),
00414 mySCHelper.e2x5Left(),
00415 mySCHelper.e2x5Right(),
00416 mySCHelper.ietaSeed(),
00417 mySCHelper.iphiSeed(),
00418 mySCHelper.etaCrySeed(),
00419 mySCHelper.phiCrySeed(),
00420 mySCHelper.preshowerEnergyOverRaw(),
00421 ele->ecalDrivenSeed(),
00422 ele->isEBEtaGap(),
00423 ele->isEBPhiGap(),
00424 ele->isEEDeeGap(),
00425 mySCHelper.eSubClusters(),
00426 mySCHelper.subClusterEnergy(1),
00427 mySCHelper.subClusterEta(1),
00428 mySCHelper.subClusterPhi(1),
00429 mySCHelper.subClusterEmax(1),
00430 mySCHelper.subClusterE3x3(1),
00431 mySCHelper.subClusterEnergy(2),
00432 mySCHelper.subClusterEta(2),
00433 mySCHelper.subClusterPhi(2),
00434 mySCHelper.subClusterEmax(2),
00435 mySCHelper.subClusterE3x3(2),
00436 mySCHelper.subClusterEnergy(3),
00437 mySCHelper.subClusterEta(3),
00438 mySCHelper.subClusterPhi(3),
00439 mySCHelper.subClusterEmax(3),
00440 mySCHelper.subClusterE3x3(3),
00441 mySCHelper.nPreshowerClusters(),
00442 mySCHelper.eESClusters(),
00443 mySCHelper.esClusterEnergy(0),
00444 mySCHelper.esClusterEta(0),
00445 mySCHelper.esClusterPhi(0),
00446 mySCHelper.esClusterEnergy(1),
00447 mySCHelper.esClusterEta(1),
00448 mySCHelper.esClusterPhi(1),
00449 mySCHelper.esClusterEnergy(2),
00450 mySCHelper.esClusterEta(2),
00451 mySCHelper.esClusterPhi(2),
00452 ele->isEB(),
00453 printDebug
00454 );
00455 }
00456 else if (fVersionType == kNoTrkVarV1) {
00457 return regressionUncertaintyNoTrkVarV1(
00458 mySCHelper.rawEnergy(),
00459 mySCHelper.eta(),
00460 mySCHelper.phi(),
00461 mySCHelper.r9(),
00462 mySCHelper.etaWidth(),
00463 mySCHelper.phiWidth(),
00464 mySCHelper.clustersSize(),
00465 mySCHelper.hadronicOverEm(),
00466 rho,
00467 nvertices,
00468 mySCHelper.seedEta(),
00469 mySCHelper.seedPhi(),
00470 mySCHelper.seedEnergy(),
00471 mySCHelper.e3x3(),
00472 mySCHelper.e5x5(),
00473 mySCHelper.sigmaIetaIeta(),
00474 mySCHelper.spp(),
00475 mySCHelper.sep(),
00476 mySCHelper.eMax(),
00477 mySCHelper.e2nd(),
00478 mySCHelper.eTop(),
00479 mySCHelper.eBottom(),
00480 mySCHelper.eLeft(),
00481 mySCHelper.eRight(),
00482 mySCHelper.e2x5Max(),
00483 mySCHelper.e2x5Top(),
00484 mySCHelper.e2x5Bottom(),
00485 mySCHelper.e2x5Left(),
00486 mySCHelper.e2x5Right(),
00487 mySCHelper.ietaSeed(),
00488 mySCHelper.iphiSeed(),
00489 mySCHelper.etaCrySeed(),
00490 mySCHelper.phiCrySeed(),
00491 mySCHelper.preshowerEnergyOverRaw(),
00492 ele->ecalDrivenSeed(),
00493 printDebug
00494 );
00495 }
00496 else if (fVersionType == kWithTrkVarV1) {
00497 return regressionUncertaintyWithTrkVarV1(
00498 mySCHelper.rawEnergy(),
00499 mySCHelper.eta(),
00500 mySCHelper.phi(),
00501 mySCHelper.r9(),
00502 mySCHelper.etaWidth(),
00503 mySCHelper.phiWidth(),
00504 mySCHelper.clustersSize(),
00505 mySCHelper.hadronicOverEm(),
00506 rho,
00507 nvertices,
00508 mySCHelper.seedEta(),
00509 mySCHelper.seedPhi(),
00510 mySCHelper.seedEnergy(),
00511 mySCHelper.e3x3(),
00512 mySCHelper.e5x5(),
00513 mySCHelper.sigmaIetaIeta(),
00514 mySCHelper.spp(),
00515 mySCHelper.sep(),
00516 mySCHelper.eMax(),
00517 mySCHelper.e2nd(),
00518 mySCHelper.eTop(),
00519 mySCHelper.eBottom(),
00520 mySCHelper.eLeft(),
00521 mySCHelper.eRight(),
00522 mySCHelper.e2x5Max(),
00523 mySCHelper.e2x5Top(),
00524 mySCHelper.e2x5Bottom(),
00525 mySCHelper.e2x5Left(),
00526 mySCHelper.e2x5Right(),
00527 mySCHelper.ietaSeed(),
00528 mySCHelper.iphiSeed(),
00529 mySCHelper.etaCrySeed(),
00530 mySCHelper.phiCrySeed(),
00531 mySCHelper.preshowerEnergyOverRaw(),
00532 ele->ecalDrivenSeed(),
00533 ele->trackMomentumAtVtx().R(),
00534 fmax(ele->fbrem(),-1.0),
00535 ele->charge(),
00536 fmin(ele->eSuperClusterOverP(), 20.0),
00537 ele->trackMomentumError(),
00538 ele->correctedEcalEnergyError(),
00539 ele->classification(),
00540 printDebug
00541 );
00542 }
00543 else if (fVersionType == kWithTrkVarV2) {
00544 return regressionUncertaintyWithTrkVarV2(
00545 mySCHelper.rawEnergy(),
00546 mySCHelper.eta(),
00547 mySCHelper.phi(),
00548 mySCHelper.r9(),
00549 mySCHelper.etaWidth(),
00550 mySCHelper.phiWidth(),
00551 mySCHelper.clustersSize(),
00552 mySCHelper.hadronicOverEm(),
00553 rho,
00554 nvertices,
00555 mySCHelper.seedEta(),
00556 mySCHelper.seedPhi(),
00557 mySCHelper.seedEnergy(),
00558 mySCHelper.e3x3(),
00559 mySCHelper.e5x5(),
00560 mySCHelper.sigmaIetaIeta(),
00561 mySCHelper.spp(),
00562 mySCHelper.sep(),
00563 mySCHelper.eMax(),
00564 mySCHelper.e2nd(),
00565 mySCHelper.eTop(),
00566 mySCHelper.eBottom(),
00567 mySCHelper.eLeft(),
00568 mySCHelper.eRight(),
00569 mySCHelper.e2x5Max(),
00570 mySCHelper.e2x5Top(),
00571 mySCHelper.e2x5Bottom(),
00572 mySCHelper.e2x5Left(),
00573 mySCHelper.e2x5Right(),
00574 mySCHelper.ietaSeed(),
00575 mySCHelper.iphiSeed(),
00576 mySCHelper.etaCrySeed(),
00577 mySCHelper.phiCrySeed(),
00578 mySCHelper.preshowerEnergyOverRaw(),
00579 ele->ecalDrivenSeed(),
00580 ele->trackMomentumAtVtx().R(),
00581 fmax(ele->fbrem(),-1.0),
00582 ele->charge(),
00583 fmin(ele->eSuperClusterOverP(), 20.0),
00584 ele->trackMomentumError(),
00585 ele->correctedEcalEnergyError(),
00586 ele->classification(),
00587 fmin(fabs(ele->deltaEtaSuperClusterTrackAtVtx()), 0.6),
00588 ele->deltaPhiSuperClusterTrackAtVtx(),
00589 ele->deltaEtaSeedClusterTrackAtCalo(),
00590 ele->deltaPhiSeedClusterTrackAtCalo(),
00591 ele->gsfTrack()->chi2() / ele->gsfTrack()->ndof(),
00592 (ele->closestCtfTrackRef().isNonnull() ? ele->closestCtfTrackRef()->hitPattern().trackerLayersWithMeasurement() : -1),
00593 fmin(ele->eEleClusterOverPout(),20.0),
00594 printDebug
00595 );
00596 }
00597 else {
00598 std::cout << "Warning: Electron Regression Type " << fVersionType << " is not supported. Reverting to default electron momentum.\n";
00599 return ele->p();
00600 }
00601 }
00602 #endif
00603
00604
00605 double ElectronEnergyRegressionEvaluate::regressionValueNoTrkVar(
00606 double SCRawEnergy,
00607 double scEta,
00608 double scPhi,
00609 double R9,
00610 double etawidth,
00611 double phiwidth,
00612 double NClusters,
00613 double HoE,
00614 double rho,
00615 double vertices,
00616 double EtaSeed,
00617 double PhiSeed,
00618 double ESeed,
00619 double E3x3Seed,
00620 double E5x5Seed,
00621 double see,
00622 double spp,
00623 double sep,
00624 double EMaxSeed,
00625 double E2ndSeed,
00626 double ETopSeed,
00627 double EBottomSeed,
00628 double ELeftSeed,
00629 double ERightSeed,
00630 double E2x5MaxSeed,
00631 double E2x5TopSeed,
00632 double E2x5BottomSeed,
00633 double E2x5LeftSeed,
00634 double E2x5RightSeed,
00635 double IEtaSeed,
00636 double IPhiSeed,
00637 double EtaCrySeed,
00638 double PhiCrySeed,
00639 double PreShowerOverRaw,
00640 bool printDebug)
00641 {
00642
00643 if (fIsInitialized == kFALSE) {
00644 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00645 return 0;
00646 }
00647
00648
00649 if (!(fVersionType == kNoTrkVar)) {
00650 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueNoTrkVar.\n";
00651 return 0;
00652 }
00653 assert(forestCorrection_ee);
00654
00655
00656 float *vals = (fabs(scEta) <= 1.479) ? new float[38] : new float[31];
00657 if (fabs(scEta) <= 1.479) {
00658 vals[0] = SCRawEnergy;
00659 vals[1] = scEta;
00660 vals[2] = scPhi;
00661 vals[3] = R9;
00662 vals[4] = E5x5Seed/SCRawEnergy;
00663 vals[5] = etawidth;
00664 vals[6] = phiwidth;
00665 vals[7] = NClusters;
00666 vals[8] = HoE;
00667 vals[9] = rho;
00668 vals[10] = vertices;
00669 vals[11] = EtaSeed - scEta;
00670 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
00671 vals[13] = ESeed/SCRawEnergy;
00672 vals[14] = E3x3Seed/ESeed;
00673 vals[15] = E5x5Seed/ESeed;
00674 vals[16] = see;
00675 vals[17] = spp;
00676 vals[18] = sep;
00677 vals[19] = EMaxSeed/ESeed;
00678 vals[20] = E2ndSeed/ESeed;
00679 vals[21] = ETopSeed/ESeed;
00680 vals[22] = EBottomSeed/ESeed;
00681 vals[23] = ELeftSeed/ESeed;
00682 vals[24] = ERightSeed/ESeed;
00683 vals[25] = E2x5MaxSeed/ESeed;
00684 vals[26] = E2x5TopSeed/ESeed;
00685 vals[27] = E2x5BottomSeed/ESeed;
00686 vals[28] = E2x5LeftSeed/ESeed;
00687 vals[29] = E2x5RightSeed/ESeed;
00688 vals[30] = IEtaSeed;
00689 vals[31] = IPhiSeed;
00690 vals[32] = ((int) IEtaSeed)%5;
00691 vals[33] = ((int) IPhiSeed)%2;
00692 vals[34] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
00693 vals[35] = ((int) IPhiSeed)%20;
00694 vals[36] = EtaCrySeed;
00695 vals[37] = PhiCrySeed;
00696 }
00697 else {
00698 vals[0] = SCRawEnergy;
00699 vals[1] = scEta;
00700 vals[2] = scPhi;
00701 vals[3] = R9;
00702 vals[4] = E5x5Seed/SCRawEnergy;
00703 vals[5] = etawidth;
00704 vals[6] = phiwidth;
00705 vals[7] = NClusters;
00706 vals[8] = HoE;
00707 vals[9] = rho;
00708 vals[10] = vertices;
00709 vals[11] = EtaSeed - scEta;
00710 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
00711 vals[13] = ESeed/SCRawEnergy;
00712 vals[14] = E3x3Seed/ESeed;
00713 vals[15] = E5x5Seed/ESeed;
00714 vals[16] = see;
00715 vals[17] = spp;
00716 vals[18] = sep;
00717 vals[19] = EMaxSeed/ESeed;
00718 vals[20] = E2ndSeed/ESeed;
00719 vals[21] = ETopSeed/ESeed;
00720 vals[22] = EBottomSeed/ESeed;
00721 vals[23] = ELeftSeed/ESeed;
00722 vals[24] = ERightSeed/ESeed;
00723 vals[25] = E2x5MaxSeed/ESeed;
00724 vals[26] = E2x5TopSeed/ESeed;
00725 vals[27] = E2x5BottomSeed/ESeed;
00726 vals[28] = E2x5LeftSeed/ESeed;
00727 vals[29] = E2x5RightSeed/ESeed;
00728 vals[30] = PreShowerOverRaw;
00729 }
00730
00731
00732 double regressionResult = 0;
00733 Int_t BinIndex = -1;
00734
00735 if (fVersionType == kNoTrkVar) {
00736 if (fabs(scEta) <= 1.479) {
00737 regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
00738 BinIndex = 0;
00739 }
00740 else {
00741 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
00742 BinIndex = 1;
00743 }
00744 }
00745
00746
00747 if (printDebug) {
00748 if ( fabs(scEta) <= 1.479) {
00749 std::cout << "Barrel :";
00750 for (unsigned int v=0; v < 38; ++v) std::cout << vals[v] << ", ";
00751 std::cout << "\n";
00752 }
00753 else {
00754 std::cout << "Endcap :";
00755 for (unsigned int v=0; v < 31; ++v) std::cout << vals[v] << ", ";
00756 std::cout << "\n";
00757 }
00758 std::cout << "BinIndex : " << BinIndex << "\n";
00759 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
00760 std::cout << "regression energy = " << regressionResult << std::endl;
00761 }
00762
00763
00764
00765 delete[] vals;
00766 return regressionResult;
00767 }
00768
00769 double ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVar(
00770 double SCRawEnergy,
00771 double scEta,
00772 double scPhi,
00773 double R9,
00774 double etawidth,
00775 double phiwidth,
00776 double NClusters,
00777 double HoE,
00778 double rho,
00779 double vertices,
00780 double EtaSeed,
00781 double PhiSeed,
00782 double ESeed,
00783 double E3x3Seed,
00784 double E5x5Seed,
00785 double see,
00786 double spp,
00787 double sep,
00788 double EMaxSeed,
00789 double E2ndSeed,
00790 double ETopSeed,
00791 double EBottomSeed,
00792 double ELeftSeed,
00793 double ERightSeed,
00794 double E2x5MaxSeed,
00795 double E2x5TopSeed,
00796 double E2x5BottomSeed,
00797 double E2x5LeftSeed,
00798 double E2x5RightSeed,
00799 double IEtaSeed,
00800 double IPhiSeed,
00801 double EtaCrySeed,
00802 double PhiCrySeed,
00803 double PreShowerOverRaw,
00804 bool printDebug)
00805 {
00806
00807 if (fIsInitialized == kFALSE) {
00808 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00809 return 0;
00810 }
00811
00812
00813 if (!(fVersionType == kNoTrkVar)) {
00814 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueNoTrkVar.\n";
00815 return 0;
00816 }
00817
00818
00819 float *vals = (fabs(scEta) <= 1.479) ? new float[38] : new float[31];
00820 if (fabs(scEta) <= 1.479) {
00821 vals[0] = SCRawEnergy;
00822 vals[1] = scEta;
00823 vals[2] = scPhi;
00824 vals[3] = R9;
00825 vals[4] = E5x5Seed/SCRawEnergy;
00826 vals[5] = etawidth;
00827 vals[6] = phiwidth;
00828 vals[7] = NClusters;
00829 vals[8] = HoE;
00830 vals[9] = rho;
00831 vals[10] = vertices;
00832 vals[11] = EtaSeed - scEta;
00833 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
00834 vals[13] = ESeed/SCRawEnergy;
00835 vals[14] = E3x3Seed/ESeed;
00836 vals[15] = E5x5Seed/ESeed;
00837 vals[16] = see;
00838 vals[17] = spp;
00839 vals[18] = sep;
00840 vals[19] = EMaxSeed/ESeed;
00841 vals[20] = E2ndSeed/ESeed;
00842 vals[21] = ETopSeed/ESeed;
00843 vals[22] = EBottomSeed/ESeed;
00844 vals[23] = ELeftSeed/ESeed;
00845 vals[24] = ERightSeed/ESeed;
00846 vals[25] = E2x5MaxSeed/ESeed;
00847 vals[26] = E2x5TopSeed/ESeed;
00848 vals[27] = E2x5BottomSeed/ESeed;
00849 vals[28] = E2x5LeftSeed/ESeed;
00850 vals[29] = E2x5RightSeed/ESeed;
00851 vals[30] = IEtaSeed;
00852 vals[31] = IPhiSeed;
00853 vals[32] = ((int) IEtaSeed)%5;
00854 vals[33] = ((int) IPhiSeed)%2;
00855 vals[34] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
00856 vals[35] = ((int) IPhiSeed)%20;
00857 vals[36] = EtaCrySeed;
00858 vals[37] = PhiCrySeed;
00859 }
00860 else {
00861 vals[0] = SCRawEnergy;
00862 vals[1] = scEta;
00863 vals[2] = scPhi;
00864 vals[3] = R9;
00865 vals[4] = E5x5Seed/SCRawEnergy;
00866 vals[5] = etawidth;
00867 vals[6] = phiwidth;
00868 vals[7] = NClusters;
00869 vals[8] = HoE;
00870 vals[9] = rho;
00871 vals[10] = vertices;
00872 vals[11] = EtaSeed - scEta;
00873 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
00874 vals[13] = ESeed/SCRawEnergy;
00875 vals[14] = E3x3Seed/ESeed;
00876 vals[15] = E5x5Seed/ESeed;
00877 vals[16] = see;
00878 vals[17] = spp;
00879 vals[18] = sep;
00880 vals[19] = EMaxSeed/ESeed;
00881 vals[20] = E2ndSeed/ESeed;
00882 vals[21] = ETopSeed/ESeed;
00883 vals[22] = EBottomSeed/ESeed;
00884 vals[23] = ELeftSeed/ESeed;
00885 vals[24] = ERightSeed/ESeed;
00886 vals[25] = E2x5MaxSeed/ESeed;
00887 vals[26] = E2x5TopSeed/ESeed;
00888 vals[27] = E2x5BottomSeed/ESeed;
00889 vals[28] = E2x5LeftSeed/ESeed;
00890 vals[29] = E2x5RightSeed/ESeed;
00891 vals[30] = PreShowerOverRaw;
00892 }
00893
00894
00895 double regressionResult = 0;
00896 Int_t BinIndex = -1;
00897
00898 if (fVersionType == kNoTrkVar) {
00899 if (fabs(scEta) <= 1.479) {
00900 regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
00901 BinIndex = 0;
00902 }
00903 else {
00904 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
00905 BinIndex = 1;
00906 }
00907 }
00908
00909
00910 if (printDebug) {
00911 if (fabs(scEta) <= 1.479) {
00912 std::cout << "Barrel :";
00913 for (unsigned int v=0; v < 38; ++v) std::cout << vals[v] << ", ";
00914 std::cout << "\n";
00915 }
00916 else {
00917 std::cout << "Endcap :";
00918 for (unsigned int v=0; v < 31; ++v) std::cout << vals[v] << ", ";
00919 std::cout << "\n";
00920 }
00921 std::cout << "BinIndex : " << BinIndex << "\n";
00922 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
00923 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
00924 }
00925
00926
00927
00928 delete[] vals;
00929 return regressionResult;
00930 }
00931
00932
00933
00934
00935 double ElectronEnergyRegressionEvaluate::regressionValueNoTrkVarV1(
00936 double SCRawEnergy,
00937 double scEta,
00938 double scPhi,
00939 double R9,
00940 double etawidth,
00941 double phiwidth,
00942 double NClusters,
00943 double HoE,
00944 double rho,
00945 double vertices,
00946 double EtaSeed,
00947 double PhiSeed,
00948 double ESeed,
00949 double E3x3Seed,
00950 double E5x5Seed,
00951 double see,
00952 double spp,
00953 double sep,
00954 double EMaxSeed,
00955 double E2ndSeed,
00956 double ETopSeed,
00957 double EBottomSeed,
00958 double ELeftSeed,
00959 double ERightSeed,
00960 double E2x5MaxSeed,
00961 double E2x5TopSeed,
00962 double E2x5BottomSeed,
00963 double E2x5LeftSeed,
00964 double E2x5RightSeed,
00965 double IEtaSeed,
00966 double IPhiSeed,
00967 double EtaCrySeed,
00968 double PhiCrySeed,
00969 double PreShowerOverRaw,
00970 int IsEcalDriven,
00971 bool printDebug)
00972 {
00973
00974 if (fIsInitialized == kFALSE) {
00975 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00976 return 0;
00977 }
00978
00979
00980 if (!(fVersionType == kNoTrkVarV1)) {
00981 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueNoTrkVar.\n";
00982 return 0;
00983 }
00984
00985
00986 float *vals = (fabs(scEta) <= 1.479) ? new float[39] : new float[32];
00987 if (fabs(scEta) <= 1.479) {
00988 vals[0] = SCRawEnergy;
00989 vals[1] = scEta;
00990 vals[2] = scPhi;
00991 vals[3] = R9;
00992 vals[4] = E5x5Seed/SCRawEnergy;
00993 vals[5] = etawidth;
00994 vals[6] = phiwidth;
00995 vals[7] = NClusters;
00996 vals[8] = HoE;
00997 vals[9] = rho;
00998 vals[10] = vertices;
00999 vals[11] = EtaSeed - scEta;
01000 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01001 vals[13] = ESeed/SCRawEnergy;
01002 vals[14] = E3x3Seed/ESeed;
01003 vals[15] = E5x5Seed/ESeed;
01004 vals[16] = see;
01005 vals[17] = spp;
01006 vals[18] = sep;
01007 vals[19] = EMaxSeed/ESeed;
01008 vals[20] = E2ndSeed/ESeed;
01009 vals[21] = ETopSeed/ESeed;
01010 vals[22] = EBottomSeed/ESeed;
01011 vals[23] = ELeftSeed/ESeed;
01012 vals[24] = ERightSeed/ESeed;
01013 vals[25] = E2x5MaxSeed/ESeed;
01014 vals[26] = E2x5TopSeed/ESeed;
01015 vals[27] = E2x5BottomSeed/ESeed;
01016 vals[28] = E2x5LeftSeed/ESeed;
01017 vals[29] = E2x5RightSeed/ESeed;
01018 vals[30] = IsEcalDriven;
01019 vals[31] = IEtaSeed;
01020 vals[32] = IPhiSeed;
01021 vals[33] = ((int) IEtaSeed)%5;
01022 vals[34] = ((int) IPhiSeed)%2;
01023 vals[35] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01024 vals[36] = ((int) IPhiSeed)%20;
01025 vals[37] = EtaCrySeed;
01026 vals[38] = PhiCrySeed;
01027 }
01028 else {
01029 vals[0] = SCRawEnergy;
01030 vals[1] = scEta;
01031 vals[2] = scPhi;
01032 vals[3] = R9;
01033 vals[4] = E5x5Seed/SCRawEnergy;
01034 vals[5] = etawidth;
01035 vals[6] = phiwidth;
01036 vals[7] = NClusters;
01037 vals[8] = HoE;
01038 vals[9] = rho;
01039 vals[10] = vertices;
01040 vals[11] = EtaSeed - scEta;
01041 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01042 vals[13] = ESeed/SCRawEnergy;
01043 vals[14] = E3x3Seed/ESeed;
01044 vals[15] = E5x5Seed/ESeed;
01045 vals[16] = see;
01046 vals[17] = spp;
01047 vals[18] = sep;
01048 vals[19] = EMaxSeed/ESeed;
01049 vals[20] = E2ndSeed/ESeed;
01050 vals[21] = ETopSeed/ESeed;
01051 vals[22] = EBottomSeed/ESeed;
01052 vals[23] = ELeftSeed/ESeed;
01053 vals[24] = ERightSeed/ESeed;
01054 vals[25] = E2x5MaxSeed/ESeed;
01055 vals[26] = E2x5TopSeed/ESeed;
01056 vals[27] = E2x5BottomSeed/ESeed;
01057 vals[28] = E2x5LeftSeed/ESeed;
01058 vals[29] = E2x5RightSeed/ESeed;
01059 vals[30] = IsEcalDriven;
01060 vals[31] = PreShowerOverRaw;
01061 }
01062
01063
01064 double regressionResult = 0;
01065 Int_t BinIndex = -1;
01066
01067 if (fVersionType == kNoTrkVarV1) {
01068 if (fabs(scEta) <= 1.479) {
01069 regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
01070 BinIndex = 0;
01071 }
01072 else {
01073 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
01074 BinIndex = 1;
01075 }
01076 }
01077
01078
01079 if (printDebug) {
01080 if ( fabs(scEta) <= 1.479) {
01081 std::cout << "Barrel :";
01082 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
01083 std::cout << "\n";
01084 }
01085 else {
01086 std::cout << "Endcap :";
01087 for (unsigned int v=0; v < 32; ++v) std::cout << vals[v] << ", ";
01088 std::cout << "\n";
01089 }
01090 std::cout << "BinIndex : " << BinIndex << "\n";
01091 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01092 std::cout << "regression energy = " << regressionResult << std::endl;
01093 }
01094
01095
01096
01097 delete[] vals;
01098 return regressionResult;
01099 }
01100
01101 double ElectronEnergyRegressionEvaluate::regressionUncertaintyNoTrkVarV1(
01102 double SCRawEnergy,
01103 double scEta,
01104 double scPhi,
01105 double R9,
01106 double etawidth,
01107 double phiwidth,
01108 double NClusters,
01109 double HoE,
01110 double rho,
01111 double vertices,
01112 double EtaSeed,
01113 double PhiSeed,
01114 double ESeed,
01115 double E3x3Seed,
01116 double E5x5Seed,
01117 double see,
01118 double spp,
01119 double sep,
01120 double EMaxSeed,
01121 double E2ndSeed,
01122 double ETopSeed,
01123 double EBottomSeed,
01124 double ELeftSeed,
01125 double ERightSeed,
01126 double E2x5MaxSeed,
01127 double E2x5TopSeed,
01128 double E2x5BottomSeed,
01129 double E2x5LeftSeed,
01130 double E2x5RightSeed,
01131 double IEtaSeed,
01132 double IPhiSeed,
01133 double EtaCrySeed,
01134 double PhiCrySeed,
01135 double PreShowerOverRaw,
01136 int IsEcalDriven,
01137 bool printDebug)
01138 {
01139
01140 if (fIsInitialized == kFALSE) {
01141 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01142 return 0;
01143 }
01144
01145
01146 if (!(fVersionType == kNoTrkVarV1)) {
01147 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueNoTrkVar.\n";
01148 return 0;
01149 }
01150
01151
01152 float *vals = (fabs(scEta) <= 1.479) ? new float[39] : new float[32];
01153 if (fabs(scEta) <= 1.479) {
01154 vals[0] = SCRawEnergy;
01155 vals[1] = scEta;
01156 vals[2] = scPhi;
01157 vals[3] = R9;
01158 vals[4] = E5x5Seed/SCRawEnergy;
01159 vals[5] = etawidth;
01160 vals[6] = phiwidth;
01161 vals[7] = NClusters;
01162 vals[8] = HoE;
01163 vals[9] = rho;
01164 vals[10] = vertices;
01165 vals[11] = EtaSeed - scEta;
01166 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01167 vals[13] = ESeed/SCRawEnergy;
01168 vals[14] = E3x3Seed/ESeed;
01169 vals[15] = E5x5Seed/ESeed;
01170 vals[16] = see;
01171 vals[17] = spp;
01172 vals[18] = sep;
01173 vals[19] = EMaxSeed/ESeed;
01174 vals[20] = E2ndSeed/ESeed;
01175 vals[21] = ETopSeed/ESeed;
01176 vals[22] = EBottomSeed/ESeed;
01177 vals[23] = ELeftSeed/ESeed;
01178 vals[24] = ERightSeed/ESeed;
01179 vals[25] = E2x5MaxSeed/ESeed;
01180 vals[26] = E2x5TopSeed/ESeed;
01181 vals[27] = E2x5BottomSeed/ESeed;
01182 vals[28] = E2x5LeftSeed/ESeed;
01183 vals[29] = E2x5RightSeed/ESeed;
01184 vals[30] = IsEcalDriven;
01185 vals[31] = IEtaSeed;
01186 vals[32] = IPhiSeed;
01187 vals[33] = ((int) IEtaSeed)%5;
01188 vals[34] = ((int) IPhiSeed)%2;
01189 vals[35] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01190 vals[36] = ((int) IPhiSeed)%20;
01191 vals[37] = EtaCrySeed;
01192 vals[38] = PhiCrySeed;
01193 }
01194 else {
01195 vals[0] = SCRawEnergy;
01196 vals[1] = scEta;
01197 vals[2] = scPhi;
01198 vals[3] = R9;
01199 vals[4] = E5x5Seed/SCRawEnergy;
01200 vals[5] = etawidth;
01201 vals[6] = phiwidth;
01202 vals[7] = NClusters;
01203 vals[8] = HoE;
01204 vals[9] = rho;
01205 vals[10] = vertices;
01206 vals[11] = EtaSeed - scEta;
01207 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01208 vals[13] = ESeed/SCRawEnergy;
01209 vals[14] = E3x3Seed/ESeed;
01210 vals[15] = E5x5Seed/ESeed;
01211 vals[16] = see;
01212 vals[17] = spp;
01213 vals[18] = sep;
01214 vals[19] = EMaxSeed/ESeed;
01215 vals[20] = E2ndSeed/ESeed;
01216 vals[21] = ETopSeed/ESeed;
01217 vals[22] = EBottomSeed/ESeed;
01218 vals[23] = ELeftSeed/ESeed;
01219 vals[24] = ERightSeed/ESeed;
01220 vals[25] = E2x5MaxSeed/ESeed;
01221 vals[26] = E2x5TopSeed/ESeed;
01222 vals[27] = E2x5BottomSeed/ESeed;
01223 vals[28] = E2x5LeftSeed/ESeed;
01224 vals[29] = E2x5RightSeed/ESeed;
01225 vals[30] = IsEcalDriven;
01226 vals[31] = PreShowerOverRaw;
01227 }
01228
01229
01230 double regressionResult = 0;
01231 Int_t BinIndex = -1;
01232
01233 if (fVersionType == kNoTrkVarV1) {
01234 if (fabs(scEta) <= 1.479) {
01235 regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
01236 BinIndex = 0;
01237 }
01238 else {
01239 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
01240 BinIndex = 1;
01241 }
01242 }
01243
01244
01245 if (printDebug) {
01246 if (fabs(scEta) <= 1.479) {
01247 std::cout << "Barrel :";
01248 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
01249 std::cout << "\n";
01250 }
01251 else {
01252 std::cout << "Endcap :";
01253 for (unsigned int v=0; v < 32; ++v) std::cout << vals[v] << ", ";
01254 std::cout << "\n";
01255 }
01256 std::cout << "BinIndex : " << BinIndex << "\n";
01257 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01258 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
01259 }
01260
01261
01262
01263 delete[] vals;
01264 return regressionResult;
01265 }
01266
01267
01268
01269
01270
01271 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVar(
01272 double electronP,
01273 double SCRawEnergy,
01274 double scEta,
01275 double scPhi,
01276 double R9,
01277 double etawidth,
01278 double phiwidth,
01279 double NClusters,
01280 double HoE,
01281 double rho,
01282 double vertices,
01283 double EtaSeed,
01284 double PhiSeed,
01285 double ESeed,
01286 double E3x3Seed,
01287 double E5x5Seed,
01288 double see,
01289 double spp,
01290 double sep,
01291 double EMaxSeed,
01292 double E2ndSeed,
01293 double ETopSeed,
01294 double EBottomSeed,
01295 double ELeftSeed,
01296 double ERightSeed,
01297 double E2x5MaxSeed,
01298 double E2x5TopSeed,
01299 double E2x5BottomSeed,
01300 double E2x5LeftSeed,
01301 double E2x5RightSeed,
01302 double pt,
01303 double GsfTrackPIn,
01304 double fbrem,
01305 double Charge,
01306 double EoP,
01307 double IEtaSeed,
01308 double IPhiSeed,
01309 double EtaCrySeed,
01310 double PhiCrySeed,
01311 double PreShowerOverRaw,
01312 bool printDebug)
01313 {
01314
01315 if (fIsInitialized == kFALSE) {
01316 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01317 return 0;
01318 }
01319
01320
01321 assert(fVersionType == kWithTrkVar);
01322
01323 float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
01324 if (fabs(scEta) <= 1.479) {
01325 vals[0] = SCRawEnergy;
01326 vals[1] = scEta;
01327 vals[2] = scPhi;
01328 vals[3] = R9;
01329 vals[4] = E5x5Seed/SCRawEnergy;
01330 vals[5] = etawidth;
01331 vals[6] = phiwidth;
01332 vals[7] = NClusters;
01333 vals[8] = HoE;
01334 vals[9] = rho;
01335 vals[10] = vertices;
01336 vals[11] = EtaSeed - scEta;
01337 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01338 vals[13] = ESeed/SCRawEnergy;
01339 vals[14] = E3x3Seed/ESeed;
01340 vals[15] = E5x5Seed/ESeed;
01341 vals[16] = see;
01342 vals[17] = spp;
01343 vals[18] = sep;
01344 vals[19] = EMaxSeed/ESeed;
01345 vals[20] = E2ndSeed/ESeed;
01346 vals[21] = ETopSeed/ESeed;
01347 vals[22] = EBottomSeed/ESeed;
01348 vals[23] = ELeftSeed/ESeed;
01349 vals[24] = ERightSeed/ESeed;
01350 vals[25] = E2x5MaxSeed/ESeed;
01351 vals[26] = E2x5TopSeed/ESeed;
01352 vals[27] = E2x5BottomSeed/ESeed;
01353 vals[28] = E2x5LeftSeed/ESeed;
01354 vals[29] = E2x5RightSeed/ESeed;
01355 vals[30] = pt;
01356 vals[31] = GsfTrackPIn;
01357 vals[32] = fbrem;
01358 vals[33] = Charge;
01359 vals[34] = EoP;
01360 vals[35] = IEtaSeed;
01361 vals[36] = IPhiSeed;
01362 vals[37] = ((int) IEtaSeed)%5;
01363 vals[38] = ((int) IPhiSeed)%2;
01364 vals[39] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01365 vals[40] = ((int) IPhiSeed)%20;
01366 vals[41] = EtaCrySeed;
01367 vals[42] = PhiCrySeed;
01368 }
01369
01370 else {
01371 vals[0] = SCRawEnergy;
01372 vals[1] = scEta;
01373 vals[2] = scPhi;
01374 vals[3] = R9;
01375 vals[4] = E5x5Seed/SCRawEnergy;
01376 vals[5] = etawidth;
01377 vals[6] = phiwidth;
01378 vals[7] = NClusters;
01379 vals[8] = HoE;
01380 vals[9] = rho;
01381 vals[10] = vertices;
01382 vals[11] = EtaSeed - scEta;
01383 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01384 vals[13] = ESeed/SCRawEnergy;
01385 vals[14] = E3x3Seed/ESeed;
01386 vals[15] = E5x5Seed/ESeed;
01387 vals[16] = see;
01388 vals[17] = spp;
01389 vals[18] = sep;
01390 vals[19] = EMaxSeed/ESeed;
01391 vals[20] = E2ndSeed/ESeed;
01392 vals[21] = ETopSeed/ESeed;
01393 vals[22] = EBottomSeed/ESeed;
01394 vals[23] = ELeftSeed/ESeed;
01395 vals[24] = ERightSeed/ESeed;
01396 vals[25] = E2x5MaxSeed/ESeed;
01397 vals[26] = E2x5TopSeed/ESeed;
01398 vals[27] = E2x5BottomSeed/ESeed;
01399 vals[28] = E2x5LeftSeed/ESeed;
01400 vals[29] = E2x5RightSeed/ESeed;
01401 vals[30] = pt;
01402 vals[31] = GsfTrackPIn;
01403 vals[32] = fbrem;
01404 vals[33] = Charge;
01405 vals[34] = EoP;
01406 vals[35] = PreShowerOverRaw;
01407 }
01408
01409
01410 double regressionResult = 0;
01411
01412 if (fVersionType == kWithTrkVar) {
01413 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
01414 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
01415 }
01416
01417
01418
01419 if (printDebug) {
01420 if (scEta <= 1.479) {
01421 std::cout << "Barrel :";
01422 for (unsigned int v=0; v < 43; ++v) std::cout << vals[v] << ", ";
01423 std::cout << "\n";
01424 }
01425 else {
01426 std::cout << "Endcap :";
01427 for (unsigned int v=0; v < 36; ++v) std::cout << vals[v] << ", ";
01428 std::cout << "\n";
01429 }
01430 std::cout << "pt = " << pt << " : SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01431 std::cout << "regression energy = " << regressionResult << std::endl;
01432 }
01433
01434
01435 delete[] vals;
01436 return regressionResult;
01437 }
01438
01439
01440
01441
01442
01443
01444 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVar(
01445 double electronP,
01446 double SCRawEnergy,
01447 double scEta,
01448 double scPhi,
01449 double R9,
01450 double etawidth,
01451 double phiwidth,
01452 double NClusters,
01453 double HoE,
01454 double rho,
01455 double vertices,
01456 double EtaSeed,
01457 double PhiSeed,
01458 double ESeed,
01459 double E3x3Seed,
01460 double E5x5Seed,
01461 double see,
01462 double spp,
01463 double sep,
01464 double EMaxSeed,
01465 double E2ndSeed,
01466 double ETopSeed,
01467 double EBottomSeed,
01468 double ELeftSeed,
01469 double ERightSeed,
01470 double E2x5MaxSeed,
01471 double E2x5TopSeed,
01472 double E2x5BottomSeed,
01473 double E2x5LeftSeed,
01474 double E2x5RightSeed,
01475 double pt,
01476 double GsfTrackPIn,
01477 double fbrem,
01478 double Charge,
01479 double EoP,
01480 double IEtaSeed,
01481 double IPhiSeed,
01482 double EtaCrySeed,
01483 double PhiCrySeed,
01484 double PreShowerOverRaw,
01485 bool printDebug)
01486 {
01487
01488 if (fIsInitialized == kFALSE) {
01489 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01490 return 0;
01491 }
01492
01493
01494 assert(fVersionType == kWithTrkVar);
01495
01496 float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
01497 if (fabs(scEta) <= 1.479) {
01498 vals[0] = SCRawEnergy;
01499 vals[1] = scEta;
01500 vals[2] = scPhi;
01501 vals[3] = R9;
01502 vals[4] = E5x5Seed/SCRawEnergy;
01503 vals[5] = etawidth;
01504 vals[6] = phiwidth;
01505 vals[7] = NClusters;
01506 vals[8] = HoE;
01507 vals[9] = rho;
01508 vals[10] = vertices;
01509 vals[11] = EtaSeed - scEta;
01510 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01511 vals[13] = ESeed/SCRawEnergy;
01512 vals[14] = E3x3Seed/ESeed;
01513 vals[15] = E5x5Seed/ESeed;
01514 vals[16] = see;
01515 vals[17] = spp;
01516 vals[18] = sep;
01517 vals[19] = EMaxSeed/ESeed;
01518 vals[20] = E2ndSeed/ESeed;
01519 vals[21] = ETopSeed/ESeed;
01520 vals[22] = EBottomSeed/ESeed;
01521 vals[23] = ELeftSeed/ESeed;
01522 vals[24] = ERightSeed/ESeed;
01523 vals[25] = E2x5MaxSeed/ESeed;
01524 vals[26] = E2x5TopSeed/ESeed;
01525 vals[27] = E2x5BottomSeed/ESeed;
01526 vals[28] = E2x5LeftSeed/ESeed;
01527 vals[29] = E2x5RightSeed/ESeed;
01528 vals[30] = pt;
01529 vals[31] = GsfTrackPIn;
01530 vals[32] = fbrem;
01531 vals[33] = Charge;
01532 vals[34] = EoP;
01533 vals[35] = IEtaSeed;
01534 vals[36] = IPhiSeed;
01535 vals[37] = ((int) IEtaSeed)%5;
01536 vals[38] = ((int) IPhiSeed)%2;
01537 vals[39] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01538 vals[40] = ((int) IPhiSeed)%20;
01539 vals[41] = EtaCrySeed;
01540 vals[42] = PhiCrySeed;
01541 }
01542
01543 else {
01544 vals[0] = SCRawEnergy;
01545 vals[1] = scEta;
01546 vals[2] = scPhi;
01547 vals[3] = R9;
01548 vals[4] = E5x5Seed/SCRawEnergy;
01549 vals[5] = etawidth;
01550 vals[6] = phiwidth;
01551 vals[7] = NClusters;
01552 vals[8] = HoE;
01553 vals[9] = rho;
01554 vals[10] = vertices;
01555 vals[11] = EtaSeed - scEta;
01556 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01557 vals[13] = ESeed/SCRawEnergy;
01558 vals[14] = E3x3Seed/ESeed;
01559 vals[15] = E5x5Seed/ESeed;
01560 vals[16] = see;
01561 vals[17] = spp;
01562 vals[18] = sep;
01563 vals[19] = EMaxSeed/ESeed;
01564 vals[20] = E2ndSeed/ESeed;
01565 vals[21] = ETopSeed/ESeed;
01566 vals[22] = EBottomSeed/ESeed;
01567 vals[23] = ELeftSeed/ESeed;
01568 vals[24] = ERightSeed/ESeed;
01569 vals[25] = E2x5MaxSeed/ESeed;
01570 vals[26] = E2x5TopSeed/ESeed;
01571 vals[27] = E2x5BottomSeed/ESeed;
01572 vals[28] = E2x5LeftSeed/ESeed;
01573 vals[29] = E2x5RightSeed/ESeed;
01574 vals[30] = pt;
01575 vals[31] = GsfTrackPIn;
01576 vals[32] = fbrem;
01577 vals[33] = Charge;
01578 vals[34] = EoP;
01579 vals[35] = PreShowerOverRaw;
01580 }
01581
01582
01583 double regressionResult = 0;
01584
01585 if (fVersionType == kWithTrkVar) {
01586 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
01587 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
01588 }
01589
01590
01591 if (printDebug) {
01592 if (scEta <= 1.479) {
01593 std::cout << "Barrel :";
01594 for (unsigned int v=0; v < 43; ++v) std::cout << vals[v] << ", ";
01595 std::cout << "\n";
01596 }
01597 else {
01598 std::cout << "Endcap :";
01599 for (unsigned int v=0; v < 36; ++v) std::cout << vals[v] << ", ";
01600 std::cout << "\n";
01601 }
01602 std::cout << "pt = " << pt << " : SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01603 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
01604 }
01605
01606
01607
01608 delete[] vals;
01609 return regressionResult;
01610 }
01611
01612
01613
01614
01615 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV1(
01616 double SCRawEnergy,
01617 double scEta,
01618 double scPhi,
01619 double R9,
01620 double etawidth,
01621 double phiwidth,
01622 double NClusters,
01623 double HoE,
01624 double rho,
01625 double vertices,
01626 double EtaSeed,
01627 double PhiSeed,
01628 double ESeed,
01629 double E3x3Seed,
01630 double E5x5Seed,
01631 double see,
01632 double spp,
01633 double sep,
01634 double EMaxSeed,
01635 double E2ndSeed,
01636 double ETopSeed,
01637 double EBottomSeed,
01638 double ELeftSeed,
01639 double ERightSeed,
01640 double E2x5MaxSeed,
01641 double E2x5TopSeed,
01642 double E2x5BottomSeed,
01643 double E2x5LeftSeed,
01644 double E2x5RightSeed,
01645 double IEtaSeed,
01646 double IPhiSeed,
01647 double EtaCrySeed,
01648 double PhiCrySeed,
01649 double PreShowerOverRaw,
01650 int IsEcalDriven,
01651 double GsfTrackPIn,
01652 double fbrem,
01653 double Charge,
01654 double EoP,
01655 double TrackMomentumError,
01656 double EcalEnergyError,
01657 int Classification,
01658 bool printDebug)
01659 {
01660
01661 if (fIsInitialized == kFALSE) {
01662 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01663 return 0;
01664 }
01665
01666
01667 assert(fVersionType == kWithTrkVarV1);
01668
01669 float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
01670 if (fabs(scEta) <= 1.479) {
01671 vals[0] = SCRawEnergy;
01672 vals[1] = scEta;
01673 vals[2] = scPhi;
01674 vals[3] = R9;
01675 vals[4] = E5x5Seed/SCRawEnergy;
01676 vals[5] = etawidth;
01677 vals[6] = phiwidth;
01678 vals[7] = NClusters;
01679 vals[8] = HoE;
01680 vals[9] = rho;
01681 vals[10] = vertices;
01682 vals[11] = EtaSeed - scEta;
01683 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01684 vals[13] = ESeed/SCRawEnergy;
01685 vals[14] = E3x3Seed/ESeed;
01686 vals[15] = E5x5Seed/ESeed;
01687 vals[16] = see;
01688 vals[17] = spp;
01689 vals[18] = sep;
01690 vals[19] = EMaxSeed/ESeed;
01691 vals[20] = E2ndSeed/ESeed;
01692 vals[21] = ETopSeed/ESeed;
01693 vals[22] = EBottomSeed/ESeed;
01694 vals[23] = ELeftSeed/ESeed;
01695 vals[24] = ERightSeed/ESeed;
01696 vals[25] = E2x5MaxSeed/ESeed;
01697 vals[26] = E2x5TopSeed/ESeed;
01698 vals[27] = E2x5BottomSeed/ESeed;
01699 vals[28] = E2x5LeftSeed/ESeed;
01700 vals[29] = E2x5RightSeed/ESeed;
01701 vals[30] = IsEcalDriven;
01702 vals[31] = GsfTrackPIn;
01703 vals[32] = fbrem;
01704 vals[33] = Charge;
01705 vals[34] = EoP;
01706 vals[35] = TrackMomentumError/GsfTrackPIn;
01707 vals[36] = EcalEnergyError/SCRawEnergy;
01708 vals[37] = Classification;
01709 vals[38] = IEtaSeed;
01710 vals[39] = IPhiSeed;
01711 vals[40] = ((int) IEtaSeed)%5;
01712 vals[41] = ((int) IPhiSeed)%2;
01713 vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01714 vals[43] = ((int) IPhiSeed)%20;
01715 vals[44] = EtaCrySeed;
01716 vals[45] = PhiCrySeed;
01717 }
01718
01719 else {
01720 vals[0] = SCRawEnergy;
01721 vals[1] = scEta;
01722 vals[2] = scPhi;
01723 vals[3] = R9;
01724 vals[4] = E5x5Seed/SCRawEnergy;
01725 vals[5] = etawidth;
01726 vals[6] = phiwidth;
01727 vals[7] = NClusters;
01728 vals[8] = HoE;
01729 vals[9] = rho;
01730 vals[10] = vertices;
01731 vals[11] = EtaSeed - scEta;
01732 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01733 vals[13] = ESeed/SCRawEnergy;
01734 vals[14] = E3x3Seed/ESeed;
01735 vals[15] = E5x5Seed/ESeed;
01736 vals[16] = see;
01737 vals[17] = spp;
01738 vals[18] = sep;
01739 vals[19] = EMaxSeed/ESeed;
01740 vals[20] = E2ndSeed/ESeed;
01741 vals[21] = ETopSeed/ESeed;
01742 vals[22] = EBottomSeed/ESeed;
01743 vals[23] = ELeftSeed/ESeed;
01744 vals[24] = ERightSeed/ESeed;
01745 vals[25] = E2x5MaxSeed/ESeed;
01746 vals[26] = E2x5TopSeed/ESeed;
01747 vals[27] = E2x5BottomSeed/ESeed;
01748 vals[28] = E2x5LeftSeed/ESeed;
01749 vals[29] = E2x5RightSeed/ESeed;
01750 vals[30] = IsEcalDriven;
01751 vals[31] = GsfTrackPIn;
01752 vals[32] = fbrem;
01753 vals[33] = Charge;
01754 vals[34] = EoP;
01755 vals[35] = TrackMomentumError/GsfTrackPIn;
01756 vals[36] = EcalEnergyError/SCRawEnergy;
01757 vals[37] = Classification;
01758 vals[38] = PreShowerOverRaw;
01759 }
01760
01761
01762 double regressionResult = 0;
01763
01764 if (fVersionType == kWithTrkVarV1) {
01765 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
01766 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
01767 }
01768
01769
01770
01771 if (printDebug) {
01772 if (fabs(scEta) <= 1.479) {
01773 std::cout << "Barrel :";
01774 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
01775 std::cout << "\n";
01776 }
01777 else {
01778 std::cout << "Endcap :";
01779 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
01780 std::cout << "\n";
01781 }
01782 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01783 std::cout << "regression energy = " << regressionResult << std::endl;
01784 }
01785
01786
01787 delete[] vals;
01788 return regressionResult;
01789 }
01790
01791
01792
01793
01794 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1(
01795 double SCRawEnergy,
01796 double scEta,
01797 double scPhi,
01798 double R9,
01799 double etawidth,
01800 double phiwidth,
01801 double NClusters,
01802 double HoE,
01803 double rho,
01804 double vertices,
01805 double EtaSeed,
01806 double PhiSeed,
01807 double ESeed,
01808 double E3x3Seed,
01809 double E5x5Seed,
01810 double see,
01811 double spp,
01812 double sep,
01813 double EMaxSeed,
01814 double E2ndSeed,
01815 double ETopSeed,
01816 double EBottomSeed,
01817 double ELeftSeed,
01818 double ERightSeed,
01819 double E2x5MaxSeed,
01820 double E2x5TopSeed,
01821 double E2x5BottomSeed,
01822 double E2x5LeftSeed,
01823 double E2x5RightSeed,
01824 double IEtaSeed,
01825 double IPhiSeed,
01826 double EtaCrySeed,
01827 double PhiCrySeed,
01828 double PreShowerOverRaw,
01829 int IsEcalDriven,
01830 double GsfTrackPIn,
01831 double fbrem,
01832 double Charge,
01833 double EoP,
01834 double TrackMomentumError,
01835 double EcalEnergyError,
01836 int Classification,
01837 bool printDebug)
01838 {
01839
01840 if (fIsInitialized == kFALSE) {
01841 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01842 return 0;
01843 }
01844
01845
01846 assert(fVersionType == kWithTrkVarV1);
01847
01848 float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
01849 if (fabs(scEta) <= 1.479) {
01850 vals[0] = SCRawEnergy;
01851 vals[1] = scEta;
01852 vals[2] = scPhi;
01853 vals[3] = R9;
01854 vals[4] = E5x5Seed/SCRawEnergy;
01855 vals[5] = etawidth;
01856 vals[6] = phiwidth;
01857 vals[7] = NClusters;
01858 vals[8] = HoE;
01859 vals[9] = rho;
01860 vals[10] = vertices;
01861 vals[11] = EtaSeed - scEta;
01862 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01863 vals[13] = ESeed/SCRawEnergy;
01864 vals[14] = E3x3Seed/ESeed;
01865 vals[15] = E5x5Seed/ESeed;
01866 vals[16] = see;
01867 vals[17] = spp;
01868 vals[18] = sep;
01869 vals[19] = EMaxSeed/ESeed;
01870 vals[20] = E2ndSeed/ESeed;
01871 vals[21] = ETopSeed/ESeed;
01872 vals[22] = EBottomSeed/ESeed;
01873 vals[23] = ELeftSeed/ESeed;
01874 vals[24] = ERightSeed/ESeed;
01875 vals[25] = E2x5MaxSeed/ESeed;
01876 vals[26] = E2x5TopSeed/ESeed;
01877 vals[27] = E2x5BottomSeed/ESeed;
01878 vals[28] = E2x5LeftSeed/ESeed;
01879 vals[29] = E2x5RightSeed/ESeed;
01880 vals[30] = IsEcalDriven;
01881 vals[31] = GsfTrackPIn;
01882 vals[32] = fbrem;
01883 vals[33] = Charge;
01884 vals[34] = EoP;
01885 vals[35] = TrackMomentumError/GsfTrackPIn;
01886 vals[36] = EcalEnergyError/SCRawEnergy;
01887 vals[37] = Classification;
01888 vals[38] = IEtaSeed;
01889 vals[39] = IPhiSeed;
01890 vals[40] = ((int) IEtaSeed)%5;
01891 vals[41] = ((int) IPhiSeed)%2;
01892 vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
01893 vals[43] = ((int) IPhiSeed)%20;
01894 vals[44] = EtaCrySeed;
01895 vals[45] = PhiCrySeed;
01896 }
01897
01898 else {
01899 vals[0] = SCRawEnergy;
01900 vals[1] = scEta;
01901 vals[2] = scPhi;
01902 vals[3] = R9;
01903 vals[4] = E5x5Seed/SCRawEnergy;
01904 vals[5] = etawidth;
01905 vals[6] = phiwidth;
01906 vals[7] = NClusters;
01907 vals[8] = HoE;
01908 vals[9] = rho;
01909 vals[10] = vertices;
01910 vals[11] = EtaSeed - scEta;
01911 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
01912 vals[13] = ESeed/SCRawEnergy;
01913 vals[14] = E3x3Seed/ESeed;
01914 vals[15] = E5x5Seed/ESeed;
01915 vals[16] = see;
01916 vals[17] = spp;
01917 vals[18] = sep;
01918 vals[19] = EMaxSeed/ESeed;
01919 vals[20] = E2ndSeed/ESeed;
01920 vals[21] = ETopSeed/ESeed;
01921 vals[22] = EBottomSeed/ESeed;
01922 vals[23] = ELeftSeed/ESeed;
01923 vals[24] = ERightSeed/ESeed;
01924 vals[25] = E2x5MaxSeed/ESeed;
01925 vals[26] = E2x5TopSeed/ESeed;
01926 vals[27] = E2x5BottomSeed/ESeed;
01927 vals[28] = E2x5LeftSeed/ESeed;
01928 vals[29] = E2x5RightSeed/ESeed;
01929 vals[30] = IsEcalDriven;
01930 vals[31] = GsfTrackPIn;
01931 vals[32] = fbrem;
01932 vals[33] = Charge;
01933 vals[34] = EoP;
01934 vals[35] = TrackMomentumError/GsfTrackPIn;
01935 vals[36] = EcalEnergyError/SCRawEnergy;
01936 vals[37] = Classification;
01937 vals[38] = PreShowerOverRaw;
01938 }
01939
01940
01941 double regressionResult = 0;
01942
01943 if (fVersionType == kWithTrkVarV1) {
01944 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
01945 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
01946 }
01947
01948
01949 if (printDebug) {
01950 if (fabs(scEta) <= 1.479) {
01951 std::cout << "Barrel :";
01952 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
01953 std::cout << "\n";
01954 }
01955 else {
01956 std::cout << "Endcap :";
01957 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
01958 std::cout << "\n";
01959 }
01960 std::cout << " SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
01961 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
01962 }
01963
01964
01965
01966 delete[] vals;
01967 return regressionResult;
01968 }
01969
01970
01971
01972
01973
01974 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV1(std::vector<double> &inputvars,
01975 bool printDebug)
01976 {
01977
01978 if (fIsInitialized == kFALSE) {
01979 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01980 return 0;
01981 }
01982
01983
01984 assert(fVersionType == kWithTrkVarV1);
01985
01986
01987 assert(inputvars.size() == 42);
01988
01989 double SCRawEnergy = inputvars[0];
01990 double scEta = inputvars[1];
01991 double scPhi = inputvars[2];
01992 double R9 = inputvars[3];
01993 double etawidth = inputvars[4];
01994 double phiwidth = inputvars[5];
01995 double NClusters = inputvars[6];
01996 double HoE = inputvars[7];
01997 double rho = inputvars[8];
01998 double vertices = inputvars[9];
01999 double EtaSeed = inputvars[10];
02000 double PhiSeed = inputvars[11];
02001 double ESeed = inputvars[12];
02002 double E3x3Seed = inputvars[13];
02003 double E5x5Seed = inputvars[14];
02004 double see = inputvars[15];
02005 double spp = inputvars[16];
02006 double sep = inputvars[17];
02007 double EMaxSeed = inputvars[18];
02008 double E2ndSeed = inputvars[19];
02009 double ETopSeed = inputvars[20];
02010 double EBottomSeed = inputvars[21];
02011 double ELeftSeed = inputvars[22];
02012 double ERightSeed = inputvars[23];
02013 double E2x5MaxSeed = inputvars[24];
02014 double E2x5TopSeed = inputvars[25];
02015 double E2x5BottomSeed = inputvars[26];
02016 double E2x5LeftSeed = inputvars[27];
02017 double E2x5RightSeed = inputvars[28];
02018 double IEtaSeed = inputvars[29];
02019 double IPhiSeed = inputvars[30];
02020 double EtaCrySeed = inputvars[31];
02021 double PhiCrySeed = inputvars[32];
02022 double PreShowerOverRaw = inputvars[33];
02023 int IsEcalDriven = inputvars[34];
02024 double GsfTrackPIn = inputvars[35];
02025 double fbrem = inputvars[36];
02026 double Charge = inputvars[37];
02027 double EoP = inputvars[38];
02028 double TrackMomentumError = inputvars[39];
02029 double EcalEnergyError = inputvars[40];
02030 int Classification = inputvars[41];
02031
02032 float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
02033 if (fabs(scEta) <= 1.479) {
02034 vals[0] = SCRawEnergy;
02035 vals[1] = scEta;
02036 vals[2] = scPhi;
02037 vals[3] = R9;
02038 vals[4] = E5x5Seed/SCRawEnergy;
02039 vals[5] = etawidth;
02040 vals[6] = phiwidth;
02041 vals[7] = NClusters;
02042 vals[8] = HoE;
02043 vals[9] = rho;
02044 vals[10] = vertices;
02045 vals[11] = EtaSeed - scEta;
02046 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02047 vals[13] = ESeed/SCRawEnergy;
02048 vals[14] = E3x3Seed/ESeed;
02049 vals[15] = E5x5Seed/ESeed;
02050 vals[16] = see;
02051 vals[17] = spp;
02052 vals[18] = sep;
02053 vals[19] = EMaxSeed/ESeed;
02054 vals[20] = E2ndSeed/ESeed;
02055 vals[21] = ETopSeed/ESeed;
02056 vals[22] = EBottomSeed/ESeed;
02057 vals[23] = ELeftSeed/ESeed;
02058 vals[24] = ERightSeed/ESeed;
02059 vals[25] = E2x5MaxSeed/ESeed;
02060 vals[26] = E2x5TopSeed/ESeed;
02061 vals[27] = E2x5BottomSeed/ESeed;
02062 vals[28] = E2x5LeftSeed/ESeed;
02063 vals[29] = E2x5RightSeed/ESeed;
02064 vals[30] = IsEcalDriven;
02065 vals[31] = GsfTrackPIn;
02066 vals[32] = fbrem;
02067 vals[33] = Charge;
02068 vals[34] = EoP;
02069 vals[35] = TrackMomentumError/GsfTrackPIn;
02070 vals[36] = EcalEnergyError/SCRawEnergy;
02071 vals[37] = Classification;
02072 vals[38] = IEtaSeed;
02073 vals[39] = IPhiSeed;
02074 vals[40] = ((int) IEtaSeed)%5;
02075 vals[41] = ((int) IPhiSeed)%2;
02076 vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
02077 vals[43] = ((int) IPhiSeed)%20;
02078 vals[44] = EtaCrySeed;
02079 vals[45] = PhiCrySeed;
02080 }
02081
02082 else {
02083 vals[0] = SCRawEnergy;
02084 vals[1] = scEta;
02085 vals[2] = scPhi;
02086 vals[3] = R9;
02087 vals[4] = E5x5Seed/SCRawEnergy;
02088 vals[5] = etawidth;
02089 vals[6] = phiwidth;
02090 vals[7] = NClusters;
02091 vals[8] = HoE;
02092 vals[9] = rho;
02093 vals[10] = vertices;
02094 vals[11] = EtaSeed - scEta;
02095 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02096 vals[13] = ESeed/SCRawEnergy;
02097 vals[14] = E3x3Seed/ESeed;
02098 vals[15] = E5x5Seed/ESeed;
02099 vals[16] = see;
02100 vals[17] = spp;
02101 vals[18] = sep;
02102 vals[19] = EMaxSeed/ESeed;
02103 vals[20] = E2ndSeed/ESeed;
02104 vals[21] = ETopSeed/ESeed;
02105 vals[22] = EBottomSeed/ESeed;
02106 vals[23] = ELeftSeed/ESeed;
02107 vals[24] = ERightSeed/ESeed;
02108 vals[25] = E2x5MaxSeed/ESeed;
02109 vals[26] = E2x5TopSeed/ESeed;
02110 vals[27] = E2x5BottomSeed/ESeed;
02111 vals[28] = E2x5LeftSeed/ESeed;
02112 vals[29] = E2x5RightSeed/ESeed;
02113 vals[30] = IsEcalDriven;
02114 vals[31] = GsfTrackPIn;
02115 vals[32] = fbrem;
02116 vals[33] = Charge;
02117 vals[34] = EoP;
02118 vals[35] = TrackMomentumError/GsfTrackPIn;
02119 vals[36] = EcalEnergyError/SCRawEnergy;
02120 vals[37] = Classification;
02121 vals[38] = PreShowerOverRaw;
02122 }
02123
02124
02125 double regressionResult = 0;
02126
02127 if (fVersionType == kWithTrkVarV1) {
02128 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
02129 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
02130 }
02131
02132
02133
02134 if (printDebug) {
02135 if (fabs(scEta) <= 1.479) {
02136 std::cout << "Barrel :";
02137 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
02138 std::cout << "\n";
02139 }
02140 else {
02141 std::cout << "Endcap :";
02142 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
02143 std::cout << "\n";
02144 }
02145 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
02146 std::cout << "regression energy = " << regressionResult << std::endl;
02147 }
02148
02149
02150 delete[] vals;
02151 return regressionResult;
02152 }
02153
02154
02155
02156
02157 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1(std::vector<double> &inputvars,
02158 bool printDebug)
02159 {
02160
02161 if (fIsInitialized == kFALSE) {
02162 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02163 return 0;
02164 }
02165
02166
02167 assert(fVersionType == kWithTrkVarV1);
02168
02169
02170 assert(inputvars.size() == 42);
02171
02172 double SCRawEnergy = inputvars[0];
02173 double scEta = inputvars[1];
02174 double scPhi = inputvars[2];
02175 double R9 = inputvars[3];
02176 double etawidth = inputvars[4];
02177 double phiwidth = inputvars[5];
02178 double NClusters = inputvars[6];
02179 double HoE = inputvars[7];
02180 double rho = inputvars[8];
02181 double vertices = inputvars[9];
02182 double EtaSeed = inputvars[10];
02183 double PhiSeed = inputvars[11];
02184 double ESeed = inputvars[12];
02185 double E3x3Seed = inputvars[13];
02186 double E5x5Seed = inputvars[14];
02187 double see = inputvars[15];
02188 double spp = inputvars[16];
02189 double sep = inputvars[17];
02190 double EMaxSeed = inputvars[18];
02191 double E2ndSeed = inputvars[19];
02192 double ETopSeed = inputvars[20];
02193 double EBottomSeed = inputvars[21];
02194 double ELeftSeed = inputvars[22];
02195 double ERightSeed = inputvars[23];
02196 double E2x5MaxSeed = inputvars[24];
02197 double E2x5TopSeed = inputvars[25];
02198 double E2x5BottomSeed = inputvars[26];
02199 double E2x5LeftSeed = inputvars[27];
02200 double E2x5RightSeed = inputvars[28];
02201 double IEtaSeed = inputvars[29];
02202 double IPhiSeed = inputvars[30];
02203 double EtaCrySeed = inputvars[31];
02204 double PhiCrySeed = inputvars[32];
02205 double PreShowerOverRaw = inputvars[33];
02206 int IsEcalDriven = inputvars[34];
02207 double GsfTrackPIn = inputvars[35];
02208 double fbrem = inputvars[36];
02209 double Charge = inputvars[37];
02210 double EoP = inputvars[38];
02211 double TrackMomentumError = inputvars[39];
02212 double EcalEnergyError = inputvars[40];
02213 int Classification = inputvars[41];
02214
02215
02216 float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
02217 if (fabs(scEta) <= 1.479) {
02218 vals[0] = SCRawEnergy;
02219 vals[1] = scEta;
02220 vals[2] = scPhi;
02221 vals[3] = R9;
02222 vals[4] = E5x5Seed/SCRawEnergy;
02223 vals[5] = etawidth;
02224 vals[6] = phiwidth;
02225 vals[7] = NClusters;
02226 vals[8] = HoE;
02227 vals[9] = rho;
02228 vals[10] = vertices;
02229 vals[11] = EtaSeed - scEta;
02230 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02231 vals[13] = ESeed/SCRawEnergy;
02232 vals[14] = E3x3Seed/ESeed;
02233 vals[15] = E5x5Seed/ESeed;
02234 vals[16] = see;
02235 vals[17] = spp;
02236 vals[18] = sep;
02237 vals[19] = EMaxSeed/ESeed;
02238 vals[20] = E2ndSeed/ESeed;
02239 vals[21] = ETopSeed/ESeed;
02240 vals[22] = EBottomSeed/ESeed;
02241 vals[23] = ELeftSeed/ESeed;
02242 vals[24] = ERightSeed/ESeed;
02243 vals[25] = E2x5MaxSeed/ESeed;
02244 vals[26] = E2x5TopSeed/ESeed;
02245 vals[27] = E2x5BottomSeed/ESeed;
02246 vals[28] = E2x5LeftSeed/ESeed;
02247 vals[29] = E2x5RightSeed/ESeed;
02248 vals[30] = IsEcalDriven;
02249 vals[31] = GsfTrackPIn;
02250 vals[32] = fbrem;
02251 vals[33] = Charge;
02252 vals[34] = EoP;
02253 vals[35] = TrackMomentumError/GsfTrackPIn;
02254 vals[36] = EcalEnergyError/SCRawEnergy;
02255 vals[37] = Classification;
02256 vals[38] = IEtaSeed;
02257 vals[39] = IPhiSeed;
02258 vals[40] = ((int) IEtaSeed)%5;
02259 vals[41] = ((int) IPhiSeed)%2;
02260 vals[42] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
02261 vals[43] = ((int) IPhiSeed)%20;
02262 vals[44] = EtaCrySeed;
02263 vals[45] = PhiCrySeed;
02264 }
02265
02266 else {
02267 vals[0] = SCRawEnergy;
02268 vals[1] = scEta;
02269 vals[2] = scPhi;
02270 vals[3] = R9;
02271 vals[4] = E5x5Seed/SCRawEnergy;
02272 vals[5] = etawidth;
02273 vals[6] = phiwidth;
02274 vals[7] = NClusters;
02275 vals[8] = HoE;
02276 vals[9] = rho;
02277 vals[10] = vertices;
02278 vals[11] = EtaSeed - scEta;
02279 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02280 vals[13] = ESeed/SCRawEnergy;
02281 vals[14] = E3x3Seed/ESeed;
02282 vals[15] = E5x5Seed/ESeed;
02283 vals[16] = see;
02284 vals[17] = spp;
02285 vals[18] = sep;
02286 vals[19] = EMaxSeed/ESeed;
02287 vals[20] = E2ndSeed/ESeed;
02288 vals[21] = ETopSeed/ESeed;
02289 vals[22] = EBottomSeed/ESeed;
02290 vals[23] = ELeftSeed/ESeed;
02291 vals[24] = ERightSeed/ESeed;
02292 vals[25] = E2x5MaxSeed/ESeed;
02293 vals[26] = E2x5TopSeed/ESeed;
02294 vals[27] = E2x5BottomSeed/ESeed;
02295 vals[28] = E2x5LeftSeed/ESeed;
02296 vals[29] = E2x5RightSeed/ESeed;
02297 vals[30] = IsEcalDriven;
02298 vals[31] = GsfTrackPIn;
02299 vals[32] = fbrem;
02300 vals[33] = Charge;
02301 vals[34] = EoP;
02302 vals[35] = TrackMomentumError/GsfTrackPIn;
02303 vals[36] = EcalEnergyError/SCRawEnergy;
02304 vals[37] = Classification;
02305 vals[38] = PreShowerOverRaw;
02306 }
02307
02308
02309 double regressionResult = 0;
02310
02311 if (fVersionType == kWithTrkVarV1) {
02312 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
02313 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
02314 }
02315
02316
02317 if (printDebug) {
02318 if (fabs(scEta) <= 1.479) {
02319 std::cout << "Barrel :";
02320 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
02321 std::cout << "\n";
02322 }
02323 else {
02324 std::cout << "Endcap :";
02325 for (unsigned int v=0; v < 39; ++v) std::cout << vals[v] << ", ";
02326 std::cout << "\n";
02327 }
02328 std::cout << " SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
02329 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
02330 }
02331
02332
02333
02334 delete[] vals;
02335 return regressionResult;
02336 }
02337
02338
02339
02340 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2(
02341 double SCRawEnergy,
02342 double scEta,
02343 double scPhi,
02344 double R9,
02345 double etawidth,
02346 double phiwidth,
02347 double NClusters,
02348 double HoE,
02349 double rho,
02350 double vertices,
02351 double EtaSeed,
02352 double PhiSeed,
02353 double ESeed,
02354 double E3x3Seed,
02355 double E5x5Seed,
02356 double see,
02357 double spp,
02358 double sep,
02359 double EMaxSeed,
02360 double E2ndSeed,
02361 double ETopSeed,
02362 double EBottomSeed,
02363 double ELeftSeed,
02364 double ERightSeed,
02365 double E2x5MaxSeed,
02366 double E2x5TopSeed,
02367 double E2x5BottomSeed,
02368 double E2x5LeftSeed,
02369 double E2x5RightSeed,
02370 double IEtaSeed,
02371 double IPhiSeed,
02372 double EtaCrySeed,
02373 double PhiCrySeed,
02374 double PreShowerOverRaw,
02375 int IsEcalDriven,
02376 double GsfTrackPIn,
02377 double fbrem,
02378 double Charge,
02379 double EoP,
02380 double TrackMomentumError,
02381 double EcalEnergyError,
02382 int Classification,
02383 double detaIn,
02384 double dphiIn,
02385 double detaCalo,
02386 double dphiCalo,
02387 double GsfTrackChiSqr,
02388 double KFTrackNLayers,
02389 double ElectronEnergyOverPout,
02390 bool printDebug)
02391 {
02392
02393 if (fIsInitialized == kFALSE) {
02394 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02395 return 0;
02396 }
02397
02398
02399 assert(fVersionType == kWithTrkVarV2);
02400
02401 float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
02402 if (fabs(scEta) <= 1.479) {
02403 vals[0] = SCRawEnergy;
02404 vals[1] = scEta;
02405 vals[2] = scPhi;
02406 vals[3] = R9;
02407 vals[4] = E5x5Seed/SCRawEnergy;
02408 vals[5] = etawidth;
02409 vals[6] = phiwidth;
02410 vals[7] = NClusters;
02411 vals[8] = HoE;
02412 vals[9] = rho;
02413 vals[10] = vertices;
02414 vals[11] = EtaSeed - scEta;
02415 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02416 vals[13] = ESeed/SCRawEnergy;
02417 vals[14] = E3x3Seed/ESeed;
02418 vals[15] = E5x5Seed/ESeed;
02419 vals[16] = see;
02420 vals[17] = spp;
02421 vals[18] = sep;
02422 vals[19] = EMaxSeed/ESeed;
02423 vals[20] = E2ndSeed/ESeed;
02424 vals[21] = ETopSeed/ESeed;
02425 vals[22] = EBottomSeed/ESeed;
02426 vals[23] = ELeftSeed/ESeed;
02427 vals[24] = ERightSeed/ESeed;
02428 vals[25] = E2x5MaxSeed/ESeed;
02429 vals[26] = E2x5TopSeed/ESeed;
02430 vals[27] = E2x5BottomSeed/ESeed;
02431 vals[28] = E2x5LeftSeed/ESeed;
02432 vals[29] = E2x5RightSeed/ESeed;
02433 vals[30] = IsEcalDriven;
02434 vals[31] = GsfTrackPIn;
02435 vals[32] = fbrem;
02436 vals[33] = Charge;
02437 vals[34] = EoP;
02438 vals[35] = TrackMomentumError/GsfTrackPIn;
02439 vals[36] = EcalEnergyError/SCRawEnergy;
02440 vals[37] = Classification;
02441 vals[38] = detaIn;
02442 vals[39] = dphiIn;
02443 vals[40] = detaCalo;
02444 vals[41] = dphiCalo;
02445 vals[42] = GsfTrackChiSqr;
02446 vals[43] = KFTrackNLayers;
02447 vals[44] = ElectronEnergyOverPout;
02448 vals[45] = IEtaSeed;
02449 vals[46] = IPhiSeed;
02450 vals[47] = ((int) IEtaSeed)%5;
02451 vals[48] = ((int) IPhiSeed)%2;
02452 vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
02453 vals[50] = ((int) IPhiSeed)%20;
02454 vals[51] = EtaCrySeed;
02455 vals[52] = PhiCrySeed;
02456 }
02457
02458 else {
02459 vals[0] = SCRawEnergy;
02460 vals[1] = scEta;
02461 vals[2] = scPhi;
02462 vals[3] = R9;
02463 vals[4] = E5x5Seed/SCRawEnergy;
02464 vals[5] = etawidth;
02465 vals[6] = phiwidth;
02466 vals[7] = NClusters;
02467 vals[8] = HoE;
02468 vals[9] = rho;
02469 vals[10] = vertices;
02470 vals[11] = EtaSeed - scEta;
02471 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02472 vals[13] = ESeed/SCRawEnergy;
02473 vals[14] = E3x3Seed/ESeed;
02474 vals[15] = E5x5Seed/ESeed;
02475 vals[16] = see;
02476 vals[17] = spp;
02477 vals[18] = sep;
02478 vals[19] = EMaxSeed/ESeed;
02479 vals[20] = E2ndSeed/ESeed;
02480 vals[21] = ETopSeed/ESeed;
02481 vals[22] = EBottomSeed/ESeed;
02482 vals[23] = ELeftSeed/ESeed;
02483 vals[24] = ERightSeed/ESeed;
02484 vals[25] = E2x5MaxSeed/ESeed;
02485 vals[26] = E2x5TopSeed/ESeed;
02486 vals[27] = E2x5BottomSeed/ESeed;
02487 vals[28] = E2x5LeftSeed/ESeed;
02488 vals[29] = E2x5RightSeed/ESeed;
02489 vals[30] = IsEcalDriven;
02490 vals[31] = GsfTrackPIn;
02491 vals[32] = fbrem;
02492 vals[33] = Charge;
02493 vals[34] = EoP;
02494 vals[35] = TrackMomentumError/GsfTrackPIn;
02495 vals[36] = EcalEnergyError/SCRawEnergy;
02496 vals[37] = Classification;
02497 vals[38] = detaIn;
02498 vals[39] = dphiIn;
02499 vals[40] = detaCalo;
02500 vals[41] = dphiCalo;
02501 vals[42] = GsfTrackChiSqr;
02502 vals[43] = KFTrackNLayers;
02503 vals[44] = ElectronEnergyOverPout;
02504 vals[45] = PreShowerOverRaw;
02505 }
02506
02507
02508 double regressionResult = 0;
02509
02510 if (fVersionType == kWithTrkVarV2) {
02511 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
02512 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
02513 }
02514
02515
02516
02517 if (printDebug) {
02518 if (fabs(scEta) <= 1.479) {
02519 std::cout << "Barrel :";
02520 for (unsigned int v=0; v < 53; ++v) std::cout << vals[v] << ", ";
02521 std::cout << "\n";
02522 }
02523 else {
02524 std::cout << "Endcap :";
02525 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
02526 std::cout << "\n";
02527 }
02528 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
02529 std::cout << "regression energy = " << regressionResult << std::endl;
02530 }
02531
02532
02533 delete[] vals;
02534 return regressionResult;
02535 }
02536
02537
02538
02539
02540 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2(
02541 double SCRawEnergy,
02542 double scEta,
02543 double scPhi,
02544 double R9,
02545 double etawidth,
02546 double phiwidth,
02547 double NClusters,
02548 double HoE,
02549 double rho,
02550 double vertices,
02551 double EtaSeed,
02552 double PhiSeed,
02553 double ESeed,
02554 double E3x3Seed,
02555 double E5x5Seed,
02556 double see,
02557 double spp,
02558 double sep,
02559 double EMaxSeed,
02560 double E2ndSeed,
02561 double ETopSeed,
02562 double EBottomSeed,
02563 double ELeftSeed,
02564 double ERightSeed,
02565 double E2x5MaxSeed,
02566 double E2x5TopSeed,
02567 double E2x5BottomSeed,
02568 double E2x5LeftSeed,
02569 double E2x5RightSeed,
02570 double IEtaSeed,
02571 double IPhiSeed,
02572 double EtaCrySeed,
02573 double PhiCrySeed,
02574 double PreShowerOverRaw,
02575 int IsEcalDriven,
02576 double GsfTrackPIn,
02577 double fbrem,
02578 double Charge,
02579 double EoP,
02580 double TrackMomentumError,
02581 double EcalEnergyError,
02582 int Classification,
02583 double detaIn,
02584 double dphiIn,
02585 double detaCalo,
02586 double dphiCalo,
02587 double GsfTrackChiSqr,
02588 double KFTrackNLayers,
02589 double ElectronEnergyOverPout,
02590 bool printDebug)
02591 {
02592
02593 if (fIsInitialized == kFALSE) {
02594 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02595 return 0;
02596 }
02597
02598
02599 assert(fVersionType == kWithTrkVarV2);
02600
02601 float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
02602 if (fabs(scEta) <= 1.479) {
02603 vals[0] = SCRawEnergy;
02604 vals[1] = scEta;
02605 vals[2] = scPhi;
02606 vals[3] = R9;
02607 vals[4] = E5x5Seed/SCRawEnergy;
02608 vals[5] = etawidth;
02609 vals[6] = phiwidth;
02610 vals[7] = NClusters;
02611 vals[8] = HoE;
02612 vals[9] = rho;
02613 vals[10] = vertices;
02614 vals[11] = EtaSeed - scEta;
02615 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02616 vals[13] = ESeed/SCRawEnergy;
02617 vals[14] = E3x3Seed/ESeed;
02618 vals[15] = E5x5Seed/ESeed;
02619 vals[16] = see;
02620 vals[17] = spp;
02621 vals[18] = sep;
02622 vals[19] = EMaxSeed/ESeed;
02623 vals[20] = E2ndSeed/ESeed;
02624 vals[21] = ETopSeed/ESeed;
02625 vals[22] = EBottomSeed/ESeed;
02626 vals[23] = ELeftSeed/ESeed;
02627 vals[24] = ERightSeed/ESeed;
02628 vals[25] = E2x5MaxSeed/ESeed;
02629 vals[26] = E2x5TopSeed/ESeed;
02630 vals[27] = E2x5BottomSeed/ESeed;
02631 vals[28] = E2x5LeftSeed/ESeed;
02632 vals[29] = E2x5RightSeed/ESeed;
02633 vals[30] = IsEcalDriven;
02634 vals[31] = GsfTrackPIn;
02635 vals[32] = fbrem;
02636 vals[33] = Charge;
02637 vals[34] = EoP;
02638 vals[35] = TrackMomentumError/GsfTrackPIn;
02639 vals[36] = EcalEnergyError/SCRawEnergy;
02640 vals[37] = Classification;
02641 vals[38] = detaIn;
02642 vals[39] = dphiIn;
02643 vals[40] = detaCalo;
02644 vals[41] = dphiCalo;
02645 vals[42] = GsfTrackChiSqr;
02646 vals[43] = KFTrackNLayers;
02647 vals[44] = ElectronEnergyOverPout;
02648 vals[45] = IEtaSeed;
02649 vals[46] = IPhiSeed;
02650 vals[47] = ((int) IEtaSeed)%5;
02651 vals[48] = ((int) IPhiSeed)%2;
02652 vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
02653 vals[50] = ((int) IPhiSeed)%20;
02654 vals[51] = EtaCrySeed;
02655 vals[52] = PhiCrySeed;
02656 }
02657
02658 else {
02659 vals[0] = SCRawEnergy;
02660 vals[1] = scEta;
02661 vals[2] = scPhi;
02662 vals[3] = R9;
02663 vals[4] = E5x5Seed/SCRawEnergy;
02664 vals[5] = etawidth;
02665 vals[6] = phiwidth;
02666 vals[7] = NClusters;
02667 vals[8] = HoE;
02668 vals[9] = rho;
02669 vals[10] = vertices;
02670 vals[11] = EtaSeed - scEta;
02671 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02672 vals[13] = ESeed/SCRawEnergy;
02673 vals[14] = E3x3Seed/ESeed;
02674 vals[15] = E5x5Seed/ESeed;
02675 vals[16] = see;
02676 vals[17] = spp;
02677 vals[18] = sep;
02678 vals[19] = EMaxSeed/ESeed;
02679 vals[20] = E2ndSeed/ESeed;
02680 vals[21] = ETopSeed/ESeed;
02681 vals[22] = EBottomSeed/ESeed;
02682 vals[23] = ELeftSeed/ESeed;
02683 vals[24] = ERightSeed/ESeed;
02684 vals[25] = E2x5MaxSeed/ESeed;
02685 vals[26] = E2x5TopSeed/ESeed;
02686 vals[27] = E2x5BottomSeed/ESeed;
02687 vals[28] = E2x5LeftSeed/ESeed;
02688 vals[29] = E2x5RightSeed/ESeed;
02689 vals[30] = IsEcalDriven;
02690 vals[31] = GsfTrackPIn;
02691 vals[32] = fbrem;
02692 vals[33] = Charge;
02693 vals[34] = EoP;
02694 vals[35] = TrackMomentumError/GsfTrackPIn;
02695 vals[36] = EcalEnergyError/SCRawEnergy;
02696 vals[37] = Classification;
02697 vals[38] = detaIn;
02698 vals[39] = dphiIn;
02699 vals[40] = detaCalo;
02700 vals[41] = dphiCalo;
02701 vals[42] = GsfTrackChiSqr;
02702 vals[43] = KFTrackNLayers;
02703 vals[44] = ElectronEnergyOverPout;
02704 vals[45] = PreShowerOverRaw;
02705 }
02706
02707
02708 double regressionResult = 0;
02709
02710 if (fVersionType == kWithTrkVarV2) {
02711 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
02712 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
02713 }
02714
02715
02716 if (printDebug) {
02717 if (fabs(scEta) <= 1.479) {
02718 std::cout << "Barrel :";
02719 for (unsigned int v=0; v < 53; ++v) std::cout << vals[v] << ", ";
02720 std::cout << "\n";
02721 }
02722 else {
02723 std::cout << "Endcap :";
02724 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
02725 std::cout << "\n";
02726 }
02727 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
02728 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
02729 }
02730
02731
02732
02733 delete[] vals;
02734 return regressionResult;
02735 }
02736
02737
02738
02739
02740 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2(std::vector<double> &inputvars,
02741 bool printDebug)
02742 {
02743
02744 if (fIsInitialized == kFALSE) {
02745 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02746 return 0;
02747 }
02748
02749
02750 assert(fVersionType == kWithTrkVarV2);
02751
02752
02753 assert(inputvars.size() == 49);
02754
02755 double SCRawEnergy = inputvars[0];
02756 double scEta = inputvars[1];
02757 double scPhi = inputvars[2];
02758 double R9 = inputvars[3];
02759 double etawidth = inputvars[4];
02760 double phiwidth = inputvars[5];
02761 double NClusters = inputvars[6];
02762 double HoE = inputvars[7];
02763 double rho = inputvars[8];
02764 double vertices = inputvars[9];
02765 double EtaSeed = inputvars[10];
02766 double PhiSeed = inputvars[11];
02767 double ESeed = inputvars[12];
02768 double E3x3Seed = inputvars[13];
02769 double E5x5Seed = inputvars[14];
02770 double see = inputvars[15];
02771 double spp = inputvars[16];
02772 double sep = inputvars[17];
02773 double EMaxSeed = inputvars[18];
02774 double E2ndSeed = inputvars[19];
02775 double ETopSeed = inputvars[20];
02776 double EBottomSeed = inputvars[21];
02777 double ELeftSeed = inputvars[22];
02778 double ERightSeed = inputvars[23];
02779 double E2x5MaxSeed = inputvars[24];
02780 double E2x5TopSeed = inputvars[25];
02781 double E2x5BottomSeed = inputvars[26];
02782 double E2x5LeftSeed = inputvars[27];
02783 double E2x5RightSeed = inputvars[28];
02784 double IEtaSeed = inputvars[29];
02785 double IPhiSeed = inputvars[30];
02786 double EtaCrySeed = inputvars[31];
02787 double PhiCrySeed = inputvars[32];
02788 double PreShowerOverRaw = inputvars[33];
02789 int IsEcalDriven = inputvars[34];
02790 double GsfTrackPIn = inputvars[35];
02791 double fbrem = inputvars[36];
02792 double Charge = inputvars[37];
02793 double EoP = inputvars[38];
02794 double TrackMomentumError = inputvars[39];
02795 double EcalEnergyError = inputvars[40];
02796 int Classification = inputvars[41];
02797 double detaIn = inputvars[42];
02798 double dphiIn = inputvars[43];
02799 double detaCalo = inputvars[44];
02800 double dphiCalo = inputvars[45];
02801 double GsfTrackChiSqr = inputvars[46];
02802 double KFTrackNLayers = inputvars[47];
02803 double ElectronEnergyOverPout = inputvars[48];
02804
02805 float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
02806 if (fabs(scEta) <= 1.479) {
02807 vals[0] = SCRawEnergy;
02808 vals[1] = scEta;
02809 vals[2] = scPhi;
02810 vals[3] = R9;
02811 vals[4] = E5x5Seed/SCRawEnergy;
02812 vals[5] = etawidth;
02813 vals[6] = phiwidth;
02814 vals[7] = NClusters;
02815 vals[8] = HoE;
02816 vals[9] = rho;
02817 vals[10] = vertices;
02818 vals[11] = EtaSeed - scEta;
02819 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02820 vals[13] = ESeed/SCRawEnergy;
02821 vals[14] = E3x3Seed/ESeed;
02822 vals[15] = E5x5Seed/ESeed;
02823 vals[16] = see;
02824 vals[17] = spp;
02825 vals[18] = sep;
02826 vals[19] = EMaxSeed/ESeed;
02827 vals[20] = E2ndSeed/ESeed;
02828 vals[21] = ETopSeed/ESeed;
02829 vals[22] = EBottomSeed/ESeed;
02830 vals[23] = ELeftSeed/ESeed;
02831 vals[24] = ERightSeed/ESeed;
02832 vals[25] = E2x5MaxSeed/ESeed;
02833 vals[26] = E2x5TopSeed/ESeed;
02834 vals[27] = E2x5BottomSeed/ESeed;
02835 vals[28] = E2x5LeftSeed/ESeed;
02836 vals[29] = E2x5RightSeed/ESeed;
02837 vals[30] = IsEcalDriven;
02838 vals[31] = GsfTrackPIn;
02839 vals[32] = fbrem;
02840 vals[33] = Charge;
02841 vals[34] = EoP;
02842 vals[35] = TrackMomentumError/GsfTrackPIn;
02843 vals[36] = EcalEnergyError/SCRawEnergy;
02844 vals[37] = Classification;
02845 vals[38] = detaIn;
02846 vals[39] = dphiIn;
02847 vals[40] = detaCalo;
02848 vals[41] = dphiCalo;
02849 vals[42] = GsfTrackChiSqr;
02850 vals[43] = KFTrackNLayers;
02851 vals[44] = ElectronEnergyOverPout;
02852 vals[45] = IEtaSeed;
02853 vals[46] = IPhiSeed;
02854 vals[47] = ((int) IEtaSeed)%5;
02855 vals[48] = ((int) IPhiSeed)%2;
02856 vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
02857 vals[50] = ((int) IPhiSeed)%20;
02858 vals[51] = EtaCrySeed;
02859 vals[52] = PhiCrySeed;
02860 }
02861
02862 else {
02863 vals[0] = SCRawEnergy;
02864 vals[1] = scEta;
02865 vals[2] = scPhi;
02866 vals[3] = R9;
02867 vals[4] = E5x5Seed/SCRawEnergy;
02868 vals[5] = etawidth;
02869 vals[6] = phiwidth;
02870 vals[7] = NClusters;
02871 vals[8] = HoE;
02872 vals[9] = rho;
02873 vals[10] = vertices;
02874 vals[11] = EtaSeed - scEta;
02875 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
02876 vals[13] = ESeed/SCRawEnergy;
02877 vals[14] = E3x3Seed/ESeed;
02878 vals[15] = E5x5Seed/ESeed;
02879 vals[16] = see;
02880 vals[17] = spp;
02881 vals[18] = sep;
02882 vals[19] = EMaxSeed/ESeed;
02883 vals[20] = E2ndSeed/ESeed;
02884 vals[21] = ETopSeed/ESeed;
02885 vals[22] = EBottomSeed/ESeed;
02886 vals[23] = ELeftSeed/ESeed;
02887 vals[24] = ERightSeed/ESeed;
02888 vals[25] = E2x5MaxSeed/ESeed;
02889 vals[26] = E2x5TopSeed/ESeed;
02890 vals[27] = E2x5BottomSeed/ESeed;
02891 vals[28] = E2x5LeftSeed/ESeed;
02892 vals[29] = E2x5RightSeed/ESeed;
02893 vals[30] = IsEcalDriven;
02894 vals[31] = GsfTrackPIn;
02895 vals[32] = fbrem;
02896 vals[33] = Charge;
02897 vals[34] = EoP;
02898 vals[35] = TrackMomentumError/GsfTrackPIn;
02899 vals[36] = EcalEnergyError/SCRawEnergy;
02900 vals[37] = Classification;
02901 vals[38] = detaIn;
02902 vals[39] = dphiIn;
02903 vals[40] = detaCalo;
02904 vals[41] = dphiCalo;
02905 vals[42] = GsfTrackChiSqr;
02906 vals[43] = KFTrackNLayers;
02907 vals[44] = ElectronEnergyOverPout;
02908 vals[45] = PreShowerOverRaw;
02909 }
02910
02911
02912 double regressionResult = 0;
02913
02914 if (fVersionType == kWithTrkVarV2) {
02915 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
02916 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
02917 }
02918
02919
02920
02921 if (printDebug) {
02922 if (fabs(scEta) <= 1.479) {
02923 std::cout << "Barrel :";
02924 for (unsigned int v=0; v < 53; ++v) std::cout << vals[v] << ", ";
02925 std::cout << "\n";
02926 }
02927 else {
02928 std::cout << "Endcap :";
02929 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
02930 std::cout << "\n";
02931 }
02932 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
02933 std::cout << "regression energy = " << regressionResult << std::endl;
02934 }
02935
02936
02937 delete[] vals;
02938 return regressionResult;
02939 }
02940
02941
02942
02943
02944 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2(std::vector<double> &inputvars,
02945 bool printDebug)
02946 {
02947
02948 if (fIsInitialized == kFALSE) {
02949 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02950 return 0;
02951 }
02952
02953
02954 assert(fVersionType == kWithTrkVarV2);
02955
02956
02957 assert(inputvars.size() == 49);
02958
02959 double SCRawEnergy = inputvars[0];
02960 double scEta = inputvars[1];
02961 double scPhi = inputvars[2];
02962 double R9 = inputvars[3];
02963 double etawidth = inputvars[4];
02964 double phiwidth = inputvars[5];
02965 double NClusters = inputvars[6];
02966 double HoE = inputvars[7];
02967 double rho = inputvars[8];
02968 double vertices = inputvars[9];
02969 double EtaSeed = inputvars[10];
02970 double PhiSeed = inputvars[11];
02971 double ESeed = inputvars[12];
02972 double E3x3Seed = inputvars[13];
02973 double E5x5Seed = inputvars[14];
02974 double see = inputvars[15];
02975 double spp = inputvars[16];
02976 double sep = inputvars[17];
02977 double EMaxSeed = inputvars[18];
02978 double E2ndSeed = inputvars[19];
02979 double ETopSeed = inputvars[20];
02980 double EBottomSeed = inputvars[21];
02981 double ELeftSeed = inputvars[22];
02982 double ERightSeed = inputvars[23];
02983 double E2x5MaxSeed = inputvars[24];
02984 double E2x5TopSeed = inputvars[25];
02985 double E2x5BottomSeed = inputvars[26];
02986 double E2x5LeftSeed = inputvars[27];
02987 double E2x5RightSeed = inputvars[28];
02988 double IEtaSeed = inputvars[29];
02989 double IPhiSeed = inputvars[30];
02990 double EtaCrySeed = inputvars[31];
02991 double PhiCrySeed = inputvars[32];
02992 double PreShowerOverRaw = inputvars[33];
02993 int IsEcalDriven = inputvars[34];
02994 double GsfTrackPIn = inputvars[35];
02995 double fbrem = inputvars[36];
02996 double Charge = inputvars[37];
02997 double EoP = inputvars[38];
02998 double TrackMomentumError = inputvars[39];
02999 double EcalEnergyError = inputvars[40];
03000 int Classification = inputvars[41];
03001 double detaIn = inputvars[42];
03002 double dphiIn = inputvars[43];
03003 double detaCalo = inputvars[44];
03004 double dphiCalo = inputvars[45];
03005 double GsfTrackChiSqr = inputvars[46];
03006 double KFTrackNLayers = inputvars[47];
03007 double ElectronEnergyOverPout = inputvars[48];
03008
03009 float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
03010 if (fabs(scEta) <= 1.479) {
03011 vals[0] = SCRawEnergy;
03012 vals[1] = scEta;
03013 vals[2] = scPhi;
03014 vals[3] = R9;
03015 vals[4] = E5x5Seed/SCRawEnergy;
03016 vals[5] = etawidth;
03017 vals[6] = phiwidth;
03018 vals[7] = NClusters;
03019 vals[8] = HoE;
03020 vals[9] = rho;
03021 vals[10] = vertices;
03022 vals[11] = EtaSeed - scEta;
03023 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03024 vals[13] = ESeed/SCRawEnergy;
03025 vals[14] = E3x3Seed/ESeed;
03026 vals[15] = E5x5Seed/ESeed;
03027 vals[16] = see;
03028 vals[17] = spp;
03029 vals[18] = sep;
03030 vals[19] = EMaxSeed/ESeed;
03031 vals[20] = E2ndSeed/ESeed;
03032 vals[21] = ETopSeed/ESeed;
03033 vals[22] = EBottomSeed/ESeed;
03034 vals[23] = ELeftSeed/ESeed;
03035 vals[24] = ERightSeed/ESeed;
03036 vals[25] = E2x5MaxSeed/ESeed;
03037 vals[26] = E2x5TopSeed/ESeed;
03038 vals[27] = E2x5BottomSeed/ESeed;
03039 vals[28] = E2x5LeftSeed/ESeed;
03040 vals[29] = E2x5RightSeed/ESeed;
03041 vals[30] = IsEcalDriven;
03042 vals[31] = GsfTrackPIn;
03043 vals[32] = fbrem;
03044 vals[33] = Charge;
03045 vals[34] = EoP;
03046 vals[35] = TrackMomentumError/GsfTrackPIn;
03047 vals[36] = EcalEnergyError/SCRawEnergy;
03048 vals[37] = Classification;
03049 vals[38] = detaIn;
03050 vals[39] = dphiIn;
03051 vals[40] = detaCalo;
03052 vals[41] = dphiCalo;
03053 vals[42] = GsfTrackChiSqr;
03054 vals[43] = KFTrackNLayers;
03055 vals[44] = ElectronEnergyOverPout;
03056 vals[45] = IEtaSeed;
03057 vals[46] = IPhiSeed;
03058 vals[47] = ((int) IEtaSeed)%5;
03059 vals[48] = ((int) IPhiSeed)%2;
03060 vals[49] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
03061 vals[50] = ((int) IPhiSeed)%20;
03062 vals[51] = EtaCrySeed;
03063 vals[52] = PhiCrySeed;
03064 }
03065
03066 else {
03067 vals[0] = SCRawEnergy;
03068 vals[1] = scEta;
03069 vals[2] = scPhi;
03070 vals[3] = R9;
03071 vals[4] = E5x5Seed/SCRawEnergy;
03072 vals[5] = etawidth;
03073 vals[6] = phiwidth;
03074 vals[7] = NClusters;
03075 vals[8] = HoE;
03076 vals[9] = rho;
03077 vals[10] = vertices;
03078 vals[11] = EtaSeed - scEta;
03079 vals[12] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03080 vals[13] = ESeed/SCRawEnergy;
03081 vals[14] = E3x3Seed/ESeed;
03082 vals[15] = E5x5Seed/ESeed;
03083 vals[16] = see;
03084 vals[17] = spp;
03085 vals[18] = sep;
03086 vals[19] = EMaxSeed/ESeed;
03087 vals[20] = E2ndSeed/ESeed;
03088 vals[21] = ETopSeed/ESeed;
03089 vals[22] = EBottomSeed/ESeed;
03090 vals[23] = ELeftSeed/ESeed;
03091 vals[24] = ERightSeed/ESeed;
03092 vals[25] = E2x5MaxSeed/ESeed;
03093 vals[26] = E2x5TopSeed/ESeed;
03094 vals[27] = E2x5BottomSeed/ESeed;
03095 vals[28] = E2x5LeftSeed/ESeed;
03096 vals[29] = E2x5RightSeed/ESeed;
03097 vals[30] = IsEcalDriven;
03098 vals[31] = GsfTrackPIn;
03099 vals[32] = fbrem;
03100 vals[33] = Charge;
03101 vals[34] = EoP;
03102 vals[35] = TrackMomentumError/GsfTrackPIn;
03103 vals[36] = EcalEnergyError/SCRawEnergy;
03104 vals[37] = Classification;
03105 vals[38] = detaIn;
03106 vals[39] = dphiIn;
03107 vals[40] = detaCalo;
03108 vals[41] = dphiCalo;
03109 vals[42] = GsfTrackChiSqr;
03110 vals[43] = KFTrackNLayers;
03111 vals[44] = ElectronEnergyOverPout;
03112 vals[45] = PreShowerOverRaw;
03113 }
03114
03115
03116 double regressionResult = 0;
03117
03118 if (fVersionType == kWithTrkVarV2) {
03119 if (fabs(scEta) <= 1.479) regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
03120 else regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
03121 }
03122
03123
03124 if (printDebug) {
03125 if (fabs(scEta) <= 1.479) {
03126 std::cout << "Barrel :";
03127 for (unsigned int v=0; v < 53; ++v) std::cout << vals[v] << ", ";
03128 std::cout << "\n";
03129 }
03130 else {
03131 std::cout << "Endcap :";
03132 for (unsigned int v=0; v < 46; ++v) std::cout << vals[v] << ", ";
03133 std::cout << "\n";
03134 }
03135 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
03136 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
03137 }
03138
03139
03140
03141 delete[] vals;
03142 return regressionResult;
03143 }
03144
03145 double ElectronEnergyRegressionEvaluate::regressionValueWithSubClusters(
03146 double SCRawEnergy,
03147 double scEta,
03148 double scPhi,
03149 double R9,
03150 double etawidth,
03151 double phiwidth,
03152 double NClusters,
03153 double HoE,
03154 double rho,
03155 double vertices,
03156 double EtaSeed,
03157 double PhiSeed,
03158 double ESeed,
03159 double E3x3Seed,
03160 double E5x5Seed,
03161 double see,
03162 double spp,
03163 double sep,
03164 double EMaxSeed,
03165 double E2ndSeed,
03166 double ETopSeed,
03167 double EBottomSeed,
03168 double ELeftSeed,
03169 double ERightSeed,
03170 double E2x5MaxSeed,
03171 double E2x5TopSeed,
03172 double E2x5BottomSeed,
03173 double E2x5LeftSeed,
03174 double E2x5RightSeed,
03175 double IEtaSeed,
03176 double IPhiSeed,
03177 double EtaCrySeed,
03178 double PhiCrySeed,
03179 double PreShowerOverRaw,
03180 double isEcalDriven,
03181 double isEtaGap,
03182 double isPhiGap,
03183 double isDeeGap,
03184 double ESubs,
03185 double ESub1,
03186 double EtaSub1,
03187 double PhiSub1,
03188 double EMaxSub1,
03189 double E3x3Sub1,
03190 double ESub2,
03191 double EtaSub2,
03192 double PhiSub2,
03193 double EMaxSub2,
03194 double E3x3Sub2,
03195 double ESub3,
03196 double EtaSub3,
03197 double PhiSub3,
03198 double EMaxSub3,
03199 double E3x3Sub3,
03200 double NPshwClusters,
03201 double EPshwSubs,
03202 double EPshwSub1,
03203 double EtaPshwSub1,
03204 double PhiPshwSub1,
03205 double EPshwSub2,
03206 double EtaPshwSub2,
03207 double PhiPshwSub2,
03208 double EPshwSub3,
03209 double EtaPshwSub3,
03210 double PhiPshwSub3,
03211 bool isEB,
03212 bool printDebug)
03213 {
03214
03215
03216 if (fIsInitialized == kFALSE) {
03217 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
03218 return 0;
03219 }
03220
03221
03222 if (!(fVersionType == kWithSubCluVar)) {
03223 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueWithSubClusters.\n";
03224 return 0;
03225 }
03226
03227
03228
03229
03230 float *vals = (isEB) ? new float[61] : new float[65];
03231 if (isEB) {
03232 vals[0] = rho;
03233 vals[1] = vertices;
03234 vals[2] = isEcalDriven;
03235 vals[3] = isEtaGap;
03236 vals[4] = isPhiGap;
03237 vals[5] = isDeeGap;
03238 vals[6] = SCRawEnergy;
03239 vals[7] = scEta;
03240 vals[8] = scPhi;
03241 vals[9] = R9;
03242 vals[10] = etawidth;
03243 vals[11] = phiwidth;
03244 vals[12] = NClusters;
03245 vals[13] = HoE;
03246 vals[14] = EtaSeed - scEta;
03247 vals[15] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03248 vals[16] = ESeed/SCRawEnergy;
03249 vals[17] = E3x3Seed/ESeed;
03250 vals[18] = E5x5Seed/SCRawEnergy;
03251 vals[19] = E5x5Seed/ESeed;
03252 vals[20] = EMaxSeed/ESeed;
03253 vals[21] = E2ndSeed/ESeed;
03254 vals[22] = ETopSeed/ESeed;
03255 vals[23] = EBottomSeed/ESeed;
03256 vals[24] = ELeftSeed/ESeed;
03257 vals[25] = ERightSeed/ESeed;
03258 vals[26] = E2x5MaxSeed/ESeed;
03259 vals[27] = E2x5TopSeed/ESeed;
03260 vals[28] = E2x5BottomSeed/ESeed;
03261 vals[29] = E2x5LeftSeed/ESeed;
03262 vals[30] = E2x5RightSeed/ESeed;
03263 vals[31] = see;
03264 vals[32] = spp;
03265 vals[33] = sep;
03266 vals[34] = phiwidth/etawidth;
03267 vals[35] = (ELeftSeed+ERightSeed==0. ? 0. : (ELeftSeed-ERightSeed)/(ELeftSeed+ERightSeed));
03268 vals[36] = (ETopSeed+EBottomSeed==0. ? 0. : (ETopSeed-EBottomSeed)/(ETopSeed+EBottomSeed));
03269 vals[37] = ESubs/SCRawEnergy;
03270 vals[38] = ESub1/SCRawEnergy;
03271 vals[39] = (NClusters<=1 ? 999. : EtaSub1-EtaSeed);
03272 vals[40] = (NClusters<=1 ? 999. : atan2(sin(PhiSub1-PhiSeed),cos(PhiSub1-PhiSeed)));
03273 vals[41] = (NClusters<=1 ? 0. : EMaxSub1/ESub1);
03274 vals[42] = (NClusters<=1 ? 0. : E3x3Sub1/ESub1);
03275 vals[43] = ESub2/SCRawEnergy;
03276 vals[44] = (NClusters<=2 ? 999. : EtaSub2-EtaSeed);
03277 vals[45] = (NClusters<=2 ? 999. : atan2(sin(PhiSub2-PhiSeed),cos(PhiSub2-PhiSeed)));
03278 vals[46] = (NClusters<=2 ? 0. : EMaxSub2/ESub2);
03279 vals[47] = (NClusters<=2 ? 0. : E3x3Sub2/ESub2);
03280 vals[48] = ESub3/SCRawEnergy;
03281 vals[49] = (NClusters<=3 ? 999. : EtaSub3-EtaSeed);
03282 vals[50] = (NClusters<=3 ? 999. : atan2(sin(PhiSub3-PhiSeed),cos(PhiSub3-PhiSeed)));
03283 vals[51] = (NClusters<=3 ? 0. : EMaxSub3/ESub3);
03284 vals[52] = (NClusters<=3 ? 0. : E3x3Sub3/ESub3);
03285 vals[53] = IEtaSeed;
03286 vals[54] = ((int) IEtaSeed)%5;
03287 vals[55] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
03288 vals[56] = IPhiSeed;
03289 vals[57] = ((int) IPhiSeed)%2;
03290 vals[58] = ((int) IPhiSeed)%20;
03291 vals[59] = EtaCrySeed;
03292 vals[60] = PhiCrySeed;
03293 }
03294 else {
03295 vals[0] = rho;
03296 vals[1] = vertices;
03297 vals[2] = isEcalDriven;
03298 vals[3] = isEtaGap;
03299 vals[4] = isPhiGap;
03300 vals[5] = isDeeGap;
03301 vals[6] = SCRawEnergy;
03302 vals[7] = scEta;
03303 vals[8] = scPhi;
03304 vals[9] = R9;
03305 vals[10] = etawidth;
03306 vals[11] = phiwidth;
03307 vals[12] = NClusters;
03308 vals[13] = HoE;
03309 vals[14] = EtaSeed - scEta;
03310 vals[15] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03311 vals[16] = ESeed/SCRawEnergy;
03312 vals[17] = E3x3Seed/ESeed;
03313 vals[18] = E5x5Seed/SCRawEnergy;
03314 vals[19] = E5x5Seed/ESeed;
03315 vals[20] = EMaxSeed/ESeed;
03316 vals[21] = E2ndSeed/ESeed;
03317 vals[22] = ETopSeed/ESeed;
03318 vals[23] = EBottomSeed/ESeed;
03319 vals[24] = ELeftSeed/ESeed;
03320 vals[25] = ERightSeed/ESeed;
03321 vals[26] = E2x5MaxSeed/ESeed;
03322 vals[27] = E2x5TopSeed/ESeed;
03323 vals[28] = E2x5BottomSeed/ESeed;
03324 vals[29] = E2x5LeftSeed/ESeed;
03325 vals[30] = E2x5RightSeed/ESeed;
03326 vals[31] = see;
03327 vals[32] = spp;
03328 vals[33] = sep;
03329 vals[34] = phiwidth/etawidth;
03330 vals[35] = (ELeftSeed+ERightSeed==0. ? 0. : (ELeftSeed-ERightSeed)/(ELeftSeed+ERightSeed));
03331 vals[36] = (ETopSeed+EBottomSeed==0. ? 0. : (ETopSeed-EBottomSeed)/(ETopSeed+EBottomSeed));
03332 vals[37] = ESubs/SCRawEnergy;
03333 vals[38] = ESub1/SCRawEnergy;
03334 vals[39] = (NClusters<=1 ? 999. : EtaSub1-EtaSeed);
03335 vals[40] = (NClusters<=1 ? 999. : atan2(sin(PhiSub1-PhiSeed),cos(PhiSub1-PhiSeed)));
03336 vals[41] = (NClusters<=1 ? 0. : EMaxSub1/ESub1);
03337 vals[42] = (NClusters<=1 ? 0. : E3x3Sub1/ESub1);
03338 vals[43] = ESub2/SCRawEnergy;
03339 vals[44] = (NClusters<=2 ? 999. : EtaSub2-EtaSeed);
03340 vals[45] = (NClusters<=2 ? 999. : atan2(sin(PhiSub2-PhiSeed),cos(PhiSub2-PhiSeed)));
03341 vals[46] = (NClusters<=2 ? 0. : EMaxSub2/ESub2);
03342 vals[47] = (NClusters<=2 ? 0. : E3x3Sub2/ESub2);
03343 vals[48] = ESub3/SCRawEnergy;
03344 vals[49] = (NClusters<=3 ? 999. : EtaSub3-EtaSeed);
03345 vals[50] = (NClusters<=3 ? 999. : atan2(sin(PhiSub3-PhiSeed),cos(PhiSub3-PhiSeed)));
03346 vals[51] = (NClusters<=3 ? 0. : EMaxSub3/ESub3);
03347 vals[52] = (NClusters<=3 ? 0. : E3x3Sub3/ESub3);
03348 vals[53] = PreShowerOverRaw;
03349 vals[54] = NPshwClusters;
03350 vals[55] = EPshwSubs/SCRawEnergy;
03351 vals[56] = EPshwSub1/SCRawEnergy;
03352 vals[57] = (NPshwClusters==0 ? 999. : EtaPshwSub1-EtaSeed);
03353 vals[58] = (NPshwClusters==0 ? 999. : atan2(sin(PhiPshwSub1-PhiSeed),cos(PhiPshwSub1-PhiSeed)));
03354 vals[59] = EPshwSub2/SCRawEnergy;
03355 vals[60] = (NPshwClusters<=1 ? 999. : EtaPshwSub2-EtaSeed);
03356 vals[61] = (NPshwClusters<=1 ? 999. : atan2(sin(PhiPshwSub2-PhiSeed),cos(PhiPshwSub2-PhiSeed)));
03357 vals[62] = EPshwSub3/SCRawEnergy;
03358 vals[63] = (NPshwClusters<=2 ? 999. : EtaPshwSub3-EtaSeed);
03359 vals[64] = (NPshwClusters<=2 ? 999. : atan2(sin(PhiPshwSub3-PhiSeed),cos(PhiPshwSub3-PhiSeed)));
03360
03361 }
03362
03363
03364 double regressionResult = 0;
03365 Int_t BinIndex = -1;
03366
03367 if (fVersionType == kWithSubCluVar) {
03368 if (isEB) {
03369 regressionResult = SCRawEnergy * forestCorrection_eb->GetResponse(vals);
03370 BinIndex = 0;
03371 }
03372 else {
03373 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestCorrection_ee->GetResponse(vals);
03374 BinIndex = 1;
03375 }
03376 }
03377
03378
03379 if (printDebug) {
03380 if (isEB) {
03381 std::cout << "Barrel :";
03382 for (unsigned int v=0; v < 61; ++v) std::cout << v << "=" << vals[v] << ", ";
03383 std::cout << "\n";
03384 }
03385 else {
03386 std::cout << "Endcap :";
03387 for (unsigned int v=0; v < 65; ++v) std::cout << v << "=" << vals[v] << ", ";
03388 std::cout << "\n";
03389 }
03390 std::cout << "BinIndex : " << BinIndex << "\n";
03391 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
03392 std::cout << "regression energy = " << regressionResult << std::endl;
03393 }
03394
03395
03396
03397 delete[] vals;
03398 return regressionResult;
03399 }
03400
03401 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithSubClusters(
03402 double SCRawEnergy,
03403 double scEta,
03404 double scPhi,
03405 double R9,
03406 double etawidth,
03407 double phiwidth,
03408 double NClusters,
03409 double HoE,
03410 double rho,
03411 double vertices,
03412 double EtaSeed,
03413 double PhiSeed,
03414 double ESeed,
03415 double E3x3Seed,
03416 double E5x5Seed,
03417 double see,
03418 double spp,
03419 double sep,
03420 double EMaxSeed,
03421 double E2ndSeed,
03422 double ETopSeed,
03423 double EBottomSeed,
03424 double ELeftSeed,
03425 double ERightSeed,
03426 double E2x5MaxSeed,
03427 double E2x5TopSeed,
03428 double E2x5BottomSeed,
03429 double E2x5LeftSeed,
03430 double E2x5RightSeed,
03431 double IEtaSeed,
03432 double IPhiSeed,
03433 double EtaCrySeed,
03434 double PhiCrySeed,
03435 double PreShowerOverRaw,
03436 double isEcalDriven,
03437 double isEtaGap,
03438 double isPhiGap,
03439 double isDeeGap,
03440 double ESubs,
03441 double ESub1,
03442 double EtaSub1,
03443 double PhiSub1,
03444 double EMaxSub1,
03445 double E3x3Sub1,
03446 double ESub2,
03447 double EtaSub2,
03448 double PhiSub2,
03449 double EMaxSub2,
03450 double E3x3Sub2,
03451 double ESub3,
03452 double EtaSub3,
03453 double PhiSub3,
03454 double EMaxSub3,
03455 double E3x3Sub3,
03456 double NPshwClusters,
03457 double EPshwSubs,
03458 double EPshwSub1,
03459 double EtaPshwSub1,
03460 double PhiPshwSub1,
03461 double EPshwSub2,
03462 double EtaPshwSub2,
03463 double PhiPshwSub2,
03464 double EPshwSub3,
03465 double EtaPshwSub3,
03466 double PhiPshwSub3,
03467 bool isEB,
03468 bool printDebug)
03469 {
03470
03471 if (fIsInitialized == kFALSE) {
03472 printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
03473 return 0;
03474 }
03475
03476
03477 if (!(fVersionType == kWithSubCluVar)) {
03478 std::cout << "Error: Regression VersionType " << fVersionType << " is not supported to use function regressionValueWithSubClusters.\n";
03479 return 0;
03480 }
03481
03482
03483 float *vals = (isEB) ? new float[61] : new float[65];
03484 if (isEB) {
03485 vals[0] = rho;
03486 vals[1] = vertices;
03487 vals[2] = isEcalDriven;
03488 vals[3] = isEtaGap;
03489 vals[4] = isPhiGap;
03490 vals[5] = isDeeGap;
03491 vals[6] = SCRawEnergy;
03492 vals[7] = scEta;
03493 vals[8] = scPhi;
03494 vals[9] = R9;
03495 vals[10] = etawidth;
03496 vals[11] = phiwidth;
03497 vals[12] = NClusters;
03498 vals[13] = HoE;
03499 vals[14] = EtaSeed - scEta;
03500 vals[15] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03501 vals[16] = ESeed/SCRawEnergy;
03502 vals[17] = E3x3Seed/ESeed;
03503 vals[18] = E5x5Seed/SCRawEnergy;
03504 vals[19] = E5x5Seed/ESeed;
03505 vals[20] = EMaxSeed/ESeed;
03506 vals[21] = E2ndSeed/ESeed;
03507 vals[22] = ETopSeed/ESeed;
03508 vals[23] = EBottomSeed/ESeed;
03509 vals[24] = ELeftSeed/ESeed;
03510 vals[25] = ERightSeed/ESeed;
03511 vals[26] = E2x5MaxSeed/ESeed;
03512 vals[27] = E2x5TopSeed/ESeed;
03513 vals[28] = E2x5BottomSeed/ESeed;
03514 vals[29] = E2x5LeftSeed/ESeed;
03515 vals[30] = E2x5RightSeed/ESeed;
03516 vals[31] = see;
03517 vals[32] = spp;
03518 vals[33] = sep;
03519 vals[34] = phiwidth/etawidth;
03520 vals[35] = (ELeftSeed+ERightSeed==0. ? 0. : (ELeftSeed-ERightSeed)/(ELeftSeed+ERightSeed));
03521 vals[36] = (ETopSeed+EBottomSeed==0. ? 0. : (ETopSeed-EBottomSeed)/(ETopSeed+EBottomSeed));
03522 vals[37] = ESubs/SCRawEnergy;
03523 vals[38] = ESub1/SCRawEnergy;
03524 vals[39] = (NClusters<=1 ? 999. : EtaSub1-EtaSeed);
03525 vals[40] = (NClusters<=1 ? 999. : atan2(sin(PhiSub1-PhiSeed),cos(PhiSub1-PhiSeed)));
03526 vals[41] = (NClusters<=1 ? 0. : EMaxSub1/ESub1);
03527 vals[42] = (NClusters<=1 ? 0. : E3x3Sub1/ESub1);
03528 vals[43] = ESub2/SCRawEnergy;
03529 vals[44] = (NClusters<=2 ? 999. : EtaSub2-EtaSeed);
03530 vals[45] = (NClusters<=2 ? 999. : atan2(sin(PhiSub2-PhiSeed),cos(PhiSub2-PhiSeed)));
03531 vals[46] = (NClusters<=2 ? 0. : EMaxSub2/ESub2);
03532 vals[47] = (NClusters<=2 ? 0. : E3x3Sub2/ESub2);
03533 vals[48] = ESub3/SCRawEnergy;
03534 vals[49] = (NClusters<=3 ? 999. : EtaSub3-EtaSeed);
03535 vals[50] = (NClusters<=3 ? 999. : atan2(sin(PhiSub3-PhiSeed),cos(PhiSub3-PhiSeed)));
03536 vals[51] = (NClusters<=3 ? 0. : EMaxSub3/ESub3);
03537 vals[52] = (NClusters<=3 ? 0. : E3x3Sub3/ESub3);
03538 vals[53] = IEtaSeed;
03539 vals[54] = ((int) IEtaSeed)%5;
03540 vals[55] = (abs(IEtaSeed)<=25)*(((int)IEtaSeed)%25) + (abs(IEtaSeed)>25)*(((int) (IEtaSeed-25*abs(IEtaSeed)/IEtaSeed))%20);
03541 vals[56] = IPhiSeed;
03542 vals[57] = ((int) IPhiSeed)%2;
03543 vals[58] = ((int) IPhiSeed)%20;
03544 vals[59] = EtaCrySeed;
03545 vals[60] = PhiCrySeed;
03546 }
03547 else {
03548 vals[0] = rho;
03549 vals[1] = vertices;
03550 vals[2] = isEcalDriven;
03551 vals[3] = isEtaGap;
03552 vals[4] = isPhiGap;
03553 vals[5] = isDeeGap;
03554 vals[6] = SCRawEnergy;
03555 vals[7] = scEta;
03556 vals[8] = scPhi;
03557 vals[9] = R9;
03558 vals[10] = etawidth;
03559 vals[11] = phiwidth;
03560 vals[12] = NClusters;
03561 vals[13] = HoE;
03562 vals[14] = EtaSeed - scEta;
03563 vals[15] = atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi));
03564 vals[16] = ESeed/SCRawEnergy;
03565 vals[17] = E3x3Seed/ESeed;
03566 vals[18] = E5x5Seed/SCRawEnergy;
03567 vals[19] = E5x5Seed/ESeed;
03568 vals[20] = EMaxSeed/ESeed;
03569 vals[21] = E2ndSeed/ESeed;
03570 vals[22] = ETopSeed/ESeed;
03571 vals[23] = EBottomSeed/ESeed;
03572 vals[24] = ELeftSeed/ESeed;
03573 vals[25] = ERightSeed/ESeed;
03574 vals[26] = E2x5MaxSeed/ESeed;
03575 vals[27] = E2x5TopSeed/ESeed;
03576 vals[28] = E2x5BottomSeed/ESeed;
03577 vals[29] = E2x5LeftSeed/ESeed;
03578 vals[30] = E2x5RightSeed/ESeed;
03579 vals[31] = see;
03580 vals[32] = spp;
03581 vals[33] = sep;
03582 vals[34] = phiwidth/etawidth;
03583 vals[35] = (ELeftSeed+ERightSeed==0. ? 0. : (ELeftSeed-ERightSeed)/(ELeftSeed+ERightSeed));
03584 vals[36] = (ETopSeed+EBottomSeed==0. ? 0. : (ETopSeed-EBottomSeed)/(ETopSeed+EBottomSeed));
03585 vals[37] = ESubs/SCRawEnergy;
03586 vals[38] = ESub1/SCRawEnergy;
03587 vals[39] = (NClusters<=1 ? 999. : EtaSub1-EtaSeed);
03588 vals[40] = (NClusters<=1 ? 999. : atan2(sin(PhiSub1-PhiSeed),cos(PhiSub1-PhiSeed)));
03589 vals[41] = (NClusters<=1 ? 0. : EMaxSub1/ESub1);
03590 vals[42] = (NClusters<=1 ? 0. : E3x3Sub1/ESub1);
03591 vals[43] = ESub2/SCRawEnergy;
03592 vals[44] = (NClusters<=2 ? 999. : EtaSub2-EtaSeed);
03593 vals[45] = (NClusters<=2 ? 999. : atan2(sin(PhiSub2-PhiSeed),cos(PhiSub2-PhiSeed)));
03594 vals[46] = (NClusters<=2 ? 0. : EMaxSub2/ESub2);
03595 vals[47] = (NClusters<=2 ? 0. : E3x3Sub2/ESub2);
03596 vals[48] = ESub3/SCRawEnergy;
03597 vals[49] = (NClusters<=3 ? 999. : EtaSub3-EtaSeed);
03598 vals[50] = (NClusters<=3 ? 999. : atan2(sin(PhiSub3-PhiSeed),cos(PhiSub3-PhiSeed)));
03599 vals[51] = (NClusters<=3 ? 0. : EMaxSub3/ESub3);
03600 vals[52] = (NClusters<=3 ? 0. : E3x3Sub3/ESub3);
03601 vals[53] = PreShowerOverRaw;
03602 vals[54] = NPshwClusters;
03603 vals[55] = EPshwSubs/SCRawEnergy;
03604 vals[56] = EPshwSub1/SCRawEnergy;
03605 vals[57] = (NPshwClusters<=0 ? 999. : EtaPshwSub1-EtaSeed);
03606 vals[58] = (NPshwClusters<=0 ? 999. : atan2(sin(PhiPshwSub1-PhiSeed),cos(PhiPshwSub1-PhiSeed)));
03607 vals[59] = EPshwSub2/SCRawEnergy;
03608 vals[60] = (NPshwClusters<=1 ? 999. : EtaPshwSub2-EtaSeed);
03609 vals[61] = (NPshwClusters<=1 ? 999. : atan2(sin(PhiPshwSub2-PhiSeed),cos(PhiPshwSub2-PhiSeed)));
03610 vals[62] = EPshwSub3/SCRawEnergy;
03611 vals[63] = (NPshwClusters<=2 ? 999. : EtaPshwSub3-EtaSeed);
03612 vals[64] = (NPshwClusters<=2 ? 999. : atan2(sin(PhiPshwSub3-PhiSeed),cos(PhiPshwSub3-PhiSeed)));
03613
03614 }
03615
03616
03617 double regressionResult = 0;
03618 Int_t BinIndex = -1;
03619
03620 if (fVersionType == kWithSubCluVar) {
03621 if (isEB) {
03622 regressionResult = SCRawEnergy * forestUncertainty_eb->GetResponse(vals);
03623 BinIndex = 0;
03624 }
03625 else {
03626 regressionResult = (SCRawEnergy*(1+PreShowerOverRaw)) * forestUncertainty_ee->GetResponse(vals);
03627 BinIndex = 1;
03628 }
03629 }
03630
03631
03632 if (printDebug) {
03633 if (isEB) {
03634 std::cout << "Barrel :";
03635 for (unsigned int v=0; v < 38; ++v) std::cout << vals[v] << ", ";
03636 std::cout << "\n";
03637 }
03638 else {
03639 std::cout << "Endcap :";
03640 for (unsigned int v=0; v < 31; ++v) std::cout << vals[v] << ", ";
03641 std::cout << "\n";
03642 }
03643 std::cout << "BinIndex : " << BinIndex << "\n";
03644 std::cout << "SCRawEnergy = " << SCRawEnergy << " : PreShowerOverRaw = " << PreShowerOverRaw << std::endl;
03645 std::cout << "regression energy uncertainty = " << regressionResult << std::endl;
03646 }
03647
03648
03649
03650 delete[] vals;
03651 return regressionResult;
03652 }
03653