Ejemplo n.º 1
0
//2d reweighting of rho and its sigma
void reweight_rhosigma(TH1F* weight_rho, TH1F* weight_rhoo,TH2F*weight_rhon,TH2F*weight_rho2o,TH2F* weight_rhonr, TH2F* weight_rho2,TH2F*weight_sigman,TH2F*weight_sigma2o,TH2F* weight_sigmanr, TH2F* weight_sigma2,RooDataSet **dset, RooDataSet *dsetdestination, bool deleteold){
  if (!(*dset)) return;
//  TH2F *hnum = new TH2F("hnum","hnum",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting);
//  TH2F *hden = new TH2F("hden","hden",n_rhobins_forreweighting,rhobins_forreweighting,n_sigmabins_forreweighting,sigmabins_forreweighting);
  TH2F *hnum = new TH2F("hnum","hnum",100,0,100,20,0,20);
  TH2F *hden = new TH2F("hden","hden",100,0,100,20,0,20);
  hnum->Sumw2();
  hden->Sumw2();
  for (int i=0; i<(*dset)->numEntries(); i++){
    hden->Fill(fabs((*dset)->get(i)->getRealValue("roorho")),fabs((*dset)->get(i)->getRealValue("roosigma")),(*dset)->store()->weight(i));
  }
  for (int i=0; i<dsetdestination->numEntries(); i++){
    hnum->Fill(fabs(dsetdestination->get(i)->getRealValue("roorho")),fabs(dsetdestination->get(i)->getRealValue("roosigma")),dsetdestination->store()->weight(i));
  }

  hnum->Scale(1.0/hnum->Integral());
  hden->Scale(1.0/hden->Integral());
//data/MC
  hnum->Divide(hden);
  TH2F *h = hnum;

  RooDataSet *newdset = new RooDataSet(**dset,Form("%s_rhosigmarew",(*dset)->GetName()));
  newdset->reset();
  for (int i=0; i<(*dset)->numEntries(); i++){
    RooArgSet args = *((*dset)->get(i));
    float oldw = (*dset)->store()->weight(i);
    float rho = args.getRealValue("roorho");
    float sigma = args.getRealValue("roosigma");
    float neww = oldw*h->GetBinContent(h->FindBin(rho,sigma));
	if(debug){
		weight_rho->Fill(neww);
		weight_rhoo->Fill(oldw);
		weight_rho2o->Fill(h->GetXaxis()->FindBin(rho),oldw);	
		weight_rhon->Fill(h->GetXaxis()->FindBin(rho),neww);	
		if(oldw!=0)weight_rhonr->Fill(h->GetXaxis()->FindBin(rho),oldw/neww);
		else {weight_rhonr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
		if(oldw!=0)weight_rho2->Fill(rho,oldw/neww);
		weight_sigma2o->Fill(h->GetYaxis()->FindBin(sigma),oldw);	
		weight_sigman->Fill(h->GetYaxis()->FindBin(sigma),neww);	
		if(oldw!=0)weight_sigmanr->Fill(h->GetYaxis()->FindBin(sigma),oldw/neww);
		else {weight_sigmanr->Fill(-10,1);}//cout << "dipho weight old 0" << endl;}
		if(oldw!=0)weight_sigma2->Fill(sigma,oldw/neww);
	}
		newdset->add(args,neww);
	  }
	  newdset->SetName((*dset)->GetName());
	  newdset->SetTitle((*dset)->GetTitle());
	  delete hnum; delete hden;
	  RooDataSet *old_dset = *dset;
	  *dset=newdset;
	  std::cout << "RhoSigma2D rew: norm from " << old_dset->sumEntries() << " to " << newdset->sumEntries() << std::endl;
	  if (deleteold) delete old_dset;
	};
Ejemplo n.º 2
0
void makeNewTree(TTree *oldTree, TTree *newTree, TFile *outFile){
  
  float bdtoutput, deltaMOverM, wt;
  oldTree->SetBranchAddress("bdtoutput",&bdtoutput);
  oldTree->SetBranchAddress("deltaMOverM",&deltaMOverM);
  oldTree->SetBranchAddress("wt",&wt);
  newTree->Branch("bdtoutput",&bdtoutput,"bdtoutput/F");
  newTree->Branch("deltaMOverM",&deltaMOverM,"deltaMOverM/F");
  newTree->Branch("wt",&wt,"wt/F");

  string name = string(newTree->GetName());
  TH1F *h_bdt = new TH1F(Form("h_bdt_%s",name.c_str()),Form("h_bdt_%s",name.c_str()),100,-1,1.);
  TH1F *h_dM = new TH1F(Form("h_dm_%s",name.c_str()),Form("h_dm_%s",name.c_str()),100,-0.1,0.1);
  TH2F *scat = new TH2F(Form("scat_%s",name.c_str()),Form("scat_%s",name.c_str()),100,-1.,1.,100,-.1,0.1);
  TH2F *scat_abs = new TH2F(Form("scat_abs_%s",name.c_str()),Form("scat_abs_%s",name.c_str()),100,-1.,1.,100,0,0.1);
  
  for (int i=0; i<oldTree->GetEntries(); i++){
    oldTree->GetEntry(i);
    if (bdtoutput > -0.5 && deltaMOverM <= 0.02) {
      newTree->Fill();
      h_bdt->Fill(bdtoutput);
      h_dM->Fill(deltaMOverM);
      scat->Fill(bdtoutput,deltaMOverM);
      scat_abs->Fill(bdtoutput,fabs(deltaMOverM));
    }
  }
  outFile->cd();
  h_bdt->Write();
  h_dM->Write();
  scat->Write();
  scat_abs->Write();

}
Ejemplo n.º 3
0
void plotDeltaT()
{
  Double_t nTopOfIce=1.4;
  Double_t ant1[3]={8,-5,-25};
  Double_t ant2[3]={8,5,-30};
  Double_t rho1=TMath::Sqrt(ant1[0]*ant1[0]+ant1[1]*ant1[1]);
  Double_t rho2=TMath::Sqrt(ant2[0]*ant2[0]+ant2[1]*ant2[1]);
  Double_t phi1=TMath::ATan2(ant1[1],ant1[0]);
  Double_t phi2=TMath::ATan2(ant2[1],ant2[0]);
  std::cout << phi1*TMath::RadToDeg() << "\t" << phi2*TMath::RadToDeg() << "\n";
  TH2F *histDt = new TH2F("histDt","histDt",360,-180,180,180,-90,90);
  for(int binx=1;binx<=histDt->GetNbinsX();binx++) {
    Double_t phiWaveDeg=histDt->GetXaxis()->GetBinCenter(binx);
    for(int biny=1;biny<=histDt->GetNbinsY();biny++) {
      Double_t thetaWaveDeg=histDt->GetYaxis()->GetBinCenter(biny);
      Double_t phiWave=phiWaveDeg*TMath::DegToRad();
      Double_t thetaWave=thetaWaveDeg*TMath::DegToRad();
      
      Double_t d1=TMath::Cos(thetaWave)*(ant1[2]*TMath::Tan(thetaWave)+rho1*TMath::Cos(phi1-phiWave));
      Double_t d2=TMath::Cos(thetaWave)*(ant2[2]*TMath::Tan(thetaWave)+rho2*TMath::Cos(phi2-phiWave));
      Double_t t2t1=(d1-d2)*nTopOfIce/TMath::C();
      t2t1*=1e9;
      histDt->Fill(phiWaveDeg,thetaWaveDeg,t2t1);
    }
  }
  histDt->Draw("colz");

}
Ejemplo n.º 4
0
int main(int argc, char** argv)
{
  // Build histogram of chi^2 values over many files
  // Write out to a new rootfile chiout.root
  TFile file("chiout.root", "recreate");
  TH2F* histogram = new TH2F("chisquared", "chisquared values of pedestal fit", 
			     52, 0, 52, 1000, 0, 2000);

  for(int i=1; i<argc; i++)
  {
    TFile fin(argv[i]);
    TTree* tin=(TTree*)fin.Get("slowTree");
    double chi2vals[52];
    tin->SetBranchAddress("fit_chi2perndf", &chi2vals);
    tin->GetEvent(0);

    for(int j=0; j<52; j++)
    {
      histogram->Fill(j, chi2vals[j]);
      if( chi2vals[j] > 500 )
      {
	std::cout << "Chi^2 high on pmt: "
		  << j << " file:["
		  << argv[i] << "]\n";
      }
    }
  }

  file.Write();
  return 0;
}
Ejemplo n.º 5
0
void display_magfield(){
    FILE *pFile = fopen("magfield.table", "r");
    // FILE *pFile = fopen(
    //     "../MUSIC-3D-filed-map/MUSIC-FILL-map1-X=+-2000-Y=0-1000-Z=-1000-5000.table", "r");
    
    TFile *outFile = new TFile("magfield.root", "RECREATE");
    TTree *outTree = new TTree("bfield", "bfield");
    
    bfield2d myfield;
    outTree->Branch("field", &myfield, "x/F:z:bx:bz");
    TH2F *bhist = new TH2F("Bfield", "Bfield", 200, -2000, 2000,
                                               300, -1000, 5000);
    
    float y, by, junk;
    char dat_format [] = "%f %f %f %e %e %e %e";
    char line [150];
    int linecount = 0;
    while (fgets(line, 150, pFile) != NULL)
    {
        ++ linecount;
        if (linecount < 10) continue;
        sscanf(line, dat_format, &myfield.x, &y, 
            &myfield.z, &myfield.bx, &by, &myfield.bz, &myfield.bmod);
        
        if (y < 5) continue; // take only the y = 0 slice
        outTree->Fill();
        bhist->Fill(myfield.x, myfield.z, myfield.bmod);
    }
    // bhist->Draw("SURF2");
    bhist->Draw("CONT1");
    
}
void ECALEndcapCorrectionFactorCalculator()
{
    std::string detectorModel("90");
    std::string recoVar("71");

    TString rootFilesToCompare("/r04/lc/sg568/HCAL_Optimisation_Studies/Calibration/Detector_Model_" + detectorModel + "/Reco_Stage_" + recoVar + "/MuonCalibration/RootFiles/*Photon*.root");
    std::string resultsFileName("ECALEndcapCorrectionFactorCalculator_DetectorModel" + detectorModel + "_RecoStage" + recoVar + ".txt");

    std::ofstream resultsFile;
    resultsFile.open (resultsFileName.c_str());

    float ecalTotalCaloHitEnergy(-1.f);
    std::vector<float> *pPfoTargetCosTheta(NULL);

    TChain *pTChain = new TChain("PfoAnalysisTree");
    pTChain->Add(rootFilesToCompare);
    pTChain->SetBranchAddress("ECalTotalCaloHitEnergy",&ecalTotalCaloHitEnergy);
    pTChain->SetBranchAddress("pfoTargetCosTheta",&pPfoTargetCosTheta);

    TCanvas *pTCanvas = new TCanvas("PhotonDistPic", "PhotonDistPic");
    TH2F *pPhotonDist = new TH2F("PhotonDist","PhotonDist",100,0,1,150,0,15);
    pPhotonDist->GetXaxis()->SetTitle("abs( cos (#theta_{#gamma}) )");
    pPhotonDist->GetYaxis()->SetTitle("ECal Calo Hit Energy [GeV]");

    for (int entry = 0; entry < pTChain->GetEntries(); entry++)
    {
//        std::cout << "Reading entry " << entry << std::endl;
        pTChain->GetEvent(entry);

        if (!pPfoTargetCosTheta->empty())
        {
//            std::cout << "Target cos theta : " << pPfoTargetCosTheta.at(0) << std::endl;
            pPhotonDist->Fill(TMath::Abs(pPfoTargetCosTheta->at(0)),ecalTotalCaloHitEnergy);
        }
    }

    TF1 *barrelFit = new TF1("BarrelFit","[0]",0.1,0.7);
    barrelFit->SetLineColor(kGray);
    barrelFit->SetLineWidth(4);

    TF1 *endcapFit = new TF1("EndcapFit","[0]",0.85,0.95);
    endcapFit->SetLineColor(kGray);
    endcapFit->SetLineWidth(4);

    pTCanvas->cd();
    pPhotonDist->Draw("COLZ");

    pPhotonDist->Fit(barrelFit,"QR+");
    pPhotonDist->Fit(endcapFit,"QR+");

    resultsFile << "For the barrel the best fit is : " << barrelFit->GetParameter(0) << std::endl;
    resultsFile << "For the endcap the best fit is : " << endcapFit->GetParameter(0) << std::endl;
    resultsFile << "ECALEndcapCorrectionFactorCalculator -> " << (barrelFit->GetParameter(0))/(endcapFit->GetParameter(0)) << std::endl;
    resultsFile.close();

    TString picName = "ECALEndcapCorrectionFactorCalculator_DetectorModel" + detectorModel + "_RecoStage" + recoVar + ".pdf";
    pTCanvas->SaveAs(picName);   
}
Ejemplo n.º 7
0
TCanvas *earth(){
  //this tutorial illustrate the special contour options
  //    "AITOFF"     : Draw a contour via an AITOFF projection
  //    "MERCATOR"   : Draw a contour via an Mercator projection
  //    "SINUSOIDAL" : Draw a contour via an Sinusoidal projection
  //    "PARABOLIC"  : Draw a contour via an Parabolic projection
  //
  //Author: Olivier Couet (from an original macro sent by Ernst-Jan Buis)

   gStyle->SetPalette(57);
   gStyle->SetOptTitle(1);
   gStyle->SetOptStat(0);

   TCanvas *c1 = new TCanvas("c1","earth_projections",700,700);
   c1->Divide(2,2);

   TH2F *ha = new TH2F("ha","Aitoff",    180, -180, 180, 179, -89.5, 89.5);
   TH2F *hm = new TH2F("hm","Mercator",  180, -180, 180, 161, -80.5, 80.5);
   TH2F *hs = new TH2F("hs","Sinusoidal",180, -180, 180, 181, -90.5, 90.5);
   TH2F *hp = new TH2F("hp","Parabolic", 180, -180, 180, 181, -90.5, 90.5);

   TString dat = gSystem->UnixPathName(__FILE__);
   dat.ReplaceAll("C","dat");
   dat.ReplaceAll("/./","/");

   ifstream in;
   in.open(dat.Data());
   Float_t x,y;
   while (1) {
     in >> x >> y;
     if (!in.good()) break;
     ha->Fill(x,y, 1);
     hm->Fill(x,y, 1);
     hs->Fill(x,y, 1);
     hp->Fill(x,y, 1);
   }
   in.close();

   c1->cd(1); ha->Draw("aitoff");
   c1->cd(2); hm->Draw("mercator");
   c1->cd(3); hs->Draw("sinusoidal");
   c1->cd(4); hp->Draw("parabolic");

   return c1;
}
Ejemplo n.º 8
0
void Correlation::DrawMatrix(){

  map<TString, map<TString,double> >::iterator it1 = results.begin();
  map<TString, double>::iterator it2 = ((*it1).second).begin();

  int nvars = (int) results.size();
  TH2F* hmatrix = new TH2F("matrix","",nvars,0,nvars,nvars,0,nvars);
  hmatrix->SetStats(0);

  int counter1= 1;
  for(it1 = results.begin(); it1!= results.end(); ++it1){

    TString var1 = (*it1).first;
    var1.ReplaceAll("_both_mix_merge","");
    hmatrix->GetXaxis()->SetBinLabel(counter1,var1);
    counter1++;

    int counter2=1;
    map<TString, double> results2 = (*it1).second;
    map<TString, double>::iterator it2 = results2.begin();

    for(it2 = results2.begin(); it2!=results2.end(); ++it2){
      TString var2 = (*it2).first;
      var2.ReplaceAll("_both_mix_merge","");
      //cout << counter2 << " " << var2 << endl;
      if ( counter1==1) hmatrix->GetYaxis()->SetBinLabel(counter2,var2);
      counter2++;
      double value = abs((*it2).second);
      //cout << var1 << " " << var2 << " " << value << endl;
      hmatrix->Fill(var1,var2,value);
      if(var1!=var2) hmatrix->Fill(var2,var1,value);
    }
  }

  TCanvas* c = new TCanvas("c","",700,700);
  hmatrix->GetXaxis()->SetLabelSize(0.03);
  hmatrix->GetYaxis()->SetLabelSize(0.03);
  c->SetLeftMargin(0.2);
  c->SetBottomMargin(0.2);
  hmatrix->Draw("colz");
  c->SaveAs("results/matrix.pdf");
  c->SaveAs("results/matrix.eps");

}
Ejemplo n.º 9
0
void display_magfield(){
    // FILE *pFile = fopen("../../PION-DIPOLE-bfield/Dipole fring Bmap_XZ_X-2000-0_Z0-2000.table", "r");
    // FILE *pFile = fopen("../../PION-DIPOLE-bfield/Dipole Bmap_XZ_X0-220_Z0-500.table", "r");
    // FILE *pFile = fopen("../input/Bfield_roi.table", "r");
    FILE *pFile = fopen("../output/vec_field_out.table", "r");
    // FILE *pFile = fopen(
    //     "../../MUSIC-3D-filed-map/MUSIC-FILL-map1-X=+-2000-Y=0-1000-Z=-1000-5000.table", "r");
    
    TFile *outFile = new TFile("magfield.root", "RECREATE");
    TTree *outTree = new TTree("bfield", "bfield");
    
    bfield2d myfield;
    outTree->Branch("field", &myfield, "x/F:z:bx:bz");
    // TH2F *bhist = new TH2F("Bfield", "Bfield", 200, -2000, 2000,
    //                                            300, -1000, 5000);
    // TH2F *bhist = new TH2F("Bfield", "Bfield", 55, 500, 1600,
    //                                        55, 3080, 4180);
    TH2F *bhist = new TH2F("Bfield", "Bfield", 54, -540, 540,
                                           54, -540, 540);
    // TH2F *bhist = new TH2F("Bfield", "Bfield", 55, 460, 1560,
    //                                         54, 3240, 4320);
    
    // TH2F *bhist = new TH2F("Bfield", "Bfield", 54, -540, 540,
    //                                        54, -540, 540);
    float y, by, junk;
    char dat_format [] = "%f %f %f %e %e %e %e";
    char line [150];
    int linecount = 0;
    float max_bfield = 0;
    int test =0;
    while (fgets(line, 150, pFile) != NULL)
    {
        ++ linecount;
        // if (linecount < 10) continue;
        sscanf(line, dat_format, &myfield.x, &y, 
            &myfield.z, &myfield.bx, &by, &myfield.bz, &myfield.bmod);
        if (myfield.bmod > max_bfield) max_bfield = myfield.bmod;
        if (y > 15) continue; // take only the y = 0 slice
        ++test;
        outTree->Fill();
        bhist->Fill(myfield.x, myfield.z, myfield.bmod);
    }
    outFile->Write();
    // bhist->Draw("SURF2");
    bhist->SetTitle("Magnetic dipole fringe field");
    // bhist->SetTitle("Magnetic field in simulated region");
    // bhist->
    // bhist->Draw("CONT1");
    bhist->Draw("COLZ");
    cout << "Max magnetic field: "<<max_bfield << endl;
    cout << "Number of lines read in: "<<test << endl;
    cout << "REMEMBER: if using an 'output' file from the simulation - uncomment the ignore lines code"<<endl;
    
}
Ejemplo n.º 10
0
TH2F* Bin2DTree::fillHistogram()
/*****************************************************************/
{
        if(!m_gridConstraint)
        {
            cerr<<"ERROR: Bin2DLeaf.fillHistogram(): Trying to fill histogram, but the binning is unknown. Define first the gridConstraint.\n";
            exit(1);
        }
        TH2F* histo = (TH2F*)m_gridConstraint->Clone("histoFromTree");
        int nbinsx = histo->GetNbinsX();
        int nbinsy = histo->GetNbinsY();
        map<Bin2DLeaf*, vector< pair<int,int> > > binsInLeaf;
        // First find the list of TH2 bins for each Bin2DLeaf bin
        for(int bx=1;bx<nbinsx+1;bx++) 
        {
            for(int by=1;by<nbinsy+1;by++)
            {
                histo->SetBinContent(bx,by,0);
                histo->SetBinError(bx,by,0);
                double x = histo->GetXaxis()->GetBinCenter(bx);
                double y = histo->GetYaxis()->GetBinCenter(by);
                Bin2DLeaf* leaf = getLeaf(x,y);
                if(binsInLeaf.find(leaf)==binsInLeaf.end())
                {
                    vector< pair<int,int> > empty;
                    binsInLeaf[leaf] = empty;
                }
                binsInLeaf[leaf].push_back(make_pair(bx,by));
            }
        }
        // Then all the TH2 bins are filled according to the entries in the Bin2DLeaf bins
        map<Bin2DLeaf*, vector< pair<int,int> > >::iterator it = binsInLeaf.begin();
        map<Bin2DLeaf*, vector< pair<int,int> > >::iterator itE = binsInLeaf.end();
        for(;it!=itE;++it)
        {
            Bin2DLeaf* leaf = it->first;
            vector< pair<int,int> > bins = it->second;
            vector< vector<double> > entries = leaf->getEntries();
            int nbins = bins.size();
            for(int b=0;b<nbins;b++)
            {
                int bx = bins[b].first;
                int by = bins[b].second;
                double x = histo->GetXaxis()->GetBinCenter(bx);
                double y = histo->GetYaxis()->GetBinCenter(by);
                for(unsigned int e=0;e<entries.size();e++)
                {
                    double value = entries[e][2]/(double)nbins;
                    histo->Fill(x,y,value);
                }
            }
        }
        return histo;
}
Ejemplo n.º 11
0
TCanvas *earth(){

   gStyle->SetPalette(1);
   gStyle->SetOptTitle(1);
   gStyle->SetOptStat(0);

   TCanvas *c1 = new TCanvas("c1","earth_projections",700,700);
   c1->Divide(2,2);

   TH2F *ha = new TH2F("ha","Aitoff",    180, -180, 180, 179, -89.5, 89.5);
   TH2F *hm = new TH2F("hm","Mercator",  180, -180, 180, 161, -80.5, 80.5);
   TH2F *hs = new TH2F("hs","Sinusoidal",180, -180, 180, 181, -90.5, 90.5);
   TH2F *hp = new TH2F("hp","Parabolic", 180, -180, 180, 181, -90.5, 90.5);

   TString dat = gSystem->UnixPathName(__FILE__);
   dat.ReplaceAll(".C",".dat");
   dat.ReplaceAll("/./","/");

   ifstream in;
   in.open(dat.Data());
   Float_t x,y;
   while (1) {
     in >> x >> y;
     if (!in.good()) break;
     ha->Fill(x,y, 1);
     hm->Fill(x,y, 1);
     hs->Fill(x,y, 1);
     hp->Fill(x,y, 1);
   }
   in.close();

   c1->cd(1); ha->Draw("aitoff");
   c1->cd(2); hm->Draw("mercator");
   c1->cd(3); hs->Draw("sinusoidal");
   c1->cd(4); hp->Draw("parabolic");

   return c1;
}
Ejemplo n.º 12
0
void QAnalysis::PlotVelocityDistribution(int phi) {
  TTree* tree = ReadTree(file);
  
  int zbin = 60; int rbin = 19;
  TH2F*  hist = new TH2F("quenchv", "quenchv", zbin, 0, 60, rbin, 0, 19);
  
  for (int i=0; i<tree->GetEntries(); i++) {
    tree->GetEntry(i);
    if ( time==70. && posID[1]==phi )
	  hist->Fill(posID[0], posID[2], qchTime);
  }
  
  hist->SetTitle("; Z; R; Quenched Time [sec]");
  hist->Draw("colz");
}
Ejemplo n.º 13
0
void QAnalysis::PlotTemperatureDistribution(double qtime, int numPhi, bool scale) {
  int zbin = 60;
  int rbin = 19;
  TH2F*  hist = new TH2F(Form("tempDis%.1f", qtime), Form("tempDis%.1f", qtime), zbin, 0, 60, rbin, 0, 19);
  TTree* tree = ReadTree(file);
  
  for (int i=0; i<tree->GetEntries(); i++) {
    tree->GetEntry(i);
	if ( time==qtime && posID[1]==numPhi ) 
      hist->Fill(posID[0], posID[2], temp);
  }
  
  if (scale==true) hist->GetZaxis()->SetRangeUser(0., GetMaximum("temp"));
  hist->SetTitle(Form("time = %.1f [sec]; Z; R; Temperature [K]", qtime));
  hist->Draw("colz");
}
Ejemplo n.º 14
0
void drawRes(TString in="data/scan7/res_all.root"){

  glx_savepath = "data/drawRes";
  gStyle->SetOptStat(0);
  gStyle->SetPalette(55);
  gStyle->SetNumberContours(99);
   
  TChain ch("reco"); ch.Add(in);  
  Double_t sep,esep,spr,mom,theta,phi,nph;
  ch.SetBranchAddress("theta",&theta);
  ch.SetBranchAddress("phi",&phi);
  ch.SetBranchAddress("sep",&sep);
  ch.SetBranchAddress("esep",&esep);
  ch.SetBranchAddress("spr",&spr);
  ch.SetBranchAddress("mom",&mom);
  ch.SetBranchAddress("nph",&nph);

  TH2F *hSep_pol = new TH2F("hSep",";#theta [deg];#varphi [deg]",72,0,360,(11.4-1.2)/0.2+1+6,0,11.4);
  TH2F *hSep = new TH2F("hSep",";#theta [deg];#varphi [deg]",(11.4-1.2)/0.2+1,1.2,11.4,36,-170,10);
  
  for(Int_t i=0; i<ch.GetEntries(); i++){
    ch.GetEvent(i);
    hSep->Fill(theta,phi,sep);
    hSep_pol->Fill(180-phi,theta,sep);
  }

  // // interpolate emptiness
  // double pval;
  // for(int i=0; i<hSep_pol->GetNbinsX()*hSep_pol->GetNbinsX(); i++){
  //   double val = hSep_pol->GetBinContent(i);
  //   if(val<0.001 && )  hSep_pol->SetBinContent(i,pval);
  //   else pval=val;
  // }
  
  Int_t colors[]={1,kGreen+1,kRed+2,kRed,4,5,6,7,8,9,10};


  glx_canvasAdd("hSep_pol",800,800);
  gPad->SetTheta(90.);
  gPad->SetPhi(0.);
  hSep_pol->Draw("lego2 polz");

  glx_canvasAdd("hSep",800,500);
  hSep->Draw("colz");
  
  glx_canvasSave(0,0);
}
Ejemplo n.º 15
0
void scatterPloteta(){
  gROOT->Reset();
  gStyle->SetOptStat(1);

  ifstream data;
  
  float valueX;
  float valueY;

  string name = "eta";
  data.open((name+".txt").c_str());
  
  TH2F * histo = new TH2F("histo",name.c_str(),1000,-2.4,2.4,100,-2.4,2.4); //eta
  TH1F * histo1D = new TH1F("histo1D",name.c_str(),1000,-2.4,2.4); //eta

//  float pi = 3.14159265;
//  TH2F * histo = new TH2F("histo",name.c_str(),1000,-1*pi,pi,1000,-1*pi,pi); //phi
//  TH1F * histo1D = new TH1F("histo1D",name.c_str(),1000,-1*pi,pi); //phi

  while(!data.eof()){
    data >>valueX>>valueY;
    cout<<valueX<<" "<<valueY<<endl;
    histo->Fill(valueX,valueY);
    histo1D->Fill(valueX-valueY);
  }
  
  TCanvas * Ca0 = new TCanvas("Ca0","Canvas",1200,800);
  histo->SetLineWidth(3);

  TFile * theFile = new TFile("eta.root","RECREATE");
  theFile->cd();

  histo->Draw();
  histo1D->DrawNormalized("same");
  histo->GetXaxis()->SetTitle(("RPC"+name).c_str());
  histo->GetYaxis()->SetTitle(("CSC"+name).c_str());
  Ca0->SaveAs((name+".png").c_str());

  histo1D->Write();
  histo->Write();

  theFile->Save();
  theFile->Close();

  
}
void generate_sample(string OutFilePath="out.txt", string unusedArgument="")
{
     if(OutFilePath == "")return;
     
     FILE* OutputFile = fopen(OutFilePath.c_str(), "w");

     float mu=0.5;
     float sigma=0.1;
     float nb_events=1000000;

     TRandom3 rand(12345);

     TFile* OutputHisto = new TFile((OutFilePath+".root").c_str(),"RECREATE");
     OutputHisto->cd();
     TH2F* HGen         = new TH2F("pdf", "pdf;x;y", 100,0,1, 100, 0, 1 );



     int i=0;
     while(i<nb_events){
        double x = rand.Uniform();
        double y = rand.Uniform();

//       double r=0.5+rand.Uniform()* 0.2; //rand.Gaus(0.2, 0.1);
//       double phi=rand.Uniform() * 2.0 * 3.1415;
//       double x=r*cos(phi);
//       double y=r*sin(phi);

        double eps=0.1;
        double fct=1.0+eps*(2.0*y);
        double max_weight=1.0+2*eps;

//        if(fct>max_weight*rand.Uniform()){
        if(true){        
           fprintf(OutputFile, "%8f %8f  \n", x, y );
           HGen->Fill(x,y);
           i++;
        }
     }


     fclose(OutputFile);

     HGen->Write();
}
Ejemplo n.º 17
0
void gauss2D()
{
  TH2F * h = new TH2F("h", "h", 41, -20.5, 20.5, 41, -20.5, 20.5);

  /*
  for (int i=0;i<50000;++i) {
    h->Fill(gRandom->Gaus(-1.5, 2.0), gRandom->Gaus(2.0, 4.0));
  }
  */
  double x, y, r;
  for (int i=0;i<100000;++i) {
    x = gRandom->Uniform(-5, 5);
    y = gRandom->Uniform(-5, 5);
    r = TMath::Sqrt(x*x+y*y);
    if (r>5) continue;
    h->Fill(x, y);
  }

  h->Draw("lego2");

  TF2 *f2 = new TF2("f2", func_, -20.5, 20.5, -20.5, 20.5, 5);
  f2->SetParameter(0, 1000);
  f2->SetParameter(1, 0);
  f2->SetParameter(2, 1);
  f2->SetParameter(3, 0);
  f2->SetParameter(4, 1);

  h->Fit(f2);

  //f2->Draw("surf");
  /*
  std::ofstream ofile("gauss2Ddump.txt");

  for (int bx=1;bx<=41;++bx) {
    for (int by=1;by<=41;++by) {
      ofile << h->GetXaxis()->GetBinCenter(bx) << "\t"
            << h->GetXaxis()->GetBinCenter(bx) << "\t"
            << h->GetBinContent(bx, by) << std::endl;
    }
  }
  */
}
Ejemplo n.º 18
0
void DynamicSlice()
{
   // Create a new canvas.
   c1 = new TCanvas("c1","Dynamic Slice Example",10,10,700,500);
   c1->SetFillColor(42);
   c1->SetFrameFillColor(33);
  
   //create a 2-d histogram, fill and draw it
   TH2F *hpxpy  = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
   hpxpy->SetStats(0);
   Double_t px,py;
   for (Int_t i = 0; i < 50000; i++) {
      gRandom->Rannor(px,py);
      hpxpy->Fill(px,py);
   }
   hpxpy->Draw("col");
   
   //Add a TExec object to the canvas
   c1->AddExec("dynamic","DynamicExec()");
}
Ejemplo n.º 19
0
void drawLoad(TString infile="../build/hits.root"){
  gStyle->SetOptStat(0);
  fSavePath = "load";
  
  PrtInit(infile,0); //digi
  
  TH2F* hHits = new TH2F("hHits",";x, [mm];y, [mm]",500,-40,350,500,-100,100);
  Int_t angle(0), step(0);
  Double_t test(0);
  PrtHit fHit;
  for (Int_t ievent=0; ievent<fCh->GetEntries(); ievent++){
    PrtNextEvent(ievent,1000);
    if(ievent==0){
      angle = fEvent->GetAngle() + 0.01;
      test = fEvent->GetTest1();
      fInfo +=  fEvent->PrintInfo();
    }
    for(Int_t h=0; h<fEvent->GetHitSize(); h++){
      fHit = fEvent->GetHit(h);
      Int_t mcpid = fHit.GetMcpId();
      Int_t pixid = fHit.GetPixelId()-1;
      TVector3 pos = fHit.GetGlobalPos();
      
      Double_t time = fHit.GetLeadTime();
      hHits->Fill(pos.X(),pos.Y());
    }
  }
  
  canvasAdd(Form("load_%d",angle),800,500);
  hHits->SetStats(0);
  hHits->GetXaxis()->SetTitleOffset(0.85);
  hHits->GetYaxis()->SetTitleOffset(0.85);
  hHits->GetXaxis()->SetTitleSize(0.05);
  hHits->GetYaxis()->SetTitleSize(0.05);
  //hHits->SetTitle(Form("#theta_{track} = %d#circ",angle));
  hHits->Draw("colz");
  drawPrism(prismShift,0);
  canvasSave(1,0);
}
Ejemplo n.º 20
0
void FakeLeptonPlotter::fill(unsigned int iSample, unsigned int iSubSample) 
{
    if( iSample < nSamples && iSubSample < configContainer.sampleContainer.sampleNames[iSample].size() )
    {
//         if( configContainer.sampleContainer.sampleType[iSample] == SampleType::DATA )
//         {
//             for( unsigned int iVar = 0, iHist = 0; iVar < nVariables; ++iVar, ++iHist )
//             {
//                 if( configContainer.variableContainer.is2D[iVar] )
//                 {
//                     TH2F* h = (TH2F*) histogramContainers[iHist].histograms[iSample];
//                     h->Fill( functionVector[iVar](), functionVector[iVar+1](), globalWeight[iSample][iSubSample] );  // apply global weight for trigger luminosity
//                     iVar++;
//                 }
//                 else
//                     histogramContainers[iHist].histograms[iSample]->Fill( functionVector[iVar](), globalWeight[iSample][iSubSample] );
//             }
//         }
//         else
//         {
            for( unsigned int iVar = 0, iHist = 0; iVar < nVariables; ++iVar, ++iHist )
            {
                if( configContainer.variableContainer.is2D[iVar] )
                {
                    TH2F* h = (TH2F*) histogramContainers[iHist].histograms[iSample];
                    h->Fill( functionVector[iVar](), functionVector[iVar+1](), globalWeight[iSample][iSubSample]*eventWeightFunction() );
                    iVar++;
                }
                else
                    histogramContainers[iHist].histograms[iSample]->Fill( functionVector[iVar](), globalWeight[iSample][iSubSample]*eventWeightFunction() );
            }
//         }
    }
    else
    {
        cerr << "Indices for sample or subsample out of range in the FakeLeptonPlotter::fill function." << endl;
        throw 1;
    }
}
Ejemplo n.º 21
0
TCanvas *hlabels2()
{
   const Int_t nx = 12;
   const Int_t ny = 20;
   const char *month[nx]  = {"January","February","March","April","May",
      "June","July","August","September","October","November",
      "December"};
   const char *people[ny] = {"Jean","Pierre","Marie","Odile","Sebastien",
      "Fons","Rene","Nicolas","Xavier","Greg","Bjarne","Anton",
      "Otto","Eddy","Peter","Pasha","Philippe","Suzanne","Jeff",
      "Valery"};
   TCanvas *c1 = new TCanvas("c1","demo bin labels",10,10,600,600);
   c1->SetGrid();
   c1->SetLeftMargin(0.15);
   c1->SetBottomMargin(0.15);
   TH2F *h = new TH2F("h","test",3,0,3,2,0,2);
   h->SetCanExtend(TH1::kAllAxes);
   h->SetStats(0);
   gRandom->SetSeed();
   for (Int_t i=0;i<15000;i++) {
      Int_t rx = gRandom->Rndm()*nx;
      Int_t ry = gRandom->Rndm()*ny;
      h->Fill(people[ry],month[rx],1);
   }
   h->LabelsDeflate("X");
   h->LabelsDeflate("Y");
   h->LabelsOption("v");
   h->Draw("text");

   TPaveText *pt = new TPaveText(0.6,0.85,0.98,0.98,"brNDC");
   pt->SetFillColor(18);
   pt->SetTextAlign(12);
   pt->AddText("Use the axis Context Menu LabelsOption");
   pt->AddText(" \"a\"   to sort by alphabetic order");
   pt->AddText(" \">\"   to sort by decreasing values");
   pt->AddText(" \"<\"   to sort by increasing values");
   pt->Draw();
   return c1;
}
Ejemplo n.º 22
0
Archivo: plotjets.C Proyecto: XuQiao/HI
void plotjets(){
    TFile *f = TFile::Open("/store/user/qixu/flow/STEGwithnf/pPbDataV205m100/Varmults10b10/vndata_50k_0.root");
    int ievent = 1000;
    int n;
    float etag[10000];
    float phig[10000];
    float ptg[10000];
    TH2F* hetaphi = new TH2F("hetaphi","",100,-4,4,200,0,6.5);
    TTree *t = f->Get("tree");
    t->SetBranchAddress("n",&n);
    t->SetBranchAddress("etag",&etag);
    t->SetBranchAddress("phig",&phig);
    t->GetEntry(ievent);
    for(int ip = 0;ip<n;ip++){
        hetaphi->Fill(etag[ip],phig[ip]);
    }
    hetaphi->GetXaxis()->SetTitle("#eta");
    hetaphi->GetYaxis()->SetTitle("#phi");
    TCanvas *c1 = new TCanvas();
    //c1->SetLogy();
    hetaphi->Draw("colz");
    c1->Print("hetaphi.png");
}
Ejemplo n.º 23
0
TH1F *
CheckEnabledChannels(Int_t run, Bool_t checkROEff = kTRUE, const Char_t *dbString = "raw://")
{

  /* init */
  AliCDBManager *cdb = AliCDBManager::Instance();
  cdb->SetDefaultStorage(dbString);
  cdb->SetRun(run);
  AliTOFcalib calib;
  calib.Init();

  TH2F *hEnabledMap = new TH2F("hEnabledMap", "Enabled channel map;sector;strip", 72, 0., 18., 91, 0., 91.);
  TH1F *hEnabledFlag = new TH1F("hEnabledFlag", "Enabled channel flag;index;flag", 157248, 0., 157248.);

  AliTOFcalibHisto calibhisto;
  calibhisto.LoadCalibHisto();
  calibhisto.LoadCalibStat(); /* temp */

  Int_t sector, sectorStrip, padx, fea;
  Float_t hitmapx, hitmapy;
  /* loop over channels */
  for (Int_t ich = 0; ich < 157248; ich++) {
    if (!calib.IsChannelEnabled(ich, checkROEff)) continue;
    sector = calibhisto.GetCalibMap(AliTOFcalibHisto::kSector, ich);
    sectorStrip = calibhisto.GetCalibMap(AliTOFcalibHisto::kSectorStrip, ich);
    padx = calibhisto.GetCalibMap(AliTOFcalibHisto::kPadX, ich);
    fea = padx / 12;
    hitmapx = sector + ((Double_t)(3 - fea) + 0.5) / 4.;
    hitmapy = sectorStrip;
    hEnabledMap->Fill(hitmapx, hitmapy);
    hEnabledFlag->SetBinContent(ich + 1, 1);
  }
  
  hEnabledMap->DrawCopy("colz");
  return hEnabledFlag;

}
Ejemplo n.º 24
0
void
PlotYields(const std::string& name, std::map<double, double> yields, TLegend* legend) {
  static int pass = 0;
  int colors[] = {kBlue, kRed, kGreen, kOrange, kBlack};
  int lastColor = sizeof(colors)/sizeof(colors[0])-1;
  double miny = std::min_element(yields.begin(), yields.end(), [](std::pair<double, double> p, std::pair<double, double> q) { return p.second < q.second; })->second;
  double maxy = std::max_element(yields.begin(), yields.end(), [](std::pair<double, double> p, std::pair<double, double> q) { return p.second < q.second; })->second;

  std::string canvasName = "Yields " + name;
  //  TCanvas * c = new TCanvas(canvasName.c_str(), canvasName.c_str(), 900, 700);
  SetAtlasStyle();
  //c->SetLogy();

  TH2F* hist = new TH2F(canvasName.c_str(), canvasName.c_str(), 20, 200, 1100, 200, miny * 0.9, maxy * 1.1);
  hist->SetMarkerStyle(21+pass);
  hist->SetMarkerColor(pass > lastColor ? lastColor : colors[pass]);
  for (const std::pair<double, double>& p : yields) {
    // don't plot background yields
    if (p.first < 100) {
      continue;
    }
    
    hist->Fill(p.first, p.second);
  }
  
  if (pass == 0) {
    hist->Draw("p");
  } else {
    hist->Draw("same");
  }

  legend->AddEntry(hist, name.c_str(), "lp");

  //c->Print(outputFolder + "yields.pdf");
  ++pass;
}
Ejemplo n.º 25
0
// inputs data file and event in file to display (default is to integrate all)
void dqmDisplay(TString fdat, int ndisplay = -1){

  gStyle->SetOptStat(0);

  TFile *f = new TFile(fdat);
  if (f->IsZombie()){
    cout << "Cannot open file: " << fdat << endl;
    return;
  }

  TBEvent *event = new TBEvent();
  TTree *t1041 = (TTree*)f->Get("t1041"); 
  TBranch *bevent = t1041->GetBranch("tbevent");
  bevent->SetAddress(&event);

  Bool_t singleEvent = (ndisplay >= 0);

  Mapper * mapper = Mapper::Instance();

  TH2F * hModU = (TH2F*)moduleHistogram(true, "RO", threshold, 2500, singleEvent);
  TH2F * hModD = (TH2F*)moduleHistogram(false, "RO", threshold, 2500, singleEvent);
  TH2F * hChanU = (TH2F*)channelHistogram(true, "RO", threshold, 2500, singleEvent);
  TH2F * hChanD = (TH2F*)channelHistogram(false, "RO", threshold, 2500, singleEvent);

  TH2F * hModU_time = (TH2F*)moduleHistogram(true, "Timing", 0, -1, singleEvent);
  TH2F * hModD_time = (TH2F*)moduleHistogram(false, "Timing", 0, -1, singleEvent);
  TH2F * hChanU_time = (TH2F*)channelHistogram(true, "Timing", 0, -1, singleEvent);
  TH2F * hChanD_time = (TH2F*)channelHistogram(false, "Timing", 0, -1, singleEvent);

  int nPerMod = t1041->GetEntries() / 16;
  int nPerFiber = t1041->GetEntries() / 64;

  TH2F * hModU_nhits = (TH2F*)moduleHistogram(true, "nHits", nPerMod * .85, nPerMod * 1.1, singleEvent);
  TH2F * hModD_nhits = (TH2F*)moduleHistogram(false, "nHits", nPerMod * .85, nPerMod * 1.1, singleEvent);
  TH2F * hChanU_nhits = (TH2F*)channelHistogram(true, "nHits", nPerFiber * .25, nPerFiber * 1.1, singleEvent);
  TH2F * hChanD_nhits = (TH2F*)channelHistogram(false, "nHits", nPerFiber * .25, nPerFiber * 1.1, singleEvent);

  TH2F * hModU_ntriggers = (TH2F*)moduleHistogram(true, "nTriggers", nPerMod * .95, nPerMod * 1.3, singleEvent);
  TH2F * hModD_ntriggers = (TH2F*)moduleHistogram(false, "nTriggers", nPerMod * .95, nPerMod * 1.3, singleEvent);
  TH2F * hChanU_ntriggers = (TH2F*)channelHistogram(true, "nTriggers", nPerFiber * .95, nPerFiber * 1.3, singleEvent);
  TH2F * hChanD_ntriggers = (TH2F*)channelHistogram(false, "nTriggers", nPerFiber * .95, nPerFiber * 1.3, singleEvent);

  Int_t start = 0; 
  Int_t end = t1041->GetEntries();

  if (singleEvent) {
    start = ndisplay;
    end = ndisplay + 1;
  }

  for (Int_t i=start; i < end; i++) {
    t1041->GetEntry(i);
    for (Int_t j = 0; j < event->NPadeChan(); j++){
      PadeChannel pch = event->GetPadeChan(j);

      UShort_t max = pch.GetMax();
      Int_t maxTime = pch.GetPeak();
      if (max>MAXADC) continue;    // skip channels with bad adc readings (should be RARE)

      int channelID=pch.GetChannelID();   // boardID*100+channelNum in PADE
      int moduleID,fiberID;
      mapper->ChannelID2ModuleFiber(channelID,moduleID,fiberID);  // get module and fiber IDs

      float xm,ym,xf,yf;
      mapper->ModuleXY(moduleID,xm,ym);
      mapper->FiberXY(fiberID, xf, yf);
	    
      if(moduleID < 0) {
	hModU_ntriggers->Fill(xm, ym);
	hChanU_ntriggers->Fill(xf, yf);
      }
      else {
	hModD_ntriggers->Fill(xm, ym);
	hChanD_ntriggers->Fill(xf, yf);
      }
      if(max <= threshold) continue;


      if (moduleID < 0) {
	hModU->Fill(xm, ym, max);
	hModU_time->Fill(xm, ym, maxTime);
	hModU_nhits->Fill(xm, ym);

	hChanU->Fill(xf, yf, max);
	hChanU_time->Fill(xf, yf, maxTime);
	hChanU_nhits->Fill(xf, yf);
      }
      else {
	hModD->Fill(xm, ym, max);
	hModD_time->Fill(xm, ym, maxTime);
	hModD_nhits->Fill(xm, ym);

	hChanD->Fill(xf, yf, max);
	hChanD_time->Fill(xf, yf, maxTime);
	hChanD_nhits->Fill(xf, yf);
      }
      
    }

  }

  hModD->Divide(hModD_nhits);
  hModU->Divide(hModU_nhits);
  hChanD->Divide(hChanD_nhits);
  hChanU->Divide(hChanU_nhits);

  hModD_time->Divide(hModD_nhits);
  hModU_time->Divide(hModU_nhits);
  hChanD_time->Divide(hChanD_nhits);
  hChanU_time->Divide(hChanU_nhits);

  drawCalorimeterPlot("AvgPeakHeight", 
		      hModU, hModD, hChanU, hChanD,
		      t1041->GetEntries(), ndisplay);

  drawCalorimeterPlot("AvgPeakTiming",
		      hModU_time, hModD_time, hChanU_time, hChanD_time,
		      t1041->GetEntries(), ndisplay);

  drawCalorimeterPlot("NHits", 
		      hModU_nhits, hModD_nhits, hChanU_nhits, hChanD_nhits,
		      t1041->GetEntries(), ndisplay);

  drawCalorimeterPlot("NTriggers",
		      hModU_ntriggers, hModD_ntriggers, hChanU_ntriggers, hChanD_ntriggers,
		      t1041->GetEntries(), ndisplay);

}
int main( int argc, const char* argv[] ){

  // List of arguments:
  // 0: The executable itself
  // 1: The number of times JetMET is smeared (not smeared if equal to 1)
  // 2: The scale and type of JES shift (if fabs(x) < 0.5, shift by eta, else absolute

// fixme: Depracated
   float JES_JetMET = 1.0;

  string xmlFileName = string ("./MyMassAnalysis.xml");

  for (int i=1;i<argc;++i) {
    if (strncmp(argv[i],"-c",2)==0) xmlFileName = string(argv[i+1]);
    if (strncmp(argv[i],"-h",2)==0) {
      cout << " -c xm_config_file\n";
      exit(1);
    }
  }

  cout<<"#########################"<<endl;
  cout<<"Beginning of the program"<<endl;
  cout<<"#########################"<<endl;

  //////////////////////
  //Global variables
  //////////////////////

  // GEN
  TH1F * histoGenTopRapidity1 = new TH1F("GenTopRapidity1", "GenTopRapidity1", 100, -5, 5);
  TH1F * histoGenTopRapidity2 = new TH1F("GenTopRapidity2", "GenTopRapidity2", 100, -5, 5);
  TH1F * histoGenTopMass1 = new TH1F("GenTopMass1", "GenTopMass1", 200, 0, 200);
  TH1F * histoGenTopMass2 = new TH1F("GenTopMass2", "GenTopMass2", 200, 0, 200);
  TH2F * histoGenTopMass1VsTopMass2 = new TH2F("GenTopMass1VsTopMass2", "GenTopMass1VsTopMass2", 200, 0, 200, 200, 0, 200);
  TH1F * histoGenDelta_y = new TH1F("GenDelta_y", "GenDelta_y", 400, -2, 2);
  TH1F * histoGenTTRapidity = new TH1F("GenTTRapidity", "GenTTRapidity", 500, -2.5, 2.5);
  TH1F * histoGenTTPt = new TH1F("GenTTPt", "GenTTPt", 250, 0, 250);
  TH1F * histoGenTTMass = new TH1F("GenTTMass", "GenTTMass", 100, 0, 1000);

  TH2F * histoGenDelta_yVsTTRapidity = new TH2F("GenDelta_yVsTTRapidity", "GenDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5);
  TH2F * histoGenDelta_yVsTTPt = new TH2F("GenDelta_yVsTTPt", "GenDelta_yVsTTPt", 10, -2, 2, 5, 0, 250);
  TH2F * histoGenDelta_yVsTTMass = new TH2F("GenDelta_yVsTTMass", "GenDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000);
  TH1F * histoGenN_plusTTRapidity = new TH1F("GenN_plusTTRapidity", "GenN_plusTTRapidity", 20, -2.5, 2.5);
  histoGenN_plusTTRapidity->Sumw2();
  TH1F * histoGenN_plusTTPt = new TH1F("GenN_plusTTPt", "GenN_plusTTPt", 20, 0, 250);
  histoGenN_plusTTPt->Sumw2();
  TH1F * histoGenN_plusTTMass = new TH1F("GenN_plusTTMass", "GenN_plusTTMass", 20, 0, 1000);
  histoGenN_plusTTMass->Sumw2();
  TH1F * histoGenN_minusTTRapidity = new TH1F("GenN_minusTTRapidity", "GenN_minusTTRapidity", 20, -2.5, 2.5);
  histoGenN_minusTTRapidity->Sumw2();
  TH1F * histoGenN_minusTTPt = new TH1F("GenN_minusTTPt", "GenN_minusTTPt", 20, 0, 250);
  histoGenN_minusTTPt->Sumw2();
  TH1F * histoGenN_minusTTMass = new TH1F("GenN_minusTTMass", "GenN_minusTTMass", 20, 0, 1000);
  histoGenN_minusTTMass->Sumw2();
  TH1F * histoGenN_plusMinusN_minusTTRapidity = new TH1F("GenN_plusMinusN_minusTTRapidity", "GenN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5);
  histoGenN_plusMinusN_minusTTRapidity->Sumw2();
  TH1F * histoGenN_plusPlusN_minusTTRapidity = new TH1F("GenN_plusPlusN_minusTTRapidity", "GenN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5);
  histoGenN_plusPlusN_minusTTRapidity->Sumw2();
  TH1F * histoGenN_plusMinusN_minusTTPt = new TH1F("GenN_plusMinusN_minusTTPt", "GenN_plusMinusN_minusTTPt", 20, 0, 250);
  histoGenN_plusMinusN_minusTTPt->Sumw2();
  TH1F * histoGenN_plusPlusN_minusTTPt = new TH1F("GenN_plusPlusN_minusTTPt", "GenN_plusPlusN_minusTTPt", 20, 0, 250);
  histoGenN_plusPlusN_minusTTPt->Sumw2();
  TH1F * histoGenN_plusMinusN_minusTTMass = new TH1F("GenN_plusMinusN_minusTTMass", "GenN_plusMinusN_minusTTMass", 20, 0, 1000);
  histoGenN_plusMinusN_minusTTMass->Sumw2();
  TH1F * histoGenN_plusPlusN_minusTTMass = new TH1F("GenN_plusPlusN_minusTTMass", "GenN_plusPlusN_minusTTMass", 20, 0, 1000);
  histoGenN_plusPlusN_minusTTMass->Sumw2();
  TH1F * histoGenA_cTTRapidity = new TH1F("GenA_cTTRapidity", "GenA_cTTRapidity", 20, -2.5, 2.5);
  histoGenA_cTTRapidity->Sumw2();
  TH1F * histoGenA_cTTPt = new TH1F("GenA_cTTPt", "GenA_cTTPt", 20, 0, 250);
  histoGenA_cTTPt->Sumw2();
  TH1F * histoGenA_cTTMass = new TH1F("GenA_cTTMass", "GenA_cTTMass", 20, 0, 1000);
  histoGenA_cTTMass->Sumw2();
  // Fine binning
  TH2F * histoFineBinning_GenDelta_yVsTTRapidity = new TH2F("FineBinning_GenDelta_yVsTTRapidity", "FineBinning_GenDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5);
  TH2F * histoFineBinning_GenDelta_yVsTTPt = new TH2F("FineBinning_GenDelta_yVsTTPt", "FineBinning_GenDelta_yVsTTPt", 200, -2, 2, 250, 0, 250);
  TH2F * histoFineBinning_GenDelta_yVsTTMass = new TH2F("FineBinning_GenDelta_yVsTTMass", "FineBinning_GenDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000);
  TH1F * histoFineBinning_GenN_plusTTRapidity = new TH1F("FineBinning_GenN_plusTTRapidity", "FineBinning_GenN_plusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_GenN_plusTTRapidity->Sumw2();
  TH1F * histoFineBinning_GenN_plusTTPt = new TH1F("FineBinning_GenN_plusTTPt", "FineBinning_GenN_plusTTPt", 250, 0, 250);
  histoFineBinning_GenN_plusTTPt->Sumw2();
  TH1F * histoFineBinning_GenN_plusTTMass = new TH1F("FineBinning_GenN_plusTTMass", "FineBinning_GenN_plusTTMass", 100, 0, 1000);
  histoFineBinning_GenN_plusTTMass->Sumw2();
  TH1F * histoFineBinning_GenN_minusTTRapidity = new TH1F("FineBinning_GenN_minusTTRapidity", "FineBinning_GenN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_GenN_minusTTRapidity->Sumw2();
  TH1F * histoFineBinning_GenN_minusTTPt = new TH1F("FineBinning_GenN_minusTTPt", "FineBinning_GenN_minusTTPt", 250, 0, 250);
  histoFineBinning_GenN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_GenN_minusTTMass = new TH1F("FineBinning_GenN_minusTTMass", "FineBinning_GenN_minusTTMass", 100, 0, 1000);
  histoFineBinning_GenN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_GenN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusMinusN_minusTTRapidity", "FineBinning_GenN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_GenN_plusMinusN_minusTTRapidity->Sumw2();
  TH1F * histoFineBinning_GenN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_GenN_plusPlusN_minusTTRapidity", "FineBinning_GenN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_GenN_plusPlusN_minusTTRapidity->Sumw2();
  TH1F * histoFineBinning_GenN_plusMinusN_minusTTPt = new TH1F("FineBinning_GenN_plusMinusN_minusTTPt", "FineBinning_GenN_plusMinusN_minusTTPt", 250, 0, 250);
  histoFineBinning_GenN_plusMinusN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_GenN_plusPlusN_minusTTPt = new TH1F("FineBinning_GenN_plusPlusN_minusTTPt", "FineBinning_GenN_plusPlusN_minusTTPt", 250, 0, 250);
  histoFineBinning_GenN_plusPlusN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_GenN_plusMinusN_minusTTMass = new TH1F("FineBinning_GenN_plusMinusN_minusTTMass", "FineBinning_GenN_plusMinusN_minusTTMass", 100, 0, 1000);
  histoFineBinning_GenN_plusMinusN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_GenN_plusPlusN_minusTTMass = new TH1F("FineBinning_GenN_plusPlusN_minusTTMass", "FineBinning_GenN_plusPlusN_minusTTMass", 100, 0, 1000);
  histoFineBinning_GenN_plusPlusN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_GenA_cTTRapidity = new TH1F("FineBinning_GenA_cTTRapidity", "FineBinning_GenA_cTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_GenA_cTTRapidity->Sumw2();
  TH1F * histoFineBinning_GenA_cTTPt = new TH1F("FineBinning_GenA_cTTPt", "FineBinning_GenA_cTTPt", 250, 0, 250);
  histoFineBinning_GenA_cTTPt->Sumw2();
  TH1F * histoFineBinning_GenA_cTTMass = new TH1F("FineBinning_GenA_cTTMass", "FineBinning_GenA_cTTMass", 100, 0, 1000);
  histoFineBinning_GenA_cTTMass->Sumw2();


  // RECO
  TH1F * histoRecoTopRapidity1 = new TH1F("RecoTopRapidity1", "RecoTopRapidity1", 100, -5, 5);
  TH1F * histoRecoTopRapidity2 = new TH1F("RecoTopRapidity2", "RecoTopRapidity2", 100, -5, 5);
  TH1F * histoRecoLeptonRapidity1 = new TH1F("RecoLeptonRapidity1", "RecoLeptonRapidity1", 100, -5, 5);
  TH1F * histoRecoLeptonRapidity2 = new TH1F("RecoLeptonRapidity2", "RecoLeptonRapidity2", 100, -5, 5);
  TH1F * histoRecoTopMass1 = new TH1F("RecoTopMass1", "RecoTopMass1", 300, 0, 300);
  TH1F * histoRecoTopMass2 = new TH1F("RecoTopMass2", "RecoTopMass2", 300, 0, 300);
  TH2F * histoRecoTopMass1VsTopMass2 = new TH2F("RecoTopMass1VsTopMass2", "RecoTopMass1VsTopMass2", 300, 0, 300, 300, 0, 300);
  TH1F * histoRecoDelta_y = new TH1F("RecoDelta_y", "RecoDelta_y", 400, -2, 2);
  TH1F * histoRecoTTRapidity = new TH1F("RecoTTRapidity", "RecoTTRapidity", 500, -2.5, 2.5);
  TH1F * histoRecoTTPt = new TH1F("RecoTTPt", "RecoTTPt", 250, 0, 250);
  TH1F * histoRecoTTMass = new TH1F("RecoTTMass", "RecoTTMass", 100, 0, 1000);

  TH2F * histoRecoDelta_yVsTTRapidity = new TH2F("RecoDelta_yVsTTRapidity", "RecoDelta_yVsTTRapidity", 10, -2, 2, 5, -2.5, 2.5);
  TH2F * histoRecoDelta_yVsTTPt = new TH2F("RecoDelta_yVsTTPt", "RecoDelta_yVsTTPt", 10, -2, 2, 5, 0, 250);
  TH2F * histoRecoDelta_yVsTTMass = new TH2F("RecoDelta_yVsTTMass", "RecoDelta_yVsTTMass", 10, -2, 2, 5, 0, 1000);
  TH1F * histoRecoN_plusTTRapidity = new TH1F("RecoN_plusTTRapidity", "RecoN_plusTTRapidity", 20, -2.5, 2.5);
  histoRecoN_plusTTRapidity->Sumw2();
  TH1F * histoRecoN_plusTTPt = new TH1F("RecoN_plusTTPt", "RecoN_plusTTPt", 20, 0, 250);
  histoRecoN_plusTTPt->Sumw2();
  TH1F * histoRecoN_plusTTMass = new TH1F("RecoN_plusTTMass", "RecoN_plusTTMass", 20, 0, 1000);
  histoRecoN_plusTTMass->Sumw2();
  TH1F * histoRecoN_minusTTRapidity = new TH1F("RecoN_minusTTRapidity", "RecoN_minusTTRapidity", 20, -2.5, 2.5);
  histoRecoN_minusTTRapidity->Sumw2();
  TH1F * histoRecoN_minusTTPt = new TH1F("RecoN_minusTTPt", "RecoN_minusTTPt", 20, 0, 250);
  histoRecoN_minusTTPt->Sumw2();
  TH1F * histoRecoN_minusTTMass = new TH1F("RecoN_minusTTMass", "RecoN_minusTTMass", 20, 0, 1000);
  histoRecoN_minusTTMass->Sumw2();
  TH1F * histoRecoN_plusMinusN_minusTTRapidity = new TH1F("RecoN_plusMinusN_minusTTRapidity", "RecoN_plusMinusN_minusTTRapidity", 20, -2.5, 2.5);
  histoRecoN_plusMinusN_minusTTRapidity->Sumw2();
  TH1F * histoRecoN_plusPlusN_minusTTRapidity = new TH1F("RecoN_plusPlusN_minusTTRapidity", "RecoN_plusPlusN_minusTTRapidity", 20, -2.5, 2.5);
  histoRecoN_plusPlusN_minusTTRapidity->Sumw2();
  TH1F * histoRecoN_plusMinusN_minusTTPt = new TH1F("RecoN_plusMinusN_minusTTPt", "RecoN_plusMinusN_minusTTPt", 20, 0, 250);
  histoRecoN_plusMinusN_minusTTPt->Sumw2();
  TH1F * histoRecoN_plusPlusN_minusTTPt = new TH1F("RecoN_plusPlusN_minusTTPt", "RecoN_plusPlusN_minusTTPt", 20, 0, 250);
  histoRecoN_plusPlusN_minusTTPt->Sumw2();
  TH1F * histoRecoN_plusMinusN_minusTTMass = new TH1F("RecoN_plusMinusN_minusTTMass", "RecoN_plusMinusN_minusTTMass", 20, 0, 1000);
  histoRecoN_plusMinusN_minusTTMass->Sumw2();
  TH1F * histoRecoN_plusPlusN_minusTTMass = new TH1F("RecoN_plusPlusN_minusTTMass", "RecoN_plusPlusN_minusTTMass", 20, 0, 1000);
  histoRecoN_plusPlusN_minusTTMass->Sumw2();
  TH1F * histoRecoA_cTTRapidity = new TH1F("RecoA_cTTRapidity", "RecoA_cTTRapidity", 20, -2.5, 2.5);
  histoRecoA_cTTRapidity->Sumw2();
  TH1F * histoRecoA_cTTPt = new TH1F("RecoA_cTTPt", "RecoA_cTTPt", 20, 0, 250);
  histoRecoA_cTTPt->Sumw2();
  TH1F * histoRecoA_cTTMass = new TH1F("RecoA_cTTMass", "RecoA_cTTMass", 20, 0, 1000);
  histoRecoA_cTTMass->Sumw2();
  // Fine binning
  TH2F * histoFineBinning_RecoDelta_yVsTTRapidity = new TH2F("FineBinning_RecoDelta_yVsTTRapidity", "FineBinning_RecoDelta_yVsTTRapidity", 200, -2, 2, 500, -2.5, 2.5);
  TH2F * histoFineBinning_RecoDelta_yVsTTPt = new TH2F("FineBinning_RecoDelta_yVsTTPt", "FineBinning_RecoDelta_yVsTTPt", 200, -2, 2, 250, 0, 250);
  TH2F * histoFineBinning_RecoDelta_yVsTTMass = new TH2F("FineBinning_RecoDelta_yVsTTMass", "FineBinning_RecoDelta_yVsTTMass", 200, -2, 2, 100, 0, 1000);
  TH1F * histoFineBinning_RecoN_plusTTRapidity = new TH1F("FineBinning_RecoN_plusTTRapidity", "FineBinning_RecoN_plusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_RecoN_plusTTRapidity->Sumw2();
  TH1F * histoFineBinning_RecoN_plusTTPt = new TH1F("FineBinning_RecoN_plusTTPt", "FineBinning_RecoN_plusTTPt", 250, 0, 250);
  histoFineBinning_RecoN_plusTTPt->Sumw2();
  TH1F * histoFineBinning_RecoN_plusTTMass = new TH1F("FineBinning_RecoN_plusTTMass", "FineBinning_RecoN_plusTTMass", 100, 0, 1000);
  histoFineBinning_RecoN_plusTTMass->Sumw2();
  TH1F * histoFineBinning_RecoN_minusTTRapidity = new TH1F("FineBinning_RecoN_minusTTRapidity", "FineBinning_RecoN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_RecoN_minusTTRapidity->Sumw2();
  TH1F * histoFineBinning_RecoN_minusTTPt = new TH1F("FineBinning_RecoN_minusTTPt", "FineBinning_RecoN_minusTTPt", 250, 0, 250);
  histoFineBinning_RecoN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_RecoN_minusTTMass = new TH1F("FineBinning_RecoN_minusTTMass", "FineBinning_RecoN_minusTTMass", 100, 0, 1000);
  histoFineBinning_RecoN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_RecoN_plusMinusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusMinusN_minusTTRapidity", "FineBinning_RecoN_plusMinusN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Sumw2();  
  TH1F * histoFineBinning_RecoN_plusPlusN_minusTTRapidity = new TH1F("FineBinning_RecoN_plusPlusN_minusTTRapidity", "FineBinning_RecoN_plusPlusN_minusTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Sumw2();
  TH1F * histoFineBinning_RecoN_plusMinusN_minusTTPt = new TH1F("FineBinning_RecoN_plusMinusN_minusTTPt", "FineBinning_RecoN_plusMinusN_minusTTPt", 250, 0, 250);
  histoFineBinning_RecoN_plusMinusN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_RecoN_plusPlusN_minusTTPt = new TH1F("FineBinning_RecoN_plusPlusN_minusTTPt", "FineBinning_RecoN_plusPlusN_minusTTPt", 250, 0, 250);
  histoFineBinning_RecoN_plusPlusN_minusTTPt->Sumw2();
  TH1F * histoFineBinning_RecoN_plusMinusN_minusTTMass = new TH1F("FineBinning_RecoN_plusMinusN_minusTTMass", "FineBinning_RecoN_plusMinusN_minusTTMass", 100, 0, 1000);
  histoFineBinning_RecoN_plusMinusN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_RecoN_plusPlusN_minusTTMass = new TH1F("FineBinning_RecoN_plusPlusN_minusTTMass", "FineBinning_RecoN_plusPlusN_minusTTMass", 100, 0, 1000);
  histoFineBinning_RecoN_plusPlusN_minusTTMass->Sumw2();
  TH1F * histoFineBinning_RecoA_cTTRapidity = new TH1F("FineBinning_RecoA_cTTRapidity", "FineBinning_RecoA_cTTRapidity", 500, -2.5, 2.5);
  histoFineBinning_RecoA_cTTRapidity->Sumw2();
  TH1F * histoFineBinning_RecoA_cTTPt = new TH1F("FineBinning_RecoA_cTTPt", "FineBinning_RecoA_cTTPt", 250, 0, 250);
  histoFineBinning_RecoA_cTTPt->Sumw2();
  TH1F * histoFineBinning_RecoA_cTTMass = new TH1F("FineBinning_RecoA_cTTMass", "FineBinning_RecoA_cTTMass", 100, 0, 1000);
  histoFineBinning_RecoA_cTTMass->Sumw2();




  // RECO vs GEN
  TH2F * histoRecoVsGenTopRapidity1 = new TH2F("RecoVsGenTopRapidity1", "RecoVsGenTopRapidity1", 100, -5, 5, 100, -5, 5);
  TH2F * histoRecoVsGenTopRapidity2 = new TH2F("RecoVsGenTopRapidity2", "RecoVsGenTopRapidity2", 100, -5, 5, 100, -5, 5);
  TH2F * histoRecoVsGenTopMass1 = new TH2F("RecoVsGenTopMass1", "RecoVsGenTopMass1", 300, 0, 300, 200, 0, 200);
  TH2F * histoRecoVsGenTopMass2 = new TH2F("RecoVsGenTopMass2", "RecoVsGenTopMass2", 300, 0, 300, 200, 0, 200);
  TH1F * histoRecoMinusGenDivGenTopRapidity1 = new TH1F("RecoMinusGenDivGenTopRapidity1", "RecoMinusGenDivGenTopRapidity1", 100, -3, 3);
  TH1F * histoRecoMinusGenDivGenTopRapidity2 = new TH1F("RecoMinusGenDivGenTopRapidity2", "RecoMinusGenDivGenTopRapidity2", 100, -3, 3);
  TH1F * histoRecoMinusGenDivGenLeptonRapidity1 = new TH1F("RecoMinusGenDivGenLeptonRapidity1", "RecoMinusGenDivGenLeptonRapidity1", 100, -3, 3);
  TH1F * histoRecoMinusGenDivGenLeptonRapidity2 = new TH1F("RecoMinusGenDivGenLeptonRapidity2", "RecoMinusGenDivGenLeptonRapidity2", 100, -3, 3);
  TH1F * histoRecoMinusGenDivGenTopMass1 = new TH1F("RecoMinusGenDivGenTopMass1", "RecoMinusGenDivGenTopMass1", 100, -3, 3);
  TH1F * histoRecoMinusGenDivGenTopMass2 = new TH1F("RecoMinusGenDivGenTopMass2", "RecoMinusGenDivGenTopMass2", 100, -3, 3);

  TH2F * histoFineBinning_RecoVsGenDelta_y = new TH2F("FineBinning_RecoVsGenDelta_y", "FineBinning_RecoVsGenDelta_y", 400, -2, 2, 400, -2, 2); // Migration Matrix
  TH2F * histoRecoVsGenDelta_y = new TH2F("RecoVsGenDelta_y", "RecoVsGenDelta_y", 8, -2, 2, 16, -2, 2); // Migration Matrix
  TH1F * histoRecoMinusGenDivGenDelta_y = new TH1F("RecoMinusGenDivGenDelta_y", "RecoMinusGenDivGenDelta_y", 100, -3, 3);

  TH2F * histoRecoVsGenTTRapidity = new TH2F("RecoVsGenTTRapidity", "RecoVsGenTTRapidity", 500, -2.5, 2.5, 500, -2.5, 2.5);
  TH1F * histoRecoMinusGenDivGenTTRapidity = new TH1F("RecoMinusGenDivGenTTRapidity", "RecoMinusGenDivGenTTRapidity", 100, -3, 3);
  TH2F * histoRecoVsGenTTPt = new TH2F("RecoVsGenTTPt", "RecoVsGenTTPt", 250, 0, 250, 250, 0, 250);
  TH1F * histoRecoMinusGenDivGenTTPt = new TH1F("RecoMinusGenDivGenTTPt", "RecoMinusGenDivGenTTPt", 100, -3, 3);
  TH2F * histoRecoVsGenTTMass = new TH2F("RecoVsGenTTMass", "RecoVsGenTTMass", 100, 0, 1000, 100, 0, 1000);
  TH1F * histoRecoMinusGenDivGenTTMass = new TH1F("RecoMinusGenDivGenTTMass", "RecoMinusGenDivGenTTMass", 100, -3, 3);

  TH1F * histoDelta_yEfficiencyN = new TH1F("Delta_yEfficiencyN", "Delta_yEfficiencyN", 10, -2, 2);
  TH1F * histoDelta_yEfficiencyD = new TH1F("Delta_yEfficiencyD", "Delta_yEfficiencyD", 10, -2, 2);
  TH1F * histoDelta_yEfficiency = new TH1F("Delta_yEfficiency", "Delta_yEfficiency", 10, -2, 2);

  TH2F * histoDelta_yVsTTRapidityEfficiency = new TH2F("Delta_yVsTTRapidityEfficiency", "Delta_yVsTTRapidityEfficiency", 10, -2, 2, 5, -2.5, 2.5);
  TH2F * histoDelta_yVsTTPtEfficiency = new TH2F("Delta_yVsTTPtEfficiency", "Delta_yVsTTPtEfficiency", 10, -2, 2, 5, 0, 250);
  TH2F * histoDelta_yVsTTMassEfficiency = new TH2F("Delta_yVsTTMassEfficiency", "Delta_yVsTTMassEfficiency", 10, -2, 2, 5, 0, 1000);
  // Fine binning
  TH1F * histoFineBinning_Delta_yEfficiencyN = new TH1F("FineBinning_Delta_yEfficiencyN", "FineBinning_Delta_yEfficiencyN", 200, -2, 2);
  TH1F * histoFineBinning_Delta_yEfficiencyD = new TH1F("FineBinning_Delta_yEfficiencyD", "FineBinning_Delta_yEfficiencyD", 200, -2, 2);
  TH1F * histoFineBinning_Delta_yEfficiency = new TH1F("FineBinning_Delta_yEfficiency", "FineBinning_Delta_yEfficiency", 200, -2, 2);

  TH2F * histoFineBinning_Delta_yVsTTRapidityEfficiency = new TH2F("FineBinning_Delta_yVsTTRapidityEfficiency", "FineBinning_Delta_yVsTTRapidityEfficiency", 200, -2, 2, 500, -2.5, 2.5);
  TH2F * histoFineBinning_Delta_yVsTTPtEfficiency = new TH2F("FineBinning_Delta_yVsTTPtEfficiency", "FineBinning_Delta_yVsTTPtEfficiency", 200, -2, 2, 250, 0, 250);
  TH2F * histoFineBinning_Delta_yVsTTMassEfficiency = new TH2F("FineBinning_Delta_yVsTTMassEfficiency", "FineBinning_Delta_yVsTTMassEfficiency", 200, -2, 2, 100, 0, 1000);




  vector < Dataset > datasets;
  DiLeptonSelection sel;
  float Luminosity = 0;
  // 0: MC - 1: Data - 2 Data & MC
  int DataType = 0;
  int verbosity = -1;
  
  // Analysis variables
  int step;
  //4-vectors
  vector < TLorentzVector > nu1;
  vector < TLorentzVector > nu2;
  //  TLorentzVector lvTop1_aux;
  //TLorentzVector lvTop2_aux;

  //////////////////////

  //////////////////////
  // Initialisation
  //////////////////////
  AnalysisEnvironmentLoader anaEL (xmlFileName);
  anaEL.LoadSamples (datasets); // now the list of datasets written in the xml file is known
  anaEL.LoadDiLeptonSelection (sel); // now the parameters for the selection are given to the selection
  anaEL.LoadGeneralInfo(DataType, Luminosity, verbosity );

  float weight_MC; 
  int nEvents;
  int firstEvent;
  int initialEvents;
  anaEL.LoadAnalysisInfo("Run", "firstEvent", firstEvent);
  anaEL.LoadAnalysisInfo("Run", "nEvents", nEvents);
  anaEL.LoadAnalysisInfo("Run", "initialEvents", initialEvents);
  string channelName;
  anaEL.LoadAnalysisInfo("MassAnalysis", "ChannelName", channelName);

  anaEL.LoadWeight (sel); // now the parameters for SFBweight are initialized (for b-tag!)

  //******************************************
  //Load Scale Factors for lepton efficiencies
  //******************************************
  sel.LoadElScaleFactors();
  sel.LoadMuScaleFactors();
  sel.InitJESUnc();

  bool nonskimmed = false;

  TopTree::NTEvent * event = 0;

  TFile * TupleFile = new TFile("TupleFileSkimmed_TTbarSemileptonicPowheg.root","RECREATE");
  float mttbar_rec, mttbar_gen;
  float diffysquare_rec, diffysquare_gen;
  float diffabseta_rec, diffabseta_gen;
  float weight;
  float pt_ttbar, pt_ttbar_gen;
  float pz_ttbar, pz_ttbar_gen;
  float eta_ttbar_rec, eta_ttbar_gen;
  float y_ttbar_rec, y_ttbar_gen;
  float diffabsy_rec, diffabsy_gen;

  TTree *tree = new TTree("Tuple","Tuple");
  tree->Branch("mttbar_rec",&mttbar_rec,"mttbar_rec/F");
  tree->Branch("mttbar_gen",&mttbar_gen,"mttbar_gen/F");
  tree->Branch("diffysquare_rec",&diffysquare_rec,"diffysquare_rec/F");
  tree->Branch("diffysquare_gen",&diffysquare_gen,"diffysquare_gen/F");
  tree->Branch("diffabseta_rec",&diffabseta_rec,"diffabseta_rec/F");
  tree->Branch("diffabseta_gen",&diffabseta_gen,"diffabseta_gen/F");
  tree->Branch("weight",&weight,"weight/F");
  tree->Branch("pt_ttbar",&pt_ttbar,"pt_ttbar/F");
  tree->Branch("pt_ttbar_gen",&pt_ttbar_gen,"pt_ttbar_gen/F");
  tree->Branch("pz_ttbar",&pz_ttbar,"pz_ttbar/F");
  tree->Branch("pz_ttbar_gen",&pz_ttbar_gen,"pz_ttbar_gen/F");
  tree->Branch("eta_ttbar_rec",&eta_ttbar_rec,"eta_ttbar_rec/F");
  tree->Branch("eta_ttbar_gen",&eta_ttbar_gen,"eta_ttbar_gen/F");
  tree->Branch("y_ttbar_rec",&y_ttbar_rec,"y_ttbar_rec/F");
  tree->Branch("y_ttbar_gen",&y_ttbar_gen,"y_ttbar_gen/F");
  tree->Branch("diffabsy_rec",&diffabsy_rec,"diffabsy_rec/F");
  tree->Branch("diffabsy_gen",&diffabsy_gen,"diffabsy_gen/F");

  //////////////////////
  //LOOP OVER THE DATASETS
  //////////////////////
  if(verbosity>0) {
    cout<<"#########################"<<endl;
    cout<<" Loop over the datasets  "<<endl;
    cout<<"#########################"<<endl;
  }

  float num_mttbar_eff = 0.;
  float den_mttbar_eff = 0.;

  for (unsigned int d = 0; d < datasets.size (); d++) {

    weight_MC = datasets[d].NormFactor()*Luminosity;

    if(datasets[d].isData() == true) weight_MC = 1.; cout << "isDATA" << endl;

    AMWT amwt(anaEL, datasets[d].isData());

    TString sample_name(datasets[d].Name());

    bool isData = datasets[d].isData ();
    datasets[d].eventTree ()->SetBranchAddress ("NTEvent",&event);

    cout << "Sample : " << sample_name<< endl;
    cout << "Data   : " << isData<< endl;

    unsigned int nEventsSample = (int) (datasets[d].eventTree ()->GetEntries ());
    unsigned int endEventToRun;

    if (firstEvent>nEventsSample) firstEvent = nEventsSample;
    if ((nEvents==-1)||((nEvents+firstEvent)>nEventsSample)) endEventToRun = nEventsSample;
    else endEventToRun = nEvents+firstEvent;
    cout << "Events to run: number / first / last / all: " << endEventToRun-firstEvent 
         << " / " << firstEvent << " / " << endEventToRun
         << " / " << nEventsSample << endl;

// Standard parameters for doFullSelection:

    bool applyEEScale = false; float EEScaleParam = 1.; bool applyEEResol = false; float EEResolParam = 1.;
    bool applyMEScale = false; float MEScaleParam = 1.; bool applyMEResol = false; float MEResolParam = 1.;
    bool applyMETS = false; float METScale = 1.;
    bool applyJES = false; float JESParam = 1.;
    bool applyJER = false; float JERFactor = 0.; 

    //////////////////////
    //LOOP OVER THE EVENTS
    //////////////////////

    float N_plus_reco = 0;
    float N_minus_reco = 0;

    float N_plus_gen = 0;
    float N_minus_gen = 0;

    mttbar_rec = 0;
    mttbar_gen = 0;
    diffysquare_rec = 0;
    diffysquare_gen = 0;
    diffabseta_rec = 0;
    diffabseta_gen = 0;
    weight = weight_MC;
    pt_ttbar = 0;
    pt_ttbar_gen = 0;
    pz_ttbar = 0;
    pz_ttbar_gen = 0;
    eta_ttbar_rec = 0;
    eta_ttbar_gen = 0;
    y_ttbar_rec = 0;
    y_ttbar_gen = 0;
    diffabsy_rec = 0;
    diffabsy_gen = 0;

    for (unsigned int ievt = firstEvent; ievt < endEventToRun; ievt++) {
//           for (unsigned int ievt = 0; ievt < 10; ievt++) {

      datasets[d].eventTree ()->GetEntry (ievt);

      if(ievt%1000 == 0) cout << "number of processed events " << ievt << endl;
      if (verbosity >= 1) cout << "Event : "<< event->runNb<<" , " << event->lumiblock <<" , " << event->eventNb<<endl;

      if(!(event->TMEME == 10010 || event->TMEME == 10001 || event->TMEME == 1 || event->TMEME == 10 || event->TMEME == 10000 || event->TMEME == 11000 || event->TMEME == 10100 )) continue;

      string candType;
      vector<NTElectron> candElec;
      vector<NTMuon> candMuon;


      //Load event for the selection
      sel.LoadEvent(event);

      int finalCut = sel.doFullSelection(&(datasets[d]), channelName, false, /*print*/ verbosity,
	false, false, -1., -1., applyJES,  JESParam,
	 applyEEScale,  EEScaleParam,  applyEEResol,  EEResolParam,
	 applyMEScale,  MEScaleParam,  
	 applyJER,  JERFactor,  applyMETS,  METScale);




        TLorentzVector lvTop1_gen;
        TLorentzVector lvTop2_gen;
        TLorentzVector lvTop1plusTop2_gen;
        float yt_gen = 0.;
        float ytbar_gen = 0.;
        float Delta_y_gen = 0.;

        if(datasets[d].Name() == "TTJets_Sig"){


        lvTop1_gen = (event->topAndDecays)[0].p4_t_gen;
        lvTop2_gen = (event->topAndDecays)[1].p4_t_gen;
        lvTop1plusTop2_gen = lvTop1_gen + lvTop2_gen;

        /////////////////////////
        //// GENERATOR LEVEL ////
        /////////////////////////

        histoGenTopRapidity1->Fill(lvTop1_gen.Rapidity());
        histoGenTopRapidity2->Fill(lvTop2_gen.Rapidity());
        histoGenTopMass1->Fill(lvTop1_gen.M());
        histoGenTopMass2->Fill(lvTop2_gen.M());
        histoGenTopMass1VsTopMass2->Fill(lvTop1_gen.M(),lvTop2_gen.M());

        yt_gen = lvTop1_gen.Rapidity();
        if(yt_gen<0.) yt_gen = (-1)*yt_gen;
        ytbar_gen = lvTop2_gen.Rapidity();
        if(ytbar_gen<0.) ytbar_gen = (-1)*ytbar_gen;
        Delta_y_gen = yt_gen - ytbar_gen;
	//        cout << "Delta_y_gen:" << Delta_y_gen << endl;
        histoGenDelta_y->Fill(Delta_y_gen);
        histoDelta_yEfficiencyD->Fill(Delta_y_gen);
        histoFineBinning_Delta_yEfficiencyD->Fill(Delta_y_gen);

        if(Delta_y_gen>0.){
          N_plus_gen++;
          histoGenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
          histoGenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp());
          histoGenN_plusTTMass->Fill(lvTop1plusTop2_gen.M());
          histoFineBinning_GenN_plusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
          histoFineBinning_GenN_plusTTPt->Fill(lvTop1plusTop2_gen.Perp());
          histoFineBinning_GenN_plusTTMass->Fill(lvTop1plusTop2_gen.M());
	}

        if(Delta_y_gen<0.){
          N_minus_gen++;
          histoGenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
          histoGenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp());
          histoGenN_minusTTMass->Fill(lvTop1plusTop2_gen.M());
          histoFineBinning_GenN_minusTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
          histoFineBinning_GenN_minusTTPt->Fill(lvTop1plusTop2_gen.Perp());
          histoFineBinning_GenN_minusTTMass->Fill(lvTop1plusTop2_gen.M());

	}

        histoGenTTRapidity->Fill(lvTop1plusTop2_gen.Rapidity());
        histoGenTTPt->Fill(lvTop1plusTop2_gen.Perp());
        histoGenTTMass->Fill(lvTop1plusTop2_gen.M());
        histoGenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity());
        histoGenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp());
        histoGenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M());

        histoFineBinning_GenDelta_yVsTTRapidity->Fill(Delta_y_gen, lvTop1plusTop2_gen.Rapidity());
        histoFineBinning_GenDelta_yVsTTPt->Fill(Delta_y_gen, lvTop1plusTop2_gen.Perp());
        histoFineBinning_GenDelta_yVsTTMass->Fill(Delta_y_gen, lvTop1plusTop2_gen.M());


        if(nonskimmed == true){
         mttbar_gen = lvTop1plusTop2_gen.M();
         diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen;
         diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta());
         pt_ttbar_gen = lvTop1plusTop2_gen.Perp();
         pz_ttbar_gen = lvTop1plusTop2_gen.Pz();
         eta_ttbar_gen = lvTop1plusTop2_gen.Eta();
         y_ttbar_gen = lvTop1plusTop2_gen.Rapidity();
         diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity());
	}

	}

      if (finalCut >6) {

        if(nonskimmed == false){
         if(datasets[d].Name() == "TTJets_Sig"){
         mttbar_gen = lvTop1plusTop2_gen.M();
         diffysquare_gen = yt_gen*yt_gen - ytbar_gen*ytbar_gen;
         diffabseta_gen = fabs(lvTop1_gen.Eta()) - fabs(lvTop2_gen.Eta());
         pt_ttbar_gen = lvTop1plusTop2_gen.Perp();
         pz_ttbar_gen = lvTop1plusTop2_gen.Pz();
         eta_ttbar_gen = lvTop1plusTop2_gen.Eta();
         y_ttbar_gen = lvTop1plusTop2_gen.Rapidity();
         diffabsy_gen = fabs(lvTop1_gen.Rapidity()) - fabs(lvTop2_gen.Rapidity());
	 }
	}

        sel.GetLeptonPair(candMuon, candElec, candType);

        for(unsigned int i=0; i<candMuon.size(); i++){
          if(candMuon[i].Charge == +1) histoRecoLeptonRapidity1->Fill(candMuon[i].p4.Rapidity());
          if(candMuon[i].Charge == -1) histoRecoLeptonRapidity2->Fill(candMuon[i].p4.Rapidity());
	}

        for(unsigned int j=0; j<candElec.size(); j++){
          if(candElec[j].Charge == +1) histoRecoLeptonRapidity1->Fill(candElec[j].p4.Rapidity());
          if(candElec[j].Charge == -1) histoRecoLeptonRapidity2->Fill(candElec[j].p4.Rapidity());
	}



        TLorentzVector lvTop1_reco;
        TLorentzVector lvTop2_reco;
        TLorentzVector lvTop1plusTop2_reco;


        TopMassVariables * tmv = amwt.findMass(sel, lvTop1_reco, lvTop2_reco);
        lvTop1plusTop2_reco = lvTop1_reco + lvTop2_reco;



        ////////////////////
        /// RECO LEVEL /////
        ////////////////////

        histoRecoTopRapidity1->Fill(lvTop1_reco.Rapidity());
        histoRecoTopRapidity2->Fill(lvTop2_reco.Rapidity());
        histoRecoTopMass1->Fill(lvTop1_reco.M());
        histoRecoTopMass2->Fill(lvTop2_reco.M());
        histoRecoTopMass1VsTopMass2->Fill(lvTop1_reco.M(),lvTop2_reco.M());

        float yt_reco = lvTop1_reco.Rapidity();
        if(yt_reco<0.) yt_reco = (-1)*yt_reco;
        float ytbar_reco = lvTop2_reco.Rapidity();
        if(ytbar_reco<0.) ytbar_reco = (-1)*ytbar_reco;
        float Delta_y_reco = yt_reco - ytbar_reco;
	//        cout << "Delta_y_reco:" << Delta_y_reco << endl;
        histoRecoDelta_y->Fill(Delta_y_reco);
        histoDelta_yEfficiencyN->Fill(Delta_y_reco);
        histoFineBinning_Delta_yEfficiencyN->Fill(Delta_y_reco);

        if(Delta_y_reco>0.){
          N_plus_reco++;
          histoRecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
          histoRecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp());
          histoRecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M());
          histoFineBinning_RecoN_plusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
          histoFineBinning_RecoN_plusTTPt->Fill(lvTop1plusTop2_reco.Perp());
          histoFineBinning_RecoN_plusTTMass->Fill(lvTop1plusTop2_reco.M());
	}

        if(Delta_y_reco<0.){
          N_minus_reco++;
          histoRecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
          histoRecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp());
          histoRecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M());
          histoFineBinning_RecoN_minusTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
          histoFineBinning_RecoN_minusTTPt->Fill(lvTop1plusTop2_reco.Perp());
          histoFineBinning_RecoN_minusTTMass->Fill(lvTop1plusTop2_reco.M());
	}

        histoRecoTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity());
        histoRecoTTPt->Fill(lvTop1plusTop2_reco.Perp());
        histoRecoTTMass->Fill(lvTop1plusTop2_reco.M());
        histoRecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity());
        histoRecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp());
        histoRecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M());

        histoFineBinning_RecoDelta_yVsTTRapidity->Fill(Delta_y_reco, lvTop1plusTop2_reco.Rapidity());
        histoFineBinning_RecoDelta_yVsTTPt->Fill(Delta_y_reco, lvTop1plusTop2_reco.Perp());
        histoFineBinning_RecoDelta_yVsTTMass->Fill(Delta_y_reco, lvTop1plusTop2_reco.M());

        if(nonskimmed == false){

         mttbar_rec = lvTop1plusTop2_reco.M();
         diffysquare_rec = yt_reco*yt_reco - ytbar_reco*ytbar_reco;
         diffabseta_rec = fabs(lvTop1_reco.Eta()) - fabs(lvTop2_reco.Eta());
         pt_ttbar = lvTop1plusTop2_reco.Perp();
         pz_ttbar = lvTop1plusTop2_reco.Pz();
         eta_ttbar_rec = lvTop1plusTop2_reco.Eta();
         y_ttbar_rec = lvTop1plusTop2_reco.Rapidity();
         diffabsy_rec = fabs(lvTop1_reco.Rapidity()) - fabs(lvTop2_reco.Rapidity());

	}

        ////////////////////////
        // RECO VS GEN LEVEL ///
        ////////////////////////
        if(datasets[d].Name() == "TTJets_Sig"){
 
        histoRecoVsGenTopRapidity1->Fill(lvTop1_reco.Rapidity(), lvTop1_gen.Rapidity());
        histoRecoVsGenTopRapidity2->Fill(lvTop2_reco.Rapidity(), lvTop2_gen.Rapidity());
        histoRecoVsGenTopMass1->Fill(lvTop1_reco.M(), lvTop1_gen.M());
        histoRecoVsGenTopMass2->Fill(lvTop2_reco.M(), lvTop2_gen.M());
	histoRecoMinusGenDivGenTopRapidity1->Fill((lvTop1_reco.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
        histoRecoMinusGenDivGenTopRapidity2->Fill((lvTop2_reco.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());

        for(unsigned int i=0; i<candMuon.size(); i++){
          if(candMuon[i].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candMuon[i].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
          if(candMuon[i].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candMuon[i].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());
	}

        for(unsigned int j=0; j<candElec.size(); j++){
          if(candElec[j].Charge == +1) histoRecoMinusGenDivGenLeptonRapidity1->Fill((candElec[j].p4.Rapidity() - lvTop1_gen.Rapidity())/lvTop1_gen.Rapidity());
          if(candElec[j].Charge == -1) histoRecoMinusGenDivGenLeptonRapidity2->Fill((candElec[j].p4.Rapidity() - lvTop2_gen.Rapidity())/lvTop2_gen.Rapidity());
	}

	histoRecoMinusGenDivGenTopMass1->Fill((lvTop1_reco.M() - lvTop1_gen.M())/lvTop1_gen.M());
        histoRecoMinusGenDivGenTopMass2->Fill((lvTop2_reco.M() - lvTop2_gen.M())/lvTop2_gen.M());

        histoRecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen);
        histoFineBinning_RecoVsGenDelta_y->Fill(Delta_y_reco, Delta_y_gen);
        histoRecoMinusGenDivGenDelta_y->Fill((Delta_y_reco - Delta_y_gen)/Delta_y_gen);

        histoRecoVsGenTTRapidity->Fill(lvTop1plusTop2_reco.Rapidity(),lvTop1plusTop2_gen.Rapidity());
        histoRecoMinusGenDivGenTTRapidity->Fill((lvTop1plusTop2_reco.Rapidity() - lvTop1plusTop2_gen.Rapidity())/lvTop1plusTop2_gen.Rapidity());
        histoRecoVsGenTTPt->Fill(lvTop1plusTop2_reco.Perp(),lvTop1plusTop2_gen.Perp());
        histoRecoMinusGenDivGenTTPt->Fill((lvTop1plusTop2_reco.Perp() - lvTop1plusTop2_gen.Perp())/lvTop1plusTop2_gen.Perp());
        histoRecoVsGenTTMass->Fill(lvTop1plusTop2_reco.M(),lvTop1plusTop2_gen.M());
        histoRecoMinusGenDivGenTTMass->Fill((lvTop1plusTop2_reco.M() - lvTop1plusTop2_gen.M())/lvTop1plusTop2_gen.M());

	}

	//	tmv->printAll();
	delete tmv;
       if(nonskimmed == false && mttbar_rec > 60.){ tree->Fill(); num_mttbar_eff += weight_MC;}
       if(nonskimmed == false) den_mttbar_eff += weight_MC;
      }

      if(nonskimmed == true) tree->Fill();

    }  // end of loop over evts

    float A_C_reco = (N_plus_reco - N_minus_reco)/(N_plus_reco + N_minus_reco);
    float A_C_gen = (N_plus_gen - N_minus_gen)/(N_plus_gen + N_minus_gen);

    cout << "A_C_gen:" << A_C_gen << endl;
    cout << "A_C_reco:" << A_C_reco << endl;

    histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_plusTTRapidity);
    histoGenN_plusMinusN_minusTTRapidity->Add(histoGenN_minusTTRapidity,-1);
    histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_plusTTRapidity);
    histoGenN_plusPlusN_minusTTRapidity->Add(histoGenN_minusTTRapidity);

    histoGenA_cTTRapidity->Divide(histoGenN_plusMinusN_minusTTRapidity, histoGenN_plusPlusN_minusTTRapidity);

    histoGenN_plusMinusN_minusTTPt->Add(histoGenN_plusTTPt);
    histoGenN_plusMinusN_minusTTPt->Add(histoGenN_minusTTPt,-1);
    histoGenN_plusPlusN_minusTTPt->Add(histoGenN_plusTTPt);
    histoGenN_plusPlusN_minusTTPt->Add(histoGenN_minusTTPt);

    histoGenA_cTTPt->Divide(histoGenN_plusMinusN_minusTTPt, histoGenN_plusPlusN_minusTTPt);

    histoGenN_plusMinusN_minusTTMass->Add(histoGenN_plusTTMass);
    histoGenN_plusMinusN_minusTTMass->Add(histoGenN_minusTTMass,-1);
    histoGenN_plusPlusN_minusTTMass->Add(histoGenN_plusTTMass);
    histoGenN_plusPlusN_minusTTMass->Add(histoGenN_minusTTMass);

    histoGenA_cTTMass->Divide(histoGenN_plusMinusN_minusTTMass, histoGenN_plusPlusN_minusTTMass);

    histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity);
    histoRecoN_plusMinusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity,-1);
    histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_plusTTRapidity);
    histoRecoN_plusPlusN_minusTTRapidity->Add(histoRecoN_minusTTRapidity);

    histoRecoA_cTTRapidity->Divide(histoRecoN_plusMinusN_minusTTRapidity, histoRecoN_plusPlusN_minusTTRapidity);

    histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_plusTTPt);
    histoRecoN_plusMinusN_minusTTPt->Add(histoRecoN_minusTTPt,-1);
    histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_plusTTPt);
    histoRecoN_plusPlusN_minusTTPt->Add(histoRecoN_minusTTPt);

    histoRecoA_cTTPt->Divide(histoRecoN_plusMinusN_minusTTPt, histoRecoN_plusPlusN_minusTTPt);

    histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_plusTTMass);
    histoRecoN_plusMinusN_minusTTMass->Add(histoRecoN_minusTTMass,-1);
    histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_plusTTMass);
    histoRecoN_plusPlusN_minusTTMass->Add(histoRecoN_minusTTMass);

    histoRecoA_cTTMass->Divide(histoRecoN_plusMinusN_minusTTMass, histoRecoN_plusPlusN_minusTTMass);





    histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity);
    histoFineBinning_GenN_plusMinusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity,-1);
    histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_plusTTRapidity);
    histoFineBinning_GenN_plusPlusN_minusTTRapidity->Add(histoFineBinning_GenN_minusTTRapidity);

    histoFineBinning_GenA_cTTRapidity->Divide(histoFineBinning_GenN_plusMinusN_minusTTRapidity, histoFineBinning_GenN_plusPlusN_minusTTRapidity);

    histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt);
    histoFineBinning_GenN_plusMinusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt,-1);
    histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_plusTTPt);
    histoFineBinning_GenN_plusPlusN_minusTTPt->Add(histoFineBinning_GenN_minusTTPt);

    histoFineBinning_GenA_cTTPt->Divide(histoFineBinning_GenN_plusMinusN_minusTTPt, histoFineBinning_GenN_plusPlusN_minusTTPt);

    histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass);
    histoFineBinning_GenN_plusMinusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass,-1);
    histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_plusTTMass);
    histoFineBinning_GenN_plusPlusN_minusTTMass->Add(histoFineBinning_GenN_minusTTMass);

    histoFineBinning_GenA_cTTMass->Divide(histoFineBinning_GenN_plusMinusN_minusTTMass, histoFineBinning_GenN_plusPlusN_minusTTMass);

    histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity);
    histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity,-1);
    histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_plusTTRapidity);
    histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Add(histoFineBinning_RecoN_minusTTRapidity);

    histoFineBinning_RecoA_cTTRapidity->Divide(histoFineBinning_RecoN_plusMinusN_minusTTRapidity, histoFineBinning_RecoN_plusPlusN_minusTTRapidity);

    histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt);
    histoFineBinning_RecoN_plusMinusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt,-1);
    histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_plusTTPt);
    histoFineBinning_RecoN_plusPlusN_minusTTPt->Add(histoFineBinning_RecoN_minusTTPt);

    histoFineBinning_RecoA_cTTPt->Divide(histoFineBinning_RecoN_plusMinusN_minusTTPt, histoFineBinning_RecoN_plusPlusN_minusTTPt);

    histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass);
    histoFineBinning_RecoN_plusMinusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass,-1);
    histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_plusTTMass);
    histoFineBinning_RecoN_plusPlusN_minusTTMass->Add(histoFineBinning_RecoN_minusTTMass);

    histoFineBinning_RecoA_cTTMass->Divide(histoFineBinning_RecoN_plusMinusN_minusTTMass, histoFineBinning_RecoN_plusPlusN_minusTTMass);



    histoDelta_yEfficiency->Divide(histoDelta_yEfficiencyN, histoDelta_yEfficiencyD);
    histoFineBinning_Delta_yEfficiency->Divide(histoFineBinning_Delta_yEfficiencyN, histoFineBinning_Delta_yEfficiencyD);


    for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
     for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
       float value = histoRecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2);
       histoDelta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value);
       float value_fb = histoFineBinning_RecoDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTRapidity->GetBinContent(bin_index1,bin_index2);
       histoFineBinning_Delta_yVsTTRapidityEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);

     }
    }

    for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
     for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
       float value = histoRecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
       histoDelta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value);
       float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
       histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);

     }
    }


    for (unsigned int bin_index1 = 1; bin_index1 < 11; bin_index1++) {
     for (unsigned int bin_index2 = 1; bin_index2 < 6; bin_index2++) {
       float value = histoRecoDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2)/histoGenDelta_yVsTTMass->GetBinContent(bin_index1,bin_index2);
       histoDelta_yVsTTMassEfficiency->SetBinContent(bin_index1, bin_index2, value);
       float value_fb = histoFineBinning_RecoDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2)/histoFineBinning_GenDelta_yVsTTPt->GetBinContent(bin_index1,bin_index2);
       histoFineBinning_Delta_yVsTTPtEfficiency->SetBinContent(bin_index1, bin_index2, value_fb);

     }
    }






  }				// end of loop over the datasets


