Exemplo n.º 1
0
void GetBinM(RooUnfoldResponse* &BinM, TH1D* &h_gen, TH1D* &h_reco, RooUnfoldResponse* &BinM_1, TH1D* &h_gen_1, TH1D* &h_reco_1, RooUnfoldResponse* &BinM_2, TH1D* &h_gen_2, TH1D* &h_reco_2, bool madgraph=1, int elec=0){

  TH2D* BinMigration=new TH2D("BinMigration","BinMigration",nbins,0,nbins,nbins,0,nbins);
  BinMigration->Sumw2();
  TH1D* Dphistar=new TH1D("Dphistar","Dphistar",2000,-1,1);
  Dphistar->Sumw2();
  TH1D* Dy=new TH1D("Dy","Dy",2000,-1,1);
  Dy->Sumw2();
  TChain* t = new TChain(reco_name.c_str(),reco_name.c_str());
  int nfiles;
  if (madgraph){
    if (elec==0) nfiles=t->Add(File_Signal_reco_d.c_str());
    if (elec==1) nfiles=t->Add(File_Signal_reco_b.c_str());
    if (elec==2) nfiles=t->Add(File_Signal_reco_n.c_str());
  }
  else {
    if (elec==0) nfiles=t->Add(File_Powheg_reco_d.c_str());
    if (elec==1) nfiles=t->Add(File_Powheg_reco_b.c_str());
    if (elec==2) nfiles=t->Add(File_Powheg_reco_n.c_str());
  }

  TBranch *b_reco=t->GetBranch("reco");
  TBranch *b_truth=t->GetBranch("truth");
  TLeaf *l_phistar=b_reco->GetLeaf("z_phistar_dressed");
  TLeaf *l_phistar_true=b_truth->GetLeaf("z_phistar_dressed");
  if (elec==1) l_phistar_true=b_truth->GetLeaf("z_phistar_born");
  if (elec==2) l_phistar_true=b_truth->GetLeaf("z_phistar_naked");
  TLeaf *l_y=b_reco->GetLeaf("z_y");
  TLeaf *l_y_true=b_truth->GetLeaf("z_y");
  if (elec==1) l_y_true=b_reco->GetLeaf("z_yBorn");
  if (elec==2) l_y_true=b_reco->GetLeaf("z_yNaked");
  int nweights;
  t->SetBranchAddress("weight_size",&nweights);
  t->GetEntry(0);
  cout<<"The sample has nweights: "<<nweights<<endl;
  double weights[nweights];
  int weightid[nweights];
  t->SetBranchAddress("weights",&weights);
  t->SetBranchAddress("weight_ids",&weightid);

  cout<<"Entries: "<<t->GetEntries()<<endl;
  h_gen   = new TH1D("phistar","phistar",nbins,0,nbins);
  h_gen->Sumw2();
  h_reco  = new TH1D("phistar","phistar",nbins,0,nbins);
  h_reco->Sumw2();
  h_gen_1 = new TH1D("phistar","phistar",nbins,0,nbins);
  h_gen_1->Sumw2();
  h_reco_1= new TH1D("phistar","phistar",nbins,0,nbins);
  h_reco_1->Sumw2();
  h_gen_2 = new TH1D("phistar","phistar",nbins,0,nbins);
  h_gen_2->Sumw2();
  h_reco_2= new TH1D("phistar","phistar",nbins,0,nbins);
  h_reco_2->Sumw2();
  BinM  =new RooUnfoldResponse (h_reco,h_gen);
  BinM_1=new RooUnfoldResponse (h_reco,h_gen);
  BinM_2=new RooUnfoldResponse (h_reco,h_gen);

  cout<<"reading signal reco "<<endl;
  for (int i=0; i<t->GetEntries();i++){
    // if (i>20000) continue;
    //for (int i=0; i<50000;i++){
    t->GetEntry(i);
    double weight =1;
    for (int w=0; w<nweights;w++){
      if (weightid[w]==1 || weightid[w]==2 || weightid[w]==12 || weightid[w]==13 || weightid[w]==20 || weightid[w]==30) {weight=weight*weights[w];}
    }
    double phistar=l_phistar->GetValue();
    double phistar_true=l_phistar_true->GetValue();
    Dphistar->Fill((phistar_true-phistar)/phistar_true,weight);
    double y=l_y->GetValue();
    double y_true=l_y_true->GetValue();
    Dy->Fill((y_true-y)/y_true,weight);

    int bin=GetBin(phistar,y);
    int bin_true=GetBin(phistar_true,y_true);

    h_gen ->Fill(bin_true,weight);
    h_reco->Fill(bin,weight);
    if (N_MC==-1 || i<N_MC) BinM  ->Fill(bin,bin_true,weight); 
    BinMigration->Fill(bin,bin_true,weight);
    if (i%2==0){
      h_gen_1 ->Fill(bin_true,weight);
      h_reco_1->Fill(bin,weight);
      if (N_MC==-1 || i<N_MC) BinM_1  ->Fill(bin,bin_true,weight); 
    }
    else{
      h_gen_2 ->Fill(bin_true,weight);
      h_reco_2->Fill(bin,weight);
      if (N_MC==-1 || i<N_MC) BinM_2  ->Fill(bin,bin_true,weight); 
    }
  }
////////////////////////////here is where I left.
  TLatex mark;
  mark.SetTextSize(0.04);
  mark.SetTextFont(42);
  mark.SetNDC(true);

//  BinMigration->GetXaxis()->SetRangeUser(0.001,3.2);
  BinMigration->GetXaxis()->SetTitle("(#phi*,y) bin (reconstructed)");
  BinMigration->GetXaxis()->SetTitleOffset(0.8);
  BinMigration->GetXaxis()->SetTitleSize(0.04);
  BinMigration->GetXaxis()->SetLabelOffset(0);
  BinMigration->GetXaxis()->SetLabelSize(0.03);
  BinMigration->GetYaxis()->SetTitleOffset(1.05);
  BinMigration->GetYaxis()->SetTitleSize(0.04);
  BinMigration->GetYaxis()->SetLabelSize(0.03);
//  BinMigration->GetYaxis()->SetRangeUser(0.001,3.2);
  BinMigration->GetYaxis()->SetTitle("(#phi*,y) bin (generated)");
  BinMigration->GetZaxis()->SetTitleOffset(-0.004);
  BinMigration->SetStats(0);
  BinMigration->SetBit( TH2::kNoTitle, true );

  Dphistar->GetXaxis()->SetTitle("(#phi*(generated) - #phi*(reconstructed)/#phi*(generated)");
  Dphistar->GetXaxis()->SetTitleOffset(1.0);
  Dphistar->GetXaxis()->SetTitleSize(0.04);
  Dphistar->GetXaxis()->SetLabelOffset(0.0);
  Dphistar->GetXaxis()->SetLabelSize(0.04);
  Dphistar->GetYaxis()->SetTitleOffset(1.05);
  Dphistar->GetYaxis()->SetTitleSize(0.04);
  Dphistar->GetYaxis()->SetLabelSize(0.04);
  Dphistar->GetYaxis()->SetTitle("a.u.");
  Dphistar->SetMarkerStyle(20);
  Dphistar->SetMarkerColor(1);
  Dphistar->SetLineColor(1);
  Dphistar->SetStats(0);
  Dphistar->SetBit( TH2::kNoTitle, true );

  Dy->GetXaxis()->SetTitle("(Z(y)(generated) - Z(y)(reconstructed)/Z(y) (generated)");
  Dy->GetXaxis()->SetTitleOffset(1.0);
  Dy->GetXaxis()->SetTitleSize(0.04);
  Dy->GetXaxis()->SetLabelOffset(0.0);
  Dy->GetXaxis()->SetLabelSize(0.04);
  Dy->GetYaxis()->SetTitleOffset(1.05);
  Dy->GetYaxis()->SetTitleSize(0.04);
  Dy->GetYaxis()->SetLabelSize(0.04);
  Dy->GetYaxis()->SetTitle("a.u.");
  Dy->SetMarkerStyle(20);
  Dy->SetMarkerColor(1);
  Dy->SetLineColor(1);
  Dy->SetStats(0);
  Dy->SetBit( TH2::kNoTitle, true );
   
  std::string plotname = "Plots/BinM_";
  if (elec==0) plotname+="Dressed_";
  if (elec==1) plotname+="Born_";
  if (elec==2) plotname+="Naked_";
  if (madgraph)plotname+="MG_";
  else         plotname+="PH_";

  if (madgraph){
    TCanvas* BinM_M = new TCanvas("BinM_M","BinM_M",800,900);
    BinM_M->cd();
    // BinM_M->SetLogx();
    // BinM_M->SetLogy();
    BinM_M->SetLogz();
    BinMigration->Draw("COLZ");
    mark.DrawLatex(0.19,0.80,"MadGraph");
    BinM_M->SaveAs((plotname+"res"+FileType).c_str());
    TCanvas* Dp_M = new TCanvas("Dp_M","Dp_M",800,900);
    Dp_M->cd();
    Dp_M->SetLogy();
    Dphistar->Draw();
    mark.DrawLatex(0.19,0.80,"MadGraph");
    Dp_M->SaveAs((plotname+"Dphistar"+FileType).c_str());
    TCanvas* Dy_M = new TCanvas("Dy_M","Dy_M",800,900);
    Dy_M->cd();
    Dy_M->SetLogy();
    Dy->Draw();
    mark.DrawLatex(0.19,0.80,"MadGraph");
    Dy_M->SaveAs((plotname+"Dy"+FileType).c_str());
  }
  else{
    TCanvas* BinM_P = new TCanvas("BinM_P","BinM_P",800,900);
    BinM_P->cd();
    // BinM_P->SetLogx();
    // BinM_P->SetLogy();
    BinM_P->SetLogz();
    BinMigration->Draw("COLZ");
    mark.DrawLatex(0.19,0.80,"Powheg");
    BinM_P->SaveAs((plotname+"res"+FileType).c_str());
    TCanvas* Dp_P = new TCanvas("Dp_P","Dp_P",800,900);
    Dp_P->cd();
    Dp_P->SetLogy();
    Dphistar->Draw();
    mark.DrawLatex(0.19,0.80,"Powheg");
    Dp_P->SaveAs((plotname+"Dphistar"+FileType).c_str());
    TCanvas* Dy_P = new TCanvas("Dy_P","Dy_P",800,900);
    Dy_P->cd();
    Dy_P->SetLogy();
    Dy->Draw();
    mark.DrawLatex(0.19,0.80,"Powheg");
    Dy_P->SaveAs((plotname+"Dy"+FileType).c_str());
  }

  double weighted_events= BinMigration->GetSumOfWeights();  
  double diagonal=0;
  for (uint i=0; i<nbins; i++){
    diagonal+=BinMigration->GetBinContent(i+1,i+1);
  }
  cout<<weighted_events<<" of which diagonal "<<diagonal<<" non diagonal faction:"<<(weighted_events-diagonal)/weighted_events<<endl;
  //Find amount of bin migration of Y
  double InTheY=0;//Gets values in the Same Y region 
  for (uint i=1; i<=nphistar; i++){
      for (uint j=1; j<=nphistar; j++){
          InTheY+=BinMigration->GetBinContent(i,j);
          InTheY+=BinMigration->GetBinContent(i+nphistar,j+nphistar);
          InTheY+=BinMigration->GetBinContent(i+nphistar*2,j+nphistar*2);
          InTheY+=BinMigration->GetBinContent(i+nphistar*3,j+nphistar*3);
          InTheY+=BinMigration->GetBinContent(i+nphistar*4,j+nphistar*4);
          InTheY+=BinMigration->GetBinContent(i+nphistar*5,j+nphistar*5);
      }
      
  }
  cout<<"Percent mig Y axis: "<<100*(weighted_events-InTheY)/weighted_events<<std::endl<<std::endl;
  
  cout<<"done reading data "<<endl;

  for (uint i=0; i<nbins;i++){
    h_gen->SetBinError(i+1,0);
    h_gen_1->SetBinError(i+1,0);
    h_gen_2->SetBinError(i+1,0);
  }
  return;
}
Exemplo n.º 2
0
void ana_MC_BTagEff(TString ds="relval", TString physics="ttbar") {
{
  gSystem->Load("libSusyEvent.so");

  // Look ../jec/JetMETObjects/README
  gSystem->Load("../jec/lib/libJetMETObjects.so");

  // Printing utility for ntuple variables
  gROOT->LoadMacro("SusyEventPrinter.cc+");

  // Main analysis code
  gROOT->LoadMacro("SusyAna_MC_BTagEff.cc+"); //this line causes everything to segfault at the end.

  // chain of inputs
  TChain* chain = new TChain("susyTree");

//////////////// MC files /////////////////
  MCpoint* thisMCpoint = setupMCpoint(which_MC_to_use2); 
cout<<"try to add "<<thisMCpoint->filepath.c_str()<<endl;
  chain->Add(thisMCpoint->filepath.c_str()); 
//int which_MC_to_use=0; //already set
/*if(which_MC_to_use==0){
   chain->Add("MC/susyEvents_MC_AB_1M_st350_ho200.root");
}
else if(which_MC_to_use==1){
   chain->Add("MC/susyEvents_MC_AB_1M_st250_ho200.root");
}
else if(which_MC_to_use==2){
   chain->Add("MC/susyEvents_MC_AB_1M_st250_ho150.root");
}
else if(which_MC_to_use==3){
   chain->Add("MC/susyEvents_MC_AB_1M_ho140.root");
}
else if(which_MC_to_use==4){
   chain->Add("MC/susyEvents_MC_AB_1M_ho200.root");
}
*/


   //chain->Add("../susyEvents_AB_1M_ho200_v2.root");
   //chain->Add("../susyEvents_newNatural.root");
   //chain->Add("/eos/uscms/store/user/abarker/MC/newNat350_225/MC_AB_2500k_NEWnaturalHiggsinoNLSPout_mst_350_M3_5025_mu_225.root");//same thing as ../susyEvents_newNatural.root
   //chain->Add("/eos/uscms/store/user/abarker/MC/st_250_ho_150/MC_AB_2500k_st_250_ho_150.root");
   //chain->Add("/eos/uscms/store/user/abarker/MC/st_250_ho_200/MC_AB_2500k_st_250_ho_200.root");
   //chain->Add("/eos/uscms/store/user/abarker/MC/st_350_ho_200/MC_AB_2500k_mst_350_mu_200.root");
   //chain->Add("/eos/uscms/store/user/abarker/MC/ho_140/MC_AB_2500k_ho_140.root");
   //chain->Add("/eos/uscms/store/user/abarker/MC/ho_200/MC_AB_2500k_ho_200.root");


   //chain->Add("../susyEvents_newNatural.root");
    //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_NEWnaturalHiggsinoNLSPout_mst_350_M3_5025_mu_225.root");

   //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_st_250_ho_150.root");
   //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_st_250_ho_200.root");
   //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_mst_350_mu_200.root");
   //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_ho_140.root");
   //chain->Add("dcache:/pnfs/cms/WAX/resilient/abarker/MC/MC_AB_2500k_ho_200.root");


  SusyAna_MC_BTagEff* sea = new SusyAna_MC_BTagEff(chain);

  // configuration parameters
  // any values given here will replace the default values
  sea->SetDataset(physics+"_"+ds);        // dataset name
  sea->SetPrintInterval(1e4);             // print frequency
  sea->SetPrintLevel(0);                  // print level for event contents
  sea->SetUseTrigger(false);
/*
  sea->AddHltName("HLT_Photon36_CaloIdL_Photon22_CaloIdL");  // add HLT trigger path name 
  sea->AddHltName("HLT_Photon32_CaloIdL_Photon26_CaloIdL");  // add HLT trigger path name
  sea->AddHltName("HLT_Photon26_R9Id85_Photon18_R9Id85_Mass60");
  sea->AddHltName("HLT_Photon26_R9Id85_Photon18_CaloId10_Iso50_Mass60");
  sea->AddHltName("HLT_Photon26_CaloId10_Iso50_Photon18_R9Id85_Mass60");
  sea->AddHltName("HLT_Photon26_CaloId10_Iso50_Photon18_CaloId10_Iso50_Mass60");
  sea->AddHltName("HLT_Photon26_R9Id85_OR_CaloId10_Iso50_Photon18_R9Id85_OR_CaloId10_Iso50_Mass60");
  sea->AddHltName("HLT_Photon26_R9Id85_OR_CaloId10_Iso50_Photon18_R9Id85_OR_CaloId10_Iso50_Mass70");
  sea->AddHltName("HLT_Photon36_R9Id85_Photon22_R9Id85");
  sea->AddHltName("HLT_Photon36_R9Id85_Photon22_CaloId10_Iso50");
  sea->AddHltName("HLT_Photon36_CaloId10_Iso50_Photon22_R9Id85");
  sea->AddHltName("HLT_Photon36_CaloId10_Iso50_Photon22_CaloId10_Iso50");
  sea->AddHltName("HLT_Photon36_R9Id85_OR_CaloId10_Iso50_Photon22_R9Id85_OR_CaloId10_Iso50");
*/
  sea->SetFilter(true);                  // filter events passing final cuts
  sea->SetProcessNEvents(-1);             // number of events to be processed

  // as an example -- add your favorite Json here.  More than one can be "Include"ed
  //  sea->IncludeAJson("Cert_161079-161352_7TeV_PromptReco_Collisions11_JSON_noESpbl_v2.txt");
  //sea->IncludeAJson("anotherJSON.txt");

  TStopwatch ts;

  ts.Start();

  sea->Loop();

  ts.Stop();

  std::cout << "RealTime : " << ts.RealTime()/60.0 << " minutes" << std::endl;
  std::cout << "CPUTime  : " << ts.CpuTime()/60.0 << " minutes" << std::endl;
	}
  std::cout << "super end"<<std::endl;
	

}
Exemplo n.º 3
0
void plotter(const char* datafilename, const char* mcfilename, const char *idmvaCorrectionFile = NULL) {

  // READ Transformations
  std::vector<TGraph*> graphs;
  if (idmvaCorrectionFile != NULL) readTransformations(graphs);
    //readTransformations(graphs, idmvaCorrectionFile);

  //std::vector<TGraph*> graphs;
  //readTransformations(graphs);
  
  // READ SAMPLES
  ifstream myReadFile;
  myReadFile.open("inputfiles.dat");
  char output[100];
  int itype = -1;
  if (myReadFile.is_open()) {
    while (!myReadFile.eof()) {
      float xsec;
      myReadFile >> output >> xsec >> itype;
      std::string init(output);
      if (init.substr(0,1) != "#") {
	samples.push_back(std::pair<std::string, int>(output, itype));
	//std::cout << output << " " << itype << std::endl;
      }
    }
  }
  myReadFile.close();
  std::cout<< "Debug level 1" << std::endl; 
  
  //std::string weight = "weight";
  
  for (int sampletype=0; sampletype<2; sampletype++) {
    
    TChain* chain = new TChain("PhotonToRECO/fitter_tree");
    if (sampletype == 0)
      chain->Add(datafilename);
    else
      chain->Add(mcfilename);
    
    TBranchesI branchesI;
    TBranchesF branchesF;
    TBranchesD branchesD;
    TBranchesUI branchesUI;
    TBranchesUC branchesUC;

    auto leafList = chain->GetListOfLeaves();
    for (auto leaf : *leafList) {
      std::string name =((TLeaf*)leaf)->GetName();
      std::string type = ((TLeaf*)leaf)->GetTypeName();
      
      std::cout << name << type << endl;
            if (type == "Int_t") {
	Int_t a = 0;
	branchesI[name] = a;
	chain->SetBranchAddress(name.c_str(), &(branchesI[name]));
      } else if (type == "Float_t") {
	Float_t a = 0;
	branchesF[name] = a;
	chain->SetBranchAddress(name.c_str(), &(branchesF[name]));
      } else if (type == "Double_t") {
	Double_t a = 0;
	branchesD[name] = a;
	chain->SetBranchAddress(name.c_str(), &(branchesD[name]));
      } else if (type == "UInt_t") {
	UInt_t a = 0;
	branchesUI[name] = a;
	chain->SetBranchAddress(name.c_str(), &(branchesUI[name]));
      } else if (type == "UChar_t") {
	UChar_t a = 0;
	branchesUC[name] = a;
	chain->SetBranchAddress(name.c_str(), &(branchesUC[name]));
	}
	    //std::cout<< "Debug level 1.1" << std::endl; 
    }
    //std::cout<< "Debug level 2" << std::endl; 
    
    std::map<int, std::vector<TTreeFormula*> > categories;
    std::cout << "Reading categories...." << std::endl;
    myReadFile.open("probeCategories.dat");
    std::string line;
    int cat;
    while(!myReadFile.eof()) {
      myReadFile >> cat >> line;
      char a[100];
      if (categories.find(cat) == categories.end() ) {
	sprintf(a, "cat%d_%d", cat, 0);
	std::cout << a << " " << line << std::endl;
	categories[cat].push_back(new TTreeFormula(a, line.c_str(), chain));
      } else {
	sprintf(a, "cat%d_%zu", cat, categories[cat].size());
	std::cout << a << " " << line << std::endl;
	categories[cat].push_back(new TTreeFormula(a, line.c_str(), chain));
      }
    }
    myReadFile.close();
    //std::cout<< "Debug level 3" << std::endl; 

    
    std::vector<HistoDefinition> histoDef;
    // READING PLOT DEFINITION
    std::cout << "Reading plots..." << std::endl;
    myReadFile.open("probesvar.dat");
    std::map<int, HistoContainer> histos;
    histos[samples[sampletype].second] = HistoContainer();
    
    while(!myReadFile.eof()) {
      // type ncat==1 xbin ybins xmin xmax ymin ymax name xaxis yaxis var cat????
      HistoDefinition temp;
      myReadFile >> temp.type >> temp.log >> temp.ncat >> temp.xbins >> temp.ybins >> temp.xmin >> temp.xmax
		 >> temp.ymin >> temp.ymax >> temp.name >> temp.xaxis >> temp.yaxis >> temp.var;
      histoDef.push_back(temp);
      
      TH1F* h = new TH1F("h", "", temp.xbins, temp.xmin, temp.xmax);
      h->GetXaxis()->SetTitle(temp.xaxis.c_str());
      h->GetYaxis()->SetTitle(temp.yaxis.c_str());
      
      int ncats = categories[temp.ncat].size();
      for (int c=0; c<ncats; c++) {
	
	std::ostringstream convert; 
	convert << c;
	std::string name = temp.name + "_cat"+ convert.str() + "_" + samples[sampletype].first;  
	std::cout << c << " " << name << std::endl;
	histos[samples[sampletype].second].histoF[temp.name].push_back(*((TH1F*)h->Clone(name.c_str())));
      }
      delete h;
    }
    myReadFile.close();
    // std::cout<< "Debug level 4 " << chain->GetEntries() << std::endl; 

    for (int z=0; z<chain->GetEntries(); z++) {
      if (z%10000 == 0)
	std::cout << z << std::endl;
      
      chain->GetEntry(z);

      float mass = branchesF["mass"];
      if ((mass > 70 && mass < 110) && ((abs(branchesF["probe_sc_eta"]) < 1.5 && branchesF["probe_Pho_sieie"] < 0.0105) || (abs(branchesF["probe_sc_eta"]) > 1.5 && branchesF["probe_Pho_sieie"] < 0.028))) {
	double weight = 1.0; 
	if (sampletype == 1 && isfinite(branchesF["totWeight"])) {
	  weight = branchesF["totWeight"];
	  // std::cout << "weight in the loop: " << weight << "and:  " << branchesD["totWeight"] << std::endl; 
	}  
	// cout << "mass: " << mass << " - " << "tag_Pho_mva" << branchesF["tag_Pho_mva"] << " - " << "probe_Pho_mva" << branchesF["probe_Pho_mva"] << endl;
	for (unsigned int s=0; s<samples.size(); s++) {
	  for (unsigned int h=0; h<histoDef.size(); h++) {
	    // std::cout << histoDef[h].name << " " << histoDef[h].var << " " << histoDef[h].ncat << std::endl;
	    std::string name = histoDef[h].name;
	    std::string var = histoDef[h].var;
	    int category = histoDef[h].ncat;
	    
	    double final_weight = weight;
	    // std::cout << "final_weight: " << final_weight << std::endl;
	    for (unsigned int cat=0; cat<categories[category].size(); cat++) {
	      categories[category][cat]->UpdateFormulaLeaves();
	      // std::cout<< "Going to draw histogram " << name <<std::endl;
	      
	      if (categories[category][cat]->EvalInstance()) {
		if (name == "idmvaup1" || name == "idmvaup2")
 		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesF[var]+idmvaShift, final_weight);
		else if (name == "idmvadown1" || name == "idmvadown2")  
 		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesF[var]-idmvaShift, final_weight);
		else if (name == "idmvatop1" || name == "idmvatop2")
		  {
		  if (idmvaCorrectionFile != NULL)
		    {

		      if(cat == 0 || cat == 1){ histos[samples[sampletype].second].histoF[name][cat].Fill(graphs[cat+2]->Eval(branchesF[var]), final_weight*graphs[cat+2]->Eval(9999));}
		    }
		  }
		else if (name == "idmvabottom1" || name == "idmvabottom2")
		  {
		    if (idmvaCorrectionFile != NULL)
		      {
			if(cat == 0 || cat == 1){ histos[samples[sampletype].second].histoF[name][cat].Fill(graphs[cat]->Eval(branchesF[var]), final_weight*graphs[cat]->Eval(9999));}
		      }

		  }
		else if (name == "sigmaEoEup1" || name == "sigmaEoEup2")
 		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesF[var]*(1+sigmaEScale), final_weight);
		else if (name == "sigmaEoEdown1" || name == "sigmaEoEdown2")  
 		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesF[var]*(1-sigmaEScale), final_weight);
		else if (branchesF.find(var) != branchesF.end())
		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesF[var], final_weight);
		else if (branchesI.find(var) != branchesI.end())
		  histos[samples[sampletype].second].histoF[name][cat].Fill(branchesI[var], final_weight);
	      }	    
	      // std::cout<< "histo " << name << " drawn" << std::endl;
	      // std::cout<< "Debug level 5 " << z << " " << s << " " << h << " " << " " << cat << std::endl; 
	    }
	    // std::cout << "Debug level 6" << std::endl;
	  }
	  // std::cout << "Debug level 7" << std::endl;
	  break;
	}
	// std::cout << "Debug level 8" << std::endl;	
      }
      // std::cout << "Debug level 9" << std::endl;
      // if(sampletype==0 && z>=10000) break ;
      if(sampletype==1 && z>0) break ;
    }
    
    std::cout << sampletype << std::endl;
    std::string rootOutputFile = "tnp_data_2017.root";  
    if (sampletype == 1)
      rootOutputFile = "tnp_tmp.root";
    
    TFile* out = new TFile(rootOutputFile.c_str(), "recreate");
    
    for (unsigned int h=0; h<histoDef.size(); h++) {
      std::string var = histoDef[h].name;
      int cat = categories[histoDef[h].ncat].size();
      for (int c=0; c<cat; c++) {
	histos[samples[sampletype].second].histoF[var][c].Write();
      }
      //std::cout << "Wrote histo successfully" << var << std::endl; 
    }
    out->Close();
  }
}
Exemplo n.º 4
0
void hbbNN(Int_t ntrain=15) {
// Example of a Multi Layer Perceptron
// For a Tevatron search for SUSY Higgs in bh->bbb, a neural network 
// was used to separate the signal from the background passing 
// some selection cuts. Here is a simplified version of this network, 
// taking into account only bbb events.
//Author: P. Jonsson

//Part 1, preparing the inputs

//Booking some histograms for signal and background, 
//Add histograms yourself for the dijet mass (MH[0]) of the leading pT 
//(=transverse momenta) jets for background and signal  

   TH1F *detas = new TH1F("detas", "detas", 50, .0, 4.);
   TH1F *detab = new TH1F("detab", "detab", 50, .0, 4.);   
   TH1F *dphis = new TH1F("dphis", "dphis", 50, .0, 3.15);
   TH1F *dphib = new TH1F("dphib", "dphib", 50, .0, 3.15);  
   TH1F *angles = new TH1F("angles", "angles", 50, .0, 2.);
   TH1F *angleb = new TH1F("angleb", "angleb", 50, .0, 2.);  
   TH1F *pbalances = new TH1F("pbalances", "pbalances", 50, .0, 1.);
   TH1F *pbalanceb = new TH1F("pbalanceb", "pbalanceb", 50, .0, 1.); 
   TH1F *etahs = new TH1F("etahs", "etahs", 50, -2.5, 2.5);
   TH1F *etahb = new TH1F("etahb", "etahb", 50, -2.5, 2.5);  
   TH1F *sphericitys = new TH1F("sphericitys", "sphericitys", 50, .0, 1.);
   TH1F *sphericityb = new TH1F("sphericityb", "sphericityb", 50, .0, 1.); 

   if (!gROOT->GetClass("TMultiLayerPerceptron")) {
      gSystem->Load("libMLP");
   }

   // Prepare inputs
   // The 2 trees are merged into one, and a "type" branch, 
   // equal to 1 for the signal and 0 for the background is added.

   TChain * signal = new TChain("higgsSearch","");

   //Use a Higgs signal at a mass of  110 GeV   
    signal->Add("LHinput-cut_2b25_1j15-Tight-MC_higgs110GeV.root/higgsSearch");

    //Use a background of multijet bbb events
   TChain *background = new TChain("higgsSearch","");
   background->Add("LHinput-cut_2b25_1j15-Tight-MC_bbb.root/higgsSearch");

   //book combined tree of selected events top use for training
   TFile *f = new TFile("training.root","recreate");
   TTree *simu = new TTree("MonteCarlo", "Filtered Monte Carlo Events");

   Double_t nnoutxlm[4], MH[6], dEta[6], dPhi[6], Angle[6], EtaH[6], pBalance[6], Sphericity;
   Double_t dphi, deta, angle, etah, pbalance, sphericity; 
   Int_t Njets, typeH[6], typeO, nsignal, nbkg;

   //counters for signal and background events
   nsignal=0;
   nbkg=0;

   // 
   //Set branch addresses to use from signal and background trees
   //Description of variables inline below. 
   //Draw histograms of these  variables for signal and background on top 
   //of eachother in different colors. 
   //Save these plots (you can look up how to save plots to files at root.cern.ch)
 
   //Invariant di-jet mass
   signal->SetBranchAddress("MH",  &MH);

   //Delta eta, difference in pseudorapidity (spatial coodinate used to 
   //describe angle with the beam axis = -ln(tan(theta/2))
   signal->SetBranchAddress("dEta",    &dEta);

   //Delta phi, azimuthal angle (going from 0 to 2pi around the beampipe)
   signal->SetBranchAddress("dPhi",  &dPhi);

   //Angle between the leading jet and the combined jet-pair
   signal->SetBranchAddress("Eta1mEtaH", &Angle);

   //Pseudorapidity of the combined jet-pair
   signal->SetBranchAddress("EtaH",  &EtaH);

   //Which jet-pair comes from the true Higgs decay
   signal->SetBranchAddress("type", &typeH);

   //Momentum balance of the jet-pair: p1-p2/p1+p2 
   signal->SetBranchAddress("pBalance",  &pBalance);

   //Number of jets in the event 
   signal->SetBranchAddress("Njets", &Njets);

   //Event sphericity (measure of how spherical, round, the event is)
   signal->SetBranchAddress("FW_H2", &Sphericity);

   //same for background
   background->SetBranchAddress("MH",  &MH);
   background->SetBranchAddress("dEta",    &dEta);
   background->SetBranchAddress("dPhi",  &dPhi);
   background->SetBranchAddress("Eta1mEtaH", &Angle);
   background->SetBranchAddress("EtaH",  &EtaH);
   background->SetBranchAddress("pBalance",  &pBalance);
   background->SetBranchAddress("Njets", &Njets);
   background->SetBranchAddress("FW_H2", &Sphericity);

   //Make input branches of variables to use for the training
   simu->Branch("dEta", &deta, "dEta/D");
   simu->Branch("dPhi",  &dphi,  "dPhi/D");
   simu->Branch("Angle",    &angle,    "Angle/D");
   simu->Branch("pBalance",  &pbalance,  "pBalance/D");
   simu->Branch("EtaH", &etah, "EtaH/D");
   simu->Branch("Sphericity",  &sphericity,  "Sphericity/D");
   simu->Branch("type",   &typeO,   "type/I");
  
   //loop over signal and select events to use for training 
   Int_t i;
   for (i = 0; i < signal->GetEntries(); i++) {
     signal->GetEntry(i);
     //only consider events with 3 jets
      if (Njets==3){
          typeO=0; 
          //select only events where the two leading pT jets come from the 
	  //Higgs decay (typeH[0]==1), and these two jets are separated by 
	  //sqrt(dEta[0]*dEta[0]+dPhi[0]*dPhi[0]) > 1, and the invariant 
          //di-jet mass is greater than 50 GeV
          if (typeH[0]==1 && sqrt(dEta[0]*dEta[0]+dPhi[0]*dPhi[0]) > 1. && MH[0]>50.){          
	    deta = dEta[0];
	    dphi =2*acos(0)- dPhi[0]; 
            angle = Angle[0];
            pbalance = pBalance[0];
            etah = EtaH[0];
            sphericity = Sphericity;
            typeO=1; 
	   }
	  //fill selected signal events (type0==1)
          if (typeO==1){
	    //fill the histograms like this:
	      detas->Fill(deta); 	      
	      dphis->Fill(dphi);
	      angles->Fill(angle);
	      pbalances->Fill(pbalance);
	      etahs->Fill(etah);
	      sphericitys->Fill(sphericity);


	      //fill the training tree   
              simu->Fill();
              nsignal++; 
	  }
      }
   }

   cout << nsignal <<endl; 
   //now loop over background events
   for (i = 0; i < background->GetEntries(); i++) {
      background->GetEntry(i);
      if (Njets==3){
          typeO=1;
	  //similar for background events
          if (sqrt(dEta[0]*dEta[0]+dPhi[0]*dPhi[0]) > 1. && MH[0]>50.){
	    deta = dEta[0];
	    dphi =2*acos(0)- dPhi[0]; 
            angle = Angle[0];
            pbalance = pBalance[0];
            etah = EtaH[0];
            sphericity = Sphericity;
            typeO=0; 
          }
	  //fill the selected background events until you have the same 
          //number as signal
          if (typeO==0 && nbkg<nsignal){
	    //fill the background histograms here:
    	      detab->Fill(deta); 	      
    	      dphib->Fill(dphi);
    	      angleb->Fill(angle);
    	      pbalanceb->Fill(pbalance);
    	      etahb->Fill(etah);
    	      sphericityb->Fill(sphericity);
            
	    
	    
	    nbkg++;
            simu->Fill();
	  } 
      }

   }
   cout << nbkg << endl;   


   	/*Plot the simulated and background variable distributions */
	TCanvas *c1 = new TCanvas("c2", "Signal and Background Distributions");
	c1->Divide(2,3);
	c1->cd(1);  dphis->Draw();       dphib->	SetLineColor(kRed);   dphib->Draw("same");	
	c1->cd(2);  detas->Draw();       detab->	SetLineColor(kRed);   detab->Draw("same");	
	c1->cd(3);  angles->Draw();      angleb->	SetLineColor(kRed);   angleb->Draw("same");	
	c1->cd(4);  pbalances ->Draw();  pbalanceb->	SetLineColor(kRed);   pbalanceb ->Draw("same");	
	c1->cd(5);  etahs->Draw();       etahb->	SetLineColor(kRed);   etahb->Draw("same");	
	c1->cd(6);  sphericitys->Draw(); sphericityb->	SetLineColor(kRed);   sphericityb->Draw("same");	
	c1->SaveAs("sig_background_distr.pdf");	
	


	for(Int_t i = 1; i++; i < 5)
	{ 
		stringstream ss;
		ss << i*5;
		TString structure = "@dEta, @dPhi, @EtaH, @pBalance, @Sphericity, @Angle:" + ss.str() + ":1:type";;
		trainNetwork(simu, structure, 100);

	}
}
Exemplo n.º 5
0
/// Main function that runs the analysis algorithm on the
/// specified input files
int main(int argc, char* argv[]) {

  /// Gets the list of input files and chains
  /// them into a single TChain
  char inputFileName[150];
  char outFileName[150];
  char skimFileName[150];
  char json[150]="none";

  if ( argc < 3 ){
    cout << "Error at Input: please specify an input file including the list of input ROOT files" << endl; 
    cout << "Example:        ./VecbosApp list.txt output.root" << endl;
    cout << "Available options: " <<endl;
    cout << "-weight=w  weight of the MC" << endl;  
    cout << "-start=N start from event N in the chain" << endl; 
    cout << "-stop=N stop at event N in the chain" << endl; 
    cout << "-signal=N 0=W(prompt),1=Z(prompt),2=W(other),3=Z(other), 4= no mctruth" << endl; 
    cout << "--isData to run on good runs on data" << endl; 
    cout << "-json=file path of the json file" << endl;
    return 1;
  }

  // rad running options
  strcpy(inputFileName,argv[1]);
  strcpy(outFileName,argv[2]);
  strcpy(skimFileName,argv[2]);

  TChain *theChain = new TChain("ntp1");
  char Buffer[500];
  char MyRootFile[2000];  
  ifstream *inputFile = new ifstream(inputFileName);
  // get the tree with the conditions from the first file
  //  TTree *treeCond = new TTree();
  //  int nfiles=1;
  char tmpFileName[256];
  vector<string> filesToRemove;
  while( !(inputFile->eof()) ){
    inputFile->getline(Buffer,500);
    if (!strstr(Buffer,"#") && !(strspn(Buffer," ") == strlen(Buffer)))
      {
	sscanf(Buffer,"%s",MyRootFile);
	if(string(MyRootFile).find("eos") != std::string::npos) {
	  theChain->Add("root:/"+TString(MyRootFile));
        } else {
	  theChain->Add("rfio:"+TString(MyRootFile));
	}
        // theChain->Add("root://castorcms/"+TString(MyRootFile));
	//        theChain->Add(TString(MyRootFile));
	std::cout << "chaining " << MyRootFile << std::endl;
	//	if ( nfiles==1 ) {
	//	  TFile *firstfile = TFile::Open("root://castorcms/"+TString(MyRootFile));
	//	  treeCond = (TTree*)firstfile->Get("Conditions");
	//	}
	//        nfiles++;
      }
  }
 

  //  theChain->MakeClass("thisiswhyitcrashed");

  inputFile->close();
  delete inputFile;
  // get additional input options
  int signal = 0;
  int start = 0;
  int stop  = theChain->GetEntries();
  bool isData = false;
  float lumi = -999.;
  float xsec = -999.;
  float weight = 1.;
  for (int i=1;i<argc;i++){
    if (strncmp(argv[i],"-start",6)==0) sscanf(argv[i],"-start=%i",&start);
    if (strncmp(argv[i],"-stop",5)==0)  sscanf(argv[i],"-stop=%i",&stop);
    if (strncmp(argv[i],"-signal",7)==0)  sscanf(argv[i],"-signal=%i",&signal);
    if (strncmp(argv[i],"-weight",7)==0)  sscanf(argv[i],"-weight=%f",&weight);
    if (strncmp(argv[i],"--isData",8)==0)  isData = true;
    if (strncmp(argv[i],"-lumi",5)==0)  sscanf(argv[i],"-lumi=%f",&lumi);
    if (strncmp(argv[i],"-xsec",5)==0)  sscanf(argv[i],"-xsec=%f",&xsec);
    if (strncmp(argv[i],"-json",5)==0)  sscanf(argv[i],"-json=%s",&json);
  }

  

#if Application == 1
  std::cout << " initialising " << std::endl;
  VecbosEESelection vecbos(theChain);
  std::cout << " setup trigger selection " << std::endl;
  std::vector<string> mask;
  mask.push_back("HLT_Photon10_L1R");
  mask.push_back("HLT_Photon15_L1R");
  for(std::vector<string>::iterator it=mask.begin(); it!= mask.end();it++)
    std::cout << *it <<std::endl;
  vecbos.setRequiredTriggers(mask);
  std::cout << " setup analysis parameters" <<std::endl;
  vecbos.doBestElectronStudy(false);
  std::cout << "  skimname" <<std::endl;
  vecbos.setPrefix(skimFileName);
  std::cout << "  signal" <<std::endl;
  vecbos.setSignal(signal);
  std::cout << " starting event loop"<< std::endl;
  vecbos.Loop();
  std::cout << " preparing plots" <<std::endl;
  vecbos.displayEfficiencies();
#endif

#if Application == 2
  CandleCalib vecbos(theChain);
  //  TriggerMask mask(treeCond);
  //  mask.requireTrigger("HLT_Mu9");
  //  mask.requireTrigger("HLT_Mu11");
  //  mask.requireTrigger("HLT_Mu15");
  //  mask.requireTrigger("HLT_DoubleMu3");
  //  std::vector<int> requiredTriggers = mask.getBits();
  //  vecbos.requireTrigger(requiredTriggers);
  vecbos.Loop(string(outFileName), start, stop);  
#endif

#if Application == 3

  // for electron analysis:
  VecbosEESelection vecbos(theChain);
  std::vector<std::string> mask;
  if(!isData) { // for Winter10 MC only
    mask.push_back("HLT_Ele10_SW_L1R_v2");
    mask.push_back("HLT_Ele17_SW_L1R_v2");
    mask.push_back("HLT_Ele17_SW_L1R_v2");
    mask.push_back("HLT_Ele17_SW_Isol_L1R_v2");
    mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    mask.push_back("HLT_Ele17_SW_TightCaloEleId_Ele8HE_L1R_v2");
  } else { // 2010 Run data
    std::cout << "Applying triggers for data" << std::endl;
    mask.push_back("HLT_Photon10_L1R");
    mask.push_back("HLT_Photon15_L1R");
    mask.push_back("HLT_Photon15_Cleaned_L1R");
    mask.push_back("HLT_Ele10_LW_L1R");
    mask.push_back("HLT_Ele15_SW_L1R");
    mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
    mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
    mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
    mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
    mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
  }
  vecbos.setRequiredTriggers(mask);
  vecbos.doBestElectronStudy(false);
  vecbos.doBTagEfficiencyStudy(false);
  vecbos.setPrefix(skimFileName);
  vecbos.setSignal(signal);
  vecbos.Loop();
  vecbos.displayEfficiencies();

  return 0;

#endif

#if Application == 4  
  // for muon analysis:
  VecbosMuMuSelection vecbos(theChain);
  std::vector<std::string> mask;
  mask.push_back("HLT_Mu9");
  mask.push_back("HLT_Mu15_v1");
  vecbos.setRequiredTriggers(mask);
  vecbos.setPrefix(skimFileName);
  vecbos.setSignal(signal);
  vecbos.Loop();
  vecbos.displayEfficiencies();
  return 0;
#endif

#if Application == 5
#endif

#if Application == 6
  
#endif

#if Application == 7
  if(isData) {
    DiJet vecbos(theChain, true, true);
    vecbos.Loop(string(outFileName), start, stop);  
  } else {
    DiJet vecbos(theChain, false, false);
    vecbos.Loop(string(outFileName), start, stop);  
  }
#endif

#if Application == 8  
  if(isData) {
    vecbos.Loop(string(outFileName), start, stop);  
  } else {
    Razor vecbos(theChain, string(json), false, false);
    vecbos.Loop(string(outFileName), start, stop);  
  }
#endif

#if Application == 9

  VecbosPFEESelection vecbos(theChain);
  std::vector<std::string> mask;
  mask.push_back("HLT_Photon10_L1R");
  vecbos.setRequiredTriggers(mask);
  vecbos.setPrefix(skimFileName);
  vecbos.setSignal(signal);
  vecbos.Loop();
  vecbos.displayEfficiencies();

#endif

#if Application == 10

  // for electron analysis:
  SuperClustersEESelection vecbos(theChain);
  std::vector<std::string> mask;
  mask.push_back("HLT_Photon10_L1R");
  vecbos.setRequiredTriggers(mask);
  vecbos.requireTrigger(requiredTriggers);
  vecbos.setPrefix(skimFileName);
  vecbos.setSignal(signal);
  vecbos.Loop();
  vecbos.displayEfficiencies();
#endif
 //  **********NATASHA MODIFIED 6/21/2010*****************

#if Application == 12
  if(isData) {
    GammaPlusJet vecbos(theChain, true, true);
    vecbos.SetConditions(treeCond);
    vecbos.Loop(string(outFileName), start, stop);  
  } else {
    GammaPlusJet vecbos(theChain, false, false);
    if(lumi > 0. && xsec > 0.) {
      vecbos.SetLuminosity(lumi);
      vecbos.SetXsection(xsec);
    }
    vecbos.SetConditions(treeCond);
    vecbos.Loop(string(outFileName), start, stop);  
  }
#endif

#if Application == 13  
  std::vector<std::string> mask;
  // if(!isData) {
  //   mask.push_back("HLT_HT200");
  // } else {
  if (isData) {
    mask.push_back("HLT_R014_MR150");
    mask.push_back("HLT_R020_MR150");
    mask.push_back("HLT_R025_MR150");
    mask.push_back("HLT_R020_MR500");
    mask.push_back("HLT_R020_MR550");
    mask.push_back("HLT_R025_MR400");
    mask.push_back("HLT_R025_MR450");
    mask.push_back("HLT_R033_MR300");
    mask.push_back("HLT_R033_MR350");
    mask.push_back("HLT_R038_MR200");
    mask.push_back("HLT_R038_MR250");
    mask.push_back("HLT_Mu8_R005_MR200");
    mask.push_back("HLT_Mu8_R020_MR200");
    mask.push_back("HLT_Mu8_R025_MR200");
    mask.push_back("HLT_Ele10_CaloIdL_TrkIdVL_CaloIsoVL_TrkIsoVL_R005_MR200");
    mask.push_back("HLT_Ele10_CaloIdL_TrkIdVL_CaloIsoVL_TrkIsoVL_R020_MR200");
    mask.push_back("HLT_Ele10_CaloIdL_TrkIdVL_CaloIsoVL_TrkIsoVL_R025_MR200");
  }
  if(isData) {
    SUSYInclusive vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);  
  } else {
    SUSYTau vecbos(theChain, false, false);
    // vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);  
  }
#endif

#if Application == 14

  // top control sample
  TopControlSample vecbos(theChain);
  std::vector<std::string> mask;
  mask.push_back("HLT_Photon10_L1R");
  mask.push_back("HLT_Photon15_L1R");
  mask.push_back("HLT_Photon15_Cleaned_L1R");
  mask.push_back("HLT_Ele10_LW_L1R");
  mask.push_back("HLT_Ele15_SW_L1R");
  mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
  mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
  mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
  mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
  mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");

  mask.push_back("HLT_Mu9");
  mask.push_back("HLT_Mu15_v1");

  // MC triggers
//   mask.push_back("HLT_Ele15_LW_L1R");
//   mask.push_back("HLT_Mu9");
  vecbos.setRequiredTriggers(mask);
  vecbos.setPrefix(skimFileName);
  vecbos.setSignal(signal);
  vecbos.Loop();
  vecbos.displayEfficiencies();

#endif


#if Application == 15
  std::vector<std::string> mask;
  if(isData) {
    if(AnalysisSelector == 1 || AnalysisSelector == 2){

      //      mask.push_back("HLT_Mu9");
      //      mask.push_back("HLT_Mu11");
      //      mask.push_back("HLT_Mu15");                                                                        

      //Single Mu
      // mask.push_back("1-163261:HLT_Mu15_v2");
//       mask.push_back("163262-164237:HLT_Mu24_v");
//       mask.push_back("165085-999999:HLT_Mu30_v");
      //Iso Mu
           mask.push_back("1-163261:HLT_Mu15_v2");
           mask.push_back("163262-167043:HLT_IsoMu17_v");
           mask.push_back("167044-167913:HLT_IsoMu17_eta2p1_v");
           mask.push_back("170053-172949:HLT_IsoMu20_v");
      
    }else if(AnalysisSelector == 3 || AnalysisSelector == 4){
      mask.push_back("HLT_Ele10_LW_L1R");                                                                                   
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");                                                               
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    }
    SUSYMultiTop vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);  
  } else {
    SUSYMultiTop vecbos(theChain, false, false);
    vecbos.SetWeight(double(weight));
    vecbos.Loop(string(outFileName), start, stop);  
  }
#endif

#if Application == 23
  std::vector<std::string> mask;
  if(isData) {
    if(AnalysisSelector == 1 || AnalysisSelector == 2){
      mask.push_back("1-163261:HLT_Mu15_v2");                                                                                                      
      mask.push_back("163262-164237:HLT_Mu24_v"); 
      mask.push_back("165085-999999:HLT_Mu30_v"); 
      
    }else if(AnalysisSelector == 3 || AnalysisSelector == 4){
      mask.push_back("HLT_Ele10_LW_L1R");
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    }
    SUSYMultiB vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    SUSYMultiB vecbos(theChain, false, false);
    vecbos.SetWeight(double(weight));
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif


#if Application == 16
  if(isData == true)
    {
      CreateWJetDataset vecbos(theChain, true, true, -1);
      std::vector<std::string> mask;
      mask.push_back("HLT_Mu15");
      mask.push_back("HLT_Mu15_v1");
      vecbos.setRequiredTriggers(mask);
      vecbos.Loop(string(outFileName), start, stop); 
    }
  else
    {
      int SelectZMuMu = -1;
      if(signal == 1)   // Z(prompt)
	SelectZMuMu = 1;
      if(signal == 3)   // Z(other)
	SelectZMuMu = 0;
      
      CreateWJetDataset vecbos(theChain, false, false, SelectZMuMu);
      std::vector<std::string> mask;
      mask.push_back("HLT_Mu15");
      mask.push_back("HLT_Mu15_v1");
      vecbos.setRequiredTriggers(mask);
      vecbos.Loop(string(outFileName), start, stop);
    }
#endif

#if Application == 17
  if(isData) {
    RazorDiPhoton vecbos(theChain, string(json), true, true);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    RazorDiPhoton vecbos(theChain,  string(json), false, false);
    vecbos.SetWeight(double(weight));
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 18
  std::vector<std::string> mask;
  if(isData) {
    if(RA4Selector == 1){
      mask.push_back("HLT_Mu11");
      mask.push_back("HLT_Mu5_HT70U_v3");
    }else if(RA4Selector == 2){
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele10_SW_HT70U_L1R_v1");
      mask.push_back("HLT_Ele10_SW_HT70U_L1R_v2");
    }
    SUSYRA vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    SUSYRA vecbos(theChain, false, false);
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 19
  std::vector<std::string> mask;
  if(isData) {
    mask.push_back("HLT_Mu9");
    mask.push_back("HLT_Mu11");
    mask.push_back("HLT_Mu15");
    mask.push_back("HLT_Mu17");
    ZMuMu vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    ZMuMu vecbos(theChain, false, false);
    vecbos.Loop(string(outFileName), start, stop);
  }

#endif

#if Application == 20   // LQ3 Analysis
  std::vector<std::string> mask;
  if(isData == true)
  {
     LQ3Analysis Analysis(theChain, true, true);
     Analysis.setRequiredTriggers(mask);
     Analysis.Loop(string(outFileName), start, stop);
  }
  else
  {
     LQ3Analysis Analysis(theChain, false, true);
     Analysis.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 21   // VBTF Lepton Efficiencies                                                                                                                     
  std::vector<std::string> mask;
  if(isData) {
    if(AnalysisSelector == 1 || AnalysisSelector == 2){
      mask.push_back("HLT_Mu9");
      mask.push_back("HLT_Mu11");
      mask.push_back("HLT_Mu15");
    }else if(AnalysisSelector == 3 || AnalysisSelector == 4){
      mask.push_back("HLT_Ele10_LW_L1R");
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    }
    VBTFLeptEff vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    VBTFLeptEff vecbos(theChain, false, false);
    vecbos.Loop(string(outFileName), start, stop);
  }

#endif

#if Application == 22
  if(isData) {
    RazorLeptons vecbos(theChain, string(json), true, true);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    RazorLeptons vecbos(theChain, string(json), false, false);
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 24
  if(isData) {
    RazorHiggsBB vecbos(theChain, string(json), true, true);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    RazorHiggsBB vecbos(theChain, string(json), false, false);
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 25
  if(isData) {
    RazorBoostedTop vecbos(theChain, string(json), true, true);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    int model=-1;
    const int nModels=7;
    const char *models[nModels] = {"mSUGRA","T1bbbb","T2bb","T2tt","T1tttt","T2","T1"};
    int modNameLen[nModels] = {6,6,4,4,6,2,2};
    
    for(int i=0;i<nModels;i++){
      if(strstr(inputFileName,models[i])){
	model=i; break;
      }
    }
    RazorBoostedTop vecbos(theChain, string(json), false, false,model);
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 26
  std::vector<std::string> mask;
  if(isData) {
    if(AnalysisSelector == 1 || AnalysisSelector == 2){
      mask.push_back("1-163261:HLT_Mu15_v2");
      mask.push_back("163262-164237:HLT_Mu24_v");
      mask.push_back("165085-999999:HLT_Mu30_v");

    }else if(AnalysisSelector == 3 || AnalysisSelector == 4){
      mask.push_back("HLT_Ele10_LW_L1R");
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    }
    SF_Filler vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    SF_Filler vecbos(theChain, false, false);
    vecbos.SetWeight(double(weight));
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif

#if Application == 27
  std::vector<std::string> mask;
  if(isData) {
    if(AnalysisSelector == 1 || AnalysisSelector == 2){
      mask.push_back("1-163261:HLT_Mu15_v2");
      mask.push_back("163262-164237:HLT_Mu24_v");
      mask.push_back("165085-999999:HLT_Mu30_v");

    }else if(AnalysisSelector == 3 || AnalysisSelector == 4){
      mask.push_back("HLT_Ele10_LW_L1R");
      mask.push_back("HLT_Ele15_SW_L1R");
      mask.push_back("HLT_Ele15_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_CaloEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TightEleId_L1R");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v2");
      mask.push_back("HLT_Ele17_SW_TighterEleIdIsol_L1R_v3");
    }
    H4b vecbos(theChain, true, true);
    vecbos.setRequiredTriggers(mask);
    vecbos.Loop(string(outFileName), start, stop);
  } else {
    H4b vecbos(theChain, false, false);
    vecbos.SetWeight(double(weight));
    vecbos.Loop(string(outFileName), start, stop);
  }
#endif


  system("rm thisiswhyitcrashed*");

  return 0;

}
Exemplo n.º 6
0
int
Fitfraction(){
   ofstream myfile;
   myfile.open("JetFakeRate-mg-2016.txt");
   std::ostringstream hadfrac;
   hadfrac.str("");

  double IsoCutLower[]={3.32,3.42,3.52,3.62,3.72,3.82,3.92,4.02,4.12,4.22,4.32,4.42,4.52,4.62,4.72,4.82,4.92};
  double IsoCutUpper[]={12,12.5,13,13.5,14,14.5,15,15.5,16,16.5,17,17.5,18};
  unsigned nUpper = sizeof(IsoCutUpper)/sizeof(double);
  unsigned nLower = sizeof(IsoCutLower)/sizeof(double);
  //int PtBins[]=  {25,30,35,45,55,70,90};
  int PtBins[]=  {25,28,30,34,38,42,46,50,54,58,62,66,70,75,80,90,100,120,140};
  unsigned nSet = sizeof(PtBins)/sizeof(int);
  TH1F* h_data[nSet][nLower][nUpper]; 
  TH1F* h_bg[nSet][nLower][nUpper];
  TH1F* h_target[nSet][nLower][nUpper];
  TObjArray *templatelist[nSet][nLower][nUpper];
  TFractionFitter* fitter[nSet][nLower][nUpper];
  TH1F* result[nSet][nLower][nUpper];
  TCanvas *can[nSet][nLower][nUpper];
  std::ostringstream hname;

  TFile *outputfile = TFile::Open("hadfraction.root","NEW");
  outputfile->cd();
  TH2F* fracHad2D[nSet];
  TH1F* fracHad1D[nSet];
  for(unsigned iF(0); iF<nSet; iF++){
	hname.str("");
	hname << "fracHad2D_" << iF;
	fracHad2D[iF]=new TH2F(hname.str().c_str(),hname.str().c_str(),17,3.3,5,13,12,18);
	hname.str("");
    hname << "fracHad1D_" << iF;
    fracHad1D[iF]=new TH1F(hname.str().c_str(),hname.str().c_str(),100,0,0.4);
  } 
//************ Signal Tree **********************//
  TChain *egtree = new TChain("egTree");
  egtree->Add("../data/plot_hadron_2016.root");
  float eg_phoEt(0);
  float eg_phoSigma(0);
  float eg_phoChIso(0);
  
  egtree->SetBranchAddress("phoEt",     &eg_phoEt);
  egtree->SetBranchAddress("phoSigma",  &eg_phoSigma);
  egtree->SetBranchAddress("phoChIso",  &eg_phoChIso);

  TChain *mgtree = new TChain("mgTree","mgTree");
  mgtree->Add("../data/plot_hadron_2016.root");
  float mg_phoEt(0);
  float mg_phoSigma(0);
  float mg_phoChIso(0);
  
  mgtree->SetBranchAddress("phoEt",     &mg_phoEt);
  mgtree->SetBranchAddress("phoSigma",  &mg_phoSigma);
  mgtree->SetBranchAddress("phoChIso",  &mg_phoChIso);

  TChain *hadtree = new TChain("hadTree","hadTree");
  hadtree->Add("../data/plot_hadron_2016.root");
  float had_phoEt(0);
  float had_phoSigma(0);
  float had_phoChIso(0);
  
  hadtree->SetBranchAddress("phoEt",     &had_phoEt);
  hadtree->SetBranchAddress("phoSigma",  &had_phoSigma);
  hadtree->SetBranchAddress("phoChIso",  &had_phoChIso);

  TChain *Zeetree = new TChain("ZeeTree");
  Zeetree->Add("../data/plotZ_DoubleMu2016.root");
  float phoEt(0);
  float phoSigma(0);
  float invmass(0);
  bool  ismg(0); 
 
  Zeetree->SetBranchAddress("phoEt",     &phoEt);
  Zeetree->SetBranchAddress("phoSigma",  &phoSigma);
  Zeetree->SetBranchAddress("invmass",   &invmass);
  Zeetree->SetBranchAddress("ismg",      &ismg);

  double fittingError[nSet];
  double systematicError[nSet];
  for(unsigned iF(0); iF<nSet; iF++){ fittingError[iF] = 0; systematicError[iF] = 0;}

  for(unsigned iUpper(0); iUpper<nUpper; iUpper++){
    for(unsigned iLower(0); iLower<nLower; iLower++){
	  for(unsigned iF(0); iF<nSet; iF++){
		templatelist[iF][iLower][iUpper] = new TObjArray(2);
		hname.str("");
		hname << "can" << iF << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper] ;
		can[iF][iLower][iUpper]=new TCanvas(hname.str().c_str(),hname.str().c_str(),600,600);
		hname.str("");
        if(iF==nSet-1)hname << "p_SigmaZ-pt-140-inf" << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
        else hname <<"p_SigmaZ-pt-" << PtBins[iF] << "-" << PtBins[iF+1] << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
		h_data[iF][iLower][iUpper] = new TH1F(hname.str().c_str(), hname.str().c_str(), 40, 0.0, 0.02); 
		hname.str("");
		if(iF==nSet-1)hname<< "SigmaHadEB-pt-140-inf" << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
		else hname <<"SigmaHadEB-pt-" <<  PtBins[iF] << "-" << PtBins[iF+1] << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
		h_bg[iF][iLower][iUpper] = new TH1F(hname.str().c_str(), hname.str().c_str(), 40, 0.0, 0.02);
		hname.str("");
		if(iF==nSet-1)hname<< "p_SigmaTarEB-pt-140-inf" << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
		else hname <<"p_SigmaTarEB-pt-" <<  PtBins[iF] << "-" << PtBins[iF+1]<< "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper];
		h_target[iF][iLower][iUpper] = new TH1F(hname.str().c_str(), hname.str().c_str(),40, 0.0, 0.02);    

        for(unsigned ievt(0); ievt < Zeetree->GetEntries(); ievt++){
          Zeetree->GetEntry(ievt);
          if(invmass > 70 && invmass < 110 && ismg){
			if(PtBins[iF] < 50){
			  if(phoEt >= PtBins[iF] && phoEt < PtBins[iF+1])h_data[iF][iLower][iUpper]->Fill(phoSigma);
			}else{
              if(phoEt >= 50)h_data[iF][iLower][iUpper]->Fill(phoSigma);
			}
          }
        }
 
		double nden(0), totalden(0);
		double nnum(0), totalnum(0);
		for(unsigned ievt(0); ievt < mgtree->GetEntries(); ievt++){
		  mgtree->GetEntry(ievt);
		  if(iF!= nSet-1){
			if(mg_phoEt >= PtBins[iF] && mg_phoEt < PtBins[iF+1]){
			  if(mg_phoChIso <= 3.32){
                h_target[iF][iLower][iUpper]->Fill(mg_phoSigma);
                totalden+=1;
                if(mg_phoSigma < 0.0103)nden+=1;
              }
			}
		  }else{
			if(mg_phoEt >= PtBins[iF]){
			  if(mg_phoChIso <= 3.32){
                h_target[iF][iLower][iUpper]->Fill(mg_phoSigma);
                totalden+=1;
                if(mg_phoSigma < 0.0103)nden+=1;
              }
			}
		  }
		}

		for(unsigned ievt(0); ievt < mgtree->GetEntries(); ievt++){
		  mgtree->GetEntry(ievt);
		  if(iF!= nSet-1){
			if(mg_phoEt >= PtBins[iF] && mg_phoEt < PtBins[iF+1]){
			  if(mg_phoChIso > IsoCutLower[iLower] && mg_phoChIso < IsoCutUpper[iUpper]){
                h_bg[iF][iLower][iUpper]->Fill(mg_phoSigma);
                totalnum+=1;
                if(mg_phoSigma < 0.0103)nnum+=1;
              }
			}
		  }else{
			if(mg_phoEt >= PtBins[iF]){
			  if(mg_phoChIso > IsoCutLower[iLower] && mg_phoChIso < IsoCutUpper[iUpper]){
                h_bg[iF][iLower][iUpper]->Fill(mg_phoSigma);
                totalnum+=1;
                if(mg_phoSigma < 0.0103)nnum+=1;
              }
			}
		  }
		}
		double den = nden/totalden; 
		double denerror = (1.0/sqrt(nden)+ 1.0/sqrt(totalden))*den;
		double num = nnum/totalnum; 
		double numerror = (1.0/sqrt(nnum) + 1.0/sqrt(totalnum))*num;
		myfile << "pt=" << PtBins[iF] << " " <<  IsoCutLower[iLower] << " < Iso < " << IsoCutUpper[iUpper] <<  " numIntegral/entries = " << num << std::endl; 

		templatelist[iF][iLower][iUpper]->Add(h_data[iF][iLower][iUpper]);
		templatelist[iF][iLower][iUpper]->Add(h_bg[iF][iLower][iUpper]);
		fitter[iF][iLower][iUpper]= new TFractionFitter(h_target[iF][iLower][iUpper], templatelist[iF][iLower][iUpper], "V");
		fitter[iF][iLower][iUpper]->SetRangeX(3,32);
		fitter[iF][iLower][iUpper]->Constrain(1,0.0,1.0);
		Int_t status = fitter[iF][iLower][iUpper]->Fit();
		if(status == 0){
		  result[iF][iLower][iUpper] = (TH1F*)fitter[iF][iLower][iUpper]->GetPlot();
          result[iF][iLower][iUpper]->SetMinimum(0);
		  double fracBkg, errorBkg;
		  double fracSig, errorSig;
		  fitter[iF][iLower][iUpper]->GetResult(0, fracSig, errorSig);
		  fitter[iF][iLower][iUpper]->GetResult(1, fracBkg, errorBkg);
		  can[iF][iLower][iUpper]->cd();
		  h_target[iF][iLower][iUpper]->GetXaxis()->SetRangeUser(0.006,0.02);
		  h_target[iF][iLower][iUpper]->SetMarkerStyle(20);
		  h_target[iF][iLower][iUpper]->Draw("Ep");
		  result[iF][iLower][iUpper]->SetLineColor(kBlue);
		  result[iF][iLower][iUpper]->SetFillStyle(1001);
		  result[iF][iLower][iUpper]->SetFillColor(kBlue);
		  result[iF][iLower][iUpper]->Draw("same");
		  h_bg[iF][iLower][iUpper]->Scale(1.0/h_bg[iF][iLower][iUpper]->GetEntries()*h_target[iF][iLower][iUpper]->GetEntries()*fracBkg);
		  h_bg[iF][iLower][iUpper]->SetLineColor(kGreen);
		  h_bg[iF][iLower][iUpper]->SetFillStyle(1001);
		  h_bg[iF][iLower][iUpper]->SetFillColor(kGreen);
		  h_bg[iF][iLower][iUpper]->Draw("same");
		  h_target[iF][iLower][iUpper]->Draw("Ep same");
		  TLatex* latex = new TLatex();
		  hname.str("");
		  hname << "Bkg% = " << fracBkg << " #pm " << errorBkg << std::endl;
		  latex->DrawLatex(0.01,0.9*h_target[iF][iLower][iUpper]->GetMaximum(),hname.str().c_str()); 
		  hname.str("");
		  hname << "#chi^{2}/ndof = " << fitter[iF][iLower][iUpper]->GetChisquare() << "/" << fitter[iF][iLower][iUpper]->GetNDF(); 
		  latex->DrawLatex(0.01,0.8*h_target[iF][iLower][iUpper]->GetMaximum(),hname.str().c_str());
		  hname.str("");
		  hname << "frac=" << num << "*" << fracBkg << "/" << den << std::endl;
		  latex->DrawLatex(0.01,0.7*h_target[iF][iLower][iUpper]->GetMaximum(),hname.str().c_str());
		  hname.str("");
		  hname << " =" << num*fracBkg/den << " #pm " << (numerror/num + denerror/den + errorBkg/fracBkg)*num*fracBkg/den;
		  latex->DrawLatex(0.01,0.6*h_target[iF][iLower][iUpper]->GetMaximum(),hname.str().c_str());
		 
		  if(IsoCutLower[iLower] == 3.32 && IsoCutUpper[iUpper]==15.0){
            hadfrac << num*fracBkg/den << ",";
		    fittingError[iF] = (numerror/num + denerror/den + errorBkg/fracBkg)*num*fracBkg/den ;
          }
		  myfile << "frac = " << fracBkg << std::endl;
          fracHad2D[iF]->Fill(IsoCutLower[iLower], IsoCutUpper[iUpper], num*fracBkg/den);
          fracHad1D[iF]->Fill(num*fracBkg/den); 
		} 
		 
		hname.str("");
		hname << "frac" << iF << "_" << IsoCutLower[iLower] << "_" << IsoCutUpper[iUpper] << ".pdf";
		if(IsoCutLower[iLower] == 3.32 && IsoCutUpper[iUpper]==15.0)can[iF][iLower][iUpper]->SaveAs(hname.str().c_str());

	  }
    }
  }
  myfile << hadfrac.str().c_str() << std::endl;
  for(unsigned iF(0); iF < nSet; iF++)systematicError[iF] =  fracHad1D[iF]->GetMeanError();
  for(unsigned iF(0); iF < nSet; iF++)myfile << sqrt(fittingError[iF]*fittingError[iF] + systematicError[iF]*systematicError[iF]) << ",";
  myfile.close();
  outputfile->Write();
  return 1;
}
Exemplo n.º 7
0
Arquivo: drawE.C Projeto: phuo/Glauber
void drawE(){
    TChain* t = new TChain("t");
    char dfilelist[100];
    char name[100];
    sprintf(dfilelist,"outlist.txt");
    ifstream lis(dfilelist);
    int cnt=0;
    int dnt=0;
    while(!lis.eof())
    {
        string filename;
        lis >> filename;
        if(cnt>=0&&cnt<100)
        {
            cout << filename << endl;
            if(!filename.empty()) t->Add(filename.c_str());
            dnt++;
        }
        cnt++;
    }

    double fAngGl[ETOT],feGl[ETOT];
    double frAngGl[ETOT],freGl[ETOT];

    double pfAngGl[ETOT],pfeGl[ETOT];
    double pfrAngGl[ETOT],pfreGl[ETOT];

    double b;
    int ncoll;
    int npart,npartproj,nparttarg;
    int nHitBbc_n, nHitBbc_s, BBCTrig;
    int Centbin;
    double qBBC_n, qBBC_s, pTrigBBC;
    double vertex, ecc_std,ecc_rp, ecc_part,ecc_partr,r_ollitra,r_geo,r_arith,r_ollitrar,r_geor,r_arithr,e4;


    float nux[600] ;
    float nuy[600] ;
    int  st_part[600] ;

    t->SetBranchAddress("b",            &b);
    t->SetBranchAddress("Centbin",   &Centbin);
    t->SetBranchAddress("ncoll",        &ncoll);
    t->SetBranchAddress("npart",        &npart);
    /*    t->SetBranchAddress("npartproj",    &npartproj);
          t->SetBranchAddress("nparttarg",    &nparttarg);
          t->SetBranchAddress("ecc_std",      &ecc_std);
          t->SetBranchAddress("ecc_rp",       &ecc_rp);
          t->SetBranchAddress("ecc_part",     &ecc_part);

          t->SetBranchAddress("e_gl",         feGl);
          t->SetBranchAddress("ang_gl",    fAngGl);
          t->SetBranchAddress("re_gl",       freGl);
          t->SetBranchAddress("rang_gl", frAngGl);

          t->SetBranchAddress("nux", &nux);
          t->SetBranchAddress("nuy", &nuy);
          t->SetBranchAddress("st_part",&st_part);

          t->SetBranchAddress("pe_gl",        pfeGl);
          t->SetBranchAddress("pang_gl",      pfAngGl);
          */
    t->SetBranchAddress("pre_gl",       pfreGl);
    t->SetBranchAddress("prang_gl",     pfrAngGl);

    cout<<t->GetEntries()/1000000<<endl;

    TH1* hevent[7];
    for(int ic=0;ic<7; ic++){
   sprintf(name, "hevent%d", ic); 
    hevent[ic]= new TH1D(name, name,10, 0-0.5, 50-0.5);
    }


    for(int iev=0; iev<t->GetEntries(); iev++){
        t->GetEntry(iev);
        if(iev%10000000==0) cout<<iev<<endl;
        if(Centbin!=0) continue;
        int Ebin[6] = {-1,-1,-1,-1,-1,-1};
        int cutID[7] = {0,0,0,0,0,0,0};
        for(int ih=0;ih<6; ih++){ //iHar bin
            Ebin[ih] = findEbin(Centbin, pfreGl[ih], ih);
        }
        if(Ebin[5]<10 && Ebin[1]<10 && Ebin[2]<10 && Ebin[3]<10 && Ebin[4]<10) cutID[0] = 1;
        if(Ebin[0]<10 && Ebin[5]<10 && Ebin[2]<10 && Ebin[3]<10 && Ebin[4]<10) cutID[1] = 1;
        if(Ebin[0]<10 && Ebin[1]<10 && Ebin[5]<10 && Ebin[3]<10 && Ebin[4]<10) cutID[2] = 1;
        if(Ebin[0]<10 && Ebin[1]<10 && Ebin[2]<10 && Ebin[5]<10 && Ebin[4]<10) cutID[3] = 1;
        if(Ebin[0]<10 && Ebin[1]<10 && Ebin[2]<10 && Ebin[3]<10 && Ebin[5]<10) cutID[4] = 1;
        if(Ebin[0]<10 && Ebin[1]<10 && Ebin[2]<10 && Ebin[3]<10 && Ebin[4]<10) cutID[5] = 1;
        cutID[6] = 1;

        for(int i=0; i<6; i++){
            if(cutID[i] == 1) hevent[i]->Fill(Ebin[i]);
        }
    }
    //hevent->DrawClone();
    for(int i=0;i<6; i++){
    hevent[i]->Scale(1.0/hevent[i]->GetEntries());

        for(int ib=0; ib<10; ib++){
        cout<<hevent[i]->GetBinContent(ib+1)<<"  ";
        }
        cout<<endl;
    }
    /*  gStyle->SetOptStat(0);

        TLatex ptext;

        ptext.SetNDC(1);
        ptext.SetTextFont(43);
        ptext.SetTextSize(15.5);
        ptext.SetTextColor(2);


        gStyle->SetOptTitle(0);
        TH2* hist = new TH2D("hist", "hist", 104, -13, 13, 104, -13, 13);
        TCanvas* c1 = new TCanvas("c1","c1", 400*3, 400*2);
        c1->Divide(3,2);
        int ccnt=0;
        double rg[] = {0.12,0.2,0.2,0.2,0.2,0.3,0.3};
        double rg2[] = {0.05, 0.05, 0.05, 0.05,0.05, 0.05};

        for(int iev=0; iev<t->GetEntries(); iev++){
        t->GetEntry(iev);
        if(iev%100000==0) cout<<iev<<endl;

        if(ccnt==6) break;
        if(b>6) continue;
        if(fabs(pfreGl[ccnt] - rg[ccnt]) >0.02) continue;
        int badd=0;
        for(int ij=0;ij<6; ij++){
        if(ij==ccnt) continue;
        if(pfreGl[ij] > rg2[ij]) badd=1;
        }
        if(badd==1) continue;
        cout<<b<<"  "<<pfreGl[ccnt]<<"  "<<fabs(pfreGl[ccnt] - rg[ccnt])<<"  "<< rg[ccnt]<<"  "<<ccnt<<endl;
        c1->cd(ccnt+1);
        hist->Draw();
        Double_t r = 0.5*sqrt(64/TMath::Pi()/10.);
        TEllipse e;

// cout<<nux->size()<<endl;
for(int in=0; in<600; in++){
e.SetLineColor(kBlack);
e.SetFillColor(0);
e.SetLineWidth(1);
e.SetFillStyle(0);
if(abs(st_part[in])!=1) continue;
e.DrawEllipse(nux[in],nuy[in],r,r,0,360,0,"same");
    //   cout<<nux[in]<<endl;
    }

    TEllipse e1;
    for(int in=0; in<600; in++){
    e1.SetLineColor(kBlack);
    if(st_part[in]==0) continue;
    if(abs(st_part[in])==2)  {
    e1.SetLineStyle(1);
    e1.SetFillStyle(0);
    //      e1.SetFillColor(kGreen);
    if(st_part[in]==2)  e1.SetLineColor(kBlue);
    if(st_part[in]==-2)  e1.SetLineColor(kRed);
    e1.DrawEllipse(nux[in],nuy[in],r,r,0,360,0,"same");
    }
    //   cout<<nux[in]<<endl;
    }
    sprintf(name, "b = %4.2f", b);
    ptext.DrawLatex(0.8, 0.67,name);
    for(int i=0; i<6; i++){
    sprintf(name, "#epsilon_{%d}=%4.2f", i+1, pfreGl[i]);
    ptext.DrawLatex(0.8, 0.7+i*0.04,name);
    }
    e.SetFillColor(0);
    e.SetFillStyle(0);
    e.SetLineColor(1);
e.SetLineStyle(2);
e.SetLineWidth(1);
e.DrawEllipse(b/2,0,6.62,6.62,0,360,0,"same");
e.DrawEllipse(-b/2,0,6.62,6.62,0,360,0,"same");

ccnt++;
}
*/

}
Exemplo n.º 8
0
void CPVanalysis(const TString dataset="")
{
    
  gSystem->Load("libTree");
  gSystem->Load("libGeom");
  gSystem->Load("libVMC");
  gSystem->Load("libPhysics");
  
  //load analysis framework
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
  
  gSystem->AddIncludePath("-I$ALICE_ROOT/include -I$ALICE_ROOT/PHOS");

  // A task can be compiled dynamically with AClic
  gROOT->LoadMacro("AliAnalysisTaskCPV.cxx+g");
  
  // Connect to alien
  TString token = gSystem->Getenv("GRID_TOKEN") ;
  token="OK";
  if ( token == "OK" ) 
    TGrid::Connect("alien://");
  else 
    Printf("You are not connected to the GRID") ; 
    // AliInfo("You are not connected to the GRID") ; 

  cout << "CPVanalysis: processing collection " << dataset << endl;
  
  // Create the chain
    TChain* chain;

  if (dataset.Contains(".txt")) {
    gROOT->LoadMacro("$ALICE_PHYSICS/PWG/EMCAL/macros/CreateESDChain.C");
    chain = CreateESDChain(dataset.Data(), 1000);
  }
  else if (dataset.Contains(".xml")) {
    chain = new TChain("esdTree");
    TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
  
    TAlienResult* result = collection->GetGridResult("",0 ,0);
    TList* rawFileList = result->GetFileInfoList();
    
    for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
      TFileInfo * fi =  static_cast<TFileInfo*>(rawFileList->At(counter)) ; 
      const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;  
      printf("Processing %s\n", rawFile) ;
      chain->Add(rawFile);
      printf("Chain: %d entries.\n",chain->GetEntries()); 
    }
  }
  
  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("CPVanalysis");
  
  // ESD input handler
  AliESDInputHandler* esdH = new AliESDInputHandler();
  esdH->SetReadFriends(kFALSE);
  mgr->SetInputEventHandler(esdH);
  
  // Debug level
  mgr->SetDebugLevel(0);
  
  //PID task
  gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C");
  AliAnalysisTask *taskPID =  AddTaskPIDResponse(/*Bool_t isMC=*/ kFALSE, /*Bool_t autoMCesd=*/kTRUE,
						 /*Bool_t tuneOnData=*/kTRUE);

  // // Add physics selection
  gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskPhysicsSelection.C");
  AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection();
  physSelTask->GetPhysicsSelection()->SetUseBXNumbers(kFALSE);// ---> ???

  // Add my task
  AliAnalysisTaskCPV *task1 = new AliAnalysisTaskCPV("CPVanalysis");

  // task1->SelectCollisionCandidates(AliVEvent::kMB);
  mgr->AddTask(task1);
  
  // Create containers for input/output
  AliAnalysisDataContainer *cinput   = mgr->GetCommonInputContainer(); 
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("histCPV1",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root");
  AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("histCPV2",TList::Class(),AliAnalysisManager::kOutputContainer,"CPVanalysis.root");

  ((AliInputEventHandler*)mgr->GetInputEventHandler())->SetNeedField(1);


  // Connect input/output
  mgr->ConnectInput(task1 , 0, cinput);
  mgr->ConnectOutput(task1, 1, coutput1);
  mgr->ConnectOutput(task1, 2, coutput2);
  
  if (mgr->InitAnalysis()) {
    mgr->PrintStatus();
    mgr->StartAnalysis("local", chain);
  }
  
}
Exemplo n.º 9
0
Arquivo: hadd.C Projeto: Y--/root
void MergeRootfile( TDirectory *target, TList *sourcelist ) {

   //  cout << "Target path: " << target->GetPath() << endl;
   TString path( (char*)strstr( target->GetPath(), ":" ) );
   path.Remove( 0, 2 );

   TFile *first_source = (TFile*)sourcelist->First();
   first_source->cd( path );
   TDirectory *current_sourcedir = gDirectory;
   //gain time, do not add the objects in the list in memory
   Bool_t status = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);

   // loop over all keys in this directory
   TChain *globChain = 0;
   TIter nextkey( current_sourcedir->GetListOfKeys() );
   TKey *key, *oldkey=0;
   while ( (key = (TKey*)nextkey())) {

      //keep only the highest cycle number for each key
      if (oldkey && !strcmp(oldkey->GetName(),key->GetName())) continue;

      // read object from first source file
      first_source->cd( path );
      TObject *obj = key->ReadObj();

      if ( obj->IsA()->InheritsFrom( TH1::Class() ) ) {
         // descendant of TH1 -> merge it

         //      cout << "Merging histogram " << obj->GetName() << endl;
         TH1 *h1 = (TH1*)obj;

         // loop over all source files and add the content of the
         // correspondant histogram to the one pointed to by "h1"
         TFile *nextsource = (TFile*)sourcelist->After( first_source );
         while ( nextsource ) {

            // make sure we are at the correct directory level by cd'ing to path
            nextsource->cd( path );
            TKey *key2 = (TKey*)gDirectory->GetListOfKeys()->FindObject(h1->GetName());
            if (key2) {
               TH1 *h2 = (TH1*)key2->ReadObj();
               h1->Add( h2 );
               delete h2;
            }

            nextsource = (TFile*)sourcelist->After( nextsource );
         }
      }
      else if ( obj->IsA()->InheritsFrom( TTree::Class() ) ) {

         // loop over all source files create a chain of Trees "globChain"
         const char* obj_name= obj->GetName();

         globChain = new TChain(obj_name);
         globChain->Add(first_source->GetName());
         TFile *nextsource = (TFile*)sourcelist->After( first_source );
         //      const char* file_name = nextsource->GetName();
         // cout << "file name  " << file_name << endl;
         while ( nextsource ) {

            globChain->Add(nextsource->GetName());
            nextsource = (TFile*)sourcelist->After( nextsource );
         }

      } else if ( obj->IsA()->InheritsFrom( TDirectory::Class() ) ) {
         // it's a subdirectory

         cout << "Found subdirectory " << obj->GetName() << endl;

         // create a new subdir of same name and title in the target file
         target->cd();
         TDirectory *newdir = target->mkdir( obj->GetName(), obj->GetTitle() );

         // newdir is now the starting point of another round of merging
         // newdir still knows its depth within the target file via
         // GetPath(), so we can still figure out where we are in the recursion
         MergeRootfile( newdir, sourcelist );

      } else {

         // object is of no type that we know or can handle
         cout << "Unknown object type, name: "
         << obj->GetName() << " title: " << obj->GetTitle() << endl;
      }

      // now write the merged histogram (which is "in" obj) to the target file
      // note that this will just store obj in the current directory level,
      // which is not persistent until the complete directory itself is stored
      // by "target->Write()" below
      if ( obj ) {
         target->cd();

         //!!if the object is a tree, it is stored in globChain...
         if(obj->IsA()->InheritsFrom( TTree::Class() ))
            globChain->Merge(target->GetFile(),0,"keep");
         else
            obj->Write( key->GetName() );
      }

   } // while ( ( TKey *key = (TKey*)nextkey() ) )

   // save modifications to target file
   target->SaveSelf(kTRUE);
   TH1::AddDirectory(status);
}
Exemplo n.º 10
0
int main( int argc, char* argv[] ) {


  std::string runName = "precalib_BGO_pedestal_noSource";
  if( argc>1 ) {
    std::string runName_str(argv[1]);
    runName = runName_str;
  }

  std::string tag = "V00";
  if( argc>2 ) {
    std::string tag_str(argv[2]);
    tag = tag_str;
  }

  TString runName_tstr(runName);
  bool isOnlyRunNumber = !(runName_tstr.BeginsWith("BTF_"));


  TChain* tree = new TChain("recoTree");
  if( isOnlyRunNumber ) {
    std::cout << "-> We believe you are passing the program only the run number!" << std::endl;
    std::cout << "-> So for instance you are passing '246' for run 'BTF_246_20140501-212512_beam'" << std::endl;
    std::cout << "(if this is not the case this means TROUBLE)" << std::endl;
    std::cout << "-> Will look for runs matching run number: " << runName << std::endl;
    tree->Add(Form("analysisTrees_%s/Reco_BTF_%s_*beam.root/recoTree", tag.c_str(), runName.c_str()) );
    if( tree->GetEntries()==0 ) {
      std::cout << "WARNING! Didn't find any events matching run: " << runName << std::endl;
      std::cout << "Exiting" << std::endl;
      exit(1913);
    }
  } else {
    std::string fileName = "analysisTrees_"+tag+"/Reco_" + runName + ".root";
    TFile* file = TFile::Open(fileName.c_str());
    if( file==0 ) {
      std::cout << "ERROR! Din't find file " << fileName << std::endl;
      std::cout << "Exiting." << std::endl;
      exit(11);
    }
    tree = (TChain*)file->Get("recoTree");
  }





  UInt_t evtNumber;
  tree->SetBranchAddress( "evtNumber", &evtNumber );
  UInt_t adcData[40];
  tree->SetBranchAddress( "adcData", adcData );
  UInt_t adcBoard[40];
  tree->SetBranchAddress( "adcBoard", adcBoard );
  UInt_t adcChannel[40];
  tree->SetBranchAddress( "adcChannel", adcChannel );


  unsigned int runNumber;
  int nHodoFibersX;
  int nHodoFibersY;
  int nHodoClustersX;
  int nHodoClustersY;
  float cef3_corr[CEF3_CHANNELS];
  float bgo_corr[BGO_CHANNELS];
  float scintFront;
  float pos_hodoClustX[HODOX_CHANNELS];
  float pos_hodoClustY[HODOY_CHANNELS];
  int nFibres_hodoClustX[HODOX_CHANNELS];
  int nFibres_hodoClustY[HODOY_CHANNELS];
  float xBeam, yBeam;
  bool isSingleEle_scintFront;
  bool cef3_ok;
  bool cef3_corr_ok;
  bool bgo_ok;
  bool bgo_corr_ok;

  tree->SetBranchAddress( "runNumber", &runNumber );

  tree->SetBranchAddress( "scintFront", &scintFront );
  tree->SetBranchAddress( "cef3_corr", cef3_corr );
  tree->SetBranchAddress( "bgo_corr", bgo_corr );

  tree->SetBranchAddress( "nHodoFibersX", &nHodoFibersX );
  tree->SetBranchAddress( "nHodoFibersY", &nHodoFibersY );
  tree->SetBranchAddress( "nHodoClustersX", &nHodoClustersX );
  tree->SetBranchAddress( "pos_hodoClustX", pos_hodoClustX );
  tree->SetBranchAddress( "nFibres_hodoClustX", nFibres_hodoClustX );
  tree->SetBranchAddress( "nHodoClustersY", &nHodoClustersY );
  tree->SetBranchAddress( "pos_hodoClustY", pos_hodoClustY );
  tree->SetBranchAddress( "nFibres_hodoClustY", nFibres_hodoClustY );
  tree->SetBranchAddress( "scintFront", &scintFront );
  tree->SetBranchAddress( "isSingleEle_scintFront", &isSingleEle_scintFront );
  tree->SetBranchAddress( "xBeam", &xBeam );
  tree->SetBranchAddress( "yBeam", &yBeam );

  tree->SetBranchAddress( "cef3_ok", &cef3_ok );
  tree->SetBranchAddress( "cef3_corr_ok", &cef3_corr_ok );
  tree->SetBranchAddress( "bgo_ok", &bgo_ok );
  tree->SetBranchAddress( "bgo_corr_ok", &bgo_corr_ok );




  int nBins = 500;
  float xMax = 25.*3./2.;


  TH1D* h1_xPos = new TH1D("xPos", "", nBins, -xMax, xMax);
  TH1D* h1_yPos = new TH1D("yPos", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos = new TH2D("xyPos", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_singleEle = new TH1D("xPos_singleEle", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_singleEle = new TH1D("yPos_singleEle", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle = new TH2D("xyPos_singleEle", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_new = new TH1D("xPos_new", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_new = new TH1D("yPos_new", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_new = new TH2D("xyPos_new", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_new_singleEle = new TH1D("xPos_new_singleEle", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_new_singleEle = new TH1D("yPos_new_singleEle", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_new_singleEle = new TH2D("xyPos_new_singleEle", "", nBins, -xMax, xMax, nBins, -xMax, xMax);


  TH1D* h1_xPos_bgo = new TH1D("xPos_bgo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_bgo = new TH1D("yPos_bgo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_bgo = new TH2D("xyPos_bgo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_singleEle_bgo = new TH1D("xPos_singleEle_bgo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_singleEle_bgo = new TH1D("yPos_singleEle_bgo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle_bgo = new TH2D("xyPos_singleEle_bgo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_hodo = new TH1D("xPos_hodo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_hodo = new TH1D("yPos_hodo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_hodo = new TH2D("xyPos_hodo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_singleEle_hodo = new TH1D("xPos_singleEle_hodo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_singleEle_hodo = new TH1D("yPos_singleEle_hodo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle_hodo = new TH2D("xyPos_singleEle_hodo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_singleEle_hodoClust = new TH1D("xPos_singleEle_hodoClust", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_singleEle_hodoClust = new TH1D("yPos_singleEle_hodoClust", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle_hodoClust = new TH2D("xyPos_singleEle_hodoClust", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_calo = new TH1D("xPos_calo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo = new TH1D("yPos_calo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_calo = new TH2D("xyPos_calo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_singleEle_calo = new TH1D("xPos_singleEle_calo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_singleEle_calo = new TH1D("yPos_singleEle_calo", "", nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle_calo = new TH2D("xyPos_singleEle_calo", "", nBins, -xMax, xMax, nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_hodo = new TH1D("xPos_calo_vs_hodo", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_hodo = new TH1D("yPos_calo_vs_hodo", "", nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_beam = new TH1D("xPos_calo_vs_beam", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_beam = new TH1D("yPos_calo_vs_beam", "", nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_hodo_singleElectron = new TH1D("xPos_calo_vs_hodo_singleElectron", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_hodo_singleElectron = new TH1D("yPos_calo_vs_hodo_singleElectron", "", nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_beam_singleElectron = new TH1D("xPos_calo_vs_beam_singleElectron", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_beam_singleElectron = new TH1D("yPos_calo_vs_beam_singleElectron", "", nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_hodo_singleElectron_HR = new TH1D("xPos_calo_vs_hodo_singleElectron_HR", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_hodo_singleElectron_HR = new TH1D("yPos_calo_vs_hodo_singleElectron_HR", "", nBins, -xMax, xMax);

  TH1D* h1_xPos_calo_vs_beam_singleElectron_HR = new TH1D("xPos_calo_vs_beam_singleElectron_HR", "", nBins, -xMax, xMax);
  TH1D* h1_yPos_calo_vs_beam_singleElectron_HR = new TH1D("yPos_calo_vs_beam_singleElectron_HR", "", nBins, -xMax, xMax);


  TH2D* h2_correlation_cef3_hodo_xPos = new TH2D("correlation_cef3_hodo_xPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_cef3_hodo_yPos = new TH2D("correlation_cef3_hodo_yPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);

  TH2D* h2_correlation_cef3_bgo_xPos = new TH2D("correlation_cef3_bgo_xPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_cef3_bgo_yPos = new TH2D("correlation_cef3_bgo_yPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);

  TH2D* h2_correlation_hodo_bgo_xPos = new TH2D("correlation_hodo_bgo_xPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_hodo_bgo_yPos = new TH2D("correlation_hodo_bgo_yPos", "", 100, -12.5, 12.5,  100, -12.5, 12.5);


  TH2D* h2_correlation_cef3_hodo_xPos_singleEle = new TH2D("correlation_cef3_hodo_xPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_cef3_hodo_yPos_singleEle = new TH2D("correlation_cef3_hodo_yPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);

  TH2D* h2_correlation_cef3_bgo_xPos_singleEle = new TH2D("correlation_cef3_bgo_xPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_cef3_bgo_yPos_singleEle = new TH2D("correlation_cef3_bgo_yPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);

  TH2D* h2_correlation_hodo_bgo_xPos_singleEle = new TH2D("correlation_hodo_bgo_xPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);
  TH2D* h2_correlation_hodo_bgo_yPos_singleEle = new TH2D("correlation_hodo_bgo_yPos_singleEle", "", 100, -12.5, 12.5,  100, -12.5, 12.5);



  int nentries = tree->GetEntries();


  if( isOnlyRunNumber ) {
    // modify runname in such a way that it's useful for getBeamPosition and outfile:
    runName = "BTF_" + runName + "_beam";
  }



  std::string outputdir = "PosAnTrees_"+tag;
  system( Form("mkdir -p %s", outputdir.c_str()) );
  std::string outfileName = outputdir + "/PosAn_" + runName + ".root";
  TFile* outfile = TFile::Open( outfileName.c_str(), "RECREATE" );

  TTree* outTree = new TTree("posTree","posTree");
  float xPos_calo_, yPos_calo_;
  float xPos_bgo_, yPos_bgo_;
  float xPos_new_, yPos_new_;
  float xPos_regr2D_, yPos_regr2D_;
  float r02_, r13_;

  outTree->Branch( "isSingleEle_scintFront", &isSingleEle_scintFront, "isSingleEle_scintFront/O" );
  outTree->Branch( "nHodoClustersX", &nHodoClustersX, "nHodoClustersX/I" );
  outTree->Branch( "nHodoClustersY", &nHodoClustersY, "nHodoClustersY/I" );
  outTree->Branch( "cef3_corr", cef3_corr, "cef3_corr[4]/F" );
  outTree->Branch( "r02", &r02_, "r02_/F" );
  outTree->Branch( "r13", &r13_, "r13_/F" );
  outTree->Branch( "xBeam", &xBeam, "xBeam/F" );
  outTree->Branch( "yBeam", &yBeam, "yBeam/F" );
  outTree->Branch( "xPos_bgo", &xPos_bgo_, "xPos_bgo_/F" );
  outTree->Branch( "yPos_bgo", &yPos_bgo_, "yPos_bgo_/F" );
  outTree->Branch( "xPos_calo", &xPos_calo_, "xPos_calo_/F" );
  outTree->Branch( "yPos_calo", &yPos_calo_, "yPos_calo_/F" );
  outTree->Branch( "xPos_new", &xPos_new_, "xPos_new_/F" );
  outTree->Branch( "yPos_new", &yPos_new_, "yPos_new_/F" );
  outTree->Branch( "xPos_regr2D", &xPos_regr2D_, "xPos_regr2D_/F" );
  outTree->Branch( "yPos_regr2D", &yPos_regr2D_, "yPos_regr2D_/F" );

  float diag02_calo_;
  float diag13_calo_;
  outTree->Branch( "diag02_calo", &diag02_calo_, "diag02_calo_/F" );
  outTree->Branch( "diag13_calo", &diag13_calo_, "diag13_calo_/F" );
  float diag02_new_;
  float diag13_new_;
  outTree->Branch( "diag02_new", &diag02_new_, "diag02_new_/F" );
  outTree->Branch( "diag13_new", &diag13_new_, "diag13_new_/F" );
  float diag02_beam_;
  float diag13_beam_;
  outTree->Branch( "diag02_beam", &diag02_beam_, "diag02_beam_/F" );
  outTree->Branch( "diag13_beam", &diag13_beam_, "diag13_beam_/F" );

  
  std::vector<float> xbgo, ybgo;
  for( unsigned i=0; i<BGO_CHANNELS; ++i ) {
    float x,y;
    RunHelper::getBGOCoordinates( i, x, y );
    xbgo.push_back( x );
    ybgo.push_back( y );
  }


  
  



  float cef3_regr[CEF3_CHANNELS];
  //TMVA::Reader* readerRegrX = new TMVA::Reader( "!Color:!Silent" );
  //readerRegrX->AddVariable("cef3_corr[0]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[0] );
  //readerRegrX->AddVariable("cef3_corr[1]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[1] );
  //readerRegrX->AddVariable("cef3_corr[2]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[2] );
  //readerRegrX->AddVariable("cef3_corr[3]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[3] );

  //TMVA::Reader* readerRegrY = new TMVA::Reader( "!Color:!Silent" );
  //readerRegrY->AddVariable("cef3_corr[0]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[0] );
  //readerRegrY->AddVariable("cef3_corr[1]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[1] );
  //readerRegrY->AddVariable("cef3_corr[2]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[2] );
  //readerRegrY->AddVariable("cef3_corr[3]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3])", &cef3_regr[3] ); // let try this trick

  //TMVA::Reader* readerRegr2D = new TMVA::Reader( "!Color:!Silent" );
  //readerRegr2D->AddVariable("cef3_corr[0]", &cef3_corr_[0] );
  //readerRegr2D->AddVariable("cef3_corr[1]", &cef3_corr_[1] );
  //readerRegr2D->AddVariable("cef3_corr[2]", &cef3_corr_[2] );
  //readerRegr2D->AddVariable("cef3_corr[3]", &cef3_corr_[3] );
  //readerRegr2D->BookMVA( "MLP", "TMVA/weights/TMVARegression_MLP.weights.xml" );


  std::vector<std::string> methodNames;
  //methodNames.push_back("BDTG");
  ////methodNames.push_back("FDA_MT");
  //methodNames.push_back("LD");
  //methodNames.push_back("MLP");
  ////methodNames.push_back("PDERS");

 
  //
  //std::cout << "-> Booking TMVA Reader" << std::endl;
  //for( unsigned i=0; i<methodNames.size(); ++i ) {
  //  readerRegrX->BookMVA( methodNames[i], Form("TMVA/weights/TMVARegression_%s.weights.xml", methodNames[i].c_str()) ); 
  //  readerRegrY->BookMVA( methodNames[i], Form("TMVA/weights/TMVARegression_%s.weights.xml", methodNames[i].c_str()) ); 
  //}


  std::vector< TH1D* > h1_xPos_regr_vs_calo;
  std::vector< TH1D* > h1_yPos_regr_vs_calo;
  std::vector< TH2D* > h2_xyPos_regr;
  std::vector< TH1D* > h1_xPos_regr_vs_calo_singleEle;
  std::vector< TH1D* > h1_yPos_regr_vs_calo_singleEle;
  std::vector< TH2D* > h2_xyPos_singleEle_regr;
  for( unsigned i=0; i<methodNames.size(); ++i ) {
    TH1D* newHistx = new TH1D( Form("xPos_regr%s_vs_calo", methodNames[i].c_str()), "", nBins, -xMax, xMax);
    h1_xPos_regr_vs_calo.push_back( newHistx );
    TH1D* newHisty = new TH1D( Form("yPos_regr%s_vs_calo", methodNames[i].c_str()), "", nBins, -xMax, xMax);
    h1_yPos_regr_vs_calo.push_back( newHisty );
    TH2D* newHistxy = new TH2D( Form("xyPos_regr%s", methodNames[i].c_str()), "", nBins, -xMax, xMax, nBins, -xMax, xMax);
    h2_xyPos_regr.push_back( newHistxy );
    TH1D* newHistx_singleEle = new TH1D( Form("xPos_regr%s_vs_calo_singleEle", methodNames[i].c_str()), "", nBins, -xMax, xMax);
    h1_xPos_regr_vs_calo_singleEle.push_back( newHistx_singleEle );
    TH1D* newHisty_singleEle = new TH1D( Form("yPos_regr%s_vs_calo_singleEle", methodNames[i].c_str()), "", nBins, -xMax, xMax);
    h1_yPos_regr_vs_calo_singleEle.push_back( newHisty_singleEle );
    TH2D* newHistxy_singleEle = new TH2D( Form("xyPos_singleEle_regr%s", methodNames[i].c_str()), "", nBins, -xMax, xMax, nBins, -xMax, xMax);
    h2_xyPos_singleEle_regr.push_back( newHistxy_singleEle );
  }


  TH2D* h2_xyPos_regr2D = new TH2D("xyPos_regr2D", "", nBins, -xMax, xMax, nBins, -xMax, xMax);
  TH2D* h2_xyPos_singleEle_regr2D = new TH2D("xyPos_singleEle_regr2D", "", nBins, -xMax, xMax, nBins, -xMax, xMax);





  for( unsigned iEntry=0; iEntry<nentries; ++iEntry ) {

    xPos_bgo_ = -999.;
    yPos_bgo_ = -999.;

    xPos_calo_ = -999.;
    yPos_calo_ = -999.;


    tree->GetEntry(iEntry);

    if( iEntry % 5000 == 0 ) std::cout << "Entry: " << iEntry << " / " << nentries << std::endl;

    if( !bgo_corr_ok ) continue;

    r02_ = cef3_corr[0]/cef3_corr[2];
    r13_ = cef3_corr[1]/cef3_corr[3];

    // FIRST GET POSITION FROM HODOSCOPE:


    float xPos_hodo = getMeanposHodo(nHodoClustersX, pos_hodoClustX);
    float yPos_hodo = getMeanposHodo(nHodoClustersY, pos_hodoClustY);



    if( xPos_hodo>-100. )
      h1_xPos_hodo->Fill(xPos_hodo);
    if( yPos_hodo>-100. )
      h1_yPos_hodo->Fill(yPos_hodo);

    if( xPos_hodo>-100. && yPos_hodo>-100. ) 
      h2_xyPos_hodo->Fill(xPos_hodo, yPos_hodo);


    if( isSingleEle_scintFront ) {

      if( xPos_hodo>-100. )
        h1_xPos_singleEle_hodo->Fill(xPos_hodo);
      if( yPos_hodo>-100. )
        h1_yPos_singleEle_hodo->Fill(yPos_hodo);

      if( xPos_hodo>-100. && yPos_hodo>-100. ) 
        h2_xyPos_singleEle_hodo->Fill(xPos_hodo, yPos_hodo);

    }



    std::vector<float> xPosW_bgo;
    std::vector<float> yPosW_bgo;

    std::vector<float> v_bgo_corr;
    for( unsigned i=0; i<BGO_CHANNELS; ++i ) v_bgo_corr.push_back(bgo_corr[i]);

    float eTot_bgo_corr = sumVector(v_bgo_corr);

    if( bgo_ok && bgo_corr_ok ) {

      //   0  1  2
      //   3     4
      //   5  6  7

      xPosW_bgo.push_back(bgo_corr[0]*xbgo[0]);
      xPosW_bgo.push_back(bgo_corr[1]*xbgo[1]);
      xPosW_bgo.push_back(bgo_corr[2]*xbgo[2]);
      xPosW_bgo.push_back(bgo_corr[3]*xbgo[3]);
      xPosW_bgo.push_back(bgo_corr[4]*xbgo[4]);
      xPosW_bgo.push_back(bgo_corr[5]*xbgo[5]);
      xPosW_bgo.push_back(bgo_corr[6]*xbgo[6]);
      xPosW_bgo.push_back(bgo_corr[7]*xbgo[7]);
      
      yPosW_bgo.push_back(bgo_corr[0]*ybgo[0]);
      yPosW_bgo.push_back(bgo_corr[1]*ybgo[1]);
      yPosW_bgo.push_back(bgo_corr[2]*ybgo[2]);
      yPosW_bgo.push_back(bgo_corr[3]*ybgo[3]);
      yPosW_bgo.push_back(bgo_corr[4]*ybgo[4]);
      yPosW_bgo.push_back(bgo_corr[5]*ybgo[5]);
      yPosW_bgo.push_back(bgo_corr[6]*ybgo[6]);
      yPosW_bgo.push_back(bgo_corr[7]*ybgo[7]);
      

      xPos_bgo_ = sumVector( xPosW_bgo )/eTot_bgo_corr;
      yPos_bgo_ = sumVector( yPosW_bgo )/eTot_bgo_corr;
      
      h1_xPos_bgo->Fill( xPos_bgo_ );
      h1_yPos_bgo->Fill( yPos_bgo_ );
      h2_xyPos_bgo->Fill( xPos_bgo_, yPos_bgo_ );

      h2_correlation_hodo_bgo_xPos->Fill( xPos_hodo, xPos_bgo_ );
      h2_correlation_hodo_bgo_yPos->Fill( yPos_hodo, yPos_bgo_ );
      
      if( isSingleEle_scintFront ) {

        h1_xPos_singleEle_bgo->Fill( xPos_bgo_ );
        h1_yPos_singleEle_bgo->Fill( yPos_bgo_ );
        h2_xyPos_singleEle_bgo->Fill( xPos_bgo_, yPos_bgo_ );

        h2_correlation_hodo_bgo_xPos_singleEle->Fill( xPos_hodo, xPos_bgo_ );
        h2_correlation_hodo_bgo_yPos_singleEle->Fill( yPos_hodo, yPos_bgo_ );

      }
      
    }  // if bgo ok



    // THEN USE CeF3 DATA:

    if( cef3_ok ) {


      std::vector<float> v_cef3_corr;
      for(unsigned i=0; i<CEF3_CHANNELS; ++i) v_cef3_corr.push_back(cef3_corr[i]);

      float eTot_corr = sumVector(v_cef3_corr);

      

      if( cef3_corr_ok ) {


        //   0      1
        //          
        //          
        //   3      2


        float position = 12. - 0.696; // using FN's infallible trigonometry

        //std::vector

        std::vector<float> xPosW;
        xPosW.push_back(cef3_corr[0]*(-position));
        xPosW.push_back(cef3_corr[1]*(+position));
        xPosW.push_back(cef3_corr[2]*(+position));
        xPosW.push_back(cef3_corr[3]*(-position));

        std::vector<float> yPosW;
        yPosW.push_back(cef3_corr[0]*(+position));
        yPosW.push_back(cef3_corr[1]*(+position));
        yPosW.push_back(cef3_corr[2]*(-position));
        yPosW.push_back(cef3_corr[3]*(-position));


        getCeF3Position( v_cef3_corr, xPos_new_, yPos_new_ );
        //diag02_new_ = xPos_new_;
        //diag13_new_ = yPos_new_;

        float pi = 3.14159;
        float theta = pi/4.; // 45 degrees 
        TVector2 vnew( xPos_new_, yPos_new_ );
        TVector2 dnew = vnew.Rotate(-theta);
        diag02_new_ = dnew.Y();
        diag13_new_ = dnew.X();


        TVector2 vBeam( xBeam, yBeam );
        TVector2 dBeam = vBeam.Rotate(-theta);
        diag02_beam_ = dBeam.Y();
        diag13_beam_ = dBeam.X();

        float xPos = sumVector(xPosW)/eTot_corr;
        float yPos = sumVector(yPosW)/eTot_corr;

        h1_xPos->Fill( xPos );
        h1_yPos->Fill( yPos );

        h2_xyPos->Fill( xPos, yPos );

        h1_xPos_new->Fill( xPos_new_ );
        h1_yPos_new->Fill( yPos_new_ );

        h2_xyPos_new->Fill( xPos_new_, yPos_new_ );


        // positioning with all 9 calorimeter channels:
        //float xPos_calo = sumVector( xPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.07); // cef3 is in 0,0
        //float yPos_calo = sumVector( yPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.08); // so counts only in denominator
        xPos_calo_ = sumVector( xPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.06); // cef3 is in 0,0
        yPos_calo_ = sumVector( yPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.10); // so counts only in denominator
        //float xPos_calo = sumVector( xPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.791577); // cef3 is in 0,0
        //float yPos_calo = sumVector( yPosW_bgo )/(eTot_bgo_corr + eTot_corr*0.791577); // so counts only in denominator

        TVector2 vcalo( xPos_calo_, yPos_calo_ );
        TVector2 dcalo = vcalo.Rotate(-theta);
        diag02_calo_ = dcalo.Y();
        diag13_calo_ = dcalo.X();

        //xPos_regr2D_ = readerRegr2D->EvaluateRegression( "MLP" )[0];
        //yPos_regr2D_ = readerRegr2D->EvaluateRegression( "MLP" )[1];

        cef3_regr[0] = cef3_corr[0]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3]);
        cef3_regr[1] = cef3_corr[1]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3]);
        cef3_regr[2] = cef3_corr[2]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3]);
        cef3_regr[3] = cef3_corr[3]/(cef3_corr[0]+cef3_corr[1]+cef3_corr[2]+cef3_corr[3]);
  
        if( bgo_ok && bgo_corr_ok ) {

          h1_xPos_calo->Fill( xPos_calo_ );
          h1_yPos_calo->Fill( yPos_calo_ );
          h2_xyPos_calo->Fill( xPos_calo_, yPos_calo_ );

          //for( unsigned i=0; i<methodNames.size(); ++i ) {
          //  Float_t xPos_regr = (readerRegrX->EvaluateRegression( methodNames[i] ))[0];
          //  Float_t yPos_regr = (readerRegrY->EvaluateRegression( methodNames[i] ))[0];
          //  h1_xPos_regr_vs_calo[i]->Fill( xPos_regr-xPos_calo_ );
          //  h1_yPos_regr_vs_calo[i]->Fill( yPos_regr-yPos_calo_ );
          //  h2_xyPos_regr[i]->Fill( xPos_regr, yPos_regr );
          //}
          //h2_xyPos_regr2D->Fill( xPos_regr2D_, yPos_regr2D_ );

          h1_xPos_calo_vs_hodo->Fill( xPos_calo_-xPos_hodo );
          h1_yPos_calo_vs_hodo->Fill( yPos_calo_-yPos_hodo );

          h1_xPos_calo_vs_beam->Fill( xPos_calo_-xBeam );
          h1_yPos_calo_vs_beam->Fill( yPos_calo_-yBeam );

          // CORRELATIONS BETWEEN CALO AND HODO:

          h2_correlation_cef3_bgo_xPos->Fill( xPos, xPos_bgo_ );
          h2_correlation_cef3_bgo_yPos->Fill( yPos, yPos_bgo_ );

        }

        if( isSingleEle_scintFront ) {

          h1_xPos_singleEle->Fill( xPos );
          h1_yPos_singleEle->Fill( yPos );
          h2_xyPos_singleEle->Fill( xPos, yPos );

          h1_xPos_new_singleEle->Fill( xPos_new_ );
          h1_yPos_new_singleEle->Fill( yPos_new_ );
          h2_xyPos_new_singleEle->Fill( xPos_new_, yPos_new_ );

          h1_xPos_calo_vs_hodo_singleElectron->Fill( xPos_calo_-xPos_hodo );
          h1_yPos_calo_vs_hodo_singleElectron->Fill( yPos_calo_-yPos_hodo );

          h1_xPos_calo_vs_beam_singleElectron->Fill( xPos_calo_-xBeam );
          h1_yPos_calo_vs_beam_singleElectron->Fill( yPos_calo_-yBeam );

          if( nHodoClustersX==1 && nHodoClustersY==1 && nFibres_hodoClustX[0]<=2 && nFibres_hodoClustY[0]<=2 ) {

            h1_xPos_calo_vs_hodo_singleElectron_HR->Fill( xPos_calo_-xPos_hodo );
            h1_yPos_calo_vs_hodo_singleElectron_HR->Fill( yPos_calo_-yPos_hodo );
  
            h1_xPos_calo_vs_beam_singleElectron_HR->Fill( xPos_calo_-xBeam );
            h1_yPos_calo_vs_beam_singleElectron_HR->Fill( yPos_calo_-yBeam );

          }


          h2_correlation_cef3_hodo_xPos_singleEle->Fill( xPos, xPos_hodo );
          h2_correlation_cef3_hodo_yPos_singleEle->Fill( yPos, yPos_hodo );

  
          if( bgo_ok && bgo_corr_ok ) {

            h1_xPos_singleEle_calo->Fill( xPos_calo_ );
            h1_yPos_singleEle_calo->Fill( yPos_calo_ );
            h2_xyPos_singleEle_calo->Fill( xPos_calo_, yPos_calo_ );

            //for( unsigned i=0; i<methodNames.size(); ++i ) {
            //  Float_t xPos_regr = (readerRegrX->EvaluateRegression( methodNames[i] ))[0];
            //  Float_t yPos_regr = (readerRegrY->EvaluateRegression( methodNames[i] ))[0];
            //  h1_xPos_regr_vs_calo_singleEle[i]->Fill( xPos_regr-xPos_calo_ );
            //  h1_yPos_regr_vs_calo_singleEle[i]->Fill( yPos_regr-yPos_calo_ );
            //  h2_xyPos_singleEle_regr[i]->Fill( xPos_regr, yPos_regr );
            //}

            //h2_xyPos_singleEle_regr2D->Fill( xPos_regr2D_, yPos_regr2D_ );

            h2_correlation_cef3_bgo_xPos_singleEle->Fill( xPos, xPos_bgo_ );
            h2_correlation_cef3_bgo_yPos_singleEle->Fill( yPos, yPos_bgo_ );

          }

        }

        
        outTree->Fill();


      } // if cef3_ok

    }

  }


  outfile->cd();

  outTree->Write();


  for( unsigned i=0; i<h1_xPos_regr_vs_calo.size(); ++i ) {
    h1_xPos_regr_vs_calo[i]->Write();
    h1_yPos_regr_vs_calo[i]->Write();
    h1_xPos_regr_vs_calo_singleEle[i]->Write();
    h1_yPos_regr_vs_calo_singleEle[i]->Write();
    h2_xyPos_regr[i]->Write();
    h2_xyPos_singleEle_regr[i]->Write();
  }




  h1_xPos->Write();
  h1_yPos->Write();
  h2_xyPos->Write();

  h1_xPos_singleEle->Write();
  h1_yPos_singleEle->Write();
  h2_xyPos_singleEle->Write();

  h1_xPos_new->Write();
  h1_yPos_new->Write();
  h2_xyPos_new->Write();

  h1_xPos_new_singleEle->Write();
  h1_yPos_new_singleEle->Write();
  h2_xyPos_new_singleEle->Write();

  
  
  h1_xPos_bgo->Write();
  h1_yPos_bgo->Write();
  h2_xyPos_bgo->Write();
  

  h1_xPos_hodo->Write();
  h1_yPos_hodo->Write();
  h2_xyPos_hodo->Write();

  
  h1_xPos_calo_vs_hodo->Write();
  h1_yPos_calo_vs_hodo->Write();

  h1_xPos_calo_vs_beam->Write();
  h1_yPos_calo_vs_beam->Write();
  
  h1_xPos_calo_vs_hodo_singleElectron->Write();
  h1_yPos_calo_vs_hodo_singleElectron->Write();

  h1_xPos_calo_vs_beam_singleElectron->Write();
  h1_yPos_calo_vs_beam_singleElectron->Write();
  
  h1_xPos_calo_vs_hodo_singleElectron_HR->Write();
  h1_yPos_calo_vs_hodo_singleElectron_HR->Write();

  h1_xPos_calo_vs_beam_singleElectron_HR->Write();
  h1_yPos_calo_vs_beam_singleElectron_HR->Write();
  

  std::cout << std::endl;

  

  h2_correlation_cef3_hodo_xPos->Write();
  h2_correlation_cef3_hodo_yPos->Write();

  h2_correlation_cef3_bgo_xPos->Write();
  h2_correlation_cef3_bgo_yPos->Write();

  h2_correlation_hodo_bgo_xPos->Write();
  h2_correlation_hodo_bgo_yPos->Write();

  h1_xPos_singleEle_bgo->Write();
  h1_yPos_singleEle_bgo->Write();
  h2_xyPos_singleEle_bgo->Write();
  
  h1_xPos_singleEle_hodo->Write();
  h1_yPos_singleEle_hodo->Write();
  h2_xyPos_singleEle_hodo->Write();

  h1_xPos_singleEle_hodoClust->Write();
  h1_yPos_singleEle_hodoClust->Write();
  h2_xyPos_singleEle_hodoClust->Write();

  h1_xPos_calo->Write();
  h1_yPos_calo->Write();
  h2_xyPos_calo->Write();
  
  h1_xPos_singleEle_calo->Write();
  h1_yPos_singleEle_calo->Write();
  h2_xyPos_singleEle_calo->Write();
  

  h2_correlation_cef3_hodo_xPos_singleEle->Write();
  h2_correlation_cef3_hodo_yPos_singleEle->Write();

  h2_correlation_cef3_bgo_xPos_singleEle->Write();
  h2_correlation_cef3_bgo_yPos_singleEle->Write();

  h2_correlation_hodo_bgo_xPos_singleEle->Write();
  h2_correlation_hodo_bgo_yPos_singleEle->Write();


  outfile->Close();
  std::cout << "-> Histograms saved in: " << outfile->GetName() << std::endl;


  return 0;

}
Exemplo n.º 11
0
void mergeForest(TString fname = "/data/jisun/temp/*.root",
		 TString outfile="/data/jisun/pp_2015_HeavyFlavor_AOD_tkpt1_D0pt1_eta2p5_D3d1_Prob0p05_1202.root",
		 bool failOnError = true)
{
  // First, find on of the files within 'fname' and use it to make a
  // list of trees. Unfortunately we have to know in advance at least
  // one of the tree names. hiEvtAnalyzer/HiTree is a safe choice for
  // HiForests. We also assume that every TTree is inside a
  // TDirectoryFile which is in the top level of the root file.
  TChain *dummyChain = new TChain("hltanalysis/HltTree");
  dummyChain->Add(fname);
  TFile *testFile = dummyChain->GetFile();
  TList *topKeyList = testFile->GetListOfKeys();

  std::vector<TString> trees;
  std::vector<TString> dir;

  for(int i = 0; i < topKeyList->GetEntries(); ++i)
  {
    TDirectoryFile *dFile = (TDirectoryFile*)testFile->Get(topKeyList->At(i)->GetName());
    if(strcmp(dFile->ClassName(), "TDirectoryFile") != 0) continue;
    
    TList *bottomKeyList = dFile->GetListOfKeys();

    for(int j = 0; j < bottomKeyList->GetEntries(); ++j)
    {
      TString treeName = dFile->GetName();
      treeName += "/";
      treeName += bottomKeyList->At(j)->GetName();

      TTree* tree = (TTree*)testFile->Get(treeName);
      if(strcmp(tree->ClassName(), "TTree") != 0 && strcmp(tree->ClassName(), "TNtuple") != 0) continue;

      trees.push_back(treeName);
      dir.push_back(dFile->GetName());
    }
  }

  testFile->Close();
  delete dummyChain;

  // Now use the list of tree names to make a new root file, filling
  // it with the trees from 'fname'.
  const int Ntrees = trees.size();
  TChain* ch[Ntrees];

  Long64_t nentries = 0;
  for(int i = 0; i < Ntrees; ++i){
    ch[i] = new TChain(trees[i]);
    ch[i]->Add(fname);
    std::cout << "Tree loaded : " << trees[i] << std::endl;
    std::cout << "Entries : " << ch[i]->GetEntries() << std::endl;

    // If the number of entries in this tree is different from other
    // trees there is a problem. Quit and inform the user without
    // producing output.
    if(failOnError)
    {
      if(strcmp(trees[i],"HiForest/HiForestVersion") == 0) continue;
      if(i == 0) nentries = ch[i]->GetEntries();
      else if (nentries != ch[i]->GetEntries())
      {
	std::cout << "ERROR: number of entries in this tree does not match." << std::endl;
	std::cout << "First inconsistent file: " <<ch[i]->GetFile()->GetName()<<std::endl;
	std::cout << "Exiting. Please check input." << std::endl;
	return;
      }
    }
    else
    {
      std::cout << "WARN: error checking disabled" << std::endl;
    }
  }

  TFile* file = new TFile(outfile, "RECREATE");

  for(int i = 0; i < Ntrees; ++i)
  {
    file->cd();
    std::cout << trees[i] << std::endl;
    if (i==0)
    {
      file->mkdir(dir[i])->cd();
    }
    else
    {
      if ( dir[i] != dir[i-1] )
  	file->mkdir(dir[i])->cd();
      else
  	file->cd(dir[i]);
    }
    ch[i]->Merge(file,0,"keep");
    delete ch[i];
  }
  //file->Write();
  file->Close();

  std::cout << "Done. Output: " << outfile << std::endl;
}
Exemplo n.º 12
0
void analyzeDijetAj(std::vector<std::string> urls, const char *outname = "eventObjects.root", Long64_t nentries = 20, Int_t firstF = -1, Int_t lastF = -1, Int_t firstEvent = 0) {

  /*
    ptminType: minimum raw pt for particles used by puppi
    0 : 0 GeV
    1 : 1 GeV
    2 : 2 GeV

    jetSignalType: jets used to select jetty region in events
    0 : detector-level jets (akPu4PF)
    1 : particle-level jets (gen jets)
   */

  double ptminjet = 30.;
  TString jetName = "aktCs4PF";
  TString jetTreeName = "akCs4PFJetAnalyzer";
  //jetName = "akCs4PFFilter";
  //jetTreeName = "akCs4PFFilterJetAnalyzer";

  std::cout << "analyzing subjets for: " << jetName << " tree: " << jetTreeName << std::endl;
   
  std::cout << "nfiles: " << urls.size() << std::endl;
  for (auto i = urls.begin(); i != urls.end(); ++i)
    std::cout << *i << std::endl;

  size_t firstFile = 0;
  size_t lastFile = urls.size();

  if(firstF>-1) {
    firstFile = (size_t)firstF;
    lastFile = std::min((size_t)lastF,lastFile);
  }
  std::cout << "firstFile: " << firstFile << "  lastFile: " << lastFile << std::endl;

  Int_t lastEvent = nentries;
  if(firstEvent>0) {
    lastEvent = firstEvent + nentries;
  }
  std::cout << "firstEvent: " << firstEvent << std::endl;
  
  //add files to chain
  TChain *chain = NULL;
  chain = new TChain("hiEvtAnalyzer/HiTree");
  for(size_t i=firstFile; i<lastFile; i++) chain->Add(urls[i].c_str());
  Printf("hiTree done");

  TChain *skimTree = new TChain("skimanalysis/HltTree");
  for(size_t i=firstFile; i<lastFile; i++) skimTree->Add(urls[i].c_str());
  chain->AddFriend(skimTree);
  Printf("skimTree done");

  TChain *hltTree = new TChain("hltanalysis/HltTree");
  for(size_t i=firstFile; i<lastFile; i++) hltTree->Add(urls[i].c_str());
  chain->AddFriend(hltTree);
  Printf("hltTree done");
  
  TChain *jetTree = new TChain(Form("%s/t",jetTreeName.Data()));
  for(size_t i=firstFile; i<lastFile; i++) jetTree->Add(urls[i].c_str());
  chain->AddFriend(jetTree);
  Printf("jetTree done");

  // TChain *csJetTree = new TChain(Form("%s/t","akCs4PFJetAnalyzer"));
  // for(size_t i=firstFile; i<lastFile; i++) csJetTree->Add(urls[i].c_str());
  // chain->AddFriend(csJetTree);
  // Printf("csJetTree done");

  TList *fEventObjects = new TList();

  //---------------------------------------------------------------
  // producers
  //
  hiEventProducer *p_evt = new hiEventProducer("hiEvtProd");
  p_evt->SetInput(chain);
  p_evt->SetHIEventContName("hiEventContainer");
  p_evt->SetEventObjects(fEventObjects);

  triggerProducer *p_trg = new triggerProducer("trigProd");
  p_trg->SetInput(chain);//hltTree);
  p_trg->SetTriggerMapName("triggerMap");
  p_trg->AddTrigger("HLT_HIPuAK4CaloJet100_Eta5p1_v1");
  p_trg->SetEventObjects(fEventObjects);

  lwJetFromForestProducer *p_PUJet = new lwJetFromForestProducer("lwJetForestProd");
  p_PUJet->SetInput(chain);
  p_PUJet->SetJetContName(jetName);
  p_PUJet->SetGenJetContName("");
  p_PUJet->SetEventObjects(fEventObjects);
  p_PUJet->SetRadius(0.4);
  p_PUJet->SetMinJetPt(ptminjet);
  // lwJetFromForestProducer *p_CSJet = new lwJetFromForestProducer("lwJetForestProd");
  // p_CSJet->SetInput(csJetTree);
  // p_CSJet->SetJetContName("aktCs4PF");
  // p_CSJet->SetGenJetContName("");
  // p_CSJet->SetEventObjects(fEventObjects);
  // p_CSJet->SetRadius(0.4);
  
  //---------------------------------------------------------------
  //analysis modules
  //

  //handler to which all modules will be added
  anaBaseTask *handler = new anaBaseTask("handler","handler");

  anaDijetAj *anadijetAj = new anaDijetAj("anaDijetAj","anaDijetAj");
  anadijetAj->ConnectEventObject(fEventObjects);
  anadijetAj->SetHiEvtName("hiEventContainer");
  anadijetAj->DoCollisionEventSel(true);
  anadijetAj->DoHBHENoiseFilter(true);
  anadijetAj->DoHBHENoiseFilterLoose(true);
  anadijetAj->DoPrimaryVertexFilter(true);
  anadijetAj->DoClusterCompatibilityFilter(true);
  anadijetAj->DoHFCoincFilter(true);
  anadijetAj->SetTriggerMapName("triggerMap");
  anadijetAj->AddTriggerSel("HLT_HIPuAK4CaloJet100_Eta5p1_v1");
  anadijetAj->SetJetsName(jetName);
  anadijetAj->SetNCentBins(5);
  anadijetAj->SetJetEtaRange(-1.3,1.3);
  anadijetAj->SetDoDijets(true);
  anadijetAj->AddLeadingJetPtBin(120.,150.);
  anadijetAj->AddLeadingJetPtBin(150.,180.);
  anadijetAj->AddLeadingJetPtBin(180.,220.);
  anadijetAj->AddLeadingJetPtBin(220.,260.);
  anadijetAj->AddLeadingJetPtBin(260.,300.);
  anadijetAj->AddLeadingJetPtBin(300.,500.);
  anadijetAj->SetPtMinSubleading(40.);
  handler->Add(anadijetAj);

  anaDijetAj *anadijetAjMassCut = new anaDijetAj("anaDijetAjMassCut","anaDijetAjMassCut");
  anadijetAjMassCut->ConnectEventObject(fEventObjects);
  anadijetAjMassCut->SetHiEvtName("hiEventContainer");
  anadijetAjMassCut->DoCollisionEventSel(true);
  anadijetAjMassCut->DoHBHENoiseFilter(true);
  anadijetAjMassCut->DoHBHENoiseFilterLoose(true);
  anadijetAjMassCut->DoPrimaryVertexFilter(true);
  anadijetAjMassCut->DoClusterCompatibilityFilter(true);
  anadijetAjMassCut->DoHFCoincFilter(true);
  anadijetAjMassCut->SetTriggerMapName("triggerMap");
  anadijetAjMassCut->AddTriggerSel("HLT_HIPuAK4CaloJet100_Eta5p1_v1");
  anadijetAjMassCut->SetJetsName(jetName);
  anadijetAjMassCut->SetNCentBins(5);
  anadijetAjMassCut->SetJetEtaRange(-1.,3.);
  anadijetAjMassCut->SetDoDijets(true);
  anadijetAjMassCut->AddLeadingJetPtBin(120.,150.);
  anadijetAjMassCut->AddLeadingJetPtBin(150.,180.);
  anadijetAjMassCut->AddLeadingJetPtBin(180.,220.);
  anadijetAjMassCut->AddLeadingJetPtBin(220.,260.);
  anadijetAjMassCut->AddLeadingJetPtBin(260.,300.);
  anadijetAjMassCut->AddLeadingJetPtBin(300.,500.);
  anadijetAjMassCut->SetPtMinSubleading(40.);
  anadijetAjMassCut->SetMinMassLeading(10.);
  handler->Add(anadijetAjMassCut);
  
  //---------------------------------------------------------------
  //Event loop
  //---------------------------------------------------------------
  Long64_t entries_tot =  chain->GetEntries(); //93064
  if(nentries<0) lastEvent = chain->GetEntries();
  Printf("nentries: %lld  tot: %lld",nentries,entries_tot);
  for (Long64_t jentry=firstEvent; jentry<lastEvent; ++jentry) {
    if(jentry%10000==0) cout << "entry: "<< jentry << endl;
    //Run producers
    //Printf("produce hiEvent");
    p_evt->Run(jentry);   //hi event properties
    //Printf("produce PU jets");
    p_PUJet->Run(jentry); //forest jets
    p_trg->Run(jentry);	    

    //Execute all analysis tasks
    handler->ExecuteTask();
  }
    
  fEventObjects->Print();

  TFile *out = new TFile(outname,"RECREATE");
  TList *tasks = handler->GetListOfTasks();
  TIter next(tasks);
  anaBaseTask *obj;
  while ((obj = dynamic_cast<anaBaseTask*>(next()) ))
    if(obj->GetOutput()) obj->GetOutput()->Write(obj->GetName(),TObject::kSingleKey);
  
  out->Write();
  out->Close();
  
}
Exemplo n.º 13
0
void frameViewerAngles_Mall(char* arg){

	//Take the arguments and save them into respective strings
	std::string infileName;
	std::string inF;
	std::string inPrefix;
	std::string runs, layers;
	std::string runCount;
	std::istringstream stm(arg);

	inPrefix = "/home/p180f/Do_Jo_Ol_Ma/Analysis/MainProcedure/testMain/rawRoot/";

	while (true) {	
		if (std::getline(stm, layers, ' ')) {

			//load the input root files
			TChain *chain = new TChain("fourChamTree");

			for (int i=0; ; i++) {
				runCount = std::to_string(i);
				inF = "run" + runCount + "_" + layers + "layers.root";
				infileName = inPrefix + inF;
				ifstream fin;
				fin.open(infileName.c_str());
				if (!fin.fail()) {
					fin.close();
					chain->Add(infileName.c_str());
					std::cout << "Got " << inF << std::endl;
				} else break;
			}

			//define frame arrays
			int frame[480][640]={0};
			
			const int width = 480;
			const int height = 640;

			//define picture numbers for each tree
			// (in case they are needed)
			int pNum = 0;

			//get branch info from these guyz
			chain->SetBranchAddress("pNum", &pNum);
			chain->SetBranchAddress("frame", &frame);

			//define analysis variables
			Double_t ang[3] = {0};
			Double_t angD = 0;
			Double_t x[4] = {0};
			Double_t y[4] = {0};
			Double_t x_int[1];
			Double_t x_diff= 0;
			Double_t y_int[1];
			Double_t m0 = 0;
			Double_t m1 = 0;
			Double_t b0 = 0;
			Double_t b1 = 0;
			Double_t const Pi = 3.14159265359;
			Double_t convert = 180 / Pi;
			
			TH2D *frameHisto = new TH2D("frameHisto","Muon Tracking by Line Fitting",width,0,width,height,0,height);	//histogram for the stacked images
			TH1D *chamber1x = new TH1D("chamber1x", "Chamber 1x", width, 0, width);
			TH1D *chamber1y = new TH1D("chamber1y", "Chamber 1y", height, 0, height);
			TH1D *chamber2x = new TH1D("chamber2x", "Chamber 2x", width, 0, width);
			TH1D *chamber2y = new TH1D("chamber2y", "Chamber 2y", height, 0, height);
			TH1D *chamber3x = new TH1D("chamber3x", "Chamber 3x", width, 0, width);
			TH1D *chamber3y = new TH1D("chamber3y", "Chamber 3y", height, 0, height);
			TH1D *chamber4x = new TH1D("chamber4x", "Chamber 4x", width, 0, width);
			TH1D *chamber4y = new TH1D("chamber4y", "Chamber 4y", height, 0, height);

			TCanvas *pc2 = new TCanvas("pc2","Frame",0,0,800,800);

			pc2->cd();
			frameHisto->SetStats(false);
			frameHisto->GetXaxis()->SetTitle("X position (px)");
			frameHisto->GetXaxis()->CenterTitle();
			frameHisto->GetYaxis()->SetTitle("Y position (px)");
			frameHisto->GetYaxis()->CenterTitle();
		
			Int_t nentries = chain->GetEntries();
			int count = 0;
			for (Int_t i=0; i<nentries; i++) {
				chain->GetEntry(i);
				for (int x=0; x<width; x++) {
					for (int y=0; y<height; y++) {
						frameHisto->Fill(x, y, frame[x][y]);
						if (frame[x][y]>0) {
							if (y>580 && y<610) {
								chamber1x->Fill(x, frame[x][y]);
								chamber1y->Fill(y, frame[x][y]);
							}
							else if (y>400 && y<440) {
								chamber2x->Fill(x, frame[x][y]);
								chamber2y->Fill(y, frame[x][y]);
							}
							else if (y>240 && y<280) {
								chamber3x->Fill(x, frame[x][y]);
								chamber3y->Fill(y, frame[x][y]);
							}
							else if (y>50 && y<100)	{
								chamber4x->Fill(x, frame[x][y]);
								chamber4y->Fill(y, frame[x][y]);
							}
						}
					}
				}

				//Get the means and fill the x, y coordinates
				x[0] = chamber1x->GetMean();
				y[0] = chamber1y->GetMean();
				x[1] = chamber2x->GetMean();
				y[1] = chamber2y->GetMean();
				x[2] = chamber3x->GetMean();
				y[2] = chamber3y->GetMean();
				x[3] = chamber4x->GetMean();
				y[3] = chamber4y->GetMean();
		
				Double_t x_pos = 0;
				Double_t y_pos = 0;
				
				//Calculate slopes and intercepts
				m0 = ((y[1]-y[0])/(x[1]-x[0]));
				m1 = ((y[3]-y[2])/(x[3]-x[2]));
				b0 = (y[0]-(m0*x[0]));
				b1 = (y[2]-(m1*x[2]));
				
				//Calculate the intersection coordinates
				x_int[0] = ((b1-b0)/(m0-m1));
				y_int[0] = ((m0*x_int[0])+b0);
				
				//Calculate the angle
				ang[0] = atan(m0)*convert;
				ang[1] = atan(m1)*convert;

				//Calculate the rough difference in x in medium
				x_diff = ((340-b0)/m0) - ((340-b1)/m1);

//				std::cout << "ang[0], frame" << i << " = " << ang[0]<< std::endl;
//				std::cout << "ang[1], frame" << i << " = " << ang[1]<< std::endl;
//				cin.ignore();

				//Make array of xdiff RMS
				Double_t x_diffRMS[5] = {41.06, 45.03, 43.29, 40.71, 34.25};		
				Double_t xRMS[4] = {0};
		
				xRMS[0] = chamber1x->GetRMS();
				xRMS[1] = chamber2x->GetRMS();
				xRMS[2] = chamber3x->GetRMS();
				xRMS[3] = chamber4x->GetRMS();
 
				if(ang[0] < 0)
					ang[0] += 180;
				if(ang[1] < 0)
					ang[1] += 180;
				ang[2] = (ang[1]-ang[0]);
			
				//OTHER WAY TO FIND THE ANGLES
				Double_t x_comp[2] = {(x[3]-x[2]), (x[1]-x[0])};
				Double_t y_comp[2] = {(y[3]-y[2]), (y[1]-y[0])};
					
				Double_t vec_mag[2];
				vec_mag[0] = TMath::Sqrt(x_comp[0]*x_comp[0]+y_comp[0]*y_comp[0]);	
				vec_mag[1] = TMath::Sqrt(x_comp[1]*x_comp[1]+y_comp[1]*y_comp[1]);
	
				Double_t cosArg = ((x_comp[0]*x_comp[1]+y_comp[0]*y_comp[1])/(vec_mag[0]*vec_mag[1]));
				angD = acos(cosArg)*convert;	

				if (x_comp[1]<x_comp[0]) {
					angD*=-1;
				}	

				Double_t x_RMS[4];
				x_RMS[0] = chamber1x->GetRMS();
				x_RMS[1] = chamber2x->GetRMS();
				x_RMS[2] = chamber3x->GetRMS();
				x_RMS[3] = chamber4x->GetRMS();

				std::cout << "Processing frame number: " << pNum << "\r";
	
				if (x_RMS[0]>5 && x_RMS[1]>5 && x_RMS[2]>5 && x_RMS[3]>5) {

					//find new x points from given ymin, ymax
					
					double x_min[2];
					double x_max[2];
					double y_min[2] = {0,0};
					double y_max[2] = {640,640};				

					x_min[0] = (y_min[0] - b0) / m0;
					x_max[0] = (y_max[0] - b0) / m0;
					x_min[1] = (y_min[1] - b1) / m1;
					x_max[1] = (y_max[1] - b1) / m1;

					TLine *line0 = new TLine(x_min[0], y_min[0], x_max[0], y_max[0]);
					TLine *line1 = new TLine(x_min[1], y_min[1], x_max[1], y_max[1]);
					TGraph *intersect = new TGraph(1, x_int, y_int); 
					
					pc2->cd();
					frameHisto->Draw("COLZ");
					line0->Draw();
					line1->Draw();
					intersect->Draw("F1*");
					gPad->Update();				

					//wait for user input to advance to next event
					std::cout << "Frame Number=" << pNum << std::endl;
					std::cout << "Press enter to advance to the next frame" << std::endl;
					std::cout << "x[0] RMS = " << x_RMS[0] << std::endl;
					std::cout << "x[1] RMS = " << x_RMS[1] << std::endl;
					std::cout << "x[2] RMS = " << x_RMS[2] << std::endl;
					std::cout << "x[3] RMS = " << x_RMS[3] << std::endl;
					std::cin.ignore();
					
					//clear the old frame from the histogram
					frameHisto->Reset();
					chamber1x->Reset();
					chamber1y->Reset();
					chamber2x->Reset();
					chamber2y->Reset();
					chamber3x->Reset();
					chamber3y->Reset();
					chamber4x->Reset();
					chamber4y->Reset();
				}
			}
		} else {
			break;
		}
	} 
	std::cout << "Complete!\n";
}
Exemplo n.º 14
0
int main(int argc, char ** argv)
{
  // select fed
  int month = atoi(argv[1]);
  string month_name [12] = {"Gen","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

  if (month < 0 || month > 12) {
   cout << "Give as argument a number between 1 and 12 corresponding to the chosen month" << endl;
   return 0;
  }

  if (month > 10) {
   cout << "No data corresponding to the chosen month..yet!" << endl;
   return 0;
  }


  //Get old tree 
  TChain *tx = new TChain("x");
  tx->Add(argv[2]);
 
  init_ttree(tx, &x);

  TTree *oldtree = (TTree*)tx;

  Long64_t nentries = oldtree->GetEntries();
  cout<< "Number of entries in the tree : " << nentries << endl;


  //Create a new file + a clone of old tree in new file
  char fname[1000];
  sprintf(fname,argv[3],(month_name[month - 1]).c_str());
  TFile *newfile = new TFile(fname,"recreate");
  TTree *newtree = oldtree->CloneTree(0);

  int lowerRun, upperRun = 0;

  if (month == 1) {
    lowerRun = 153941;
    upperRun = 156054;
  }

  if (month == 2) {
    lowerRun = 156225;
    upperRun = 159130;
  }

  if (month == 3) {
    lowerRun = 159248;
    upperRun = 161732;
  }

  if (month == 4) {
    lowerRun = 161846;
    upperRun = 163726;
  }

  if (month == 5) {
    lowerRun = 163762;
    upperRun = 166139;
  }

  if (month == 6) {
    lowerRun = 166243;
    upperRun = 168148;
  }

  if (month == 7) {
    lowerRun = 168266;
    upperRun = 172266;
  }

  if (month == 8) {
    lowerRun = 172319;
    upperRun = 174912;
  }

  if (month == 9) {
    lowerRun = 175118;
    upperRun = 177519;
  }

  if (month == 10) {
    lowerRun = 177624;
    upperRun = 179998;
  }


  for (int i=0; i<nentries; i++) {

    if (i%10000000==0) cout << "Analyzing entry " << i << endl;
    oldtree->GetEntry(i);

    if ( x.run > lowerRun && x.run < upperRun ) newtree->Fill();
  }
  
  newtree->Print();
  newtree->AutoSave();
  
  delete newfile;


}
Exemplo n.º 15
0
// The actual job
int convertTreeForDatacards(TString inFile, TString outfile, bool useJET, bool VBFtag){
  TChain* treedata ;
  treedata= new TChain("SelectedTree");
  treedata->Add(inFile);

  int neventOut=0;
  Int_t run;
  Int_t ls=0;
  Long64_t event;
  float mzz, mzzErr;
  float p0plus_VAJHU, bkg_VAMCFM;
  float m1, m2;
  //float ZZVAKD;
  float pt4l, fisher;
  int NJets_30;

  //Spin analysis variables
  float psigM4l,pbkgM4l;
  float p0minusVA, p0hplusVA,p1minusVA,p1plusVA,p2minimalVA,p2minimalVA_qq,p2hplusVA,p2hminusVA,p2bplusVA,p1minusProdIndepVA,p1plusProdIndepVA,p2mProdIndepVA,pbkg_ProdIndep_VA;

  treedata->SetBranchAddress("RunNumber",&run);
  //  treedata->SetBranchAddress("LumiNumber",&ls);
  treedata->SetBranchAddress("EventNumber",&event);
  treedata->SetBranchAddress("ZZMass",&mzz);
  treedata->SetBranchAddress("ZZMassErrCorr",&mzzErr);
  treedata->SetBranchAddress("p0plus_VAJHU",&p0plus_VAJHU);
  treedata->SetBranchAddress("bkg_VAMCFM",&bkg_VAMCFM);
  //treedata->SetBranchAddress("ZZVAKD",&ZZVAKD);
  treedata->SetBranchAddress("Z1Mass",&m1);
  treedata->SetBranchAddress("Z2Mass",&m2);

  treedata->SetBranchAddress("ZZPt",&pt4l);
  //treedata->SetBranchAddress("ZZRapidity",&Y4l);
  treedata->SetBranchAddress("Fisher",&fisher);

  treedata->SetBranchAddress("NJets30", &NJets_30);

  //Spin Disc variables
  treedata->SetBranchAddress("p0plus_m4l",&psigM4l);
  treedata->SetBranchAddress("bkg_m4l",&pbkgM4l);
  treedata->SetBranchAddress("p0minus_VAJHU",&p0minusVA);
  treedata->SetBranchAddress("p0hplus_VAJHU",&p0hplusVA);
  treedata->SetBranchAddress("p1plus_VAJHU",&p1plusVA);
  treedata->SetBranchAddress("p1_VAJHU",&p1minusVA);
  treedata->SetBranchAddress("p2_VAJHU",&p2minimalVA);
  treedata->SetBranchAddress("p2qqb_VAJHU",&p2minimalVA_qq);
  treedata->SetBranchAddress("p2hplus_VAJHU", &p2hplusVA);
  treedata->SetBranchAddress("p2hminus_VAJHU", &p2hminusVA);
  treedata->SetBranchAddress("p2bplus_VAJHU", &p2bplusVA);
  treedata->SetBranchAddress("p1_prodIndep_VAJHU", &p1minusProdIndepVA);
  treedata->SetBranchAddress("p1plus_prodIndep_VAJHU", &p1plusProdIndepVA);
  treedata->SetBranchAddress("p2_prodIndep_VAJHU", &p2mProdIndepVA);
  treedata->SetBranchAddress("bkg_prodIndep_VAMCFM", &pbkg_ProdIndep_VA);
 
   
  TFile* newFile  = new TFile(outfile, "RECREATE");
  newFile->cd();
  TTree* newTree = new TTree("data_obs","data_obs"); 
  Double_t CMS_zz4l_mass, melaLD, CMS_zz4l_massErr, CMS_zz4l_massRelErr;
  Double_t pt = -99, Fisher = -99;

  newTree->Branch("CMS_zz4l_mass",&CMS_zz4l_mass,"CMS_zz4l_mass/D");
  newTree->Branch("CMS_zz4l_massErr",&CMS_zz4l_massErr,"CMS_zz4l_massErr/D");
  newTree->Branch("CMS_zz4l_massRelErr",&CMS_zz4l_massRelErr,"CMS_zz4l_massRelErr/D");
  newTree->Branch("melaLD",&melaLD,"melaLD/D");
  newTree->Branch("CMS_zz4l_Fisher",&Fisher,"CMS_zz4l_Fisher/D");
  newTree->Branch("CMS_zz4l_Pt",&pt,"CMS_zz4l_Pt/D");

  //Spin Analysis Branches
  Double_t sKD,pseudoKD,graviKD,p0hplusKD,p1plusKD,p1minusKD,qqgraviKD,p2hplusKD,p2hminusKD,p2bplusKD,gravi_piKD,qqgravi_piKD,p1minus_piKD,p1plus_piKD, PIsKD;
  newTree->Branch("CMS_zz4l_smd",&sKD,"CMS_zz4l_smd/D");
  newTree->Branch("CMS_zz4l_pseudoKD",&pseudoKD,"CMS_zz4l_pseudoKD/D");
  newTree->Branch("CMS_zz4l_graviKD",&graviKD,"CMS_zz4l_graviKD/D");
  newTree->Branch("CMS_zz4l_p0hplusKD",&p0hplusKD,"CMS_zz4l_p0hplusKD/D");
  newTree->Branch("CMS_zz4l_p1plusKD",&p1plusKD,"CMS_zz4l_p1plusKD/D");
  newTree->Branch("CMS_zz4l_p1minusKD",&p1minusKD,"CMS_zz4l_p1minusKD/D");
  newTree->Branch("CMS_zz4l_qqgraviKD",&qqgraviKD,"CMS_zz4l_qqgraviKD/D");
  newTree->Branch("CMS_zz4l_p2hplusKD",&p2hplusKD,"CMS_zz4l_p2hplusKD/D");
  newTree->Branch("CMS_zz4l_p2hminusKD",&p2hminusKD,"CMS_zz4l_p2hminusKD/D");
  newTree->Branch("CMS_zz4l_p2bplusKD",&p2bplusKD,"CMS_zz4l_p2bplusKD/D");
  newTree->Branch("CMS_zz4l_gravi_ProdIndepKD",&gravi_piKD,"CMS_zz4l_gravi_ProdIndepKD/D");
  newTree->Branch("CMS_zz4l_qqgravi_ProdIndepKD",&qqgravi_piKD,"CMS_zz4l_qqgravi_ProdIndepKD/D");
  newTree->Branch("CMS_zz4l_p1minus_ProdIndepKD",&p1minus_piKD,"CMS_zz4l_p1minus_ProdIndepKD/D");
  newTree->Branch("CMS_zz4l_p1plus_ProdIndepKD",&p1plus_piKD,"CMS_zz4l_p1plus_ProdIndepKD/D");
  newTree->Branch("CMS_zz4l_ProdIndepSKD",&PIsKD,"CMS_zz4l_ProdIndepSKD/D");


  cout << inFile << " entries: " << treedata->GetEntries() << endl;
  for(int iEvt=0; iEvt<treedata->GetEntries(); iEvt++){
    //    if(iEvt%5000==0) cout << "event: " << iEvt << endl;
    treedata->GetEntry(iEvt);

    //cout << run << endl;
    
    if (onlyICHEPStat && run>=198049) continue;

    //if( NJets_30 > 0) cout << "NJets_30: " << NJets_30 << endl;

    if ((useJET && VBFtag && NJets_30 < 2) || (useJET && !VBFtag && NJets_30 >= 2)) continue;

    CMS_zz4l_mass = double(mzz);
    CMS_zz4l_massErr = double(mzzErr);
    CMS_zz4l_massRelErr = double(mzzErr/mzz);
    //pseudomelaLD = pseudomela;
    //melaLD = mela;
    //supermelaLD = 0;
    melaLD=double(p0plus_VAJHU/(p0plus_VAJHU+bkg_VAMCFM));
    //ZZVAKD=double(p0plus_VAJHU/(bkg_VAMCFM + p0plus_VAJHU));
    if(useJET && !VBFtag) 
      {
	if(pt4l > 200.)
	  {
	    //if pt out of range set to middle of higest bin
	    pt4l = 198.;
	  }
	pt = double(pt4l);
      }
    if(useJET && VBFtag) 
      {
	if(fisher > 2.)
	  {
	    //if fisher out of range set to middle of higest bin
	    fisher = 1.98;
	  }
	Fisher = double(fisher);
      }

    //make variables for spin analysis
    sKD = double((p0plus_VAJHU*psigM4l)/(p0plus_VAJHU*psigM4l + bkg_VAMCFM*pbkgM4l));
    pseudoKD = double(p0plus_VAJHU/(p0plus_VAJHU + p0minusVA));
    graviKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2minimalVA));
    p0hplusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p0hplusVA));
    p1plusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p1plusVA));
    p1minusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p1minusVA));
    qqgraviKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2minimalVA_qq));
    p2hplusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2hplusVA));
    p2hminusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2hminusVA));
    p2bplusKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2bplusVA));
    gravi_piKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2mProdIndepVA));
    qqgravi_piKD = double(p0plus_VAJHU/(p0plus_VAJHU + p2mProdIndepVA));
    p1plus_piKD = double (p0plus_VAJHU/(p0plus_VAJHU + p1plusProdIndepVA));
    p1minus_piKD = double (p0plus_VAJHU/(p0plus_VAJHU + p1minusProdIndepVA));
    PIsKD = double((p0plus_VAJHU*psigM4l)/(p0plus_VAJHU*psigM4l + pbkg_ProdIndep_VA*pbkgM4l));
  
#ifdef LINKMELA
    if(recompute_){
      float KD, psig, pbkg;
      myMELA->computeKD(mzz,m1,m2,
		       costhetastar,
		       costheta1,
		       costheta2,
		       phi,
		       phi1,
		       KD,psig,pbkg,
		       withPt_,pt4l,
		       withY_, Y4l,
		       sqrts);
      
      melaLD = KD;
    }
#endif
    ++neventOut;
    newTree->Fill();
    if (dumpEvents) {
      if (!useJET && !VBFtag) {
	cout.setf(ios::fixed);
	int ifs=-1;
	if (outfile.Contains("4e")) ifs = 0;
	else if (outfile.Contains("4mu")) ifs = 1;
	else if (outfile.Contains("2e2mu")) ifs = 2;
	cout << run << ":" << ls << ":" << event << " " << ifs << " " << setprecision(2) << CMS_zz4l_mass << " " << m1 << " " << m2 << " " << CMS_zz4l_massErr << " "  <<  setprecision(3) << melaLD << " "  <<  setprecision(2)  << ((pt4l>0)?pt4l:-1) << " " << setprecision(3) << ((NJets_30 >= 2)?fisher:-1) << endl;
      }
    }
  }
  newTree->Write("data_obs"); 
  newFile->Close();
  
  cout << "written: " << outfile << " entries: " << neventOut << endl << endl;
  return  neventOut;
  
}
void template_ntupleViewer_Chain(){

  const double beamspot=-2.64157;

//  gROOT->Reset();
  gStyle->SetOptStat(1111);
  gStyle->SetCanvasBorderMode(0);
  gStyle->SetPadBorderMode(0);

  gStyle->SetCanvasColor(10);
  gStyle->SetPadColor(10);
  gStyle->SetFillColor(10);
  gStyle->SetStatColor(10);
  gStyle->SetTitleFillColor(10);

std::string addMe = "DATA_";

TH1D* eta_All             =new TH1D( (addMe + std::string("eta_All")).c_str()        , (addMe + std::string("eta_All")).c_str(),25,-3,3);
TH1D* eta_withVertex      =new TH1D( (addMe + std::string("eta_withVertex")).c_str() , (addMe + std::string("eta_withVertex")).c_str(),25,-3,3);
TH1D* eta_AssVertex       =new TH1D( (addMe + std::string("eta_AssVertex")).c_str()  , (addMe + std::string("eta_AssVertex")).c_str(),25,-3,3);
  TH1D* phi_All             =new TH1D( (addMe + std::string("phi_All")).c_str()        , (addMe + std::string("phi_All")).c_str(),25,-3.1415,3.1415);
  TH1D* phi_withVertex      =new TH1D( (addMe + std::string("phi_withVertex")).c_str() , (addMe + std::string("phi_withVertex")).c_str(),25,-3.1415,3.1415);
  TH1D* phi_AssVertex       =new TH1D( (addMe + std::string("phi_AssVertex")).c_str()  , (addMe + std::string("phi_AssVertex")).c_str(),25,-3.1415,3.1415);
TH1D* pt_All              =new TH1D( (addMe + std::string("pt_All")).c_str()         , (addMe + std::string("pt_All")).c_str(),400,0.,40);
TH1D* pt_withVertex       =new TH1D( (addMe + std::string("pt_withVertex")).c_str()  , (addMe + std::string("pt_withVertex")).c_str(),400,0.,40);
TH1D* pt_AssVertex        =new TH1D( (addMe + std::string("pt_AssVertex")).c_str()   , (addMe + std::string("pt_AssVertex")).c_str(),400,0.,40);
  TH1D* track_multip_All       =new TH1D( (addMe + std::string("track_multip_All")).c_str()       , (addMe + std::string("track_multip_All")).c_str(),201,0,200);
  TH1D* track_multip_withVertex=new TH1D( (addMe + std::string("track_multip_withVertex")).c_str(), (addMe + std::string("track_multip_withVertex")).c_str(),201,0,200);
  TH1D* track_multip_AssVertex =new TH1D( (addMe + std::string("track_multip_AssVertex")).c_str() , (addMe + std::string("track_multip_AssVertex")).c_str(),201,0,200);
TH2D* pt_vs_multip_All              =new TH2D( (addMe + std::string("pt_vs_multip_All")).c_str()         , (addMe + std::string("pt_vs_multip_All")).c_str(),400,0.,40,201,0,200);
TH2D* pt_vs_multip_withVertex       =new TH2D( (addMe + std::string("pt_vs_multip_withVertex")).c_str()  , (addMe + std::string("pt_vs_multip_withVertex")).c_str(),400,0.,40,201,0,200);
TH2D* pt_vs_multip_AssVertex        =new TH2D( (addMe + std::string("pt_vs_multip_AssVertex")).c_str()   , (addMe + std::string("pt_vs_multip_AssVertex")).c_str(),400,0.,40,201,0,200);
  TH2D* pt_vs_ndof_All              =new TH2D( (addMe + std::string("pt_vs_ndof_All")).c_str()         , (addMe + std::string("pt_vs_ndof_All")).c_str(),400,0.,40,61,0,60);
  TH2D* pt_vs_ndof_withVertex       =new TH2D( (addMe + std::string("pt_vs_ndof_withVertex")).c_str()  , (addMe + std::string("pt_vs_ndof_withVertex")).c_str(),400,0.,40,61,0,60);
  TH2D* pt_vs_ndof_AssVertex        =new TH2D( (addMe + std::string("pt_vs_ndof_AssVertex")).c_str()   , (addMe + std::string("pt_vs_ndof_AssVertex")).c_str(),400,0.,40,61,0,60);
TH1D* ndof_All              =new TH1D( (addMe + std::string("ndof_All")).c_str()         , (addMe + std::string("ndof_All")).c_str(),61,0,60);
TH1D* ndof_withVertex       =new TH1D( (addMe + std::string("ndof_withVertex")).c_str()  , (addMe + std::string("ndof_withVertex")).c_str(),61,0,60);
TH1D* ndof_AssVertex        =new TH1D( (addMe + std::string("ndof_AssVertex")).c_str()   , (addMe + std::string("ndof_AssVertex")).c_str(),61,0,60);
  TH1D* normChi2_All        =new TH1D( (addMe + std::string("normChi2_All")).c_str()        , (addMe + std::string("normChi2_All")).c_str(),25,0,20);
  TH1D* normChi2_withVertex =new TH1D( (addMe + std::string("normChi2_withVertex")).c_str() , (addMe + std::string("normChi2_withVertex")).c_str(),25,0,20);
  TH1D* normChi2_AssVertex  =new TH1D( (addMe + std::string("normChi2_AssVertex")).c_str()  , (addMe + std::string("normChi2_AssVertex")).c_str(),25,0,20);
TH2D* chi2_vs_pT_All       =new TH2D( (addMe + std::string("chi2_vs_pT_All")).c_str()       , (addMe + std::string("chi2_vs_pT_All")).c_str(),25,0,20,400,0.,40);
TH2D* chi2_vs_pT_withVertex=new TH2D( (addMe + std::string("chi2_vs_pT_withVertex")).c_str(), (addMe + std::string("chi2_vs_pT_withVertex")).c_str(),25,0,20,400,0.,40);
TH2D* chi2_vs_pT_AssVertex =new TH2D( (addMe + std::string("chi2_vs_pT_AssVertex")).c_str() , (addMe + std::string("chi2_vs_pT_AssVertex")).c_str(),25,0,20,400,0.,40);
  TH2D* chi2_vs_pT_lowMultip_All       =new TH2D( (addMe + std::string("chi2_vs_pT_lowMultip_All")).c_str()       , (addMe + std::string("chi2_vs_pT_lowMultip_All")).c_str(),25,0,20,400,0.,40);
  TH2D* chi2_vs_pT_lowMultip_withVertex=new TH2D( (addMe + std::string("chi2_vs_pT_lowMultip_withVertex")).c_str(), (addMe + std::string("chi2_vs_pT_lowMultip_withVertex")).c_str(),25,0,20,400,0.,40);
  TH2D* chi2_vs_pT_lowMultip_AssVertex =new TH2D( (addMe + std::string("chi2_vs_pT_lowMultip_AssVertex")).c_str() , (addMe + std::string("chi2_vs_pT_lowMultip_AssVertex")).c_str(),25,0,20,400,0.,40);
TH2D* chi2_vs_pT_highMultip_All       =new TH2D( (addMe + std::string("chi2_vs_pT_highMultip_All")).c_str()       , (addMe + std::string("chi2_vs_pT_highMultip_All")).c_str(),25,0,20,400,0.,40);
TH2D* chi2_vs_pT_highMultip_withVertex=new TH2D( (addMe + std::string("chi2_vs_pT_highMultip_withVertex")).c_str(), (addMe + std::string("chi2_vs_pT_highMultip_withVertex")).c_str(),25,0,20,400,0.,40);
TH2D* chi2_vs_pT_highMultip_AssVertex =new TH2D( (addMe + std::string("chi2_vs_pT_highMultip_AssVertex")).c_str() , (addMe + std::string("chi2_vs_pT_highMultip_AssVertex")).c_str(),25,0,20,400,0.,40);
  TH1D* vertexes            =new TH1D( (addMe + std::string("vertexes")).c_str()       , (addMe + std::string("vertexes")).c_str(),5,0,5);
  TH1D* vertexes_z          =new TH1D( (addMe + std::string("vertexes_z")).c_str()     , (addMe + std::string("vertexes_z")).c_str(),25,-20,20);
  TH2D* vertexes_xy         =new TH2D( (addMe + std::string("vertexes_xy")).c_str()    , (addMe + std::string("vertexes_xy")).c_str(),200,-10,10,200,-10,10);
  TH1D* deltaZ_trackPV      =new TH1D( (addMe + std::string("deltaZ_trackPV")).c_str() , (addMe + std::string("deltaZ_trackPV")).c_str(),50,-25,25);
  TH1D* deltaZ_trackPV_ZOOM      =new TH1D( (addMe + std::string("deltaZ_trackPV_ZOOM")).c_str() , (addMe +  std::string("deltaZ_trackPV_ZOOM")).c_str(),100,-3,3);
TH1D* deltaX_trackPV      =new TH1D( (addMe + std::string("deltaX_trackPV")).c_str() , (addMe + std::string("deltaX_trackPV")).c_str(),50,-25,25);
TH1D* deltaX_trackPV_ZOOM      =new TH1D( (addMe + std::string("deltaX_trackPV_ZOOM")).c_str() , (addMe + std::string("deltaX_trackPV_ZOOM")).c_str(),100,-3,3);
  TH1D* deltaY_trackPV      =new TH1D( (addMe + std::string("deltaY_trackPV")).c_str() , (addMe + std::string("deltaY_trackPV")).c_str(),50,-25,25);
  TH1D* deltaY_trackPV_ZOOM      =new TH1D( (addMe + std::string("deltaY_trackPV_ZOOM")).c_str() , (addMe + std::string("deltaY_trackPV_ZOOM")).c_str(),100,-3,3);
TH1D* vertexesNum_NoutTrk =new TH1D( (addMe + std::string("vertexesNum_NoutTrk")).c_str() , (addMe + std::string("vertexesNum_NoutTrk")).c_str(),50,0,50);
TH1D* deltaZ_v1v2         =new TH1D( (addMe + std::string("deltaZ_v1v2")).c_str()    , (addMe + std::string("deltaZ_v1v2")).c_str(),100,0,50);
  TH1D* dZ_All      =new TH1D( (addMe + std::string("dZ_All")).c_str() , (addMe +  std::string("dZ_All")).c_str(),100,-3,3);
  TH1D* d0_All      =new TH1D( (addMe + std::string("d0_All")).c_str() , (addMe + std::string("d0_All")).c_str(),100,-3,3);
TH1D* dZPoint_Ass      =new TH1D( (addMe + std::string("dZPoint_Ass")).c_str() , (addMe +  std::string("dZPoint_Ass")).c_str(),100,-3,3);
TH1D* d0Point_Ass      =new TH1D( (addMe + std::string("d0Point_Ass")).c_str() , (addMe + std::string("d0Point_Ass")).c_str(),100,-3,3);
TH1D* dZ_Ass      =new TH1D( (addMe + std::string("dZ_Ass")).c_str() , (addMe +  std::string("dZ_Ass")).c_str(),100,-3,3);
TH1D* d0_Ass      =new TH1D( (addMe + std::string("d0_Ass")).c_str() , (addMe + std::string("d0_Ass")).c_str(),100,-3,3);
  TH1D* dZPoint_Vtx      =new TH1D( (addMe + std::string("dZPoint_Vtx")).c_str() , (addMe +  std::string("dZPoint_Vtx")).c_str(),100,-3,3);
  TH1D* d0Point_Vtx      =new TH1D( (addMe + std::string("d0Point_Vtx")).c_str() , (addMe + std::string("d0Point_Vtx")).c_str(),100,-3,3);
  TH1D* dZ_Vtx      =new TH1D( (addMe + std::string("dZ_Vtx")).c_str() , (addMe +  std::string("dZ_Vtx")).c_str(),100,-3,3);
  TH1D* d0_Vtx      =new TH1D( (addMe + std::string("d0_Vtx")).c_str() , (addMe + std::string("d0_Vtx")).c_str(),100,-3,3);
TH1D* dZ_Vtx_LARGE      =new TH1D( (addMe + std::string("dZ_Vtx_LARGE")).c_str() , (addMe + std::string("dZ_Vtx_LARGE")).c_str(),500,-15,15);
  TH1D* hthrust_z_All            =new TH1D( (addMe + std::string("hthrust_z_All")).c_str()       , (addMe + std::string("thrust_z_All")).c_str(),50,-1.1,1.1);
  TH1D* hthrust_z_withVertex     =new TH1D( (addMe + std::string("hthrust_z_withVertex")).c_str(), (addMe + std::string("thrust_y_withVertex")).c_str(),50,-1.1,1.1);
  TH1D* hthrust_z_AssVertex      =new TH1D( (addMe + std::string("hthrust_z_AssVertex")).c_str() , (addMe + std::string("thrust_z_AssVertex")).c_str(),50,-1.1,1.1);
TH1D* chargeAsymmetry_All = new TH1D( (addMe + std::string("chargeAsymmetry_All")).c_str() , (addMe + std::string("chargeAsymmetry_All")).c_str(),20,-10,10);
TH1D* chargeAsymmetry_AssVertex = new TH1D( (addMe + std::string("chargeAsymmetry_AssVertex")).c_str() , (addMe + std::string("chargeAsymmetry_AssVertex")).c_str(),20,-10,10);

//*********************************  

  TChain fChain ("MyAnalyzer/EventTree") ;
  fChain.Add("/res/*root");
  dati Input(&fChain);
  int entries = fChain.GetEntries();

//*******  TRUST_Z histograms *****
//deleted
//

//*******  TRACK parameters  ******

cout<<"corro su "<<entries<<" entries"<<endl;

for(int eventn=0;eventn<entries;eventn++){
  fChain.GetEntry(eventn);


  if (realdata)
    if ( rejectRunLumi(Input.runNumber,Input.lumiBlock) ) continue; 

  int chargePlusY=0;
  int chargeMinusY=0;

//All
  track_multip_All->Fill(Input.numTracks);
  for(Int_t trackn=0;trackn<Input.numTracks;trackn++){ //tutte le tracce dell'evento	
      	  
    eta_All->Fill(Input.track_eta[trackn]);
    phi_All->Fill(Input.track_phi[trackn]);
    pt_All->Fill(Input.track_pt[trackn]);
    normChi2_All->Fill(Input.track_normalizedChi2[trackn]);
    chi2_vs_pT_All->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
    pt_vs_multip_All->Fill(Input.track_pt[trackn],Input.numTracks);
    pt_vs_ndof_All->Fill(Input.track_pt[trackn],Input.track_ndof[trackn]);
    ndof_All->Fill(Input.track_ndof[trackn]);
    if (Input.numTracks>100)    chi2_vs_pT_highMultip_All->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
    else                  chi2_vs_pT_lowMultip_All->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
    dZ_All->Fill( Input.track_dz[trackn] );
    d0_All->Fill( Input.track_d0[trackn] );

    if ( Input.track_py[trackn]>0. )  chargePlusY+=Input.track_charge[trackn];
    else                              chargeMinusY+=Input.track_charge[trackn];

    }//tutte le tracce dell'evento
 
  chargeAsymmetry_All->Fill(chargePlusY+chargeMinusY);


//vertex presence requirement
  for(Int_t vertexn=0;vertexn<Input.numVertices;vertexn++)
    {
    if(Input.vertex_z[vertexn]!=beamspot){  //vertice non ricostruito valore del beam spot
      if(fabs(Input.vertex_z[vertexn]-beamspot)<10){
        track_multip_withVertex->Fill(Input.numTracks);
	for(Int_t trackn=0;trackn<Input.numTracks;trackn++){
      	  
	  //if (track_pt[trackn]>8.) continue;
	  
	  eta_withVertex->Fill(Input.track_eta[trackn]);
	  phi_withVertex->Fill(Input.track_phi[trackn]);
	  pt_withVertex->Fill(Input.track_pt[trackn]);
	  normChi2_withVertex->Fill(Input.track_normalizedChi2[trackn]); 
          chi2_vs_pT_withVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
          pt_vs_multip_withVertex->Fill(Input.track_pt[trackn],Input.numTracks);
          pt_vs_ndof_withVertex->Fill(Input.track_pt[trackn],Input.track_ndof[trackn]);
          ndof_withVertex->Fill(Input.track_ndof[trackn]);
          if (Input.numTracks>100)    chi2_vs_pT_highMultip_withVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
          else                  chi2_vs_pT_lowMultip_withVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);

	  dZPoint_Vtx->Fill( (Input.track_vz[trackn]-Input.vertex_z[vertexn])- ( (Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_px[trackn] +  (Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_py[trackn])/(Input.track_pt[trackn]) * Input.track_pz[trackn]/Input.track_pt[trackn] );
	  d0Point_Vtx->Fill( (-(Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_py[trackn]+(Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_px[trackn])/Input.track_pt[trackn] );
	    dZ_Vtx->Fill( Input.track_dz[trackn] );
	    dZ_Vtx_LARGE->Fill( Input.track_dz[trackn] );
	    d0_Vtx->Fill( Input.track_d0[trackn] );
          
	  }
	}
      break; 
      }//vertice non ricostruito valore del beam spot
    }


//Vertex Association requirement

  chargePlusY=0;
  chargeMinusY=0;

  for(Int_t vertexn=0;vertexn<Input.numVertices;vertexn++)
    {
    //std::cout<<"vertices z: "<<Input.vertex_z[vertexn]<<endl;
    if(Input.vertex_z[vertexn]!=beamspot){  //vertice non ricostruito valore del beam spot
      if(fabs(Input.vertex_z[vertexn]-beamspot)<10){
        int fillCounter=0;
	for(Int_t trackn=0;trackn<Input.numTracks;trackn++){
      	  
	  double dZ_cut= (Input.track_vz[trackn]-Input.vertex_z[vertexn])- ( (Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_px[trackn] +  (Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_py[trackn])/(Input.track_pt[trackn]) * Input.track_pz[trackn]/Input.track_pt[trackn] ;
	  double d0_cut= (-(Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_py[trackn]+(Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_px[trackn])/Input.track_pt[trackn] ;
	  
	  //if ( fabs(track_vz[trackn]-vertex_z[vertexn])<1. )  //old cut in acceptance
	  if ( fabs(dZ_cut)<0.36 && fabs(d0_cut)<0.18 && Input.track_highPurity[trackn]==1 )
	    {
	    fillCounter++;
	    eta_AssVertex->Fill(Input.track_eta[trackn]);
	    phi_AssVertex->Fill(Input.track_phi[trackn]);
	    pt_AssVertex->Fill(Input.track_pt[trackn]);
	    normChi2_AssVertex->Fill(Input.track_normalizedChi2[trackn]);
            chi2_vs_pT_AssVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
            pt_vs_multip_AssVertex->Fill(Input.track_pt[trackn],Input.numTracks);
            pt_vs_ndof_AssVertex->Fill(Input.track_pt[trackn],Input.track_ndof[trackn]);
            ndof_AssVertex->Fill(Input.track_ndof[trackn]);
            if (Input.numTracks>100)    chi2_vs_pT_highMultip_AssVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
            else                  chi2_vs_pT_lowMultip_AssVertex->Fill(Input.track_normalizedChi2[trackn],Input.track_pt[trackn]);
	    
	    dZPoint_Ass->Fill( (Input.track_vz[trackn]-Input.vertex_z[vertexn])- ( (Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_px[trackn] +  (Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_py[trackn])/(Input.track_pt[trackn]) * Input.track_pz[trackn]/Input.track_pt[trackn] );
	    d0Point_Ass->Fill( (-(Input.track_vx[trackn]-Input.vertex_x[vertexn])*Input.track_py[trackn]+(Input.track_vy[trackn]-Input.vertex_y[vertexn])*Input.track_px[trackn])/Input.track_pt[trackn] );
	    dZ_Ass->Fill( Input.track_dz[trackn] );
	    d0_Ass->Fill( Input.track_d0[trackn] );

            if ( Input.track_py[trackn]>0. )  chargePlusY+=Input.track_charge[trackn];
            else                        chargeMinusY+=Input.track_charge[trackn];

	    }
          }
	  
        chargeAsymmetry_AssVertex->Fill(chargePlusY+chargeMinusY);
	}
      break; 
      }//vertice non ricostruito valore del beam spot
    }

}

  
//***** VERTEX properties *****

int contime=0;
cout<<"corro su "<<entries<<" entries"<<endl;
for(int eventn=0;eventn<entries;eventn++){
  fChain.GetEntry(eventn);

  if (realdata)
   if ( rejectRunLumi(Input.runNumber,Input.lumiBlock) ) continue; 

  int fill;
  if (Input.numVertices==1){
    if (Input.vertex_z[0]==beamspot) fill = 0;
    else                             fill = 1;
    }
  else fill = Input.numVertices;  
  vertexes->Fill(fill);

  if (Input.numVertices>1)
    deltaZ_v1v2->Fill( fabs(Input.vertex_z[0]-Input.vertex_z[1]) );
  
  for(Int_t vertexn=0;vertexn<Input.numVertices;vertexn++){
    if(Input.vertex_z[vertexn]!=beamspot){  //vertice non ricostruito valore del beam spot
	vertexesNum_NoutTrk->Fill(Input.vertex_nOutgoingTracks[vertexn]);
	vertexes_z->Fill(Input.vertex_z[vertexn]);
	vertexes_xy->Fill(Input.vertex_x[vertexn],Input.vertex_y[vertexn]);
    }//vertice non ricostruito valore del beam spot
  }

  for(Int_t vertexn=0;vertexn<Input.numVertices;vertexn++)
    {
    if(Input.vertex_z[0]!=beamspot){  //vertice non ricostruito valore del beam spot
      if(fabs(Input.vertex_z[vertexn]-beamspot)<10){
        contime++;
	for(Int_t trackn=0;trackn<Input.numTracks;trackn++){
	  deltaZ_trackPV->Fill(Input.track_vz[trackn]-Input.vertex_z[vertexn]);  
	  deltaZ_trackPV_ZOOM->Fill(Input.track_vz[trackn]-Input.vertex_z[vertexn]);  
	    deltaX_trackPV->Fill(Input.track_vx[trackn]-Input.vertex_x[vertexn]);  
	    deltaX_trackPV_ZOOM->Fill(Input.track_vx[trackn]-Input.vertex_x[vertexn]);  
	  deltaY_trackPV->Fill(Input.track_vy[trackn]-Input.vertex_y[vertexn]);  
	  deltaY_trackPV_ZOOM->Fill(Input.track_vy[trackn]-Input.vertex_y[vertexn]);  
          }
	break;       
      }
      }//vertice non ricostruito valore del beam spot
    }

}

cout<<"li gavemo contai: "<<contime<<endl;
double averageMultip = track_multip_AssVertex->GetMean();
TH1D* KNO_scaling = new TH1D("KNO_scaling","KNO_scaling",track_multip_AssVertex->GetNbinsX(),0.,double(track_multip_AssVertex->GetNbinsX())/averageMultip);
  KNO_scaling->GetXaxis()->SetTitle("n / < n >");
  KNO_scaling->GetYaxis()->SetTitle("< n >   P_{n}");
  for (int k=1; k<=KNO_scaling->GetNbinsX(); k++)
    KNO_scaling->SetBinContent(k,averageMultip*track_multip_AssVertex->GetBinContent(k));


if (realdata){

  //********* SetStatisticalError Real Data *********

  setStatError(eta_withVertex);
  setStatError(eta_All);
  setStatError(eta_AssVertex);
  setStatError(phi_withVertex);
  setStatError(phi_All);
  setStatError(phi_AssVertex);
  setStatError(pt_withVertex);
  setStatError(pt_All);
  setStatError(pt_AssVertex);
  setStatError(normChi2_withVertex);
  setStatError(normChi2_All);
  setStatError(normChi2_AssVertex);
  setStatError(vertexes);
  setStatError(vertexes_z);
  setStatError(deltaZ_trackPV);
  setStatError(vertexesNum_NoutTrk);
  setStatError(ndof_All);
  setStatError(ndof_withVertex);
  setStatError(ndof_AssVertex);
  setStatError(track_multip_All);
  setStatError(track_multip_withVertex);
  setStatError(track_multip_AssVertex);

  //****   marker styles  *****  

  eta_withVertex->SetMarkerStyle(22);
  eta_AssVertex->SetMarkerStyle(22);
  eta_All->SetMarkerStyle(22);
  phi_withVertex->SetMarkerStyle(22);
  phi_AssVertex->SetMarkerStyle(22);
  phi_All->SetMarkerStyle(22);
  pt_withVertex->SetMarkerStyle(22);
  pt_AssVertex->SetMarkerStyle(22);
  pt_All->SetMarkerStyle(22);
  normChi2_withVertex->SetMarkerStyle(22);
  normChi2_AssVertex->SetMarkerStyle(22);
  normChi2_All->SetMarkerStyle(22);

  vertexes_z->SetMarkerStyle(22);
  deltaZ_trackPV->SetMarkerStyle(22);
  vertexesNum_NoutTrk->SetMarkerStyle(22);

  vertexes->SetMarkerStyle(22);
  }

  vertexes->GetXaxis()->SetBinLabel(1,"BeamSpot");
  vertexes->GetXaxis()->SetBinLabel(2,"1 Vertex");
  vertexes->GetXaxis()->SetBinLabel(3,"2 Vertices");
  vertexes->GetXaxis()->SetBinLabel(4,"3 Vertices");
  vertexes->GetXaxis()->SetBinLabel(5,"4 Vertices");
  vertexes->GetXaxis()->SetTitle("N^{vtx}/evt");

  deltaZ_v1v2->GetXaxis()->SetTitle("|v^{1}_{z}-v^{1}_{z}|");


//***** saving histos *****

  std::string fileToOpen="histoDATA_fromChain.root";  
  TFile outFile((fileToOpen).c_str(),"RECREATE");
 
  eta_withVertex->Write();
  eta_All->Write();
  phi_withVertex->Write();
  phi_All->Write();
  pt_withVertex ->Write();
  pt_All->Write();
  normChi2_withVertex->Write();
  normChi2_All->Write();

  vertexes->Write();
  vertexes_z->Write();
  vertexes_xy->Write();
  deltaZ_trackPV->Write();
  vertexesNum_NoutTrk->Write();
  deltaZ_v1v2->Write();

  eta_AssVertex->Write();
  phi_AssVertex->Write();
  pt_AssVertex ->Write();
  normChi2_AssVertex->Write();
  
  hthrust_z_All->Write();
  hthrust_z_withVertex->Write();
  hthrust_z_AssVertex->Write();

  track_multip_All->Write();
  track_multip_withVertex->Write();
  track_multip_AssVertex->Write();
    chi2_vs_pT_All->Write();
    chi2_vs_pT_withVertex->Write();
    chi2_vs_pT_AssVertex->Write();
  chi2_vs_pT_lowMultip_All->Write();
  chi2_vs_pT_lowMultip_withVertex->Write();
  chi2_vs_pT_lowMultip_AssVertex->Write();
    chi2_vs_pT_highMultip_All->Write();
    chi2_vs_pT_highMultip_withVertex->Write();
    chi2_vs_pT_highMultip_AssVertex->Write();

  pt_vs_multip_All->Write();
  pt_vs_multip_withVertex->Write();
  pt_vs_multip_AssVertex->Write();  
    pt_vs_ndof_All->Write();        
    pt_vs_ndof_withVertex->Write(); 
    pt_vs_ndof_AssVertex->Write();  

  deltaX_trackPV->Write();
  deltaX_trackPV_ZOOM->Write(); 
    deltaY_trackPV->Write();  
    deltaY_trackPV_ZOOM->Write();  

    dZ_All->Write();
    d0_All->Write();
  dZPoint_Ass->Write();
  d0Point_Ass->Write();
    dZ_Ass->Write();
    d0_Ass->Write();
  dZPoint_Vtx->Write();
  d0Point_Vtx->Write();
    dZ_Vtx->Write();
    dZ_Vtx_LARGE->Write();
    d0_Vtx->Write();

   KNO_scaling->Write();

   ndof_All->Write();
   ndof_withVertex->Write();
   ndof_AssVertex->Write();
  
  chargeAsymmetry_All->Write();
  chargeAsymmetry_AssVertex->Write();
  
  outFile.Close();
}
Exemplo n.º 17
0
TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
{
  // creates chain of files in a given directory or file containing a list.
  // In case of directory the structure is expected as:
  // <aDataDir>/<dir0>/AliAOD.root
  // <aDataDir>/<dir1>/AliAOD.root
  // ...

  if (!aDataDir)
    return 0;

  Long_t id, size, flags, modtime;
  if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
  {
    printf("%s not found.\n", aDataDir);
    return 0;
  }

  TChain* chain = new TChain("aodTree");
  TChain* chaingAlice = 0;

  if (flags & 2)
  {
    TString execDir(gSystem->pwd());
    TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
    TList* dirList            = baseDir->GetListOfFiles();
    Int_t nDirs               = dirList->GetEntries();
    gSystem->cd(execDir);

    Int_t count = 0;

    for (Int_t iDir=0; iDir<nDirs; ++iDir)
    {
      TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
      if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
        continue;

      if (offset > 0)
      {
        --offset;
        continue;
      }

      if (count++ == aRuns)
        break;

      TString presentDirName(aDataDir);
      presentDirName += "/";
      presentDirName += presentDir->GetName();
      chain->Add(presentDirName + "/AliAOD.root/aodTree");
      // cerr<<presentDirName<<endl;
    }

  }
  else
  {
    // Open the input stream
    ifstream in;
    in.open(aDataDir);

    Int_t count = 0;

    // Read the input list of files and add them to the chain
    TString aodfile;
    while(in.good())
    {
      in >> aodfile;
      if (!aodfile.Contains("root")) continue; // protection

      if (offset > 0)
      {
        --offset;
        continue;
      }

      if (count++ == aRuns)
        break;

      // add aod file
      chain->Add(aodfile);
    }

    in.close();
  }

  return chain;

} // end of TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
Exemplo n.º 18
0
void v_src_fit(){

  int CRunNumberR=20591;
  int endCRunNumberR=22461;
  int HeRunNumberR=20596;
  int endHeRunNumberR=20789;
// NOTE: There is a problem with the BCM values. When fixed, swap below and above lines.
//  int endHeRunNumberR=20879;

  TString Q2 = "1.0";
  TString vartodraw = "PriKineR.Q2 / (PriKineR.nu * 2 * 0.9315)";
//Range is of the form (bins, start, end)
//  TString range = "(800,0.5,4.0)";
  double bins = 50;
  double plotmin = 0.5;
  double plotmax = 2.0;
  TString title = "12C/3He x with Target cut, Run # ";
  title += CRunNumberR;
  title += " & ";
  title += HeRunNumberR;

	TCut cut = "";  
	TCut kinematics = "PriKineR.Q2<10 && GoodElectron==1 && PriKineR.nu<10";
//	TCut eventtype = "D.evtypebits&(1<<1)>0";
	TCut eventtype = "(D.evtypebits&2)==2";
	TCut gold = "ExTgtCor_R.dp>-0.04 && ExTgtCor_R.dp<0.055";
	TCut target = "ReactPt_R.z>-0.172 && ReactPt_R.z<0.175";
	TCut sieve = "abs(ExTgtCor_R.ph)<0.03 && abs(ExTgtCor_R.th)<0.06";

//	TCut cut = "";
//	TCut eventtype = "";
//	TCut target = "";
//	TCut sieve = "";
//	TCut gold = "";

  TCut cuts = kinematics && target && sieve && gold && eventtype;

  TString whattodraw = vartodraw;
//  whattodraw += ">>";
//  whattodraw += title;
//  whattodraw += range;
  TString whattodrawC = whattodraw;
  whattodrawC += ">>histCR";
  TString whattodrawHe = whattodraw;
  whattodrawHe += ">>histHeR";
  TChain* chainCR = new TChain("T");
  TChain* chainHeR = new TChain("T");

  gStyle->SetErrorX(.25);
  gStyle->SetEndErrorSize(.25);
  ifstream inp;
  ofstream out;

  TString filenameCR;
  TString filenameHeR;


// Below is the loop for adding chains for the Carbon run
  for (int thisCRunNumberR=CRunNumberR; thisCRunNumberR<(endCRunNumberR+1); thisCRunNumberR++)
  {
 		if(thisCRunNumberR==20592){thisCRunNumberR=20731;}
		if(thisCRunNumberR==20735){thisCRunNumberR=20762;}
		if(thisCRunNumberR==20765){thisCRunNumberR=22380;}
		if(thisCRunNumberR==22381){thisCRunNumberR=22389;}
		if(thisCRunNumberR==22390){thisCRunNumberR=22425;}
		if(thisCRunNumberR==22427){thisCRunNumberR=22461;}
		if(thisCRunNumberR==22462){thisCRunNumberR=99999;}

   for (int t=0; t<1000;t++)
    {
      filenameCR = "/home/ellie/physics/e05-102/terabyte/ROOTfiles/e05102_R_";
      filenameCR += thisCRunNumberR;
      if (t!=0)
      {
        filenameCR += "_";
        filenameCR += t;
      }
      filenameCR += ".root";
      ifstream ifileCR(filenameCR);
      if (ifileCR)
      {
        cout << "Adding file to chainCR: " << filenameCR << endl;
        chainCR->Add(filenameCR);
      }
      else
      {
        cout << "File " << filenameCR << " does not exist. Ending here." << endl;
        t=9999999;
      }

    }
	
// Uncommenting the line below will let the code only go through one run (Good for debugging purposes)
//	thisCRunNumberR = 99999999;

  }




// Below is the loop for adding chains for the 3He run

  for (int thisHeRunNumberR=HeRunNumberR;thisHeRunNumberR<(endHeRunNumberR+1); thisHeRunNumberR++)
  {
	// Skipping Vertical Carbon Runs
	if(thisHeRunNumberR==20591){thisHeRunNumberR=20596;}
	if(thisHeRunNumberR==20731){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20732){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20733){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20734){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20736){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20737){thisHeRunNumberR=20738;}
	if(thisHeRunNumberR==20762){thisHeRunNumberR=20789;}
	if(thisHeRunNumberR==20763){thisHeRunNumberR=20789;}
	if(thisHeRunNumberR==20764){thisHeRunNumberR=20789;}
	if(thisHeRunNumberR==20791){thisHeRunNumberR=20814;}
	if(thisHeRunNumberR==20792){thisHeRunNumberR=20814;}

	// Skipping Longitudinal Carbon Runs
	if(thisHeRunNumberR==22380){thisHeRunNumberR=22393;}
	if(thisHeRunNumberR==22389){thisHeRunNumberR=22393;}
	if(thisHeRunNumberR==22425){thisHeRunNumberR=22436;}
	if(thisHeRunNumberR==22426){thisHeRunNumberR=22436;}

	// Skipping Transverse Carbon Runs
	if(thisHeRunNumberR==22461){thisHeRunNumberR=22465;}
	if(thisHeRunNumberR==20591){thisHeRunNumberR=20596;}

   if(thisHeRunNumberR==22397){thisHeRunNumberR=22398;}
    for (int t=0; t<1000;t++)
    {
      filenameHeR = "/home/ellie/physics/e05-102/terabyte/ROOTfiles/e05102_R_";
      filenameHeR += thisHeRunNumberR;
      if (t!=0)
      {
        filenameHeR += "_";
        filenameHeR += t;
      }
      filenameHeR += ".root";
      ifstream ifileHeR(filenameHeR);
      if (ifileHeR)
      {
        cout << "Adding file to chainHeR: " << filenameHeR << endl;
        chainHeR->Add(filenameHeR);
      }
      else
      {
        cout << "File " << filenameHeR << " does not exist. Ending here." << endl;
        t=9999999;
      }

    }

// Uncommenting the line below will let the code only go through one run (Good for debugging purposes)
//	thisHeRunNumberR = 999999999;

  }


	
	gStyle->SetPalette(1);
	gStyle->SetOptFit(0001);

	// Defines Canvas
	TCanvas *c1 = new TCanvas("c1","x of 12C and 3He",1360,800);//x,y
	pad01 = new TPad("pad01","pad01",0.0000,0.8333,0.2000,1.0000,0,0,0);
	pad02 = new TPad("pad02","pad02",0.2000,0.8333,0.4000,1.0000,0,0,0);
	pad03 = new TPad("pad03","pad03",0.4000,0.8333,0.6000,1.0000,0,0,0);
	pad04 = new TPad("pad04","pad04",0.6000,0.8333,0.8000,1.0000,0,0,0);
	pad05 = new TPad("pad05","pad05",0.0000,0.6666,0.2000,0.8333,0,0,0);
	pad06 = new TPad("pad06","pad06",0.2000,0.6666,0.4000,0.8333,0,0,0);
	pad07 = new TPad("pad07","pad07",0.4000,0.6666,0.6000,0.8333,0,0,0);
	pad08 = new TPad("pad08","pad08",0.6000,0.6666,0.8000,0.8333,0,0,0);
	pad09 = new TPad("pad09","pad09",0.0000,0.3333,0.3333,0.6666,0,0,0);
	pad10 = new TPad("pad10","pad10",0.3333,0.3333,0.6666,0.6666,0,0,0);
	pad11 = new TPad("pad11","pad11",0.6666,0.3333,1.0000,0.6666,0,0,0);
	pad12 = new TPad("pad12","pad12",0.0000,0.0000,0.3333,0.3333,0,0,0);
	pad13 = new TPad("pad13","pad13",0.3333,0.0000,0.6666,0.3333,0,0,0);
	pad14 = new TPad("pad14","pad14",0.6666,0.0000,1.0000,0.3333,0,0,0);
	pad15 = new TPad("pad15","pad15",0.8000,0.8333,1.0000,1.0000,0,0,0);
	pad16 = new TPad("pad16","pad16",0.8000,0.6666,1.0000,0.8333,0,0,0);
	pad01->Draw();pad02->Draw();pad03->Draw();pad04->Draw();pad05->Draw();pad06->Draw();pad07->Draw();pad08->Draw();pad09->Draw();pad10->Draw();pad11->Draw();pad12->Draw();pad13->Draw();pad14->Draw();pad15->Draw();pad16->Draw();

	// Everything below here makes graphs for each section of the canvas

	pad01->cd();
	TString titledpHe = "dp Cut from 3He Runs";
	cout << "Drawing " << titledpHe << "..." << endl;
	chainHeR->Draw("ExTgtCor_R.dp>>HedpNoCut(400,-0.08,0.08)", "", "");
	chainHeR->Draw("ExTgtCor_R.dp>>HedpCut(400,-0.08,0.08)", gold, "");
	HedpNoCut->SetTitle(titledpHe);
	HedpNoCut->Draw();
	HedpCut->SetLineColor(kBlack);
	HedpCut->SetFillColor(kViolet);
	HedpCut->Draw("same");

	pad05->cd();
	TString titledpC = "dp Cut from 12C Runs";
	cout << "Drawing " << titledpC << "..." << endl;
	chainCR->Draw("ExTgtCor_R.dp>>CdpNoCut(400,-0.08,0.08)", "", "");
	chainCR->Draw("ExTgtCor_R.dp>>CdpCut(400,-0.08,0.08)", gold, "");
	CdpNoCut->SetTitle(titledpC);
	CdpNoCut->Draw();
	CdpCut->SetLineColor(kBlack);
	CdpCut->SetFillColor(kViolet);
	CdpCut->Draw("same");

	pad02->cd();
	TString titleTargetHe = "Target Cut for 3He Runs";
	cout << "Drawing " << titleTargetHe << "..." << endl;
	chainHeR->Draw("ReactPt_R.z>>HeReactZNoCut(400,-0.3,0.3)", "", "");
	chainHeR->Draw("ReactPt_R.z>>HeReactZCut(400,-0.3,0.3)", target, "");
	HeReactZNoCut->SetTitle(titleTargetHe);
	HeReactZNoCut->Draw();
	HeReactZCut->SetLineColor(kBlack);
	HeReactZCut->SetFillColor(kViolet);
	HeReactZCut->Draw("same");

	pad06->cd();
	TString titleTargetC = "Target Cut for 12C Runs";
	cout << "Drawing " << titleTargetC << "..." << endl;
	chainCR->Draw("ReactPt_R.z>>CReactZNoCut(400,-0.3,0.3)", "", "");
	chainCR->Draw("ReactPt_R.z>>CReactZCut(400,-0.3,0.3)", target, "");
	CReactZNoCut->SetTitle(titleTargetC);
	CReactZNoCut->Draw();
	CReactZCut->SetLineColor(kBlack);
	CReactZCut->SetFillColor(kViolet);
	CReactZCut->Draw("same");

	pad03->cd();
	TString titleThetaPhiHe = "Theta and Phi, No Cut, for 3He";
	cout << "Drawing " << titleThetaPhiHe << "..." << endl;
	chainHeR->Draw("ExTgtCor_R.th:ExTgtCor_R.ph>>HeSieveNoCut(100,-0.05,0.05,100,-0.1,0.1)", target, "");
	HeSieveNoCut->SetTitle(titleThetaPhiHe);
	HeSieveNoCut->SetStats(kFALSE);
	HeSieveNoCut->Draw("COLZ");

	pad07->cd();
	TString titleThetaPhiC = "Theta and Phi, No Cut, for 12C";
	cout << "Drawing " << titleThetaPhiC << "..." << endl;
	chainCR->Draw("ExTgtCor_R.th:ExTgtCor_R.ph>>CSieveNoCut(100,-0.05,0.05,100,-0.1,0.1)", target, "");
	CSieveNoCut->SetTitle(titleThetaPhiC);
	CSieveNoCut->SetStats(kFALSE);
	CSieveNoCut->Draw("COLZ");

	pad04->cd();
	TString titleThetaCutHe = "Theta and Phi Cut for 3He";
	cout << "Drawing " << titleThetaCutHe << "..." << endl;
	chainHeR->Draw("ExTgtCor_R.th:ExTgtCor_R.ph>>HeSieveCut(100,-0.05,0.05,100,-0.1,0.1)", target && sieve, "");
	HeSieveCut->SetTitle(titleThetaCutHe);
	HeSieveCut->SetStats(kFALSE);
	HeSieveCut->Draw("COLZ");

	pad08->cd();
	TString titleThetaCutC = "Theta and Phi Cut for 12C";
	cout << "Drawing " << titleThetaCutC << "..." << endl;
	chainCR->Draw("ExTgtCor_R.th:ExTgtCor_R.ph>>CSieveCut(100,-0.05,0.05,100,-0.1,0.1)", target && sieve, "");
	CSieveCut->SetTitle(titleThetaCutC);
	CSieveCut->SetStats(kFALSE);
	CSieveCut->Draw("COLZ");

	pad15->cd();
	TString titleQ2WHe = "Q2 v. Nu for 3He";
	cout << "Drawing " << titleQ2WHe << "..." << endl;
	chainHeR->Draw("PriKineR.Q2:PriKineR.nu>>Q2WHe(100,0.3,0.8,400,0,1.6)", cuts, "");
	Q2WHe->SetTitle(titleQ2WHe);
	Q2WHe->SetStats(kFALSE);
	Q2WHe->Draw("COLZ");

	pad16->cd();
	TString titleQ2WC = "Q2 v. Nu for 12C";
	cout << "Drawing " << titleQ2WC << "..." << endl;
	chainCR->Draw("PriKineR.Q2:PriKineR.nu>>Q2WC(100,0.3,0.8,400,0,1.6,100)", cuts, "");
	Q2WC->SetTitle(titleQ2WC);
	Q2WC->SetStats(kFALSE);
	Q2WC->Draw("COLZ");


	pad09->cd();
	TString titleC = "x for 12C at Q2 of ";
	titleC += Q2;
//	titleC += " and Target Cut of ";
//	titleC += target;
	cout << "Drawing " << titleC << "..." << endl;
	TH1F *histCR = new TH1F("histCR",titleC,bins,plotmin,plotmax);
	histCR->Sumw2();
	chainCR->Draw(whattodrawC, cuts, "E");
	histCR.Scale(1/0.0161297);
	histCR->Draw();
	TF1 *fitC1 = new TF1("fitC1","[0]*exp(-x*[1])",1.45,1.6);
	fitC1->SetParNames("C Red p1","C Red p2");
	Double_t fitC1const = fitC1->GetParameter(0);
	Double_t fitC1expconst = fitC1->GetParameter(1);
//	Double_t fitC1exp = fitC1->GetParameter(2);
	Double_t fitC1consterror = fitC1->GetParError(0);
	Double_t fitC1expconsterror = fitC1->GetParError(1);
//	Double_t fitC1experror = fitC1->GetParError(2);
	fitC1->SetLineColor(kRed);
	TF1 *fit2 = new TF1("fitC2","[0]*exp(-x*[1])",1.6,1.8);
	fitC2->SetParNames("C Blue p1","C Blue p2");
	Double_t fitC2const = fitC2->GetParameter(0);
	Double_t fitC2expconst = fitC2->GetParameter(1);
//	Double_t fitC2exp = fitC2->GetParameter(2);
	Double_t fitC2consterror = fitC2->GetParError(0);
	Double_t fitC2expconsterror = fitC2->GetParError(1);
//	Double_t fitC2experror = fitC2->GetParError(2);
	fitC2->SetLineColor(kBlue);
	TF1 *fitC3 = new TF1("fitC3","[0]*exp(-x*[1])",1.35,1.45);
	fitC3->SetParNames("C Green p1","C Green p2");
	Double_t fitC3const = fitC3->GetParameter(0);
	Double_t fitC3expconst = fitC3->GetParameter(1);
//	Double_t fitC3exp = fitC3->GetParameter(2);
	Double_t fitC3consterror = fitC3->GetParError(0);
	Double_t fitC3expconsterror = fitC3->GetParError(1);
//	Double_t fitC3experror = fitC3->GetParError(2);
	fitC3->SetLineColor(kGreen);

	histCR->Fit("fitC2","R");
	histCR->Fit("fitC3","R+");
	histCR->Fit("fitC1","R+");
	

	pad12->cd();
	pad12->SetLogy();
	cout << "Drawing " << titleC << " in log scale..." << endl;
	TH1F *histCR = new TH1F("histCR",titleC,bins,plotmin,plotmax);
	histCR->Sumw2();
	chainCR->Draw(whattodrawC, cuts, "E");
	histCR->Draw();
	histCR->Fit("fitC1","R");
	histCR->Fit("fitC3","R+");
	histCR->Fit("fitC2","R+");

	pad10->cd();
	TString titleHe = "x for 3He at Q2 of ";
	titleHe += Q2;
//	titleHe += " and Target Cut of ";
//	titleHe += target;
	cout << "Drawing " << titleHe << "..." << endl;
	TH1F *histHeR = new TH1F("histHeR",titleHe,bins,plotmin,plotmax);
	histHeR->Sumw2();
	chainHeR->Draw(whattodrawHe, cuts, "E");
	histHeR.Scale(1/2.33878);
	histHeR->Draw();
	TF1 *fitHe1 = new TF1("fitHe1","[0]*exp(-x*[1])",1.45,1.6);
	fitHe1->SetParNames("He Red p1", "He Red p2");
	Double_t fitHe1const = fitHe1->GetParameter(0);
	Double_t fitHe1expconst = fitHe1->GetParameter(1);
//	Double_t fitHe1exp = fitHe1->GetParameter(2);
	Double_t fitHe1consterror = fitHe1->GetParError(0);
	Double_t fitHe1expconsterror = fitHe1->GetParError(1);
//	Double_t fitHe1experror = fitHe1->GetParError(2);
	fitHe1->SetLineColor(kRed);
	TF1 *fitHe2 = new TF1("fitHe2","[0]*exp(-x*[1])",1.6,1.8);
	fitHe2->SetParNames("He Blue p1","He Blue p2");
	Double_t fitHe2const = fitHe2->GetParameter(0);
	Double_t fitHe2expconst = fitHe2->GetParameter(1);
//	Double_t fitHe2exp = fitHe2->GetParameter(2);
	Double_t fitHe2consterror = fitHe2->GetParError(0);
	Double_t fitHe2expconsterror = fitHe2->GetParError(1);
//	Double_t fitHe2experror = fitHe2->GetParError(2);
	fitHe2->SetLineColor(kBlue);
	TF1 *fitHe3 = new TF1("fitHe3","[0]*exp(-x*[1])",1.35,1.45);
	fitHe3->SetParNames("He Green p1","He Green p2");
	Double_t fitHe3const = fitHe3->GetParameter(0);
	Double_t fitHe3expconst = fitHe3->GetParameter(1);
//	Double_t fitHe3exp = fitHe3->GetParameter(2);
	Double_t fitHe3consterror = fitHe3->GetParError(0);
	Double_t fitHe3expconsterror = fitHe3->GetParError(1);
//	Double_t fitHe3experror = fitHe3->GetParError(2);
	fitHe3->SetLineColor(kGreen);

	histHeR->Fit("fitHe2","R+");
	histHeR->Fit("fitHe3","R+");
	histHeR->Fit("fitHe1","R+");
	
	pad13->cd();
	pad13->SetLogy();
	cout << "Drawing " << titleHe << " in log scale..." << endl;
	TH1F *histHeR = new TH1F("histHeR",titleHe,bins,plotmin,plotmax);
	histHeR->Sumw2();
	chainHeR->Draw(whattodrawHe, cuts, "E");
	histHeR->Draw();
	histHeR->Fit("fitHe1","R+");
	histHeR->Fit("fitHe3","R+");
	histHeR->Fit("fitHe2","R+");

	pad11->cd();
	TString titleCoverHe = "12C/3He for Q2 of ";
	titleCoverHe += Q2;
//	titleCoverHe += " and Target Cut of ";
//	titleCoverHe += target;
	cout << "Drawing " << titleCoverHe << "..." << endl;
	TH1F *histCoverHeR = new TH1F("histCoverHeR",titleCoverHe,bins,plotmin,plotmax);
	histCoverHeR->Sumw2();
	histCoverHeR->Divide(histCR,histHeR,1,0.0918143);
	histCoverHeR->Draw("E");

	pad14->cd();
	pad14->SetLogy();
	cout << "Drawing " << titleCoverHe << " in log scale..." << endl;
	TH1F *histCoverHeR = new TH1F("histCoverHeR",titleCoverHe,bins,plotmin,plotmax);
	histCoverHeR->Sumw2();
	histCoverHeR->Divide(histCR,histHeR,1,0.0918143);
	histCoverHeR->Draw("E");

   
	TString imagename = "xbj_scaling_plots/Vertical_xbj_scaling_plots_all_at_Q2_of_";
	imagename += Q2;
	imagename += ".png";
	c1->Print(imagename);

	cout << "All done!" << endl;


}
Exemplo n.º 19
0
void Diagnostics()
{
  gSystem->Load("src/RunData12.so");
  RunData12 * RD = new RunData12();
  const Int_t NBINS=400; // NUMBER OF BINS

  // open chain
  TChain * tr = new TChain("str");
  tr->Add("./redset/Red*.root");
  Float_t E12,Pt,Eta,Phi,M12,Z,b_pol,y_pol;
  Bool_t kicked,isConsistent;
  Int_t TrigBits,runnum,bx,ClIndex;
  Float_t N12;

  Float_t E12_min,Pt_min,Eta_min,Phi_min;
  Float_t E12_max,Pt_max,Eta_max,Phi_max;
  E12_min=Pt_min=Eta_min=Phi_min=1000;
  E12_max=Pt_max=Eta_max=Phi_max=0;

  str->SetBranchAddress("runnum",&runnum);
  str->SetBranchAddress("Bunchid7bit",&bx);
  str->SetBranchAddress("E12",&E12);
  str->SetBranchAddress("Pt",&Pt);
  str->SetBranchAddress("Eta",&Eta);
  str->SetBranchAddress("Phi",&Phi);
  str->SetBranchAddress("M12",&M12);
  str->SetBranchAddress("Z",&Z);
  str->SetBranchAddress("TrigBits",&TrigBits);
  str->SetBranchAddress("N12",&N12);
  str->SetBranchAddress("ClIndex",&ClIndex);
  Int_t runnum_tmp=0;

  
  // get kinematics ranges for eta,Pt,Phi using the reduced data set and looking for maxima and minima
  // -- this is useful for looking at kinematic distrbutions beyond the kinematic boundaries set in Bin_Splitter.C
  // -- below there is a section to get the kinematic ranges using Bin_Splitter.C; comment either this section
  //    or the next to choose which one to use
  /*
  for(Int_t x=0; x<tr->GetEntries(); x++)
  {
    if((x%100000)==0) printf("computing kin ranges: %.2f%%\n",100*((Float_t)x)/((Float_t)tr->GetEntries()));
    tr->GetEntry(x);
    kicked = RD->Kicked(runnum,bx);
    if(runnum!=runnum_tmp)
    {
      b_pol = RD->BluePol(runnum);
      y_pol = RD->YellPol(runnum);
      isConsistent = RD->RellumConsistent(runnum);
      runnum_tmp=runnum;
    }
    // n photon cut
    //if(N12==1 && kicked==0 && isConsistent==1 && b_pol*y_pol!=0)
    // pi0 cut
    if(fabs(M12-0.135)<0.1 && Z<0.8 && (TrigBits&0x200) && N12==2 && kicked==0 && isConsistent==1 && b_pol*y_pol!=0 && Pt<15)
    {
      E12_min = (E12 < E12_min) ? E12:E12_min;
      Pt_min  = (Pt  < Pt_min)  ? Pt:Pt_min;
      Eta_min = (Eta < Eta_min) ? Eta:Eta_min;
      Phi_min = (Phi < Phi_min) ? Phi:Phi_min;

      E12_max = (E12 > E12_max) ? E12:E12_max;
      Pt_max  = (Pt  > Pt_max)  ? Pt:Pt_max;
      Eta_max = (Eta > Eta_max) ? Eta:Eta_max;
      Phi_max = (Phi > Phi_max) ? Phi:Phi_max;
    };
  };
  */


  // get kinematic ranges using the current binning set by Bin_Splitter.C
  // -- choose this section or the previous one to set the kinematic ranges to plot in diag.root 
  ///*
  Int_t phi_bins0, eta_bins0, pt_bins0, en_bins0;
  if(gSystem->Getenv("PHI_BINS")==NULL){fprintf(stderr,"ERROR: source env vars\n"); return;};
  sscanf(gSystem->Getenv("PHI_BINS"),"%d",&phi_bins0);
  sscanf(gSystem->Getenv("ETA_BINS"),"%d",&eta_bins0);
  sscanf(gSystem->Getenv("PT_BINS"),"%d",&pt_bins0);
  sscanf(gSystem->Getenv("EN_BINS"),"%d",&en_bins0);
  const Int_t phi_bins = phi_bins0;
  const Int_t eta_bins = eta_bins0;
  const Int_t pt_bins = pt_bins0;
  const Int_t en_bins = en_bins0;
  Float_t phi_div[phi_bins+1];
  Float_t eta_div[eta_bins+1];
  Float_t pt_div[pt_bins+1];
  Float_t en_div[en_bins+1];
  char phi_div_env[phi_bins+1][20];
  char eta_div_env[eta_bins+1][20];
  char pt_div_env[pt_bins+1][20];
  char en_div_env[en_bins+1][20];
  for(Int_t i=0; i<=phi_bins; i++)
  {
    sprintf(phi_div_env[i],"PHI_DIV_%d",i);
    sscanf(gSystem->Getenv(phi_div_env[i]),"%f",&(phi_div[i]));
    printf("%s %f\n",phi_div_env[i],phi_div[i]);
  };
  for(Int_t i=0; i<=eta_bins; i++)
  {
    sprintf(eta_div_env[i],"ETA_DIV_%d",i);
    sscanf(gSystem->Getenv(eta_div_env[i]),"%f",&(eta_div[i]));
    printf("%s %f\n",eta_div_env[i],eta_div[i]);
  };
  for(Int_t i=0; i<=pt_bins; i++)
  {
    sprintf(pt_div_env[i],"PT_DIV_%d",i);
    sscanf(gSystem->Getenv(pt_div_env[i]),"%f",&(pt_div[i]));
    printf("%s %f\n",pt_div_env[i],pt_div[i]);
  };
  for(Int_t i=0; i<=en_bins; i++)
  {
    sprintf(en_div_env[i],"EN_DIV_%d",i);
    sscanf(gSystem->Getenv(en_div_env[i]),"%f",&(en_div[i]));
    printf("%s %f\n",en_div_env[i],en_div[i]);
  };
  sscanf(gSystem->Getenv("PHI_LOW"),"%f",&Phi_min);
  sscanf(gSystem->Getenv("PHI_HIGH"),"%f",&Phi_max);
  sscanf(gSystem->Getenv("ETA_LOW"),"%f",&Eta_min);
  sscanf(gSystem->Getenv("ETA_HIGH"),"%f",&Eta_max);
  sscanf(gSystem->Getenv("PT_LOW"),"%f",&Pt_min);
  sscanf(gSystem->Getenv("PT_HIGH"),"%f",&Pt_max);
  sscanf(gSystem->Getenv("EN_LOW"),"%f",&E12_min);
  sscanf(gSystem->Getenv("EN_HIGH"),"%f",&E12_max);
  //*/

  
  // load run exclusion trees
  TTree * exclusion_sph = new TTree("exclusion_sph","exclusion_sph");
  TTree * exclusion_pi0 = new TTree("exclusion_pi0","exclusion_pi0");
  TTree * exclusion_thr = new TTree("exclusion_thr","exclusion_thr");
  exclusion_sph->ReadFile("exclusion_list_sph","runnum/I");
  exclusion_pi0->ReadFile("exclusion_list_pi0","runnum/I");
  exclusion_thr->ReadFile("exclusion_list_thr","runnum/I");
  Bool_t exclude_sph,exclude_pi0,exclude_thr;
  Int_t rn_sph,rn_pi0,rn_thr;
  exclusion_sph->SetBranchAddress("runnum",&rn_sph);
  exclusion_pi0->SetBranchAddress("runnum",&rn_pi0);
  exclusion_thr->SetBranchAddress("runnum",&rn_thr);


  TH2D * sph_pt_vs_eta = new TH2D("sph_pt_vs_eta","single #gamma :: p_{T} vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,Pt_max);
  TH2D * sph_en_vs_eta = new TH2D("sph_en_vs_eta","single #gamma :: E vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,E12_max);
  TH2D * sph_pt_vs_phi = new TH2D("sph_pt_vs_phi","single #gamma :: p_{T} vs. #phi",NBINS,-3.14,3.14,NBINS,0,Pt_max);
  TH2D * sph_en_vs_phi = new TH2D("sph_en_vs_phi","single #gamma :: E vs. #phi",NBINS,-3.14,3.14,NBINS,0,E12_max);
  TH2D * sph_eta_vs_phi = new TH2D("sph_eta_vs_phi","single #gamma :: #eta vs. #phi",NBINS,-3.14,3.14,NBINS,Eta_min,Eta_max);
  TH2D * sph_en_vs_pt = new TH2D("sph_en_vs_pt","single #gamma :: E vs. p_{T}",NBINS,0,Pt_max,NBINS,0,E12_max);

  TH2D * pi0_pt_vs_eta = new TH2D("pi0_pt_vs_eta","#pi^{0} (naive M cut) :: p_{T} vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,Pt_max);
  TH2D * pi0_en_vs_eta = new TH2D("pi0_en_vs_eta","#pi^{0} (naive M cut) :: E vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,E12_max);
  TH2D * pi0_pt_vs_phi = new TH2D("pi0_pt_vs_phi","#pi^{0} (naive M cut) :: p_{T} vs. #phi",NBINS,-3.14,3.14,NBINS,0,Pt_max);
  TH2D * pi0_en_vs_phi = new TH2D("pi0_en_vs_phi","#pi^{0} (naive M cut) :: E vs. #phi",NBINS,-3.14,3.14,NBINS,0,E12_max);
  TH2D * pi0_eta_vs_phi = new TH2D("pi0_eta_vs_phi","#pi^{0} (naive M cut) :: #eta vs. #phi",NBINS,-3.14,3.14,NBINS,Eta_min,Eta_max);
  TH2D * pi0_en_vs_pt = new TH2D("pi0_en_vs_pt","#pi^{0} (naive M cut) :: E vs. p_{T}",NBINS,0,Pt_max,NBINS,0,E12_max);

  TH2D * thr_pt_vs_eta = new TH2D("thr_pt_vs_eta","N_{#gamma}>2 :: p_{T} vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,Pt_max);
  TH2D * thr_en_vs_eta = new TH2D("thr_en_vs_eta","N_{#gamma}>2 :: E vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,E12_max);
  TH2D * thr_pt_vs_phi = new TH2D("thr_pt_vs_phi","N_{#gamma}>2 :: p_{T} vs. #phi",NBINS,-3.14,3.14,NBINS,0,Pt_max);
  TH2D * thr_en_vs_phi = new TH2D("thr_en_vs_phi","N_{#gamma}>2 :: E vs. #phi",NBINS,-3.14,3.14,NBINS,0,E12_max);
  TH2D * thr_eta_vs_phi = new TH2D("thr_eta_vs_phi","N_{#gamma}>2 :: #eta vs. #phi",NBINS,-3.14,3.14,NBINS,Eta_min,Eta_max);
  TH2D * thr_en_vs_pt = new TH2D("thr_en_vs_pt","N_{#gamma}>2 :: E vs. p_{T}",NBINS,0,Pt_max,NBINS,0,E12_max);

  TH2D * pi0_z_vs_eta = new TH2D("pi0_z_vs_eta","#pi^{0} (naive M cut) :: Z vs. #eta",NBINS,Eta_min,Eta_max,NBINS,0,1);
  TH2D * pi0_z_vs_phi = new TH2D("pi0_z_vs_phi","#pi^{0} (naive M cut) :: Z vs. #phi",NBINS,-3.14,3.14,NBINS,0,1);

  TH1D * mass_dist = new TH1D("mass_dist","M_{#gamma#gamma} distribution (#pi^{0} cuts without mass cut)",NBINS,0,1);
  TH1D * z_dist = new TH1D("z_dist","Z distribution (N12==2, jet1, abs(M12-0.135)<0.1, kicked==0)",NBINS,0,1);
  TH1D * trig_dist = new TH1D("trig_dist","TrigBits distribution (N12==2)",NBINS,7500,33500);
  
  TH2D * mass_vs_en = new TH2D("mass_vs_en","M_{#gamma#gamma} vs. E_{#gamma#gamma} (#pi^{0} cuts without mass cut)",
    NBINS,0,E12_max,NBINS,0,1);
  TH2D * mass_vs_pt = new TH2D("mass_vs_pt","M_{#gamma#gamma} vs. p_{T} (#pi^{0} cuts without mass cut)",
    NBINS,0,Pt_max,NBINS,0,1);

  TH1D * mass_dist_for_enbin[10];
  char mass_dist_for_enbin_n[10][64];
  char mass_dist_for_enbin_t[10][256];
  for(Int_t ee=0; ee<10; ee++)
  {
    sprintf(mass_dist_for_enbin_n[ee],"mass_dist_for_enbin%d",ee);
    sprintf(mass_dist_for_enbin_t[ee],"M_{#gamma#gamma} distribution for E_{#gamma#gamma}#in[%d,%d) GeV",ee*10,(ee+1)*10);
    mass_dist_for_enbin[ee] = new TH1D(mass_dist_for_enbin_n[ee],mass_dist_for_enbin_t[ee],NBINS,0,1);
  };

  runnum_tmp=0;
  Int_t ENT = tr->GetEntries();
  //ENT=10000;
  for(Int_t x=0; x<ENT; x++)
  {
    if((x%100000)==0) printf("filling histograms: %.2f%%\n",100*((Float_t)x)/((Float_t)ENT));
    tr->GetEntry(x);
    kicked = RD->Kicked(runnum,bx);
    if(runnum!=runnum_tmp)
    {
      b_pol = RD->BluePol(runnum);
      y_pol = RD->YellPol(runnum);
      isConsistent = RD->RellumConsistent(runnum);
      runnum_tmp=runnum;
      exclude_sph=0;
      exclude_pi0=0;
      exclude_thr=0;
      for(Int_t xx=0; xx<exclusion_sph->GetEntries(); xx++) { exclusion_sph->GetEntry(xx); if(runnum==rn_sph) exclude_sph=1; };
      for(Int_t xx=0; xx<exclusion_pi0->GetEntries(); xx++) { exclusion_pi0->GetEntry(xx); if(runnum==rn_pi0) exclude_pi0=1; };
      for(Int_t xx=0; xx<exclusion_thr->GetEntries(); xx++) { exclusion_thr->GetEntry(xx); if(runnum==rn_thr) exclude_thr=1; };
    }
    // rellum / pol cut
    if( kicked==0 && isConsistent==1 && b_pol>0 && y_pol>0)
    {
      // IF YOU CHANGE THE CUTS HERE, CHANGE THEM IN THE PLOT TITLES TOO!!!!!
      if(exclude_pi0==0 && 
         (TrigBits&0xFFF) &&
         ClIndex==0 &&
         fabs(N12-2)<0.01 &&
         Z<0.8 &&
         ( (((runnum/1000000)-1 == 12) && Pt>=2.5 && Pt<10) ||
           (((runnum/1000000)-1 == 13) && Pt>=2.0 && Pt<10) ) &&
         E12>=30 && E12<100 &&
         M12>0) 
      {
        mass_dist->Fill(M12);
        mass_vs_en->Fill(E12,M12);
        mass_vs_pt->Fill(Pt,M12);
        for(Int_t ee=0; ee<10; ee++)
        {
          if(E12>=(ee*10) && E12<((ee+1)*10)) mass_dist_for_enbin[ee]->Fill(M12);
        };
        // naive mass cut for correlation plots
        if(fabs(M12-0.135)<0.1)
        {
          pi0_pt_vs_eta->Fill(Eta,Pt);
          pi0_en_vs_eta->Fill(Eta,E12);
          pi0_pt_vs_phi->Fill(Phi,Pt);
          pi0_en_vs_phi->Fill(Phi,E12);
          pi0_eta_vs_phi->Fill(Phi,Eta);
          pi0_en_vs_pt->Fill(Pt,E12);
          pi0_z_vs_eta->Fill(Eta,Z);
          pi0_z_vs_phi->Fill(Phi,Z);
        };
      }
      if(exclude_pi0==0 && fabs(N12-2)<0.01 && (TrigBits&0xFFF) && ClIndex==0 && fabs(M12-0.135)<0.1) z_dist->Fill(Z);
      if(exclude_pi0==0 && fabs(N12-2)<0.01 && ClIndex==0) trig_dist->Fill(TrigBits);

      // single photon cut
      if(exclude_sph==0 && fabs(N12-1)<0.01)
      {
        sph_pt_vs_eta->Fill(Eta,Pt);
        sph_en_vs_eta->Fill(Eta,E12);
        sph_pt_vs_phi->Fill(Phi,Pt);
        sph_en_vs_phi->Fill(Phi,E12);
        sph_eta_vs_phi->Fill(Phi,Eta);
        sph_en_vs_pt->Fill(Pt,E12);
      };

      // three or more photons cut
      if(exclude_thr==0 && N12>2.5)
      {
        thr_pt_vs_eta->Fill(Eta,Pt);
        thr_en_vs_eta->Fill(Eta,E12);
        thr_pt_vs_phi->Fill(Phi,Pt);
        thr_en_vs_phi->Fill(Phi,E12);
        thr_eta_vs_phi->Fill(Phi,Eta);
        thr_en_vs_pt->Fill(Pt,E12);
      };
    };
  };


  /*
  // draw output -- MOVED TO DrawDiagnostics.C
  gStyle->SetOptStat(0);

  TCanvas * cc0 = new TCanvas("cc0","cc0",1000,1200);
  cc0->Divide(1,3);
  cc0->cd(1); mass_dist->Draw();
  cc0->cd(2); z_dist->Draw();
  cc0->cd(3); cc0->GetPad(3)->SetLogy(); trig_dist->Draw();


  TCanvas * cc1 = new TCanvas("cc1","cc1",1000,1200);
  cc1->Divide(2,3);
  cc1->cd(1); pt_vs_eta->Draw("colz");
  cc1->cd(2); pt_vs_phi->Draw("colz");
  cc1->cd(3); en_vs_eta->Draw("colz");
  cc1->cd(4); en_vs_phi->Draw("colz");
  cc1->cd(5); z_vs_eta->Draw("colz");
  cc1->cd(6); z_vs_phi->Draw("colz");

  TCanvas * cc2 = new TCanvas("cc2","cc2",1000,1200);
  cc2->Divide(2,3);
  cc2->cd(1); eta_vs_phi->Draw("colz");
  cc2->cd(2); en_vs_pt->Draw("colz");


  cc0->Print("diag_lin.pdf(","pdf");
  cc1->Print("diag_lin.pdf","pdf");
  cc2->Print("diag_lin.pdf)","pdf");
  printf("\ndiag_lin.pdf diagnostic kinematics file produced\n");

  for(Int_t i=1; i<=3; i++) cc0->GetPad(i)->SetLogy();
  for(Int_t i=1; i<=6; i++)
  {
    cc1->GetPad(i)->SetLogz();
    cc2->GetPad(i)->SetLogz();
  };

  cc0->Print("diag_log.pdf(","pdf");
  cc1->Print("diag_log.pdf","pdf");
  cc2->Print("diag_log.pdf)","pdf");
  printf("\ndiag_log.pdf diagnostic kinematics file produced\n");

  printf("E12 range: %f -- %f\n",E12_min,E12_max);
  printf("Pt range: %f -- %f\n",Pt_min,Pt_max);
  printf("Eta range: %f -- %f\n",Eta_min,Eta_max);
  printf("Phi range: %f -- %f\n",Phi_min,Phi_max);
  */

  // write output
  TFile * outfile = new TFile("diag.root","RECREATE");

  mass_dist->Write();
  z_dist->Write();
  trig_dist->Write();
  mass_vs_en->Write();
  mass_vs_pt->Write();

  for(Int_t ee=0; ee<10; ee++) mass_dist_for_enbin[ee]->Write();

  sph_pt_vs_eta->Write();
  sph_en_vs_eta->Write();
  sph_pt_vs_phi->Write();
  sph_en_vs_phi->Write();
  sph_eta_vs_phi->Write();
  sph_en_vs_pt->Write();

  pi0_pt_vs_eta->Write();
  pi0_en_vs_eta->Write();
  pi0_pt_vs_phi->Write();
  pi0_en_vs_phi->Write();
  pi0_eta_vs_phi->Write();
  pi0_en_vs_pt->Write();

  thr_pt_vs_eta->Write();
  thr_en_vs_eta->Write();
  thr_pt_vs_phi->Write();
  thr_en_vs_phi->Write();
  thr_eta_vs_phi->Write();
  thr_en_vs_pt->Write();

  pi0_z_vs_eta->Write();
  pi0_z_vs_phi->Write();


}
Exemplo n.º 20
0
int main(int argc, char ** argv){
  char inputFileName[2000];
  bool isList=true;
  char outFileName[2000];
  char cfg[400];
  bool isData=false;
  int start=0;
  int stop=-1;
  
  ArgParser parser(argc,argv);
  parser.addLongOption("isData",ArgParser::noArg,"Specify data or MC");
  parser.addLongOption("json",ArgParser::reqArg,"Specify the JSON to use");
  parser.addLongOption("config",ArgParser::reqArg, "Specify the configuration file");
  parser.addLongOption("start",ArgParser::reqArg, "first event to process");
  parser.addLongOption("stop",ArgParser::reqArg, "last event to process");
  parser.addShortOption('f',ArgParser::noArg,"Specify whether the input file is a single file"); //use this if we only specify one file, not a list
  parser.addArgument("inputFile",ArgParser::required,"input file, expects a list unless -f is set");
  parser.addArgument("outputFile",ArgParser::required,"output file");

    std::string error;
  int retCode = parser.process(error);

  if(retCode != 0){
    cout << "ERROR Parsing option: " << error << "   return code: " << retCode << endl;
    parser.printOptions("CaltechAnalyzerApp");
    return 0;
  }

  isData = parser.longFlagPres("isData");
  strncpy(cfg,parser.getLongFlag("config").c_str(),400);
  isList = !parser.shortFlagPres('f');

  if(parser.longFlagPres("start")) start = atoi(parser.getLongFlag("start").c_str());
  if(parser.longFlagPres("stop")) stop = atoi(parser.getLongFlag("stop").c_str());

  strncpy(inputFileName,parser.getArgument("inputFile").c_str(),2000);
  strncpy(outFileName,parser.getArgument("outputFile").c_str(),2000);
  
  cout << "Running with Arguments: " << endl
       << "isData: " << isData << endl
       << "isList: " << isList << endl
       << "config: " << cfg << endl
       << "inputFile: " << inputFileName << endl
       << "outputFile: " << outFileName << endl;

    TChain *theChain = new TChain("ntp1");
  char Buffer[2000];
  char MyRootFile[2000];  
  if(isList){
    ifstream *inputFile = new ifstream(inputFileName);
    char tmpFileName[2000];
    while( !(inputFile->eof()) ){
      inputFile->getline(Buffer,2000);
      if (!strstr(Buffer,"#") && !(strspn(Buffer," ") == strlen(Buffer)))
	{
	  sscanf(Buffer,"%s",MyRootFile);
	  if(string(MyRootFile).find("eos") != std::string::npos) {
	    theChain->Add("root:/"+TString(MyRootFile));
	  } else if(string(MyRootFile).find("castor") != std::string::npos) {
	    theChain->Add("rfio:"+TString(MyRootFile));
	  } else{
	    theChain->Add(TString(MyRootFile));	 
	  }
	  // theChain->Add("root://castorcms/"+TString(MyRootFile));
	  //        theChain->Add(TString(MyRootFile));
	  std::cout << "chaining " << MyRootFile << std::endl;
	  //	if ( nfiles==1 ) {
	  //	  TFile *firstfile = TFile::Open("root://castorcms/"+TString(MyRootFile));
	  //	  treeCond = (TTree*)firstfile->Get("Conditions");
	  //	}
	  //        nfiles++;
	}
    }
    inputFile->close();
    
  }else{
    if(string(inputFileName).find("eos") != std::string::npos) {
      theChain->Add("root:/"+TString(inputFileName));
    } else if(string(inputFileName).find("castor") != std::string::npos) {
      theChain->Add("rfio:"+TString(inputFileName));
    } else{
      theChain->Add(TString(inputFileName));	 
    }
    std::cout << "chaining " << inputFileName << std::endl;
  }

  __ANALYSIS__ analyzer(theChain,__ANALYSIS__,outFileName,isData);
  analyzer.setConfigFile(cfg);
  analyzer.process(start,stop);
}
Exemplo n.º 21
0
//int data_MC_Pt_Comparison_entries(int EndCaps = 0, int r9sup = 1, int log = 0)
int main(int argc, char *argv[])
{

	for(int iarg = 0 ; iarg < argc; iarg++)
        {
                cout << "argv[" << iarg << "]= " << argv[iarg] << endl;
        }

        if( argc == 1 ) 
        {
                cerr << "arguments should be passed : directoryName, eta, r9, xVariable, log" <<endl; 
                return 1;

        }    

	string directoryName = "Data_MC_Mmumugamma_Comparison_ScaleAndSmearing/smearingFactors";
	string eta = "Barrel_1";
	string r9 = "all";
	string ptCut = "25"; // "30" "35"

	if( argc > 1 ) directoryName = argv[1];
	if( argc > 2 ) eta = argv[2];
        if( argc > 3 ) r9 = argv[3];	
	if( argc > 4 ) ptCut = argv[4];	

	


	int nBins = 50; //FIXME
	double xMin, xMax;
	xMin = 0.9; //FIXME
	xMax = 1.1; //FIXME
	
	string xVariableName, yVariableName;

	gROOT->Reset();
        TGaxis::SetMaxDigits(3);
        setTDRStyle();
	//setEgammaStyle();

	string directoryName_2 = directoryName;
	string fileName = directoryName;

	cout<<endl<<"fileName = "<<fileName<<endl;
	cout<<endl<<"directoryName = "<<directoryName<<endl;
	directoryName += Form("/%s_%sR9/",eta.c_str(), r9.c_str());
	
	TString cut = Form("(Photon_Et > %s && isJanLooseMMG == 1",ptCut.c_str());

	if(r9 == "low" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && Photon_r9 < 0.94 && abs(Photon_SC_Eta) < 1";
        if(r9 == "low" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && Photon_r9 < 0.94 && abs(Photon_SC_Eta) > 1";
	if(r9 == "high" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && Photon_r9 > 0.94 && abs(Photon_SC_Eta) < 1";
	if(r9 == "high" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && Photon_r9 > 0.94 && abs(Photon_SC_Eta) > 1";
        if(r9 == "low" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && Photon_r9 < 0.95 && abs(Photon_SC_Eta) < 2";
	if(r9 == "low" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && Photon_r9 < 0.95 && abs(Photon_SC_Eta) > 2";
        if(r9 == "high" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && Photon_r9 > 0.95 && abs(Photon_SC_Eta) < 2";
	if(r9 == "high" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && Photon_r9 > 0.95 && abs(Photon_SC_Eta) > 2";
        if(r9 == "all" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && abs(Photon_SC_Eta) < 1";
	if(r9 == "all" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && abs(Photon_SC_Eta) > 1";
        if(r9 == "all" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && abs(Photon_SC_Eta) < 2";
	if(r9 == "all" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && abs(Photon_SC_Eta) > 2";
	if(r9 == "all" && eta == "all") cut += " && (Photon_isEE == 1 || Photon_isEB == 1)";

	cut += ")*weight_pileUp"; 

	cout<<endl<<"cut = "<<cut<<endl;

        TChain * dYToMuMuFSRChainNew = new TChain("miniTree");
        TChain * dYToMuMuNonFSRChainNew = new TChain("miniTree");
        TChain * ttJetsChainNew = new TChain("miniTree");
        TChain * wJetsChainNew = new TChain("miniTree");

        dYToMuMuFSRChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_DYToMuMu_M-20_CT10_TuneZ2_7TeV-powheg-pythia_Fall11-PU_S6_START42_V14B-v1_September12_NewSelection_1_scaleAndsmearing_v4_partALL.root");
        dYToMuMuNonFSRChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_DYToMuMu_M-20_CT10_TuneZ2_7TeV-powheg-pythia_Fall11-PU_S6_START42_V14B-v1_September12_NewSelection_2_scaleAndsmearing_v4_partALL.root");
        ttJetsChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_TTJets_TuneZ2_7TeV-madgraph-tauola_NewSelection_3_scaleAndsmearing_v4_partALL.root");
        wJetsChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_WJetsToLNu_TuneZ2_7TeV-madgraph-tauola_NewSelection_3_scaleAndsmearing_v4_partALL.root");
	

	TCanvas *c1 = new TCanvas("c1", "c1",0,0,600,600);

        TH1D *dYToMuMuFSRNew = new TH1D("dYToMuMuFSRNew","dYToMuMuFSRNew", nBins, xMin, xMax);
        TH1D *dYToMuMuNonFSRNew = new TH1D("dYToMuMuNonFSRNew","dYToMuMuNonFSRNew", nBins, xMin, xMax);
        TH1D *ttJetsNew = new TH1D("ttJetsNew","ttJetsNew", nBins, xMin, xMax);
        TH1D *wJetsNew = new TH1D("wJetsNew","wJetsNew", nBins, xMin, xMax);

        dYToMuMuFSRChainNew->Draw("shervinSmearing>>dYToMuMuFSRNew",cut);
        dYToMuMuNonFSRChainNew->Draw("shervinSmearing>>dYToMuMuNonFSRNew",cut);
        ttJetsChainNew->Draw("shervinSmearing>>ttJetsNew",cut);
        wJetsChainNew->Draw("shervinSmearing>>wJetsNew",cut);


	// --- 2012 Lumi --- //
        //double lumidata = 808.472 + 82.136 + 4429.0 + 495.003 + 134.242 + 6397.0 + 7274.0;
        //double lumiDY = 48819386.0 / 1914.894;
        //double lumiTtJets = 6736135.0 / 234.0;
        //double lumiwJets = 57709905.0 / 37509.25;	

	// --- 2011 Lumi --- //
	double lumidata = (0.706370 + 0.385819 + 2.741 + 1.099) * 1000;
	double lumiDY = 29743564.0 / 1665.835;
	double lumiTtJets = 3701947.0 / 165.0;
	double lumiwJets = 81345381.0 / 31314.0;	

	// --- 2011 Lumi old --- //
	//double lumiDY = 29743564.0 / 1626.0;
        //double lumiTtJets = 3701947.0 / 94.76;
        //double lumiwJets = 81345381.0 / 27770.0;

	ttJetsNew->Scale(lumiDY / lumiTtJets);
	wJetsNew->Scale(lumiDY / lumiwJets);
		
	dYToMuMuFSRNew->Add(dYToMuMuNonFSRNew);
	dYToMuMuFSRNew->Add(ttJetsNew);
	dYToMuMuFSRNew->Add(wJetsNew);

	dYToMuMuNonFSRNew->Add(ttJetsNew);
	dYToMuMuNonFSRNew->Add(wJetsNew);

	ttJetsNew->Add(wJetsNew);

	c1->Clear();


	dYToMuMuFSRNew->GetYaxis()->SetTitle("Events / 0.004"); //FIXME
       	dYToMuMuFSRNew->GetXaxis()->SetTitle("smearing factors");	

	/*
	dYToMuMuFSR->GetXaxis()->SetLabelFont(42);
	dYToMuMuFSR->GetXaxis()->SetTitleFont(42);
	dYToMuMuFSR->GetYaxis()->SetLabelFont(42);
	dYToMuMuFSR->GetYaxis()->SetTitleFont(42);
	dYToMuMuFSR->GetYaxis()->SetTitleOffset(1.65);
	*/

	dYToMuMuFSRNew->SetFillColor(kGreen-7);
        dYToMuMuNonFSRNew->SetFillColor(kAzure-5);
        ttJetsNew->SetFillColor(kBlue-1);
        wJetsNew->SetFillColor(kCyan+2);

	dYToMuMuFSRNew->Draw("");


	// --- Fit --- //

        TF1 * f1 = new TF1("f1","gaus",xMin,xMax);
	//TF1 * f1 = new TF1("f1","gaus",0.96,1.04);
	//f1->FixParameter(1,1.0); //FIXME
        //f1->FixParameter(2,1.0); //FIXME
        dYToMuMuFSRNew->Fit(f1);
        f1->SetLineColor(kBlue);
        f1->SetLineWidth(2);
        f1->Draw("SAMES");

        c1->Clear();
        dYToMuMuFSRNew->Draw("E");
        f1->Draw("SAMES");

        dYToMuMuFSRNew->SetMarkerStyle(20);
        dYToMuMuFSRNew->SetMarkerSize(0.5);
	
	TLatex latexLabel;
	latexLabel.SetTextFont(42);
	latexLabel.SetTextSize(0.028);
	latexLabel.SetNDC();
	//latexLabel.DrawLatex(0.25, 0.96, "CMS Preliminary 2011               #sqrt{s} = 7 TeV               L = 4.93 fb^{-1}");
	
	//double Ymin = 0;
	//double Ymax = max(dYToMuMuFSR->GetMaximum(),data->GetMaximum()) + max(dYToMuMuFSR->GetMaximum(),data->GetMaximum()) * 0.1;	
	//cout << "Ymax = "<<Ymax<<endl;

	//dYToMuMuFSRNew->GetYaxis()->SetRangeUser(Ymin,Ymax);

	plotsRecording(directoryName, fileName, c1);

	c1->Clear();

	f1->Delete();
	f1 = 0;
        dYToMuMuFSRNew->Delete();
        dYToMuMuFSRNew = 0;
        dYToMuMuNonFSRNew->Delete();
        dYToMuMuNonFSRNew = 0;
        ttJetsNew->Delete();
        ttJetsNew = 0;
        wJetsNew->Delete();
        wJetsNew = 0;
        dYToMuMuFSRChainNew->Delete();
        dYToMuMuFSRChainNew = 0;
        dYToMuMuNonFSRChainNew->Delete();
        dYToMuMuNonFSRChainNew = 0;
        ttJetsChainNew->Delete();
        ttJetsChainNew = 0;
        wJetsChainNew->Delete();
        wJetsChainNew = 0;


	
	delete c1;
	c1 = 0;	
	
	return 0;

}
Exemplo n.º 22
0
void SMS(char* sample = "wzsms" , bool print = false){

  //--------------------------------------------------
  // input parameters
  //--------------------------------------------------
  
  const float denom    = 100000;
  const float lumi     =   9200;
  const char* filename = Form("../../output/V00-01-05/%s_baby_oldIso.root",sample);

  cout << "Using file        " << filename << endl;
  cout << "Using denominator " << denom    << " events" << endl;
  cout << "Using lumi        " << lumi     << " pb-1" << endl;

  //--------------------------------------------------
  // set text stuff
  //--------------------------------------------------

  char* xtitle  = "m_{#chi_{2}^{0}} = m_{#chi_{1}^{#pm}} [GeV]";
  char* ytitle  = "m_{#chi_{1}^{0}} [GeV]";
  char* label   = "CMS Preliminary   #sqrt{s} = 8 TeV, #scale[0.6]{#int}Ldt = 9.2 fb^{-1}";
  char* process = "pp #rightarrow#chi_{2}^{0} #chi_{1}^{#pm} #rightarrow WZ+E_{T}^{miss}";

  //--------------------------------------------------
  // read in TChain
  //--------------------------------------------------

  TChain *ch = new TChain("T1");
  ch->Add(filename);

  //--------------------------------------------------
  // read in reference cross section
  //--------------------------------------------------

  TFile *xsecfile = TFile::Open("C1N2_8TeV_finer.root");
  TH1F* refxsec   = (TH1F*) xsecfile->Get("C1N2_8TeV_NLO");

  //--------------------------------------------------
  // preselection
  //--------------------------------------------------

  TCut pt2020("lep1.pt()>20.0 && lep2.pt()>20.0");
  TCut Zmass("dilmass>81 && dilmass<101");
  TCut sf = "leptype<2";
  TCut njets2("njets>=2");
  TCut bveto("nbcsvm==0");
  TCut nlep2("nlep==2");
  TCut mjj("mjj>70.0 && mjj<110.0");

  TCut presel;
  presel += pt2020;
  presel += Zmass;
  presel += sf;
  presel += njets2;
  presel += bveto;
  presel += mjj;
  presel += nlep2;

  TCut weight("vtxweight * trgeff");

  cout << "Using selection   " << presel.GetTitle() << endl;
  cout << "Using weight      " << weight.GetTitle() << endl;

  //--------------------------------------------------
  // signal regions
  //--------------------------------------------------

  vector<TCut>    sigcuts;
  vector<string>  signames;
  vector<string>  labels;
  vector<int>     cuts;

  TCut met60 ("pfmet > 60.0");
  TCut met80 ("pfmet > 80.0");
  TCut met100("pfmet > 100.0");
  TCut met120("pfmet > 120.0");
  TCut met140("pfmet > 140.0");
  TCut met160("pfmet > 160.0");
  TCut met180("pfmet > 180.0");
  TCut met200("pfmet > 200.0");

  // sigcuts.push_back(TCut(presel+met60));      signames.push_back("E_{T}^{miss} > 60 GeV");      labels.push_back("met60");  cuts.push_back(60);
  // sigcuts.push_back(TCut(presel+met80));      signames.push_back("E_{T}^{miss} > 80 GeV");      labels.push_back("met80");  cuts.push_back(80);
  // sigcuts.push_back(TCut(presel+met100));     signames.push_back("E_{T}^{miss} > 100 GeV");     labels.push_back("met100"); cuts.push_back(100);
  sigcuts.push_back(TCut(presel+met120));     signames.push_back("E_{T}^{miss} > 120 GeV");     labels.push_back("met120"); cuts.push_back(120);
  // sigcuts.push_back(TCut(presel+met140));     signames.push_back("E_{T}^{miss} > 140 GeV");     labels.push_back("met140"); cuts.push_back(140);
  // sigcuts.push_back(TCut(presel+met160));     signames.push_back("E_{T}^{miss} > 160 GeV");     labels.push_back("met160"); cuts.push_back(160);
  // sigcuts.push_back(TCut(presel+met180));     signames.push_back("E_{T}^{miss} > 180 GeV");     labels.push_back("met180"); cuts.push_back(180);
  // sigcuts.push_back(TCut(presel+met200));     signames.push_back("E_{T}^{miss} > 200 GeV");     labels.push_back("met200"); cuts.push_back(200);

  const unsigned int nsig = sigcuts.size();

  //--------------------------------------------------
  // make efficiency and xsec TH2's
  //--------------------------------------------------
  
  TH2F* heff[nsig];
  TH2F* heffup[nsig];
  TH2F* heffdn[nsig];
  TH2F* hxsec[nsig];
  TH2F* hxsec_exp[nsig];
  TH2F* hexcl[nsig];
  TH2F* hjes[nsig];
  
  TCanvas *ctemp = new TCanvas();
  ctemp->cd();

  for( unsigned int i = 0 ; i < nsig ; ++i ){

    TString jesup(sigcuts.at(i));
    jesup.ReplaceAll("njets","njetsup");
    jesup.ReplaceAll("pfmet","pfmetup");

    TString jesdn(sigcuts.at(i));
    jesdn.ReplaceAll("njets","njetsdn");
    jesdn.ReplaceAll("pfmet","pfmetdn");

    TCut jesupcut(jesup);
    TCut jesdncut(jesdn);

    cout << endl << endl;
    cout << "Signal region : " << labels.at(i)  << endl;
    cout << "Selection     : " << sigcuts.at(i) << endl;
    cout << "Selection up  : " << jesupcut      << endl;
    cout << "Selection dn  : " << jesdncut      << endl;

    int   nx   =  26;
    float xmin =  95;
    float xmax = 355;

    int   ny   =  36;
    float ymin =  -5;
    float ymax = 355;
    
    heff[i]      = new TH2F(Form("heff_%i",i)        , Form("heff_%i",i)       ,  nx , xmin , xmax , ny , ymin , ymax );
    heffup[i]    = new TH2F(Form("heffup_%i",i)      , Form("heffup_%i",i)     ,  nx , xmin , xmax , ny , ymin , ymax );
    heffdn[i]    = new TH2F(Form("heffdn_%i",i)      , Form("heffdn_%i",i)     ,  nx , xmin , xmax , ny , ymin , ymax );
    hxsec[i]     = new TH2F(Form("hxsec_%i",i)       , Form("hxsec_%i",i)      ,  nx , xmin , xmax , ny , ymin , ymax );
    hxsec_exp[i] = new TH2F(Form("hxsec_exp_%i",i)   , Form("hxsec_exp_%i",i)  ,  nx , xmin , xmax , ny , ymin , ymax );
    hexcl[i]     = new TH2F(Form("hexcl_%i",i)       , Form("hexcl_%i",i)      ,  nx , xmin , xmax , ny , ymin , ymax );
    hjes[i]      = new TH2F(Form("hjes_%i",i)        , Form("hjes_%i",i)       ,  nx , xmin , xmax , ny , ymin , ymax );

    ch->Draw(Form("ml:mg>>heff_%i",i),sigcuts.at(i)*weight);
    heff[i]->Scale(1.0/denom);

    // ch->Draw(Form("ml:mg>>heffup_%i",i),jesupcut*weight);
    // heffup[i]->Scale(1.0/denom);

    // ch->Draw(Form("ml:mg>>heffdn_%i",i),jesdncut*weight);
    // heffdn[i]->Scale(1.0/denom);

    for( unsigned int ibin = 1 ; ibin <= nx ; ibin++ ){
      for( unsigned int jbin = 1 ; jbin <= ny ; jbin++ ){

	float mg = heff[i]->GetXaxis()->GetBinCenter(ibin);
	float ml = heff[i]->GetYaxis()->GetBinCenter(jbin);

	float eff    = heff[i]->GetBinContent(ibin,jbin);
	// float effup  = heffup[i]->GetBinContent(ibin,jbin);
	// float effdn  = heffdn[i]->GetBinContent(ibin,jbin);

	if( eff   < 1e-20 ) continue;

	// float dup    = effup/eff-1;
	// float ddn    = 1-effdn/eff;
	// float djes   = 0.5 * (dup+ddn);
	// hjes[i]->SetBinContent(ibin,jbin,djes);

	// float toterr = sqrt( 0.04*0.04 + 0.05*0.05 + 0.05*0.05 + djes*djes );

	//float this_ul = getObservedLimit( cuts.at(i) , toterr );
	float this_ul = getObservedUpperLimit( cuts.at(i) );
	float xsecul  = this_ul / ( lumi * eff );

	//float this_ul_exp = getExpectedLimit( cuts.at(i) , toterr );
	float this_ul_exp = getExpectedUpperLimit( cuts.at(i) );
	float xsecul_exp  = this_ul_exp / ( lumi * eff );

	if( eff > 0 ){
	  hxsec[i]->SetBinContent(ibin,jbin, xsecul );
	  hxsec_exp[i]->SetBinContent(ibin,jbin, xsecul_exp );
	}

	int   bin = refxsec->FindBin(mg);
	float xsec = refxsec->GetBinContent(bin);

	hexcl[i]->SetBinContent(ibin,jbin,0);
	if( xsec > xsecul )   hexcl[i]->SetBinContent(ibin,jbin,1);
	//cout << "ibin jbin mg xsec " << ibin << " " << jbin << " " << mg << " " << xsec << endl;
      }
    }
  }

  delete ctemp;

  cout << endl << endl;

  //--------------------------------------------------
  // make pretty pictures
  //--------------------------------------------------
  
  TLatex *t = new TLatex();
  t->SetNDC();
  t->SetTextSize(0.04);

  TCanvas* can[nsig];

  for( unsigned int i = 0 ; i < nsig ; ++i ){
  
    //can[i] = new TCanvas(Form("can_%i",i),Form("can_%i",i),1200,600);
    //can[i]->Divide(2,1);
    //can[i] = new TCanvas(Form("can_%i",i),Form("can_%i",i),1800,600);
    //can[i]->Divide(3,1);
    can[i] = new TCanvas(Form("can_%i",i),Form("can_%i",i),1000,1000);
    can[i]->Divide(2,2);

    //-------------------------------
    // efficiency
    //-------------------------------

    can[i]->cd(1);
    gPad->SetTopMargin(0.1);
    gPad->SetRightMargin(0.2);
    heff[i]->GetXaxis()->SetLabelSize(0.035);
    heff[i]->Scale(1000);
    heff[i]->GetYaxis()->SetTitle(ytitle);
    heff[i]->GetXaxis()->SetTitle(xtitle);
    heff[i]->GetZaxis()->SetTitle("efficiency (10^{-3})");
    heff[i]->Draw("colz");

    
    t->DrawLatex(0.2 ,0.83,process);
    t->DrawLatex(0.2 ,0.71,signames.at(i).c_str());
    t->DrawLatex(0.18,0.92,label);

    //-------------------------------
    // cross section
    //-------------------------------
  
    can[i]->cd(2);
    gPad->SetTopMargin(0.1);
    gPad->SetRightMargin(0.2);
    gPad->SetLogz();
    hxsec[i]->GetXaxis()->SetLabelSize(0.035);
    hxsec[i]->GetYaxis()->SetTitle(ytitle);
    hxsec[i]->GetXaxis()->SetTitle(xtitle);
    hxsec[i]->GetXaxis()->SetRangeUser(95,305);
    hxsec[i]->GetYaxis()->SetRangeUser(-5,305);
    hxsec[i]->GetZaxis()->SetTitle("#sigma upper limit [pb]");
    hxsec[i]->Draw("colz");
    hxsec[i]->SetMinimum(0.01);
    hxsec[i]->SetMaximum(100);

    TGraph* gr2011 = getGraph_2011();
    TGraph* gr2012 = getGraph_2012();

    gr2011->Draw("same");
    gr2012->Draw("same");

    // TGraph* gr_excl      = getRefXsecGraph(hxsec[i], "T5zz", 1.0);
    // TGraph* gr_excl_down = getRefXsecGraph(hxsec[i], "T5zz", 1./3.);
    // TGraph* gr_excl_up   = getRefXsecGraph(hxsec[i], "T5zz", 3.);

    // gr_excl->SetLineWidth(2);
    // gr_excl_up->SetLineWidth(2);
    // gr_excl_down->SetLineWidth(2);
    // gr_excl_up->SetLineStyle(2);
    // gr_excl_down->SetLineStyle(3);
    // gr_excl->Draw("same");
    // gr_excl_up->Draw("same");
    // gr_excl_down->Draw("same");

    TLegend *leg = new TLegend(0.2,0.53,0.53,0.67);
    // leg->AddEntry(gr_excl,"#sigma^{prod} = #sigma^{NLO-QCD}","l");
    // leg->AddEntry(gr_excl_up,"#sigma^{prod} = 3 #times #sigma^{NLO-QCD}","l");
    // leg->AddEntry(gr_excl_down,"#sigma^{prod} = 1/3 #times #sigma^{NLO-QCD}","l");
    leg->AddEntry(gr2011,"2011 observed","l");
    leg->AddEntry(gr2012,"2012 expected","l");
    leg->SetFillColor(0);
    leg->SetBorderSize(0);
    leg->Draw();

    // t->DrawLatex(0.2,0.83,"pp #rightarrow #tilde{g}#tilde{g}, #tilde{g} #rightarrow 2j+#chi_{2}^{0}, #chi_{2}^{0} #rightarrow Z #chi_{1}^{0}");
    // t->DrawLatex(0.2,0.77,"m(#tilde{q}) >> m(#tilde{g})");
    // t->DrawLatex(0.2,0.71,signames.at(i).c_str());
    // t->DrawLatex(0.18,0.92,"CMS Preliminary            #sqrt{s} = 7 TeV, #scale[0.6]{#int}Ldt = 4.7 fb^{-1}");

    t->DrawLatex(0.2 ,0.83,process);
    t->DrawLatex(0.2 ,0.71,signames.at(i).c_str());
    t->DrawLatex(0.18,0.92,label);

    //-------------------------------
    // excluded points
    //-------------------------------

    can[i]->cd(3);
    gPad->SetGridx();
    gPad->SetGridy();
    gPad->SetRightMargin(0.2);
    gPad->SetTopMargin(0.1);
    hexcl[i]->GetXaxis()->SetRangeUser(150,250);
    hexcl[i]->GetYaxis()->SetRangeUser(-10,100);
    hexcl[i]->GetYaxis()->SetTitle("#chi^{0}_{1} mass (GeV)");
    hexcl[i]->GetXaxis()->SetTitle("gluino mass (GeV)");
    hexcl[i]->GetZaxis()->SetTitle("excluded points");
    hexcl[i]->Draw("colz");

    gr2012->Draw("same");
    gr2012->Draw("samep");

    //gr_excl->Draw("same");

    // t->DrawLatex(0.2,0.83,"pp #rightarrow #tilde{g}#tilde{g}, #tilde{g} #rightarrow 2j+#chi_{2}^{0}, #chi_{2}^{0} #rightarrow Z #chi_{1}^{0}");
    // t->DrawLatex(0.2,0.77,"m(#tilde{q}) >> m(#tilde{g})");
    // t->DrawLatex(0.2,0.71,signames.at(i).c_str());
    // t->DrawLatex(0.18,0.92,"CMS Preliminary            #sqrt{s} = 7 TeV, #scale[0.6]{#int}Ldt = 4.7 fb^{-1}");

    t->DrawLatex(0.2 ,0.83,process);
    t->DrawLatex(0.2 ,0.71,signames.at(i).c_str());
    t->DrawLatex(0.18,0.92,label);

    //-------------------------------
    // JES uncertainty
    //-------------------------------

    can[i]->cd(4);
    gPad->SetRightMargin(0.2);
    gPad->SetTopMargin(0.1);
    hjes[i]->GetYaxis()->SetTitle("#chi^{0}_{1} mass (GeV)");
    hjes[i]->GetXaxis()->SetTitle("gluino mass (GeV)");
    hjes[i]->GetZaxis()->SetTitle("JES uncertainty");
    hjes[i]->Draw("colz");

    t->DrawLatex(0.2 ,0.83,process);
    t->DrawLatex(0.2 ,0.71,signames.at(i).c_str());
    t->DrawLatex(0.18,0.92,label);

    // t->DrawLatex(0.2,0.83,"pp #rightarrow #tilde{g}#tilde{g}, #tilde{g} #rightarrow 2j+#chi_{2}^{0}, #chi_{2}^{0} #rightarrow Z #chi_{1}^{0}");
    // t->DrawLatex(0.2,0.77,"m(#tilde{q}) >> m(#tilde{g})");
    // t->DrawLatex(0.2,0.71,signames.at(i).c_str());
    // t->DrawLatex(0.18,0.92,"CMS Preliminary            #sqrt{s} = 7 TeV, #scale[0.6]{#int}Ldt = 4.7 fb^{-1}");

    if( print ){
      can[i]->Print(Form("../../plots/%s.pdf",labels.at(i).c_str()));
      //can[i]->Print(Form("../plots/%s.eps",labels.at(i).c_str()));
      //gROOT->ProcessLine(Form(".! ps2pdf ../plots/%s.eps  ../plots/%s.pdf",labels.at(i).c_str(),labels.at(i).c_str()));
    }

    int bin = heff[i]->FindBin(250,50);
    cout << "efficiency (250,50)  " << heff[i]->GetBinContent(bin) << endl;
    cout << "xsec UL              " << hxsec[i]->GetBinContent(bin) << endl;
    cout << "xsec UL exp          " << hxsec_exp[i]->GetBinContent(bin) << endl;
    cout << "JES                  " << hjes[i]->GetBinContent(bin) << endl;
    cout << "tot err              " << sqrt(pow(hjes[i]->GetBinContent(bin),2)+0.06*0.06+0.05*0.05) << endl;
    cout << endl << endl;
  }
  
  TFile *outfile = TFile::Open(Form("%s_histos.root",sample),"RECREATE");
  outfile->cd();
  for( unsigned int i = 0 ; i < nsig ; ++i ){
    hxsec[i]->Write();
    heff[i]->Write();
    hxsec_exp[i]->Write();
  }
  outfile->Close();

}
Exemplo n.º 23
0
void AddDetectorEffects(TString infile,TString outfile)
{
	InitExterns();
	const int kMaxTrack = 10;	// maximal number of particles in a single event.
	
	
	int evt = -999;
	
	int nPhoton = 0;
	float photonPt[kMaxTrack];
	float photonEta[kMaxTrack];
	float photonPhi[kMaxTrack];
	
	int nElectron = 0;
	float electronPt[kMaxTrack];
	float electronEta[kMaxTrack];
	float electronPhi[kMaxTrack];
	int electronQ[kMaxTrack];
	int electronTag[kMaxTrack];
	float electronCal02[kMaxTrack];
	float electronCal03[kMaxTrack];
	float electronCal04[kMaxTrack];
	float electronTrk02[kMaxTrack];
	float electronTrk03[kMaxTrack];
	float electronTrk04[kMaxTrack];
	float electronSign[kMaxTrack];
	
	int nMuon = 0;
	float muonPt[kMaxTrack];
	float muonEta[kMaxTrack];
	float muonPhi[kMaxTrack];
	int muonQ[kMaxTrack];
	int muonTag[kMaxTrack];
	float muonCal02[kMaxTrack];
	float muonCal03[kMaxTrack];
	float muonCal04[kMaxTrack];
	float muonTrk02[kMaxTrack];
	float muonTrk03[kMaxTrack];
	float muonTrk04[kMaxTrack];
	float muonSign[kMaxTrack];
	
	int nTau = 0;
	float tauPt[kMaxTrack];
	float tauEta[kMaxTrack];
	float tauPhi[kMaxTrack];
	int tauQ[kMaxTrack];
	int tauTag[kMaxTrack];
	float tauCal02[kMaxTrack];
	float tauCal03[kMaxTrack];
	float tauCal04[kMaxTrack];
	float tauTrk02[kMaxTrack];
	float tauTrk03[kMaxTrack];
	float tauTrk04[kMaxTrack];
	float tauSign[kMaxTrack];
	
	int nJet = 0;
	float jetPt[kMaxTrack];
	float jetEta[kMaxTrack];
	float jetPhi[kMaxTrack];
	int jetQ[kMaxTrack];
	int jetTag[kMaxTrack];
	float jetCal02[kMaxTrack];
	float jetCal03[kMaxTrack];
	float jetCal04[kMaxTrack];
	float jetTrk02[kMaxTrack];
	float jetTrk03[kMaxTrack];
	float jetTrk04[kMaxTrack];
	
	float metPt = -999.;
	float metEta = -999.;
	float metPhi = -999.;

	float sf_mu_reco_eff[kMaxTrack];	// scale factor muon reco efficiency
	float sf_el_reco_eff[kMaxTrack];	// scale factor electron reco efficiency
	
	
	TFile f(outfile,"recreate");	// the file and tree
	TTree *t = new TTree("t","Reconst ntuple");
	
	
	// adding branches:
	// t->Branch(Branch name in the browser, pointer to the variable, variable name)
	
	t->Branch("evt",&evt,"evt/I");

	t->Branch("nPhoton",&nPhoton,"nPhoton/I");
	t->Branch("photonPt",photonPt,"photonPt[nPhoton]/F");
	t->Branch("photonEta",photonEta,"photonEta[nPhoton]/F");
	t->Branch("photonPhi",photonPhi,"photonPhi[nPhoton]/F");

	t->Branch("nElectron",&nElectron,"nElectron/I");
	t->Branch("electronPt",electronPt,"electronPt[nElectron]/F");
	t->Branch("electronEta",electronEta,"electronEta[nElectron]/F");
	t->Branch("electronPhi",electronPhi,"electronPhi[nElectron]/F");
	t->Branch("electronQ",electronQ,"electronQ[nElectron]/I");
	t->Branch("electronTag",electronTag,"electronTag[nElectron]/I");
	t->Branch("electronCal02",electronCal02,"electronCal02[nElectron]/F");
	t->Branch("electronCal03",electronCal03,"electronCal03[nElectron]/F");
	t->Branch("electronCal04",electronCal04,"electronCal04[nElectron]/F");
	t->Branch("electronTrk02",electronTrk02,"electronTrk02[nElectron]/F");
	t->Branch("electronTrk03",electronTrk03,"electronTrk03[nElectron]/F");
	t->Branch("electronTrk04",electronTrk04,"electronTrk04[nElectron]/F");
	t->Branch("electronSign",electronSign,"electronSign[nElectron]/F");
	
	t->Branch("nMuon",&nMuon,"nMuon/I");
	t->Branch("muonPt",muonPt,"muonPt[nMuon]/F");
	t->Branch("muonEta",muonEta,"muonEta[nMuon]/F");
	t->Branch("muonPhi",muonPhi,"muonPhi[nMuon]/F");
	t->Branch("muonQ",muonQ,"muonQ[nMuon]/I");
	t->Branch("muonTag",muonTag,"muonTag[nMuon]/I");
	t->Branch("muonCal02",muonCal02,"muonCal02[nMuon]/F");
	t->Branch("muonCal03",muonCal03,"muonCal03[nMuon]/F");
	t->Branch("muonCal04",muonCal04,"muonCal04[nMuon]/F");
	t->Branch("muonTrk02",muonTrk02,"muonTrk02[nMuon]/F");
	t->Branch("muonTrk03",muonTrk03,"muonTrk03[nMuon]/F");
	t->Branch("muonTrk04",muonTrk04,"muonTrk04[nMuon]/F");
	t->Branch("muonSign",muonSign,"muonSign[nMuon]/F");
	
	t->Branch("nTau",&nTau,"nTau/I");
	t->Branch("tauPt",tauPt,"tauPt[nTau]/F");
	t->Branch("tauEta",tauEta,"tauEta[nTau]/F");
	t->Branch("tauPhi",tauPhi,"tauPhi[nTau]/F");
	t->Branch("tauQ",tauQ,"tauQ[nTau]/I");
	t->Branch("tauTag",tauTag,"tauTag[nTau]/I");
	t->Branch("tauCal02",tauCal02,"tauCal02[nTau]/F");
	t->Branch("tauCal03",tauCal03,"tauCal03[nTau]/F");
	t->Branch("tauCal04",tauCal04,"tauCal04[nTau]/F");
	t->Branch("tauTrk02",tauTrk02,"tauTrk02[nTau]/F");
	t->Branch("tauTrk03",tauTrk03,"tauTrk03[nTau]/F");
	t->Branch("tauTrk04",tauTrk04,"tauTrk04[nTau]/F");
	t->Branch("tauSign",tauSign,"tauSign[nTau]/F");
	
	t->Branch("nJet",&nJet,"nJet/I");
	t->Branch("jetPt",jetPt,"jetPt[nJet]/F");
	t->Branch("jetEta",jetEta,"jetEta[nJet]/F");
	t->Branch("jetPhi",jetPhi,"jetPhi[nJet]/F");
	t->Branch("jetQ",jetQ,"jetQ[nJet]/I");
	t->Branch("jetTag",jetTag,"jetTag[nJet]/I");
	t->Branch("jetCal02",jetCal02,"jetCal02[nJet]/F");
	t->Branch("jetCal03",jetCal03,"jetCal03[nJet]/F");
	t->Branch("jetCal04",jetCal04,"jetCal04[nJet]/F");
	t->Branch("jetTrk02",jetTrk02,"jetTrk02[nJet]/F");
	t->Branch("jetTrk03",jetTrk03,"jetTrk03[nJet]/F");
	t->Branch("jetTrk04",jetTrk04,"jetTrk04[nJet]/F");
	
	t->Branch("metPt",&metPt,"metPt/F");
	t->Branch("metEta",&metEta,"metEta/F");
	t->Branch("metPhi",&metPhi,"metPhi/F");
	
	t->Branch("sf_mu_reco_eff",sf_mu_reco_eff,"sf_mu_reco_eff[nMuon]/F");	// my branches
	t->Branch("sf_el_reco_eff",sf_el_reco_eff,"sf_el_reco_eff[nElectron]/F");
	
	// This next part is taken from looper.
	
	TChain* chain = new TChain("t");
	chain->Add("../run/"+infile+"/t");
	TTree* tree = chain;
	
	SimData* data = new SimData(tree);

    if(data->fChain == 0) {
		cout << " fchain is empty" << endl;
	}
    Int_t nentries = Int_t(data->fChain->GetEntries());
    cout << " Reading data ..." << nentries << " in physics tree" << endl;

    Int_t nTen = nentries/10;
    Int_t nbytes = 0, nb = 0;


    for (Int_t jentry=0; jentry<nentries; jentry++) {

		Int_t ientry = data->LoadTree(jentry);
		if (ientry < 0) break;
		
		nb = data->fChain->GetEntry(jentry);
		nbytes += nb;
		
		if (nTen!=0) if (jentry%nTen==0) cout << " " << 10*(jentry/nTen) << "%-" <<flush;

//		printf("evt %d: nPhoton %d, nElectron %d, nMuon %d, nTau %d, nJet %d \n",
//		data->evt,data->nPhoton,data->nElectron,data->nMuon,data->nTau,data->nJet);

		evt = data->evt;

		nPhoton = data->nPhoton;
		nElectron = data->nElectron;
		nMuon = data->nMuon;
		nTau = data->nTau;
		nJet = data->nJet;

		for (int i = 0; i < kMaxTrack; i++) {

			photonPt[i] = data->photonPt[i];
			photonEta[i] = data->photonEta[i];
			photonPhi[i] = data->photonPhi[i];
			
			electronPt[i] = data->electronPt[i];
			electronEta[i] = data->electronEta[i];
			electronPhi[i] = data->electronPhi[i];
			electronQ[i] = data->electronQ[i];
//			electronTag[i] = data->electronTag[i];
//			electronCal02[i] = data->electronCal02[i];
//			electronCal03[i] = data->electronCal03[i];
//			electronCal04[i] = data->electronCal04[i];
//			electronTrk02[i] = data->electronTrk02[i];
//			electronTrk03[i] = data->electronTrk03[i];
//			electronTrk04[i] = data->electronTrk04[i];
//			electronSign[i] = data->electronSign[i];
			
			muonPt[i] = data->muonPt[i];
			muonEta[i] = data->muonEta[i];
			muonPhi[i] = data->muonPhi[i];
			muonQ[i] = data->muonQ[i];
//			muonTag[i] = data->muonTag[i];
//			muonCal02[i] = data->muonCal02[i];
//			muonCal03[i] = data->muonCal03[i];
//			muonCal04[i] = data->muonCal04[i];
//			muonTrk02[i] = data->muonTrk02[i];
//			muonTrk03[i] = data->muonTrk03[i];
//			muonTrk04[i] = data->muonTrk04[i];
//			muonSign[i] = data->muonSign[i];

			tauPt[i] = data->tauPt[i];
			tauEta[i] = data->tauEta[i];
			tauPhi[i] = data->tauPhi[i];
			tauQ[i] = data->tauQ[i];
//			tauTag[i] = data->tauTag[i];
//			tauCal02[i] = data->tauCal02[i];
//			tauCal03[i] = data->tauCal03[i];
//			tauCal04[i] = data->tauCal04[i];
//			tauTrk02[i] = data->tauTrk02[i];
//			tauTrk03[i] = data->tauTrk03[i];
//			tauTrk04[i] = data->tauTrk04[i];
//			tauSign[i] = data->tauSign[i];
			
			jetPt[i] = data->jetPt[i];
			jetEta[i] = data->jetEta[i];
			jetPhi[i] = data->jetPhi[i];
			jetQ[i] = data->jetQ[i];
//			jetTag[i] = data->jetTag[i];
//			jetCal02[i] = data->jetCal02[i];
//			jetCal03[i] = data->jetCal03[i];
//			jetCal04[i] = data->jetCal04[i];
//			jetTrk02[i] = data->jetTrk02[i];
//			jetTrk03[i] = data->jetTrk03[i];
//			jetTrk04[i] = data->jetTrk04[i];

		}

		metPt = data->metPt;
		metEta = data->metEta;
		metPhi = data->metPhi;

		// smearing and efficiency for electrons
//		for (int i = 0; i < nElectron; i++) {
//
//			float mean = data->electronPt[i];
//			float sd = DeviationForParameter("electronPt",mean);
//			// Box-Muller method:
//			electronPt[i] = mean + sd * sqrt(-2*log(float(rand())/RAND_MAX))*cos(2*M_PI*float(rand())/RAND_MAX);
//
//			sf_el_reco_eff[i] = EfficiencyForParticle("electron", electronPt[i], electronEta[i], electronPhi[i]);
//		}

		// smearing and efficiency for muons
//		for (int i = 0; i < nMuon; i++) {
//
//			float mean = data->muonPt[i];
//			float sd = DeviationForParameter("muonPt",mean);
//			muonPt[i] = mean + sd * sqrt(-2*log(float(rand())/RAND_MAX))*cos(2*M_PI*float(rand())/RAND_MAX);
//
//			sf_mu_reco_eff[i] = EfficiencyForParticle("muon", muonPt[i], muonEta[i], muonPhi[i]);
//		}

		// effective smearing for met.
		// I say effective because the met is calculated from the particles, but we "delete" some of them...
		float mean = data->metPt;
		float sd = DeviationForParameter("metPt",mean);
//		TRandom r; r.SetSeed(12);
		metPt = RAND.Gaus(mean,sd);
		if (metPt<0){metPt=0;}

				//sqrt(-2*log(float(rand())/RAND_MAX))*cos(2*M_PI*float(rand())/RAND_MAX);

		t->Fill();

	}

	f.cd();
	t->Write("",TObject::kOverwrite);
	
	
	delete data;
}
Exemplo n.º 24
0
int main(int argc, char *argv[])
{
  char appName[] = "root2pileup";
  stringstream message;
  TChain *inputChain = 0;
  ExRootTreeReader *treeReader = 0;
  TClonesArray *branchParticle = 0;
  TIterator *itParticle = 0;
  GenParticle *particle = 0;
  DelphesPileUpWriter *writer = 0;
  Long64_t entry, allEntries;
  Int_t i;

  if(argc < 3)
  {
    cout << " Usage: " << appName << " output_file" << " input_file(s)" << endl;
    cout << " output_file - output binary pile-up file," << endl;
    cout << " input_file(s) - input file(s) in ROOT format." << endl;
    return 1;
  }

  signal(SIGINT, SignalHandler);

  gROOT->SetBatch();

  int appargc = 1;
  char *appargv[] = {appName};
  TApplication app(appName, &appargc, appargv);

  try
  {
    inputChain = new TChain("Delphes");
    for(i = 2; i < argc && !interrupted; ++i)
    {
      inputChain->Add(argv[i]);
    }

    treeReader = new ExRootTreeReader(inputChain);
    branchParticle = treeReader->UseBranch("Particle");
    itParticle = branchParticle->MakeIterator();

    writer = new DelphesPileUpWriter(argv[1]);

    allEntries = treeReader->GetEntries();
    cout << "** Input file(s) contain(s) " << allEntries << " events" << endl;

    if(allEntries > 0)
    {
      ExRootProgressBar progressBar(allEntries - 1);
      // Loop over all events in the input file
      for(entry = 0; entry < allEntries && !interrupted; ++entry)
      {
        if(!treeReader->ReadEntry(entry))
        {
          cerr << "** ERROR: cannot read event " << entry << endl;
          break;
        }

        itParticle->Reset();
        while((particle = static_cast<GenParticle*>(itParticle->Next())))
        {
          writer->WriteParticle(particle->PID,
            particle->X, particle->Y, particle->Z, particle->T,
            particle->Px, particle->Py, particle->Pz, particle->E);
        }
        
        writer->WriteEntry();

        progressBar.Update(entry);
      }
      progressBar.Finish();

      writer->WriteIndex();
    }

    cout << "** Exiting..." << endl;

    delete writer;
    delete itParticle;
    delete treeReader;
    delete inputChain;
    return 0;
  }
  catch(runtime_error &e)
  {
    if(writer) delete writer;
    if(itParticle) delete itParticle;
    if(treeReader) delete treeReader;
    if(inputChain) delete inputChain;
    cerr << "** ERROR: " << e.what() << endl;
    return 1;
  }
}
Exemplo n.º 25
0
void TMVARegression( TString myMethodList = "" ) 
{
   // The explicit loading of the shared libTMVA is done in TMVAlogon.C, defined in .rootrc
   // if you use your private .rootrc, or run from a different directory, please copy the 
   // corresponding lines from .rootrc

   // methods to be processed can be given as an argument; use format:
   //
   // mylinux~> root -l TMVARegression.C\(\"myMethod1,myMethod2,myMethod3\"\)
   //

   // this loads the library
   TMVA::Tools::Instance();

   //---------------------------------------------------------------
   // default MVA methods to be trained + tested
   std::map<std::string,int> Use;

   Use["PDERS"]           = 0;
   Use["PDERSkNN"]        = 0; // depreciated until further notice
   Use["PDEFoam"]         = 0; // preparation for new TMVA version "reader". This method is not available in this version of TMVA
   // ---
   Use["KNN"]             = 0;
   // ---
   Use["LD"]		  = 0;
   // ---
   Use["FDA_GA"]          = 0;
   Use["FDA_MC"]          = 0;
   Use["FDA_MT"]          = 0;
   Use["FDA_GAMT"]        = 0;
   // ---
   Use["MLP"]             = 0; 
   // ---
   Use["SVM"]             = 0;
   // ---
   Use["BDT"]             = 0;
   Use["BDTG"]            = 1;
   // ---------------------------------------------------------------

   std::cout << std::endl;
   std::cout << "==> Start TMVARegression" << std::endl;

   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 a new root output file
   TString outfileName( "TMVAReg_TarggetAPDPN.root" );
   TFile* outputFile = TFile::Open( outfileName, "RECREATE" );

   // Create the factory object. Later you can choose the methods
   // whose performance you'd like to investigate. The factory will
   // then run the performance analysis for you.
   //
   // The first argument is the base of the name of all the
   // weightfiles in the directory weight/ 
   //
   // The second argument is the output file for the training results
   // All TMVA output can be suppressed by removing the "!" (not) in 
   // front of the "Silent" argument in the option string
   TMVA::Factory *factory = new TMVA::Factory( "TMVARegression", outputFile, 
                                               "!V:!Silent:Color:DrawProgressBar" );

   // If you wish to modify default settings 
   // (please check "src/Config.h" to see all available global options)
   //    (TMVA::gConfig().GetVariablePlotting()).fTimesRMS = 8.0;
   //    (TMVA::gConfig().GetIONames()).fWeightFileDir = "myWeightDirectory";

   // Define the input variables that shall be used for the MVA training
   // note that you may also use variable expressions, such as: "3*var1/var2*abs(var3)"
   // [all types of expressions that can also be parsed by TTree::Draw( "expression" )]
//    factory->AddVariable( "laser.qmax", "Qmax", "ADC", 'D' );
//    factory->AddVariable( "laser.tmax", "T_{0}", "ns", 'D' );
//    factory->AddVariable( "laser.fwhm", "FWHM","ns", 'D');
//    factory->AddVariable( "laser.prepulse","Prepulse indicator","A.U.", 'D' );
//    factory->AddVariable( "laser.w10","Width at 10%","ns", 'D' );

   factory->AddVariable( "qmax[0]", "Qmax", "ADC", 'D' );
   factory->AddVariable( "tmax[0]", "T_{0}", "ns", 'D' );
   factory->AddVariable( "l_fwhm[0]", "FWHM","ns", 'D');
   factory->AddVariable( "l_prepulse[0]","Prepulse indicator","A.U.", 'D' );
   factory->AddVariable( "l_width90[0]","Width at 10%","ns", 'D' );

   // You can add so-called "Spectator variables", which are not used in the MVA training, 
   // but will appear in the final "TestTree" produced by TMVA. This TestTree will contain the 
   // input variables, the response values of all trained MVAs, and the spectator variables
   //   factory->AddSpectator( "spec1:=var1*2",  "Spectator 1", "units", 'F' );
   //   factory->AddSpectator( "spec2:=timeStamp",  "Spectator 1", "units", 'F' );

   // Add the variable carrying the regression target
   factory->AddTarget  ( "apdpnAB[0]" ); 

   // It is also possible to declare additional targets for multi-dimensional regression, ie:
   // -- factory->AddTarget( "fvalue2" );
   // BUT: this is currently ONLY implemented for MLP

   // read training and test data (see TMVAClassification for reading ASCII files)
   // load the signal and background event samples from ROOT trees
//    TFile *input(0);
//    TString fname = "./stabTreeFed630.root";
//    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 << "--- TMVARegression           : Using input file: " << input->GetName() << std::endl;


   TChain * ntu = new TChain("x");
   ntu->Add("/data2/EcalLaserMonitoringData/ntuples_2011_158851_178888/ntu_data_0015*.root");
   ntu->Add("/data2/EcalLaserMonitoringData/ntuples_2011_158851_178888/ntu_data_0016*.root");

   //TTree *regTree = (TTree*)input->Get("ntu");

   // global event weights per tree (see below for setting event-wise weights)
   Double_t regWeight  = 1.0;   

   // ====== register trees ====================================================
   //
   // the following method is the prefered one:
   // you can add an arbitrary number of regression trees
   //factory->AddRegressionTree( regTree, regWeight );
   factory->AddRegressionTree( ntu, regWeight );

   // Alternative call:
   // -- factory->AddRegressionTree( regTree, regWeight );
   
   // This would set individual event weights (the variables defined in the 
   // expression need to exist in the original TTree)
   //   factory->SetWeightExpression( "fwhm-26", "Regression" );

   // Apply additional cuts on the signal and background samples (can be different)
   //   TCut mycut = "abs(0.5*(apd0+apd1)-1)<0.015 && timeStamp<1299.8e6"; // for example: TCut mycut = "abs(var1)<0.5 && abs(var2-0.5)<1";
   cout << "Defining cuts..." << endl;
   TCut mycut = "fed[0] == 605 && harness == 6 && field > 0.1 && run < 161200 && apdpnAB[0] > 0"; 

   // Count selected events and use them all
   TCanvas cdummy("cdummy","cdummy"); cdummy.cd(); 
   Int_t selectedEvts = ntu->Draw("l_fwhm[0]",mycut,"N");
   cdummy.Delete(); 
   cout << selectedEvts << endl;
   char trainPara[132];
   sprintf(trainPara,"nTrain_Regression=%d:nTest_Regression=0:SplitMode=Random:NormMode=NumEvents:!V",selectedEvts-10);

   // tell the factory to use all remaining events in the trees after training for testing:
   factory->PrepareTrainingAndTestTree( mycut, trainPara ); 

   // If no numbers of events are given, half of the events in the tree are used for training, and 
   // the other half for testing:
   //   factory->PrepareTrainingAndTestTree( mycut, "SplitMode=random:!V" );  
   // To also specify the number of testing events, use:
   //    factory->PrepareTrainingAndTestTree( mycut, 
   //                                         "NSigTrain=3000:NBkgTrain=3000:NSigTest=3000:NBkgTest=3000:SplitMode=Random:!V" );  

   // ---- Book MVA methods
   //
   // please lookup the various method configuration options in the corresponding cxx files, eg:
   // src/MethoCuts.cxx, etc, or here: http://tmva.sourceforge.net/optionRef.html
   // it is possible to preset ranges in the option string in which the cut optimisation should be done:
   // "...:CutRangeMin[2]=-1:CutRangeMax[2]=1"...", where [2] is the third input variable

   cout << "Booking MVA methods" << endl;

   // PDE - RS method
   if (Use["PDERS"])
      factory->BookMethod( TMVA::Types::kPDERS, "PDERS", 
                           "!H:!V:NormTree=T:VolumeRangeMode=Adaptive:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=40:NEventsMax=60:VarTransform=None" );
   // And the options strings for the MinMax and RMS methods, respectively:
   //      "!H:!V:VolumeRangeMode=MinMax:DeltaFrac=0.2:KernelEstimator=Gauss:GaussSigma=0.3" );   
   //      "!H:!V:VolumeRangeMode=RMS:DeltaFrac=3:KernelEstimator=Gauss:GaussSigma=0.3" );   

   if (Use["PDERSkNN"]) // depreciated until further notice
      factory->BookMethod( TMVA::Types::kPDERS, "PDERSkNN", 
                           "!H:!V:VolumeRangeMode=kNN:KernelEstimator=Gauss:GaussSigma=0.3:NEventsMin=400:NEventsMax=600" );

   if (Use["PDEFoam"])
       factory->BookMethod( TMVA::Types::kPDEFoam, "PDEFoam", 
			    "!H:!V:MultiTargetRegression=F:TargetSelection=Mpv:TailCut=0.001:VolFrac=0.0333:nActiveCells=500:nSampl=2000:nBin=5:Compress=T:Kernel=None:CutNmin=T:Nmin=10:VarTransform=None" );


   // K-Nearest Neighbour classifier (KNN)
   if (Use["KNN"])
      factory->BookMethod( TMVA::Types::kKNN, "KNN", 
                           "nkNN=20:ScaleFrac=0.8:SigmaFact=1.0:Kernel=Gaus:UseKernel=F:UseWeight=T:!Trim" );

   // Linear discriminant
   if (Use["LD"])
      factory->BookMethod( TMVA::Types::kLD, "LD", 
                           "!H:!V:VarTransform=N" );

	// Function discrimination analysis (FDA) -- test of various fitters - the recommended one is Minuit (or GA or SA)
   if (Use["FDA_MC"]) 
      factory->BookMethod( TMVA::Types::kFDA, "FDA_MC",
                          "!H:!V:Formula=(0)+(1)*x0+(2)*x1:ParRanges=(-100,100);(-100,100);(-100,100):FitMethod=MC:SampleSize=100000:Sigma=0.1:VarTransform=D" );
   
   if (Use["FDA_GA"]) // can also use Simulated Annealing (SA) algorithm (see Cuts_SA options) .. the formula of this example is good for parabolas
      factory->BookMethod( TMVA::Types::kFDA, "FDA_GA",
                           "!H:!V:Formula=(0)+(1)*x0+(2)*x1:ParRanges=(-100,100);(-100,100);(-100,100):FitMethod=GA:PopSize=100:Cycles=3:Steps=30:Trim=True:SaveBestGen=1:VarTransform=Norm" );

   if (Use["FDA_MT"]) 
      factory->BookMethod( TMVA::Types::kFDA, "FDA_MT",
                           "!H:!V:Formula=(0)+(1)*x0+(2)*x1:ParRanges=(-100,100);(-100,100);(-100,100);(-10,10):FitMethod=MINUIT:ErrorLevel=1:PrintLevel=-1:FitStrategy=2:UseImprove:UseMinos:SetBatch" );

   if (Use["FDA_GAMT"]) 
      factory->BookMethod( TMVA::Types::kFDA, "FDA_GAMT",
                           "!H:!V:Formula=(0)+(1)*x0+(2)*x1:ParRanges=(-100,100);(-100,100);(-100,100):FitMethod=GA:Converger=MINUIT:ErrorLevel=1:PrintLevel=-1:FitStrategy=0:!UseImprove:!UseMinos:SetBatch:Cycles=1:PopSize=5:Steps=5:Trim" );

   // Neural network (MLP)
   if (Use["MLP"])
      factory->BookMethod( TMVA::Types::kMLP, "MLP", "!H:!V:VarTransform=Norm:NeuronType=tanh:NCycles=5000:HiddenLayers=N+5,N+2:TestRate=6:TrainingMethod=BP:Sampling=0.3:SamplingEpoch=0.8:ConvergenceImprove=1e-6:ConvergenceTests=15" );

   // Support Vector Machine
   if (Use["SVM"])
      factory->BookMethod( TMVA::Types::kSVM, "SVM", "Gamma=0.25:Tol=0.001:VarTransform=Norm" );

   // Boosted Decision Trees
   if (Use["BDT"])
     factory->BookMethod( TMVA::Types::kBDT, "BDT",
                           "!H:!V:NTrees=100:nEventsMin=5:BoostType=AdaBoostR2:SeparationType=RegressionVariance:nCuts=20:PruneMethod=CostComplexity:PruneStrength=30" );

   if (Use["BDTG"])
     factory->BookMethod( TMVA::Types::kBDT, "BDTG",
                           "!H:!V:NTrees=200::BoostType=Grad:Shrinkage=1.0:UseBaggedGrad:SeparationType=GiniIndex:nCuts=20:NNodesMax=5" );
   // --------------------------------------------------------------------------------------------------

   // ---- Now you can tell the factory to train, test, and evaluate the MVAs

   // Train MVAs using the set of training events
   factory->TrainAllMethods();

   // ---- Evaluate all MVAs using the set of test events
   factory->TestAllMethods();

   // ----- Evaluate and compare performance of all configured MVAs
   factory->EvaluateAllMethods();    

   // --------------------------------------------------------------
   
   // Save the output
   outputFile->Close();

   std::cout << "==> Wrote root file: " << outputFile->GetName() << std::endl;
   std::cout << "==> TMVARegression is done!" << std::endl;      

   delete factory;

   // Launch the GUI for the root macros
   //if (!gROOT->IsBatch()) TMVARegGui( outfileName );
}
Exemplo n.º 26
0
void runTask(Float_t etamax=0.5,const char * incollection = 0, const char * outfile = "dndeta.root", Bool_t skipNorm = kFALSE)
{
  // for running with root only
  gSystem->Load("libTree");
  gSystem->Load("libGeom");
  gSystem->Load("libVMC");
  gSystem->Load("libSTEERBase");
  gSystem->Load("libESD");
  gSystem->Load("libAOD");

  // load analysis framework
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice");


  TChain * chain = new TChain ("TE");
  if (incollection == 0) {
    chain->Add("galice.root");
  }
  else if (TString(incollection).Contains("xml")){
    TGrid::Connect("alien://");
    TAlienCollection * coll = TAlienCollection::Open (incollection);
    while(coll->Next()){
      chain->Add(TString("alien://")+coll->GetLFN());
    }
  } else {
    ifstream file_collect(incollection);
    TString line;
    while (line.ReadLine(file_collect) ) {
      chain->Add(line.Data());
    }
  }
  chain->GetListOfFiles()->Print();

  // for includes use either global setting in $HOME/.rootrc
  // ACLiC.IncludePaths: -I$(ALICE_ROOT)/include
  // or in each macro
  gSystem->AddIncludePath("-I$ALICE_ROOT/include");

  // Create the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("dNdeta");

  AliVEventHandler* esdH = new AliESDInputHandler;
  ((AliESDInputHandler*)esdH)->SetReadFriends(kFALSE);
  mgr->SetInputEventHandler(esdH);

  // Create tasks
  gROOT->LoadMacro("AliAnalysisTaskdNdetaMC.cxx++g");

  AliAnalysisTask *task1 = new AliAnalysisTaskdNdetaMC("TaskdNdeta");
  ((AliAnalysisTaskdNdetaMC*)task1)->SetEtaMax(etamax);
  if (skipNorm) ((AliAnalysisTaskdNdetaMC*)task1)->SkipNormalization();
  // Enable MC event handler

  AliMCEventHandler* handler = new AliMCEventHandler;
  handler->SetReadTR(kFALSE);
  mgr->SetMCtruthEventHandler(handler);

  // Add tasks
  mgr->AddTask(task1);

  // Create containers for input/output
  AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("coutput", TList::Class(),    AliAnalysisManager::kOutputContainer, outfile);

  // Connect input/output
  mgr->ConnectInput(task1, 0, cinput);
  mgr->ConnectOutput(task1, 1, coutput1);

  // Enable debug printouts
  mgr->SetDebugLevel(0);

  if (!mgr->InitAnalysis()) return;

  mgr->PrintStatus();

  mgr->StartAnalysis("local", chain);
}
Exemplo n.º 27
0
int main (int argc, char** argv)
{

  if (argc < 3) {
    printHelp() ;
    exit (1) ;
  }

  std::string inputfiles, inputdir ;
  std::string outputRootName = "histoTPG.root" ;
  int verbose = 0 ;
  int occupancyCut = 0 ;
  std::string l1algo ; 

  bool ok(false) ;
  for (int i=0 ; i<argc ; i++) {
    if (argv[i] == std::string("-h") ) {
      printHelp() ;
      exit(1);
    }
    if (argv[i] == std::string("-i") && argc>i+1) {
      ok = true ;
      inputfiles = argv[i+1] ;
    }
    if (argv[i] == std::string("-d") && argc>i+1) inputdir = argv[i+1] ;
    if (argv[i] == std::string("-o") && argc>i+1) outputRootName = argv[i+1] ;
    if (argv[i] == std::string("-v") && argc>i+1) verbose = atoi(argv[i+1]) ;
    if (argv[i] == std::string("-l1") && argc>i+1) l1algo =  std::string(argv[i+1]) ;
    if (argv[i] == std::string("--cutTPOccup") && argc>i+1) occupancyCut = atoi(argv[i+1]) ;
  }
  if (!ok) {
    std::cout<<"No input files have been given: nothing to do!"<<std::endl ;
    printHelp() ;
    exit(1);
  }
  
  std::vector<int> algobits ;
  std::vector<std::string> algos = split(l1algo,",") ;
  for (unsigned int i=0 ; i<algos.size() ; i++) algobits.push_back(atoi(algos[i].c_str())) ;


  unsigned int ref = 2 ;



  ///////////////////////
  // book the histograms
  ///////////////////////

  TH2F * occupancyTP = new TH2F("occupancyTP", "Occupancy TP data", 72, 1, 73, 38, -19, 19) ;
  occupancyTP->GetYaxis()->SetTitle("eta index") ;
  occupancyTP->GetXaxis()->SetTitle("phi index") ;
  TH2F * occupancyTPEmul = new TH2F("occupancyTPEmul", "Occupancy TP emulator", 72, 1, 73, 38, -19, 19) ;
  occupancyTPEmul->GetYaxis()->SetTitle("eta index") ;
  occupancyTPEmul->GetXaxis()->SetTitle("phi index") ;

  TH1F * TP = new TH1F("TP", "TP", 256, 0., 256.) ;
  TP->GetXaxis()->SetTitle("TP (ADC)") ;
  TH1F * TPEmul = new TH1F("TPEmul", "TP Emulator", 256, 0., 256.) ;
  TPEmul->GetXaxis()->SetTitle("TP (ADC)") ;
  TH1F * TPEmulMax = new TH1F("TPEmulMax", "TP Emulator max", 256, 0., 256.) ;
  TPEmulMax->GetXaxis()->SetTitle("TP (ADC)") ;
  TH3F * TPspectrumMap3D = new TH3F("TPspectrumMap3D", "TP data spectrum map", 72, 1, 73, 38, -19, 19, 256, 0., 256.) ;
  TPspectrumMap3D->GetYaxis()->SetTitle("eta index") ;
  TPspectrumMap3D->GetXaxis()->SetTitle("phi index") ;

  TH1F * TPMatchEmul = new TH1F("TPMatchEmul", "TP data matching Emulator", 7, -1., 6.) ;
  TH1F * TPEmulMaxIndex = new TH1F("TPEmulMaxIndex", "Index of the max TP from Emulator", 7, -1., 6.) ;
  TH3I * TPMatchEmul3D = new TH3I("TPMatchEmul3D", "TP data matching Emulator", 72, 1, 73, 38, -19, 19, 7, -1, 6) ;
  TPMatchEmul3D->GetYaxis()->SetTitle("eta index") ;
  TPMatchEmul3D->GetXaxis()->SetTitle("phi index") ;

  TH2I * ttfMismatch = new TH2I("ttfMismatch", "TTF mismatch map",  72, 1, 73, 38, -19, 19) ;
  ttfMismatch->GetYaxis()->SetTitle("eta index") ;
  ttfMismatch->GetXaxis()->SetTitle("phi index") ;

  ///////////////////////
  // Chain the trees:
  ///////////////////////

  TChain * chain = new TChain ("EcalTPGAnalysis") ;
  std::vector<std::string> files ;
  if (inputfiles.find(std::string(",")) != std::string::npos) files = split(inputfiles,",") ;
  if (inputfiles.find(std::string(":")) != std::string::npos) {
    std::vector<std::string> filesbase = split(inputfiles,":") ;
    if (filesbase.size() == 4) {
      int first = atoi(filesbase[1].c_str()) ;
      int last = atoi(filesbase[2].c_str()) ;
      for (int i=first ; i<=last ; i++) {
	std::stringstream name ;
	name<<filesbase[0]<<i<<filesbase[3] ;
	files.push_back(name.str()) ;
      }
    }
  }
  for (unsigned int i=0 ; i<files.size() ; i++) {
    files[i] = inputdir+"/"+files[i] ;
    std::cout<<"Input file: "<<files[i]<<std::endl ;
    chain->Add (files[i].c_str()) ;
  }

  EcalTPGVariables treeVars ;
  setBranchAddresses (chain, treeVars) ;

  int nEntries = chain->GetEntries () ;
  std::cout << "Number of entries: " << nEntries <<std::endl ;    



  ///////////////////////
  // Main loop over entries
  ///////////////////////

  for (int entry = 0 ; entry < nEntries ; ++entry) {
    chain->GetEntry (entry) ;
    if (entry%1000==0) std::cout <<"------> "<< entry+1 <<" entries processed" << " <------\n" ; 
    if (verbose>0) std::cout<<"Run="<<treeVars.runNb<<" Evt="<<treeVars.runNb<<std::endl ;

    // trigger selection if any
    bool keep(false) ;
    if (!algobits.size()) keep = true ; // keep all events when no trigger selection
    for (unsigned int algo = 0 ; algo<algobits.size() ; algo++)
      for (unsigned int ntrig = 0 ; ntrig < treeVars.nbOfActiveTriggers ; ntrig++)
	if (algobits[algo] == treeVars.activeTriggers[ntrig]) keep = true ;
    if (!keep) continue ;
    
             
    // loop on towers
    for (unsigned int tower = 0 ; tower < treeVars.nbOfTowers ; tower++) {

      int tp = getEt(treeVars.rawTPData[tower]) ;
      int emul[5] = {getEt(treeVars.rawTPEmul1[tower]),  
		     getEt(treeVars.rawTPEmul2[tower]),
		     getEt(treeVars.rawTPEmul3[tower]),
		     getEt(treeVars.rawTPEmul4[tower]),
		     getEt(treeVars.rawTPEmul5[tower])} ;
      int maxOfTPEmul = 0 ;
      int indexOfTPEmulMax = -1 ;
      for (int i=0 ; i<5 ; i++) if (emul[i]>maxOfTPEmul) {
	maxOfTPEmul = emul[i] ; 
	indexOfTPEmulMax = i ;
      }
      int ieta = treeVars.ieta[tower] ;
      int iphi = treeVars.iphi[tower] ;
      int nbXtals = treeVars.nbOfXtals[tower] ;
      int ttf = getTtf(treeVars.rawTPData[tower]) ;


      if (verbose>9 && (tp>0 || maxOfTPEmul>0)) {
	std::cout<<"(phi,eta, Nbxtals)="<<std::dec<<iphi<<" "<<ieta<<" "<<nbXtals<<std::endl ;
	std::cout<<"Data Et, TTF: "<<tp<<" "<<ttf<<std::endl ;
	std::cout<<"Emulator: " ;
	for (int i=0 ; i<5 ; i++) std::cout<<emul[i]<<" " ;
	std::cout<<std::endl ;
      }


      // Fill TP spctrum
      TP->Fill(tp) ;
      TPEmul->Fill(emul[ref]) ;
      TPEmulMax->Fill(maxOfTPEmul) ;
      TPspectrumMap3D->Fill(iphi, ieta, tp) ;


      // Fill TP occupancy
      if (tp>occupancyCut) occupancyTP->Fill(iphi, ieta) ;
      if (emul[ref]>occupancyCut) occupancyTPEmul->Fill(iphi, ieta) ;


      // Fill TP-Emulator matching
      // comparison is meaningful when:
      if (tp>0 && nbXtals == 25) {
	bool match(false) ;
	for (int i=0 ; i<5 ; i++) {
	  if (tp == emul[i]) {
	    TPMatchEmul->Fill(i+1) ;
	    TPMatchEmul3D->Fill(iphi, ieta, i+1) ;
	    match = true ;
	  }
	}
	if (!match) {
	  TPMatchEmul->Fill(-1) ;
	  TPMatchEmul3D->Fill(iphi, ieta, -1) ;
	  if (verbose>5) {
	    std::cout<<"MISMATCH"<<std::endl ;
	    std::cout<<"(phi,eta, Nbxtals)="<<std::dec<<iphi<<" "<<ieta<<" "<<nbXtals<<std::endl ;
	    std::cout<<"Data Et, TTF: "<<tp<<" "<<ttf<<std::endl ;
	    std::cout<<"Emulator: " ;
	    for (int i=0 ; i<5 ; i++) std::cout<<emul[i]<<" " ;
	    std::cout<<std::endl ;
	  }
	}
      }
      if (maxOfTPEmul>0) TPEmulMaxIndex->Fill(indexOfTPEmulMax+1) ;


      // Fill TTF mismatch
      if ((ttf==1 || ttf==3) && nbXtals != 25) ttfMismatch->Fill(iphi, ieta) ;


    } // end loop towers


  } // endloop entries

  

  ///////////////////////
  // Format & write histos
  ///////////////////////


  // 1. TP Spectrum  
  TProfile2D * TPspectrumMap = TPspectrumMap3D->Project3DProfile("yx") ;
  TPspectrumMap->SetName("TPspectrumMap") ;

  // 2. TP Timing
  TH2F * TPMatchEmul2D = new TH2F("TPMatchEmul2D", "TP data matching Emulator", 72, 1, 73, 38, -19, 19) ;
  TH2F * TPMatchFraction2D = new TH2F("TPMatchFraction2D", "TP data: fraction of non-single timing", 72, 1, 73, 38, -19, 19) ;
  TPMatchEmul2D->GetYaxis()->SetTitle("eta index") ; 
  TPMatchEmul2D->GetXaxis()->SetTitle("phi index") ;
  TPMatchEmul2D->GetZaxis()->SetRangeUser(-1,6) ;
  TPMatchFraction2D->GetYaxis()->SetTitle("eta index") ; 
  TPMatchFraction2D->GetXaxis()->SetTitle("phi index") ;
  for (int binx=1 ; binx<=72 ; binx++)    
    for (int biny=1 ; biny<=38 ; biny++) {
      int maxBinz = 5 ;
      double maxCell = TPMatchEmul3D->GetBinContent(binx, biny, maxBinz) ;
      double totalCell(0) ;
      for (int binz=1; binz<=7 ; binz++) {
	double content = TPMatchEmul3D->GetBinContent(binx, biny, binz) ;
	if (content>maxCell) {
	  maxCell = content ;
	  maxBinz = binz ;
	}
	totalCell += content ;
      }
      if (maxCell <=0) maxBinz = 2 ; // empty cell
      TPMatchEmul2D->SetBinContent(binx, biny, float(maxBinz)-2.) ; //z must be in [-1,5] 
      double fraction = 0 ;
      if (totalCell>0) fraction = 1.- maxCell/totalCell ;
      TPMatchFraction2D->SetBinContent(binx, biny, fraction) ;
      if (totalCell > maxCell && verbose>9) {
	std::cout<<"--->"<<std::endl ;	
	for (int binz=1; binz<=7 ; binz++) {	  
	  std::cout<< "(phi,eta, z): (" 
		   << TPMatchEmul3D->GetXaxis()->GetBinLowEdge(binx) 
		   << ", " << TPMatchEmul3D->GetYaxis()->GetBinLowEdge(biny) 
		   << ", " << TPMatchEmul3D->GetZaxis()->GetBinLowEdge(binz)		   
		   << ") Content="<<TPMatchEmul3D->GetBinContent(binx, biny, binz)		   
		   << ", erro="<<TPMatchEmul3D->GetBinContent(binx, biny, binz)	   
		   << std::endl ;	
	}
      }
    }



  TFile saving (outputRootName.c_str (),"recreate") ;
  saving.cd () ;
  
  occupancyTP->Write() ;
  occupancyTPEmul->Write() ;
  
  TP->Write() ;
  TPEmul->Write() ;
  TPEmulMax->Write() ;
  TPspectrumMap->Write() ;

  TPMatchEmul->Write() ; 
  TPMatchEmul3D->Write() ; 
  TPEmulMaxIndex->Write() ;
  TPMatchEmul2D->Write() ; 
  TPMatchFraction2D->Write() ; 

  ttfMismatch->Write() ; 

     
  saving.Close () ;
  delete chain ;

  return 0 ;
}
Exemplo n.º 28
0
void readTree(TString filelist="/global/project/projectdirs/star/pwg/starhf/zamiller/minBiasTemplates101015/Trees.list",TString outFile="/global/project/projectdirs/star/pwg/starhf/zamiller/minBiasTemplates101015/readTreeOutSubmitTEST.root")
{

  //TString filelist=Form("%s/%s",localDir,fileIn);
  //TString outFile=Form("%s/%s",outDir,fileOut);

  TFile fout(outFile,"RECREATE");
  TH1F::SetDefaultSumw2(); 
  TH1D::SetDefaultSumw2(); 

  for(Int_t c=0; c< numPtBins; c++)
  {
    lowpt[c] = anaConst::lpt[c];
    highpt[c] = anaConst::hpt[c];
  }
  for(Int_t ptbin = 0; ptbin < numPtBins; ptbin++)
  {
    hdEtaRawce[ptbin] = new TH1D(Form("hdEtaRawce_%i",ptbin),"hdEtaRawce",100, -5,5);
    hdEtaRawbe[ptbin] = new TH1D(Form("hdEtaRawbe_%i",ptbin),"hdEtaRawbe",100, -5,5);
    hEventTallyce[ptbin] = new TH1D(Form("ceEventTally_%i",ptbin),"ceEvent Tally",1,0,1);
    hEventTallybe[ptbin] = new TH1D(Form("beEventTally_%i",ptbin),"beEvent Tally",1,0,1);
    hEventTallybce[ptbin] = new TH1D(Form("bceEventTally_%i",ptbin),"bceEvent Tally",1,0,1);
    hdPhiRawce[ptbin] = new TH1D(Form("hdPhiRawce_%i",ptbin),"hdPhiRawce",Phibin, -10,10);
    hdPhiRawbe[ptbin] = new TH1D(Form("hdPhiRawbe_%i",ptbin),"hdPhiRawbe",Phibin, -10,10);
    hdPhiRawbce[ptbin] = new TH1D(Form("hdPhiRawbce_%i",ptbin),"hdPhiRawbce",Phibin, -10,10);
    hept[ptbin] = new TH1D(Form("hept_%i",ptbin),"hept",200,0.,20.);
  }

  // Make Chain
  TChain* chain = new TChain("tree");
  int nfile = 0;
  /*  nfile += chain->Add("Oct30_set13/pythia_tree_Oct30_13.root");
      nfile += chain->Add("Oct30_set14/pythia_tree_Oct30_14.root");
      nfile += chain->Add("Oct30_set15/pythia_tree_Oct30_15.root");
      nfile += chain->Add("Oct30_set16/pythia_tree_Oct30_16.root");
      nfile += chain->Add("Oct30_set17/pythia_tree_Oct30_17.root");
  //  nfile += chain->Add("Oct30_set12/pythia_tree_Oct30_12.root");
  //  nfile += chain->Add("Oct26_set3/pythia_tree_Oct26_3.root");
  // nfile += chain->Add("Oct18_set4/pythia_tree_Oct18_4.root");
  //nfile += chain->Add("liweiTemplate_part2.root");*/
  char filename[1000];
  ifstream fstream(filelist.Data());
  int ifile = 0;
  while (fstream >> filename)
  {
    nfile+= chain->Add(filename);
    std::cout << "Got File: " << filename << std::endl;
  }

  std::cout <<"Added "<<nfile<<" files"<<std::endl;
  std::cout<<"# entries in chain: "<<chain->GetEntries()<<std::endl;
  if (chain == 0) return;

  int ceNtrigger=0;
  int beNtrigger=0;
  int bceNtrigger=0;
  int ptbin,maxptbin;

  //define variables
  Int_t   Event, numberofcElectrons, numberofbElectrons,numberofbcElectrons, numberofHadrons, noTracks;   //
  Float_t celectron_id,celectron_status,celectron_pt,celectron_pz,celectron_phi,celectron_eta,celectron_y;                //track info
  Float_t belectron_id,belectron_status,belectron_pt,belectron_pz,belectron_phi,belectron_eta,belectron_y;
  Float_t bcelectron_id,bcelectron_status,bcelectron_pt,bcelectron_pz,bcelectron_phi,bcelectron_eta,bcelectron_y;
  Float_t assoh_id,assoh_status,assoh_pt,assoh_pz,assoh_phi,assoh_eta,assoh_y;

  int goodEvent = 0;


  Long64_t nentries = chain->GetEntriesFast();
  int x = 0; int n = nentries; int w = 25;

  for(int i = 0; i < nentries; i++){
    Long64_t ientry = chain->LoadTree(i);
    if (ientry < 0) break;
    TBranch *b_destep = chain->GetBranch("hf2eDecay");

    TLeaf* leaf_Event_id            = b_destep->GetLeaf("Event_id");
    TLeaf* leaf_refMult             = b_destep->GetLeaf("refMult");
    TLeaf* leaf_numberofcElectrons  = b_destep->GetLeaf("numberofcElectrons");
    TLeaf* leaf_numberofbElectrons  = b_destep->GetLeaf("numberofbElectrons");
    TLeaf* leaf_numberofbcElectrons = b_destep->GetLeaf("numberofbcElectrons");
    TLeaf* leaf_numberofHadrons     = b_destep->GetLeaf("numberofHadrons");
    TLeaf* leaf_noTracks            = b_destep->GetLeaf("noTracks");

    TLeaf* leaf_ce_id               = b_destep->GetLeaf("ce_id");
    TLeaf* leaf_ce_status           = b_destep->GetLeaf("ce_status");
    TLeaf* leaf_ce_pt               = b_destep->GetLeaf("ce_pt");
    TLeaf* leaf_ce_pz               = b_destep->GetLeaf("ce_pz");
    TLeaf* leaf_ce_phi              = b_destep->GetLeaf("ce_phi");
    TLeaf* leaf_ce_eta              = b_destep->GetLeaf("ce_eta");
    TLeaf* leaf_ce_y                = b_destep->GetLeaf("ce_y");

    TLeaf* leaf_be_id               = b_destep->GetLeaf("be_id");
    TLeaf* leaf_be_status           = b_destep->GetLeaf("be_status");
    TLeaf* leaf_be_pt               = b_destep->GetLeaf("be_pt");
    TLeaf* leaf_be_pz               = b_destep->GetLeaf("be_pz");
    TLeaf* leaf_be_phi              = b_destep->GetLeaf("be_phi");
    TLeaf* leaf_be_eta              = b_destep->GetLeaf("be_eta");
    TLeaf* leaf_be_y                = b_destep->GetLeaf("be_y");

    TLeaf* leaf_bce_id              = b_destep->GetLeaf("bce_id");
    TLeaf* leaf_bce_status          = b_destep->GetLeaf("bce_status");
    TLeaf* leaf_bce_pt              = b_destep->GetLeaf("bce_pt");
    TLeaf* leaf_bce_pz              = b_destep->GetLeaf("bce_pz");
    TLeaf* leaf_bce_phi             = b_destep->GetLeaf("bce_phi");
    TLeaf* leaf_bce_eta             = b_destep->GetLeaf("bce_eta");
    TLeaf* leaf_bce_y               = b_destep->GetLeaf("bce_y");

    TLeaf* leaf_hadron_id           = b_destep->GetLeaf("hadron_id");
    TLeaf* leaf_hadron_status       = b_destep->GetLeaf("hadron_status");
    TLeaf* leaf_hadron_pt           = b_destep->GetLeaf("hadron_pt");
    TLeaf* leaf_hadron_pz           = b_destep->GetLeaf("hadron_pz");
    TLeaf* leaf_hadron_phi          = b_destep->GetLeaf("hadron_phi");
    TLeaf* leaf_hadron_eta          = b_destep->GetLeaf("hadron_eta");
    TLeaf* leaf_hadron_y            = b_destep->GetLeaf("hadron_y");

    x = i+1;
    // Process Completion bar
    if ( (x != n) && (x % (n/100) == 0) )
    {
      float ratio  =  (float)x/(float)n;
      int   c      =  ratio * w;

      if(ratio < 1){
        std::cout << (int)(ratio*100) << "% [";
        for (int x=0; x<c; x++) std::cout << "=";
        for (int x=c; x<w; x++) std::cout << " ";
        std::cout << "]\r" << std::flush ;
      }
    }


    // if(i%10000 == 0)
    //   std::cout <<"Entry: "<< i << std::endl;
    chain->GetEntry(i);

    Event   = (int)leaf_Event_id->GetValue(0);
    numberofcElectrons = (int)leaf_numberofcElectrons->GetValue(0);
    // std::cout << numberofcElectrons << " ";
    numberofbElectrons = (int)leaf_numberofbElectrons->GetValue(0);
    numberofbcElectrons = (int)leaf_numberofbcElectrons->GetValue(0);
    numberofHadrons = (int)leaf_numberofHadrons->GetValue(0);
    // std::cout << "numHad: " << numberofHadrons << std::endl;
    noTracks        = leaf_noTracks->GetValue(0);
    hrefmult -> Fill(noTracks);

    //loop through matched primary tracks electron find c decayed electron
    int ceNtrigcount=0;
    maxptbin = 0;
    for(int trki = 0; trki < numberofcElectrons; trki++){
      celectron_id      = (int)leaf_ce_id->GetValue(trki);
      celectron_status  = (int)leaf_ce_status->GetValue(trki);
      celectron_pt      = leaf_ce_pt->GetValue(trki);
      celectron_pz      = leaf_ce_pz->GetValue(trki);
      celectron_phi     = leaf_ce_phi->GetValue(trki);
      celectron_eta     = leaf_ce_eta->GetValue(trki);
      celectron_y       = leaf_ce_y->GetValue(trki);
      if(celectron_eta > EtaCut || celectron_eta < -EtaCut) continue;
      ptbin = getPtBin(celectron_pt);
      if(ptbin == -99) continue;
      if(ptbin > maxptbin)
        maxptbin = ptbin;
      hept[ptbin]->Fill(celectron_pt);
      hEventTallyce[maxptbin]->Fill(0.5); //fill for each NPE

      for(int trkj = 0; trkj < numberofHadrons; trkj++){

        assoh_id = (int)leaf_hadron_id->GetValue(trkj);
        assoh_status  = (int)leaf_hadron_status->GetValue(trkj);
        assoh_pt      = leaf_hadron_pt->GetValue(trkj);
        assoh_pz      = leaf_hadron_pz->GetValue(trkj);
        assoh_phi     = leaf_hadron_phi->GetValue(trkj);
        assoh_eta     = leaf_hadron_eta->GetValue(trkj);
        assoh_y       = leaf_hadron_y->GetValue(trkj);
        if(assoh_eta > hEtaCut || assoh_eta < -hEtaCut) continue;

        float deltPhi = assoh_phi - celectron_phi;
        float deltEta = assoh_eta - celectron_eta;
        if(deltPhi < -PI)  deltPhi += 2*PI;
        if(deltPhi >  PI) deltPhi -= 2*PI;
        if(abs(deltEta) > deletacut) continue;
        if(assoh_pt>hptCut)
        {
          hdPhiRawce[ptbin]->Fill(deltPhi); 
          hdEtaRawce[ptbin]->Fill(deltEta);
          ceNtrigcount++;
        }
      }
    }
    //if(ceNtrigcount>0)hEventTallyce[maxptbin]->Fill(0.5);
    //if(ceNtrigcount>0)ceNtrigger++;

    //b decayed electron-------------------------------------------------- 
    int beNtrigcount=0;
    maxptbin = 0;
    for(int trki = 0; trki < numberofbElectrons; trki++){
      belectron_id = (int)leaf_be_id->GetValue(trki);
      belectron_status  = (int)leaf_be_status->GetValue(trki);
      belectron_pt      = leaf_be_pt->GetValue(trki);
      belectron_pz      = leaf_be_pz->GetValue(trki);
      belectron_phi     = leaf_be_phi->GetValue(trki);
      belectron_eta     = leaf_be_eta->GetValue(trki);
      belectron_y        = leaf_be_y->GetValue(trki);
      if(belectron_eta > EtaCut || belectron_eta < -EtaCut) continue;
      ptbin = getPtBin(belectron_pt);
      if(ptbin == -99) continue;
      if(ptbin > maxptbin)
        maxptbin = ptbin;
      hept[ptbin]->Fill(belectron_pt);
      hEventTallybe[maxptbin]->Fill(0.5); //fill for each NPE
      for(int trkj = 0; trkj < numberofHadrons; trkj++){

        assoh_id = (int)leaf_hadron_id->GetValue(trkj);
        assoh_status  = (int)leaf_hadron_status->GetValue(trkj);
        assoh_pt      = leaf_hadron_pt->GetValue(trkj);
        assoh_pz      = leaf_hadron_pz->GetValue(trkj);
        assoh_phi     = leaf_hadron_phi->GetValue(trkj);
        assoh_eta     = leaf_hadron_eta->GetValue(trkj);
        assoh_y       = leaf_hadron_y->GetValue(trkj);
        if(assoh_eta > hEtaCut || assoh_eta < -hEtaCut) continue;

        float deltPhi = assoh_phi - belectron_phi;
        float deltEta = assoh_eta - belectron_eta;
        if(deltPhi < -PI)  deltPhi += 2*PI;
        if(deltPhi >  PI) deltPhi -= 2*PI;
        if(abs(deltEta) > deletacut) continue;
        if(assoh_pt>hptCut)
        {
          hdPhiRawbe[ptbin]->Fill(deltPhi);
          hdEtaRawbe[ptbin]->Fill(deltEta);  
          beNtrigcount++;
        }
      }
    }
    //    if(beNtrigcount>0)hEventTallybe[maxptbin]->Fill("be non photonic electron",1);
    //    if(beNtrigcount>0)beNtrigger++;
    //bce decayed electron-----------------------------------------------------------------                                                                                           
    int bceNtrigcount=0;
    maxptbin = 0;
    for(int trki = 0; trki < numberofbcElectrons; trki++){
      bcelectron_id = (int)leaf_bce_id->GetValue(trki);
      bcelectron_status  = (int)leaf_bce_status->GetValue(trki);
      bcelectron_pt      = leaf_bce_pt->GetValue(trki);
      bcelectron_pz      = leaf_bce_pz->GetValue(trki);
      bcelectron_phi     = leaf_bce_phi->GetValue(trki);
      bcelectron_eta     = leaf_bce_eta->GetValue(trki);
      bcelectron_y       = leaf_bce_y->GetValue(trki);
      if(bcelectron_eta > EtaCut || bcelectron_eta < -EtaCut) continue;
      ptbin = getPtBin(bcelectron_pt);
      if(ptbin == -99) continue;
      if(ptbin > maxptbin)
        maxptbin = ptbin;
      hept[ptbin]->Fill(bcelectron_pt);
      hEventTallybe[maxptbin]->Fill(0.5); //fill for each NPE
      for(int trkj = 0; trkj < numberofHadrons; trkj++){

        assoh_id = (int)leaf_hadron_id->GetValue(trkj);
        assoh_status  = (int)leaf_hadron_status->GetValue(trkj);
        assoh_pt      = leaf_hadron_pt->GetValue(trkj);
        assoh_pz      = leaf_hadron_pz->GetValue(trkj);
        assoh_phi     = leaf_hadron_phi->GetValue(trkj);
        assoh_eta     = leaf_hadron_eta->GetValue(trkj);
        assoh_y       = leaf_hadron_y->GetValue(trkj);
        if(assoh_eta > hEtaCut || assoh_eta < -hEtaCut) continue;

        float deltPhi = assoh_phi - bcelectron_phi;
        float deltEta = assoh_eta - celectron_eta;
        if(deltPhi < -PI)  deltPhi += 2*PI;
        if(deltPhi >  PI) deltPhi -= 2*PI;
        if(abs(deltEta) > deletacut) continue;
        if(assoh_pt>hptCut)
        {
          hdPhiRawbe[ptbin]->Fill(deltPhi);
          hdEtaRawbe[ptbin]->Fill(deltEta);  
          bceNtrigcount++;
        }
      }
    }
    //    if(bceNtrigcount>0)hEventTallybe[maxptbin]->Fill("be non photonic electron",1);
    //    if(bceNtrigcount>0)beNtrigger++;


    /* if(ceNtrigger+bceNtrigger+beNtrigger > 0){
       std::cout<<"ce Trigger electron number = "<<ceNtrigger<<std::endl;
       std::cout<<"be Trigger electron number = "<<beNtrigger<<std::endl;
       std::cout<<"bce Trigger electron number = "<<bceNtrigger<<std::endl;
       }*/
  }

  // After Fill Manipulations
  for(int qq = 0; qq < numPtBins; qq++)
  {
    hdPhiRawceN[qq] = (TH1D*)hdPhiRawce[qq]->Clone();
    hdPhiRawceN[qq] -> SetName(Form("hdPhiRawceN_%i",qq));
    hdPhiRawceN[qq] -> Sumw2();
    hdPhiRawceN[qq] -> Scale(1./(Double_t)hEventTallyce[qq]->GetBinContent(1));
    hdPhiRawbeN[qq] = (TH1D*)hdPhiRawbe[qq]->Clone();
    hdPhiRawbeN[qq] -> SetName(Form("hdPhiRawbeN_%i",qq));
    hdPhiRawbeN[qq] -> Sumw2();
    hdPhiRawbeN[qq] -> Scale(1./(Double_t)hEventTallybe[qq]->GetBinContent(1));
  }

  std::cout << "100% [";
  for (int x=0; x<w; x++) std::cout << "=";
  std::cout << "]" << std::endl;
  fout.Write();
  fout.Close();
  delete chain;
}
Exemplo n.º 29
0
void Hyperon(const char* dataset="collection.xml")
{
  /* $Id$ */
  TStopwatch timer;
  timer.Start();


    TStringToken libs("Core,Tree,Geom,VMC,Physics,Minuit,Gui,XMLParser,Minuit2,Proof,STEERBase,ESD,AOD,OADB,ANALYSIS,ANALYSISalice,CDB,RAWDatabase,STEER,CORRFW,PHOSUtils,PHOSbase,PHOSpi0Calib,PHOSrec,PHOSshuttle,PHOSsim", ",");
  while( libs.NextToken() )
    gSystem->Load( Form("lib%s", libs.Data()) );

  gSystem->Load("libTree");
  gSystem->Load("libGeom");
  gSystem->Load("libVMC");
  gSystem->Load("libPhysics");
  gSystem->Load("libPWGGAGammaConv");
  gSystem->Load("libPWGGAHyperon");
  
  //load analysis framework
  gSystem->Load("libANALYSIS");
  gSystem->Load("libANALYSISalice"); //AliAnalysisTaskSE
  
  // Connect to alien
  TString token = gSystem->Getenv("GRID_TOKEN") ;
  if (1) // token == "OK" ) 
    TGrid::Connect("alien://");
  else 
    AliInfo("You are not connected to the GRID") ; 

  cout << "Pi0Analysis: processing collection " << dataset << endl;

  // Create the chain
  TChain* chain = new TChain("aodTree");

  TGridCollection * collection = dynamic_cast<TGridCollection*>(TAlienCollection::Open(dataset));
  
  TAlienResult* result = collection->GetGridResult("",0 ,0);
  TList* rawFileList = result->GetFileInfoList();
  
  for (Int_t counter=0 ; counter < rawFileList->GetEntries() ; counter++) {
    TFileInfo * fi =  static_cast<TFileInfo*>(rawFileList->At(counter)) ; 
    const char * rawFile = fi->GetCurrentUrl()->GetUrl() ;  
    printf("Processing %s\n", rawFile) ;
    chain->Add(rawFile);
    printf("Chain: %d entries.\n",chain->GetEntriesFast()); 
  }

  // Make the analysis manager
  AliAnalysisManager *mgr = new AliAnalysisManager("Hyperon");
  mgr->SetCommonFileName("histos.root");
  
  // AOD input handler
  AliAODInputHandler* aodH = new AliAODInputHandler();
  mgr->SetInputEventHandler(aodH);

  
  // Debug level
  mgr->SetDebugLevel(2);

   gROOT->LoadMacro("$ALICE_PHYSICS/OADB/macros/AddTaskCentrality.C"); 
   AliCentralitySelectionTask* taskCentrality = AddTaskCentrality(); 
   if (analysisMC) 
    taskCentrality->SetMCInput(); 

  // // Update it for Hyperon (YK 22.01.2015)
  // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskEventplane.C");
  // AliEPSelectionTask *taskEP = AddTaskEventplane() ; 

  // gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskVZEROEPSelection.C");
  // AliVZEROEPSelectionTask *selTask = AddTaskVZEROEPSelection();  

  // Add my task
  AliAnalysisHyperon* task = new AliAnalysisHyperon();
  // gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPb/AddTaskPHOSPi0Flow.C"); // Update it for Hyperon (YK 22.01.2015)
  // task = AddTaskPHOSPi0Flow();

  
  // // Create containers for input/output
  AliAnalysisDataContainer *cinput   = mgr->GetCommonInputContainer(); 
  AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("Hyperon",TList::Class(),AliAnalysisManager::kOutputContainer,"HyperonHist.root");
  
  // // Connect input/output
  mgr->ConnectInput(task , 0, cinput);
  mgr->ConnectOutput(task, 1, coutput1);
 
  if (mgr->InitAnalysis()) {
    mgr->PrintStatus();
    mgr->StartAnalysis("local", chain);
  }

  timer.Stop();
  timer.Print();
}
Exemplo n.º 30
0
void produce_elefakepho(){//main  

//  TFile *efile = TFile::Open("plot_elefakepho_test.root","read");
//  TTree* etree = (TTree*)efile->Get("FakeRateTree");

 TChain *etree = new TChain("FakeRateTree");
 etree->Add("../data/plot_elefakepho_Calib.root"); 


  int tracks=0; 
  int nVertex=0;
  float mass_denmg=0,mass_nummg=0,et_denmg=0,et_nummg=0, rap_denmg=0, rap_nummg=0;
  float mass_denrandom=0,mass_numrandom=0,et_denrandom=0,et_numrandom=0,rap_denrandom=0,rap_numrandom=0;
  std::vector<float> *mass_denbothcount=0;
  std::vector<float> *mass_numbothcount=0;
  std::vector<float> *et_denbothcount=0;
  std::vector<float> *et_numbothcount=0;
  std::vector<float> *rap_denbothcount=0;
  std::vector<float> *rap_numbothcount=0;
  std::vector<float> *track_denbothcount=0;
  std::vector<float> *track_numbothcount=0;
  std::vector<float> *tagEta=0;
  std::vector<float> *tagPhi=0;
  std::vector<float> *tagPt=0;
  std::vector<float> *probeEta=0;
  std::vector<float> *probePhi=0;
  std::vector<float> *probePt=0;
  std::vector<float> *invmass=0;
  std::vector<bool>  *vetovalue=0;
  
  etree->SetBranchAddress("tracks",&tracks);
  etree->SetBranchAddress("nVertex",&nVertex);
  etree->SetBranchAddress("mass_denrandom",      &mass_denrandom);    
  etree->SetBranchAddress("mass_numrandom",      &mass_numrandom);
  etree->SetBranchAddress("et_denrandom",        &et_denrandom);   
  etree->SetBranchAddress("et_numrandom",        &et_numrandom);  
  etree->SetBranchAddress("rap_denrandom",       &rap_denrandom);   
  etree->SetBranchAddress("rap_numrandom",       &rap_numrandom);  
  etree->SetBranchAddress("mass_denbothcount",   &mass_denbothcount); 
  etree->SetBranchAddress("mass_numbothcount",   &mass_numbothcount); 
  etree->SetBranchAddress("et_denbothcount",     &et_denbothcount);   
  etree->SetBranchAddress("et_numbothcount",     &et_numbothcount);   
  etree->SetBranchAddress("rap_denbothcount",    &rap_denbothcount);  
  etree->SetBranchAddress("rap_numbothcount",    &rap_numbothcount);  
  etree->SetBranchAddress("track_denbothcount",  &track_denbothcount);
  etree->SetBranchAddress("track_numbothcount",  &track_numbothcount);
  etree->SetBranchAddress("tagEta",              &tagEta);
  etree->SetBranchAddress("tagPhi",              &tagPhi);
  etree->SetBranchAddress("tagPt",               &tagPt);
  etree->SetBranchAddress("probeEta",            &probeEta);
  etree->SetBranchAddress("probePhi",            &probePhi);
  etree->SetBranchAddress("probePt",             &probePt);
  etree->SetBranchAddress("invmass",             &invmass);
  etree->SetBranchAddress("vetovalue",           &vetovalue);

  //float PtBins[]={25,30,35,40,45,50,60,70,90,110};
  float PtBins[]={25,30,35,40,50,60,70};
  float NtrkBins[] = {10,20,30,40,50,60,70,90,120};
  float EtaBins[] = {0.0,0.1,0.2,0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3};
  float VertexBins[]={0,4,8,10,11,12,13,14,15,16,17,18,20};
  unsigned nPtBins = sizeof(PtBins)/sizeof(float);
  unsigned nNtrkBins = sizeof(NtrkBins)/sizeof(float);
  unsigned nEtaBins = sizeof(EtaBins)/sizeof(float);
  unsigned nVertexBins = sizeof(VertexBins)/sizeof(float);

  TFile *outputfile = TFile::Open("histo_elefakepho_Calib.root","RECREATE");
  outputfile->cd();

  TH1F* den_random_pt[nPtBins]; 
  TH1F* den_random_trk[nNtrkBins];
  TH1F* den_random_eta[nEtaBins];
  TH1F* den_random_vtx[nVertexBins];
  TH1F* num_random_pt[nPtBins]; 
  TH1F* num_random_trk[nNtrkBins];
  TH1F* num_random_eta[nEtaBins];
  TH1F* num_random_vtx[nVertexBins];

  TH1F* den_both_pt[nPtBins]; 
  TH1F* den_both_trk[nNtrkBins];
  TH1F* den_both_eta[nEtaBins];
  TH1F* den_both_vtx[nVertexBins];
  TH1F* num_both_pt[nPtBins]; 
  TH1F* num_both_trk[nNtrkBins];
  TH1F* num_both_eta[nEtaBins];
  TH1F* num_both_vtx[nVertexBins];

  TH1F *event_type=new TH1F("event_type","",10,0,10);
 
  std::ostringstream binname; 
  for(unsigned iPt(0); iPt < nPtBins; iPt++){
    binname.str("");
    if(iPt != nPtBins-1)binname << "den_random_pt-" << PtBins[iPt] << "-" << PtBins[iPt+1];
    else binname << "den_random_pt-" << PtBins[iPt] << "-inf";
    den_random_pt[iPt] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iPt != nPtBins-1)binname << "num_random_pt-" << PtBins[iPt] << "-" << PtBins[iPt+1];
    else binname << "num_random_pt-" << PtBins[iPt] << "-inf";
    num_random_pt[iPt] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iPt != nPtBins-1)binname << "den_both_pt-" << PtBins[iPt] << "-" << PtBins[iPt+1];
    else binname << "den_both_pt-" << PtBins[iPt] << "-inf";
    den_both_pt[iPt] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iPt != nPtBins-1)binname << "num_both_pt-" << PtBins[iPt] << "-" << PtBins[iPt+1];
    else binname << "num_both_pt-" << PtBins[iPt] << "-inf";
    num_both_pt[iPt] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
  }
    

  for(unsigned iNtrk(0); iNtrk < nNtrkBins; iNtrk++){
    binname.str("");
    if(iNtrk != nNtrkBins-1)binname << "den_random_trk-" << NtrkBins[iNtrk] << "-" << NtrkBins[iNtrk+1];
    else binname << "den_random_trk-" << NtrkBins[iNtrk] << "-inf";
    den_random_trk[iNtrk] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iNtrk != nNtrkBins-1)binname << "num_random_trk-" << NtrkBins[iNtrk] << "-" << NtrkBins[iNtrk+1];
    else binname << "num_random_trk-" << NtrkBins[iNtrk] << "-inf";
    num_random_trk[iNtrk] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iNtrk != nNtrkBins-1)binname << "den_both_trk-" << NtrkBins[iNtrk] << "-" << NtrkBins[iNtrk+1];
    else binname << "den_both_trk-" << NtrkBins[iNtrk] << "-inf";
    den_both_trk[iNtrk] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iNtrk != nNtrkBins-1)binname << "num_both_trk-" << NtrkBins[iNtrk] << "-" << NtrkBins[iNtrk+1];
    else binname << "num_both_trk-" << NtrkBins[iNtrk] << "-inf";
    num_both_trk[iNtrk] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
  }


  for(unsigned iEta(0); iEta < nEtaBins; iEta++){
    binname.str("");
    if(iEta != nEtaBins-1)binname << "den_random_eta-" << EtaBins[iEta] << "-" << EtaBins[iEta+1];
    else binname << "den_random_eta-" << EtaBins[iEta] << "-inf";
    den_random_eta[iEta] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iEta != nEtaBins-1)binname << "num_random_eta-" << EtaBins[iEta] << "-" << EtaBins[iEta+1];
    else binname << "num_random_eta-" << EtaBins[iEta] << "-inf";
    num_random_eta[iEta] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iEta != nEtaBins-1)binname << "den_both_eta-" << EtaBins[iEta] << "-" << EtaBins[iEta+1];
    else binname << "den_both_eta-" << EtaBins[iEta] << "-inf";
    den_both_eta[iEta] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iEta != nEtaBins-1)binname << "num_both_eta-" << EtaBins[iEta] << "-" << EtaBins[iEta+1];
    else binname << "num_both_eta-" << EtaBins[iEta] << "-inf";
    num_both_eta[iEta] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
  }

  for(unsigned iVertexBins(0); iVertexBins < nVertexBins; iVertexBins++){
    binname.str("");
    if(iVertexBins != nVertexBins-1)binname << "den_random_vtx-" << VertexBins[iVertexBins] << "-" << VertexBins[iVertexBins+1];
    else binname << "den_random_vtx-" << VertexBins[iVertexBins] << "-inf";
    den_random_vtx[iVertexBins] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iVertexBins != nVertexBins-1)binname << "num_random_vtx-" << VertexBins[iVertexBins] << "-" << VertexBins[iVertexBins+1];
    else binname << "num_random_vtx-" << VertexBins[iVertexBins] << "-inf";
    num_random_vtx[iVertexBins] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iVertexBins != nVertexBins-1)binname << "den_both_vtx-" << VertexBins[iVertexBins] << "-" << VertexBins[iVertexBins+1];
    else binname << "den_both_vtx-" << VertexBins[iVertexBins] << "-inf";
    den_both_vtx[iVertexBins] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
    binname.str("");
    if(iVertexBins != nVertexBins-1)binname << "num_both_vtx-" << VertexBins[iVertexBins] << "-" << VertexBins[iVertexBins+1];
    else binname << "num_both_vtx-" << VertexBins[iVertexBins] << "-inf";
    num_both_vtx[iVertexBins] = new TH1F(binname.str().c_str(), binname.str().c_str(), 60, 60,120);
  }

  const unsigned nEvts = etree->GetEntries(); 
  for(unsigned iEvt(0); iEvt < nEvts; iEvt++){
    etree->GetEntry(iEvt);
    nVertex = nVertex+0.1;

    if(mass_denrandom > 40.0){
      den_random_pt[findIndex(PtBins,et_denrandom,nPtBins)]->Fill(mass_denrandom);
      den_random_trk[findIndex(NtrkBins,tracks,nNtrkBins)]->Fill(mass_denrandom);
      den_random_eta[findIndex(EtaBins,fabs(rap_denrandom),nEtaBins)]->Fill(mass_denrandom); 
      den_random_vtx[findIndex(VertexBins,nVertex, nVertexBins)]->Fill(mass_denrandom);
    }

    if(mass_numrandom > 40.0){
      num_random_pt[findIndex(PtBins,et_numrandom,nPtBins)]->Fill(mass_numrandom);
      num_random_trk[findIndex(NtrkBins,tracks,nNtrkBins)]->Fill(mass_numrandom);
      num_random_eta[findIndex(EtaBins,fabs(rap_numrandom),nEtaBins)]->Fill(mass_numrandom); 
      num_random_vtx[findIndex(VertexBins,nVertex, nVertexBins)]->Fill(mass_numrandom);
    }

    if(mass_denbothcount->size()>0){
      for(unsigned ii(0); ii<mass_denbothcount->size(); ii++){
        den_both_pt[findIndex(PtBins, (*et_denbothcount)[ii], nPtBins)]->Fill( (*mass_denbothcount)[ii]);
        den_both_trk[findIndex(NtrkBins, (*track_denbothcount)[ii], nNtrkBins)]->Fill((*mass_denbothcount)[ii]);
        den_both_eta[findIndex(EtaBins, fabs((*rap_denbothcount)[ii]), nEtaBins)]->Fill((*mass_denbothcount)[ii]);
        den_both_vtx[findIndex(VertexBins,nVertex, nVertexBins)]->Fill((*mass_denbothcount)[ii]);
      }
    }

    if(mass_numbothcount->size()>0){
      for(unsigned ii(0); ii<mass_numbothcount->size(); ii++){
        num_both_pt[findIndex(PtBins, (*et_numbothcount)[ii], nPtBins)]->Fill( (*mass_numbothcount)[ii]);
        num_both_trk[findIndex(NtrkBins, (*track_numbothcount)[ii], nNtrkBins)]->Fill((*mass_numbothcount)[ii]);
        num_both_eta[findIndex(EtaBins, fabs((*rap_numbothcount)[ii]), nEtaBins)]->Fill((*mass_numbothcount)[ii]);
        num_both_vtx[findIndex(VertexBins,nVertex, nVertexBins)]->Fill((*mass_numbothcount)[ii]);
      }
    }

  }

outputfile->Write();
outputfile->Close();
}