CMS 3D CMS Logo

/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/EgammaAnalysis/ElectronTools/src/ElectronEnergyRegressionEvaluate.cc

Go to the documentation of this file.
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 // Destructor does nothing
00027 
00028 
00029 void ElectronEnergyRegressionEvaluate::initialize(std::string weightsFile, 
00030                                                   ElectronEnergyRegressionEvaluate::ElectronEnergyRegressionType type) {
00031 
00032   // Loading forest object according to different versions
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   // Just checking
00041   assert(forestCorrection_eb);
00042   assert(forestCorrection_ee);
00043   assert(forestUncertainty_eb);
00044   assert(forestUncertainty_ee);
00045     
00046   // Updating type and marking as initialized
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   // Checking if instance has been initialized
00643   if (fIsInitialized == kFALSE) {
00644     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00645     return 0;
00646   }
00647 
00648   // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
00656   float *vals = (fabs(scEta) <= 1.479) ? new float[38] : new float[31];
00657   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
00807   if (fIsInitialized == kFALSE) {
00808     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00809     return 0;
00810   }
00811 
00812   // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
00819   float *vals = (fabs(scEta) <= 1.479) ? new float[38] : new float[31];
00820   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
00974   if (fIsInitialized == kFALSE) {
00975     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
00976     return 0;
00977   }
00978 
00979   // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
00986   float *vals = (fabs(scEta) <= 1.479) ? new float[39] : new float[32];
00987   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
01140   if (fIsInitialized == kFALSE) {
01141     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01142     return 0;
01143   }
01144 
01145   // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
01152   float *vals = (fabs(scEta) <= 1.479) ? new float[39] : new float[32];
01153   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
01263   delete[] vals;
01264   return regressionResult;
01265 }
01266 
01267 
01268 
01269 // This option is now deprecated. we keep it only
01270 // for backwards compatibility
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   // Checking if instance has been initialized
01315   if (fIsInitialized == kFALSE) {
01316     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01317     return 0;
01318   }
01319 
01320   // Checking if fVersionType is correct
01321   assert(fVersionType == kWithTrkVar);
01322 
01323   float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
01324   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
01435   delete[] vals;
01436   return regressionResult;
01437 }
01438 
01439 
01440 
01441 
01442 // This option is now deprecated. we keep it only
01443 // for backwards compatibility
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   // Checking if instance has been initialized
01488   if (fIsInitialized == kFALSE) {
01489     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01490     return 0;
01491   }
01492 
01493   // Checking if fVersionType is correct
01494   assert(fVersionType == kWithTrkVar);
01495 
01496   float *vals = (fabs(scEta) <= 1.479) ? new float[43] : new float[36];
01497   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
01661   if (fIsInitialized == kFALSE) {
01662     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01663     return 0;
01664   }
01665 
01666   // Checking if fVersionType is correct
01667   assert(fVersionType == kWithTrkVarV1);
01668 
01669   float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
01670   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
01840   if (fIsInitialized == kFALSE) {
01841     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01842     return 0;
01843   }
01844 
01845   // Checking if fVersionType is correct
01846   assert(fVersionType == kWithTrkVarV1);
01847 
01848   float *vals = (fabs(scEta) <= 1.479) ? new float[46] : new float[39];
01849   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
01978   if (fIsInitialized == kFALSE) {
01979     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
01980     return 0;
01981   }
01982 
01983   // Checking if fVersionType is correct
01984   assert(fVersionType == kWithTrkVarV1);
01985 
01986   // Checking if fVersionType is correct
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) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
02150   delete[] vals;
02151   return regressionResult;
02152 }
02153 
02154 
02155 
02156 
02157 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV1(std::vector<double> &inputvars,                                                                          
02158                                                                            bool printDebug) 
02159 {
02160   // Checking if instance has been initialized
02161   if (fIsInitialized == kFALSE) {
02162     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02163     return 0;
02164   }
02165 
02166   // Checking if fVersionType is correct
02167   assert(fVersionType == kWithTrkVarV1);
02168 
02169   // Checking if fVersionType is correct
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) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
02393   if (fIsInitialized == kFALSE) {
02394     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02395     return 0;
02396   }
02397 
02398   // Checking if fVersionType is correct
02399   assert(fVersionType == kWithTrkVarV2);
02400 
02401   float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
02402   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
02593   if (fIsInitialized == kFALSE) {
02594     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02595     return 0;
02596   }
02597 
02598   // Checking if fVersionType is correct
02599   assert(fVersionType == kWithTrkVarV2);
02600 
02601   float *vals = (fabs(scEta) <= 1.479) ? new float[53] : new float[46];
02602   if (fabs(scEta) <= 1.479) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
02733   delete[] vals;
02734   return regressionResult;
02735 }
02736 
02737 
02738 
02739 
02740 double ElectronEnergyRegressionEvaluate::regressionValueWithTrkVarV2(std::vector<double> &inputvars,
02741                                                                      bool printDebug) 
02742 {
02743   // Checking if instance has been initialized
02744   if (fIsInitialized == kFALSE) {
02745     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02746     return 0;
02747   }
02748 
02749   // Checking if fVersionType is correct
02750   assert(fVersionType == kWithTrkVarV2);
02751 
02752   // Checking if fVersionType is correct
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) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
02937   delete[] vals;
02938   return regressionResult;
02939 }
02940 
02941 
02942 
02943 
02944 double ElectronEnergyRegressionEvaluate::regressionUncertaintyWithTrkVarV2(std::vector<double> &inputvars,                                                                        
02945                                                                            bool printDebug) 
02946 {
02947   // Checking if instance has been initialized
02948   if (fIsInitialized == kFALSE) {
02949     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
02950     return 0;
02951   }
02952 
02953   // Checking if fVersionType is correct
02954   assert(fVersionType == kWithTrkVarV2);
02955 
02956   // Checking if fVersionType is correct
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) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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     // Checking if instance has been initialized
03216     if (fIsInitialized == kFALSE) {
03217         printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
03218         return 0;
03219     }
03220 
03221     // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
03230   float *vals = (isEB) ? new float[61] : new float[65];
03231   if (isEB) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
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   // Checking if instance has been initialized
03471   if (fIsInitialized == kFALSE) {
03472     printf("ElectronEnergyRegressionEvaluate instance not initialized !!!");
03473     return 0;
03474   }
03475 
03476   // Checking if type is correct
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   // Now applying regression according to version and (endcap/barrel)
03483   float *vals = (isEB) ? new float[61] : new float[65];
03484   if (isEB) {           // Barrel
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 {        // Endcap
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   // Now evaluating the regression
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   //print debug
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   // Cleaning up and returning
03650   delete[] vals;
03651   return regressionResult;
03652 }
03653