//  if(verbosity>0) {
    cout<<"#########################"<<endl;
    cout<<"    End of the program   "<<endl;
    cout<<"#########################"<<endl;
//  }

    tree->Print();

    TupleFile->Write();
    TupleFile->Close();


    TFile * fileCA = new TFile("ChargeAsymmetryResults_Skimmed_TTbarSemileptonicPowheg.root","RECREATE");
    //  fileCA->cd();

    // GEN
    histoGenTopRapidity1->Write();
    histoGenTopRapidity2->Write();
    histoGenTopMass1->Write();
    histoGenTopMass2->Write();
    histoGenTopMass1VsTopMass2->Write();
    histoGenDelta_y->Write();
    histoGenTTRapidity->Write();
    histoGenTTPt->Write();
    histoGenTTMass->Write();
    histoGenDelta_yVsTTRapidity->Write();
    histoGenDelta_yVsTTPt->Write();
    histoGenDelta_yVsTTMass->Write();
    histoGenN_plusTTRapidity->Write();
    histoGenN_plusTTPt->Write();
    histoGenN_plusTTMass->Write();
    histoGenN_minusTTRapidity->Write();
    histoGenN_minusTTPt->Write();
    histoGenN_minusTTMass->Write();
    histoGenN_plusMinusN_minusTTRapidity->Write();
    histoGenN_plusPlusN_minusTTRapidity->Write();
    histoGenN_plusMinusN_minusTTPt->Write();
    histoGenN_plusPlusN_minusTTPt->Write();
    histoGenN_plusMinusN_minusTTMass->Write();
    histoGenN_plusPlusN_minusTTMass->Write();
    histoGenA_cTTRapidity->Write();
    histoGenA_cTTPt->Write();
    histoGenA_cTTMass->Write();
    histoFineBinning_GenDelta_yVsTTRapidity->Write();
    histoFineBinning_GenDelta_yVsTTPt->Write();
    histoFineBinning_GenDelta_yVsTTMass->Write();
    histoFineBinning_GenN_plusTTRapidity->Write();
    histoFineBinning_GenN_plusTTPt->Write();
    histoFineBinning_GenN_plusTTMass->Write();
    histoFineBinning_GenN_minusTTRapidity->Write();
    histoFineBinning_GenN_minusTTPt->Write();
    histoFineBinning_GenN_minusTTMass->Write();
    histoFineBinning_GenN_plusMinusN_minusTTRapidity->Write();
    histoFineBinning_GenN_plusPlusN_minusTTRapidity->Write();
    histoFineBinning_GenN_plusMinusN_minusTTPt->Write();
    histoFineBinning_GenN_plusPlusN_minusTTPt->Write();
    histoFineBinning_GenN_plusMinusN_minusTTMass->Write();
    histoFineBinning_GenN_plusPlusN_minusTTMass->Write();
    histoFineBinning_GenA_cTTRapidity->Write();
    histoFineBinning_GenA_cTTPt->Write();
    histoFineBinning_GenA_cTTMass->Write(); 



    // RECO
    histoRecoTopRapidity1->Write();
    histoRecoTopRapidity2->Write();
    histoRecoLeptonRapidity1->Write();
    histoRecoLeptonRapidity2->Write();
    histoRecoTopMass1->Write();
    histoRecoTopMass2->Write();
    histoRecoTopMass1VsTopMass2->Write();
    histoRecoDelta_y->Write();
    histoRecoTTRapidity->Write();
    histoRecoTTPt->Write();
    histoRecoTTMass->Write();
    histoRecoDelta_yVsTTRapidity->Write();
    histoRecoDelta_yVsTTPt->Write();
    histoRecoDelta_yVsTTMass->Write();
    histoRecoN_plusTTRapidity->Write();
    histoRecoN_plusTTPt->Write();
    histoRecoN_plusTTMass->Write();
    histoRecoN_minusTTRapidity->Write();
    histoRecoN_minusTTPt->Write();
    histoRecoN_minusTTMass->Write();
    histoRecoN_plusMinusN_minusTTRapidity->Write();
    histoRecoN_plusPlusN_minusTTRapidity->Write();
    histoRecoN_plusMinusN_minusTTPt->Write();
    histoRecoN_plusPlusN_minusTTPt->Write();
    histoRecoN_plusMinusN_minusTTMass->Write();
    histoRecoN_plusPlusN_minusTTMass->Write();
    histoRecoA_cTTRapidity->Write();
    histoRecoA_cTTPt->Write();
    histoRecoA_cTTMass->Write();
    histoFineBinning_RecoDelta_yVsTTRapidity->Write();
    histoFineBinning_RecoDelta_yVsTTPt->Write();
    histoFineBinning_RecoDelta_yVsTTMass->Write();
    histoFineBinning_RecoN_plusTTRapidity->Write();
    histoFineBinning_RecoN_plusTTPt->Write();
    histoFineBinning_RecoN_plusTTMass->Write();
    histoFineBinning_RecoN_minusTTRapidity->Write();
    histoFineBinning_RecoN_minusTTPt->Write();
    histoFineBinning_RecoN_minusTTMass->Write();
    histoFineBinning_RecoN_plusMinusN_minusTTRapidity->Write();
    histoFineBinning_RecoN_plusPlusN_minusTTRapidity->Write();
    histoFineBinning_RecoN_plusMinusN_minusTTPt->Write();
    histoFineBinning_RecoN_plusPlusN_minusTTPt->Write();
    histoFineBinning_RecoN_plusMinusN_minusTTMass->Write();
    histoFineBinning_RecoN_plusPlusN_minusTTMass->Write();
    histoFineBinning_RecoA_cTTRapidity->Write();
    histoFineBinning_RecoA_cTTPt->Write();
    histoFineBinning_RecoA_cTTMass->Write(); 

    // RECO vs GEN
    histoRecoVsGenTopRapidity1->Write();
    histoRecoVsGenTopRapidity2->Write();
    histoRecoMinusGenDivGenLeptonRapidity1->Write();
    histoRecoMinusGenDivGenLeptonRapidity2->Write();
    histoRecoMinusGenDivGenTopRapidity1->Write();
    histoRecoMinusGenDivGenTopRapidity2->Write();
    histoRecoVsGenTopMass1->Write();
    histoRecoVsGenTopMass2->Write();
    histoRecoMinusGenDivGenTopMass1->Write();
    histoRecoMinusGenDivGenTopMass2->Write();
    histoRecoVsGenDelta_y->Write();
    histoFineBinning_RecoVsGenDelta_y->Write();
    histoRecoMinusGenDivGenDelta_y->Write();
    histoRecoVsGenTTRapidity->Write();
    histoRecoMinusGenDivGenTTRapidity->Write();
    histoRecoVsGenTTPt->Write();
    histoRecoMinusGenDivGenTTPt->Write();
    histoRecoVsGenTTMass->Write();
    histoRecoMinusGenDivGenTTMass->Write();
    histoDelta_yEfficiencyN->Write();
    histoDelta_yEfficiencyD->Write();
    histoDelta_yEfficiency->Write();
    histoDelta_yVsTTRapidityEfficiency->Write();
    histoDelta_yVsTTPtEfficiency->Write();
    histoDelta_yVsTTMassEfficiency->Write();
    histoFineBinning_Delta_yEfficiencyN->Write();
    histoFineBinning_Delta_yEfficiencyD->Write();
    histoFineBinning_Delta_yEfficiency->Write();
    histoFineBinning_Delta_yVsTTRapidityEfficiency->Write();
    histoFineBinning_Delta_yVsTTPtEfficiency->Write();
    histoFineBinning_Delta_yVsTTMassEfficiency->Write();


    //    fileCA->Write();
    fileCA->Close();
    delete fileCA;

    cout << "num_mttbar_eff = " <<  num_mttbar_eff << endl;
    cout << "den_mttbar_eff = " <<  den_mttbar_eff << endl;
    cout << "mttbar_eff = " <<  num_mttbar_eff / den_mttbar_eff << endl;

  return (0);
}
Ejemplo n.º 27
0
void dNdeta_dAu(int i){
    TFile *f = TFile::Open(Form("phhijing_dAu_%d.root",i));
    TTree *tree = (TTree*)f->Get("T");
    TBranchElement *array = (TBranchElement*)T->GetBranch("part_array");
    tree->SetMakeClass(1);
    TH1::SetDefaultSumw2(kTRUE);
    const int ncent = 3;
    TH1F* hKF = new TH1F("hKF","particle id",10000,-5000,5000);
    TH1F* hn = new TH1F("hn","Ntotal",1000,0,1000);
    TH2F* hnchntrk = new TH2F("hnchntrk","",300,0,300,100,0,100);
    TH2F* hNbinary = new TH2F("hNbinary","Nbinary",300,0,300,300,0,300);
    TH2F* hb = new TH2F("hb","bimpact",300,0,300,200,0,20);
    TH1F* hnchtotal = new TH1F("hnchtotal","Nchargetotal",500,0,500);
    TH2F* hNbinarymbtrig = new TH2F("hNbinarymbtrig","Nbinary",300,0,300,300,0,300);
    TH2F* hbmbtrig = new TH2F("hbmbtrig","bimpact",300,0,300,200,0,20);
    TH2F* hnchntrkmbtrig = new TH2F("hnchntrkmbtrig","",300,0,300,100,0,100);
    TH1F* heta = new TH1F("heta","particle eta distr",120,-6,6);
    TH1F* hy = new TH1F("hy","particle y distr",120,-6,6);
    TH1F* hy1 = new TH1F("hy1","particle y distr in |y|<1",150,-1.5,1.5);
    TH1F* hphi = new TH1F("hphi","",200,0,8);
    TH1F* hMass= new TH1F("hMass","mass distribution",500,0,5);
    TH2F* hpteta[ncent];
    TH2F* hptetambtrig[ncent];
    TH2F* hpty[ncent];
    TH2F* hptymbtrig[ncent];
    for(int icent=0;icent<ncent;icent++){
      hpteta[icent]  = new TH2F(Form("hpteta_%d",icent),"",100,0,10,120,-6,6);
      hptetambtrig[icent] = new TH2F(Form("hptetambtrig_%d",icent),"",100,0,10,120,-6,6);
      hpty[icent] = new TH2F(Form("hpty_%d",icent),"",100,0,10,120,-6,6);
      hptymbtrig[icent] = new TH2F(Form("hptymbtrig_%d",icent),"",100,0,10,120,-6,6);
    }
    
    int Nbinary;
    float b;
    float px[MAXP];
    float py[MAXP];
    float pz[MAXP];
    float E[MAXP];
    int KS[MAXP];
    int KF[MAXP];
    float M[MAXP];
    int n;
    int nPion = 0;
    int nPrim = 0;
    int nSecond = 0;
    int nPionC = 0;
    int nKaonC = 0;
    int nout=0;
    tree->SetBranchAddress("nbin",&Nbinary);
    tree->SetBranchAddress("bimpact",&b);
    tree->SetBranchAddress("part_array.fKS",&KS);
    tree->SetBranchAddress("part_array.fKF",&KF);
    tree->SetBranchAddress("part_array.fPx",&px);
    tree->SetBranchAddress("part_array.fPy",&py);
    tree->SetBranchAddress("part_array.fPz",&pz);
    tree->SetBranchAddress("part_array.fEnergy",&E);
    tree->SetBranchAddress("part_array.fMass",&M);
    array->SetAddress(&n);
    for(int ievent = 0;ievent < tree->GetEntries(); ievent++){
        int nch = 0;
        int nchtotal = 0;
        int ntrk = 0;
        int nbbcau = 0;
        int nbbcde = 0;
        tree->GetEntry(ievent);
 //       array->GetEntry(ievent);
 //       int n = array->GetNdata();
        if(n>MAXP)  {cout<<n<<"!"<<endl;  continue;}
        if(ievent%10000==0) cout<<ievent<<endl;
        for(int iparticle = 0;iparticle < n; iparticle++){
     //     if(KS[iparticle] < 1 || KS[iparticle] > 10) continue;
     //     if(iparticle>10000) cout<<KF[iparticle]<<" ";
            hKF->Fill(KF[iparticle]);
            if(KF[iparticle] == 111) nPion++;
            if(fabs(KF[iparticle]) == 211) nPionC++;
            if(fabs(KF[iparticle]) == 321) nKaonC++;
            if(fabs(KF[iparticle]) > 5000) nout++;
         //   if(KF[iparticle]!=313 && KF[iparticle]!=421 && KF[iparticle]!=311 && KF[iparticle]!d221 && KF[iparticle]!=111 && KF[iparticle]!=223 && KF[iparticle]!=333 && KF[iparticle]!=443 && KF[iparticle]!=2112 && KF[iparticle]!=3122) nch++;
            if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue;
            if(KS[iparticle]==1) nPrim++;
            if(KS[iparticle]==11) nSecond++;
            hMass->Fill(M[iparticle]);
         //   if(KS[iparticle]!=1) continue;
            float pt = sqrt(px[iparticle]**2+py[iparticle]**2);
            float theta = atan(pt/pz[iparticle]);
            if(theta<0) theta = TMath::Pi()+theta;
            float eta = -log(tan(theta/2));
            if(px[iparticle]>0){
                float phi = atan(py[iparticle]/px[iparticle]);
            if(py[iparticle]<0)
                float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            }
            else
                float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue;
            float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle]));

          if(fabs(eta)<0.35 && pt>0.2 && pt< 5.0){
              ntrk++;
          }
          if(fabs(eta)>3 && fabs(eta)<4 && pt>0.05){
            int iarm = 0;
            if (eta > 0) iarm = 1;
	    if(iarm==0){
	        nbbcau++;
	    }
	    else{
                nbbcde++;
	    }
            if(iarm==0)   nch++;
        }
          nchtotal++;
        }
        
        if(nch>21) icent=0;//0-4.6%
        else if(nch<5) icent=2; //58-100%
        else icent = 1;

        for(int iparticle = 0;iparticle < n; iparticle++){
            if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue;
            float pt = sqrt(px[iparticle]**2+py[iparticle]**2);
            float theta = atan(pt/pz[iparticle]);
            if(theta<0) theta = TMath::Pi()+theta;
            float eta = -log(tan(theta/2));
            if(px[iparticle]>0){
                float phi = atan(py[iparticle]/px[iparticle]);
            if(py[iparticle]<0)
                float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            }
            else
                float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue;
            float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle]));
            hy->Fill(y);
            heta->Fill(eta);
            if(fabs(y)<=1)
            hy1->Fill(y);

            hphi->Fill(phi);
            hpteta[icent]->Fill(pt,eta);
            hpty[icent]->Fill(pt,y);
        }
        hn->Fill(n);
        hnchtotal->Fill(nchtotal);
        hnchntrk->Fill(nch,ntrk);
        hNbinary->Fill(nch,Nbinary);
        hb->Fill(nch,b);


        if(nbbcau<1 || nbbcde<1) continue; //mb trigger
            hnchntrkmbtrig->Fill(nch,ntrk);
            hNbinarymbtrig->Fill(nch,Nbinary);
            hbmbtrig->Fill(nch,b);


        for(int iparticle = 0;iparticle < n; iparticle++){
            if(!(fabs(KF[iparticle]) == 211 || fabs(KF[iparticle]) == 213 || fabs(KF[iparticle]) == 321 || fabs(KF[iparticle]) == 323 ||fabs(KF[iparticle]) == 2212)) continue;
            float pt = sqrt(px[iparticle]**2+py[iparticle]**2);
            float theta = atan(pt/pz[iparticle]);
            if(theta<0) theta = TMath::Pi()+theta;
            float eta = -log(tan(theta/2));
            if(px[iparticle]>0){
                float phi = atan(py[iparticle]/px[iparticle]);
            if(py[iparticle]<0)
                float phi = 2*TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            }
            else
                float phi = TMath::Pi()+atan(py[iparticle]/px[iparticle]);
            if((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle])<=0) continue;
            float y = 0.5*log((E[iparticle]+pz[iparticle])/(E[iparticle]-pz[iparticle]));
            hptetambtrig[icent]->Fill(pt,eta);
            hptymbtrig[icent]->Fill(pt,y);
    }
    }
    TFile *fout = new TFile(Form("outhisto_dAu_%d.root",i),"Recreate");
    fout->cd();
    hKF->Write();
    heta->Write();
    hy->Write();
    hy1->Write();
    hphi->Write();
    for(int icent=0;icent<ncent;icent++){
    hpteta[icent]->Write();
    hpty[icent]->Write();
    hptetambtrig[icent]->Write();
    hptymbtrig[icent]->Write();
    }
    hMass->Write();
    hn->Write();
    hnchntrk->Write();
    hnchntrkmbtrig->Write();
    hnchtotal->Write();
    hNbinary->Write();
    hb->Write();
    hNbinarymbtrig->Write();
    hbmbtrig->Write();
    fout->Close();
    cout<<nPion<<"\t"<<nPionC<<"\t"<<nKaonC<<"\t"<<nout<<"\t"<<nPrim<<"\t"<<nSecond<<endl;
}
Ejemplo n.º 28
0
  Int_t GetRateXY( Int_t fillnum = 15419 ,const char* sl = "small" ){
	
	gSystem->Load("../lib/libMyCellMgr.so");
        gROOT->LoadMacro("/home/yuxip/FMS/CellScan/macros/Legal.C");
	Char_t runlist[20];
	sprintf(runlist,"fill%d.list",fillnum);
	fstream inlist(runlist,ios::in);
	if(!inlist){
		cout<<runlist<<" does not exist!!"<<endl;
		return -1;
	}	

	TH2F* 	fcmp;
	TFile* 	fcell	= 0;
	Int_t	n1 	= 0;
	Int_t	n2	= 0;
	
	Char_t outfilename[30];
	if(!strcmp(sl,"large")){
		sprintf(outfilename,"largeRateVsGcor_fill%d_n2.ps",fillnum);
		n1 = 2;
		n2 = 2;         //analysis each nstb separately
	}
	else if(!strcmp(sl,"small")){
		sprintf(outfilename,"smallRateVsGcor_fill%d_n4.ps",fillnum);
		n1 = 4;
		n2 = 4;
	}
	else{
		cout<<"invalid 2nd argument"<<endl;
		return -1;
	}
	TString outfile(outfilename);
	TString headout = outfile + "[";
	TString endout  = outfile + "]";
//	TCanvas* c1 	= new TCanvas("c1","c1",1100,1100);
	TCanvas* c1 	= new TCanvas("c1","c1",700,700);
//	c1->Divide(3,3);
//	c1->Print(headout);
	
	fstream inGcor("FmsCorr_sh.txt",ios::in);
	Int_t	iew;
	Int_t	instb;
	Int_t	ich;
	Float_t	gcorsh;
	
	Int_t	cnt	= 1;
	Int_t	cellcnt	= 0;
	Int_t	rch	= 0;
	Long_t 	runnum 	= 0;
	Char_t	cellname[30];
	Char_t	cellfile[30];
	Char_t  title[20];
	Int_t	bit	= 0;
	UChar_t status	= 0;
	Int_t	rate	= 0;
	Int_t 	Trgth	= 100;
	MyCell*	mcell	= 0;
	Float_t mycor;
	Float_t	gdiff;
//	while(inlist>>runnum){
	
	sprintf(title,"RateVsGcor_fill%d_n2",fillnum);
//	fcmp[cnt-1] = new TH2F(title,title,100,-1,1,100,0,10000);
	fcmp = new TH2F(title,title,100,-1,1,100,0,10000);
	while(inGcor>>iew>>instb>>ich>>gcorsh){
		if(instb==n1&&iew==2)break;
	}
	
	for(Int_t nstb = n1; nstb <= n2; nstb++){
		for(Int_t row0 = 0; row0 < 34; row0++){
			for(Int_t col0 = 0; col0 < 17; col0++){

				if(cellcnt)inGcor>>iew>>instb>>ich>>gcorsh;
				cellcnt++;	
				if(!Legal(2,nstb,row0,col0)){
					continue;
				}
				sprintf(cellname,"Cellr%d_c%d_n%d",row0,col0,nstb);
				cout<<"processing "<<cellname<<endl;
				if(col0==0){
					if(nstb<3){
						rch = 17*row0+col0+1;
					}
					else if(nstb<5){
						rch = 12*row0+col0+1;
					}
					cout<<"debug instb: "<<instb<<" nstb: "<<nstb<<" ich: "<<ich<<" rch: "<<rch<<" gcorsh: "<<gcorsh<<endl;
				}

				sprintf(cellfile,"../cells/Cellr%d_c%d_n%d.root",row0,col0,nstb);
					
				fcell = new TFile(cellfile,"read");
				if(!fcell){
					cout<<cellfile<<" does not exist!!"<<endl;
					return -1;
				}
				mcell = (MyCell*)fcell->Get(cellname);
				if(!mcell){
					cout<<"ERROR reading "<<cellname<<" object"<<endl;
					return -1;
				}
				mycor = mcell->GetGainCor();
				if(col0==0)cout<<"mycor: "<<mycor<<endl;
				gdiff = mycor - gcorsh;
//					status = mcell->GetStatusBit(runnum);
//					bit = (Int_t)(status&0x03); //can not be 0011
				inlist.clear();
				inlist.seekg(0,ios::beg);
				while(inlist>>runnum){
					if(col0==0)cout<<"run :"<<runnum<<endl;
					rate = mcell->GetNth(runnum,Trgth);
					fcmp->Fill(gdiff,rate);
				}
				mcell	= 0;
				status 	= 0;
				bit	= 0;
				gdiff	= 0;
				fcell->Close();
				fcell	= 0;
			}
		}
	}
//	c1->cd(cnt);
	fcmp->Draw("COLZ");
//	if(cnt%9==0){
//		c1->Print(outfile);
//		c1->Clear();
//		c1->Divide(3,3);
//		cnt = 0;
//	}
//		cnt++;
//		cout<<"============================"<<runnum<<" done.."<<endl;
//		cellcnt = 0;
//	}
	c1->Print(outfile);	
//	c1->Print(endout);
		
	return 1;
  }
