int main (int argc, char **argv) { /// Mc Ntuplas TString input = Form("/data1/rgerosa/NTUPLES_FINAL_CALIB/MC/WJetsToLNu_DYJetsToLL_7TeV-madgraph-tauola_Fall11_All.root"); /// MC Calibration result E/p TString input2 = Form("/data1/rgerosa/L3_Weight/MC_WJets/EB_Z_recoFlag/WJetsToLNu_DYJetsToLL_7TeV-madgraph-tauola_Fall11_Z_noEP.root"); TApplication* theApp = new TApplication("Application",&argc, argv); TFile *f = new TFile(input,""); TTree *inputTree = (TTree*)f->Get("ntu"); TFile *f2 = new TFile(input2,""); TH2F *h_scale_EB = (TH2F*)f2->Get("h_scale_EB"); TH2F *hcmap = (TH2F*) h_scale_EB->Clone("hcmap"); hcmap -> Reset("ICEMS"); hcmap -> ResetStats(); /// Taking infos std::vector<float>* ele1_recHit_E=0; std::vector<float>* ele2_recHit_E=0; std::vector<int>* ele1_recHit_hashedIndex=0; std::vector<int>* ele2_recHit_hashedIndex=0; std::vector<int>* ele1_recHit_flag=0; std::vector<int>* ele2_recHit_flag=0; float ele1_E_true,ele2_E_true; float ele1_tkP,ele2_tkP; int ele1_isEB, ele2_isEB; float ele1_fbrem,ele2_fbrem; int isW, isZ; inputTree->SetBranchAddress("ele1_recHit_E", &ele1_recHit_E); inputTree->SetBranchAddress("ele2_recHit_E", &ele2_recHit_E); inputTree->SetBranchAddress("ele1_recHit_hashedIndex", &ele1_recHit_hashedIndex); inputTree->SetBranchAddress("ele2_recHit_hashedIndex", &ele2_recHit_hashedIndex); inputTree->SetBranchAddress("ele1_recHit_flag", &ele1_recHit_flag); inputTree->SetBranchAddress("ele2_recHit_flag", &ele2_recHit_flag); inputTree->SetBranchAddress("ele1_E_true", &ele1_E_true); inputTree->SetBranchAddress("ele2_E_true", &ele2_E_true); inputTree->SetBranchAddress("ele1_tkP", &ele1_tkP); inputTree->SetBranchAddress("ele2_tkP", &ele2_tkP); inputTree->SetBranchAddress("ele1_isEB", &ele1_isEB); inputTree->SetBranchAddress("ele2_isEB", &ele2_isEB); inputTree->SetBranchAddress("ele1_fbrem", &ele1_fbrem); inputTree->SetBranchAddress("ele2_fbrem", &ele2_fbrem); inputTree->SetBranchAddress("isW", &isW); inputTree->SetBranchAddress("isZ", &isZ); TProfile2D* mapMomentum = new TProfile2D("mapMomentum","mapMomentum",360,0,360,170,-85,85); TProfile2D* mapfbrem = new TProfile2D("mapfbrem","mapfbrem",360,0,360,170,-85,85); /// Make fbrem and p/ptrue map cycling on MC --> all the events for(Long64_t i=0; i< inputTree->GetEntries(); i++) { inputTree->GetEntry(i); if (!(i%100000))std::cerr<<i; if (!(i%10000)) std::cerr<<"."; if (ele1_isEB == 1 && (isW==1 || isZ==1)) { double E_seed=0; int seed_hashedIndex=-1;// iseed; for (unsigned int iRecHit = 0; iRecHit < ele1_recHit_E->size(); iRecHit++ ) { if(ele1_recHit_E -> at(iRecHit) > E_seed && ele1_recHit_flag->at(iRecHit) < 4 ) /// control if this recHit is good { seed_hashedIndex=ele1_recHit_hashedIndex -> at(iRecHit); // iseed=iRecHit; E_seed=ele1_recHit_E -> at(iRecHit); ///! Seed search } } int eta_seed = GetIetaFromHashedIndex(seed_hashedIndex); int phi_seed = GetIphiFromHashedIndex(seed_hashedIndex); if(ele1_tkP>0 && ele1_E_true>0 && abs(ele1_tkP/ele1_E_true)<2. && abs(ele1_tkP/ele1_E_true)>0.5) mapMomentum->Fill(phi_seed,eta_seed,abs(ele1_tkP/ele1_E_true)); mapfbrem->Fill(phi_seed,eta_seed,abs(ele1_fbrem)); } if (ele2_isEB == 1 && isZ==1) { double E_seed=0; int seed_hashedIndex=-1;// iseed; for (unsigned int iRecHit = 0; iRecHit < ele2_recHit_E->size(); iRecHit++ ) { if(ele2_recHit_E -> at(iRecHit) > E_seed && ele2_recHit_flag->at(iRecHit) < 4 ) /// control if this recHit is good { seed_hashedIndex=ele2_recHit_hashedIndex -> at(iRecHit); // iseed=iRecHit; E_seed=ele2_recHit_E -> at(iRecHit); ///! Seed search } } int eta_seed = GetIetaFromHashedIndex(seed_hashedIndex); int phi_seed = GetIphiFromHashedIndex(seed_hashedIndex); if(ele2_tkP>0 && ele2_E_true>0 && abs(ele2_tkP/ele2_E_true)<2. && abs(ele2_tkP/ele2_E_true)>0.5) mapMomentum->Fill(phi_seed,eta_seed,abs(ele2_tkP/ele2_E_true)); mapfbrem->Fill(phi_seed,eta_seed,abs(ele2_fbrem)); } } /// Map of IC normalized in eta rings std::vector< std::pair<int,int> > TT_centre ; TT_centre.push_back(std::pair<int,int> (58,49)); TT_centre.push_back(std::pair<int,int> (53,109)); TT_centre.push_back(std::pair<int,int> (8,114)); TT_centre.push_back(std::pair<int,int> (83,169)); TT_centre.push_back(std::pair<int,int> (53,174)); TT_centre.push_back(std::pair<int,int> (63,194)); TT_centre.push_back(std::pair<int,int> (83,224)); TT_centre.push_back(std::pair<int,int> (73,344)); TT_centre.push_back(std::pair<int,int> (83,358)); TT_centre.push_back(std::pair<int,int> (-13,18)); TT_centre.push_back(std::pair<int,int> (-18,23)); TT_centre.push_back(std::pair<int,int> (-8,53)); TT_centre.push_back(std::pair<int,int> (-3,63)); TT_centre.push_back(std::pair<int,int> (-53,128)); TT_centre.push_back(std::pair<int,int> (-53,183)); TT_centre.push_back(std::pair<int,int> (-83,193)); TT_centre.push_back(std::pair<int,int> (-74,218)); TT_centre.push_back(std::pair<int,int> (-8,223)); TT_centre.push_back(std::pair<int,int> (-68,303)); TT_centre.push_back(std::pair<int,int> (-43,328)); /// Mean over phi corrected skipping dead channel for (int iEta = 1 ; iEta < h_scale_EB->GetNbinsY()+1; iEta ++) { float SumIC = 0; int numIC = 0; for(int iPhi = 1 ; iPhi < h_scale_EB->GetNbinsX()+1 ; iPhi++) { bool isGood = CheckxtalIC(h_scale_EB,iPhi,iEta); bool isGoodTT = CheckxtalTT(iPhi,iEta,TT_centre); if(isGood && isGoodTT) { SumIC = SumIC + h_scale_EB->GetBinContent(iPhi,iEta); numIC ++ ; } } //fede: skip bad channels and bad TTs for (int iPhi = 1; iPhi< h_scale_EB->GetNbinsX()+1 ; iPhi++) { if(numIC==0 || SumIC==0) continue; bool isGood = CheckxtalIC(h_scale_EB,iPhi,iEta); bool isGoodTT = CheckxtalTT(iPhi,iEta,TT_centre); if (!isGood || !isGoodTT) continue; hcmap->SetBinContent(iPhi,iEta,h_scale_EB->GetBinContent(iPhi,iEta)/(SumIC/numIC)); } } /// ratio map TH2F* ratioMap = (TH2F*) hcmap -> Clone("ratioMap"); ratioMap->Reset(); for( int i =0 ; i<hcmap->GetNbinsX() ; i++){ for( int j=0; j<hcmap->GetNbinsY() ; j++){ if(hcmap->GetBinContent(i,j)!=0 && mapMomentum->GetBinContent(i,j)!=0) ratioMap->SetBinContent(i+1,j+1,mapMomentum->GetBinContent(i,j)/hcmap->GetBinContent(i,j)); } } /// Profile along phi taking into account dead channels TGraphErrors *coeffEBp = new TGraphErrors(); TGraphErrors *coeffEBm = new TGraphErrors(); for (int iPhi =1; iPhi< hcmap->GetNbinsX()+1 ; iPhi++){ double SumEBp =0, SumEBm=0; double iEBp=0, iEBm=0; for(int iEta = 1; iEta<hcmap->GetNbinsY()+1 ; iEta++){ if(hcmap->GetBinContent(iPhi,iEta)==0)continue; if(iEta>85) {SumEBp=SumEBp+mapMomentum->GetBinContent(iPhi,iEta)/hcmap->GetBinContent(iPhi,iEta); iEBp++;} else{ SumEBm=SumEBm+mapMomentum->GetBinContent(iPhi,iEta)/hcmap->GetBinContent(iPhi,iEta); iEBm++;} } coeffEBp->SetPoint(iPhi-1,iPhi-1,SumEBp/iEBp); coeffEBm->SetPoint(iPhi-1,iPhi-1,SumEBm/iEBm); } TFile* outputGraph = new TFile("output/GraphFor_P_Correction.root","RECREATE"); outputGraph->cd(); coeffEBp->Write("coeffEBp"); coeffEBm->Write("coeffEBm"); outputGraph->Close(); gROOT->Reset(); gROOT->SetStyle("Plain"); gStyle->SetPadTickX(1); gStyle->SetPadTickY(1); gStyle->SetOptTitle(1); gStyle->SetOptStat(0); gStyle->SetOptFit(0); gStyle->SetFitFormat("6.3g"); gStyle->SetPalette(1); gStyle->SetTextFont(42); gStyle->SetTextSize(0.05); gStyle->SetTitleFont(42,"xyz"); gStyle->SetTitleSize(0.05); gStyle->SetLabelFont(42,"xyz"); gStyle->SetLabelSize(0.05); gStyle->SetTitleXOffset(0.8); gStyle->SetTitleYOffset(1.1); gROOT->ForceStyle(); TCanvas* c1 = new TCanvas("mapMomentum","mapMomentum",1); c1->cd(); mapMomentum->GetXaxis()->SetTitle("#phi"); mapMomentum->GetXaxis()->SetNdivisions(20); c1->SetGridx(); mapMomentum->GetYaxis()->SetTitle("#eta"); mapMomentum->GetZaxis()->SetRangeUser(0.7,1.3); mapMomentum->Draw("colz"); TCanvas* c2 = new TCanvas("mapfbrem","mapfbrem",1); c2->cd(); mapfbrem->GetXaxis()->SetTitle("#phi"); mapfbrem->GetYaxis()->SetTitle("#eta"); mapfbrem->GetXaxis()->SetNdivisions(20); c2->SetGridx(); mapfbrem->GetZaxis()->SetRangeUser(0.,0.7); mapfbrem->Draw("colz"); TCanvas* c3 = new TCanvas("ratioMap","ratioMap",1); c3->cd(); ratioMap->GetXaxis()->SetTitle("#phi"); ratioMap->GetYaxis()->SetTitle("#eta"); ratioMap->GetXaxis()->SetNdivisions(20); c3->SetGridx(); ratioMap->GetZaxis()->SetRangeUser(0.7,1.3); ratioMap->Draw("colz"); TCanvas* c4 = new TCanvas("coeffEB","coeffEB",1); c4->cd(); coeffEBp->GetXaxis()->SetTitle("#phi"); coeffEBp->GetYaxis()->SetTitle("p/p_{true}"); coeffEBp -> SetMarkerStyle(20); coeffEBp -> SetMarkerSize(1); coeffEBp -> SetMarkerColor(kRed+1); coeffEBp -> SetLineColor(kRed+1); c4->SetGridx(); c4->SetGridy(); ratioMap->Draw("ap"); coeffEBm->GetXaxis()->SetTitle("#phi"); coeffEBm->GetYaxis()->SetTitle("p/p_{true}"); coeffEBm -> SetMarkerStyle(20); coeffEBm -> SetMarkerSize(1); coeffEBm -> SetMarkerColor(kBlue+1); coeffEBm -> SetLineColor(kBlue+1); coeffEBm->Draw("ap same"); theApp->Run(); return 0; }
void DoEvolutions( const TString &sim, Int_t time, Int_t Nbins=1, const TString &options="") { #ifdef __CINT__ gSystem->Load("libptools.so"); #endif PGlobals::Initialize(); // Palettes! gROOT->Macro("PPalettes.C"); TString opt = options; // cout << "options = " << opt << endl; // Load PData PData *pData = PData::Get(sim.Data()); pData->LoadFileNames(time); if(!pData->IsInit()) return; Bool_t CYL = kFALSE; if(sim.Contains("cyl")) { CYL = kTRUE; opt += "cyl"; } Bool_t ThreeD = kFALSE; if(sim.Contains("3D")) ThreeD = kTRUE; // Some plasma constants Double_t n0 = pData->GetPlasmaDensity(); Double_t kp = pData->GetPlasmaK(); Double_t skindepth = 1.0; if(kp!=0.0) skindepth = 1/kp; Double_t E0 = pData->GetPlasmaE0(); // Some initial beam properties: Float_t Ebeam = pData->GetBeamEnergy() * PUnits::MeV; Float_t gamma = pData->GetBeamGamma(); Float_t vbeam = pData->GetBeamVelocity(); Double_t rms0 = pData->GetBeamRmsY() * kp; if(CYL) rms0 = pData->GetBeamRmsR() * kp; // Time in OU Float_t Time = pData->GetRealTime(); // z start of the plasma in normalized units. Float_t zStartPlasma = pData->GetPlasmaStart() * kp; // z start of the beam in normalized units. Float_t zStartBeam = pData->GetBeamStart() * kp; if(opt.Contains("center")) { Time -= zStartPlasma; if(opt.Contains("comov")) // Centers on the head of the beam. Time += zStartBeam; } // Beam charge 2D and 1D histogram (on-axis) // ------------------------------------------------------------------ TH2F *hDen2D = NULL; if(pData->GetChargeFileName(1)) { char hName[24]; sprintf(hName,"hDen2D"); hDen2D = (TH2F*) gROOT->FindObject(hName); if(hDen2D) { delete hDen2D; hDen2D = NULL; } if(!ThreeD) hDen2D = pData->GetCharge(1,opt); else hDen2D = pData->GetCharge2DSliceZY(1,-1,1,opt+"avg"); hDen2D->SetName(hName); hDen2D->GetXaxis()->CenterTitle(); hDen2D->GetYaxis()->CenterTitle(); hDen2D->GetZaxis()->CenterTitle(); if(opt.Contains("comov")) hDen2D->GetXaxis()->SetTitle("k_{p}#zeta"); else hDen2D->GetXaxis()->SetTitle("k_{p}z"); if(CYL) hDen2D->GetYaxis()->SetTitle("k_{p}r"); else hDen2D->GetYaxis()->SetTitle("k_{p}y"); hDen2D->GetZaxis()->SetTitle("n_{b}/n_{0}"); } // Define ranges from the charge 2D histogram: // Binning for 2D histograms: // We get this values from the 2D density histogram. Int_t x1Nbin = hDen2D->GetNbinsX(); Float_t x1Range = (hDen2D->GetXaxis()->GetXmax() - hDen2D->GetXaxis()->GetXmin()); Float_t x1Mid = (hDen2D->GetXaxis()->GetXmax() + hDen2D->GetXaxis()->GetXmin())/2.; Float_t x1Min = hDen2D->GetXaxis()->GetXmin(); Float_t x1Max = hDen2D->GetXaxis()->GetXmax(); Int_t x2Nbin = hDen2D->GetNbinsY(); Float_t x2Range = (hDen2D->GetYaxis()->GetXmax() - hDen2D->GetYaxis()->GetXmin()); Float_t x2Mid = (hDen2D->GetYaxis()->GetXmax() + hDen2D->GetYaxis()->GetXmin())/2.; Float_t x2Min = x2Mid - x2Range/2; Float_t x2Max = x2Mid + x2Range/2; if(Nbins==0) { Nbins = TMath::Nint(rms0 / hDen2D->GetYaxis()->GetBinWidth(1)) ; // cout << Form(" Rms0 = %6.2f Dx = %6.2f Nbins = %4i .", // rms0, hDen2D->GetYaxis()->GetBinWidth(1), Nbins) << endl; } // Slice width limits. Int_t FirstyBin = 0; Int_t LastyBin = 0; if(!CYL) { FirstyBin = hDen2D->GetNbinsY()/2 + 1 - Nbins; LastyBin = hDen2D->GetNbinsY()/2 + Nbins; } else { FirstyBin = 1; LastyBin = Nbins; } // OUTPUT ROOT FILE WITH THE PLOTS: TString filename = Form("./%s/Plots/Evolutions/Evolutions-%s.root",sim.Data(),sim.Data()); TFile * ifile = (TFile*) gROOT->GetListOfFiles()->FindObject(filename); // if doesn't exist the directory should be created if (!ifile) { TString f = filename; TString dir2 = f.Remove( f.Last( '/' ), f.Length() - f.Last( '/' ) ); TString dir1 = f.Remove( f.Last( '/' ), f.Length() - f.Last( '/' ) ); gSystem->mkdir( dir1 ); gSystem->mkdir( dir2 ); ifile = new TFile(filename,"UPDATE"); } // Charge 1D histogram on axis TH1F *hDen1D = NULL; if(pData->GetChargeFileName(1)) { TString opth1 = opt; opth1 += "avg"; char hName[24]; sprintf(hName,"hDen1D"); hDen1D = (TH1F*) gROOT->FindObject(hName); if(hDen1D) delete hDen1D; if(ThreeD) { hDen1D = pData->GetH1SliceZ3D(pData->GetChargeFileName(1)->c_str(),"charge",-1,Nbins,-1,Nbins,opth1.Data()); } else if(CYL) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0). hDen1D = pData->GetH1SliceZ(pData->GetChargeFileName(1)->c_str(),"charge",1,Nbins,opth1.Data()); } else { // 2D cartesian hDen1D = pData->GetH1SliceZ(pData->GetChargeFileName(1)->c_str(),"charge",-1,Nbins,opth1.Data()); } hDen1D->SetName(hName); if(opt.Contains("comov")) hDen1D->GetXaxis()->SetTitle("k_{p}#zeta"); else hDen1D->GetXaxis()->SetTitle("k_{p}z"); hDen1D->GetYaxis()->SetTitle("n_{b}/n_{0}"); } // On-axis beam density vs \zeta vs time! _________________________________ TH2F *hDen1DvsTime = NULL; if(hDen1D) { char hName[24]; sprintf(hName,"hDen1DvsTime"); TH2F *hDen1DvsTimeOld = (TH2F*) ifile->Get(hName); Int_t nBins = 1; Float_t edge0 = Time-0.5; Float_t edge1 = Time+0.5; if(hDen1DvsTimeOld!=NULL) { nBins = hDen1DvsTimeOld->GetNbinsX()+1; Float_t binwidth = (Time - hDen1DvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1); edge0 = hDen1DvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.; edge1 = Time + binwidth/2.; } hDen1DvsTime = new TH2F("temp","",nBins,edge0,edge1, hDen1D->GetNbinsX(), hDen1D->GetBinLowEdge(1), hDen1D->GetBinLowEdge(hDen1D->GetNbinsX()+1)); for(Int_t ix=1;ix<hDen1DvsTime->GetNbinsX();ix++) { for(Int_t iy=1;iy<hDen1DvsTime->GetNbinsY();iy++) { hDen1DvsTime->SetBinContent(ix,iy,hDen1DvsTimeOld->GetBinContent(ix,iy)); } } delete hDen1DvsTimeOld; // Fill last bin with the newest values. for(Int_t iy=1;iy<=hDen1D->GetNbinsX();iy++) { hDen1DvsTime->SetBinContent(nBins,iy,hDen1D->GetBinContent(iy)); } hDen1DvsTime->GetZaxis()->SetTitle("n_{b}/n_{0}"); hDen1DvsTime->GetYaxis()->SetTitle("k_{p}#zeta"); hDen1DvsTime->GetXaxis()->SetTitle("k_{p}z"); hDen1DvsTime->GetZaxis()->CenterTitle(); hDen1DvsTime->GetYaxis()->CenterTitle(); hDen1DvsTime->GetXaxis()->CenterTitle(); hDen1DvsTime->SetName(hName); // Change the range of z axis Float_t Denmax = hDen1DvsTime->GetMaximum(); hDen1DvsTime->GetZaxis()->SetRangeUser(0,Denmax); hDen1DvsTime->Write(hName,TObject::kOverwrite); } // RMS (vs z) of the beam's charge distribution: TProfile *hDen2Dprof = NULL; TH1F *hRms = NULL; Double_t axisPos = x2Mid; if(hDen2D) { TString pname = hDen2D->GetName(); pname += "_pfx"; hDen2Dprof = (TProfile*) gROOT->FindObject(pname.Data()); if(hDen2Dprof) { delete hDen2Dprof; hDen2Dprof = NULL; } hDen2Dprof = hDen2D->ProfileX("_pfx",1,-1,"s"); hRms = (TH1F*) gROOT->FindObject("hRms"); if(hRms) delete hRms; hRms = new TH1F("hRms","",x1Nbin,x1Min,x1Max); if(CYL) axisPos = 0.0; for(Int_t j=0;j<hRms->GetNbinsX();j++) { Double_t rms = 0; Double_t total = 0; for(Int_t k=1;k<=x2Nbin;k++) { Double_t value = hDen2D->GetBinContent(j,k); Double_t radius = hDen2D->GetYaxis()->GetBinCenter(k) - axisPos; if(CYL) { rms += radius*radius*radius*value; total += radius*value; } else { rms += radius*radius*value; total += value; } // cout << Form(" (%i,%i) -> radius = %7.4f , density = %7.4f",j,k,radius,value) << endl; } rms /= total; rms = sqrt(rms); hRms->SetBinContent(j,rms); } hRms->GetXaxis()->SetTitle("k_{p}z"); if(opt.Contains("comov")) hRms->GetXaxis()->SetTitle("k_{p}#zeta"); hRms->GetYaxis()->SetTitle("k_{p}#LTr#GT_{rms}"); } // Transverse charge RMS vs \zeta vs time! _________________________________ TH2F *hRmsvsTime = NULL; if(hRms) { char hName[24]; sprintf(hName,"hRmsvsTime"); TH2F *hRmsvsTimeOld = (TH2F*) ifile->Get(hName); Int_t nBins = 1; Float_t edge0 = Time-0.5; Float_t edge1 = Time+0.5; if(hRmsvsTimeOld!=NULL) { nBins = hRmsvsTimeOld->GetNbinsX()+1; Float_t binwidth = (Time - hRmsvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1); edge0 = hRmsvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.; edge1 = Time + binwidth/2.; } hRmsvsTime = new TH2F("temp","",nBins,edge0,edge1, hRms->GetNbinsX(), hRms->GetBinLowEdge(1), hRms->GetBinLowEdge(hRms->GetNbinsX()+1)); for(Int_t ix=1;ix<hRmsvsTime->GetNbinsX();ix++) { for(Int_t iy=1;iy<hRmsvsTime->GetNbinsY();iy++) { hRmsvsTime->SetBinContent(ix,iy,hRmsvsTimeOld->GetBinContent(ix,iy)); } } delete hRmsvsTimeOld; // Fill last bin with the newest values. for(Int_t iy=1;iy<=hRms->GetNbinsX();iy++) { hRmsvsTime->SetBinContent(nBins,iy,hRms->GetBinContent(iy)); } hRmsvsTime->GetZaxis()->SetTitle("#LTr#GT_{rms}"); hRmsvsTime->GetYaxis()->SetTitle("k_{p}#zeta"); hRmsvsTime->GetXaxis()->SetTitle("k_{p}z"); hRmsvsTime->GetZaxis()->CenterTitle(); hRmsvsTime->GetYaxis()->CenterTitle(); hRmsvsTime->GetXaxis()->CenterTitle(); hRmsvsTime->SetName(hName); // Change the range of z axis Float_t Rmsmax = hRmsvsTime->GetMaximum(); hRmsvsTime->GetZaxis()->SetRangeUser(0,Rmsmax); hRmsvsTime->Write(hName,TObject::kOverwrite); } // INTEGRATED Beam's Charge: // Total charge vs time : TGraph *gQvsTime = NULL; if(hDen2D) { Double_t Q = 0; for(Int_t i=1;i<=x1Nbin;i++) { for(Int_t j=1;j<=x2Nbin;j++) { Double_t value = hDen2D->GetBinContent(i,j); if(CYL) { Double_t radius = hDen2D->GetYaxis()->GetBinCenter(j); Q += radius * value; // cout << Form(" (%i,%i) -> radius = %7.4f , value = %7.4f",i,j,radius,value) << endl; } else { Q += value; } } } Double_t xbinsize = hDen2D->GetXaxis()->GetBinWidth(1); Double_t ybinsize = hDen2D->GetYaxis()->GetBinWidth(1); Q *= xbinsize * ybinsize; if(!CYL && !ThreeD) { Q *= TMath::Sqrt(2*TMath::Pi()) * rms0; } else if(CYL) { Q *= 2*TMath::Pi(); } if(opt.Contains("units")) { Double_t dV = skindepth * skindepth * skindepth; Q *= n0 * dV; Q *= (PConst::ElectronCharge/PUnits::picocoulomb); cout << Form(" Integrated charge = %8i pC", TMath::Nint(Q)) << endl; } else { cout << Form(" Integrated charge = %8.4f n0 * kp^-3",Q) << endl; } Int_t nPoints = 0; char gName[32]; sprintf(gName,"gQvsTime"); gQvsTime = (TGraph*) ifile->Get(gName); if(gQvsTime==NULL) { gQvsTime = new TGraph(); gQvsTime->SetName(gName); nPoints = 0; // Some cosmetics at creation time: gQvsTime->SetLineWidth(3); gQvsTime->SetLineColor(PGlobals::fieldLine); gQvsTime->SetMarkerStyle(20); gQvsTime->SetMarkerSize(0.4); gQvsTime->SetMarkerColor(PGlobals::fieldLine); gQvsTime->GetYaxis()->SetTitle("charge [n_{0}/k_{p}^{3}]"); gQvsTime->GetXaxis()->SetTitle("k_{p}z"); } else { nPoints = gQvsTime->GetN(); } gQvsTime->Set(nPoints+1); gQvsTime->SetPoint(nPoints,Time,Q); gQvsTime->Write(gName,TObject::kOverwrite); } // ------------------------------------------------------------------------------------ // Longitudinal phasespace Int_t gNbin = 100; // Float_t gMin = 80; // Float_t gMax = 120; Float_t gMin = 43.07 - 1.2; Float_t gMax = 43.07 + 1.2; TH2F *hGvsZ = NULL; if(pData->GetRawFileName(1)) { char hName[24]; sprintf(hName,"hGvsZ"); hGvsZ = (TH2F*) gROOT->FindObject(hName); if(hGvsZ) { delete hGvsZ; hGvsZ = NULL; } hGvsZ = new TH2F(hName,"",x1Nbin,x1Min,x1Max,gNbin,gMin,gMax); pData->GetH2Raw(pData->GetRawFileName(1)->c_str(),"x1","gamma",hGvsZ,opt); hGvsZ->GetXaxis()->CenterTitle(); hGvsZ->GetYaxis()->CenterTitle(); hGvsZ->GetZaxis()->CenterTitle(); hGvsZ->GetYaxis()->SetTitle("#gamma"); if(opt.Contains("comov")) { hGvsZ->GetXaxis()->SetTitle("k_{p}#zeta"); hGvsZ->GetZaxis()->SetTitle("dN/d#zetad#gamma [a.u.]"); } else { hGvsZ->GetXaxis()->SetTitle("k_{p}z"); hGvsZ->GetZaxis()->SetTitle("dN/dzd#gamma [a.u.]"); } } else { cout << Form("--> No RAW data file is present for species 1") << endl; } TH2F *hGvsTime = NULL; TProfile *hGvsZprof = NULL; TGraphErrors *gGvsZ = NULL; if(hGvsZ) { TString pname = hGvsZ->GetName(); pname += "_pfx"; hGvsZprof = (TProfile*) gROOT->FindObject(pname.Data()); if(hGvsZprof) delete hGvsZprof; hGvsZprof = hGvsZ->ProfileX("_pfx",1,-1,"s"); gGvsZ = (TGraphErrors*) gROOT->FindObject("gGvsZ"); if(gGvsZ) delete gGvsZ; Int_t Npoints = hGvsZprof->GetNbinsX(); Double_t *x = new Double_t[Npoints]; Double_t *y = new Double_t[Npoints]; Double_t *ex = new Double_t[Npoints]; Double_t *ey = new Double_t[Npoints]; for(Int_t j=0;j<Npoints;j++) { x[j] = hGvsZprof->GetBinCenter(j); y[j] = hGvsZprof->GetBinContent(j); ex[j] = 0; ey[j] = hGvsZprof->GetBinError(j); } gGvsZ = new TGraphErrors(Npoints,x,y,ex,ey); gGvsZ->SetName("gGvsZ"); // PGlobals::SetH1Style((TH1*)gGvsZ,1); PGlobals::SetGraphStyle(gGvsZ,1); if(opt.Contains("comov")) gGvsZ->GetXaxis()->SetTitle("k_{p}#zeta"); else gGvsZ->GetXaxis()->SetTitle("k_{p}z"); gGvsZ->GetYaxis()->SetTitle("#LT#gamma#GT [MeV]"); char hName[24]; sprintf(hName,"hGvsTime"); TH2F *hGvsTimeOld = (TH2F*) ifile->Get(hName); Int_t nBins = 1; Float_t edge0 = Time-0.5; Float_t edge1 = Time+0.5; if(hGvsTimeOld!=NULL) { nBins = hGvsTimeOld->GetNbinsX()+1; Float_t binwidth = (Time - hGvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1); edge0 = hGvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.; edge1 = Time + binwidth/2.; } hGvsTime = new TH2F("temp","",nBins,edge0,edge1, hGvsZprof->GetNbinsX(), hGvsZprof->GetBinLowEdge(1), hGvsZprof->GetBinLowEdge(hGvsZprof->GetNbinsX()+1)); for(Int_t ix=1;ix<hGvsTime->GetNbinsX();ix++) { for(Int_t iy=1;iy<hGvsTime->GetNbinsY();iy++) { hGvsTime->SetBinContent(ix,iy,hGvsTimeOld->GetBinContent(ix,iy)); } } delete hGvsTimeOld; // Fill last bin with the newest values. for(Int_t iy=1;iy<=hGvsZprof->GetNbinsX();iy++) { hGvsTime->SetBinContent(nBins,iy,hGvsZprof->GetBinContent(iy)); } hGvsTime->GetZaxis()->SetTitle("#LT#gamma#GT"); hGvsTime->GetYaxis()->SetTitle("k_{p}#zeta"); hGvsTime->GetXaxis()->SetTitle("k_{p}z"); hGvsTime->GetZaxis()->CenterTitle(); hGvsTime->GetYaxis()->CenterTitle(); hGvsTime->GetXaxis()->CenterTitle(); hGvsTime->SetName(hName); // Change the range of z axis Float_t Gmax = hGvsTime->GetMaximum(); Float_t Gmin = hGvsTime->GetMinimum(); hGvsTime->GetZaxis()->SetRangeUser(Gmin,Gmax); hGvsTime->Write(hName,TObject::kOverwrite); } // --------------------------------------------------------------------------------- // EM fields on - axis : TString opth1 = opt; opth1 += "avg"; // Get electric fields const Int_t Nfields = 2; TH1F **hE1D = new TH1F*[Nfields]; for(Int_t i=0;i<Nfields;i++) { hE1D[i] = NULL; if(!pData->GetEfieldFileName(i)) continue; char nam[3]; sprintf(nam,"e%i",i+1); if(ThreeD) { if(i==0) hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,-1,Nbins,opth1.Data()); else hE1D[i] = pData->GetH1SliceZ3D(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,-Nbins,Nbins,opth1.Data()); } else if(CYL) { // Cylindrical: The first bin with r>0 is actually the number 1 (not the 0). if(i==0) hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opth1.Data()); else hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,1,Nbins,opth1.Data()); } else { // 2D cartesian if(i==0) hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-1,Nbins,opth1.Data()); else hE1D[i] = pData->GetH1SliceZ(pData->GetEfieldFileName(i)->c_str(),nam,-Nbins,Nbins,opth1.Data()); } char hName[24]; sprintf(hName,"hE_%i_%i",i,time); hE1D[i]->SetName(hName); if(opt.Contains("comov")) hE1D[i]->GetXaxis()->SetTitle("k_{p}#zeta"); else hE1D[i]->GetXaxis()->SetTitle("k_{p}z"); if(i==0) hE1D[i]->GetYaxis()->SetTitle("E_{z}/E_{0}"); else if(i==1) hE1D[i]->GetYaxis()->SetTitle("E_{y}/E_{0}"); else if(i==2) hE1D[i]->GetYaxis()->SetTitle("E_{x}/E_{0}"); hE1D[i]->GetYaxis()->CenterTitle(); hE1D[i]->GetXaxis()->CenterTitle(); } // Calculate wave positions: // ---------------------------------------------------------------- // Calculate the crossings and the extremes of the Electric fields Float_t Ecross[Nfields][100] = {{0.0}}; Float_t Eextr[Nfields][100] = {{0.0}}; Int_t Ncross[Nfields] = {0}; for(Int_t i=0;i<Nfields;i++) { Ncross[i] = 0; if(!hE1D[i]) continue; // Only smooths the focusing if flag activated.. if(i>0 && opt.Contains("smooth")) { // cout << " Smoothing fields on axis..." << endl; hE1D[i]->Smooth(10); } Float_t maxZeta = zStartBeam; if(opt.Contains("center")) maxZeta -= zStartBeam; for(Int_t ip=hE1D[i]->GetNbinsX();ip>1;ip--) { Float_t Z2 = hE1D[i]->GetBinCenter(ip-1); if(Z2 > maxZeta) continue; Float_t E1 = hE1D[i]->GetBinContent(ip); Float_t E2 = hE1D[i]->GetBinContent(ip-1); Float_t Z1 = hE1D[i]->GetBinCenter(ip); // cout << Form("Z1 = %6.4f Z2 = %6.4f E1 = %6.4f E2 = %6.4f", Z1, Z2, E1, E2) << endl; if(E1*E2 >= 0) { // No change of sign means we are in a side of the zero axis. if(fabs(E2)>fabs(Eextr[i][Ncross[i]])) { Eextr[i][Ncross[i]] = E2; } } if(E1*E2 < 0) { // change of sign means a crossing! // The next crossing has to be far enough from the previous one: Float_t zcross = -E1 * ( (Z2-Z1)/(E2-E1) ) + Z1; if(Ncross[i]>0 && fabs(Ecross[i][Ncross[i]-1]-zcross)<TMath::PiOver2() ) continue; // cout << " CROSS! " << endl; // add the point Ecross[i][Ncross[i]] = zcross; Ncross[i]++; } } cout << " -> Number of crossings for field " << i << " : " << Ncross[i] << endl; for(Int_t ic=0;ic<Ncross[i];ic++) { // cout << Form(" %2i: zeta = %6.4f E = %6.4f", ic, Ecross[i][ic], Eextr[i][ic]) << endl; } hE1D[i]->SetLineColor(kRed); hE1D[i]->Write(hE1D[i]->GetName(),TObject::kOverwrite); } // Get the Graphs and histos from file Int_t nPoints = 0; TGraph ***gEcross = new TGraph**[Nfields]; TGraph ***gEextr = new TGraph**[Nfields]; TH2F **hEvsTime = new TH2F*[Nfields]; for(Int_t i=0;i<Nfields;i++) { char hName[24]; sprintf(hName,"hEvsTime_%i",i); TH2F *hEvsTimeOld = (TH2F*) ifile->Get(hName); Int_t nBins = 1; Float_t edge0 = Time-0.5; Float_t edge1 = Time+0.5; if(hEvsTimeOld!=NULL) { nBins = hEvsTimeOld->GetNbinsX()+1; Float_t binwidth = (Time - hEvsTimeOld->GetXaxis()->GetBinCenter(1))/(nBins-1); edge0 = hEvsTimeOld->GetXaxis()->GetBinCenter(1) - binwidth/2.; edge1 = Time + binwidth/2.; } hEvsTime[i] = new TH2F("temp","",nBins,edge0,edge1, hE1D[i]->GetNbinsX(), hE1D[i]->GetBinLowEdge(1), hE1D[i]->GetBinLowEdge(hE1D[i]->GetNbinsX()+1)); for(Int_t ix=1;ix<hEvsTime[i]->GetNbinsX();ix++) { for(Int_t iy=1;iy<hEvsTime[i]->GetNbinsY();iy++) { hEvsTime[i]->SetBinContent(ix,iy,hEvsTimeOld->GetBinContent(ix,iy)); } } delete hEvsTimeOld; // Fill last bin with the newest values. for(Int_t iy=1;iy<=hE1D[i]->GetNbinsX();iy++) { hEvsTime[i]->SetBinContent(nBins,iy,hE1D[i]->GetBinContent(iy)); } if(i==0) hEvsTime[i]->GetZaxis()->SetTitle("E_{z}/E_{0}"); else if(i==1) hEvsTime[i]->GetZaxis()->SetTitle("E_{y}/E_{0}"); else if(i==2) hEvsTime[i]->GetZaxis()->SetTitle("E_{x}/E_{0}"); hEvsTime[i]->GetYaxis()->SetTitle("k_{p}#zeta"); hEvsTime[i]->GetXaxis()->SetTitle("k_{p}z"); hEvsTime[i]->GetZaxis()->CenterTitle(); hEvsTime[i]->GetYaxis()->CenterTitle(); hEvsTime[i]->GetXaxis()->CenterTitle(); hEvsTime[i]->SetName(hName); // Change the range of z axis for the fields to be symmetric. Float_t Emax = hEvsTime[i]->GetMaximum(); Float_t Emin = hEvsTime[i]->GetMinimum(); if(Emax > TMath::Abs(Emin)) Emin = -Emax; else Emax = -Emin; hEvsTime[i]->GetZaxis()->SetRangeUser(Emin,Emax); hEvsTime[i]->Write(hName,TObject::kOverwrite); // --- gEcross[i] = new TGraph*[Ncross[i]]; gEextr[i] = new TGraph*[Ncross[i]]; char gName[24]; Int_t ifail = 0; for(Int_t ic=0;ic<Ncross[i];ic++) { sprintf(gName,"gEcross_%i_%i",i,ic); gEcross[i][ic] = (TGraph*) ifile->Get(gName); if(gEcross[i][ic]==NULL) { gEcross[i][ic] = new TGraph(); gEcross[i][ic]->SetName(gName); nPoints = 0; // Some cosmetics at creation time: if(i==1) gEcross[i][ic]->SetLineStyle(2); else gEcross[i][ic]->SetLineStyle(1); gEcross[i][ic]->SetLineWidth(1); gEcross[i][ic]->SetLineColor(kGray+1); gEcross[i][ic]->SetMarkerStyle(20); gEcross[i][ic]->SetMarkerSize(0.4); gEcross[i][ic]->SetMarkerColor(kGray+1); gEcross[i][ic]->GetYaxis()->SetTitle("k_{p}#zeta]"); gEcross[i][ic]->GetXaxis()->SetTitle("k_{p}z"); } else { nPoints = gEcross[i][ic]->GetN(); } // Check the new crossings respect the previous ones: // Double_t t,zeta; // if(nPoints>0) { // gEcross[i][ic]->GetPoint(nPoints-1,t,zeta); // if(fabs(zeta-Ecross[i][ic+ifail])>TMath::Pi()) { // ic--; // ifail++; // continue; // } // } gEcross[i][ic]->Set(nPoints+1); gEcross[i][ic]->SetPoint(nPoints,Time,Ecross[i][ic+ifail]); gEcross[i][ic]->Write(gName,TObject::kOverwrite); // if(ic==Ncross[i]-1) continue; sprintf(gName,"gEextr_%i_%i",i,ic); gEextr[i][ic] = (TGraph*) ifile->Get(gName); if(gEextr[i][ic]==NULL) { gEextr[i][ic] = new TGraph(); gEextr[i][ic]->SetName(gName); nPoints = 0; // Some cosmetics at creation time: if(i==0) { gEextr[i][ic]->SetLineWidth(3); gEextr[i][ic]->SetLineColor(PGlobals::fieldLine); gEextr[i][ic]->SetMarkerStyle(20); gEextr[i][ic]->SetMarkerSize(0.4); gEextr[i][ic]->SetMarkerColor(PGlobals::fieldLine); gEextr[i][ic]->GetYaxis()->SetTitle("E_{z}/E_{0}"); gEextr[i][ic]->GetXaxis()->SetTitle("k_{p}z"); } else if(i==1) { gEextr[i][ic]->SetLineWidth(1); gEextr[i][ic]->SetLineColor(kGray+2); gEextr[i][ic]->SetMarkerStyle(20); gEextr[i][ic]->SetMarkerSize(0.4); gEextr[i][ic]->SetMarkerColor(kGray+2); gEextr[i][ic]->GetYaxis()->SetTitle("E_{y}/E_{0}"); gEextr[i][ic]->GetXaxis()->SetTitle("k_{p}z"); } } else { nPoints = gEextr[i][ic]->GetN(); } gEextr[i][ic]->Set(nPoints+1); gEextr[i][ic]->SetPoint(nPoints,Time,Eextr[i][ic]); gEextr[i][ic]->Write(gName,TObject::kOverwrite); } } ifile->Close(); }
void AverageMW() { // include NuTeV? if( inclNuTeV ) nVals = 5; else nVals = 4; // number of parameters const int npar = 1; // create minuit pointer TMinuit *minuit = new TMinuit( npar ); // set FCN function minuit->SetFCN( &fcn ); // -1=quiet, 0=normal, 1=verbose minuit->SetPrintLevel( 0 ); // start values Double_t startVal = 80; Double_t fitStep = 0.1; Double_t limitMin = 70; Double_t limitMax = 90; minuit->DefineParameter( 0, "MW", startVal, fitStep, limitMin, limitMax); // minimize with MIGRAD Int_t ierr = 0; Double_t args[2]; args[0] = 0; // maximum function calls (0=default) args[1] = 0; // tolerance at minimum (0=default) minuit->mnexcm( "MIGrad", args, 2, ierr ); if ( ierr != 0 ) cout << "Warning: Maybe fit didn't converge!" << endl; // fit results Double_t fitval_MW[1], fiterr_MW[1]; minuit->GetParameter( 0, fitval_MW[0], fiterr_MW[0] ); cout << "\n\n*************************************************" << endl; cout << " chi2Min = " << chi2Min << endl; cout << " n_dof = " << nVals-1 << endl; cout << " p-value = " << TMath::Prob(chi2Min, nVals-1) << endl; cout << " MW = " << fitval_MW[0] << " +- " << fiterr_MW[0] << endl; cout << "*************************************************" << endl; // make plot gStyle->SetOptTitle(0); gStyle->SetOptStat(0); gStyle->SetOptFit(0); TCanvas* c = new TCanvas( "c", "Mean of W boson mass", 0, 0, 850, 500 ); c->SetGridy(); TH2F *frame = new TH2F("frame", "Mean of W boson mass", 1, 80, 80.6, 5, 0, 5. ); frame->SetLineColor(0); frame->SetTickLength(0,"Y"); frame->SetXTitle("M_{W} [GeV]"); frame->GetYaxis()->CenterLabels( 1 ); frame->GetYaxis()->SetNdivisions( frame->GetNbinsY()+10, 1 ); frame->GetYaxis()->SetBinLabel( 1, "" ); // no labels frame->Draw(); // make labels MakeLabels(frame); // draw fit value DrawFitValue( frame, fitval_MW[0], fiterr_MW[0] ); // draw measurements for( Int_t i=0; i<5; i++ ){ DrawMeasurement( frame, 4-i, val_MW[i], err_MW[i] ); } // Redraw axis frame->Draw("sameaxis"); }
int main (int argc, char *argv[]) { printBoxedMessage("Starting plot generation"); // #################### // ## Init tools ## // #################### string signalCategory = "T2tt"; // Create a sonic Screwdriver SonicScrewdriver screwdriver; // ########################## // ## Create Variables ## // ########################## screwdriver.AddVariable("METoverSqrtHT", "MET / #sqrt{H_{T}}", "", 32,0,32, &(myEvent.METoverSqrtHT), ""); screwdriver.AddVariable("MET", "MET", "GeV", 15,50,500, &(myEvent.MET), "logY=true"); screwdriver.AddVariable("MT", "MT", "GeV", 20,0,400, &(myEvent.MT), "logY=true"); screwdriver.AddVariable("MT2W", "M_{T2}^{W}", "GeV", 20,0,500, &(myEvent.MT2W), ""); screwdriver.AddVariable("deltaPhiMETJets","#Delta#Phi(MET,j_{1,2})", "rad", 16,0,3.2, &(myEvent.deltaPhiMETJets), ""); screwdriver.AddVariable("HadronicChi2", "Hadronic #chi^{2}", "", 40,0,20, &(myEvent.hadronicChi2), ""); screwdriver.AddVariable("mStop", "m_{#tilde{t}}", "GeV", 28,112.5,812.5, &(myEvent.mStop), ""); screwdriver.AddVariable("mNeutralino", "m_{#chi^{0}}", "GeV", 16,-12.5,387.5, &(myEvent.mNeutralino), "noOverflowInLastBin"); // ######################################################### // ## Create ProcessClasses (and associated datasets) ## // ######################################################### screwdriver.AddProcessClass("1ltop", "1l top", "background",kRed-7); #ifdef USING_TTBAR_POWHEG screwdriver.AddDataset("ttbar_powheg", "1ltop", 0, 0); #endif #ifdef USING_TTBAR_MADGRAPH screwdriver.AddDataset("ttbar_madgraph_1l", "1ltop", 0, 0); #endif screwdriver.AddDataset("singleTop_st", "1ltop", 0, 0); screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3); #ifdef USING_TTBAR_MADGRAPH screwdriver.AddDataset("ttbar_madgraph_2l", "ttbar_2l", 0, 0); #endif screwdriver.AddProcessClass("W+jets", "W+jets", "background", kOrange-2); screwdriver.AddDataset("W+jets", "W+jets", 0, 0); screwdriver.AddProcessClass("rare", "rare", "background", kMagenta-5); screwdriver.AddDataset("rare", "rare", 0, 0); screwdriver.AddProcessClass(signalCategory, signalCategory, "signal", kViolet-1); screwdriver.AddDataset(signalCategory, signalCategory, 0, 0); screwdriver.AddProcessClass("signal_250_100", signalCategory+" (250/100)", "signal",COLORPLOT_BLUE ); screwdriver.AddProcessClass("signal_450_100", signalCategory+" (450/100)", "signal",COLORPLOT_GREEN2 ); screwdriver.AddProcessClass("signal_650_100", signalCategory+" (650/100)", "signal",COLORPLOT_GREEN ); // ########################## // ## Create Regions ## // ########################## screwdriver.AddRegion("presel", "Preselection", &goesInPreselectionMTtail); screwdriver.AddRegion("offShell_Loose", "Cut&Count;Off-shell Loose", &Selector_cutAndCount_offShellLoose); screwdriver.AddRegion("offShell_Tight", "Cut&Count;Off-shell tight", &Selector_cutAndCount_offShellTight); screwdriver.AddRegion("lowDM", "Cut&Count;Low #DeltaM", &Selector_cutAndCount_lowDeltaM ); screwdriver.AddRegion("mediumDM", "Cut&Count;Medium #DeltaM", &Selector_cutAndCount_mediumDeltaM ); screwdriver.AddRegion("highDM", "Cut&Count;High #DeltaM", &Selector_cutAndCount_highDeltaM ); // ########################## // ## Create Channels ## // ########################## screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel); // ######################################## // ## Create histograms and ## // ## schedule type of plots to produce ## // ######################################## screwdriver.SetLumi(20000); // Create histograms screwdriver.Create1DHistos(); screwdriver.Add2DHisto("mStop","mNeutralino"); screwdriver.SetGlobalBoolOption ("1DSuperimposed", "includeSignal", true ); screwdriver.SetGlobalStringOption("1DStack", "includeSignal", "stack"); screwdriver.SetGlobalFloatOption ("1DStack", "factorSignal", 1.0 ); screwdriver.SetGlobalStringOption("DataMCComparison", "includeSignal", "stack"); screwdriver.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 1.0 ); // Schedule plots screwdriver.SchedulePlots("1DSuperimposed"); screwdriver.SchedulePlots("1DStack"); screwdriver.SchedulePlots("2D"); screwdriver.SchedulePlots("2DSuperimposed"); // Config plots screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Internal"); screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 20 fb^{-1}"); screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true); screwdriver.SetGlobalBoolOption("Plot", "exportEps", false); screwdriver.SetGlobalBoolOption("Plot", "exportPng", false); // ######################################## // ## Run over the datasets ## // ######################################## vector<string> datasetsList; screwdriver.GetDatasetList(&datasetsList); cout << " > Reading datasets... " << endl; cout << endl; for (unsigned int d = 0 ; d < datasetsList.size() ; d++) { string currentDataset = datasetsList[d]; string currentProcessClass = screwdriver.GetProcessClass(currentDataset); // Open the tree TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str()); TTree* theTree = (TTree*) f.Get("babyTuple"); intermediatePointers pointers; InitializeBranchesForReading(theTree,&myEvent,&pointers); sampleName = currentDataset; sampleType = screwdriver.GetProcessClassType(currentProcessClass); if (currentDataset == signalCategory) { theTree->SetBranchAddress("mStop", &(myEvent.mStop)); theTree->SetBranchAddress("mNeutralino", &(myEvent.mNeutralino)); } else { myEvent.mStop = -1; myEvent.mNeutralino = -1; } // ######################################## // ## Run over the events ## // ######################################## int nEntries = theTree->GetEntries(); for (int i = 0 ; i < nEntries ; i++) //for (int i = 0 ; i < min(200000, (int) theTree->GetEntries()); i++) { if (i % (theTree->GetEntries() / 50) == 0) printProgressBar(i,nEntries,currentDataset); // Get the i-th entry ReadEvent(theTree,i,&pointers,&myEvent); // Split 1-lepton ttbar and 2-lepton ttbar string currentProcessClass_ = currentProcessClass; if ((currentDataset == "ttbar_powheg") && (myEvent.numberOfGenLepton == 2)) currentProcessClass_ = "ttbar_2l"; screwdriver.AutoFillProcessClass(currentProcessClass_,getWeight()); if ((myEvent.mStop == 250) && (myEvent.mNeutralino == 100)) screwdriver.AutoFillProcessClass("signal_250_100",getWeight()); if ((myEvent.mStop == 450) && (myEvent.mNeutralino == 100)) screwdriver.AutoFillProcessClass("signal_450_100",getWeight()); if ((myEvent.mStop == 650) && (myEvent.mNeutralino == 100)) screwdriver.AutoFillProcessClass("signal_650_100",getWeight()); } printProgressBar(nEntries,nEntries,currentDataset); cout << endl; f.Close(); } // ################################### // ## Make plots and write them ## // ################################### cout << endl; cout << " > Making plots..." << endl; screwdriver.MakePlots(); cout << " > Saving plots..." << endl; screwdriver.WritePlots("../plots/cutAndCount_performances/"+signalCategory+"/"); printBoxedMessage("Plot generation completed"); // ############################# // ## Post-plotting tests ## // ############################# printBoxedMessage("Now computing misc tests ... "); vector<string> cutAndCountRegions = { "offShell_Loose", "offShell_Tight", "lowDM", "mediumDM", "highDM" }; TableBackgroundSignal(&screwdriver,cutAndCountRegions,"singleLepton").Print(); TableBackgroundSignal(&screwdriver,cutAndCountRegions,"singleLepton").PrintLatex(); // ########################## // ## Compute FOM maps ## // ########################## float SF_1ltop = 5; vector<float> globalBackgroundUncertainty = { 0.17, 0.21, 0.22, 0.37, 0.37 }; vector<TH2F*> signalMaps; vector<TH2F*> FOMdiscoveryMaps; vector<TH2F*> FOMexclusionMaps; vector<TH2F*> efficiencies; int nBinsX = -1; int nBinsY = -1; TH2F* signalMapPresel = screwdriver.get2DHistoClone("mStop","mNeutralino",signalCategory,"presel","singleLepton"); TH2F* backgroundPresel = screwdriver.get2DCompositeHistoClone("mStop","mNeutralino","2DSumBackground","presel","singleLepton",""); if (nBinsX == -1) nBinsX = signalMapPresel->GetNbinsX(); if (nBinsY == -1) nBinsY = signalMapPresel->GetNbinsY(); // Store background eff in (mStop,mLSP) = (200,300) int backgroundBin = signalMapPresel->FindBin(200,300); float backgroundYieldPresel = backgroundPresel->Integral(0,nBinsX+1,0,nBinsY+1); for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++) { signalMaps.push_back(screwdriver.get2DHistoClone("mStop","mNeutralino",signalCategory,cutAndCountRegions[i],"singleLepton")); signalMaps[i]->SetName((string("signalMap_")+cutAndCountRegions[i]).c_str()); float B = screwdriver.GetYieldAndError("1ltop", cutAndCountRegions[i],"singleLepton").value() //* SF_1ltop + screwdriver.GetYieldAndError("ttbar_2l", cutAndCountRegions[i],"singleLepton").value() + screwdriver.GetYieldAndError("W+jets", cutAndCountRegions[i],"singleLepton").value() + screwdriver.GetYieldAndError("rare", cutAndCountRegions[i],"singleLepton").value(); // Apply scale factor from background prediction //float f_B = globalBackgroundUncertainty[i]; float f_B = 0.15; if (B < 1.0) B = 1.0; efficiencies.push_back((TH2F*) signalMaps[i]->Clone()); efficiencies[i]->SetName((string("eff_")+cutAndCountRegions[i]).c_str()); efficiencies[i]->Divide(signalMapPresel); efficiencies[i]->SetBinContent(backgroundBin,B/backgroundYieldPresel); FOMdiscoveryMaps.push_back((TH2F*) signalMaps[i]->Clone()); FOMdiscoveryMaps[i]->SetName((string("FOMdisco_")+cutAndCountRegions[i]).c_str()); FOMexclusionMaps.push_back((TH2F*) signalMaps[i]->Clone()); FOMexclusionMaps[i]->SetName((string("FOMexclu_")+cutAndCountRegions[i]).c_str()); for (int x = 1 ; x <= nBinsX ; x++) for (int y = 1 ; y <= nBinsY ; y++) { float S = signalMaps[i]->GetBinContent(x,y); float FOMdiscovery = figureOfMerit(S,B,"discovery",false,f_B); FOMdiscoveryMaps[i]->SetBinContent(x,y,FOMdiscovery); float FOMexclusion = figureOfMerit(S,B,"exclusion",false,f_B); FOMexclusionMaps[i]->SetBinContent(x,y,FOMexclusion); } } // ################################ // ## Compute "best" FOM map ## // ################################ TH2F* bestDiscoFOMMap = (TH2F*) signalMaps[0]->Clone(); bestDiscoFOMMap->SetName("bestDiscoFOM"); TH2F* bestDiscoSetMap = (TH2F*) signalMaps[0]->Clone(); bestDiscoSetMap->SetName("bestDiscoSet"); TH2F* bestDiscoSigEff = (TH2F*) signalMaps[0]->Clone(); bestDiscoSigEff->SetName("bestDiscoSigEff"); TH2F* bestDiscoBkgEff = (TH2F*) signalMaps[0]->Clone(); bestDiscoBkgEff->SetName("bestDiscoBkgEff"); TH2F* bestExcluFOMMap = (TH2F*) signalMaps[0]->Clone(); bestExcluFOMMap->SetName("bestExcluFOM"); TH2F* bestExcluSetMap = (TH2F*) signalMaps[0]->Clone(); bestExcluSetMap->SetName("bestExcluSet"); TH2F* bestExcluSigEff = (TH2F*) signalMaps[0]->Clone(); bestExcluSigEff->SetName("bestExcluSigEff"); TH2F* bestExcluBkgEff = (TH2F*) signalMaps[0]->Clone(); bestExcluBkgEff->SetName("bestExcluBkgEff"); for (int x = 1 ; x <= nBinsX ; x++) for (int y = 1 ; y <= nBinsY ; y++) { float bestDiscoFOM = -1.0; int bestDiscoSet = 0; float bestDiscoSigEff_ = -1.0; float bestDiscoBkgEff_ = -1.0; for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++) { float DiscoFOM = FOMdiscoveryMaps[i]->GetBinContent(x,y); if (bestDiscoFOM < DiscoFOM) { bestDiscoFOM = DiscoFOM; if (bestDiscoFOM > 0) bestDiscoSet = i+1; bestDiscoSigEff_ = efficiencies[i]->GetBinContent(x,y); bestDiscoBkgEff_ = efficiencies[i]->GetBinContent(backgroundBin); } } bestDiscoFOMMap->SetBinContent(x,y,bestDiscoFOM); bestDiscoSetMap->SetBinContent(x,y,bestDiscoSet); bestDiscoSigEff->SetBinContent(x,y,bestDiscoSigEff_); bestDiscoBkgEff->SetBinContent(x,y,bestDiscoBkgEff_); float bestExcluFOM = -1.0; int bestExcluSet = 0; float bestExcluSigEff_ = -1.0; float bestExcluBkgEff_ = -1.0; for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++) { float ExcluFOM = FOMexclusionMaps[i]->GetBinContent(x,y); if (bestExcluFOM < ExcluFOM) { bestExcluFOM = ExcluFOM; if (bestExcluFOM > 0) bestExcluSet = i+1; bestExcluSigEff_ = efficiencies[i]->GetBinContent(x,y); bestExcluBkgEff_ = efficiencies[i]->GetBinContent(backgroundBin); } } bestExcluFOMMap->SetBinContent(x,y,bestExcluFOM); bestExcluSetMap->SetBinContent(x,y,bestExcluSet); bestExcluSigEff->SetBinContent(x,y,bestExcluSigEff_); bestExcluBkgEff->SetBinContent(x,y,bestExcluBkgEff_); } // ######################### // ## Save those maps ## // ######################### float lineOffset = 0.0; string label; if (signalCategory == "T2tt" ) { lineOffset = 172; label = "T2tt;"; } if (signalCategory == "T2bw-025") { lineOffset = 320; label = "T2bw (x = 0.25);"; } if (signalCategory == "T2bw-050") { lineOffset = 160; label = "T2bw (x = 0.50);"; } if (signalCategory == "T2bw-075") { lineOffset = 105; label = "T2bw (x = 0.75);"; } TFile fOutput(("../plots/cutAndCount_performances/"+signalCategory+"/custom.root").c_str(),"RECREATE"); string pathExport = "../plots/cutAndCount_performances/"+signalCategory+"/"; gStyle->SetPaintTextFormat("4.0f"); formatAndWriteMapPlot(&screwdriver,bestDiscoSetMap,bestDiscoSetMap->GetName(),label+"Best set of cuts;(for discovery)",pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestExcluSetMap,bestExcluSetMap->GetName(),label+"Best set of cuts;(for exclusion)",pathExport,lineOffset); gStyle->SetPaintTextFormat("4.1f"); for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++) { FOMdiscoveryMaps[i]->SetMaximum(5.0); formatAndWriteMapPlot(&screwdriver,FOMdiscoveryMaps[i],FOMdiscoveryMaps[i]->GetName(),string("Discovery FOM for ")+cutAndCountRegions[i], pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver, efficiencies[i], efficiencies[i]->GetName(),string("Efficiencies for " )+cutAndCountRegions[i], pathExport,lineOffset); } bestDiscoFOMMap->SetMaximum(5.0); bestExcluFOMMap->SetMaximum(5.0); formatAndWriteMapPlot(&screwdriver,bestDiscoFOMMap,bestDiscoFOMMap->GetName(),label+"Best FOM;(for discovery)" ,pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestDiscoSigEff,bestDiscoSigEff->GetName(),label+"Best signal efficiency;(for discovery)",pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestDiscoBkgEff,bestDiscoBkgEff->GetName(),label+"Best backgr efficiency;(for discovery)",pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestExcluFOMMap,bestExcluFOMMap->GetName(),label+"Best FOM;(for exclusion)" ,pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestExcluSigEff,bestExcluSigEff->GetName(),label+"Best signal efficiency;(for exclusion)",pathExport,lineOffset); formatAndWriteMapPlot(&screwdriver,bestExcluBkgEff,bestExcluBkgEff->GetName(),label+"Best backgr efficiency;(for exclusion)",pathExport,lineOffset); fOutput.Close(); printBoxedMessage("Program done."); return (0); }
void Optimize2D(TString signal, TString background, TString histname, int minxwidth = 2, int minywidth = 2, float minsigeff=0.5){ TFile *sigfile = TFile::Open(signal); TFile *bkgfile = TFile::Open(background); TH2F *sighist = (TH2F*)sigfile->Get(histname); TH2F *bkghist = (TH2F*)bkgfile->Get(histname); int nxbins = sighist->GetNbinsX(); int nybins = sighist->GetNbinsY(); if ( nxbins != bkghist->GetNbinsX() || nybins != bkghist->GetNbinsY() ) { cout << "Error! The two input histograms do not have the same number of bins!" << endl; return; } int nsigtot = sighist->Integral(1,nxbins,1,nybins); int nbkgtot = bkghist->Integral(1,nxbins,1,nybins); cout << "Total number of entries in the signal histogram: " << nsigtot << endl; cout << "Total number of entries in the bkgrnd histogram: " << nbkgtot << endl; if ( nsigtot==0 || nbkgtot==0 ) { cout << "Error! At least one of the input histograms is empty!" << endl; return; } TH1D *projx = sighist->ProjectionX("projx"); TH1D *projy = sighist->ProjectionY("projy"); float bestsob = (float)nsigtot / nbkgtot; cout << "Starting with a \"no-cuts\" s/b of " << bestsob << endl; float x1=0, y1=0, x2=0, y2=0; // corner coordinates for the window for (int i=1; i<=nxbins; ++i) for (int j=minxwidth-1; i+j<=nxbins; ++j) for (int k=1; k<=nybins; ++k) for (int l=minywidth-1; k+l<=nybins; ++l) { int nsig = sighist->Integral(i, i+j, k, k+l); if ( nsig == 0 ) continue; if ( nsig < nsigtot*minsigeff ) continue; int nbkg = bkghist->Integral(i, i+j, k, k+l); if ( nbkg == 0 ) continue; float sob = (float)nsig / nbkg; if ( (float)nsig / nbkg > bestsob ) { bestsob = sob; x1 = projx->GetBinLowEdge(i); x2 = projx->GetBinLowEdge(i+j+1); y1 = projy->GetBinLowEdge(k); y2 = projy->GetBinLowEdge(k+l+1); cout << "x-range " << i << " (" << x1 << ") to " << i+j << " (" << x2 << ") ; \t y-range " << k << " (" << y1 <<") to " << k+l << " (" << y2 << ") ; \t signal= " << nsig << " bkgrnd= " << nbkg << " s/b= " << sob << endl; } } TCanvas *cnv = TCanvas::MakeDefCanvas(); cnv->Divide(2); TBox *box = new TBox(x1, y1, x2, y2); box->SetFillStyle(0); box->SetLineColor(2); box->SetLineWidth(2); cnv->cd(1); sighist->Draw("colbox"); box->Draw(); cnv->cd(2); bkghist->Draw("colbox"); box->Draw(); cnv->SaveAs("Optimize2D"+histname+".eps"); }
void twoDlinearcombination(TH2F* first, int firsttype, TH2F* second, int secondtype, TH2F* input, int inputtype, TH2F* finaloutput, int outputtype, TH2F* finaloutput2, int output2type){ TH2F* output = (TH2F*) input->Clone(); TH2F* output2 = (TH2F*) output->Clone(); if(outputtype==kIntHist || outputtype==kSigHist){ if(inputtype==kBSI25Hist && firsttype==kSigHist && secondtype==kBkgHist){ output->Add(first, -25.0); output->Add(second, -1.0); output->Scale(0.2); if (outputtype == kSigHist){ delete output; output = (TH2F*) first->Clone(); } output2->Add(first, -25.0); output2->Add(second, -1.0); output2->Scale(0.2); if (output2type == kSigHist){ delete output2; output2 = (TH2F*) first->Clone(); } } if(inputtype==kBSI25Hist && firsttype==kBSIHist && secondtype==kBkgHist){ for (int binx = 1; binx <= output->GetNbinsX(); binx++){ for (int biny = 1; biny <= output->GetNbinsY(); biny++){ double bsi = first->GetBinContent(binx,biny); double bkg = second->GetBinContent(binx,biny); double bsi25 = output->GetBinContent(binx,biny); double weight=doLinearCombination(bsi25,25,bsi,1,bkg,outputtype); output->SetBinContent(binx,biny,weight); if (finaloutput2 != 0){ double weight2 = doLinearCombination(bsi25, 25, bsi, 1, bkg, output2type); output2->SetBinContent(binx, biny, weight2); } } } } if(inputtype==kBSI25Hist && firsttype==kBSI10Hist && secondtype==kBkgHist){ //double scaleval = 1./(-50. + 25.*sqrt(10.)); for (int binx = 1; binx <= output->GetNbinsX(); binx++){ for (int biny = 1; biny <= output->GetNbinsY(); biny++){ double bsi10 = first->GetBinContent(binx,biny); double bkg = second->GetBinContent(binx,biny); double bsi25 = output->GetBinContent(binx,biny); double weight=doLinearCombination(bsi25,25,bsi10,10,bkg,outputtype); output->SetBinContent(binx,biny,weight); if (finaloutput2 != 0){ double weight2 = doLinearCombination(bsi25, 25, bsi10, 10, bkg, output2type); output2->SetBinContent(binx, biny, weight2); } } } } if(inputtype==kBSI10Hist && firsttype==kBSIHist && secondtype==kBkgHist){ //double scaleval = 1./(10 - sqrt(10)); for (int binx = 1; binx <= output->GetNbinsX(); binx++){ for (int biny = 1; biny <= output->GetNbinsY(); biny++){ double bsi = first->GetBinContent(binx,biny); double bkg = second->GetBinContent(binx,biny); double bsi10 = output->GetBinContent(binx,biny); double weight=doLinearCombination(bsi10,10,bsi,1,bkg,outputtype); output->SetBinContent(binx,biny,weight); if (finaloutput2 != 0){ double weight2 = doLinearCombination(bsi10, 10, bsi, 1, bkg, output2type); output2->SetBinContent(binx, biny, weight2); } } } } for (int binx = 1; binx <= output->GetNbinsX(); binx++){ for (int biny = 1; biny <= output->GetNbinsY(); biny++){ finaloutput->SetBinContent(binx, biny, output->GetBinContent(binx, biny)); if (finaloutput2 != 0) finaloutput2->SetBinContent(binx,biny,output2->GetBinContent(binx,biny)); } } } else{cout<<"Option not yet supported. Exiting..."<<endl; assert(0);}; delete output; delete output2; }
void ana_Run11_eff() { const int rebin = 1; TFile *f = TFile::Open("Rootfiles/Run11_eff.root","read"); // Run with weigth TH2F *hMcPtVsEta = (TH2F*)f->Get("mcJpsiPtY"); TH2F *hRcPtVsEta = (TH2F*)f->Get("hHt2JpsiPE"); draw2D(hMcPtVsEta); draw2D(hRcPtVsEta); hMcPtVsEta->GetXaxis()->SetRangeUser(-1+1e-6,1-1e-6); TH1F *hMcPt = (TH1F*)hMcPtVsEta->ProjectionY("hMcPt"); hMcPt->Rebin(rebin); hMcPt->SetMarkerStyle(20); draw1D(hMcPt,"",kTRUE); hRcPtVsEta->GetXaxis()->SetRangeUser(-1+1e-6,1-1e-6); TH1F *hRcPt = (TH1F*)hRcPtVsEta->ProjectionY("hRcPt"); hRcPt->Rebin(rebin); hRcPt->SetMarkerStyle(21); hRcPt->SetMarkerColor(2); hRcPt->SetLineColor(2); hRcPt->Draw("sames P"); TH1F *hRatio = (TH1F*)hRcPt->Clone("hRatio_fromRunning"); hRatio->Rebin(100); hMcPt->Rebin(100); hRatio->Divide(hMcPt); cEff = draw1D(hRatio,""); // Run without weight TH2F *hMcPtVsEtaNoWeight = (TH2F*)f->Get("mcJpsiPtY_Or"); draw2D(hMcPtVsEtaNoWeight); TH2F *hMcPtVsRcNoWeight = (TH2F*)f->Get("hJpsiRcvsMC_Cut1"); hMcPtVsRcNoWeight->RebinX(rebin); hMcPtVsRcNoWeight->RebinY(rebin); draw2D(hMcPtVsRcNoWeight); hMcPtVsEtaNoWeight->GetXaxis()->SetRangeUser(-1+1e-6,1-1e-6); TH1F *hMcPtNoWeight = (TH1F*)hMcPtVsEtaNoWeight->ProjectionY("hMcPtNoWeight"); hMcPtNoWeight->Rebin(rebin); hMcPtNoWeight->SetMarkerStyle(20); hMcPtNoWeight->SetMinimum(1); draw1D(hMcPtNoWeight,"",kTRUE); TH1F *hRcPtNoWeight = (TH1F*)hMcPtVsRcNoWeight->ProjectionX("hRcPtNoWeight"); hRcPtNoWeight->SetMarkerStyle(21); hRcPtNoWeight->SetMarkerColor(2); hRcPtNoWeight->SetLineColor(2); hRcPtNoWeight->Draw("sames P"); TH1F *hRatioNoWeight = (TH1F*)hRcPtNoWeight->Clone("hRatioNoWeight"); hRatioNoWeight->Divide(hMcPtNoWeight); cEff->cd(); hRatioNoWeight->SetMarkerColor(4); hRatioNoWeight->Draw("samesP"); // weight with input histogram TH1F *hMcPtWeight = (TH1F*)hMcPtNoWeight->Clone("hMcPtWeight"); TH2F *hMcPtVsRcWeight = (TH2F*)hMcPtVsRcNoWeight->Clone("hMcPtVsRcWeight"); for(int ibin=1; ibin<=hMcPtVsRcNoWeight->GetNbinsX(); ibin++) { double scale = hMcPt->GetBinContent(ibin); hMcPtWeight->SetBinContent(ibin,hMcPtWeight->GetBinContent(ibin)*scale); hMcPtWeight->SetBinError(ibin,hMcPtWeight->GetBinError(ibin)*scale); for(int jbin=1; jbin<=hMcPtVsRcNoWeight->GetNbinsY(); jbin++) { hMcPtVsRcWeight->SetBinContent(ibin,jbin,hMcPtVsRcWeight->GetBinContent(ibin,jbin)*scale); hMcPtVsRcWeight->SetBinError(ibin,jbin,hMcPtVsRcWeight->GetBinError(ibin,jbin)*scale); } } TH1F *hRcPtWeight = (TH1F*)hMcPtVsRcWeight->ProjectionY("hRcPtWeight"); hRcPtWeight->SetMarkerStyle(21); hRcPtWeight->SetMarkerColor(2); hRcPtWeight->SetLineColor(2); draw2D(hMcPtVsRcWeight); draw1D(hMcPtWeight,"",kTRUE); hRcPtWeight->Draw("sames P"); TH1F *hRatioWeight = (TH1F*)hRcPtWeight->Clone("hRatioWeight"); hRatioWeight->Divide(hMcPtWeight); cEff->cd(); hRatioWeight->SetMarkerColor(6); hRatioWeight->Draw("samesP"); TH1F *hCheck = (TH1F*)hRatioWeight->Clone("check"); hCheck->Divide(hRatio); draw1D(hCheck); // weight with fitted function TCanvas *c = new TCanvas("Fit","Fit",800,600); SetPadMargin(gPad,0.15,0.15); gPad->SetLogy(); TH1F *h = new TH1F("histogram",";;;",7,0,30); h->GetYaxis()->SetRangeUser(1e-7,100); h->Draw(); TFile *fdata = TFile::Open("Rootfiles/Spectrum_in_bin.root","read"); TGraphErrors *gr = (TGraphErrors*)fdata->Get("gall"); gr->SetMarkerColor(1); gr->SetLineColor(1); gr->GetXaxis()->SetRangeUser(0,30); gr->Draw("sames PE"); TF1 *func = new TF1("func",InvPt,0,30,4); func->SetParameters(0.4,-0.4796,4.229,-7.54); gr->Fit(func,"RL"); TH1F *hMcPtFunc = (TH1F*)hMcPtNoWeight->Clone("hMcPtFunc"); TH2F *hMcPtVsRcFunc = (TH2F*)hMcPtVsRcNoWeight->Clone("hMcPtVsRcFunc"); for(int ibin=1; ibin<=hMcPtVsRcFunc->GetNbinsX(); ibin++) { double scale = func->Eval(hMcPtFunc->GetBinCenter(ibin)); hMcPtFunc->SetBinContent(ibin,hMcPtFunc->GetBinContent(ibin)*scale); hMcPtFunc->SetBinError(ibin,hMcPtFunc->GetBinError(ibin)*scale); for(int jbin=1; jbin<=hMcPtVsRcNoWeight->GetNbinsY(); jbin++) { hMcPtVsRcFunc->SetBinContent(ibin,jbin,hMcPtVsRcFunc->GetBinContent(ibin,jbin)*scale); hMcPtVsRcFunc->SetBinError(ibin,jbin,hMcPtVsRcFunc->GetBinError(ibin,jbin)*scale); } } TH1F *hRcPtFunc = (TH1F*)hMcPtVsRcFunc->ProjectionY("hRcPtFunc"); hRcPtFunc->SetMarkerStyle(21); hRcPtFunc->SetMarkerColor(2); hRcPtFunc->SetLineColor(2); hMcPtVsRcFunc->GetZaxis()->SetRangeUser(1e-4,1e2); draw2D(hMcPtVsRcFunc); hMcPtFunc->GetYaxis()->SetRangeUser(1e-4,5e4); draw1D(hMcPtFunc,"",kTRUE); hRcPtFunc->Draw("sames P"); TH1F *hRatioFunc = (TH1F*)hRcPtFunc->Clone("hRatioFunc"); hRatioFunc->Rebin(100); hMcPtFunc->Rebin(100); hRatioFunc->Divide(hMcPtFunc); cEff->cd(); hRatioFunc->SetMarkerColor(5); hRatioFunc->Draw("samesP"); TH1F *hCheck2 = (TH1F*)hRatioFunc->Clone("check2"); hCheck2->Divide(hRatio); draw1D(hCheck2); }
void xformTaggingEfficiency() { TFile *fMatrix = new TFile("output/reco2GenMatrix.root"); TFile *fin = new TFile("output/NewFormatV5_bFractionMCTemplate_pppp1_SSVHEat2.0FixCL0_bin_0_40_eta_0_2.root"); // reco 2 gen matrix TH2F *hXform = (TH2F*)fMatrix->Get("hRecoVsGenNorm"); // grab reco binned histos TH1F *hRecoEffMC = (TH1F*)fin->Get("hBEfficiencyMC"); TH1F *hRecoEffDataLTJP = (TH1F*)fin->Get("hBEfficiencyDataLTJP"); TH1F *hRecoPurMC = (TH1F*)fin->Get("hBPurityMC"); TH1F *hRecoPurData = (TH1F*)fin->Get("hBPurityData"); TH1F *hRecoSpecMC = (TH1F*)fin->Get("hRawBMC"); TH1F *hRecoSpecData = (TH1F*)fin->Get("hRawBData"); // declar gen binned histos TH1F *hGenEffMC = hRecoEffMC->Clone("hGenEffMC"); hGenEffMC->Reset(); TH1F *hGenEffDataLTJP = hRecoEffDataLTJP->Clone("hGenEffDataLTJP"); hGenEffDataLTJP->Reset(); TH1F *hGenPurMC = hRecoPurMC->Clone("hGenPurMC"); hGenPurMC->Reset(); TH1F *hGenPurData = hRecoPurData->Clone("hGenPurData"); hGenPurData->Reset(); TH1F *hGenSpecMC = hRecoSpecMC->Clone("hGenSpecMC"); hGenSpecMC->Reset(); TH1F *hGenSpecData = hRecoSpecData->Clone("hGenSpecData"); hGenSpecData->Reset(); if(hRecoEffMC->GetNbinsX() != hXform->GetNbinsX()) { cout<<" FAIL "<<endl; return; } for(int i=0; i<hXform->GetNbinsX(); i++) { float genEffMC = 0; float genEffErrMC = 0; float genEffDataLTJP = 0; float genEffErrDataLTJP = 0; float genPurMC = 0; float genPurErrMC = 0; float genPurData = 0; float genPurErrData = 0; float genSpecMC = 0; float genSpecErrMC = 0; float genSpecData = 0; float genSpecErrData = 0; for(int j=0; j<hXform->GetNbinsY(); j++) { float coeff = hXform->GetBinContent(i+1,j+1); float recoEffMC = hRecoEffMC->GetBinContent(j+1); float recoEffErrMC = hRecoEffMC->GetBinError(j+1); genEffMC += coeff * recoEffMC; genEffErrMC += coeff * recoEffErrMC * coeff * recoEffErrMC; float recoEffDataLTJP = hRecoEffDataLTJP->GetBinContent(j+1); float recoEffErrDataLTJP = hRecoEffDataLTJP->GetBinError(j+1); genEffDataLTJP += coeff * recoEffDataLTJP; genEffErrDataLTJP += coeff * recoEffErrDataLTJP * coeff * recoEffErrDataLTJP; float recoPurMC = hRecoPurMC->GetBinContent(j+1); float recoPurErrMC = hRecoPurMC->GetBinError(j+1); genPurMC += coeff * recoPurMC; genPurErrMC += coeff * recoPurErrMC * coeff * recoPurErrMC; float recoPurData = hRecoPurData->GetBinContent(j+1); float recoPurErrData = hRecoPurData->GetBinError(j+1); genPurData += coeff * recoPurData; genPurErrData += coeff * recoPurErrData * coeff * recoPurErrData; float recoSpecMC = hRecoSpecMC->GetBinContent(j+1); float recoSpecErrMC = hRecoSpecMC->GetBinError(j+1); genSpecMC += coeff * recoSpecMC; genSpecErrMC += coeff * recoSpecErrMC * coeff * recoSpecErrMC; float recoSpecData = hRecoSpecData->GetBinContent(j+1); float recoSpecErrData = hRecoSpecData->GetBinError(j+1); genSpecData += coeff * recoSpecData; genSpecErrData += coeff * recoSpecErrData * coeff * recoSpecErrData; } genEffErrMC = sqrt(genEffErrMC); hGenEffMC->SetBinContent(i+1, recoEffMC); hGenEffMC->SetBinError(i+1, recoEffErrMC); genEffErrDataLTJP = sqrt(genEffErrDataLTJP); hGenEffDataLTJP->SetBinContent(i+1, recoEffDataLTJP); hGenEffDataLTJP->SetBinError(i+1, recoEffErrDataLTJP); hGenEffMC->SetBinContent(i+1, genEffMC); hGenEffMC->SetBinError(i+1, genEffErrMC); hGenEffDataLTJP->SetBinContent(i+1, genEffDataLTJP); hGenEffDataLTJP->SetBinError(i+1, genEffErrDataLTJP); genPurErrMC = sqrt(genPurErrMC); hGenPurMC->SetBinContent(i+1, recoPurMC); hGenPurMC->SetBinError(i+1, recoPurErrMC); genPurErrData = sqrt(genPurErrData); hGenPurData->SetBinContent(i+1, recoPurData); hGenPurData->SetBinError(i+1, recoPurErrData); hGenPurMC->SetBinContent(i+1, genPurMC); hGenPurMC->SetBinError(i+1, genPurErrMC); hGenPurData->SetBinContent(i+1, genPurData); hGenPurData->SetBinError(i+1, genPurErrData); genSpecErrMC = sqrt(genSpecErrMC); hGenSpecMC->SetBinContent(i+1, recoSpecMC); hGenSpecMC->SetBinError(i+1, recoSpecErrMC); genSpecErrData = sqrt(genSpecErrData); hGenSpecData->SetBinContent(i+1, recoSpecData); hGenSpecData->SetBinError(i+1, recoSpecErrData); hGenSpecMC->SetBinContent(i+1, genSpecMC); hGenSpecMC->SetBinError(i+1, genSpecErrMC); hGenSpecData->SetBinContent(i+1, genSpecData); hGenSpecData->SetBinError(i+1, genSpecErrData); } TFile *fout=new TFile("outputTowardsFinal/genBinnedHistos.root","recreate"); hRecoEffMC->SetXTitle("recoJet p_{T} (GeV/c)"); hRecoEffDataLTJP->SetXTitle("recoJet p_{T} (GeV/c)"); hGenEffMC->SetXTitle("genJet p_{T} (GeV/c)"); hGenEffDataLTJP->SetXTitle("genJet p_{T} (GeV/c)"); hRecoEffMC->Write(); hRecoEffDataLTJP->Write(); hGenEffMC->Write(); hGenEffDataLTJP->Write(); hRecoPurMC->SetXTitle("recoJet p_{T} (GeV/c)"); hRecoPurData->SetXTitle("recoJet p_{T} (GeV/c)"); hGenPurMC->SetXTitle("genJet p_{T} (GeV/c)"); hGenPurData->SetXTitle("genJet p_{T} (GeV/c)"); hRecoPurMC->Write(); hRecoPurData->Write(); hGenPurMC->Write(); hGenPurData->Write(); hRecoSpecMC->SetXTitle("recoJet p_{T} (GeV/c)"); hRecoSpecData->SetXTitle("recoJet p_{T} (GeV/c)"); hGenSpecMC->SetXTitle("genJet p_{T} (GeV/c)"); hGenSpecData->SetXTitle("genJet p_{T} (GeV/c)"); hRecoSpecMC->Write(); hRecoSpecData->Write(); hGenSpecMC->Write(); hGenSpecData->Write(); fout->Close(); }