void CopyDir(TDirectory *source) {
//copy all objects and subdirs of directory source as a subdir of the current directory
source->ls();
TDirectory *savdir = gDirectory;
TDirectory *adir = savdir->mkdir(source->GetName());
adir->cd();
//loop on all entries of this directory
TKey *key;
TIter nextkey(source->GetListOfKeys());
while ((key = (TKey*)nextkey())) {
const char *classname = key->GetClassName();
TClass *cl = gROOT->GetClass(classname);
if (!cl) continue;
if (cl->InheritsFrom(TDirectory::Class())) {
source->cd(key->GetName());
TDirectory *subdir = gDirectory;
adir->cd();
CopyDir(subdir);
adir->cd();
} else if (cl->InheritsFrom(TTree::Class())) {
TTree *T = (TTree*)source->Get(key->GetName());
adir->cd();
TTree *newT = T->CloneTree(-1,"fast");
newT->Write();
} else {
source->cd();
TObject *obj = key->ReadObj();
adir->cd();
obj->Write();
delete obj;
}
}
adir->SaveSelf(kTRUE);
savdir->cd();
}
void TreeFlattener::MakeFlatTree(){
TFile* InFile = new TFile(InputFile);
TTree* InTree =(TTree*)InFile->Get(TreeName.data());
for(auto& B : BranchesToFlatten){
int status=InTree->SetBranchAddress(B.BranchName.data(),&(B.StackedBranch));
std::cout<<"Branch Set Status = "<<status<<"for branch "<<B.BranchName<<std::endl;
if(status!=0){
BranchAddressError BError(B.BranchName);
throw BError;
}
}
TFile* TOutFile = new TFile(OutputFile,"RECREATE");
TTree* NewTree = InTree->CloneTree(0);
for(auto& B : BranchesToFlatten){
std::string TypeName=B.BranchName+"/D";
NewTree->Branch(B.FlatBranchName.data(),&(B.FlatBranch),TypeName.data());
}
LoopTimer LT(0.10);
Long64_t N=InTree->GetEntries();
for(int i=0;i<N;++i){
LT.DeclareLoopStart(N);
InTree->GetEntry(i);
for(auto& B: BranchesToFlatten){
B.FlatBranch=B.StackedBranch[0];
}
NewTree->Fill();
}
NewTree->Write();
TOutFile->Close();
}
void skim(){
int numSkip = 1013;
TFile* file = TFile::Open("bigFile.root");
TTree* tree = (TTree*) file->Get("T");
Long64_t nEntries = tree->GetEntries();
ULong64_t event;
tree->SetBranchAddress("event", &event);
tree->SetBranchStatus("*",1);
TFile *newfile = new TFile("skimmedTree.root","recreate");
TTree *newtree = tree->CloneTree(0);
for (Long64_t n=0; n<nEntries; n++) {
tree->GetEntry(n);
if (event % numSkip == 0) newtree->Fill();
}
newtree->Print();
newfile->Write();
delete file;
delete newfile;
}
void addBranches(string filename = "f1420")
{
cout << "Adding branches to " << filename << endl;
/*Input************************************************************************/
// Open the input file and create the output file
TFile* infile = TFile::Open((filename+".root" ).c_str()),
* outfile = TFile::Open((filename+"_Bs0_branches.root").c_str(),"RECREATE");
// Get the input tree and create an empty output tree
TTree* intree = (TTree*)infile->Get("tree"),
* outtree = intree->CloneTree(0);
// Read the number of events in the input file
Int_t n = intree->GetEntries();
double mass;
intree->SetBranchAddress("m_b",&mass);
outtree->Branch("B_s0_M",&mass);
outtree->Branch("B_s0_LOKI_Mass",&mass);
/*Event loop*******************************************************************/
for(Int_t i = 0; i < n; i++)
{
intree->GetEntry(i);
/*Fill tree and show progress**************************************************/
outtree->Fill();
}
/*Write the output*************************************************************/
outtree->Write();
infile->Close();
outfile->Close();
return;
}
void create_smalltuple()
{
TFile *oldfile = new TFile("/afs/cern.ch/work/t/tbird/eta/pipipi/DPiPiPi_NTuple.root");
TTree *oldtree = (TTree*)oldfile->Get("subTree");
Double_t nEntries = oldtree->GetEntries();
TFile *newfile = new TFile("dataForPhiFit.root", "recreate");
TTree *newtree = oldtree->CloneTree(0);
Float_t M_12_MuMu;
oldtree->SetBranchAddress("M_12_MuMu", &M_12_MuMu);
for (Int_t i = 0; i < 100000000; i++)
{
oldtree->GetEntry(i);
if (abs(M_12_MuMu - 1020) < 100)
{
newtree->Fill();
}
}
newtree->AutoSave();
delete oldfile;
delete newfile;
}
//*************************************************************************************************
//Main part of the macro
//*************************************************************************************************
void NormalizeHwwNtuple(const string InputFilename, const string datasetName,
const string OutputFilename, const int nsel) {
TTree* HwwTree = getTreeFromFile(InputFilename.c_str(),nsel);
assert(HwwTree);
MitNtupleEvent event(HwwTree);
Double_t normalizationWeight = getNormalizationWeight(InputFilename, datasetName);
//*************************************************************************************************
//Create new normalized tree
//*************************************************************************************************
TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE");
outputFile->cd();
TTree *normalizedTree = HwwTree->CloneTree(0);
cout << "Events in the ntuple: " << HwwTree->GetEntries() << endl;
for (int n=0; n<HwwTree->GetEntries(); n++) {
event.GetEntry(n);
event.H_weight = event.H_weight * normalizationWeight;
normalizedTree->Fill();
}
normalizedTree->Write();
outputFile->Close();
}
void make_example_cfa(TString file){
TFile fin(file);
fin.cd("cfA");
TTree *eventA = (TTree*)gDirectory->Get("eventA");
TTree *eventB = (TTree*)gDirectory->Get("eventB");
TTree *eA(eventA->CloneTree(0));
TTree *eB(eventB->CloneTree(0));
TString outname="cfa_one.root";
TFile fout(outname, "RECREATE");
fout.mkdir("cfA");
fout.cd("cfA");
eA->Write();
eB->Write();
fout.Close();
cout<<endl<<"Written "<<outname<<" with the tree structure of the cfA file."<<endl<<endl;
}
void donewfile(){
if (newtree){
newtree->Print();
newtree->AutoSave();
newfile->Close();
}
counter_files++;
thisentries = 0;
newfile = new TFile(Form("splitted_%d.root",counter_files),"recreate");
newfile->cd();
newtree = oldtree->CloneTree(0);
}
void clonefile(const char *filename = defaultname)
{
TString copyname("copy-");
copyname.Append(filename);
TFile f(filename);
TTree *in; f.GetObject("tree",in);
TFile copy(copyname,"RECREATE");
in->CloneTree(-1,"fast");
copy.Write();
}
void CommonFiducialSkim() {
// Example of Root macro to copy a subset of a Tree to a new Tree
//gSystem->Load("$ROOTSYS/test/libEvent");
//Get old file, old tree and set top branch address
TFile *origFile = new TFile(origFileLoc.c_str());
TTree *origTree = (TTree*)origFile->Get(origTreeLoc.c_str());
//Event *event = new Event();
//origTree->SetBranchAddress("event",&event);
vector<float>* L1Muon_Etas;
origTree->SetBranchAddress("L1Muon_Etas", &L1Muon_Etas);
origTree->SetBranchStatus("*",0); //Disables All Branches
//Then enables only select branches
origTree->SetBranchStatus("Generator_Weights",1);
origTree->SetBranchStatus("L1Muon_Etas",1);
origTree->SetBranchStatus("L1Muon_Phis",1);
origTree->SetBranchStatus("L1Muon_Pts",1);
origTree->SetBranchStatus("HOReco_Etas",1);
origTree->SetBranchStatus("HOReco_Phis",1);
origTree->SetBranchStatus("HOReco_Energies",1);
origTree->SetBranchStatus("hltMu5PropToRPC1_Etas",1);
origTree->SetBranchStatus("hltMu5PropToRPC1_Phis",1);
origTree->SetBranchStatus("hltMu5PropToRPC1_Pts",1);
//origTree->SetBranchStatus("fH",1);
//Create a new file + a clone of old tree in new file
TFile *skimFile = new TFile("/data/users/cranelli/HOL1Muon/Trees/"
"Version_5_1/Skim_HOMuonTreee_Test.root",
"RECREATE");
TTree *skimTree = origTree->CloneTree(0);
Long64_t nentries = origTree->GetEntries();
for (Long64_t i=0;i<nentries; i++) {
if(i%1000==0) std::cout << i << std::endl;
origTree->GetEntry(i);
// Select Only Events with a L1Muon inside the barrel.
bool keepEvent = false;
for(unsigned int l1MuonB_index = 0; l1MuonB_index < L1Muon_Etas->size(); l1MuonB_index++){
if(fabs(L1Muon_Etas->at(l1MuonB_index)) < loose_barrel_eta) keepEvent = true;
}
if (keepEvent) skimTree->Fill();
L1Muon_Etas->clear();
}
skimTree->Print();
skimFile->Write();
//delete oldfile;
//delete newfile;
}
void weightBkgMC(TString inputFileName,TString outputFileName,float weight,TString treeName="SusyHggTree") {
float inw,outw;
bool isSherpa = (inputFileName.Index("DiPhotonJetsBox_M60_8TeV-sherpa") != -1);
int Nj;
TFile inputFile(inputFileName);
TTree* inputTree = (TTree*)inputFile.Get(treeName);
TFile outputFile(outputFileName,"RECREATE");
TTree* outputTree = inputTree->CloneTree(0);
inputTree->SetBranchAddress("pileupWeight",&inw);
inputTree->SetBranchAddress("Njets",&Nj);
outputTree->SetBranchAddress("pileupWeight",&outw);
Long64_t iEntry=-1;
if(isSherpa) {
double wSum=0;
double entries=0;
while(inputTree->GetEntry(++iEntry)) {
wSum+=getSherpaWeight(Nj);
entries++;
}
weight = weight*entries/wSum;
std::cout << "sherpa: sum of weights: " << wSum << " total entries: " << entries << std::endl;
}
iEntry=-1;
while(inputTree->GetEntry(++iEntry)) {
outw = inw*weight;
if(isSherpa) outw*=getSherpaWeight(Nj);
outputTree->Fill();
}
outputFile.cd();
outputTree->Write();
outputFile.Close();
inputFile.Close();
}
void addMCWeight(TString filename, TString treename)
{
using namespace std;
cout << "adding MCWeight to:"<< filename << endl;
double scale_w;
float mcWeight;
int npv;
TFile *file = new TFile(filename,"UPDATE");
TTree *oldtree = (TTree*)file->Get(treename);
if(oldtree==NULL)
{
cout << "Could not find tree " << treeDir << "/" << treename << endl
<< "in file " << file->GetName() << endl;
return;
}
oldtree->SetBranchAddress("scale_w",&scale_w);
oldtree->SetBranchAddress("mcWeight",&mcWeight);
oldtree->SetBranchAddress("npv",&npv);
double scaleMC_w = 1.0;
TBranch *branch = oldtree->Branch("scaleMC_w",&scaleMC_w,"scaleMC_w/D");
for(int i = 0; i < oldtree->GetEntries(); i++)
{
oldtree->GetEntry(i);
double w_npv = (3.57041 + -1.49846*npv + 0.515829*npv*npv + -0.0839209*npv*npv*npv + 0.00719964*npv*npv*npv*npv + -0.000354548*npv*npv*npv*npv*npv + 1.01544e-05*npv*npv*npv*npv*npv*npv + -1.58019e-07*npv*npv*npv*npv*npv*npv*npv + 1.03663e-09*npv*npv*npv*npv*npv*npv*npv*npv);
scaleMC_w = scale_w*mcWeight*w_npv;
branch->Fill();
}
file->cd();
oldtree->CloneTree()->Write(treename, TObject::kOverwrite);
file->Close();
}
void addMCWeight_data(TString filename, TString treename)
{
using namespace std;
cout << "Data adding MCWeight to:"<< filename << endl;
double scale_w;
float mcWeight;
TFile *file = new TFile(filename,"UPDATE");
TTree *oldtree = (TTree*)file->Get(treename);
if(oldtree==NULL)
{
cout << "Could not find tree " << treeDir << "/" << treename << endl
<< "in file " << file->GetName() << endl;
return;
}
oldtree->SetBranchAddress("scale_w",&scale_w);
oldtree->SetBranchAddress("mcWeight",&mcWeight);
double scaleMC_w = 1.0;
TBranch *branch = oldtree->Branch("scaleMC_w",&scaleMC_w,"scaleMC_w/D");
for(int i = 0; i < oldtree->GetEntries(); i++)
{
oldtree->GetEntry(i);
scaleMC_w = scale_w*mcWeight;
branch->Fill();
}
file->cd();
oldtree->CloneTree()->Write(treename, TObject::kOverwrite);
file->Close();
}
void applypvalue(std::string iName="BDTOutput.root") {
TFile *lFile = new TFile(iName.c_str());
TTree *lTree = (TTree*) lFile->FindObjectAny("Result");
fMVA = 0;
lTree->SetBranchAddress("bdt" ,&fMVA);
fPFType = 0;
lTree->SetBranchAddress("pftype",&fPFType);
fGenPt = 0;
lTree->SetBranchAddress("genpt" ,&fGenPt);
fPt = 0;
lTree->SetBranchAddress("pt" ,&fPt);
float *lMean = new float[6];
float *lRMS = new float[6];
computeMeanRMS(lMean,lRMS,lTree);
TFile *lOFile = new TFile("Output.root","RECREATE");
TTree *lOTree = (TTree*) lTree->CloneTree(0);
float lChi2PV = 0;
lOTree->Branch("chi2pv",&lChi2PV,"lChi2PV/F");
float lChi2PU = 0;
lOTree->Branch("chi2pu",&lChi2PU,"lChi2PU/F");
float lProb = 0;
lOTree->Branch("prob" ,&lProb ,"lProb/F" );
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
lChi2PV = chi2(0,lMean,lRMS);
lChi2PU = chi2(1,lMean,lRMS);
float pP1 = TMath::Prob(lChi2PV,1.);
float pP2 = TMath::Prob(lChi2PU,1.);
lProb = pP1*(1-pP2);
lProb *= 2.;
if(lProb > 1) lProb = 1;
//if(fPFType == 1) std::cout << " --> " << lChi2PV << " -- " << pP1 << " -- " << lChi2PU << " -- " << pP2 << " -- " << -2*log(pP1/pP2) << " -- " << lProb << std::endl;
if(fPFType > 5) {
lProb = 1;
}
lOTree->Fill();
}
lOTree->Write();
}
void ExtractEventNums(std::string inFileName, std::string outFileName)
{
std::cout << "Copying from tree: " << inFileName << std::endl;
std::cout << "Writing to: " << outFileName << std::endl;
TFile inFile(inFileName.c_str(), "READ");
TTree* inTree = static_cast<TTree*>(inFile.Get("bdttree"));
inTree->SetBranchStatus("*", 0);
inTree->SetBranchStatus("Run", 1);
inTree->SetBranchStatus("Event", 1);
inTree->SetBranchStatus("LumiSec", 1);
TFile outFile(outFileName.c_str(), "RECREATE");
TTree* outTree = static_cast<TTree*>(inTree->CloneTree());
outTree->Print();
outTree->Write();
//outFile.Write();
return;
}
int reader_wrapper::initFormulas(TString targetbranch) {
/// don't care about spectators here
// TODO: does this tree get created in the outfile?
m_intree->SetBranchStatus("*",1);
m_outtree = m_intree->CloneTree(-1,"fast");
int buffer(0);
for (auto& var : m_variables) {
var.ttreeformula = new TTreeFormula(Form("local_var_%d",buffer++),var.formula,m_outtree);
for (size_t v = 0 ; v < var.ttreeformula->GetNcodes() ; ++v) {
m_branches.insert(var.ttreeformula->GetLeaf(v)->GetBranch());
}
}
m_outtree->SetBranchStatus("*",0);
for (auto b : m_branches) {
b->SetStatus(1);
}
// check if output branch exists already
if (nullptr == m_outtree->GetBranch(targetbranch.Data())) {
m_responseBranch = m_outtree->Branch(targetbranch.Data(),&m_response,(targetbranch + "/F").Data());
return 0;
}
std::cout << "Output branch exists already. Aborting." << std::endl;
return 4;
}
void cloneAODTreeAndRemoveObject(const char *newFileName = "AliAOD_new.root", const char *orgFileName = "AliAOD.root") {
// This little macro takes an already created AOD file and clones it.
// After removing an old brach, the new TTree is written to a new file.
// open input file and get the TTree
TFile orgFile(orgFileName, "READ");
// get original TTree
TTree *orgAodTree = (TTree*)orgFile.Get("aodTree");
// switch off one branch (and its subbranches!)
orgAodTree->SetBranchStatus("tracks*", 0);
// open new output file
TFile *newFile = new TFile(newFileName, "RECREATE");
// clone old TTree (only clones branches that are switched on)
TTree *newAodTree = orgAodTree->CloneTree();
// get the event within the new TTree
AliAODEvent *evNew = new AliAODEvent();
evNew->ReadFromTree(newAodTree);
// remove TObject from the list
evNew->RemoveObject(evNew->GetTracks());
// delete old and write new UserInfo
newAodTree->GetUserInfo()->Clear();
newAodTree->GetUserInfo()->Add(evNew);
// write new TTree to file
newAodTree->Write();
// close files
newFile->Close();
delete newFile;
orgFile.Close();
}
void inflateTree(const char *name = "h42",
const char *in = "root://eospps.cern.ch///eos/ppsscratch/test/h1big.root",
const char *out = "/tmp/h1big.root", Int_t fact = 1)
{
TStopwatch sw;
sw.Start();
// Get the input tree from the input file
TFile *fin = TFile::Open(in);
if (!fin || fin->IsZombie()) {
Printf("inflateTree", "could not open input file: %s", in);
return;
}
TTree *tin = (TTree *) fin->Get(name);
if (!tin) {
Printf("inflateTree", "could not find tree '%s' in %s", name, in);
delete fin;
return;
}
Long64_t nin = tin->GetEntriesFast();
Printf("Input tree '%s' has %lld entries", name, nin);
// Create output file
TFile *fout = TFile::Open(out, "RECREATE", 0, 1);
if (!fout || fout->IsZombie()) {
Printf("inflateTree", "could not open input file: %s", in);
delete fin;
return;
}
// Clone the header of the initial tree
TTree *tout= (TTree *) tin->CloneTree(0);
tout->SetMaxTreeSize(19000000000);
// Duplicate all entries once
#if 0
Int_t nc = fact;
while (nc--) {
Printf("Writing copy %d ...", fact - nc);
tout->CopyEntries(tin);
}
#else
for (Long64_t i = 0; i < nin; ++i) {
if (tin->LoadTree(i) < 0) {
break;
}
tin->GetEntry(i);
Int_t nc = fact;
while (nc--) {
tout->Fill();
}
if (i > 0 && !(i%1000)) {
Printf("%d copies of %lld entries filled ...", fact, i);
}
}
#endif
// Finalize the writing out
tout->Write();
// print perf stats
sw.Stop();
std::cout << "Drawing. Realtime: " << sw.RealTime() << std::endl;
std::cout << "Drawing. Cputime : " << sw.CpuTime() << std::endl;
tin->PrintCacheStats();
// Close the files
fout->Close();
fin->Close();
// Cleanup
delete fout;
delete fin;
}
void TMVAClassificationApplication_TX(TString myMethodList = "" , TString iFileName = "", TString sampleLocation = "", TString outputLocation = "")
{
#ifdef __CINT__
gROOT->ProcessLine( ".O0" ); // turn off optimization in CINT
#endif
//---------------------------------------------------------------
// This loads the library
TMVA::Tools::Instance();
// Default MVA methods to be trained + tested
std::map<std::string,int> Use;
// --- Cut optimisation
Use["Cuts"] = 0;
Use["CutsD"] = 0;
Use["CutsPCA"] = 0;
Use["CutsGA"] = 0;
Use["CutsSA"] = 0;
//
//
// --- Boosted Decision Trees
Use["BDT"] = 1; // uses Adaptive Boost
std::cout << std::endl;
std::cout << "==> Start TMVAClassificationApplication" << std::endl;
// Select methods (don't look at this code - not of interest)
if (myMethodList != "") {
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;
std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' );
for (UInt_t i=0; i<mlist.size(); i++) {
std::string regMethod(mlist[i]);
if (Use.find(regMethod) == Use.end()) {
std::cout << "Method \"" << regMethod
<< "\" not known in TMVA under this name. Choose among the following:" << std::endl;
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {
std::cout << it->first << " ";
}
std::cout << std::endl;
return;
}
Use[regMethod] = 1;
}
}
// --------------------------------------------------------------------------------------------------
// --- Create the Reader object
TMVA::Reader *reader = new TMVA::Reader("!Color:!Silent" );
// Create a set of variables and declare them to the reader
// - the variable names MUST corresponds in name and type to those given in the weight file(s) used
Float_t var1, var2, var3, var4, var5, var6, var7, var8, var9, var10, var11, var12, var13, var14, var15, var16, var17, var18, var19, var20, var21, var22, var23, var24, var25, var26, var27, var28, var29;
//reader->AddVariable( "Alt$(jet_pt_singleLepCalc[0],0)", &var1);
//reader->AddVariable( "Alt$(jet_pt_singleLepCalc[1],0)", &var2 );
//reader->AddVariable( "Alt$(jet_pt_singleLepCalc[2],0)", &var3 );
reader->AddVariable( "Alt$(bJetPt_CATopoCalc[0],0)", &var4 );
reader->AddVariable( "Alt$(bJetPt_CATopoCalc[1],0)", &var5 );
//reader->AddVariable( "corr_met_singleLepCalc", &var6 );
//reader->AddVariable( "muon_1_pt_singleLepCalc", &var7 );
//reader->AddVariable( "nBJets_CATopoCalc", &var8 );
//reader->AddVariable( "nSelJets_CommonCalc", &var9 );
//reader->AddVariable( "LeptonJet_DeltaR_LjetsTopoCalcNew", &var10);
reader->AddVariable( "Mevent_LjetsTopoCalcNew", &var11);
//reader->AddVariable( "W_Pt_LjetsTopoCalcNew", &var12 );
reader->AddVariable( "Jet1Jet2_Pt_LjetsTopoCalcNew", &var13 );
//reader->AddVariable( "BestTop_LjetsTopoCalcNew", &var14 );
//reader->AddVariable( "BTagTopMass_LjetsTopoCalcNew", &var15 );
//reader->AddVariable( "Alt$(CAHEPTopJetMass_JetSubCalc[0],0)", &var16 );
//reader->AddVariable( "Alt$(CAWCSVMSubJets_JetSubCalc[0],0)", &var17 );
//reader->AddVariable( "Alt$(CAWCSVLSubJets_JetSubCalc[0],0)", &var18 );
reader->AddVariable( "Alt$(CAWJetPt_JetSubCalc[0],0)", &var19 );
reader->AddVariable( "Alt$(CAWJetMass_JetSubCalc[0],0)", &var20 );
//reader->AddVariable( "Alt$(CAHEPTopJetMass_JetSubCalc[1],0)", &var21 );
//reader->AddVariable( "Hz_LjetsTopoCalcNew", &var22 );
//reader->AddVariable( "Centrality_LjetsTopoCalcNew", &var23 );
reader->AddVariable( "SqrtsT_LjetsTopoCalcNew", &var24 );
reader->AddVariable( "CAMindrBMass_CATopoCalc", &var28 );
reader->AddVariable( "minDRCAtoB_CATopoCalc", &var29 );
//reader->AddVariable( "HT2prime_LjetsTopoCalcNew", &var25 );
reader->AddVariable( "HT2_LjetsTopoCalcNew", &var26 );
//reader->AddVariable( "dphiLepMet_LjetsTopoCalcNew", &var27 );
// Spectator variables declared in the training have to be added to the reader, too
// Float_t spec1,spec2;
// reader->AddSpectator( "spec1 := var1*2", &spec1 );
// reader->AddSpectator( "spec2 := var1*3", &spec2 );
// Float_t Category_cat1, Category_cat2, Category_cat3;
// if (Use["Category"]){
// // Add artificial spectators for distinguishing categories
// reader->AddSpectator( "Category_cat1 := var3<=0", &Category_cat1 );
// reader->AddSpectator( "Category_cat2 := (var3>0)&&(var4<0)", &Category_cat2 );
// reader->AddSpectator( "Category_cat3 := (var3>0)&&(var4>=0)", &Category_cat3 );
// }
// --- Book the MVA methods
// Book method(s)
TString weightFileName = "weights/TMVAClassification_BDT.weights";
reader->BookMVA("BDT method", weightFileName+".xml" );
// Book output histograms
UInt_t nbin = 100;
TH1F *histBdt(0);
histBdt = new TH1F( "MVA_BDT_TX", "MVA_BDT_TX", nbin, -1.0, 1.0);
// Prepare input tree (this must be replaced by your data source)
// in this example, there is a toy tree with signal and one with background events
// we'll later on use only the "signal" events for the test in this example.
//
TFile *input(0);
TString fileName = iFileName;
TString fname = sampleLocation+"/";
fname += fileName;
TString oFileName = fileName;
if (!gSystem->AccessPathName( fname ))
input = TFile::Open( fname ); // check if file in local directory exists
if (!input) {
std::cout << "ERROR: could not open data file" << std::endl;
exit(1);
}
std::cout << "--- TMVAClassificationApp : Using input file: " << input->GetName() << std::endl;
// --- Event loop
// Prepare the event tree
// - here the variable names have to corresponds to your tree
// - you can use the same variables as above which is slightly faster,
// but of course you can use different ones and copy the values inside the event loop
//
std::cout << "--- Select signal sample" << std::endl;
TTree* theTree = (TTree*)input->Get("ljmet");
gSystem->mkdir( outputLocation );
TFile *target = new TFile( outputLocation+"/"+oFileName,"RECREATE" );
TTree *newTree = theTree->CloneTree();
Float_t BDT;
TBranch *branchBDT = newTree->Branch("__BDT_TX__",&BDT,"__BDT_TX__/F");
std::vector<Double_t> *vecVar1;
std::vector<Double_t> *vecVar4;
std::vector<Double_t> *vecVar16;
std::vector<Int_t> *vecVar17;
std::vector<Int_t> *vecVar18;
std::vector<Double_t> *vecVar19;
std::vector<Double_t> *vecVar20;
Int_t *intVar5, *intVar8, *intVar9;
Double_t *dVar2, *dVar3, *dVar6, *dVar7, *dVar10, *dVar11, *dVar12, *dVar13, *dVar14, *dVar15, *dVar22, *dVar23, *dVar24, dVar25, *dVar26, *dVar27, *dVar28, *dVar29;
theTree->SetBranchAddress( "jet_pt_singleLepCalc", &vecVar1);
theTree->SetBranchAddress( "bJetPt_CATopoCalc", &vecVar4 );
theTree->SetBranchAddress( "corr_met_singleLepCalc", &dVar6 );
theTree->SetBranchAddress( "muon_1_pt_singleLepCalc", &dVar7 );
theTree->SetBranchAddress( "nBJets_CATopoCalc", &intVar8 );
theTree->SetBranchAddress( "nSelJets_CommonCalc", &intVar9 );
theTree->SetBranchAddress( "LeptonJet_DeltaR_LjetsTopoCalcNew", &dVar10);
theTree->SetBranchAddress( "Mevent_LjetsTopoCalcNew", &dVar11);
theTree->SetBranchAddress( "W_Pt_LjetsTopoCalcNew", &dVar12 );
theTree->SetBranchAddress( "Jet1Jet2_Pt_LjetsTopoCalcNew", &dVar13 );
theTree->SetBranchAddress( "BestTop_LjetsTopoCalcNew", &dVar14 );
theTree->SetBranchAddress( "BTagTopMass_LjetsTopoCalcNew", &dVar15 );
theTree->SetBranchAddress( "CAHEPTopJetMass_JetSubCalc", &vecVar16 );
theTree->SetBranchAddress( "CAWCSVMSubJets_JetSubCalc", &vecVar17 );
theTree->SetBranchAddress( "CAWCSVLSubJets_JetSubCalc", &vecVar18 );
theTree->SetBranchAddress( "CAWJetPt_JetSubCalc", &vecVar19 );
theTree->SetBranchAddress( "CAWJetMass_JetSubCalc", &vecVar20 );
theTree->SetBranchAddress( "Hz_LjetsTopoCalcNew", &dVar22 );
theTree->SetBranchAddress( "Centrality_LjetsTopoCalcNew", &dVar23 );
theTree->SetBranchAddress( "SqrtsT_LjetsTopoCalcNew", &dVar24 );
theTree->SetBranchAddress( "HT2prime_LjetsTopoCalcNew", &dVar25 );
theTree->SetBranchAddress( "HT2_LjetsTopoCalcNew", &dVar26 );
theTree->SetBranchAddress( "dphiLepMet_LjetsTopoCalcNew", &dVar27 );
theTree->SetBranchAddress( "CAMindrBMass_CATopoCalc", &dVar28 );
theTree->SetBranchAddress( "minDRCAtoB_CATopoCalc", &dVar29 );
// Efficiency calculator for cut method
Int_t nSelCutsGA = 0;
Double_t effS = 0.7;
std::vector<Float_t> vecVar(4); // vector for EvaluateMVA tests
std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl;
TStopwatch sw;
sw.Start();
for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {
if (ievt%1000 == 0) std::cout << "--- ... Processing event: " << ievt << std::endl;
theTree->GetEntry(ievt);
if(vecVar1->size()>0){
var1 = vecVar1->at(0);
}
if(vecVar1->size()>1){
var2 = vecVar1->at(1);
}
if(vecVar1->size()>2){
var3 = vecVar1->at(2);
}
if(vecVar4->size()>0){
var4 = vecVar4->at(0);
}
if(vecVar4->size()>1){
var5 = vecVar4->at(1);
}
var6 = dVar6;
var7 = dVar7;
var8 = intVar8;
var9 = intVar9;
var10 = dVar10;
var11 = dVar11;
var12 = dVar12;
var13 = dVar13;
var14 = dVar14;
var15 = dVar15;
if(vecVar16->size()>0){
var16 = vecVar16->at(0);
}
else{
var16 = 0;
}
if(vecVar17->size()>0){
var17 = vecVar17->at(0);
}
else{
var18 = 0;
}
if(vecVar19->size()>0){
var19 = vecVar19->at(0);
}
else{
var19 = 0;
}
if(vecVar20->size()>0){
var20 = vecVar20->at(0);
}
else{
var20 = 0;
}
if(vecVar16->size()>1){
var21 = vecVar16->at(1);
}
else{
var21 = 0;
}
var22 = dVar22;
var23 = dVar23;
var24 = dVar24;
var25 = dVar25;
var26 = dVar26;
var27 = dVar27;
var28 = dVar28;
var29 = dVar29; // --- Return the MVA outputs and fill into histograms
if (Use["CutsGA"]) {
// Cuts is a special case: give the desired signal efficienciy
Bool_t passed = reader->EvaluateMVA( "CutsGA method", effS );
if (passed) nSelCutsGA++;
}
BDT = reader->EvaluateMVA( "BDT method");
histBdt->Fill(BDT);
branchBDT->Fill();
}
// Get elapsed time
sw.Stop();
std::cout << "--- End of event loop: "; sw.Print();
// Get efficiency for cuts classifier
if (Use["CutsGA"]) std::cout << "--- Efficiency for CutsGA method: " << double(nSelCutsGA)/theTree->GetEntries()
<< " (for a required signal efficiency of " << effS << ")" << std::endl;
if (Use["CutsGA"]) {
// test: retrieve cuts for particular signal efficiency
// CINT ignores dynamic_casts so we have to use a cuts-secific Reader function to acces the pointer
TMVA::MethodCuts* mcuts = reader->FindCutsMVA( "CutsGA method" ) ;
if (mcuts) {
std::vector<Double_t> cutsMin;
std::vector<Double_t> cutsMax;
mcuts->GetCuts( 0.7, cutsMin, cutsMax );
std::cout << "--- -------------------------------------------------------------" << std::endl;
std::cout << "--- Retrieve cut values for signal efficiency of 0.7 from Reader" << std::endl;
for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
std::cout << "... Cut: "
<< cutsMin[ivar]
<< " < \""
<< mcuts->GetInputVar(ivar)
<< "\" <= "
<< cutsMax[ivar] << std::endl;
}
std::cout << "--- -------------------------------------------------------------" << std::endl;
}
}
// --- Write histograms
newTree->Write("",TObject::kOverwrite);
target->Close();
std::cout << "--- Created root file: \""<<oFileName<<"\" containing the MVA output histograms" << std::endl;
delete reader;
std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl;
}
void DoSimple1()
{
// gROOT->ProcessLine(".L AdScaled.C+");
ifstream runlist;
runlist.open("recon.list");
string run;
while( getline(runlist,run) )
{
cout<<"Now is processing "<<TString(run)<<endl;
TFile *oldfile = new TFile(TString(run));
TTree *oldtree = (TTree*)oldfile->Get("/Event/Rec/AdScaled");
oldtree->SetBranchStatus("*",0);
oldtree->SetBranchStatus("site", 1);
oldtree->SetBranchStatus("detector",1);
oldtree->SetBranchStatus("triggerType",1);
oldtree->SetBranchStatus("triggerNumber",1);
oldtree->SetBranchStatus("triggerTimeSec",1);
oldtree->SetBranchStatus("triggerTimeNanoSec",1);
oldtree->SetBranchStatus("energy",1);
oldtree->SetBranchStatus("rawEvis",1);
oldtree->SetBranchStatus("enrec",1);
oldtree->SetBranchStatus("eprec",1);
oldtree->SetBranchStatus("x",1);
oldtree->SetBranchStatus("y",1);
oldtree->SetBranchStatus("z",1);
TTree *oldtree1 = (TTree*)oldfile->Get("/Event/Data/CalibStats");
oldtree1->SetBranchStatus("*",0);
oldtree1->SetBranchStatus("nHit", 1);
oldtree1->SetBranchStatus("MaxQ",1);
oldtree1->SetBranchStatus("Quadrant",1);
oldtree1->SetBranchStatus("MaxQ_2inchPMT",1);
oldtree1->SetBranchStatus("Column_2inchPMT",1);
oldtree1->SetBranchStatus("MiddleTimeRMS",1);
oldtree1->SetBranchStatus("tRMS",1);
oldtree1->SetBranchStatus("nPEMax",1);
oldtree1->SetBranchStatus("nPEMedian",1);
oldtree1->SetBranchStatus("nPERMS",1);
oldtree1->SetBranchStatus("nPESum",1);
TTree *oldtree2 = (TTree*)oldfile->Get("/Event/CalibReadout/CalibReadoutHeader");
oldtree2->SetBranchStatus("*",0);
oldtree2->SetBranchStatus("nHitsRpc", 1);
oldtree2->SetBranchStatus("rpcRow", 1);
oldtree2->SetBranchStatus("rpcColumn", 1);
oldtree2->SetBranchStatus("rpcLayer", 1);
TFile *newfile = new TFile("small.root","recreate");
gDirectory->mkdir("Event");
gDirectory->cd("Event");
gDirectory->mkdir("Rec");
gDirectory->mkdir("Data");
gDirectory->mkdir("CalibReadout");
gDirectory->cd("Rec");
TTree *newtree = oldtree->CloneTree();
gDirectory->cd("../Data");
TTree *newtree1 = oldtree1->CloneTree();
gDirectory->cd("../CalibReadout");
TTree *newtree2 = oldtree2->CloneTree();
newfile->Write();
delete oldfile;
delete newfile;
}
}
int loop(TString infile="/store/group/phys_heavyions/velicanu/forest/Run2015E/ExpressPhysics/Merged/HiForestExpress_baobab.root",
TString outfile="/data/wangj/Data2015/Bntuple/ntB_20151130_HiForestExpress_baobab.root", Bool_t REAL=true, Bool_t isPbPb=false, Int_t startEntries=0, Bool_t skim=false, Bool_t gskim=true, Bool_t checkMatching=false)
{
void fillTree(TVector3* bP, TVector3* bVtx, TLorentzVector* b4P, Int_t j, Int_t typesize, Double_t track_mass1, Double_t track_mass2, Bool_t REAL);
bool signalGen(Int_t Btype, Int_t j);
cout<<endl;
if(REAL) cout<<"--- Processing - REAL DATA"<<endl;
else cout<<"--- Processing - MC"<<endl;
TString ifname;
if(iseos) ifname = Form("root://eoscms.cern.ch//eos/cms%s",infile.Data());
else ifname = infile;
TFile* f = TFile::Open(ifname);
TTree* root = (TTree*)f->Get("Bfinder/root");
TTree* hltroot = (TTree*)f->Get("hltanalysis/HltTree");
TTree* hiroot = (TTree*)f->Get("hiEvtAnalyzer/HiTree");
TFile* outf = new TFile(outfile,"recreate");
setBBranch(root);
setHltBranch(hltroot);
if(isPbPb) setHiTreeBranch(hiroot);
int ifchannel[7];
ifchannel[0] = 1; //jpsi+Kp
ifchannel[1] = 1; //jpsi+pi
ifchannel[2] = 1; //jpsi+Ks(pi+,pi-)
ifchannel[3] = 1; //jpsi+K*(K+,pi-)
ifchannel[4] = 1; //jpsi+K*(K-,pi+)
ifchannel[5] = 1; //jpsi+phi(K+,K-)
ifchannel[6] = 1; //jpsi+pi pi <= psi', X(3872), Bs->J/psi f0
cout<<"--- Building trees"<<endl;
TTree* nt0 = new TTree("ntKp",""); buildBranch(nt0);
TTree* nt1 = new TTree("ntpi",""); buildBranch(nt1);
TTree* nt2 = new TTree("ntKs",""); buildBranch(nt2);
TTree* nt3 = new TTree("ntKstar",""); buildBranch(nt3);
TTree* nt5 = new TTree("ntphi",""); buildBranch(nt5);
TTree* nt6 = new TTree("ntmix",""); buildBranch(nt6);
TTree* ntGen = new TTree("ntGen",""); buildGenBranch(ntGen);
TTree* ntHlt = hltroot->CloneTree(0);
TTree* ntHi = hiroot->CloneTree(0);
cout<<"--- Building trees finished"<<endl;
Long64_t nentries = root->GetEntries();
TVector3* bP = new TVector3;
TVector3* bVtx = new TVector3;
TLorentzVector* b4P = new TLorentzVector;
TLorentzVector* b4Pout = new TLorentzVector;
TLorentzVector* bGen = new TLorentzVector;
cout<<"--- Check the number of events for two trees"<<endl;
cout<<root->GetEntries()<<" "<<hltroot->GetEntries();
if(isPbPb) cout<<" "<<hiroot->GetEntries();
cout<<endl;
cout<<"--- Processing events"<<endl;
//nentries=1000;
for(Int_t i=startEntries;i<nentries;i++)
{
root->GetEntry(i);
hltroot->GetEntry(i);
if(isPbPb) hiroot->GetEntry(i);
if(i%100000==0) cout<<setw(8)<<i<<" / "<<nentries<<endl;
if(checkMatching)
{
if((Int_t)Bf_HLT_Event!=EvtInfo_EvtNo||Bf_HLT_Run!=EvtInfo_RunNo||Bf_HLT_LumiBlock!=EvtInfo_LumiNo || (isPbPb&&(Bf_HiTree_Evt!=EvtInfo_EvtNo||Bf_HiTree_Run!=EvtInfo_RunNo||Bf_HiTree_Lumi!=EvtInfo_LumiNo)))
{
cout<<"Error: not matched "<<i<<" | ";
cout<<"EvtNo("<<Bf_HLT_Event<<","<<EvtInfo_EvtNo<<") RunNo("<<Bf_HLT_Run<<","<<EvtInfo_RunNo<<") LumiNo("<<Bf_HLT_LumiBlock<<","<<EvtInfo_LumiNo<<") | EvtNo("<<Bf_HiTree_Evt<<","<<EvtInfo_EvtNo<<") RunNo("<<Bf_HiTree_Run<<","<<EvtInfo_RunNo<<") LumiNo("<<Bf_HiTree_Lumi<<","<<EvtInfo_LumiNo<<")"<<endl;
continue;
}
}
Int_t Btypesize[7]={0,0,0,0,0,0,0};
Int_t ptflag=-1,ptMatchedflag=-1,probflag=-1,probMatchedflag=-1,tktkflag=-1,tktkMatchedflag=-1;
Double_t pttem=0,ptMatchedtem=0,probtem=0,probMatchedtem=0,tktktem=0,tktkMatchedtem=0;
for(Int_t t=0;t<7;t++)
{
Int_t tidx = t-1;
if(t!=4)
{
tidx = t;
Bsize = 0;
ptflag = -1;
pttem = 0;
ptMatchedflag = -1;
ptMatchedtem = 0;
probflag = -1;
probtem = 0;
probMatchedflag = -1;
probMatchedtem = 0;
tktkflag = -1;
tktktem = 1000000.;
tktkMatchedflag = -1;
tktkMatchedtem = 1000000.;
}
if(ifchannel[t]==1)
{
for(int j=0;j<BInfo_size;j++)
{
if(BInfo_type[j]==(t+1))
{
fillTree(bP,bVtx,b4P,j,Btypesize[tidx],tk1mass[t],tk2mass[t],REAL);
if(BInfo_pt[j]>pttem)
{
ptflag = Btypesize[tidx];
pttem = BInfo_pt[j];
}
if(TMath::Prob(BInfo_vtxchi2[j],BInfo_vtxdof[j])>probtem)
{
probflag = Btypesize[tidx];
probtem = TMath::Prob(BInfo_vtxchi2[j],BInfo_vtxdof[j]);
}
if(BInfo_type[j]>2&&BInfo_type[j]<7)
{
if(TMath::Abs(BInfo_tktk_mass[j]-midmass[t])<tktktem)
{
tktkflag = Btypesize[tidx];
tktktem = TMath::Abs(BInfo_tktk_mass[j]-midmass[t]);
}
}
if((!REAL&&(Bgen[Btypesize[tidx]]==23333||Bgen[Btypesize[tidx]]==41000))||REAL)//////////////////////////////
{
if(BInfo_pt[j]>ptMatchedtem)
{
ptMatchedflag = Btypesize[tidx];
ptMatchedtem = BInfo_pt[j];
}
if(TMath::Prob(BInfo_vtxchi2[j],BInfo_vtxdof[j])>probMatchedtem)
{
probMatchedflag = Btypesize[tidx];
probMatchedtem = TMath::Prob(BInfo_vtxchi2[j],BInfo_vtxdof[j]);
}
if(BInfo_type[j]>2&&BInfo_type[j]<7)
{
if(TMath::Abs(BInfo_tktk_mass[j]-midmass[t])<tktkMatchedtem)
{
tktkMatchedflag = Btypesize[tidx];
tktkMatchedtem = TMath::Abs(BInfo_tktk_mass[j]-midmass[t]);
}
}
}
Btypesize[tidx]++;
}
}
if(t!=3)
{
if(ptflag>=0) Bmaxpt[ptflag] = true;
if(probflag>=0) Bmaxprob[probflag] = true;
if(tktkflag>=0) Bbesttktkmass[tktkflag] = true;
if(ptMatchedflag>=0) BmaxptMatched[ptMatchedflag] = true;
if(probMatchedflag>=0) BmaxprobMatched[probMatchedflag] = true;
if(tktkMatchedflag>=0) BbesttktkmassMatched[tktkMatchedflag] = true;
}
if(t==0) nt0->Fill();
else if(t==1) nt1->Fill();
else if(t==2) nt2->Fill();
else if(t==4) nt3->Fill();
else if(t==5) nt5->Fill();
else if(t==6) nt6->Fill();
}
}
ntHlt->Fill();
if(isPbPb) ntHi->Fill();
if(!REAL)
{
Int_t gt=0,sigtype=0;
Int_t gsize=0;
Gsize = 0;
for(int j=0;j<GenInfo_size;j++)
{
if((TMath::Abs(GenInfo_pdgId[j])!=BPLUS_PDGID&&TMath::Abs(GenInfo_pdgId[j])!=BZERO_PDGID&&TMath::Abs(GenInfo_pdgId[j])!=BSUBS_PDGID) && gskim) continue;
Gsize = gsize+1;
Gpt[gsize] = GenInfo_pt[j];
Geta[gsize] = GenInfo_eta[j];
Gphi[gsize] = GenInfo_phi[j];
GpdgId[gsize] = GenInfo_pdgId[j];
bGen->SetPtEtaPhiM(GenInfo_pt[j],GenInfo_eta[j],GenInfo_phi[j],GenInfo_mass[j]);
Gy[gsize] = bGen->Rapidity();
sigtype=0;
for(gt=1;gt<8;gt++)
{
if(signalGen(gt,j))
{
sigtype=gt;
break;
}
}
GisSignal[gsize] = sigtype;
Gmu1pt[gsize] = -1;
Gmu1eta[gsize] = -20;
Gmu1phi[gsize] = -20;
Gmu1p[gsize] = -1;
Gmu2pt[gsize] = -1;
Gmu2eta[gsize] = -20;
Gmu2phi[gsize] = -20;
Gmu2p[gsize] = -1;
Gtk1pt[gsize] = -1;
Gtk1eta[gsize] = -20;
Gtk1phi[gsize] = -20;
Gtk2pt[gsize] = -1;
Gtk2eta[gsize] = -20;
Gtk2phi[gsize] = -20;
if(sigtype!=0)
{
Gmu1pt[gsize] = GenInfo_pt[GenInfo_da1[GenInfo_da1[j]]];
Gmu1eta[gsize] = GenInfo_eta[GenInfo_da1[GenInfo_da1[j]]];
Gmu1phi[gsize] = GenInfo_phi[GenInfo_da1[GenInfo_da1[j]]];
Gmu1p[gsize] = Gmu1pt[gsize]*cosh(Gmu1eta[gsize]);
Gmu2pt[gsize] = GenInfo_pt[GenInfo_da2[GenInfo_da1[j]]];
Gmu2eta[gsize] = GenInfo_eta[GenInfo_da2[GenInfo_da1[j]]];
Gmu2phi[gsize] = GenInfo_phi[GenInfo_da2[GenInfo_da1[j]]];
Gmu2p[gsize] = Gmu2pt[gsize]*cosh(Gmu2eta[gsize]);
if(sigtype==1||sigtype==2)
{
Gtk1pt[gsize] = GenInfo_pt[GenInfo_da2[j]];
Gtk1eta[gsize] = GenInfo_eta[GenInfo_da2[j]];
Gtk1phi[gsize] = GenInfo_phi[GenInfo_da2[j]];
}
else
{
Gtk1pt[gsize] = GenInfo_pt[GenInfo_da1[GenInfo_da2[j]]];
Gtk1eta[gsize] = GenInfo_eta[GenInfo_da1[GenInfo_da2[j]]];
Gtk1phi[gsize] = GenInfo_phi[GenInfo_da1[GenInfo_da2[j]]];
Gtk2pt[gsize] = GenInfo_pt[GenInfo_da2[GenInfo_da2[j]]];
Gtk2eta[gsize] = GenInfo_eta[GenInfo_da2[GenInfo_da2[j]]];
Gtk2phi[gsize] = GenInfo_phi[GenInfo_da2[GenInfo_da2[j]]];
}
}
gsize++;
}
ntGen->Fill();
}
}
outf->Write();
outf->Close();
return 1;
}
////////////////////////////////////////////////////////////////////////////////
/// Main ///
////////////////////////////////////////////////////////////////////////////////
void GrowTree(TString process, std::string regMethod="BDTG", Long64_t beginEntry=0, Long64_t endEntry=-1)
{
gROOT->SetBatch(1);
TH1::SetDefaultSumw2(1);
gROOT->LoadMacro("HelperFunctions.h"); //< make functions visible to TTreeFormula
if (!TString(gROOT->GetVersion()).Contains("5.34")) {
std::cout << "INCORRECT ROOT VERSION! Please use 5.34:" << std::endl;
std::cout << "source /uscmst1/prod/sw/cms/slc5_amd64_gcc462/lcg/root/5.34.02-cms/bin/thisroot.csh" << std::endl;
std::cout << "Return without doing anything." << std::endl;
return;
}
const TString indir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Phys14_PU20bx25/skimV11/";
const TString outdir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Phys14_PU20bx25/skimV11/step3/";
const TString prefix = "skim_";
const TString suffix = ".root";
TFile *input = TFile::Open(indir + prefix + process + suffix);
if (!input) {
std::cout << "ERROR: Could not open input file." << std::endl;
exit(1);
}
/// Make output directory if it doesn't exist
if (gSystem->AccessPathName(outdir))
gSystem->mkdir(outdir);
std::cout << "--- GrowTree : Using input file: " << input->GetName() << std::endl;
TTree *inTree = (TTree *) input->Get("tree");
TH1F *hcount = (TH1F *) input->Get("Count");
TFile *output(0);
if (beginEntry == 0 && endEntry == -1)
output = TFile::Open(outdir + "Step3_" + process + suffix, "RECREATE");
else
output = TFile::Open(outdir + "Step3_" + process + TString::Format("_%Li_%Li", beginEntry, endEntry) + suffix, "RECREATE");
TTree *outTree = inTree->CloneTree(0); // Do no copy the data yet
/// The clone should not delete any shared i/o buffers.
ResetDeleteBranches(outTree);
///-- Set branch addresses -------------------------------------------------
EventInfo EVENT;
double hJet_pt[MAXJ], hJet_eta[MAXJ], hJet_phi[MAXJ], hJet_m[MAXJ], hJet_ptRaw[MAXJ], hJet_genPt[MAXJ];
int hJCidx[2];
inTree->SetBranchStatus("*", 1);
inTree->SetBranchStatus("hJCidx",1);
inTree->SetBranchStatus("Jet_*",1);
inTree->SetBranchAddress("hJCidx", &hJCidx);
inTree->SetBranchAddress("Jet_pt", &hJet_pt);
inTree->SetBranchAddress("Jet_eta", &hJet_eta);
inTree->SetBranchAddress("Jet_phi", &hJet_phi);
inTree->SetBranchAddress("Jet_mass", &hJet_m);
inTree->SetBranchAddress("Jet_rawPt", &hJet_ptRaw);
inTree->SetBranchAddress("Jet_mcPt", &hJet_genPt);
///-- Make new branches ----------------------------------------------------
int EVENT_run, EVENT_event; // set these as TTree index?
float lumi_ = lumi, efflumi, efflumi_old,
efflumi_UEPS_up, efflumi_UEPS_down;
float hJet_ptReg[2];
float HptNorm, HptGen, HptReg;
float HmassNorm, HmassGen, HmassReg;
outTree->Branch("EVENT_run", &EVENT_run, "EVENT_run/I");
outTree->Branch("EVENT_event", &EVENT_event, "EVENT_event/I");
outTree->Branch("lumi", &lumi_, "lumi/F");
outTree->Branch("efflumi", &efflumi, "efflumi/F");
outTree->Branch("efflumi_old", &efflumi_old, "efflumi_old/F");
outTree->Branch("efflumi_UEPS_up", &efflumi_UEPS_up, "efflumi_UEPS_up/F");
outTree->Branch("efflumi_UEPS_down", &efflumi_UEPS_down, "efflumi_UEPS_down/F");
outTree->Branch("hJet_ptReg", &hJet_ptReg, "hJet_ptReg[2]/F");
outTree->Branch("HptNorm", &HptNorm, "HptNorm/F");
outTree->Branch("HptGen", &HptGen, "HptGen/F");
outTree->Branch("HptReg", &HptReg, "HptReg/F");
outTree->Branch("HmassNorm", &HmassNorm, "HmassNorm/F");
outTree->Branch("HmassGen", &HmassGen, "HmassGen/F");
outTree->Branch("HmassReg", &HmassReg, "HmassReg/F");
/// Get effective lumis
std::map < std::string, float > efflumis = GetLumis();
efflumi = efflumis[process.Data()];
assert(efflumi > 0);
efflumi_old = efflumi;
efflumi_UEPS_up = efflumi * hcount->GetBinContent(2) / hcount->GetBinContent(3);
efflumi_UEPS_down = efflumi * hcount->GetBinContent(2) / hcount->GetBinContent(4);
TTreeFormula* ttf_lheweight = new TTreeFormula("ttf_lheweight", Form("%f", efflumi), inTree);
#ifdef STITCH
std::map < std::string, std::string > lheweights = GetLHEWeights();
TString process_lhe = process;
if (process_lhe.BeginsWith("WJets") && process_lhe != "WJetsHW")
process_lhe = "WJets";
else if (process_lhe.BeginsWith("ZJets") && process_lhe != "ZJetsHW")
process_lhe = "ZJets";
else
process_lhe = "";
TString lheweight = lheweights[process_lhe.Data()];
if (lheweight != "") {
delete ttf_lheweight;
// Bug fix for ZJetsPtZ100
if (process == "ZJetsPtZ100")
lheweight.ReplaceAll("lheV_pt", "999");
std::cout << "BUGFIX: " << lheweight << std::endl;
ttf_lheweight = new TTreeFormula("ttf_lheweight", lheweight, inTree);
}
#endif
ttf_lheweight->SetQuickLoad(1);
// regression stuff here
///-- Setup TMVA Reader ----------------------------------------------------
TMVA::Tools::Instance(); //< This loads the library
TMVA::Reader * reader = new TMVA::Reader("!Color:!Silent");
/// Get the variables
const std::vector < std::string > & inputExpressionsReg = GetInputExpressionsReg();
const UInt_t nvars = inputExpressionsReg.size();
Float_t readerVars[nvars];
int idx_rawpt = -1, idx_pt = -1, idx_et = -1, idx_mt = -1;
for (UInt_t iexpr = 0; iexpr < nvars; iexpr++) {
const TString& expr = inputExpressionsReg.at(iexpr);
reader->AddVariable(expr, &readerVars[iexpr]);
if (expr.BeginsWith("breg_rawptJER := ")) idx_rawpt = iexpr;
else if (expr.BeginsWith("breg_pt := ")) idx_pt = iexpr;
else if (expr.BeginsWith("breg_et := ")) idx_et = iexpr;
else if (expr.BeginsWith("breg_mt := ")) idx_mt = iexpr;
}
// assert(idx_rawpt!=-1 && idx_pt!=-1 && idx_et!=-1 && idx_mt!=-1);
assert(idx_rawpt!=-1 && idx_pt!=-1 );
/// Setup TMVA regression inputs
const std::vector < std::string > & inputExpressionsReg0 = GetInputExpressionsReg0();
const std::vector < std::string > & inputExpressionsReg1 = GetInputExpressionsReg1();
assert(inputExpressionsReg0.size() == nvars);
assert(inputExpressionsReg1.size() == nvars);
/// Load TMVA weights
TString weightdir = "weights/";
TString weightfile = weightdir + "TMVARegression_" + regMethod + ".testweights.xml";
reader->BookMVA(regMethod + " method", weightfile);
TStopwatch sw;
sw.Start();
/// Create TTreeFormulas
TTreeFormula *ttf = 0;
std::vector < TTreeFormula * >::const_iterator formIt, formItEnd;
std::vector < TTreeFormula * > inputFormulasReg0;
std::vector < TTreeFormula * > inputFormulasReg1;
std::vector < TTreeFormula * > inputFormulasFJReg0;
std::vector < TTreeFormula * > inputFormulasFJReg1;
std::vector < TTreeFormula * > inputFormulasFJReg2;
for (UInt_t iexpr = 0; iexpr < nvars; iexpr++) {
ttf = new TTreeFormula(Form("ttfreg%i_0", iexpr), inputExpressionsReg0.at(iexpr).c_str(), inTree);
ttf->SetQuickLoad(1);
inputFormulasReg0.push_back(ttf);
ttf = new TTreeFormula(Form("ttfreg%i_1", iexpr), inputExpressionsReg1.at(iexpr).c_str(), inTree);
ttf->SetQuickLoad(1);
inputFormulasReg1.push_back(ttf);
}
///-- Loop over events -----------------------------------------------------
Int_t curTree = inTree->GetTreeNumber();
const Long64_t nentries = inTree->GetEntries();
if (endEntry < 0) endEntry = nentries;
Long64_t ievt = 0;
for (ievt=TMath::Max(ievt, beginEntry); ievt<TMath::Min(nentries, endEntry); ievt++) {
if (ievt % 2000 == 0)
std::cout << "--- ... Processing event: " << ievt << std::endl;
const Long64_t local_entry = inTree->LoadTree(ievt); // faster, but only for TTreeFormula
if (local_entry < 0) break;
inTree->GetEntry(ievt); // same event as received by LoadTree()
if (inTree->GetTreeNumber() != curTree) {
curTree = inTree->GetTreeNumber();
for (formIt=inputFormulasReg0.begin(), formItEnd=inputFormulasReg0.end(); formIt!=formItEnd; formIt++)
(*formIt)->UpdateFormulaLeaves(); // if using TChain
for (formIt=inputFormulasReg1.begin(), formItEnd=inputFormulasReg1.end(); formIt!=formItEnd; formIt++)
(*formIt)->UpdateFormulaLeaves(); // if using TChain
for (formIt=inputFormulasFJReg0.begin(), formItEnd=inputFormulasFJReg0.end(); formIt!=formItEnd; formIt++)
(*formIt)->UpdateFormulaLeaves(); // if using TChain
for (formIt=inputFormulasFJReg1.begin(), formItEnd=inputFormulasFJReg1.end(); formIt!=formItEnd; formIt++)
(*formIt)->UpdateFormulaLeaves(); // if using TChain
for (formIt=inputFormulasFJReg2.begin(), formItEnd=inputFormulasFJReg2.end(); formIt!=formItEnd; formIt++)
(*formIt)->UpdateFormulaLeaves(); // if using TChain
ttf_lheweight->UpdateFormulaLeaves();
}
/// These need to be called when arrays of variable size are used in TTree.
for (formIt=inputFormulasReg0.begin(), formItEnd=inputFormulasReg0.end(); formIt!=formItEnd; formIt++)
(*formIt)->GetNdata();
for (formIt=inputFormulasReg1.begin(), formItEnd=inputFormulasReg1.end(); formIt!=formItEnd; formIt++)
(*formIt)->GetNdata();
for (formIt=inputFormulasFJReg0.begin(), formItEnd=inputFormulasFJReg0.end(); formIt!=formItEnd; formIt++)
(*formIt)->GetNdata();
for (formIt=inputFormulasFJReg1.begin(), formItEnd=inputFormulasFJReg1.end(); formIt!=formItEnd; formIt++)
(*formIt)->GetNdata();
for (formIt=inputFormulasFJReg2.begin(), formItEnd=inputFormulasFJReg2.end(); formIt!=formItEnd; formIt++)
(*formIt)->GetNdata();
ttf_lheweight->GetNdata();
/// Fill branches
EVENT_run = EVENT.run;
EVENT_event = EVENT.event;
#ifdef STITCH
efflumi = ttf_lheweight->EvalInstance();
// efflumi_UEPS_up = efflumi * hcount->GetBinContent(2) / hcount->GetBinContent(3);
//efflumi_UEPS_down = efflumi * hcount->GetBinContent(2) / hcount->GetBinContent(4);
#endif
bool verbose = false;
for (Int_t ihj = 0; ihj < 2; ihj++) {
/// Evaluate TMVA regression output
for (UInt_t iexpr = 0; iexpr < nvars; iexpr++) {
if (ihj==0) {
readerVars[iexpr] = inputFormulasReg0.at(iexpr)->EvalInstance();
} else if (ihj==1) {
readerVars[iexpr] = inputFormulasReg1.at(iexpr)->EvalInstance();
}
}
hJet_ptReg[ihj] = (reader->EvaluateRegression(regMethod + " method"))[0];
if (verbose) std::cout << readerVars[idx_pt] << " " << readerVars[idx_rawpt] << " " << hJet_pt[ihj] << " " << hJet_ptReg[ihj] << " " << hJet_genPt[ihj] << std::endl;
const TLorentzVector p4Zero = TLorentzVector(0., 0., 0., 0.);
// int idx = hJCidx[0] ;
// std::cout << "the regressed pt for jet 0 is " << hJet_ptReg[0] << "; the hJCidx is " << hJCidx[0] << ", hence the origianl pt is " << hJet_pt[idx] << std::endl;
const TLorentzVector& hJet_p4Norm_0 = makePtEtaPhiM(hJet_pt[hJCidx[0]] , hJet_pt[hJCidx[0]], hJet_eta[hJCidx[0]], hJet_phi[hJCidx[0]], hJet_m[hJCidx[0]]);
const TLorentzVector& hJet_p4Norm_1 = makePtEtaPhiM(hJet_pt[hJCidx[1]] , hJet_pt[hJCidx[1]], hJet_eta[hJCidx[1]], hJet_phi[hJCidx[1]], hJet_m[hJCidx[1]]);
const TLorentzVector& hJet_p4Gen_0 = hJet_genPt[hJCidx[0]] > 0 ?
makePtEtaPhiM(hJet_genPt[hJCidx[0]] , hJet_pt[hJCidx[0]], hJet_eta[hJCidx[0]], hJet_phi[hJCidx[0]], hJet_m[hJCidx[0]]) : p4Zero;
const TLorentzVector& hJet_p4Gen_1 = hJet_genPt[hJCidx[1]] > 0 ?
makePtEtaPhiM(hJet_genPt[hJCidx[1]] , hJet_pt[hJCidx[1]], hJet_eta[hJCidx[1]], hJet_phi[hJCidx[1]], hJet_m[hJCidx[1]]) : p4Zero;
const TLorentzVector& hJet_p4Reg_0 = makePtEtaPhiM(hJet_ptReg[0] , hJet_pt[hJCidx[0]], hJet_eta[hJCidx[0]], hJet_phi[hJCidx[0]], hJet_m[hJCidx[0]]);
const TLorentzVector& hJet_p4Reg_1 = makePtEtaPhiM(hJet_ptReg[1] , hJet_pt[hJCidx[1]], hJet_eta[hJCidx[1]], hJet_phi[hJCidx[1]], hJet_m[hJCidx[1]]);
HptNorm = (hJet_p4Norm_0 + hJet_p4Norm_1 ).Pt();
HptGen = (hJet_p4Gen_0 + hJet_p4Gen_1 ).Pt();
HptReg = (hJet_p4Reg_0 + hJet_p4Reg_1 ).Pt();
HmassNorm = (hJet_p4Norm_0 + hJet_p4Norm_1 ).M();
HmassGen = (hJet_p4Gen_0 + hJet_p4Gen_1 ).M();
HmassReg = (hJet_p4Reg_0 + hJet_p4Reg_1 ).M();
// std::cout << "HmassReg is " << HmassReg << std::endl;
}
outTree->Fill(); // fill it!
} // end loop over TTree entries
/// Get elapsed time
sw.Stop();
std::cout << "--- End of event loop: ";
sw.Print();
output->cd();
outTree->Write();
output->Close();
input->Close();
delete input;
delete output;
for (formIt=inputFormulasReg0.begin(), formItEnd=inputFormulasReg0.end(); formIt!=formItEnd; formIt++)
delete *formIt;
for (formIt=inputFormulasReg1.begin(), formItEnd=inputFormulasReg1.end(); formIt!=formItEnd; formIt++)
delete *formIt;
for (formIt=inputFormulasFJReg0.begin(), formItEnd=inputFormulasFJReg0.end(); formIt!=formItEnd; formIt++)
delete *formIt;
for (formIt=inputFormulasFJReg1.begin(), formItEnd=inputFormulasFJReg1.end(); formIt!=formItEnd; formIt++)
delete *formIt;
for (formIt=inputFormulasFJReg2.begin(), formItEnd=inputFormulasFJReg2.end(); formIt!=formItEnd; formIt++)
delete *formIt;
delete ttf_lheweight;
std::cout << "==> GrowTree is done!" << std::endl << std::endl;
return;
}
void TMVAClassificationApplication_new(TString myMethodList = "" , TString iFileName = "", TString bkgSample = "", TString sampleLocation = "", TString massPoint = "", TString oFileLocation = "")
{
#ifdef __CINT__
gROOT->ProcessLine( ".O0" ); // turn off optimization in CINT
#endif
//---------------------------------------------------------------
// This loads the library
TMVA::Tools::Instance();
// Default MVA methods to be trained + tested
std::map<std::string,int> Use;
// --- Cut optimisation
Use["Cuts"] = 0;
Use["CutsD"] = 0;
Use["CutsPCA"] = 0;
Use["CutsGA"] = 0;
Use["CutsSA"] = 0;
//
//
// --- Boosted Decision Trees
Use["BDT"] = 1; // uses Adaptive Boost
std::cout << std::endl;
std::cout << "==> Start TMVAClassificationApplication" << std::endl;
// Select methods (don't look at this code - not of interest)
if (myMethodList != "") {
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;
std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' );
for (UInt_t i=0; i<mlist.size(); i++) {
std::string regMethod(mlist[i]);
if (Use.find(regMethod) == Use.end()) {
std::cout << "Method \"" << regMethod
<< "\" not known in TMVA under this name. Choose among the following:" << std::endl;
for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {
std::cout << it->first << " ";
}
std::cout << std::endl;
return;
}
Use[regMethod] = 1;
}
}
// --------------------------------------------------------------------------------------------------
// --- Create the Reader object
TMVA::Reader *reader = new TMVA::Reader("!Color:!Silent" );
TString weightTail = "_";
weightTail = weightTail + massPoint;
// Create a set of variables and declare them to the reader
// - the variable names MUST corresponds in name and type to those given in the weight file(s) used
Float_t var1, var2, var3, var4, var5, var6, var7, var8, var9, var10, var11, var12, var13, var14, var15, var16, var17, var18;
reader->AddVariable( "svMass", &var1);
reader->AddVariable( "dRTauTau", &var3 );
reader->AddVariable( "dRJJ", &var4 );
// reader->AddVariable( "svPt", &var5 );
// reader->AddVariable( "dRhh", &var6 );
reader->AddVariable( "met", &var7 );
reader->AddVariable( "mJJ", &var8 );
// reader->AddVariable( "metTau1DPhi", &var9 );
// reader->AddVariable( "metTau2DPhi", &var10);
// reader->AddVariable( "metJ1DPhi", &var11);
// reader->AddVariable( "metJ2DPhi", &var12 );
// reader->AddVariable( "metTauPairDPhi", &var13 );
// reader->AddVariable( "metSvTauPairDPhi", &var14 );
// reader->AddVariable( "metJetPairDPhi", &var15 );
// reader->AddVariable( "CSVJ1", &var16 );
// reader->AddVariable( "CSVJ2", &var17 );
reader->AddVariable( "fMassKinFit", &var2 );
reader->AddVariable( "chi2KinFit2", &var18 );
// Spectator variables declared in the training have to be added to the reader, too
// Float_t spec1,spec2;
// reader->AddSpectator( "spec1 := var1*2", &spec1 );
// reader->AddSpectator( "spec2 := var1*3", &spec2 );
// Float_t Category_cat1, Category_cat2, Category_cat3;
// if (Use["Category"]){
// // Add artificial spectators for distinguishing categories
// reader->AddSpectator( "Category_cat1 := var3<=0", &Category_cat1 );
// reader->AddSpectator( "Category_cat2 := (var3>0)&&(var4<0)", &Category_cat2 );
// reader->AddSpectator( "Category_cat3 := (var3>0)&&(var4>=0)", &Category_cat3 );
// }
// --- Book the MVA methods
// Book method(s)
TString weightFileName = "/nfs_scratch/zmao/test/CMSSW_5_3_15/src/TMVA-v4.2.0/test/weights/TMVAClassification_BDT.weights_";
weightFileName += bkgSample;
weightFileName += weightTail;
reader->BookMVA("BDT method", weightFileName+".xml" );
// Book output histograms
UInt_t nbin = 200;
TH1F *histBdt(0);
histBdt = new TH1F( "MVA_BDT", "MVA_BDT", nbin, -1.0, 1.0);
// Prepare input tree (this must be replaced by your data source)
// in this example, there is a toy tree with signal and one with background events
// we'll later on use only the "signal" events for the test in this example.
//
TFile *input(0);
TString fileName = iFileName;
TString fname = sampleLocation;
fname += fileName;
TString oFileName = oFileLocation;
oFileName += "ClassApp_" + bkgSample;
oFileName += "_";
oFileName += fileName;
if (!gSystem->AccessPathName( fname ))
input = TFile::Open(fname); // check if file in local directory exists
if (!input) {
std::cout << "ERROR: could not open data file" << std::endl;
exit(1);
}
std::cout << "--- TMVAClassificationApp : Using input file: " << input->GetName() << std::endl;
// --- Event loop
// Prepare the event tree
// - here the variable names have to corresponds to your tree
// - you can use the same variables as above which is slightly faster,
// but of course you can use different ones and copy the values inside the event loop
//
std::cout << "--- Select signal sample" << std::endl;
TTree* theTree = (TTree*)input->Get("eventTree");
TFile *target = new TFile( oFileName,"RECREATE" );
TTree *newTree = theTree->CloneTree();
Float_t BDT;
TBranch *branchBDT = newTree->Branch("BDT_"+bkgSample,&BDT,"BDT/F");
std::vector<Double_t> *vecVar1;
std::vector<Double_t> *vecVar5;
std::vector<Double_t> *vecVar7;
theTree->SetBranchAddress( "svMass", &vecVar1);
theTree->SetBranchAddress( "dRTauTau", &var3);
theTree->SetBranchAddress( "dRJJ", &var4 );
// theTree->SetBranchAddress( "svPt", &vecVar5 );
// theTree->SetBranchAddress( "dRhh", &var6 );
theTree->SetBranchAddress( "met", &vecVar7 );
theTree->SetBranchAddress( "mJJ", &var8 );
// theTree->SetBranchAddress( "metTau1DPhi", &var9 );
// theTree->SetBranchAddress( "metTau2DPhi", &var10);
// theTree->SetBranchAddress( "metJ1DPhi", &var11);
// theTree->SetBranchAddress( "metJ2DPhi", &var12 );
// theTree->SetBranchAddress( "metTauPairDPhi", &var13 );
// theTree->SetBranchAddress( "metSvTauPairDPhi", &var14 );
// theTree->SetBranchAddress( "metJetPairDPhi", &var15 );
// theTree->SetBranchAddress( "CSVJ1", &var16 );
// theTree->SetBranchAddress( "CSVJ2", &var17 );
theTree->SetBranchAddress( "fMassKinFit", &var2);
theTree->SetBranchAddress( "chi2KinFit2", &var18);
//to get initial pre-processed events
TH1F* cutFlow = (TH1F*)input->Get("preselection");
// Efficiency calculator for cut method
Int_t nSelCutsGA = 0;
Double_t effS = 0.7;
std::vector<Float_t> vecVar(4); // vector for EvaluateMVA tests
std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl;
TStopwatch sw;
sw.Start();
for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {
if (ievt%1000 == 0) std::cout << "--- ... Processing event: " << ievt << std::endl;
theTree->GetEntry(ievt);
var1 = vecVar1->at(0);
// var5 = vecVar5->at(0);
var7 = vecVar7->at(0);
// --- Return the MVA outputs and fill into histograms
if (Use["CutsGA"]) {
// Cuts is a special case: give the desired signal efficienciy
Bool_t passed = reader->EvaluateMVA( "CutsGA method", effS );
if (passed) nSelCutsGA++;
}
BDT = reader->EvaluateMVA( "BDT method");
histBdt->Fill(BDT);
branchBDT->Fill();
}
// Get elapsed time
sw.Stop();
std::cout << "--- End of event loop: "; sw.Print();
// Get efficiency for cuts classifier
if (Use["CutsGA"]) std::cout << "--- Efficiency for CutsGA method: " << double(nSelCutsGA)/theTree->GetEntries()
<< " (for a required signal efficiency of " << effS << ")" << std::endl;
if (Use["CutsGA"]) {
// test: retrieve cuts for particular signal efficiency
// CINT ignores dynamic_casts so we have to use a cuts-secific Reader function to acces the pointer
TMVA::MethodCuts* mcuts = reader->FindCutsMVA( "CutsGA method" ) ;
if (mcuts) {
std::vector<Double_t> cutsMin;
std::vector<Double_t> cutsMax;
mcuts->GetCuts( 0.7, cutsMin, cutsMax );
std::cout << "--- -------------------------------------------------------------" << std::endl;
std::cout << "--- Retrieve cut values for signal efficiency of 0.7 from Reader" << std::endl;
for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
std::cout << "... Cut: "
<< cutsMin[ivar]
<< " < \""
<< mcuts->GetInputVar(ivar)
<< "\" <= "
<< cutsMax[ivar] << std::endl;
}
std::cout << "--- -------------------------------------------------------------" << std::endl;
}
}
// --- Write histograms
histBdt->Write();
cutFlow->Write();
newTree->Write();
target->Close();
std::cout << "--- Created root file: \""<<oFileName<<"\" containing the MVA output histograms" << std::endl;
delete reader;
std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl;
}
void doPostProcessing(TString infname, TString outfile, Int_t events,
Float_t xsec, Float_t kfactor,
Float_t filt_eff, bool SortBasketsByEntry = false) {
cout << "Processing File " << infname << endl;
TFile *f = TFile::Open(infname.Data(), "READ");
if (! f || f->IsZombie()) {
cout << "File does not exist!" << endl;
return;
}
TTree* t = (TTree*)f->Get("Events");
if (! t || t->IsZombie()) {
cout << "Tree does not exist!" << endl;
return;
}
//-------------------------------------------------------------
// Removes all non *_CMS2.* branches
//-------------------------------------------------------------`
t->SetBranchStatus("*", 0);
t->SetBranchStatus("*_CMS2.*", 1);
// Removes the branches (if they exist) that we want to replace
//evt_xsec_excl
TString bName = t->GetAlias("evt_xsec_excl");
//cout << "evt_xsec_excl " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_xsec_incl
bName = t->GetAlias("evt_xsec_incl");
//cout << "evt_xsec_incl " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_kfactor
bName = t->GetAlias("evt_kfactor");
//cout << "evt_kfactor " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_nEvts
bName = t->GetAlias("evt_nEvts");
//cout << "evt_nEvts " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_filt_eff
bName = t->GetAlias("evt_filt_eff");
//cout << "evt_filt_eff " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
//evt_scale1fb
bName = t->GetAlias("evt_scale1fb");
//cout << "evt_scale1fb " << bName << endl;
if(bName != "") {
bName.ReplaceAll(".obj", "*");
t->SetBranchStatus(bName.Data(), 0);
}
TFile *out = TFile::Open(outfile.Data(), "RECREATE");
TTree *clone;
if(SortBasketsByEntry)
clone = t->CloneTree(-1, "fastSortBasketsByEntry");
else
clone = t->CloneTree(-1, "fast");
//-------------------------------------------------------------
//Calculate scaling factor and put variables into tree
Float_t scale1fb = xsec*kfactor*1000*filt_eff/(Float_t)events;
cout << "scale1fb: " << scale1fb << endl;
TBranch* b1 = clone->Branch("evtscale1fb", &scale1fb, "evt_scale1fb/F");
TBranch* b2 = clone->Branch("evtxsecexcl", &xsec, "evt_xsec_excl/F");
TBranch* b3 = clone->Branch("evtxsecincl", &xsec, "evt_xsec_incl/F");
TBranch* b4 = clone->Branch("evtkfactor", &kfactor, "evt_kfactor/F");
TBranch* b5 = clone->Branch("evtnEvts", &events, "evt_nEvts/I");
TBranch* b6 = clone->Branch("evtfilteff", &filt_eff, "evt_filt_eff/F");
clone->SetAlias("evt_scale1fb", "evtscale1fb");
clone->SetAlias("evt_xsec_excl", "evtxsecexcl");
clone->SetAlias("evt_xsec_incl", "evtxsecincl");
clone->SetAlias("evt_kfactor", "evtkfactor");
clone->SetAlias("evt_nEvts", "evtnEvts");
clone->SetAlias("evt_filt_eff", "evtfilteff");
Int_t nentries = t->GetEntries();
for(Int_t i = 0; i < nentries; i++) {
b1->Fill();
b2->Fill();
b3->Fill();
b4->Fill();
b5->Fill();
b6->Fill();
}
//-------------------------------------------------------------
clone->Write();
out->Close();
f->Close();
return;
}
void SkimChain(TChain* chain, const TString DataDir, TString SkimDir, TString skimname){
TObjArray *listOfFiles = chain->GetListOfFiles();
TIter fileIter(listOfFiles);
TPRegexp fileNameMatchPattern("(.*?)/([^/]*)$");
TPRegexp dataDirMatchPattern(DataDir);
unsigned int nEventsTotal = 0;
unsigned int nEventsSelectedTotal = 0;
std::vector<FileEntry> files;
while (TChainElement *currentFile = (TChainElement*)fileIter.Next()) {
FileEntry file;
TObjArray* matches = fileNameMatchPattern.MatchS(currentFile->GetTitle());
assert(matches);
assert(matches && matches->GetLast()==2);
TString inputFileName(currentFile->GetTitle());
TString fileName(((TObjString*)matches->At(2))->GetString());
file.fileName = fileName.Data();
TString outputDirectory(((TObjString*)matches->At(1))->GetString());
file.inputDir = outputDirectory.Data();
dataDirMatchPattern.Substitute(outputDirectory,SkimDir);
outputDirectory += "/" + skimname;
file.outputDir = outputDirectory.Data();
// make output directory if it doesn't exist yet
if ( gSystem->AccessPathName(outputDirectory.Data()) ){
gSystem->mkdir(outputDirectory.Data(),true);
assert( !gSystem->AccessPathName(outputDirectory.Data()) );
}
TString outputFileName(outputDirectory+"/"+fileName);
cout << "Skimming " << inputFileName << " -> " << outputFileName << endl;
TFile *output = TFile::Open(outputFileName.Data(), "RECREATE");
assert(output);
TFile *input = TFile::Open(inputFileName.Data());
assert(input);
TTree *tree = (TTree*)input->Get("Events");
TTree *newtree = tree->CloneTree(0);
newtree->SetDirectory(output);
cms2.Init(newtree);
cms2.Init(tree);
// Event Loop
const unsigned int nEvents = tree->GetEntries();
unsigned int nEventsSelected = 0;
int i_permille_old = 0;
for (unsigned int event = 0; event < nEvents; ++event, ++nEventsTotal) {
int i_permille = (int)floor(10000 * event / float(nEvents));
if (i_permille != i_permille_old) {
// xterm magic from L. Vacavant and A. Cerri
if (isatty(1)) {
printf("\015\033[32m ---> \033[1m\033[31m%5.2f%%"
"\033[0m\033[32m <---\033[0m\015", i_permille/100.);
fflush(stdout);
}
i_permille_old = i_permille;
}
cms2.GetEntry(event);
//set condition to skip event
if ( not passedSkimSelection() ) continue;
++nEventsSelected;
cms2.LoadAllBranches();
// fill the new tree
newtree->Fill();
}
file.nIn = nEvents;
file.nOut = nEventsSelected;
files.push_back(file);
nEventsSelectedTotal += nEventsSelected;
output->cd();
newtree->Write();
output->Close();
input->Close();
}
cout << Form("Processed events: %u, \tselected: %u\n",nEventsTotal,nEventsSelectedTotal) << endl;
}
void makeReducedTrees_P(Int_t bin) {
TString binStr; binStr+=bin;
Double_t minQ(0.), maxQ(0.);
switch(bin) {
case 0:
minQ = TMath::Sqrt(0.1e6);
maxQ = TMath::Sqrt(0.98e6);
break;
case 1:
minQ = TMath::Sqrt(1.1e6);
maxQ = TMath::Sqrt(2.e6);
break;
case 2:
minQ = TMath::Sqrt(2.e6);
maxQ = TMath::Sqrt(3.e6);
break;
case 3:
minQ = TMath::Sqrt(3.e6);
maxQ = TMath::Sqrt(4.e6);
break;
case 4:
minQ = TMath::Sqrt(4.e6);
maxQ = TMath::Sqrt(5.e6);
break;
case 5:
minQ = TMath::Sqrt(5.e6);
maxQ = TMath::Sqrt(6.e6);
break;
case 6:
minQ = TMath::Sqrt(6.e6);
maxQ = TMath::Sqrt(7.e6);
break;
case 7:
minQ = TMath::Sqrt(7.e6);
maxQ = TMath::Sqrt(8.e6);
break;
case 8:
minQ = TMath::Sqrt(11.e6);
maxQ = TMath::Sqrt(11.75e6);
break;
case 9:
minQ = TMath::Sqrt(11.75e6);
maxQ = TMath::Sqrt(12.5e6);
break;
case 10:
minQ = TMath::Sqrt(15.e6);
maxQ = TMath::Sqrt(16.e6);
break;
case 11:
minQ = TMath::Sqrt(16.e6);
maxQ = TMath::Sqrt(17.e6);
break;
case 12:
minQ = TMath::Sqrt(17.e6);
maxQ = TMath::Sqrt(18.e6);
break;
case 13:
minQ = TMath::Sqrt(18.e6);
maxQ = TMath::Sqrt(19.e6);
break;
case 14:
minQ = TMath::Sqrt(19.e6);
maxQ = TMath::Sqrt(20.e6);
break;
case 15:
minQ = TMath::Sqrt(20.e6);
maxQ = TMath::Sqrt(21.e6);
break;
case 16:
minQ = TMath::Sqrt(21.e6);
maxQ = TMath::Sqrt(22.e6);
break;
case 17:
minQ = TMath::Sqrt(1.1e6);
maxQ = TMath::Sqrt(6.e6);
break;
case 18:
minQ = TMath::Sqrt(15.e6);
maxQ = TMath::Sqrt(22.e6);
break;
case 19:
minQ = TMath::Sqrt( 8.e6);
maxQ = TMath::Sqrt(11.e6);
break;
case 20:
minQ = TMath::Sqrt(12.5e6);
maxQ = TMath::Sqrt(15.e6);
break;
default:
return;
}
TFile * f = TFile::Open("/Home/dcraik/lhcb/rd/Kll/tuples/fromPatrick/Kmm.root");
TTree * tree = dynamic_cast<TTree*>(f->Get("finalTree_KMuMu"));
TFile* fs = TFile::Open("fromPatrick/Kmm_Q"+binStr+"_sWeights.root");
TTree* stree = dynamic_cast<TTree*>(fs->Get("sWeights"));
TFile* fn = new TFile("fromPatrick/Kmm_Q"+binStr+"_reduced.root","RECREATE");
TTree* newtree = tree->CloneTree(0);
TLorentzVector mup_4mom;
TLorentzVector mum_4mom;
TLorentzVector Psi_4mom;
TLorentzVector K_4mom;
TLorentzVector B_4mom;
TVector3 B_boost;
TVector3 Psi_boost;
TVector3 mup_boost;
TVector3 mum_boost;
Double_t K_PE(0.), K_PX(0.), K_PY(0.), K_PZ(0.);
Double_t mup_PE(0.), mup_PX(0.), mup_PY(0.), mup_PZ(0.);
Double_t mum_PE(0.), mum_PX(0.), mum_PY(0.), mum_PZ(0.);
Double_t B_M(0.), Psi_M(0.);
Double_t cosThetaL(0.);
Double_t sWeight(0.);
newtree->Branch("cosThetaL" ,&cosThetaL);
newtree->Branch("sWeight" ,&sWeight);
tree->SetBranchAddress("Bplus_M", &B_M);
tree->SetBranchAddress("Jpsi_M", &Psi_M);
tree->SetBranchAddress("Kplus_PE", &K_PE);
tree->SetBranchAddress("Kplus_PX", &K_PX);
tree->SetBranchAddress("Kplus_PY", &K_PY);
tree->SetBranchAddress("Kplus_PZ", &K_PZ);
tree->SetBranchAddress("muplus_PE", &mup_PE);
tree->SetBranchAddress("muplus_PX", &mup_PX);
tree->SetBranchAddress("muplus_PY", &mup_PY);
tree->SetBranchAddress("muplus_PZ", &mup_PZ);
tree->SetBranchAddress("muminus_PE", &mum_PE);
tree->SetBranchAddress("muminus_PX", &mum_PX);
tree->SetBranchAddress("muminus_PY", &mum_PY);
tree->SetBranchAddress("muminus_PZ", &mum_PZ);
stree->SetBranchAddress("Nsig_sw", &sWeight);
Int_t i(0), is(0);
Int_t n = tree->GetEntries();
Int_t ns = stree->GetEntries();
while( i<n && is<ns ) {
if(is % 100 == 0) std::cout << "Entry " << is << " of " << ns << "..." << std::endl;
do {
++i;
if(i==n) {//i cannot iterate past n because is would have already hit ns.
std::cout << "This was supposed to be impossible. The two trees don't match!" << std::endl;
std::cout << is << "\t" << ns << std::endl;
return;
}
tree->GetEntry(i);
} while(B_M<5170 || B_M>5970 || Psi_M<minQ || Psi_M>maxQ);
++is;
stree->GetEntry(is);
//Get 4 momentum of each track
K_4mom.SetPxPyPzE( K_PX/1000, K_PY/1000, K_PZ/1000, K_PE/1000);
mup_4mom.SetPxPyPzE( mup_PX/1000, mup_PY/1000, mup_PZ/1000, mup_PE/1000);
mum_4mom.SetPxPyPzE( mum_PX/1000, mum_PY/1000, mum_PZ/1000, mum_PE/1000);
//Make 4 momenta of composites
Psi_4mom = mup_4mom + mum_4mom;
B_4mom = Psi_4mom + K_4mom;
//boost into B frame
B_boost = B_4mom.BoostVector();
Psi_4mom.Boost(-B_boost);
mup_4mom.Boost(-B_boost);
//Boost into Psi frame
Psi_boost = Psi_4mom.BoostVector();
mup_4mom.Boost(-Psi_boost);
//cosThetaL is the angle between the Psi and the mu+ in the Psi rest frame
mup_boost = mup_4mom.BoostVector();
cosThetaL = Psi_boost.Dot(mup_boost)/(Psi_boost.Mag()*mup_boost.Mag());
newtree->Fill();
}
std::cout << is << "\t" << ns << std::endl;
newtree->AutoSave();
fn->Close();
}
//std::mutex mtx;
void ProcessFilePar(TString fileIn, TString fileOut, TString treename, vector<TString> friends, vector<TString> branches, vector<TString> newbranches, unsigned jobid = 0, unsigned NPAR = 1)
{
//mtx.lock(); //for threads
TFile *fin = new TFile(fileIn);
TTree *tjet = (TTree*)fin->Get(treename);
//mtx.unlock();
vector<TTree *> friendTrees;
vector<bool> sameFileFriend;
for (auto f:friends) {
auto fr = tokenize(f,":");
if (fr.size()==1) {tjet->AddFriend(fr[0]); sameFileFriend.push_back(true);}
else if (fr.size()==2) {tjet->AddFriend(fr[1],fr[0]); sameFileFriend.push_back(false);}
TTree *tfriend = (TTree*)fin->Get(f);
friendTrees.push_back(tfriend);
}
AddBranchesByCounter(tjet, branches);
for (unsigned i=0;i<friendTrees.size();i++) AddBranchesByCounter(friendTrees[i],branches);
//sort branches into categories
for (auto bName:branches) {
TBranch *b=tjet->GetBranch(bName);
if (b==0) cout <<"Branch "<<bName<<" doesn't exist!"<<endl;
//parse in case there is a tree name in the branch
auto branchtoken = tokenize(bName,".");
auto leafname = branchtoken[branchtoken.size()-1];
TObjArray *bl = b->GetListOfLeaves();
if (bl->GetEntries()>1)
cout <<" Branch "<<b->GetTitle()<<" has more than 1 leave. Taking first..."<<endl;
if (bl->GetEntries()==0) {
cout <<" Branch "<<b->GetTitle()<<" has no leaves! Skipping..."<<endl;
continue;
}
TLeaf * l = (TLeaf *)(*bl)[0];
//what's the type?
TString type = l->GetTypeName();
if (VERBOSE) cout<<l->GetTitle()<<endl;
//array?
bool array = l->GetLeafCount()!=0;
TString counter;
if (array) counter = l->GetLeafCount()->GetBranch()->GetName();
if (type=="Float_t")
{ if (array) {brVFloat.push_back(bName); brVFloatCounter.push_back(counter); }else brFloat.push_back(bName);}
else if (type=="Int_t")
{ if (array) {brVInt.push_back(bName); brVIntCounter.push_back(counter); }else brInt.push_back(bName);}
else cout << "Unsupported branch type "<<type<<" for branch "<<bName<<". Skipping..."<<endl;
}
//treat counters as ints only
AppendToListUniquely(brVIntCounter, brInt);
AppendToListUniquely(brVFloatCounter, brInt);
//too keep track of old branches, which cannot be read (todo: just check it...)
int noldbrInt = brInt.size(), noldbrFloat = brFloat.size(), noldbrVInt = brVInt.size(), noldbrVIntCounter = brVIntCounter.size(), noldbrVFloat = brVFloat.size(), noldbrVFloatCounter = brVFloatCounter.size();
//add new branches
ParseNewBranches(newbranches, brInt, brFloat, brVInt, brVIntCounter, brVFloat, brVFloatCounter);
//print for debugging
if (VERBOSE) {
cout<<"int : "; for (auto s:brInt) cout <<s<<", "; cout<<endl;
cout<<"float : "; for (auto s:brFloat) cout <<s<<", "; cout<<endl;
cout<<"Vint : "; for (auto s:brVInt) cout <<s<<", "; cout<<endl;
cout<<"Vfloat : "; for (auto s:brVFloat) cout <<s<<", "; cout<<endl;
cout<<"Vintcnt : "; for (auto s:brVIntCounter) cout <<s<<", "; cout<<endl;
cout<<"Vfloatcnt : "; for (auto s:brVFloatCounter) cout <<s<<", "; cout<<endl;
}
tjet->SetBranchStatus("*",1);
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) {unsigned f=0; tjet->SetBranchStatus(b,0,&f); if (VERBOSE) cout<<"turning off "<<b<<", found = "<<f<<endl;}
TFile *fout = new TFile(fileOut,"recreate");
TTree *tjetout;
//in case of one-to-many event - do not copy branches automatically!
if (useOneToOne) tjetout = tjet->CloneTree(0);
else tjetout = new TTree(tjet->GetName(),tjet->GetTitle());
//think about memory tree
// tjetout->SetDirectory(0);
tjetout->SetName(tjet->GetName());
//TTree *tjetout = new TTree("t","t");
//to see what is copied...
//tjetout->Print();
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
vector<int> valIntIn(brInt.size()), valIntOut(brInt.size());
vector<float> valFloatIn(brFloat.size()), valFloatOut(brFloat.size());
vector<vector<int> >valVIntIn (brVInt.size()); vector<vector<int> >valVIntOut (brVInt.size());
vector<vector<float> >valVFloatIn (brVFloat.size()); vector<vector<float> >valVFloatOut (brVFloat.size());
for (unsigned i=0;i<brInt.size();i++) {
if (tjet->GetBranch(brInt[i])!=0)
tjet->SetBranchAddress(brInt[i],&valIntIn[i]);
if (tjetout->GetBranch(brInt[i])!=0) {//why would it?
tjetout->SetBranchAddress(brInt[i],&valIntOut[i]);
cout<<"branch "<<brInt[i]<<" already exist for some reason..."<<endl;
}
else //logical...
if (NonFriendBranch(tjet, brInt[i]))
tjetout->Branch(brInt[i],&valIntOut[i],Form("%s/I",brInt[i].Data()));
}
for (unsigned i=0;i<brFloat.size();i++) {
if (tjet->GetBranch(brFloat[i])!=0)
tjet->SetBranchAddress(brFloat[i],&valFloatIn[i]);
if (NonFriendBranch(tjet, brFloat[i]))
tjetout->Branch(brFloat[i],&valFloatOut[i],Form("%s/F",brFloat[i].Data()));
}
for (unsigned i=0;i<brVFloat.size();i++) {
if (tjet->GetBranch(brVFloat[i])!=0) {
valVFloatIn[i] = vector<float>(NMAX);
tjet->SetBranchAddress(brVFloat[i],&valVFloatIn[i][0]);
}
valVFloatOut[i] = vector<float>(NMAX);
if (NonFriendBranch(tjet, brVFloat[i]))
tjetout->Branch(brVFloat[i],&valVFloatOut[i][0],Form("%s[%s]/F",brVFloat[i].Data(),brVFloatCounter[i].Data()));
}
for (unsigned i=0;i<brVInt.size();i++) {
if (tjet->GetBranch(brVInt[i])) {
valVIntIn[i] = vector<int>(NMAX);
tjet->SetBranchAddress(brVInt[i],&valVIntIn[i][0]);
}
valVIntOut[i] = vector<int>(NMAX);
if (NonFriendBranch(tjet, brVInt[i]))
tjetout->Branch(brVInt[i],&valVIntOut[i][0],Form("%s[%s]/I",brVInt[i].Data(),brVIntCounter[i].Data()));
}
Long64_t nentries = tjet->GetEntries();
int nentries1 = nentries/NPAR*jobid;
int nentries2 = nentries/NPAR*(jobid+1);
nentries = nentries2-nentries1;
int oneperc = nentries/100; if (oneperc==0) oneperc = 1;
cout<<"Start processing..."<<endl;
TStopwatch s;
s.Start();
TTimeStamp t0;
double readTime = 0, processingTime = 0, copyToTime = 0, cloneTime=0, copyFromTime=0, fillTime = 0;
for (Long64_t i=0; i<nentries;i++) {
if (jobid==0 && i % oneperc == 0 && i>0) {
std::cout << std::fixed;
TTimeStamp t1; cout<<" \r"<<i/oneperc<<"% "<<" est. time "<<setprecision(2) <<(t1-t0)*nentries/(i+.1)<<" s ";
cout<<";Processing:"<<setprecision(2)<<processingTime/(t1-t0)*100<<" %";
cout<<";Copy1:"<<setprecision(2) <<copyToTime/(t1-t0)*100<<" %";
cout<<";Clone:"<<setprecision(2) <<cloneTime/(t1-t0)*100<<" %";
cout<<";Copy2:"<<setprecision(2) <<copyFromTime/(t1-t0)*100<<" %";
cout<<";Fill:"<<setprecision(2) <<fillTime/(t1-t0)*100<<" %";
cout<<";Read:"<<setprecision(2) <<readTime/(t1-t0)*100<<" %";
cout<<flush;
}
TTimeStamp tsRead0;
tjet->GetEntry(i+nentries1);
TTimeStamp tsRead1;
readTime+=tsRead1-tsRead0;
Everything ev;
TTimeStamp tsCpTo0;
for (unsigned j=0;j<brInt.size();j++) ev.PutInt(brInt[j],valIntIn[j]);
for (unsigned j=0;j<brFloat.size();j++) ev.PutFloat(brFloat[j],valFloatIn[j]);
for (unsigned j=0;j<brVFloat.size();j++) ev.PutVFloat(brVFloat[j],brVFloatCounter[j],valVFloatIn[j]);
for (unsigned j=0;j<brVInt.size();j++) ev.PutVInt(brVInt[j],brVIntCounter[j],valVIntIn[j]);
TTimeStamp tsCpTo1;
copyToTime+=tsCpTo1-tsCpTo0;
TTimeStamp tsCl0;
//think about: copy object (timing 10% ->3%)
//but it copies vectors, so push_back will add in the end...
// Everything evout = ev;
//or even reference(in place?) (->0.2%)
//Everything &evout = ev;
Everything evout = ev.CloneStructure();
TTimeStamp tsCl1;
cloneTime+=tsCl1-tsCl0;
bool exitEvent = false;
int counter = 0;
while (!exitEvent) {
TTimeStamp tsPr0;
if (useOneToOne) {
fProcessOneToOne(ev, evout);
evout.UpdateCounters();
exitEvent = true;
} else {
exitEvent = fProcessOneToMany(ev, evout, counter);
// if (!exitEvent) cout<<"event to write "<<counter<<endl;
counter++;
}
TTimeStamp tsPr1;
processingTime+=tsPr1-tsPr0;
//Everything evout = ev;
TTimeStamp tsCpFrom0;
for (unsigned j=0;j<brInt.size();j++) valIntOut[j] = evout.GetInt(brInt[j]);
for (unsigned j=0;j<brFloat.size();j++) {valFloatOut[j] = evout.GetFloat(brFloat[j]);
// cout<<brFloat[j]<<" "<<evout.GetFloat(brFloat[j])<<endl;
}
for (unsigned j=0;j<brVFloat.size();j++) valVFloatOut[j] = evout[brVFloat[j]];
for (unsigned j=0;j<brVInt.size();j++) valVIntOut[j] = evout.GetVInt(brVInt[j]);
TTimeStamp tsCpFrom1;
copyFromTime+=tsCpFrom1-tsCpFrom0;
TTimeStamp tsFill0;
tjetout->Fill();
TTimeStamp tsFill1;
fillTime+=tsFill1-tsFill0;
}
}
cout<<endl;
s.Stop();
cout<<"Done in ";s.Print();
tjetout->FlushBaskets();
tjetout->Write();
cout<<"Copying other trees..."<<endl;
for (unsigned i=0;i<friendTrees.size();i++) {
TTree *t = friendTrees[i];
if (sameFileFriend[i]) {
//TTree *triendout = t->CloneTree(-1,"fast");
TTree *triendout = t->CopyTree("","",nentries,nentries1);
triendout->Write();
}
}
fout->Close();
friendTrees.clear();
}
void apply(std::string iName="train/OutputTmp.root") {
TMVA::Tools::Instance();
TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" );
float lPt = 0; reader->AddVariable("pt" , &lPt);
//float lEta = 0; reader->AddVariable("eta" , &lEta);
//float lDR = 0; reader->AddVariable("dR" , &lDR);
//float lPtc = 0; reader->AddVariable("ptc" , &lPtc);
// float lPtdR = 0; reader->AddVariable("ptdR" , &lPtdR);
//float lPuppi = 0; reader->AddVariable("puppi" , &lPuppi);
float lPtODR = 0; reader->AddVariable("ptodR" , &lPtODR);
//float lPtODRS = 0; reader->AddVariable("ptodRS" , &lPtODRS);
float lPtODRSO = 0; reader->AddVariable("ptodRSO" , &lPtODRSO);
//float lDRLV = 0; reader->AddVariable("dR_lv" , &lDRLV);
//float lPtcLV = 0; reader->AddVariable("ptc_lv" , &lPtcLV);
//float lPtdRLV = 0; reader->AddVariable("ptdR_lv" , &lPtdRLV);
//float lPuppiLV = 0; reader->AddVariable("puppi_lv" , &lPuppiLV);
float lPtODRLV = 0; reader->AddVariable("ptodR_lv" , &lPtODRLV);
//float lPtODRSLV = 0; reader->AddVariable("ptodRS_lv" , &lPtODRSLV);
float lPtODRSOLV = 0; reader->AddVariable("ptodRSO_lv" , &lPtODRSOLV);
//float lDRPU = 0; reader->AddVariable("dR_pu" , &lDRPU);
//float lPtcPU = 0; reader->AddVariable("pt_pu" , &lPtcPU);
//float lPtdRPU = 0; reader->AddVariable("ptdR_pu" , &lPtdRPU);
//float lPuppiPU = 0; reader->AddVariable("puppi_pu" , &lPuppiPU);
//float lPtODRPU = 0; reader->AddVariable("ptodR_pu" , &lPtODRPU);
//float lPtODRSPU = 0; reader->AddVariable("ptodRS_pu" , &lPtODRSPU);
//float lPtODRSOPU = 0; reader->AddVariable("ptodRSO_pu" , &lPtODRSOPU);
std::string lJetName = "BDT";
reader->BookMVA(lJetName .c_str(),(std::string("weights/TMVAClassificationCategory_PUDisc_v1")+std::string(".weights.xml")).c_str());
TFile *lFile = new TFile(iName.c_str());
TTree *lTree = (TTree*) lFile->Get("tree");
lTree->SetBranchAddress("pt" , &lPt);
//lTree->SetBranchAddress("eta" , &lEta);
//lTree->SetBranchAddress("dR" , &lDR);
//lTree->SetBranchAddress("ptc" , &lPtc);
//lTree->SetBranchAddress("ptdR" , &lPtdR);
//lTree->SetBranchAddress("puppi" , &lPuppi);
lTree->SetBranchAddress("ptodR" , &lPtODR);
//lTree->SetBranchAddress("ptodRS" , &lPtODRS);
lTree->SetBranchAddress("ptodRSO" , &lPtODRSO);
//lTree->SetBranchAddress("dR_lv" , &lDRLV);
// lTree->SetBranchAddress("ptc_lv" , &lPtcLV);
//lTree->SetBranchAddress("ptdR_lv" , &lPtdRLV);
//lTree->SetBranchAddress("puppi_lv" , &lPuppiLV);
lTree->SetBranchAddress("ptodR_lv" , &lPtODRLV);
//lTree->SetBranchAddress("ptodRS_lv" , &lPtODRSLV);
lTree->SetBranchAddress("ptodRSO_lv" , &lPtODRSOLV);
//lTree->SetBranchAddress("dR_pu" , &lDRPU);
//lTree->SetBranchAddress("pt_pu" , &lPtcPU);
//lTree->SetBranchAddress("ptdR_pu" , &lPtdRPU);
//lTree->SetBranchAddress("puppi_pu" , &lPuppiPU);
//lTree->SetBranchAddress("ptodR_pu" , &lPtODRPU);
//lTree->SetBranchAddress("ptodRS_pu" , &lPtODRSPU);
//lTree->SetBranchAddress("ptodRSO_pu" , &lPtODRSOPU);
int lNEvents = lTree->GetEntries();
TFile *lOFile = new TFile("Output.root","RECREATE");
TTree *lOTree = lTree->CloneTree(0);
float lMVA = 0; lOTree->Branch("bdt" ,&lMVA ,"lMVA/F");
for (Long64_t i0=0; i0<lNEvents;i0++) {
if (i0 % 10000 == 0) std::cout << "--- ... Processing event: " << double(i0)/double(lNEvents) << std::endl;
lTree->GetEntry(i0);
lMVA = float(reader->EvaluateMVA(lJetName.c_str()));
lOTree->Fill();
}
lOTree->Write();
lOFile->Close();
delete reader;
}
void applypieeSel(TString file) {
TString fname = "/Disk/ecdf-nfs-ppe/lhcb/dcraik/Kee/"; fname+=file; fname+=".root";
TString outname = "/Disk/ecdf-nfs-ppe/lhcb/dcraik/Kee/"; outname+=file; outname+="_presel_piee.root";
TFile* fin = TFile::Open(fname);
TTree* tin = dynamic_cast<TTree*>(fin->Get("DecayTree"));
TFile* fout = new TFile(outname,"RECREATE");
TTree* tout = tin->CloneTree(0);
Bool_t B_plus_L0ElectronDecision_TOS, B_plus_L0HadronDecision_TOS, B_plus_L0ElectronDecision_TIS, B_plus_L0HadronDecision_TIS, B_plus_L0MuonDecision_TIS, B_plus_L0PhotonDecision_TIS;
Bool_t B_plus_Hlt1TrackAllL0Decision_TOS, B_plus_Hlt2TopoE3BodyBBDTDecision_TOS, B_plus_Hlt2TopoE2BodyBBDTDecision_TOS, B_plus_Hlt2Topo3BodyBBDTDecision_TOS, B_plus_Hlt2Topo2BodyBBDTDecision_TOS;
Double_t K_Kst_TRACK_GhostProb, e_plus_TRACK_GhostProb, e_minus_TRACK_GhostProb, K_Kst_ProbNNk, K_Kst_PIDe, e_plus_PIDe, e_minus_PIDe;
Double_t B_plus_M, B_plus_M02_Subst0_e2pi, B_plus_M02, J_psi_1S_M;
Float_t B_plus_DTFM_M;
Double_t B_plus_HOP_M, B_plus_FDCHI2_OWNPV;
Double_t e_plus_BremMultiplicity, e_minus_BremMultiplicity;
Int_t category;
//L0 trigger
tin->SetBranchAddress("B_plus_L0ElectronDecision_TOS", &B_plus_L0ElectronDecision_TOS);
tin->SetBranchAddress("B_plus_L0HadronDecision_TOS", &B_plus_L0HadronDecision_TOS);
tin->SetBranchAddress("B_plus_L0ElectronDecision_TIS", &B_plus_L0ElectronDecision_TIS);
tin->SetBranchAddress("B_plus_L0HadronDecision_TIS", &B_plus_L0HadronDecision_TIS);
tin->SetBranchAddress("B_plus_L0MuonDecision_TIS", &B_plus_L0MuonDecision_TIS);
tin->SetBranchAddress("B_plus_L0PhotonDecision_TIS", &B_plus_L0PhotonDecision_TIS);
//HLT
tin->SetBranchAddress("B_plus_Hlt1TrackAllL0Decision_TOS", &B_plus_Hlt1TrackAllL0Decision_TOS);
tin->SetBranchAddress("B_plus_Hlt2TopoE3BodyBBDTDecision_TOS", &B_plus_Hlt2TopoE3BodyBBDTDecision_TOS);
tin->SetBranchAddress("B_plus_Hlt2TopoE2BodyBBDTDecision_TOS", &B_plus_Hlt2TopoE2BodyBBDTDecision_TOS);
tin->SetBranchAddress("B_plus_Hlt2Topo3BodyBBDTDecision_TOS", &B_plus_Hlt2Topo3BodyBBDTDecision_TOS);
tin->SetBranchAddress("B_plus_Hlt2Topo2BodyBBDTDecision_TOS", &B_plus_Hlt2Topo2BodyBBDTDecision_TOS);
//ghost prob
tin->SetBranchAddress("K_Kst_TRACK_GhostProb", &K_Kst_TRACK_GhostProb);
tin->SetBranchAddress("e_plus_TRACK_GhostProb", &e_plus_TRACK_GhostProb);
tin->SetBranchAddress("e_minus_TRACK_GhostProb", &e_minus_TRACK_GhostProb);
//PID
tin->SetBranchAddress("K_Kst_ProbNNk", &K_Kst_ProbNNk);
tin->SetBranchAddress("K_Kst_PIDe", &K_Kst_PIDe);
tin->SetBranchAddress("e_plus_PIDe", &e_plus_PIDe);
tin->SetBranchAddress("e_minus_PIDe", &e_minus_PIDe);
//masses
tin->SetBranchAddress("B_plus_M", &B_plus_M);
tin->SetBranchAddress("B_plus_M02_Subst0_e2pi", &B_plus_M02_Subst0_e2pi);
tin->SetBranchAddress("B_plus_M02", &B_plus_M02);
tin->SetBranchAddress("J_psi_1S_M", &J_psi_1S_M);
tin->SetBranchAddress("B_plus_DTFM_M", &B_plus_DTFM_M);
//hop
tin->SetBranchAddress("B_plus_HOP_M", &B_plus_HOP_M);
tin->SetBranchAddress("B_plus_FDCHI2_OWNPV", &B_plus_FDCHI2_OWNPV);
//brem
tin->SetBranchAddress("e_plus_BremMultiplicity", &e_plus_BremMultiplicity);
tin->SetBranchAddress("e_minus_BremMultiplicity", &e_minus_BremMultiplicity);
tout->Branch("category", &category);
Int_t nEntries = tin->GetEntries();
for(Int_t i=0; i<nEntries; ++i) {
if(i%10000==0) std::cout << "Entry " << i << " of " << nEntries << "..." << std::endl;
tin->GetEntry(i);
//category for binning in L0 cat and brem multiplicity
category = 0;
switch(e_plus_BremMultiplicity+e_minus_BremMultiplicity) {
case 0:
break;
case 1:
category+=1;
break;
default:
category+=2;
}
//L0
if(B_plus_L0ElectronDecision_TOS==1) category+=6;
else if(B_plus_L0HadronDecision_TOS==1) category+=3;
else if((B_plus_L0ElectronDecision_TIS==1) || (B_plus_L0HadronDecision_TIS==1) || (B_plus_L0MuonDecision_TIS==1) || (B_plus_L0PhotonDecision_TIS)) category+=0;
else continue;
//HLT
if(B_plus_Hlt1TrackAllL0Decision_TOS!=1) continue;
if(!((B_plus_Hlt2TopoE3BodyBBDTDecision_TOS==1) || (B_plus_Hlt2TopoE2BodyBBDTDecision_TOS==1) ||
(B_plus_Hlt2Topo3BodyBBDTDecision_TOS==1) || (B_plus_Hlt2Topo2BodyBBDTDecision_TOS==1)) ) continue;
//ghost prob
if(K_Kst_TRACK_GhostProb>0.3 || e_plus_TRACK_GhostProb>0.3 || e_minus_TRACK_GhostProb>0.3) continue;
//PID
if(K_Kst_ProbNNk>0.2 || K_Kst_PIDe>0 || e_plus_PIDe<3 || e_minus_PIDe<3) continue;
tout->Fill();
}
tout->AutoSave();
fout->Close();
}
//*************************************************************************************************
//Main part of the macro
//*************************************************************************************************
void NormalizeElectronNtuple(const string InputFilename, const string datasetName,
const string OutputFilename, Int_t sampleType,
const string normalizationFile = "") {
Double_t normalizationWeight = 0;
Bool_t useReweightFactor = kFALSE;
TH2F *PtEtaReweightFactor = 0;
Double_t overallWJetsNormalizationFactor = 0;
//For Normalizing each sample individually
if (sampleType == 0 || sampleType >= 10) {
TTree* electronTree = getTreeFromFile(InputFilename.c_str());
assert(electronTree);
MitNtupleElectron ele(electronTree);
normalizationWeight = getNormalizationWeight(InputFilename, datasetName);
//*************************************************************************************************
//Create new normalized tree
//*************************************************************************************************
TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE");
outputFile->cd();
TTree *normalizedTree = electronTree->CloneTree(0);
for (int n=0;n<electronTree->GetEntries();n++) {
ele.GetEntry(n);
if (sampleType == 10) {
if (ele.electron_branch_passedSelectionCut == 1) {
if (datasetName == "s09-wwll10-mc3" || datasetName == "s09-ttbar-mc3") {
//for mu-e there should be only 1 electron candidate
ele.electron_branch_weight = normalizationWeight;
normalizedTree->Fill();
} else if (datasetName == "s09-we-mc3" || datasetName == "s09-wm-mc3" || datasetName == "s09-wt-mc3") {
//For the W->enu sample, fill only the fake electron candidates.
ele.electron_branch_weight = normalizationWeight;
if (ele.electron_branch_electronType < 100) {
normalizedTree->Fill();
}
} else {
cout << "Warning: The specified dataset " << datasetName
<< " is not recognized to be one of the selection cut samples.\n";
}
}
} else {
//For regular samples just fill all electrons
ele.electron_branch_weight = normalizationWeight;
normalizedTree->Fill();
}
}
normalizedTree->Write();
cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << normalizedTree->GetEntries() << endl;
outputFile->Close();
}
//For Normalization of Background sample
else if (sampleType == 1) {
TTree* electronTree = getTreeFromFile(InputFilename.c_str(), kFALSE);
assert(electronTree);
MitNtupleElectron ele(electronTree);
//*************************************************************************************************
//Create new reweighted tree
//*************************************************************************************************
TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE");
TTree *reweightedTree = electronTree->CloneTree(0);
if (normalizationFile == "") {
//normalize according to total number of electrons expected in W+Jets/W+gamma bkg
Double_t totalWeight = 0;
for (int n=0;n<electronTree->GetEntries();n++) {
ele.GetEntry(n);
totalWeight += ele.electron_branch_weight;
}
cout << "Input Bkg Ntuple Total Weight = " << totalWeight << endl;
normalizationWeight = 1126.5 / totalWeight;
} else {
//do pt/eta Reweighting
TFile *reweightInputFile = new TFile(normalizationFile.c_str(), "READ");
assert(reweightInputFile);
TH2F *WJetsFakeElectronPtEta = (TH2F*)reweightInputFile->Get("hWJetsFakeElectronPtEta");
assert(WJetsFakeElectronPtEta);
WJetsFakeElectronPtEta = (TH2F*)(WJetsFakeElectronPtEta->Clone());
WJetsFakeElectronPtEta->SetDirectory(0);
reweightInputFile->Close();
//Create histogram for reweighting factor
PtEtaReweightFactor = (TH2F*)WJetsFakeElectronPtEta->Clone();
PtEtaReweightFactor->SetName("PtEtaReweightFactor");
PtEtaReweightFactor->SetDirectory(0);
TH2F *BkgFakeElectronPtEta = new TH2F("BkgFakeElectronPtEta", ";Pt [GeV/c];#eta;" , WJetsFakeElectronPtEta->GetXaxis()->GetNbins(), WJetsFakeElectronPtEta->GetXaxis()->GetBinLowEdge(1), WJetsFakeElectronPtEta->GetXaxis()->GetBinUpEdge(WJetsFakeElectronPtEta->GetXaxis()->GetNbins()), WJetsFakeElectronPtEta->GetYaxis()->GetNbins(), WJetsFakeElectronPtEta->GetYaxis()->GetBinLowEdge(1), WJetsFakeElectronPtEta->GetYaxis()->GetBinUpEdge(WJetsFakeElectronPtEta->GetYaxis()->GetNbins()));
BkgFakeElectronPtEta->SetDirectory(0);
for (int n=0;n<electronTree->GetEntries();n++) {
ele.GetEntry(n);
BkgFakeElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight);
}
PtEtaReweightFactor->Divide(WJetsFakeElectronPtEta, BkgFakeElectronPtEta, 1.0,1.0,"B");
useReweightFactor = kTRUE;
}
cout << "Reweighting Background Ntuple\n";
outputFile->cd();
//check Reweighting
TH2F *ReweightedBkgFakeElectronPtEta = new TH2F("BkgFakeElectronPtEta", ";Pt [GeV/c];#eta;" , 200, 0, 200, 200, -3.0, 3.0);
ReweightedBkgFakeElectronPtEta->SetDirectory(0);
for (int n=0;n<electronTree->GetEntries();n++) {
if (n%250000 == 0) cout << "Entry " << n << endl;
ele.GetEntry(n);
if (useReweightFactor) {
Double_t reweightFactor = PtEtaReweightFactor->GetBinContent(PtEtaReweightFactor->GetXaxis()->FindFixBin(ele.electron_branch_pt),PtEtaReweightFactor->GetYaxis()->FindFixBin(ele.electron_branch_eta));
ele.electron_branch_weight = ele.electron_branch_weight*reweightFactor;//*overallWJetsNormalizationFactor;
} else {
ele.electron_branch_weight = normalizationWeight;
}
reweightedTree->Fill();
ReweightedBkgFakeElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight);
}
reweightedTree->Write();
cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << reweightedTree->GetEntries() << endl;
outputFile->Close();
TCanvas *cv = new TCanvas("BkgReweightedFakeElectronPtEta", "BkgReweightedFakeElectronPtEta", 0,0,800,600);
ReweightedBkgFakeElectronPtEta->ProjectionX()->DrawCopy("E1");
cv->SaveAs("BkgReweightedFakeElectronPt.gif");
ReweightedBkgFakeElectronPtEta->ProjectionY()->DrawCopy("E1");
cv->SaveAs("BkgReweightedFakeElectronEta.gif");
}
//For Normalization of Signal sample
else if (sampleType == 2) {
TTree* electronTree = getTreeFromFile(InputFilename.c_str(), kFALSE);
assert(electronTree);
MitNtupleElectron ele(electronTree);
//*************************************************************************************************
//Create new reweighted tree
//*************************************************************************************************
TFile *outputFile = new TFile(OutputFilename.c_str(), "RECREATE");
TTree *reweightedTree = electronTree->CloneTree(0);
if (normalizationFile == "") {
//normalize according to total number of electrons expected in WW -> ee nunu signal
Double_t totalWeight = 0;
for (int n=0;n<electronTree->GetEntries();n++) {
ele.GetEntry(n);
totalWeight += ele.electron_branch_weight;
}
cout << "Input Bkg Ntuple Total Weight = " << totalWeight << endl;
normalizationWeight = 1126.5 / totalWeight;
} else {
//do pt/eta Reweighting
TFile *reweightInputFile = new TFile(normalizationFile.c_str(), "READ");
assert(reweightInputFile);
TH2F *WWSigElectronPtEta = (TH2F*)reweightInputFile->Get("hWWRealElectronPtEta");
assert(WWSigElectronPtEta);
WWSigElectronPtEta = (TH2F*)(WWSigElectronPtEta->Clone());
WWSigElectronPtEta->SetDirectory(0);
reweightInputFile->Close();
//Create histogram for reweighting factor
PtEtaReweightFactor = (TH2F*)WWSigElectronPtEta->Clone();
PtEtaReweightFactor->SetName("PtEtaReweightFactor");
PtEtaReweightFactor->SetDirectory(0);
TH2F *SigSampleElectronPtEta = new TH2F("SigSampleElectronPtEta", ";Pt [GeV/c];#eta;" , WWSigElectronPtEta->GetXaxis()->GetNbins(), WWSigElectronPtEta->GetXaxis()->GetBinLowEdge(1), WWSigElectronPtEta->GetXaxis()->GetBinUpEdge(WWSigElectronPtEta->GetXaxis()->GetNbins()), WWSigElectronPtEta->GetYaxis()->GetNbins(), WWSigElectronPtEta->GetYaxis()->GetBinLowEdge(1), WWSigElectronPtEta->GetYaxis()->GetBinUpEdge(WWSigElectronPtEta->GetYaxis()->GetNbins()));
SigSampleElectronPtEta->SetDirectory(0);
for (int n=0;n<electronTree->GetEntries();n++) {
ele.GetEntry(n);
SigSampleElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight);
}
PtEtaReweightFactor->Divide(WWSigElectronPtEta, SigSampleElectronPtEta, 1.0,1.0,"B");
useReweightFactor = kTRUE;
}
cout << "Reweighting Signal Ntuple\n";
outputFile->cd();
//check Reweighting
TH2F *ReweightedSigRealElectronPtEta = new TH2F("ReweightedSigRealElectronPtEta", ";Pt [GeV/c];#eta;" , 200, 0, 200, 200, -3.0, 3.0);
ReweightedSigRealElectronPtEta->SetDirectory(0);
for (int n=0;n<electronTree->GetEntries();n++) {
if (n%250000 == 0) cout << "Entry " << n << endl;
ele.GetEntry(n);
if (useReweightFactor) {
Double_t reweightFactor = PtEtaReweightFactor->GetBinContent(PtEtaReweightFactor->GetXaxis()->FindFixBin(ele.electron_branch_pt),PtEtaReweightFactor->GetYaxis()->FindFixBin(ele.electron_branch_eta));
ele.electron_branch_weight = ele.electron_branch_weight*reweightFactor;//*overallWJetsNormalizationFactor;
} else {
ele.electron_branch_weight = normalizationWeight;
}
reweightedTree->Fill();
ReweightedSigRealElectronPtEta->Fill(ele.electron_branch_pt, ele.electron_branch_eta, ele.electron_branch_weight);
}
reweightedTree->Write();
cout << "Original Tree Entries: " << electronTree->GetEntries() << " Normalized Tree Entries: " << reweightedTree->GetEntries() << endl;
outputFile->Close();
TCanvas *cv = new TCanvas("BkgReweightedFakeElectronPtEta", "BkgReweightedFakeElectronPtEta", 0,0,800,600);
ReweightedSigRealElectronPtEta->ProjectionX()->DrawCopy("E1");
cv->SaveAs("SigReweightedRealElectronPt.gif");
ReweightedSigRealElectronPtEta->ProjectionY()->DrawCopy("E1");
cv->SaveAs("SigReweightedRealElectronEta.gif");
}
else {
cout << "Warning: Specified sampleType " << sampleType << " is not recognized.\n";
}
}