Ejemplo n.º 29
0
void sigma_plots_mass_4D(int sigMass, double cut_pt1IN, double cut_pt2IN, double cut_metIN,double cut_ptggIN, double ptLead_cutIN, double DPHI_cutIN, double maxDPHIJet_cutIN,double minDPHIJet_cutIN){

  gStyle->SetPadTickY(1);
  gStyle->SetPadTickX(1);



  /*
  TFile *sig = TFile::Open(Form("./50ns_betaV4/NewWeightDMHtoGG_M%d.root",sigMass),"READ");
  TFile *bkg1 =  TFile::Open("./50ns_betaV4/NewWeightDiPhoton.root","READ"); 
  TFile *bkg2 =  TFile::Open("./50ns_betaV4/NewWeightDYJetsToLL.root","READ");
  TFile *bkg3 =  TFile::Open("./50ns_betaV4/NewWeightGJets.root","READ");  
  TFile *bkg4 =  TFile::Open("./50ns_betaV4/NewWeightGluGluHToGG.root","READ");
  TFile *bkg5 =  TFile::Open("./50ns_betaV4/NewWeightQCD.root","READ");
  TFile *bkg6 =  TFile::Open("./50ns_betaV4/NewWeightVH.root","READ");
  */  
  TFile *data =  TFile::Open("./25ns_2246inv_v3/DoubleEG.root","READ"); 
  TFile *sig = TFile::Open(Form("./25ns_2246inv_v3/2HDM_mZP%d.root",sigMass),"READ");
  if(sig == NULL) cout<<"sig fails"<<endl;
  TFile *bkg1 =  TFile::Open("./25ns_2246inv_v3/DiPhoton.root","READ"); 
  if(bkg1 == NULL) cout<<"bkg1 fails"<<endl;
  TFile *bkg2 =  TFile::Open("./25ns_2246inv_v3/DYJetsToLL.root","READ");
  if(bkg2 == NULL) cout<<"bkg2 fails"<<endl;
  TFile *bkg3 =  TFile::Open("./25ns_2246inv_v3/GJets.root","READ");  
  if(bkg3 == NULL) cout<<"bkg3 fails"<<endl;
  TFile *bkg4 =  TFile::Open("./25ns_2246inv_v3/GluGluHToGG.root","READ");
  if(bkg4 == NULL) cout<<"bkg4 fails"<<endl;
  TFile *bkg5 =  TFile::Open("./25ns_2246inv_v3/QCD.root","READ");
  if(bkg5 == NULL) cout<<"bkg5 fails"<<endl;
  TFile *bkg6 =  TFile::Open("./25ns_2246inv_v3/VH.root","READ");
  if(bkg6 == NULL) cout<<"bkg6 fails"<<endl;
  TFile *bkg7 =  TFile::Open("./25ns_2246inv_v3/ttHJetToGG.root","READ");
  TFile *bkg8 =  TFile::Open("./25ns_2246inv_v3/VBFHToGG.root","READ");
  TFile *bkg9 =  TFile::Open("./25ns_2246inv_v3/TGJets.root","READ");
  TFile *bkg10 =  TFile::Open("./25ns_2246inv_v3/TTGJets.root","READ");
  TFile *bkg11 =  TFile::Open("./25ns_2246inv_v3/WGToLNuG.root","READ");
  TFile *bkg12 =  TFile::Open("./25ns_2246inv_v3/ZGTo2LG.root","READ");


 
  TTree *tree_data = (TTree*) data->Get("DiPhotonTree"); 
  TTree *tree_sig = (TTree*) sig->Get("DiPhotonTree"); 
  TTree *tree_bkg1 = (TTree*) bkg1->Get("DiPhotonTree");
  TTree *tree_bkg2 = (TTree*) bkg2->Get("DiPhotonTree");
  TTree *tree_bkg3 = (TTree*) bkg3->Get("DiPhotonTree");
  TTree *tree_bkg4 = (TTree*) bkg4->Get("DiPhotonTree");
  TTree *tree_bkg5 = (TTree*) bkg5->Get("DiPhotonTree");
  TTree *tree_bkg6 = (TTree*) bkg6->Get("DiPhotonTree");
  TTree *tree_bkg7 = (TTree*) bkg7->Get("DiPhotonTree");
  TTree *tree_bkg8 = (TTree*) bkg8->Get("DiPhotonTree");
  TTree *tree_bkg9 = (TTree*) bkg9->Get("DiPhotonTree");
  TTree *tree_bkg10 = (TTree*) bkg10->Get("DiPhotonTree");
  TTree *tree_bkg11 = (TTree*) bkg11->Get("DiPhotonTree");
  TTree *tree_bkg12 = (TTree*) bkg12->Get("DiPhotonTree");


  TCut Cut_pt1;
  TCut Cut_pt2;
  TCut Cut_met;
  TCut Cut_ptgg;
  TCut mggmax = "mgg<130";
  TCut mggmin = "mgg>120";
  TCut eveto1 = "eleveto1 == 1";
  TCut eveto2 = "eleveto2 == 1";
  TCut eveto = eveto1 && eveto2;
  TCut genmatch = "((genmatch1==1 && genmatch2==0)||(genmatch1==0 && genmatch2==1)||(genmatch1==0 && genmatch2==0))";  

  TCut DPHIcut = Form("FDelta(pt1,eta1,phi1,0.,pt2,eta2,phi2,0.,t1pfmetPhi)>%lf",DPHI_cutIN);
  TCut maxDPHIJetcut = Form("MAX(ptJetLead,phiJetLead,ptJetSubLead,phiJetSubLead,ptJet3,phiJet3,ptJet4,phiJet4,t1pfmetPhi)<%lf",maxDPHIJet_cutIN);
  TCut minDPHIJetcut = Form("myMIN(ptJetLead,phiJetLead,ptJetSubLead,phiJetSubLead,ptJet3,phiJet3,ptJet4,phiJet4,t1pfmetPhi)>%lf",minDPHIJet_cutIN);
  TCut nMuonCut = "nMuons == 0";
  TCut nEleCut = "nEle <= 1";  

  TCanvas *canvas = new TCanvas("canvas","",600,400);   
  int i = 0;
  int j = 0;
  int k = 0;
  int l = 0;
  double cut_pt1 = 0;
  double cut_pt2 = 0;
  double cut_met = 0;
  double cut_ptgg = 0;
   
  
  double Stot_pt1 = 0;
  double Stot_pt2 = 0;
  double Stot_met = 0;
  double Stot_ptgg = 0;
  double S = 0;
  double F1 = 0;
  double F2 = 0;
  double F3 = 0;
  double F4 = 0;
  double F5 = 0;
  double F6 = 0;
  double F7 = 0;
  double F8 = 0;
  double F9 = 0;
  double F10 = 0;
  double F11 = 0;
  double F12 = 0;
  double B = 0;
  double Eff = 0;
  
  double Sig3 = 0;
  double Sig5 = 0;
  int NstepsPt1 = 20; 
  int NstepsPt2 = 20; 
  int NstepsMET = 20; 
 int NstepsPtgg = 20; 
  double temp = 0;

  double firstCutPt1 = cut_pt1IN  - 0.05*NstepsPt1/2; 
  double firstCutPt2 = 1./4.;
  double firstCutMET = cut_metIN - 5*NstepsMET/2;
double firstCutPtgg = cut_ptggIN - 5*NstepsPtgg/2;
  
  double crossSec = 1.; 
  double N = 0.;
     

   
  cout<<"############Segnale M"<<sigMass<<endl;
  cout<<"120 < mgg < 130"<<endl;  
  ios_base::fmtflags oldflags = std::cout.flags();
  TH2F *hpt1VSpt2 = new TH2F("hpt1VSpt2","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2);
  TH2F *hpt1VSmet = new TH2F("hpt1VSmet","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsMET,firstCutMET,firstCutMET+5*NstepsMET);
TH2F *hptggVSmet = new TH2F("hptggVSmet","",NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg,NstepsMET,firstCutMET,firstCutMET+5*NstepsMET);
  TH2F *hmetVSpt2 = new TH2F("metVSpt2","",NstepsMET,firstCutMET,firstCutMET+5*NstepsMET,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2);
 TH2F *hptggVSpt2 = new TH2F("ptggVSpt2","",NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg,NstepsPt2,firstCutPt2,firstCutPt2+0.05*NstepsPt2);
   TH2F *hpt1VSptgg = new TH2F("hpt1VSptgg","",NstepsPt1,firstCutPt1,firstCutPt1+0.05*NstepsPt1,NstepsPtgg,firstCutPtgg,firstCutPtgg+5*NstepsPtgg);
  
  tree_sig->Draw("(pt1)>>pt1_tot1(30,0,1000)","weight"*(mggmin && mggmax && eveto));
  TH1F *pt1_tot1 =(TH1F*)gPad->GetPrimitive("pt1_tot1");
  pt1_tot1->Scale(crossSec); 
  Stot_pt1 = pt1_tot1->Integral();
  

  Cut_met = Form("t1pfmet>%lf",cut_metIN);
  Cut_ptgg = Form("ptgg>%lf",cut_ptggIN);
  for(i = 0; i<NstepsPt1;i++){
    cut_pt1 = firstCutPt1 + 0.05*i +0.001;
    Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1);   
    for(j = 0; j<NstepsPt2;j++){
      cut_pt2 = firstCutPt2 + 0.05*j +0.001;
      Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2);
      tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
      TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
      N = pt1_data->GetEntries();
      Sig5= 0.;
      if(N>=0){
      
	   
      tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto &&  maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
      TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
      pt1_1->Scale(crossSec);      
      S = pt1_1->Integral();   
      tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
      TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");
      
      F1 = pt1_bkg1->Integral();   
      tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
      TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");
      
      F2 = pt1_bkg2->Integral();
      if(F2<0) F2 = 0;          
      tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
      TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");
      
      F3 = pt1_bkg3->Integral();  
      tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
      TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");
      
      F4 = pt1_bkg4->Integral();    
      tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
      TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");
      
      F5 = pt1_bkg5->Integral();    
      tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
      TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");
      F6 = pt1_bkg6->Integral();  
      tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
      TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
      F7 = pt1_bkg7->Integral();
      tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
      TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
      F8 = pt1_bkg8->Integral();
      tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
      TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
      F9 = pt1_bkg9->Integral();
      if(F9<0) F9=0;
      tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
      TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
      F10 = pt1_bkg10->Integral();
      tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
      TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
      F11 = pt1_bkg11->Integral();
      tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
      TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
      F12 = pt1_bkg12->Integral();
      
      
      
      B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;
      Eff = S/Stot_pt1;
      Sig3 = Eff/(1.5+sqrt(B));
      Sig5 = Eff/(2.5+sqrt(B));
      }
      hpt1VSpt2->Fill(cut_pt1,cut_pt2,Sig5);
    }
  }
  
  /////////////////////////////////////////////////////////
Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN);
Cut_ptgg = Form("ptgg>%lf",cut_ptggIN);
  for(i = 0; i<NstepsPt1;i++){
    cut_pt1 = firstCutPt1 + 0.05*i +0.001;
    Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1);
      for(j = 0; j<NstepsMET;j++){
	cut_met = firstCutMET + 5*j;
	Cut_met = Form("t1pfmet>%lf",cut_met);
   tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
      TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
      N = pt1_data->GetEntries();
      Sig5= 0.;
      if(N>=0){


	tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
	pt1_1->Scale(crossSec);   
	S = pt1_1->Integral();   
	tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");

	F1 = pt1_bkg1->Integral();   
	tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");

	F2 = pt1_bkg2->Integral();
	if(F2<0) F2 = 0;     
	tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");

	F3 = pt1_bkg3->Integral();  
	tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");

	F4 = pt1_bkg4->Integral();    
	tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");

	F5 = pt1_bkg5->Integral();   
 	tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
	TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");
	F6 = pt1_bkg6->Integral();  
	tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_met && Cut_pt2 && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
  TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
	   F7 = pt1_bkg7->Integral();
	   tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
	   TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
	   F8 = pt1_bkg8->Integral();
	   tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	   TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
	   F9 = pt1_bkg9->Integral();
	   if(F9<0) F9 = 0;
	   tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	   TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
	   F10 = pt1_bkg10->Integral();
	   tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
	   TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
	   F11 = pt1_bkg11->Integral();
	   tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	   TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
	   F12 = pt1_bkg12->Integral();



	   B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;




   
	Eff = S/Stot_pt1;
	Sig3 = Eff/(1.5+sqrt(B));
	Sig5 = Eff/(2.5+sqrt(B));
      }
	hpt1VSmet->Fill(cut_pt1,cut_met,Sig5);
      }
  }



  /////////////////////////////////////////////////////////
Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN);
Cut_ptgg = Form("ptgg>%lf",cut_ptggIN);
  for(i = 0; i<NstepsPt2;i++){
    cut_pt2 = firstCutPt2 + 0.05*i+0.001;
    Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2);
    for(j = 0; j<NstepsMET;j++){
	cut_met = firstCutMET + 5*j;
	Cut_met = Form("t1pfmet>%lf",cut_met);
	tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
	N = pt1_data->GetEntries();
	Sig5= 0.;
	if(N>=0){
	tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
	pt1_1->Scale(crossSec);   	
	S = pt1_1->Integral();   
	tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");
	
	F1 = pt1_bkg1->Integral();   
	tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");
	
	F2 = pt1_bkg2->Integral();
	if(F2<0) F2 = 0;     
	tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");

	F3 = pt1_bkg3->Integral();  
	tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");
	
	F4 = pt1_bkg4->Integral();    
	tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");
	
	F5 = pt1_bkg5->Integral();    
	tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
	TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");

	F6 = pt1_bkg6->Integral();  
	
	tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
	F7 = pt1_bkg7->Integral();
	tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
	TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
	F8 = pt1_bkg8->Integral();
	tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
	F9 = pt1_bkg9->Integral();
	if(F9<0) F9=0;
	tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
	F10 = pt1_bkg10->Integral();
	tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
	TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
	F11 = pt1_bkg11->Integral();
	tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
	F12 = pt1_bkg12->Integral();
	
      
      
	B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;
	
	
	Eff = S/Stot_pt1;
	Sig3 = Eff/(1.5+sqrt(B));
	Sig5 = Eff/(2.5+sqrt(B));
	}
	hmetVSpt2->Fill(cut_met,cut_pt2,Sig5);
      }
  }




  /////////////////////////////////////////////////////////
Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN);
Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN);
  for(i = 0; i<NstepsPtgg;i++){
    cut_ptgg = firstCutPtgg + 5*i;
    Cut_ptgg = Form("ptgg>%lf",cut_ptgg);
    for(j = 0; j<NstepsMET;j++){
	cut_met = firstCutMET + 5*j;
	Cut_met = Form("t1pfmet>%lf",cut_met);
	tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
	N = pt1_data->GetEntries();
	Sig5= 0.;
	if(N>=0){
	tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
	pt1_1->Scale(crossSec);   	
	S = pt1_1->Integral();   
	tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");
	
	F1 = pt1_bkg1->Integral();   
	tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");
	
	F2 = pt1_bkg2->Integral();
	if(F2<0) F2 = 0;     
	tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");

	F3 = pt1_bkg3->Integral();  
	tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");
	
	F4 = pt1_bkg4->Integral();    
	tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");
	
	F5 = pt1_bkg5->Integral();    
	tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
	TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");

	F6 = pt1_bkg6->Integral();  
	
	tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
	F7 = pt1_bkg7->Integral();
	tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
	TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
	F8 = pt1_bkg8->Integral();
	tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
	F9 = pt1_bkg9->Integral();
	if(F9<0) F9=0;
	tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
	F10 = pt1_bkg10->Integral();
	tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
	TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
	F11 = pt1_bkg11->Integral();
	tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
	F12 = pt1_bkg12->Integral();
	
      
      
	B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;
	
	
	Eff = S/Stot_pt1;
	Sig3 = Eff/(1.5+sqrt(B));
	Sig5 = Eff/(2.5+sqrt(B));
	}
	hptggVSmet->Fill(cut_ptgg,cut_met,Sig5);
      }
  }


  /////////////////////////////////////////////////////////
