void run(Char_t* data, Long64_t nev = -1, Long64_t offset = 0, Bool_t debug = kFALSE, Int_t runMode = 0, Bool_t isMC = 0, Int_t centrBin = 0, const char * centrEstimator = "VOM", Int_t useOtherCentralityCut = 0, Int_t trackMin=0, Int_t trackMax=10000, const char* option = "",TString customSuffix = "", Int_t workers = -1, Bool_t useSingleBin=kTRUE, const char * runList = 0) { // runMode: // // 0 local // 1 proof if (nev < 0) nev = 1234567890; InitAndLoadLibs(runMode,workers,debug); // Create the analysis manager mgr = new AliAnalysisManager; // Add ESD handler AliESDInputHandler* esdH = new AliESDInputHandler; // Do I need any of this? esdH->SetInactiveBranches("AliESDACORDE FMD ALIESDTZERO ALIESDZDC AliRawDataErrorLogs CaloClusters Cascades EMCALCells EMCALTrigger ESDfriend Kinks AliESDTZERO ALIESDACORDE MuonTracks TrdTracks"); mgr->SetInputEventHandler(esdH); if(isMC) { AliMCEventHandler* handler = new AliMCEventHandler; handler->SetPreReadMode(AliMCEventHandler::kLmPreRead); mgr->SetMCtruthEventHandler(handler); } // Parse option strings TString optionStr(option); // remove SAVE option if set // This is copied from a macro by Jan. The reason I kept it is that I may want to pass textual options to the new task at some point Bool_t doSave = kFALSE; TString optionStr(option); if (optionStr.Contains("SAVE")) { optionStr = optionStr(0,optionStr.Index("SAVE")) + optionStr(optionStr.Index("SAVE")+4, optionStr.Length()); doSave = kTRUE; } AliESDtrackCuts * cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE); TString pathsuffix = ""; if(!useSingleBin) pathsuffix += "_AllCentr"; if (optionStr.Contains("DCA")) { delete cuts; // cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(); cout << ">>>> USING DCA cut" << endl; cuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(); cuts->SetMaxChi2TPCConstrainedGlobal(); // remove golden cut pathsuffix+="_DCAcut"; } if (optionStr.Contains("ITSsa")) { delete cuts; cuts = AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(); cout << ">>>> USING ITS sa tracks" << endl; pathsuffix+="_ITSsa"; } if (optionStr.Contains("TPC")) { delete cuts; cuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts(); cout << ">>>> USING TPC only tracks" << endl; pathsuffix+="_TPC"; } if(optionStr.Contains("NoElectrons")) pathsuffix +="_NoElectrons"; Bool_t useMCKinematics = isMC; if (optionStr.Contains("NOMCKIN")) { cout << ">>>> Ignoring MC kinematics" << endl; useMCKinematics=kFALSE; pathsuffix+="_NOMCKIN"; } // If we are running on grid, we need the alien handler if (runMode == kMyRunModeGRID) { // Create and configure the alien handler plugin gROOT->LoadMacro("CreateAlienHandler.C"); AliAnalysisGrid *alienHandler = CreateAlienHandler(data, runList, pathsuffix.Data(), listToLoad, "full", isMC); // full if (!alienHandler) { cout << "Cannot create alien handler" << endl; exit(1); } mgr->SetGridHandler(alienHandler); } // Add tasks // physics selection gROOT->ProcessLine(".L $ALICE_ROOT/OADB/macros/AddTaskPhysicsSelection.C"); physicsSelectionTask = AddTaskPhysicsSelection(isMC); //PID gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); AddTaskPIDResponse(isMC); // // PID QA: // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C"); // AddTaskPIDqa(); // Centrality gROOT->LoadMacro("$ALICE_ROOT/OADB/macros/AddTaskCentrality.C"); AliCentralitySelectionTask *taskCentr = AddTaskCentrality(); // OBSOLETE const char * file1 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityBy1D.root"; const char * file2 = "$ALICE_ROOT/ANALYSIS/macros/test_AliCentralityByFunction.root"; // END of OBSOLETE if(isMC) taskCentr-> SetMCInput(); taskCentr->SetPass(2); // Create my own centrality selector AliAnalysisMultPbCentralitySelector * centrSelector = new AliAnalysisMultPbCentralitySelector(); centrSelector->SetIsMC(isMC); centrSelector->SetCentrTaskFiles(file1,file2); // for bookkeping only centrSelector->SetCentralityBin(centrBin); if (!useSingleBin) centrSelector->SetCentralityBin(0); // FIXME: ok? centrSelector->SetCentralityEstimator(centrEstimator); if(useOtherCentralityCut == 1){ cout << "Setting centrality by MULT" << endl; centrSelector->SetUseMultRange(); centrSelector->SetMultRange(trackMin,trackMax); } if(useOtherCentralityCut == 2){ cout << "Setting centrality by V0" << endl; centrSelector->SetUseV0Range(); centrSelector->SetMultRange(trackMin,trackMax); } if(useOtherCentralityCut == 3){ cout << "Setting centrality by SPD outer" << endl; centrSelector->SetUseSPDOuterRange(); centrSelector->SetMultRange(trackMin,trackMax); } // load my task if (useSingleBin) { gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracks.C"); AliAnalysisTaskMultPbTracks * task = AddTaskMultPbPbTracks("multPbPbtracks.root", cuts, centrSelector); task->SetIsMC(useMCKinematics); task->SetOfflineTrigger(AliVEvent::kMB); if(optionStr.Contains("TPC")) task->SetTPCOnly(); if(optionStr.Contains("NoElectrons")) task->RejectElectrons(kTRUE); if(useMCKinematics) task->GetHistoManager()->SetSuffix("MC"); if(customSuffix!=""){ cout << "Setting custom suffix: " << customSuffix << endl; task->GetHistoManager()->SetSuffix(customSuffix); } } else { gROOT->ProcessLine(".L $ALICE_ROOT/PWG0/multPbPb/AddTaskMultPbPbTracksAllCentrality.C"); centrSelector->SetUseV0Range(kTRUE); Int_t ncentr = 11; const Float_t minCentr[] = {0 ,79 ,239,559 ,1165,2135,3555,5525,8213 ,12191,15079}; const Float_t maxCentr[] = {79,239,559,1165,2135,3555,5525,8213,12191,15079,21000}; AliAnalysisTaskMultPbTracks ** tasks = AddTaskMultPbPbTracksAllCentrality("multPbPbtracks.root", cuts, centrSelector, ncentr,minCentr,maxCentr); for(Int_t icentr = 0; icentr < ncentr; icentr++){ tasks[icentr]->Print(); cout << "MC KINEMATICS:" << useMCKinematics << endl; tasks[icentr]->SetIsMC(useMCKinematics); tasks[icentr]->SetOfflineTrigger(AliVEvent::kMB); if(optionStr.Contains("TPC")) tasks[icentr]->SetTPCOnly(); if(optionStr.Contains("NoElectrons")) task[icentr]->RejectElectrons(kTRUE); if(useMCKinematics) tasks[icentr]->GetHistoManager()->SetSuffix("MC"); if(customSuffix!=""){ cout << "Setting custom suffix: " << customSuffix+long(icentr) << endl; tasks[icentr]->GetHistoManager()->SetSuffix(customSuffix+long(icentr)); } } } // Init and run the analy if (!mgr->InitAnalysis()) return; mgr->PrintStatus(); if (runMode == kMyRunModeLocal ) { // If running in local mode, create chain of ESD files cout << "RUNNING LOCAL, CHAIN" << endl; TChain * chain = GetAnalysisChain(data); chain->Print(); mgr->StartAnalysis("local",chain,nev); } else if (runMode == kMyRunModeProofLite) { TChain * chain = GetAnalysisChain(data); mgr->StartAnalysis("proof",chain,nev); } else if (runMode == kMyRunModeCAF) { mgr->StartAnalysis("proof",TString(data)+"#esdTree",nev); } else if (runMode == kMyRunModeGRID) { mgr->StartAnalysis("grid"); } else { cout << "ERROR: unknown run mode" << endl; } if (!useOtherCentralityCut) { pathsuffix = pathsuffix + "_" + centrEstimator + "_bin_"+long(centrBin); } else if(useOtherCentralityCut==1){ pathsuffix = pathsuffix + "_TrackRange_" + long(trackMin) + "_" + long(trackMax); } else if(useOtherCentralityCut==2){ pathsuffix = pathsuffix + "_V0Range_" + long(trackMin) + "_" + long(trackMax); } else if(useOtherCentralityCut==3){ pathsuffix = pathsuffix + "_SPDOutRange_" + long(trackMin) + "_" + long(trackMax); } pathsuffix += customSuffix; if (doSave) MoveOutput(data, pathsuffix.Data()); }
void trainElectronEnergyRegression_ECAL(char* trainingFile, char* outWeightFile, char* optionChar, int nTrees) { // Setting up training option std::string optionStr(optionChar); // ******** If option is V00, V01, V02, etc. ********* // if (optionStr == "V00" || optionStr == "V01") { GBRTrainer *traineb = new GBRTrainer; GBRTrainer *trainebvar = new GBRTrainer; GBRTrainer *trainee = new GBRTrainer; GBRTrainer *traineevar = new GBRTrainer; TTree *intree = 0; cout << "Training on file " << trainingFile << " with version " << optionChar << endl; TChain *chainele = new TChain("eleIDdir/T1"); chainele->Add(trainingFile); chainele->LoadTree(0); chainele->SetCacheSize(64*1024*1024); chainele->SetCacheLearnEntries(); intree = chainele; traineb->AddTree(chainele); trainebvar->AddTree(chainele); trainee->AddTree(chainele); traineevar->AddTree(chainele); TCut traincut = "pt>0";//////////////////////////////// TCut evtcut; TCut evtcutvar; TCut statusenergycut; //if you want to train also energy variance evtcut = "event%2==0 "; evtcutvar = "event%2==1 "; statusenergycut="(GeneratedEnergyStatus3-GeneratedEnergyStatus1)/GeneratedEnergyStatus3<0.01 && GeneratedEnergyStatus3>=GeneratedEnergyStatus1"; traineb->SetTrainingCut(std::string(traincut && evtcut && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); trainee->SetTrainingCut(std::string(traincut && evtcut && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5 && mcmatch==1")); //turn this off for now trainebvar->SetTrainingCut(std::string(traincut && evtcutvar && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); traineevar->SetTrainingCut(std::string(traincut && evtcutvar && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5 && mcmatch==1")); const double maxsig = 3.0; const double shrinkage = 0.1; traineb->SetMinEvents(200); traineb->SetShrinkage(shrinkage); traineb->SetMinCutSignificance(maxsig); trainebvar->SetMinEvents(200); trainebvar->SetShrinkage(shrinkage); trainebvar->SetMinCutSignificance(maxsig); trainee->SetMinEvents(200); trainee->SetShrinkage(shrinkage); trainee->SetMinCutSignificance(maxsig); traineevar->SetMinEvents(200); traineevar->SetShrinkage(shrinkage); traineevar->SetMinCutSignificance(maxsig); traineb->SetTargetVar("GeneratedEnergyStatus3/SCRawEnergy"); trainebvar->SetTargetVar("abs( targeteb - GeneratedEnergyStatus3/SCRawEnergy) "); trainee->SetTargetVar("GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))"); traineevar->SetTargetVar("abs( targetee - GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))) "); std::vector<std::string> *varsf = new std::vector<std::string>; varsf->push_back("SCRawEnergy"); varsf->push_back("scEta"); varsf->push_back("scPhi"); varsf->push_back("R9"); varsf->push_back("E5x5Seed/SCRawEnergy"); varsf->push_back("etawidth"); varsf->push_back("phiwidth"); varsf->push_back("NClusters"); varsf->push_back("HoE"); varsf->push_back("rho"); varsf->push_back("vertices"); varsf->push_back("EtaSeed-scEta"); varsf->push_back("atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi))"); varsf->push_back("ESeed/SCRawEnergy"); varsf->push_back("E3x3Seed/ESeed"); varsf->push_back("E5x5Seed/ESeed"); varsf->push_back("see"); varsf->push_back("spp"); // varsf->push_back("sep"); varsf->push_back("EMaxSeed/ESeed"); varsf->push_back("E2ndSeed/ESeed"); varsf->push_back("ETopSeed/ESeed"); varsf->push_back("EBottomSeed/ESeed"); varsf->push_back("ELeftSeed/ESeed"); varsf->push_back("ERightSeed/ESeed"); varsf->push_back("E2x5MaxSeed/ESeed"); varsf->push_back("E2x5TopSeed/ESeed"); varsf->push_back("E2x5BottomSeed/ESeed"); varsf->push_back("E2x5LeftSeed/ESeed"); varsf->push_back("E2x5RightSeed/ESeed"); std::vector<std::string> *varseb = new std::vector<std::string>(*varsf); std::vector<std::string> *varsee = new std::vector<std::string>(*varsf); varseb->push_back("IEtaSeed"); varseb->push_back("IPhiSeed"); varseb->push_back("IEtaSeed%5"); varseb->push_back("IPhiSeed%2"); varseb->push_back("(abs(IEtaSeed)<=25)*(IEtaSeed%25) + (abs(IEtaSeed)>25)*((IEtaSeed-25*abs(IEtaSeed)/IEtaSeed)%20)"); varseb->push_back("IPhiSeed%20"); varseb->push_back("EtaCrySeed"); varseb->push_back("PhiCrySeed"); varsee->push_back("PreShowerOverRaw"); for (int i=0; i<varseb->size(); ++i) { cout << "var " << i << " = " << varseb->at(i) << endl; traineb->AddInputVar(varseb->at(i)); trainebvar->AddInputVar(varseb->at(i)); } for (int i=0; i<varsee->size(); ++i) { cout << "var " << i << " = " << varsee->at(i) << endl; trainee->AddInputVar(varsee->at(i)); traineevar->AddInputVar(varsee->at(i)); } ROOT::Cintex::Cintex::Enable(); // TFile *ftmp = new TFile("tmpfile.root","RECREATE"); GBRApply gbrapply; //Train Barrel Energy Regression intree->LoadTree(0); const GBRForest *foresteb = traineb->TrainForest(nTrees); delete traineb; //Apply Barrel Energy Regression intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, foresteb, *varseb, "targeteb"); //Train Barrel Variance Regression intree->LoadTree(0); const GBRForest *forestebvar = trainebvar->TrainForest(nTrees); delete trainebvar; //Train Endcap Energy Regression intree->LoadTree(0); const GBRForest *forestee = trainee->TrainForest(nTrees); delete trainee; //Apply Endcap Energy Regression intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, forestee, *varsee, "targetee"); //Train Endcap Variance Regression intree->LoadTree(0); const GBRForest *foresteevar = traineevar->TrainForest(nTrees); delete traineevar; TString fname; fname = outWeightFile; TFile *fout = new TFile(fname,"RECREATE"); cout << "Saving weights to file " << fname << endl; fout->WriteObject(foresteb,"EBCorrection"); fout->WriteObject(forestebvar,"EBUncertainty"); fout->WriteObject(forestee,"EECorrection"); fout->WriteObject(foresteevar,"EEUncertainty"); fout->WriteObject(varseb, "varlisteb"); fout->WriteObject(varsee, "varlistee"); // ftmp->Close(); // fout->Close(); } // ******** If option is V10, V11, V12, etc. ******** // // *** Do training separately for low and high pT *** // if (optionStr == "V10" || optionStr == "V11") { GBRTrainer *traineb_lowPt = new GBRTrainer; GBRTrainer *traineb_highPt = new GBRTrainer; GBRTrainer *trainebvar_lowPt = new GBRTrainer; GBRTrainer *trainebvar_highPt = new GBRTrainer; GBRTrainer *trainee_lowPt = new GBRTrainer; GBRTrainer *trainee_highPt = new GBRTrainer; GBRTrainer *traineevar_lowPt = new GBRTrainer; GBRTrainer *traineevar_highPt = new GBRTrainer; TTree *intree = 0; cout << "Training on file " << trainingFile << " with version " << optionChar << endl; TChain *chainele = new TChain("eleIDdir/T1"); chainele->Add(trainingFile); chainele->LoadTree(0); chainele->SetCacheSize(64*1024*1024); chainele->SetCacheLearnEntries(); intree = chainele; traineb_lowPt->AddTree(chainele); trainebvar_lowPt->AddTree(chainele); trainee_lowPt->AddTree(chainele); traineevar_lowPt->AddTree(chainele); traineb_highPt->AddTree(chainele); trainebvar_highPt->AddTree(chainele); trainee_highPt->AddTree(chainele); traineevar_highPt->AddTree(chainele); TCut traincut_lowPt = "pt>7 && pt<15"; TCut traincut_highPt = "pt>=15"; TCut statusenergycut; TCut evtcut; TCut evtcutvar; //if you want to train also energy variance evtcut = "event%2==0 "; evtcutvar = "event%2==1 "; statusenergycut="(GeneratedEnergyStatus3-GeneratedEnergyStatus1)/GeneratedEnergyStatus3<0.01 && GeneratedEnergyStatus3>=GeneratedEnergyStatus1"; traineb_lowPt->SetTrainingCut(std::string(traincut_lowPt && evtcut && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); trainee_lowPt->SetTrainingCut(std::string(traincut_lowPt && evtcut && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5 && mcmatch==1")); traineb_highPt->SetTrainingCut(std::string(traincut_highPt && evtcut && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); trainee_highPt->SetTrainingCut(std::string(traincut_highPt && evtcut && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5&& mcmatch==1")); //turn this off for now trainebvar_lowPt->SetTrainingCut(std::string(traincut_lowPt && evtcutvar && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); traineevar_lowPt->SetTrainingCut(std::string(traincut_lowPt && evtcutvar && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5 && mcmatch==1")); trainebvar_highPt->SetTrainingCut(std::string(traincut_highPt && evtcutvar && statusenergycut && "abs(eta)<1.479 && mcmatch==1")); traineevar_highPt->SetTrainingCut(std::string(traincut_highPt && evtcutvar && statusenergycut && "abs(eta)>1.479 && abs(eta)<2.5&& mcmatch==1")); const double maxsig = 3.0; const double shrinkage = 0.1; traineb_lowPt->SetMinEvents(200); traineb_lowPt->SetShrinkage(shrinkage); traineb_lowPt->SetMinCutSignificance(maxsig); traineb_highPt->SetMinEvents(200); traineb_highPt->SetShrinkage(shrinkage); traineb_highPt->SetMinCutSignificance(maxsig); trainebvar_lowPt->SetMinEvents(200); trainebvar_lowPt->SetShrinkage(shrinkage); trainebvar_lowPt->SetMinCutSignificance(maxsig); trainebvar_highPt->SetMinEvents(200); trainebvar_highPt->SetShrinkage(shrinkage); trainebvar_highPt->SetMinCutSignificance(maxsig); trainee_lowPt->SetMinEvents(200); trainee_lowPt->SetShrinkage(shrinkage); trainee_lowPt->SetMinCutSignificance(maxsig); trainee_highPt->SetMinEvents(200); trainee_highPt->SetShrinkage(shrinkage); trainee_highPt->SetMinCutSignificance(maxsig); traineevar_lowPt->SetMinEvents(200); traineevar_lowPt->SetShrinkage(shrinkage); traineevar_lowPt->SetMinCutSignificance(maxsig); traineevar_highPt->SetMinEvents(200); traineevar_highPt->SetShrinkage(shrinkage); traineevar_highPt->SetMinCutSignificance(maxsig); traineb_lowPt->SetTargetVar("GeneratedEnergyStatus3/SCRawEnergy"); traineb_highPt->SetTargetVar("GeneratedEnergyStatus3/SCRawEnergy"); trainebvar_lowPt->SetTargetVar("abs( targeteb_lowPt - GeneratedEnergyStatus3/SCRawEnergy) "); trainebvar_highPt->SetTargetVar("abs( targeteb_highPt - GeneratedEnergyStatus3/SCRawEnergy) "); trainee_lowPt->SetTargetVar("GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))"); trainee_highPt->SetTargetVar("GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))"); traineevar_lowPt->SetTargetVar("abs( targetee_lowPt - GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))) "); traineevar_highPt->SetTargetVar("abs( targetee_highPt - GeneratedEnergyStatus3/(SCRawEnergy*(1+PreShowerOverRaw))) "); std::vector<std::string> *varsf = new std::vector<std::string>; varsf->push_back("SCRawEnergy"); varsf->push_back("scEta"); varsf->push_back("scPhi"); varsf->push_back("R9"); varsf->push_back("E5x5Seed/SCRawEnergy"); varsf->push_back("etawidth"); varsf->push_back("phiwidth"); varsf->push_back("NClusters"); varsf->push_back("HoE"); varsf->push_back("rho"); varsf->push_back("vertices"); varsf->push_back("EtaSeed-scEta"); varsf->push_back("atan2(sin(PhiSeed-scPhi),cos(PhiSeed-scPhi))"); varsf->push_back("ESeed/SCRawEnergy"); varsf->push_back("E3x3Seed/ESeed"); varsf->push_back("E5x5Seed/ESeed"); varsf->push_back("see"); varsf->push_back("spp"); // varsf->push_back("sep"); varsf->push_back("EMaxSeed/ESeed"); varsf->push_back("E2ndSeed/ESeed"); varsf->push_back("ETopSeed/ESeed"); varsf->push_back("EBottomSeed/ESeed"); varsf->push_back("ELeftSeed/ESeed"); varsf->push_back("ERightSeed/ESeed"); varsf->push_back("E2x5MaxSeed/ESeed"); varsf->push_back("E2x5TopSeed/ESeed"); varsf->push_back("E2x5BottomSeed/ESeed"); varsf->push_back("E2x5LeftSeed/ESeed"); varsf->push_back("E2x5RightSeed/ESeed"); std::vector<std::string> *varseb = new std::vector<std::string>(*varsf); std::vector<std::string> *varsee = new std::vector<std::string>(*varsf); varseb->push_back("IEtaSeed"); varseb->push_back("IPhiSeed"); varseb->push_back("IEtaSeed%5"); varseb->push_back("IPhiSeed%2"); varseb->push_back("(abs(IEtaSeed)<=25)*(IEtaSeed%25) + (abs(IEtaSeed)>25)*((IEtaSeed-25*abs(IEtaSeed)/IEtaSeed)%20)"); varseb->push_back("IPhiSeed%20"); varseb->push_back("EtaCrySeed"); varseb->push_back("PhiCrySeed"); varsee->push_back("PreShowerOverRaw"); for (int i=0; i<varseb->size(); ++i) { cout << "var " << i << " = " << varseb->at(i) << endl; traineb_lowPt->AddInputVar(varseb->at(i)); trainebvar_lowPt->AddInputVar(varseb->at(i)); } for (int i=0; i<varseb->size(); ++i) { cout << "var " << i << " = " << varseb->at(i) << endl; traineb_highPt->AddInputVar(varseb->at(i)); trainebvar_highPt->AddInputVar(varseb->at(i)); } for (int i=0; i<varsee->size(); ++i) { cout << "var " << i << " = " << varsee->at(i) << endl; trainee_lowPt->AddInputVar(varsee->at(i)); traineevar_lowPt->AddInputVar(varsee->at(i)); } for (int i=0; i<varsee->size(); ++i) { cout << "var " << i << " = " << varsee->at(i) << endl; trainee_highPt->AddInputVar(varsee->at(i)); traineevar_highPt->AddInputVar(varsee->at(i)); } ROOT::Cintex::Cintex::Enable(); // TFile *ftmp = new TFile("tmpfile.root","RECREATE"); GBRApply gbrapply; //Train Barrel Energy Regression (low pT) intree->LoadTree(0); const GBRForest *foresteb_lowPt = traineb_lowPt->TrainForest(nTrees); delete traineb_lowPt; //Apply Barrel Energy Regression (low pT) intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, foresteb_lowPt, *varseb, "targeteb_lowPt"); //Train Barrel Energy Regression (high pT) intree->LoadTree(0); const GBRForest *foresteb_highPt = traineb_highPt->TrainForest(nTrees); delete traineb_highPt; //Apply Barrel Energy Regression (high pT) intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, foresteb_highPt, *varseb, "targeteb_highPt"); //Train Barrel Variance Regression (low pT) intree->LoadTree(0); const GBRForest *forestebvar_lowPt = trainebvar_lowPt->TrainForest(nTrees); delete trainebvar_lowPt; //Train Barrel Variance Regression (high pT) intree->LoadTree(0); const GBRForest *forestebvar_highPt = trainebvar_highPt->TrainForest(nTrees); delete trainebvar_highPt; //Train Endcap Energy Regression (low pT) intree->LoadTree(0); const GBRForest *forestee_lowPt = trainee_lowPt->TrainForest(nTrees); delete trainee_lowPt; //Apply Endcap Energy Regression intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, forestee_lowPt, *varsee, "targetee_lowPt"); //Train Endcap Energy Regression (high pT) intree->LoadTree(0); const GBRForest *forestee_highPt = trainee_highPt->TrainForest(nTrees); delete trainee_highPt; //Apply Endcap Energy Regression intree->LoadTree(0); gbrapply.ApplyAsFriend(intree, forestee_highPt, *varsee, "targetee_highPt"); //Train Endcap Variance Regression (low pT) intree->LoadTree(0); const GBRForest *foresteevar_lowPt = traineevar_lowPt->TrainForest(nTrees); delete traineevar_lowPt; //Train Endcap Variance Regression (high pT) intree->LoadTree(0); const GBRForest *foresteevar_highPt = traineevar_highPt->TrainForest(nTrees); delete traineevar_highPt; TString fname; fname = outWeightFile; TFile *fout = new TFile(fname,"RECREATE"); cout << "Saving weights to file " << fname << endl; fout->WriteObject(foresteb_lowPt,"EBCorrection_lowPt"); fout->WriteObject(foresteb_highPt,"EBCorrection_highPt"); fout->WriteObject(forestebvar_lowPt,"EBUncertainty_lowPt"); fout->WriteObject(forestebvar_highPt,"EBUncertainty_highPt"); fout->WriteObject(forestee_lowPt,"EECorrection_lowPt"); fout->WriteObject(forestee_highPt,"EECorrection_highPt"); fout->WriteObject(foresteevar_lowPt,"EEUncertainty_lowPt"); fout->WriteObject(foresteevar_highPt,"EEUncertainty_highPt"); fout->WriteObject(varseb, "varlisteb"); fout->WriteObject(varsee, "varlistee"); // ftmp->Close(); // fout->Close(); } }