Exemplo n.º 1
0
void updateweight(TString filename)
{
  auto f = new TFile(filename,"update");

  auto nt = (TTree *)f->Get("nt");

  float prew, weight;
  TBranch *bw;

  bw =  nt->Branch("weight",&weight);
  nt->SetBranchAddress("prew",&prew);
  
  int n = nt->GetEntries();
  int onep = n/100;
  for (int i=0;i<n;i++) {
    if (i%onep==0) cout<<i/onep<<endl;
    nt->GetEntry(i);
    weight = prew;
    bw->Fill();
  }

  nt->Write();
  f->Close();


}
Exemplo n.º 2
0
void ResultFormatter::AddBranch( TTree* inputTree, const string& BranchName, const vector<double>& DoubleData )
{
	if( inputTree->GetEntries() != 0 )
	{
		if( inputTree->GetEntries() != (int) DoubleData.size() )
		{
			cerr << "CANNOT ADD DOUBLE BRANCH: " << BranchName << " TO: " << inputTree->GetName() << endl;
			return;
		}
	}

	TString branchName( BranchName );
	TString branchLabel=branchName; branchLabel.Append("/D");

	double thisValue=0.;

	TBranch* newBranch = inputTree->Branch( branchName, &thisValue, branchLabel );

	inputTree->SetEntries( (int) DoubleData.size() );

	for( unsigned int i=0; i< DoubleData.size(); ++i )
	{
		thisValue=DoubleData[i];
		newBranch->Fill();
	}
	return;
}
Exemplo n.º 3
0
int reader_wrapper::GetEntry(Long64_t e) {
  /// don't care about spectators here
  for (auto b: m_branches) {
    b->GetEntry(e);
  }
  for (auto& v : m_variables) {
    v.value = v.ttreeformula->EvalInstance();
  }
  m_response = m_reader->EvaluateMVA(m_methodName.Data());
  m_responseBranch->Fill();
  return 0;
}
void addBranchToTreesInFiles() {
  //************************************************************
  //                      Variables                           //
  vector<TString> fileName;
  fileName.push_back( "PhotonJetPt15_realPhotons.root" );
  fileName.push_back( "PhotonJetPt30_realPhotons.root" );

  // The following 4 variables set the scale
  float invLuminosityToScaleTo = 200; // in pb-1

  vector<float> crossSection;
  crossSection.push_back( 2.9E5 );
  crossSection.push_back( 3.2E4 );

  vector<float> filterEffeciency;
  filterEffeciency.push_back( 1.0 );
  filterEffeciency.push_back( 1.0 );

  vector<float> eventsAnalyzied;
  eventsAnalyzied.push_back( 950E3 );
  eventsAnalyzied.push_back( 670E3 );
  // END of setting scale

  TString treeName = "TreePhotonMatched";

  //                  END of Variables                        //
  //************************************************************


  // Loop over all the Files
  for (int i=0; i < fileName.size(); i++) {
    TFile* currentFile = new TFile(fileName[i],"update");

    // this is the variable to be added
    Float_t scale=crossSection[i]*invLuminosityToScaleTo*filterEffeciency[i]/eventsAnalyzied[i];

    cout << "Opened " << fileName[i] << ", adding new branch with value=" << scale;

    TTree *tree = (TTree*)currentFile->Get(treeName);
    TBranch *newBranch = tree->Branch("weight", &scale,"weight/F");

    // Loop over all the entries, and add the new branch
    Int_t numEntries = (Int_t)tree->GetEntries();
    for (Int_t j=0; j<numEntries; j++) {
      newBranch->Fill();
    }
    tree->Write("",TObject::kOverwrite); // save new version only
    currentFile->Close();
    cout << "...closed file." << endl;
  }
}
Exemplo n.º 5
0
void addDiMuMassPrimeBranchZPt(DiMuPlottingSystem* dps)
{
  TTree* newtree = new TTree("newtree", "new tree");
  newtree->AddFriend(dps->treename, dps->infilename);

  TBranch *newBranch = newtree->Branch("recoCandMassPrime",&dps->recoCandMassPrime,"recoCandMassPrime/F");

  Int_t nentries = dps->tree->GetEntries();
  std::cout << "nentries: " << nentries << std::endl;
  for (Int_t i = 0; i < nentries; i++)
    {
      dps->tree->GetEntry(i);
      if(dps->recoCandPt > 20 && dps->recoCandPt < 60) dps->recoCandMassPrime = dps->recoCandMass + 0.0000917686*(dps->recoCandPt*dps->recoCandPt)*TMath::Sin(-6.43015*TMath::Sqrt(dps->recoCandPt) + 0.210496);
      else dps->recoCandMassPrime = dps->recoCandMass;
      newBranch->Fill();
    }
  dps->tree = newtree;
}
Exemplo n.º 6
0
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();
  
}
Exemplo n.º 7
0
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();
  
}
Exemplo n.º 8
0
void addBranch() {
  //TFile *f = TFile::Open("TTbar_madgraphMLM_1000pb_weighted.root","update");
  //TFile *f = TFile::Open("QCD_1000pb_weighted.root","update");
  TFile *f = TFile::Open("GluGluHToBB_M125_13TeV_powheg_pythia8_1000pb_weighted.root","update"); 
  TTree *T = (TTree*)f->Get("otree");
  double AK8Puppijet0_tau21,AK8Puppijet0_msd,AK8Puppijet0_pt;
  double AK8Puppijet0_tau21DDT = 999;
  TBranch *bpt = T->Branch("AK8Puppijet0_tau21DDT",&AK8Puppijet0_tau21DDT,"AK8Puppijet0_tau21DDT/D");
  T->SetBranchAddress("AK8Puppijet0_tau21",&AK8Puppijet0_tau21);
  T->SetBranchAddress("AK8Puppijet0_msd",&AK8Puppijet0_msd);
  T->SetBranchAddress("AK8Puppijet0_pt",&AK8Puppijet0_pt);
  Long64_t nentries = T->GetEntries();
  for (Long64_t i=0;i<nentries;i++) {
     T->GetEntry(i);
     if (AK8Puppijet0_pt > 0. && AK8Puppijet0_msd > 0.)
       AK8Puppijet0_tau21DDT = AK8Puppijet0_tau21 + 0.063*TMath::Log(AK8Puppijet0_msd*AK8Puppijet0_msd/AK8Puppijet0_pt);
     bpt->Fill();
  }
  T->Print();
  T->Write();
  delete f;
}
Exemplo n.º 9
0
void updatePbPbBtriggerweight(TString filename, vector<float> w)
{
  auto f = new TFile(filename,"update");

  auto nt = (TTree *)f->Get("nt");

  float csv60, csv80;
  float triggermatched;
  float weight;
  TBranch *bw;

  bw =  nt->Branch("weight",&weight);

  nt->SetBranchAddress("hltCSV60",&csv60);
  nt->SetBranchAddress("hltCSV80",&csv80);
  nt->SetBranchAddress("triggermatched",&triggermatched);
  
  int n = nt->GetEntries();
  int onep = n/100;
  for (int i=0;i<n;i++) {
    if (i%onep==0) cout<<i/onep<<endl;
    nt->GetEntry(i);


    weight = 0;
    if (triggermatched && csv80) weight = w[1];
    if (triggermatched && csv60 && !csv80) weight = w[0];

    bw->Fill();
  }

  nt->Write();
  f->Close();


}
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;
} 
Exemplo n.º 11
0
int main(int argc, char** argv){ 
 //Check if all nedeed arguments to parse are there                                                                                                                               
 if(argc != 2)
 {
  std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ;
  return 1;
 }
 
 
 std::cout << "  " << std::endl;
 std::cout << "  " << std::endl;
 std::cout << "         \\         |      |     \\ \\        /     _)         |      |    " << std::endl;
 std::cout << "        _ \\     _` |   _` |      \\ \\  \\   /  _ \\  |   _` |  __ \\   __|  " << std::endl;
 std::cout << "       ___ \\   (   |  (   |       \\ \\  \\ /   __/  |  (   |  | | |  |    " << std::endl;
 std::cout << "     _/    _\\ \\__,_| \\__,_|        \\_/\\_/  \\___| _| \\__, | _| |_| \\__|  " << std::endl;
 std::cout << "                                                    |___/               " << std::endl;
 std::cout << " " << std::endl;
 std::cout << " " << std::endl;
 std::cout << " " << std::endl;
 
 
 
 // Parse the config file                                                                                                                                                          
 parseConfigFile (argv[1]) ;
 
 std::string treeName     = gConfigParser -> readStringOption("Input::treeName");
 std::string treeNameDir  = "";
 try {
  treeNameDir = gConfigParser -> readStringOption("Input::treeNameDir");
 }
 catch (char const* exceptionString){
  std::cerr << " exception = " << exceptionString << std::endl;
 }
 std::cout << ">>>>> input::treeNameDir  " << treeNameDir  << std::endl;  
 
 
 std::string fileSamples = gConfigParser -> readStringOption("Input::fileSamples");
 std::string inputDirectory = gConfigParser -> readStringOption("Input::inputDirectory");
 
 TTree *treeJetLepVect[1000];
 
 char nameFileIn[1000];
 char *nameSample[1000];
 int PUScenarioIndex[1000];
 sprintf(nameFileIn,"%s",fileSamples.c_str());
 int numberOfSamples = ReadFileWeight(nameFileIn, nameSample, PUScenarioIndex); 
 
 std::cout << std::endl;
 std::cout << " numberOfSamples = " << numberOfSamples << std::endl;
 std::cout << std::endl;
 
//  std::cout << " PUScenarioIndex[0] = " << PUScenarioIndex[0]  << std::endl;
   
 ///==== PU reweight (begin) ====
 int numPUScenarios   = gConfigParser -> readIntOption("PU::PUScenarios");

 std::vector<std::string> PUVAR;
 std::vector<double> PUMC[100];
 std::vector<double> PUDATA[100];
 PUclass PU[100];
 
 for (int iScPU = 0; iScPU < numPUScenarios; iScPU++) {
  TString namePU;
  namePU = Form("PU::PUMC%d",iScPU);
  PUMC[iScPU]   = gConfigParser -> readDoubleListOption(namePU.Data());
  namePU = Form("PU::PUDATA%d",iScPU);
  PUDATA[iScPU] = gConfigParser -> readDoubleListOption(namePU.Data());
  namePU = Form("PU::PUVAR%d",iScPU);
  std::string tempName = gConfigParser -> readStringOption(namePU.Data());
  PUVAR.push_back(tempName);
  
  if (PUMC[iScPU].size() != PUDATA[iScPU].size()) {
   std::cout << " PUVAR["  << iScPU << "]        = " << PUVAR.at(iScPU) << std::endl;
   std::cout << " PUMC["   << iScPU << "].size() = " << PUMC[iScPU].size()   << std::endl;
   std::cout << " PUDATA[" << iScPU << "].size() = " << PUDATA[iScPU].size() << std::endl;
   std::cerr << " ERROR " << std::endl;
   return 1;
  }
  
  double sumPUMC = 0;
  for (int itVPU = 0; itVPU < PUMC[iScPU].size(); itVPU++ ){
   sumPUMC += PUMC[iScPU].at(itVPU);  
  }
  double sumPUDATA = 0;
  for (int itVPU = 0; itVPU < PUDATA[iScPU].size(); itVPU++ ){
   sumPUDATA += PUDATA[iScPU].at(itVPU);  
  } 
  
  for (int itVPU = 0; itVPU < PUMC[iScPU].size(); itVPU++ ){
   PU[iScPU].PUWeight.push_back(PUDATA[iScPU].at(itVPU) / PUMC[iScPU].at(itVPU) * sumPUMC / sumPUDATA);
  }
 }
 
 ///==== PU reweight (end) ====
 
 
 ///==== debug flag ==== 
 bool  debug = false; 
 try {
  debug = gConfigParser -> readBoolOption("Input::debug");
 }
 catch (char const* exceptionString){
  std::cerr << " exception = " << exceptionString << std::endl;
 }
 std::cout << ">>>>> input::debug  " << debug  << std::endl;  
 
 
 for (int iSample=0; iSample<numberOfSamples; iSample++){
  std::cout << " nameSample[" << iSample << ":" << numberOfSamples << "] = " << nameSample[iSample] << std::endl;
  
  ///==== GetTree (begin) ==== 
  char nameFile[20000];
  sprintf(nameFile,"%s/out_%s.root",inputDirectory.c_str(),nameSample[iSample]);  
  std::cout << " nameFile = " << nameFile << std::endl;
  TFile* f = new TFile(nameFile, "update");
  f->cd(treeNameDir.c_str());
  
  treeJetLepVect[iSample] = (TTree*) f->Get(treeName.c_str());
//   char nameTreeJetLep[100];
//   sprintf(nameTreeJetLep,"treeJetLep_%d",iSample); 
//   treeJetLepVect[iSample]->SetName(nameTreeJetLep);
  ///==== GetTree (end) ====
  
  std::cout << " >>>>> GetEntries " << treeJetLepVect[iSample]->GetEntries() << std::endl;   
  
  double weight;
//   TBranch *newBranch;
  ///==== add new branch ====
  TBranch *newBranch = treeJetLepVect[iSample] -> Branch("weight_PU",&weight,"weight_PU/D");
  int numPUMC;
  treeJetLepVect[iSample] -> SetBranchAddress(PUVAR.at(PUScenarioIndex[iSample]).c_str(),&numPUMC);
  Long64_t nentries = treeJetLepVect[iSample]->GetEntries();
  for (Long64_t iEntry = 0; iEntry < nentries; iEntry++){
   if((iEntry%((nentries+10)/10)) == 0) std::cout << ">>>>> analysis::GetEntry " << iEntry << " : " << nentries << std::endl;   
   treeJetLepVect[iSample]->GetEntry(iEntry);
   weight = PU[ PUScenarioIndex[iSample] ].getPUWeight(numPUMC);
   newBranch->Fill();
  }
  // save only the new version of the tree
  treeJetLepVect[iSample]->Write("", TObject::kOverwrite);
 }
 
 
 std::cout << " *** end *** " << std::endl;
}
void flagMultCands( TString fname, TString tname ) {

  TFile *inFile = new TFile( fname, "UPDATE" );
  TTree *tree = (TTree*)inFile->Get( tname );

  if ( tree->FindBranch( "pass_multcand" ) ) {
    cout << "pass_multcand branch already exists so I won't add it" << endl;
    delete inFile;
    return;
  }

  ULong64_t  eventNumber;
  int        itype;
  bool       pass_bdt;
  bool       pass_pid;
  bool       pass_rhokst;
  bool       pass_massveto;
  UInt_t     nCandidate;
  ULong64_t  totCandidates;
  tree->SetBranchAddress(  "eventNumber"                 , &eventNumber                 );
  tree->SetBranchAddress(  "itype"                       , &itype                       );
  tree->SetBranchAddress(  "pass_bdt"                    , &pass_bdt                    );
  tree->SetBranchAddress(  "pass_pid"                    , &pass_pid                    );
  tree->SetBranchAddress(  "pass_rhokst"                 , &pass_rhokst                 );
  tree->SetBranchAddress(  "pass_massveto"               , &pass_massveto               );
  tree->SetBranchAddress(  "totCandidates"               , &totCandidates               );
  tree->SetBranchAddress(  "nCandidate"                  , &nCandidate                  );

  map< ULong64_t, ULong64_t > multCandEventNumbers;

  cout << "Finding multiple candidates" << endl;
  // first loop tree and save number of all multiple candidates
  for ( int ev=0; ev<tree->GetEntries(); ev++ ) {
    tree->GetEntry(ev);
    if ( ev%10000==0 ) cout << ev << "/" << tree->GetEntries() << endl;
    //if ( itype>0 && pass_bdt && pass_pid && (!pass_rhokst) && (!pass_massveto) && totCandidates > 1 ) {
    if ( itype>0 && pass_bdt && pass_pid && (!pass_massveto) && totCandidates > 1 ) {
      multCandEventNumbers[eventNumber] = totCandidates;
    }
  }

  // now randomly select which one to keep
  map< ULong64_t, UInt_t > eventToKeep;
  TRandom3 rand;
  rand.SetSeed(2016);
  for ( map<ULong64_t,ULong64_t>::iterator it=multCandEventNumbers.begin(); it!=multCandEventNumbers.end(); it++) {
    UInt_t keep = rand.Integer( it->second );
    eventToKeep[it->first] = keep;
  }

  cout << "Adding flag pass_multcand to tree" << endl;
  // then loop again and write the random choice back in
  bool pass_multcand;
  TBranch *bpt = tree->Branch( "pass_multcand", &pass_multcand, "pass_multcand/O" );

  for ( int ev=0; ev<tree->GetEntries(); ev++ ) {
    tree->GetEntry(ev);
    if ( ev%10000==0 ) cout << ev << "/" << tree->GetEntries() << endl;
    pass_multcand = true;
    if ( totCandidates > 1 && eventToKeep[eventNumber] != nCandidate ) pass_multcand = false;
    bpt->Fill();
  }
  tree->Write();
  delete inFile;
}
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;
} 
Exemplo n.º 14
0
//Arguments: a comma-separated list of energies, a comma-separated list of
//beam heights.
void CollectRuns(string Energies, string Heights){
  vector<string> theEnergy;
  vector<string> theHeight;
  vector<double> valEnergy;
  vector<double> valHeight;

  string line;
  //Get the energies
  istringstream ssEn(Energies);
  //ssEn << (Energies);
  while(getline(ssEn, line, ',')){
    theEnergy.push_back(line);
    //now cast line to a double:
    stringstream ss;
    double dummy;
    ss << line;
    ss >> dummy;
    valEnergy.push_back(dummy);
  }
  //Get the heights
  istringstream ssHgt(Heights);
  while(getline(ssHgt, line, ',')){
    theHeight.push_back(line);
    //now cast line to a double:
    stringstream ss;
    double dummy;
    ss << line;
    ss >> dummy;
    valHeight.push_back(dummy);
  }

  //Initialise the output tree.
  TChain* OutChain = new TChain("ChainResults", "The collected run results");

  for(size_t i=0; i<theEnergy.size(); i++){
    for(size_t j=0; j<theHeight.size(); j++){

      string fname = "Edep_" + theEnergy.at(i) + "MeV_" + theHeight.at(j)
	+ "cm.root";

      cout << "Processing File: " << fname << "... ";

      TFile* infile = TFile::Open(fname.c_str(), "update");
      TTree* inTree = (TTree*)infile->Get("Results");

      //Clean up any old branches...
      //TBranch* OldBranch;
      //if(inTree->GetListOfBranches()->FindObject("BeamEn")){
      //OldBranch = inTree->GetBranch("BeamEn");
      //inTree->GetListOfBranches()->Remove(OldBranch);
      //inTree->Write();
      //}
      //if(inTree->GetListOfBranches()->FindObject("BeamHgt")){
      //OldBranch = inTree->GetBranch("BeamHgt");
      //inTree->GetListOfBranches()->Remove(OldBranch);
      //inTree->Write();
      //}
      //if(inTree->GetListOfBranches()->FindObject("MeanPE_T1")){
      //OldBranch = inTree->GetBranch("MeanPE_T1");
      //inTree->GetListOfBranches()->Remove(OldBranch);
      //inTree->Write();
      //}
      //if(inTree->GetListOfBranches()->FindObject("MeanPE_T2")){
      //OldBranch = inTree->GetBranch("MeanPE_T2");
      //inTree->GetListOfBranches()->Remove(OldBranch);
      //inTree->Write();
      //}
      

      float BeamEn = 0;
      float BeamHgt = 0;
      float MeanT1 = 0;
      float MeanT2 = 0;
      //Add an energy and beam height branch to the tree.
      TBranch* EnBranch = inTree->Branch("BeamEn", &BeamEn, "BeamEn/F");
      TBranch* HgtBranch = inTree->Branch("BeamHgt", &BeamHgt, "BeamHgt/F");
      TBranch* MeanPE_T1 = 
	inTree->Branch("MeanPE_T1", &MeanT1, "MeanPE_T1/F");
      TBranch* MeanPE_T2 =
	inTree->Branch("MeanPE_T2", &MeanT2, "MeanPE_T2/F");
      unsigned long long int measPE_T1 = 0;
      unsigned long long int measPE_T2 = 0;
      double Edep_H1 =0;
      double Edep_H2 = 0;

      inTree->SetBranchAddress("MeasNumPhotons_PMTT1", &measPE_T1);
      inTree->SetBranchAddress("MeasNumPhotons_PMTT2", &measPE_T2);
      inTree->SetBranchAddress("Edep_H1", &Edep_H1);      
      inTree->SetBranchAddress("Edep_H2", &Edep_H2);
      Long64_t nentries = inTree->GetEntries();
      int numAvg = 0;
      for(int k = 0; k<nentries; k++){
	inTree->GetEntry(k);
	//Calculate means
	if((Edep_H1!=0)&&(Edep_H2!=0)){
	  MeanT1 += measPE_T1;
	  MeanT2 += measPE_T2;
	  numAvg++;
	}
      }

      MeanT1 = MeanT1/numAvg;
      MeanT2 = MeanT2/numAvg;

      for(int k = 0; k<nentries; k++){
	BeamEn = valEnergy.at(i);
	BeamHgt = valHeight.at(j);
	EnBranch->Fill();
	HgtBranch->Fill();
	MeanPE_T1->Fill();
	MeanPE_T2->Fill();
      }

      inTree->Write("", TObject::kOverwrite);
	
      fname = fname + "/Results";
      OutChain->Add(fname.c_str());
      infile->Close();
      cout << "Done!" << endl;
    }
  }
  cout << "OutChain has " << OutChain->GetEntries() << " entries." << endl;
  TFile* OutFile = new TFile("ChainedRuns.root", "RECREATE");
  OutChain->Write();
  OutFile->Close();
  return;
}
Exemplo n.º 15
0
int mergeDigits(TString digitdir, Int_t /*simEvOffset*/)
{

    AliRunLoader *rl = AliRunLoader::Open(digitdir+TString("/galice.root"));

    AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");

    prl->LoadDigits("UPDATE");
    
    //prl->LoadDigits();

    Int_t nEvents = rl->GetNumberOfEvents();

    TClonesArray *mydigits = 0;
    simTree->SetBranchAddress("Digits", &mydigits);

    Int_t nDigits = 0;
    Int_t nEmbedDigits = 0;
    Int_t nOverlappingDigits = 0;
    Int_t nNewDigits = 0;
    
    Int_t nPhosDigits = prl->Digits()->GetEntries();

    Int_t nMyEvents = simTree->GetEntries();
    
    std::cout << "Number of real events: " << nEvents << std::endl;
    std::cout << "Number of sim events: " << nMyEvents << std::endl;
    nEvents = TMath::Min(nEvents, nMyEvents);
    std::cout << "Looping over: " << nEvents << std::endl;
	
    for (Int_t ev = 0; ev < nEvents; ev++)
    {
        rl->GetEvent(ev);
        
        simTree->GetEntry(ev);
        Int_t nMyDigits = mydigits->GetEntries();

        //Int_t nDigsFound = 0;
        nEmbedDigits += nMyDigits;
        TClonesArray *phosDigits = prl->Digits();
	nPhosDigits = prl->Digits()->GetEntries();
	
        for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
        {
            //const AliPHOSDigit *digit = prl->Digit(iDig);
            AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(iDig);
            nDigits++;
            for (Int_t n = 0; n < nMyDigits; n++)
            {
                AliPHOSDigit *myDigit = (AliPHOSDigit*)mydigits->At(n);
                if (digit->GetId() == myDigit->GetId())
                {
                    nOverlappingDigits++;
                    break;
                }
            }
        }
        if(nOverlappingDigits == nMyDigits)
        {
            std::cout << "Digits alredy embedded!" << std::endl;
            continue;
        }
        for (Int_t iDig = 0; iDig < nMyDigits; iDig++)
        {
            AliPHOSDigit *myDigit = (AliPHOSDigit*)mydigits->At(iDig);
            if (myDigit)
            {
                for (Int_t n = 0; n < nPhosDigits; n++)
                {
                    //const AliPHOSDigit *digit = prl->Digit(n);

                    AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(n);
                    if (digit->GetId() == myDigit->GetId())
                    {
                        digit->SetALTROSamplesHG(0, 0);
                        digit->SetALTROSamplesLG(0, 0);

                        *digit += *myDigit;
                        myDigit = 0;
                        break;
                    }
                }
                if (myDigit)
                {
                    TClonesArray *digArray = prl->Digits();
                    AliPHOSDigit *newDig =  new((*digArray)[nPhosDigits+nNewDigits]) AliPHOSDigit(*myDigit);

                    newDig->SetALTROSamplesHG(0, 0);
                    newDig->SetALTROSamplesLG(0, 0);
                    nNewDigits++;
                }
            }
        }
        phosDigits->Compress();
        Int_t ndigits = phosDigits->GetEntries() ;
	phosDigits->Sort();
        // Remove digits that are flagged bad in BCM. Then remove digits that are below threshold
        for (Int_t i = 0 ; i < ndigits ; i++)
        {
            AliPHOSDigit *digit = static_cast<AliPHOSDigit*>( phosDigits->At(i) ) ;
	    //std::cout << digit->GetId() << std::endl;
            if(digit->GetId())
            {
                vector<Int_t>::iterator it;
                it = std::find (badChannels.begin(), badChannels.end(), digit->GetId() );
                if(*it)
                {
                    digit->SetEnergy(0.0);
                }
            }
            if(digit->GetEnergy() <= recoParam->GetGlobalAltroThreshold())
	    {
	      phosDigits->RemoveAt(i);
	    }
        }
        //Set indexes in list of digits and make true digitization of the energy
        phosDigits->Compress();
        phosDigits->Sort();
	ndigits = phosDigits->GetEntries();
        for (Int_t i = 0 ; i < ndigits ; i++)
        {
            AliPHOSDigit *digit = static_cast<AliPHOSDigit*>( phosDigits->At(i) ) ;
            digit->SetIndexInList(i) ;
        }
        // -- create Digits branch
        Int_t bufferSize = 32000 ;

        TObjArray *branchList = prl->TreeD()->GetListOfBranches();

        branchList->RemoveAt(0);

        TBranch * digitsBranch = prl->TreeD()->Branch("PHOS","TClonesArray",&phosDigits,bufferSize);

        digitsBranch->Fill() ;
        prl->WriteDigits("OVERWRITE");
    }
    prl->WriteDigits("OVERWRITE");
    std::cout << "# Digits: " << nDigits << std::endl;
    std::cout << "# Embedded digits: " << nEmbedDigits << std::endl;
    std::cout << "# Overlapping digits: " << nOverlappingDigits << std::endl;
    std::cout << "# New digits: " << nNewDigits << std::endl;
    
    return 0;
}
Exemplo n.º 16
0
int weighPthat(TString ifname = "/data/wangj/MC2015/Dntuple/pp/ntD_pp_Dstar_D0kpi/ntD_EvtBase_20160112_Dfinder_20151229_pp_Pythia8D0kpi_noweight.root",
               TString ofname = "/afs/cern.ch/work/w/wangj/public/RunII/weighPthat/ntD_EvtBase_20160112_Dfinder_20151229_pp_Pythia8D0kpi_withweight.root")
{
    Bool_t isInsidebin(Float_t xpthat, Int_t i);
    cout<<endl;
    cout<<" -- Checking if input and output files are same"<<endl;
    if(ifname==ofname)
    {
        cout<<"    Error: Input file will be overwritten."<<endl;
        return 0;
    }
    cout<<" -- Opening unweighed sample"<<endl;
    TFile* inf = TFile::Open(ifname);
    TTree* ntHi = (TTree*)inf->Get("ntHi");
    Float_t pthat;
    ntHi->SetBranchAddress("pthat",&pthat);
    Float_t weight[nBins],nweight[nBins];
    for(Int_t j=0; j<nBins; j++)
    {
        weight[j]=0;
        nweight[j]=0;
    }
    Int_t nentries = ntHi->GetEntries();
    cout<<" -- Calculating weights"<<endl;
    for(Int_t i=0; i<nentries; i++)
    {
        ntHi->GetEntry(i);
        if(i%100000==0) cout<<"    Processing event "<<setiosflags(ios::left)<<setw(7)<<i<<" / "<<nentries<<endl;
        for(Int_t j=0; j<nBins; j++)
        {
            if(isInsidebin(pthat,j)) nweight[j]++;
        }
    }
    cout<<" -- Weight results"<<endl;
    for(Int_t j=0; j<nBins; j++)
    {
        if(nweight[j]==0)
        {
            cout<<"    Error: Weight fails."<<endl;
            return 0;
        }
        weight[j] = (crosssec[j]-crosssec[j+1])/nweight[j];
        cout<<"    Pthat"<<setiosflags(ios::left)<<setw(3)<<pthatBin[j]<<": "<<weight[j]<<endl;
    }

    cout<<" -- Building weight branch"<<endl;
    TFile* otf = TFile::Open(ofname,"update");
    TTree* ntHinew = (TTree*)otf->Get("ntHi");
    Float_t pthatweight;
    TBranch* newBranch = ntHinew->Branch("pthatweight", &pthatweight, "pthatweight/F");
    cout<<" -- Filling weight branch"<<endl;
    for(Int_t i=0; i<nentries; i++)
    {
        ntHi->GetEntry(i);
        if(i%100000==0) cout<<"    Processing event "<<setiosflags(ios::left)<<setw(7)<<i<<" / "<<nentries<<endl;
        pthatweight=0;
        for(Int_t j=0; j<nBins; j++)
        {
            if(isInsidebin(pthat,j)) pthatweight = weight[j];
        }
        newBranch->Fill();
    }
    ntHinew->Write("", TObject::kOverwrite);

    cout<<" -- End"<<endl;
    cout<<endl;
    return 1;
}
void TMVAClassificationApplication_cc1pcoh_bdt_ver3noveractFFFSI( TString myMethodList = "", TString fname)
{
#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;
    //
    // --- 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 mumucl, pmucl;
    Float_t pang_t, muang_t;
    Float_t veract;
    Float_t ppe, mupe;
    Float_t range, coplanarity;
    Float_t opening;//newadd
    
    reader->AddVariable( "mumucl", &mumucl );
    reader->AddVariable( "pmucl", &pmucl );
    reader->AddVariable( "pang_t", &pang_t );
    reader->AddVariable( "muang_t", &muang_t );
    //reader->AddVariable( "veract", &veract );
    reader->AddVariable( "ppe", &ppe);
    reader->AddVariable( "mupe", &mupe);
    reader->AddVariable( "range", &range);
    reader->AddVariable( "coplanarity", &coplanarity);
    reader->AddVariable( "opening", &opening);//newadd
    
    // Spectator variables declared in the training have to be added to the reader, too
    Int_t fileIndex, inttype;
    Float_t nuE, norm, totcrsne;
    reader->AddSpectator( "fileIndex", &fileIndex );
    reader->AddSpectator( "nuE", &nuE );
    reader->AddSpectator( "inttype", &inttype );
    reader->AddSpectator( "norm", &norm );
    reader->AddSpectator( "totcrsne", &totcrsne );
    reader->AddSpectator( "veract", &veract );
    
    // --- Book the MVA methods
    
    TString dir    = "weights/";
    TString prefix = "TMVAClassification_ver3noveractFFFSI";//newchange
    
    // Book method(s)
    for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {
        if (it->second) {
            TString methodName = TString(it->first) + TString(" method");
            TString weightfile = dir + prefix + TString("_") + TString(it->first) + TString(".weights.xml");
            reader->BookMVA( methodName, weightfile );
        }
    }
    
    // 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.
    //
    

    
    
    //for prange/pang_t corrected and other information included
    
    //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/datamc_merged_ccqe_addpidFFnew.root";
    //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/datamc_genie_merged_ccqe_addpidFFnew.root";
    //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/mc_merged_ccqe_addpidFFnew.root";
    //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/mcgenie_merged_ccqe_tot_addpidFFnew.root";
    //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/merged_ccqe_forResponseFunction.root";
   //TString fname = "/home/cvson/scraid2/cc1picoh/FIT/datafsi/pmnue_merged_ccqe_tot_addpidFFnew.root"; 
    std::cout << "--- Selecting data sample" << std::endl;
    TFile *pfile = new TFile(fname,"update");
    TTree* theTree = (TTree*)pfile->Get("tree");
    theTree->SetBranchAddress( "mumucl", &mumucl );
    theTree->SetBranchAddress( "pmucl", &pmucl );
    theTree->SetBranchAddress( "pang_t", &pang_t );
    theTree->SetBranchAddress( "muang_t", &muang_t );
    theTree->SetBranchAddress( "veract", &veract );
    theTree->SetBranchAddress( "ppe", &ppe);
    theTree->SetBranchAddress( "mupe", &mupe);
    theTree->SetBranchAddress( "range", &range);
    theTree->SetBranchAddress( "coplanarity", &coplanarity);
    theTree->SetBranchAddress( "opening", &opening);
    
 
    
    Int_t Ntrack;
    theTree->SetBranchAddress( "Ntrack", &Ntrack );
    
    
    Float_t pidfsi;
    TBranch *bpidfsi = theTree->Branch("pidfsi",&pidfsi,"pidfsi/F");
    
    
    
    std::vector<Float_t> vecVar(9); // vector for EvaluateMVA tests
    
    Long64_t nentries = theTree->GetEntriesFast();
    Long64_t iprintProcess = Long64_t(nentries/100.);
    
    std::cout << "--- Processing: " << nentries << " events" << std::endl;
    
    TStopwatch sw;
    sw.Start();
    for (Long64_t ievt=0; ievt<nentries;ievt++) {
        
        if (ievt%iprintProcess == 0) cout<<"Processing "<<int(ievt*100./nentries)<<"% of events"<<endl;
        theTree->GetEntry(ievt);
        Float_t pidfsi_tem;
        if (Use["BDT"])      {
            //if (Ntrack!=2) pidfsi_tem = -999;//changehere
            if (Ntrack<2) pidfsi_tem = -999;
            else pidfsi_tem = reader->EvaluateMVA("BDT method");
        }
        pidfsi = pidfsi_tem;
        bpidfsi->Fill();
        
    }
    theTree->Write();
    delete pfile;
    // Get elapsed time
    sw.Stop();
    std::cout << "--- End of event loop: "; sw.Print();
    
    delete reader;
    
    std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl;
} 
Exemplo n.º 18
0
void makeJetP4(TString InRootFile, double Rparam=0.5) { 
    
    cout << " ... Processing file = " << InRootFile << endl;
    cout << " ... Rparam = " << Rparam << endl;
    cout << " ................................................................." << endl; 
    
    // 
    // Get tree from a cfA ntuple 
    // 
    TFile *f = TFile::Open("../cfA/"+InRootFile, "UPDATE");
    TDirectory* dir = f->GetDirectory("configurableAnalysis");
    dir->cd();
    TTree *eventB = (TTree*)dir->Get("eventB");
    
    // 
    // set address of variables to read 
    // 
    UInt_t   event_ = 0;
    eventB->SetBranchAddress("event", &event_);
    UInt_t   run_ = 0;
    eventB->SetBranchAddress("run", &run_);
    UInt_t   lumiblock_ = 0;
    eventB->SetBranchAddress("lumiblock", &lumiblock_);
    vector<float>   *fastjets_AK5PF_px_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_px", &fastjets_AK5PF_px_);
    vector<float>   *fastjets_AK5PF_py_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_py", &fastjets_AK5PF_py_);
    vector<float>   *fastjets_AK5PF_pz_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_pz", &fastjets_AK5PF_pz_);
    vector<float>   *fastjets_AK5PF_energy_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_energy", &fastjets_AK5PF_energy_);
    vector<float>   *fastjets_AK5PF_phi_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_phi", &fastjets_AK5PF_phi_);
    vector<float>   *fastjets_AK5PF_eta_ = 0;
    eventB->SetBranchAddress("jets_AK5PF_eta", &fastjets_AK5PF_eta_);
    
    // 
    // Define new variables to write 
    // 
    // need this line because ROOT does not know vector<float>
    // one needs to generate dictionary using rootcint or 
    // just include this line 
    // [ref] http://root.cern.ch/phpBB3/viewtopic.php?t=8467
    gROOT->ProcessLine("#include <vector>"); 
    vector<float>   *fastjets_AK5PF_R1p2_px = 0;
    TBranch *pxb =  eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_px",R0p5JetpTcut), &fastjets_AK5PF_R1p2_px);
    vector<float>   *fastjets_AK5PF_R1p2_py = 0;
    TBranch *pyb = eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_py",R0p5JetpTcut), &fastjets_AK5PF_R1p2_py);
    vector<float>   *fastjets_AK5PF_R1p2_pz = 0;
    TBranch *pzb = eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_pz",R0p5JetpTcut), &fastjets_AK5PF_R1p2_pz);
    vector<float>   *fastjets_AK5PF_R1p2_energy = 0;
    TBranch *energyb = eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_energy",R0p5JetpTcut), &fastjets_AK5PF_R1p2_energy);
    vector<float>   *fastjets_AK5PF_R1p2_phi = 0;
    TBranch *phib = eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_phi",R0p5JetpTcut), &fastjets_AK5PF_R1p2_phi);
    vector<float>   *fastjets_AK5PF_R1p2_eta = 0;
    TBranch *etab = eventB->Branch(Form("fastjets_AK5PF_R1p2_pT%i_eta",R0p5JetpTcut), &fastjets_AK5PF_R1p2_eta);

    // 
    // Histgrom : to draw eta-phi plot of energy deposit 
    //  (1) Bin size is 0.087x0.087 to mimic the size of hcal tower
    //  (2) Bin Entry is the sum over energies of PF candidates in a given bin  
    // 
    TH2F *h2 = new TH2F("h2","h2", 115, -5.0, 5.0, 72, -3.141592, 3.141592);
    
    // 
    // Loop over entries
    // 
    Int_t nentries = (Int_t)eventB->GetEntries();
    if(DEBUG) nentries = 10;
    cout<<"The number of entries is: "<<nentries<<endl;

    // main event loop
    for(int ib = 0; ib<nentries; ib++) {
      
        // Counting to see progress
        if(ib%100==0) cout << " ...... " << ib << " events processed "<< endl; 

        // get the entry of event ib
        eventB->GetEntry(ib);
        
        // ---------------------------------------
        //          Block 1 
        // ---------------------------------------
        
        // Open a text file to write information about PF candidates  
        ofstream fout;
        fout.open(Form("OneEvent_FastjetsR0p5_tmp_%i.dat", ib));
        
        // loop over Fastjets with R=0.5
        for(int ifastjets = 0; ifastjets < (int)fastjets_AK5PF_px_->size(); ifastjets++) {
            
            if(TMath::Sqrt( fastjets_AK5PF_px_->at(ifastjets)*fastjets_AK5PF_px_->at(ifastjets) 
                           +fastjets_AK5PF_py_->at(ifastjets)*fastjets_AK5PF_py_->at(ifastjets)) < R0p5JetpTcut) continue; 

            fout.width(15); fout << fastjets_AK5PF_px_->at(ifastjets) << "\t";
            fout.width(15); fout << fastjets_AK5PF_py_->at(ifastjets) << "\t";
            fout.width(15); fout << fastjets_AK5PF_pz_->at(ifastjets) << "\t";
            fout.width(15); fout << fastjets_AK5PF_energy_->at(ifastjets) << endl;
           
            float pt = TMath::Sqrt(fastjets_AK5PF_px_->at(ifastjets)*fastjets_AK5PF_px_->at(ifastjets) 
                                  +fastjets_AK5PF_py_->at(ifastjets)*fastjets_AK5PF_py_->at(ifastjets));
            h2->Fill( fastjets_AK5PF_eta_->at(ifastjets), fastjets_AK5PF_phi_->at(ifastjets), pt);
        }
        fout.close();




        // ---------------------------------------
        //          Block 2 
        // ---------------------------------------

        //
        // Run Fastjet to reconstuct jets 
        //
        // Using the example code "fastjet_example.cc" 
        // It takes OneEvent_PFCands_tmp_%i.dat as an input 
        // and writes p4 of reconstructed jets in  OneEvent_PFJets_tmp_%i.dat. 
        // For the details about the code, take a look at fastjet_example.cc.
        gSystem->Exec(Form("../fastjet_example %f < OneEvent_FastjetsR0p5_tmp_%i.dat > OneEvent_FastjetsR1p2_tmp_%i.dat", Rparam, ib, ib));

        // ---------------------------------------
        //          Block 3 
        // ---------------------------------------

        // 
        // Get p4 of the reconstructed jets  
        //
        string line;
        double id, px, py , pz, energy, eta, phi, ncand;
        ifstream fin(Form("OneEvent_FastjetsR1p2_tmp_%i.dat", ib)); 
        if(fin.is_open()) { 
            while(fin.good()){

                // get a line from fin
                getline(fin, line);
                if(line=="") break; // need this to avoid line without entry 
                // Store each element in the line to the defined variables
                stringstream stream(line);
                stream >> id >> px >> py >> pz >> energy >> eta >> phi >> ncand; 
               
                // store only when pT > 3 GeV 
                // (same as CMS jet reconstruction cut)
                if(TMath::Sqrt(px*px+py*py)>(DEBUG?30:3)) {
                    fastjets_AK5PF_R1p2_px->push_back(px);
                    fastjets_AK5PF_R1p2_py->push_back(py);
                    fastjets_AK5PF_R1p2_pz->push_back(pz);
                    fastjets_AK5PF_R1p2_energy->push_back(energy);
                    fastjets_AK5PF_R1p2_eta->push_back(eta);
                    fastjets_AK5PF_R1p2_phi->push_back(phi); 

                    if(DEBUG) {
                        cout << event_ << " " 
                             << id << " " 
                             << TMath::Sqrt(px*px+py*py) << " " 
                             << eta << " " 
                             << phi << " "  
                             << endl; 
                    }
                }
            }
        }
        // Fill the branches 
        pxb->Fill();
        pyb->Fill();
        pzb->Fill();
        energyb->Fill();
        phib->Fill();
        etab->Fill();
        
        // 
        // Draw a lego plot (eta, phi) 
        //
        if(DEBUG) {
            TCanvas *c = new TCanvas();
            c->cd(1);
            h2->Draw("colz");
            h2->SetTitle(Form("run=%i lumi=%i event=%i R=%.1f", run_, lumiblock_, event_, Rparam));
            h2->SetMaximum(50); 
            h2->SetStats(0); 
            h2->SetXTitle("#eta"); 
            h2->SetYTitle("#phi"); 

            //Draw circles around jets
            TEllipse *cone[fastjets_AK5PF_R1p2_eta->size()]; 
            for(int ijets=0; ijets<(int)fastjets_AK5PF_R1p2_eta->size(); ijets++){
                cone[ijets] = new TEllipse(fastjets_AK5PF_R1p2_eta->at(ijets), fastjets_AK5PF_R1p2_phi->at(ijets), Rparam, Rparam);
                cone[ijets]->SetFillStyle(3003);
                cone[ijets]->SetFillColor(kYellow);
                cone[ijets]->Draw();
            }

            c->SaveAs(Form("EtaPhiViewPFCand_Run%i_Lumi%i_Event%i_R%.1f_usingR0p5.pdf", 
                        run_, lumiblock_, event_, Rparam));
            h2->Reset(); 
            for(int ijets=0; ijets<(int)fastjets_AK5PF_R1p2_eta->size(); ijets++) delete cone[ijets];

        } 
   
        // Clear vectors for the next event 
        fastjets_AK5PF_R1p2_px->clear();
        fastjets_AK5PF_R1p2_py->clear();
        fastjets_AK5PF_R1p2_pz->clear();
        fastjets_AK5PF_R1p2_energy->clear();
        fastjets_AK5PF_R1p2_eta->clear();
        fastjets_AK5PF_R1p2_phi->clear();
        
        // remove text files
        if(!DEBUG) gSystem->Exec("'rm' OneEvent_Fastjets*.dat");
    
    } // event loop

    // update the tree and close file
    if(!DEBUG) eventB->Write();
    f->Close();
    
    //
    // cleanup
    //
    delete f;
}