Cut_met = Form("t1pfmet>%lf",cut_metIN);
Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1IN);
  for(i = 0; i<NstepsPtgg;i++){
    cut_ptgg = firstCutPtgg + 5*i;
    Cut_ptgg = Form("ptgg>%lf",cut_ptgg);
    for(j = 0; j<NstepsPt2;j++){
	cut_pt2 = firstCutPt2 + 0.05*j+0.001;
	Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2);
	tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
	N = pt1_data->GetEntries();
	Sig5= 0.;
	if(N>=0){
	tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
	pt1_1->Scale(crossSec);   	
	S = pt1_1->Integral();   
	tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");
	
	F1 = pt1_bkg1->Integral();   
	tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");
	
	F2 = pt1_bkg2->Integral();
	if(F2<0) F2 = 0;     
	tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");

	F3 = pt1_bkg3->Integral();  
	tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");
	
	F4 = pt1_bkg4->Integral();    
	tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");
	
	F5 = pt1_bkg5->Integral();    
	tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
	TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");

	F6 = pt1_bkg6->Integral();  
	
	tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
	F7 = pt1_bkg7->Integral();
	tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
	TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
	F8 = pt1_bkg8->Integral();
	tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
	F9 = pt1_bkg9->Integral();
	if(F9<0) F9=0;
	tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
	F10 = pt1_bkg10->Integral();
	tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
	TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
	F11 = pt1_bkg11->Integral();
	tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
	F12 = pt1_bkg12->Integral();
	
      
      
	B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;
	
	
	Eff = S/Stot_pt1;
	Sig3 = Eff/(1.5+sqrt(B));
	Sig5 = Eff/(2.5+sqrt(B));
	}
	hptggVSpt2->Fill(cut_ptgg,cut_pt2,Sig5);
      }
  }

  /////////////////////////////////////////////////////////
Cut_met = Form("t1pfmet>%lf",cut_metIN);
Cut_pt2 = Form("pt2/mgg>%lf",cut_pt2IN);
  for(i = 0; i<NstepsPtgg;i++){
    cut_ptgg = firstCutPtgg + 5*i;
    Cut_ptgg = Form("ptgg>%lf",cut_ptgg);
    for(j = 0; j<NstepsPt1;j++){
	cut_pt1 = firstCutPt1 + 0.05*j+0.001;
	Cut_pt1 = Form("pt1/mgg>%lf",cut_pt1);
	tree_data->Draw("(pt1)>>pt1_data(30,0,1000)","(mgg<115||mgg>135)"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_data =(TH1F*)gPad->GetPrimitive("pt1_data");
	N = pt1_data->GetEntries();
	Sig5= 0.;
	if(N>=0){
	tree_sig->Draw("(pt1)>>pt1_1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_1 =(TH1F*)gPad->GetPrimitive("pt1_1"); 
	pt1_1->Scale(crossSec);   	
	S = pt1_1->Integral();   
	tree_bkg1->Draw("(pt1)>>pt1_bkg1(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg1 =(TH1F*)gPad->GetPrimitive("pt1_bkg1");
	
	F1 = pt1_bkg1->Integral();   
	tree_bkg2->Draw("(pt1)>>pt1_bkg2(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg2 =(TH1F*)gPad->GetPrimitive("pt1_bkg2");
	
	F2 = pt1_bkg2->Integral();
	if(F2<0) F2 = 0;     
	tree_bkg3->Draw("(pt1)>>pt1_bkg3(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg3 =(TH1F*)gPad->GetPrimitive("pt1_bkg3");

	F3 = pt1_bkg3->Integral();  
	tree_bkg4->Draw("(pt1)>>pt1_bkg4(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut));
	TH1F *pt1_bkg4 =(TH1F*)gPad->GetPrimitive("pt1_bkg4");
	
	F4 = pt1_bkg4->Integral();    
	tree_bkg5->Draw("(pt1)>>pt1_bkg5(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut && genmatch));
	TH1F *pt1_bkg5 =(TH1F*)gPad->GetPrimitive("pt1_bkg5");
	
	F5 = pt1_bkg5->Integral();    
	tree_bkg6->Draw("(pt1)>>pt1_bkg6(30,0,1000)","weight"*(Cut_pt2 && Cut_met && Cut_pt1 && Cut_ptgg && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut &&nMuonCut &&nEleCut)); 
	TH1F *pt1_bkg6 =(TH1F*)gPad->GetPrimitive("pt1_bkg6");

	F6 = pt1_bkg6->Integral();  
	
	tree_bkg7->Draw("(pt1)>>pt1_bkg7(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg7 =(TH1F*)gPad->GetPrimitive("pt1_bkg7");
	F7 = pt1_bkg7->Integral();
	tree_bkg8->Draw("(pt1)>>pt1_bkg8(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                            
	TH1F *pt1_bkg8 =(TH1F*)gPad->GetPrimitive("pt1_bkg8");
	F8 = pt1_bkg8->Integral();
	tree_bkg9->Draw("(pt1)>>pt1_bkg9(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                             
	TH1F *pt1_bkg9 =(TH1F*)gPad->GetPrimitive("pt1_bkg9");
	F9 = pt1_bkg9->Integral();
	if(F9<0) F9=0;
	tree_bkg10->Draw("(pt1)>>pt1_bkg10(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg10 =(TH1F*)gPad->GetPrimitive("pt1_bkg10");
	F10 = pt1_bkg10->Integral();
	tree_bkg11->Draw("(pt1)>>pt1_bkg11(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut && minDPHIJetcut && nMuonCut && nEleCut ));                                       
	TH1F *pt1_bkg11 =(TH1F*)gPad->GetPrimitive("pt1_bkg11");
	F11 = pt1_bkg11->Integral();
	tree_bkg12->Draw("(pt1)>>pt1_bkg12(30,0,1000)","weight"*(Cut_pt1 && Cut_ptgg && Cut_pt2 && Cut_met && mggmin && mggmax && eveto && maxDPHIJetcut  && DPHIcut &&minDPHIJetcut && nMuonCut && nEleCut ));                                           
	TH1F *pt1_bkg12 =(TH1F*)gPad->GetPrimitive("pt1_bkg12");
	F12 = pt1_bkg12->Integral();
	
      
      
	B = F1+F2+F3+F4+F5+F6+F7+F8+F9+F10+F11+F12;
	
	
	Eff = S/Stot_pt1;
	Sig3 = Eff/(1.5+sqrt(B));
	Sig5 = Eff/(2.5+sqrt(B));
	}
	hpt1VSptgg->Fill(cut_pt1,cut_ptgg,Sig5);
      }
  }
  
   
  const Int_t NRGBs = 5;
  const Int_t NCont = 255;
  Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
  Double_t red[NRGBs]   = { 0.00, 0.00, 0.87, 1.00, 0.51 };
  Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
  Double_t blue[NRGBs]  = { 0.51, 1.00, 0.12, 0.00, 0.00 };
  TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
  gStyle->SetNumberContours(NCont);
 
  int iPos=0; 

  TCanvas *fancycanvas1 = new TCanvas("fancycanvas1","",550,500);

  fancycanvas1->SetRightMargin(0.17);   
  hpt1VSpt2->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}");  
  hpt1VSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}");  
  hpt1VSpt2->GetZaxis()->SetTitle("Sign(5#sigma)");  

  hpt1VSpt2->GetZaxis()->SetTitleOffset(1.6);  
  hpt1VSpt2->GetYaxis()->SetTitleOffset(1.2);  
  hpt1VSpt2->Draw("colz");
  CMS_lumi( fancycanvas1,true,iPos,true );
  gStyle->SetOptStat(0); 

  
  TCanvas *fancycanvas2 = new TCanvas("fancycanvas2","",550,500);


  fancycanvas2->SetRightMargin(0.17);   
  hpt1VSmet->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}");  
  hpt1VSmet->GetYaxis()->SetTitle("MET [GeV]");  
  hpt1VSmet->GetZaxis()->SetTitle("Sign(5#sigma)");  
  hpt1VSmet->GetZaxis()->SetTitleOffset(1.6);  
  hpt1VSmet->GetYaxis()->SetTitleOffset(1.2);  
  hpt1VSmet->Draw("colz");
  CMS_lumi( fancycanvas2,true,iPos,true );
  gStyle->SetOptStat(0);  
  
  
  TCanvas *fancycanvas3 = new TCanvas("fancycanvas3","",550,500); 


  fancycanvas3->SetRightMargin(0.17);   
  hmetVSpt2->GetXaxis()->SetTitle("MET [GeV]");  
  hmetVSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}");  
  hmetVSpt2->GetZaxis()->SetTitle("Sign(5#sigma)");  

  hmetVSpt2->GetZaxis()->SetTitleOffset(1.6);  
  hmetVSpt2->GetYaxis()->SetTitleOffset(1.2);  
  hmetVSpt2->Draw("colz");
  CMS_lumi( fancycanvas3,true,iPos,true );

  gStyle->SetOptStat(0);  


 TCanvas *fancycanvas4 = new TCanvas("fancycanvas4","",550,500); 


  fancycanvas4->SetRightMargin(0.17);   
  hptggVSmet->GetXaxis()->SetTitle("p_{T#gamma#gamma} [GeV]");  
  hptggVSmet->GetYaxis()->SetTitle("MET [GeV]");  
  hptggVSmet->GetZaxis()->SetTitle("Sign(5#sigma)");  

  hptggVSmet->GetZaxis()->SetTitleOffset(1.6);  
  hptggVSmet->GetYaxis()->SetTitleOffset(1.2);  
  hptggVSmet->Draw("colz");
  CMS_lumi( fancycanvas4,true,iPos,true );

  gStyle->SetOptStat(0);  


 TCanvas *fancycanvas5 = new TCanvas("fancycanvas5","",550,500); 


  fancycanvas5->SetRightMargin(0.17);   
  hptggVSpt2->GetXaxis()->SetTitle("p_{T#gamma#gamma} [GeV]");  
  hptggVSpt2->GetYaxis()->SetTitle("p_{T2}/m_{#gamma#gamma}");  
  hptggVSpt2->GetZaxis()->SetTitle("Sign(5#sigma)");  

  hptggVSpt2->GetZaxis()->SetTitleOffset(1.6);  
  hptggVSpt2->GetYaxis()->SetTitleOffset(1.2);  
  hptggVSpt2->Draw("colz");
  CMS_lumi( fancycanvas5,true,iPos,true );

  gStyle->SetOptStat(0);  


 TCanvas *fancycanvas6 = new TCanvas("fancycanvas6","",550,500); 


  fancycanvas6->SetRightMargin(0.17);   
  hpt1VSptgg->GetXaxis()->SetTitle("p_{T1}/m_{#gamma#gamma}");  
  hpt1VSptgg->GetYaxis()->SetTitle("p_{T#gamma#gamma} [GeV]");  
  hpt1VSptgg->GetZaxis()->SetTitle("Sign(5#sigma)");  

  hpt1VSptgg->GetZaxis()->SetTitleOffset(1.6);  
  hpt1VSptgg->GetYaxis()->SetTitleOffset(1.2);  
  hpt1VSptgg->Draw("colz");
  CMS_lumi( fancycanvas6,true,iPos,true );

  gStyle->SetOptStat(0);  

  
  fancycanvas1->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPt2_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas2->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsMET_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas3->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsMETvsPt2_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas4->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsMET_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas5->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsPt2_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas6->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPtgg_mass_DPHIandLepVeto_all4D.png",sigMass));
  fancycanvas1->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPt2_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  fancycanvas2->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsMET_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  fancycanvas3->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsMETvspt2_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  fancycanvas4->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsMET_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  fancycanvas5->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPtggvsPt2_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  fancycanvas6->SaveAs(Form("./25ns_2246inv_v3/plots/cuts_MassDep/M%d_CutsPt1vsPtgg_mass_DPHIandLepVeto_all4D.pdf",sigMass));
  


}
Ejemplo n.º 30
0
void RPCChambersCluster::variousStudyExperimentalFunction(TFile * fileToSave,TH1F * histo[10],const int & eventNum){
  
  // Save file is used to save all the reconstructed graphs with tracks in order to inspect them
  
  RPCChamber * currentChamberObj;
  RPCChamber * triggerObj;
  RPCLinkBoardChannel * currentChannelObj;
  int numberOfChambers = this->getNumberOfChambers();
  triggerObj = this->getTriggerObjectNumber(1);
  TGraphErrors * graphToFit;
  //currentChamberObj = this->getChamberNumber(1);
  int numberOfReferenceChambers = 0; // change this value for the three cases - CERN, Ghent and BARC
  vector<int> tempCluster;
  
  TH1F * hist1,* hist2,* hist3,* hist4, * numberOfClustersHisto, * topMinusEachChamberAvg, * bottomMinusEachChamberAvg,*clsSize ,
  * numberOfClustersInSamePartitions, * histClustersPartitionDistr, * SingleMultiHits;
  
  hist1 = histo[0];
  hist2 = histo[1];
  hist3 = histo[2];
  hist4 = histo[3];
  numberOfClustersHisto = histo[4];
  topMinusEachChamberAvg = histo[5];
  bottomMinusEachChamberAvg = histo[6];
  clsSize = histo[7];
  histClustersPartitionDistr = histo[8];
  SingleMultiHits = histo[9];
  
  int timeReference = 0;
  int timeWindow = 0;
  int firstScintilatorTime = 0 ;
  int secondScintilatorTime = 0;
  int difference_reference = 0;
  int coincidence_time = 0 ;
  if (triggerObj->getChannel(32)->hasHit()){
    coincidence_time = triggerObj->getChannel(32)->getHits().at(0);
  }
  
  ESiteFileType siteType = kIsCERNrawFile; // later make the method to take file type argument and to use it in here
  
  //TH1F * firstTriggerEntries  = new TH1F("ScintStats1","ScintStats1",0,500,500);
  //firstTriggerEntries->SetLineColor(kBlue);
  //firstTriggerEntries->SetFillColor(kBlue);
  
  switch (siteType) 
  {
    case kIsCERNrawFile:
      
      timeWindow = 500;
      
      numberOfReferenceChambers = 3;
      
      int countTwoHits=0;
      for (int i = 0 ; i < 13 ; i++){
	if(triggerObj->getChannel(i+1)->hasHit() ){
	  
	  if ( difference_reference == 0 || ( coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0) ) < difference_reference ) {
	    
	    difference_reference = coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0);
	    firstScintilatorTime = triggerObj->getChannel(i+1)->getHits().at(0);
	    
	  }
	}
      }
      
      difference_reference = 0;
      
      for (int i = 13 ; i < 31 ; i++) {
	if(triggerObj->getChannel(i+1)->hasHit() ){
	  
	  if ( difference_reference == 0 || ( coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0) ) < difference_reference ) {
	    
	    difference_reference = coincidence_time - triggerObj->getChannel(i+1)->getHits().at(0);
	    secondScintilatorTime = triggerObj->getChannel(i+1)->getHits().at(0);
	    
	  }
	}
      }
      
      //timeReference = timeReference/2;
      /*
    case kIsGENTrawFile:
      timeWindow = 20;
      for(int i = 0 ; i < 32 ; i++){
	if(triggerObj->getChannel(i+1)->hasHit()) {
	  triggerObj->getChannel(i+1)->getHits().at(0);
	}
	break;
      }
    case kIsBARCrawFile:
      timeWindow = 0; 
      timeReference = 0;
      */
      
  }
  
  timeReference = (firstScintilatorTime+secondScintilatorTime)/2;
  
  //cout << " time reference : " << timeReference << endl;
  //cout << " trigger entries : ";
  for (int i=0; i < 32 ; i++){
    if (triggerObj->getChannel(i+1)->hasHit()){
//       cout << " trig channel : " << i+1 << " " << triggerObj->getChannel(i+1)->getHits().at(0) << " ";
    }
  }
  
  cout << endl;
//   cout << " most close trigger entries : top " << firstScintilatorTime << " bottom : " << secondScintilatorTime;
//   cout << endl;
  
  
  hist1->Fill(abs(firstScintilatorTime-secondScintilatorTime));
  hist2->Fill(coincidence_time - firstScintilatorTime);
  hist3->Fill(coincidence_time - secondScintilatorTime);
  
//   cout << "difference : " << firstScintilatorTime-secondScintilatorTime << endl;
  
  for (int totalChambers = 0 ; totalChambers < numberOfChambers ; totalChambers++){
    
    currentChamberObj = this->getChamberNumber(totalChambers+1);
     cout << "Chamber " << totalChambers+1 ;
    for (int j=0 ; j < 96 ;j++){
      
      currentChamberObj = this->getChamberNumber(totalChambers+1);
      currentChannelObj = currentChamberObj->getChannel(j+1);      
      if (currentChannelObj->hasHit()){
 	cout << " channel " << currentChannelObj->getOnlineNumber() << " time " << currentChannelObj->getHits().at(0);
      }
    }
     cout << endl;
    currentChamberObj->findAllClustersForTriggerTimeReferenceAndTimeWindow(timeReference,timeWindow);    
    // now check the clusterization methods
    // fill number of cluster when there is at least one
    if(currentChamberObj->getNumberOfClusters()){
      numberOfClustersHisto->Fill(currentChamberObj->getNumberOfClusters());
    }
  }
  
  cout << "-------------------" << endl;
//   cout << "Check new cluster methods" << endl;
  
  
  for (int totalChambers = 0 ; totalChambers < numberOfChambers ; totalChambers++){
    
    currentChamberObj = this->getChamberNumber(totalChambers+1);
//     cout << "Chamber " << totalChambers+1 ;
    for (int i = 0 ; i < currentChamberObj->getNumberOfClusters() ; i++){
      
      // make the difference to get the tolerance within one cluster 
      
      int smallestTime = 0;
      int biggestTime = 0;
      int currentValue = 0;
      int sizeOfCurrentCluster = currentChamberObj->getClusterNumber(i+1).size();
      tempCluster = currentChamberObj->getClusterNumber(i+1);
      int numberOfHits = 0 ;
      for (int j = 0 ; j < sizeOfCurrentCluster; j++){
	// Fill the size here
	SingleMultiHits->Fill(currentChamberObj->getStrip(tempCluster.at(j))->getHits().size());
	
      }
      
      clsSize->Fill(sizeOfCurrentCluster);
      
      for (int j = 0 ; j < sizeOfCurrentCluster ; j++ ){
	
	currentValue = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j);
	
	if ( j == 0 ) {
	  // init the values
	  smallestTime = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j);
	  biggestTime = currentChamberObj->getStripsHitsTimesForCluster(i+1).at(j);
	}
	else{
	  
	  if ( smallestTime >= currentValue ){
	    smallestTime = currentValue;
	  }
	  if( biggestTime <= currentValue){
	    biggestTime = currentValue;
	  } 
	}
      }
      
      if (biggestTime - smallestTime != 0){
	hist4->Fill(biggestTime-smallestTime);
      }
      int avgTimeForCluster = currentChamberObj->getAverageTimeForCluster(i+1);
      topMinusEachChamberAvg->Fill(abs(firstScintilatorTime - avgTimeForCluster));
      bottomMinusEachChamberAvg->Fill(abs(secondScintilatorTime - avgTimeForCluster));
      
//       cout << endl << "Cluster " << i+1 << " toptime " << biggestTime << " leasttime " << smallestTime ;
      
    }
    
//     cout << endl;
  }
  
//   cout << "-------Second check done-----------" << endl;
  
  // try with single cluster per chamber 
  
  vector<int> vectorOfReferenceChambers;
  
  for (int i=0; i < this->getNumberOfChambers() ; i ++){
    currentChamberObj = this->getChamberNumber(i+1);
    if (currentChamberObj->isReferenceChamber() && !currentChamberObj->getNumberOfClusters()){
      // the reference chamber does not have a hit (cluster), probably inefficient (or else) , skip the execution
      
      break;
    }
  }
  
  // remove the following when the configuration object is introduced // done, change the implementation
  vectorOfReferenceChambers.push_back(1); vectorOfReferenceChambers.push_back(4); vectorOfReferenceChambers.push_back(6);
  
  /** Determination of track starts here */ // Move this part in separated method 
  
  //TFile * goodTracks = new TFile("GoodTracks.root","UPDATE");
  //TFile * badTracks = new TFile("BadTracks.root","UPDATE");
  int globalCount = 1;
  for ( int i = 0 ; i < this->getChamberNumber(vectorOfReferenceChambers[0])->getNumberOfClusters() ; i++ ){
    for( int j = 0 ; j < this->getChamberNumber(vectorOfReferenceChambers[1])->getNumberOfClusters() ; j++ ){
      for( int k = 0 ; k < this->getChamberNumber(vectorOfReferenceChambers[2])->getNumberOfClusters() ; k++ ){
	
	// check the multiplicity. use 5 as upper limit number
	// with the test run 2202 - CERN channel 33 is noisy so there is a condition only for it here TO DO - remove the channel 33 condition // old function
	
	/** Hits : first , use the time to distinguish useless crap - like noisy channels 
	 *  
	 * 2. Check the partition plane (YZ plane) for vertical tracks. If the track is vertical don't search for consecutiveness and don't fill the YZ histo
	 * 3. Check the partitions plane for consecutiveness - one could not expect track that passes 3 -> 1 -> 3 partitions
	 * 
	*/ 
	
	if(this->getChamberNumber(vectorOfReferenceChambers[0])->getSizeOfCluster(i+1) > 5 ||
	  this->getChamberNumber(vectorOfReferenceChambers[1])->getSizeOfCluster(j+1) > 5 ||
	  this->getChamberNumber(vectorOfReferenceChambers[2])->getSizeOfCluster(k+1) > 5
	  ) continue;
	
	// the partition logic start  here - track could pass more than one partition
	int direction = 0 ; // direction should describe how the partition changes from one reference chamber to another. It 
	int RefChamberClusterPartition[3] ;
	int currentDifference = 0;
	bool positive = false;
	bool negative = false;
	int partitionPenetrated = 1;
	// the Y coordinate is the partition number ( 1 2 or 3 - A B or C)
	
	RefChamberClusterPartition[0] = this->getChamberNumber(vectorOfReferenceChambers[0])->getXYCoordinatesOfCluster(i+1).at(1);
	RefChamberClusterPartition[1] = this->getChamberNumber(vectorOfReferenceChambers[1])->getXYCoordinatesOfCluster(j+1).at(1);
	RefChamberClusterPartition[2] = this->getChamberNumber(vectorOfReferenceChambers[2])->getXYCoordinatesOfCluster(k+1).at(1);
	
	for ( int ii = 0; ii < 2 ; ii++ ){
	  direction = (RefChamberClusterPartition[ii] - RefChamberClusterPartition[ii+1]);
	  if (direction != 0) { 
	    direction = direction/abs(direction); 
	    partitionPenetrated++;
	  } // get only the sign ( +1 or -1)
	  if (direction && direction == -1)  positive = true;
	  if (direction && direction == 1 )  negative = true;
	  
	}
	
	// cannot have a track that goes in both direction
	// partition logic end here
	stringstream ss;
	ss << globalCount;
	string histoCounter = ss.str();
	
	
	TH2F * histXZ = new TH2F(histoCounter.c_str(),"XZ plane",110,0,110,68,0,34);
	
	
	histXZ->SetMarkerColor(kBlue);
	histXZ->SetMarkerStyle(kOpenTriangleDown); //  - open triangle down not found on noise server ? 
	
	double * xc = new double[3];
	double * yc = new double[3];
	double * zc = new double[3];
	
	vector<double> coordinates ;
	double xCoordinate = 0;
	int yCoordinate = 0;
	int zCoorinate = 0;
	
	coordinates = this->getChamberNumber(1)->getXYCoordinatesOfCluster(i+1);
	xCoordinate = coordinates.at(0);
	yCoordinate = coordinates.at(1);
	zCoorinate = 10*vectorOfReferenceChambers[0];
	
	int prevPartition = yCoordinate;
	xc[0] = xCoordinate;
	yc[0] = yCoordinate;
	zc[0] = 1*10;
	
	histXZ->Fill(zc[0],xCoordinate);
	cout << xCoordinate << " " << yCoordinate << endl;
	
	coordinates = this->getChamberNumber(4)->getXYCoordinatesOfCluster(j+1);
	xCoordinate = coordinates.at(0);
	yCoordinate = coordinates.at(1);
	
	xc[1] = xCoordinate;
	yc[1] = yCoordinate;
	zc[1] = 4*10;
	
	histXZ->Fill(zc[1],xCoordinate);
	prevPartition = yCoordinate;
	
	cout << xCoordinate << " " << yCoordinate << endl;	
	coordinates = this->getChamberNumber(6)->getXYCoordinatesOfCluster(k+1);
	xCoordinate = coordinates.at(0);
	yCoordinate = coordinates.at(1);
	
	xc[2] = xCoordinate;
	yc[2] = yCoordinate;
	zc[2] = 6*10;
	
	histXZ->Fill(zc[2],xCoordinate);
	cout << xCoordinate << " " << yCoordinate << endl;
	
	if ( positive && negative ) continue;
	
	TF1 * fitfunc = new TF1("FitTrack","[0]+x*[1]",0,100);
	Double_t * params = new Double_t[2];
	histXZ->Fit(fitfunc);
	fitfunc->GetParameters(params);
	cout << "par1 " << params[0] << " par2 " << params[1] << " chi2 " << fitfunc->GetChisquare() << endl;
	double channelToSearchHitIn ;
	
	for (int jj = 0 ; jj < this->getNumberOfChambers() ; jj++){
	  if (jj+1 != vectorOfReferenceChambers[0] || jj+1 != vectorOfReferenceChambers[1] || jj+1 != vectorOfReferenceChambers[1])
	    // add additional rule that the chamber should exist in the calibration object 
	  {
	    
	    channelToSearchHitIn = fitfunc->Eval((jj+1)*10);
	    cout << "Evaluated for chamber number " << jj+1 << " value : " << channelToSearchHitIn << endl;
	    
	  }
	  
	}
	// now here - what to return, and how to get the hits in the chambers under test from the function
	
	
	
	if (fitfunc->GetChisquare() > 20) continue; // cut the execution 
	if(fitfunc->GetChisquare() < 20){
	  //goodTracks->Write(trackHistoName.c_str());
	  histClustersPartitionDistr->Fill(partitionPenetrated);
	  //histXZ->SaveAs((trackHistoName+".root").c_str());  
	  // here search for hits in the chambers under test  
	  
	}
	
	/*
	else{
	  badTracks->Write(trackHistoName.c_str());
	}	
	*/
	
	//trackHistoName+=".root";
	//histXZ->SaveAs(trackHistoName.c_str());
	
	histXZ->Delete();
	
      }
    }
  }
//   badTracks->Close("R");
//   badTracks->Delete();
//   goodTracks->Close("R");
//   goodTracks->Delete();

}