plot_warnmap2D( string warnmapfile , bool writeplots = true ) { gStyle->SetOptStat(0); /* Read warnmap as tree */ TTree *twarn = new TTree(); twarn->ReadFile( warnmapfile.c_str(), "sector/I:y:z:status" ); // Declaration of leaf types Int_t sector; Int_t y; Int_t z; Int_t status; // List of branches TBranch *b_sector; //! TBranch *b_y; //! TBranch *b_z; //! TBranch *b_status; //! twarn->SetBranchAddress("sector", §or, &b_sector); twarn->SetBranchAddress("y", &y, &b_y); twarn->SetBranchAddress("z", &z, &b_z); twarn->SetBranchAddress("status", &status, &b_status); /* Create 2D histograms to visualize warnmap */ TH2I* h_warnmap[8]; int zbins = 0; int ybins = 0; /* Create histogram for each sector */ for( int sector = 0; sector < 8; sector++ ) { if(sector <6) // PbSc sector { zbins = 72; ybins = 36; } else // PbGl sector { zbins = 96; ybins = 48; } TString name("h_warnmap_sector_"); name += sector; TString title("Warnmap sector "); title += sector; cout << name <<endl; cout << title <<endl; h_warnmap[sector] = new TH2I( name, title, zbins, 0, zbins, ybins, 0, ybins ); h_warnmap[sector]->GetXaxis()->SetTitle("z [cm]"); h_warnmap[sector]->GetYaxis()->SetTitle("y [cm]"); } //sector /* Loop over warnmap and fill status of towers into map */ Long64_t nentries = twarn->GetEntriesFast(); for ( Long64_t jentry = 0; jentry < nentries; jentry++ ) { twarn->GetEntry(jentry); //cout << sector << " " << y << " " << z << " " << status << endl; // if status > 50 (e.g. 'dead' or 'uncalibrated', set it to 39 for nicer plotting if ( status > 50 ) status = 39; h_warnmap[sector]->Fill( z , y , status ); } /* build base filename for plots */ std::size_t pos = warnmapfile.find("/"); string filename_cut = warnmapfile.substr( pos+1 ); (filename_cut.erase( filename_cut.length()-4 ,4 ));//.erase(0,25); /* plot warnmaps */ for( int sector = 0; sector < 8; sector++ ) { TCanvas *c1 = new TCanvas(); (h_warnmap[sector])->Draw("colz"); if ( writeplots ) { TString filename("plots-warnmap-2D/warnmap2D_"); filename+=filename_cut; filename+="_sector_"; filename+=sector; filename+=".eps"; TString filenamep("plots-warnmap-2D/warnmap2D_"); filenamep+=filename_cut; filenamep+="_sector_"; filenamep+=sector; filenamep+=".png"; c1->Print( filename ); c1->Print( filenamep ); } } /* Draw combined canvas with all sectors */ TCanvas *c2 = new TCanvas(); c2->SetCanvasSize( 1000, 500 ); c2->SetWindowSize( 1000, 500 ); c2->Divide(4,2); for( int sector = 0; sector < 8; sector++ ) { c2->cd(sector+1); (h_warnmap[sector])->Draw("colz"); } TString filenameAll("plots-warnmap-2D/warnmap2D_"); filenameAll+=filename_cut; filenameAll+="_sector_all.eps"; TString filenameAllp("plots-warnmap-2D/warnmap2D_"); filenameAllp+=filename_cut; filenameAllp+="_sector_all.eps"; c2->Print( filenameAll ); c2->Print( filenameAllp ); // h_warnmap_[sect]->Fill(z, y, warnmap_[sect][z][y]); // for(int y=0; y<48; y++) //{ // if(sect<6 && y>35) continue; // for(int z=0; z<96; z++) //{ // if(sect<6 && z>71) continue; // // id = anatools::TowerID(sect, y, z); // for(int erng=0; erng<6; erng++) //{ // if(hotmap_[erng][sect][z][y] == 100) continue; // h_counts_hot[erng]->Fill(id, hitmap_[erng][sect][z][y]); // }//erng // }//z // }//y // h_warnmap_[sect]->Write(); // }//sect return; }
void sqrtByFill(){ //OPTIONS AND CUTS______________ bool useBlueBeam = true; bool useYellowBeam = true; bool randomizeSpin = false; bool fullEta = true; double PI = 3.14159265359; //LOAD LIBS_____________________ cout << "\n"; gROOT->Macro("StRoot/LoadLibs.C"); gSystem->Load("pionPair"); cout << " loading of pionPair library done" << endl; //______________________________ //SET UP INPUT FILE_____________ TFile* infile = new TFile("/star/u/klandry/ucladisk/2012IFF/schedOut_Full_4_2/allPairs_4_2.root"); string outFileName = "./resultsNew_4_22/pairsFrom4_2ByFill.root"; //______________________________ //SET UP TREE TO RECEIVE INPUT__ pionPair* pair1 = new pionPair(); TTree* pairTree = infile->Get("pionPairTree"); pairTree->SetBranchAddress("pionPair", &pair1); //______________________________ double histMin = -PI; double histMax = PI; const int binNumber = 16; TH1D * hNumberUp = new TH1D("hNumberUp","hNumberUp",binNumber,histMin,histMax); TH1D * hNumberDown = new TH1D("hNumberDown","hNumberDown",binNumber,histMin,histMax); TH1D * hAut = new TH1D("Aut","Aut",binNumber,histMin,histMax); TH1D* polOfBin[16]; for (int i = 0; i < 16; i++) { stringstream ss; ss << i; string fullname = "hPolOfBin_phiSRbin_" + ss.str(); cout << fullname << endl; polOfBin[i] = new TH1D(fullname.c_str(),fullname.c_str(),25,0,1); } //BEAM POLARIZATION_____________ ifstream polFile; polFile.open("/star/u/klandry/ucladisk/2012IFF/BeamPolarization2012.txt"); map<int, double> polarizationOfFill_Y; map<int, double> polErrOfFill_Y; map<int, double> polarizationOfFill_B; map<int, double> polErrOfFill_B; int fill; int beamE; int startT; string plusminus; double pAvrgBlue; double pErrAvrgBlue; double pInitialBlue; double pErrInitialBlue; double dPdTBlue; double dPdTErrBlue; double pAvrgYellow; double pErrAvrgYellow; double pInitialYellow; double pErrInitialYellow; double dPdTYellow; double dPdTErrYellow; string header; for (int i=0; i<19; i++){polFile >> header;} while (!polFile.eof()) { polFile >> fill; polFile >> beamE; polFile >> startT; polFile >> pAvrgBlue; polFile >> plusminus; polFile >> pErrAvrgBlue; polFile >> pInitialBlue; polFile >> plusminus; polFile >> pErrInitialBlue; polFile >> dPdTBlue; polFile >> plusminus; polFile >> dPdTErrBlue; polFile >> pAvrgYellow; polFile >> plusminus; polFile >> pErrAvrgYellow; polFile >> pInitialYellow; polFile >> plusminus; polFile >> pErrInitialYellow; polFile >> dPdTYellow; polFile >> plusminus; polFile >> dPdTErrYellow; polarizationOfFill_B[fill] = pAvrgBlue/100.; polErrOfFill_B[fill] = pErrAvrgBlue/100.; polarizationOfFill_Y[fill] = pAvrgYellow/100.; polErrOfFill_Y[fill] = pErrAvrgYellow/100.; } double avgPolOfBinUp[binNumber]; double polOfBinSumUp[binNumber]; double avgPerrorOfBinUp[binNumber]; double pErrorOfBinUp[binNumber]; double avgPolOfBinDown[binNumber]; double polOfBinSumDown[binNumber]; double avgPerrorOfBinDown[binNumber]; double pErrorOfBinDown[binNumber]; for (int i=0; i<binNumber; i++) { avgPolOfBinUp[i] = 0; polOfBinSumUp[i] = 0; avgPerrorOfBinUp[i] = 0; pErrorOfBinUp[i] = 0; avgPolOfBinDown[i] = 0; polOfBinSumDown[i] = 0; avgPerrorOfBinDown[i] = 0; pErrorOfBinDown[i] = 0; } //CUTS__________________________ double lowLimitPt = ptBinStart[0]; double hiLimitPt = ptBinEnd[4]; double lowLimitEta = etaBinStart[3]; //set up do only do eta bin 3 double hiLimitEta = etaBinEnd[3]; double lowLimitMass = massBinStart[0]; double hiLimitMass = massBinEnd[4]; //______________________________ // ====================================================================== //============================================================================ //START ANALYSIS============================================================== //============================================================================ // ====================================================================== //* cout << "\n"; cout << "<----STARTING ANALYSIS---->" << endl; cout << "\n"; cout << pairTree->GetEntries() << " pairs to analyze" << endl; int blueFillNo; int yellowFillNo; int phiSRbin; vector<double> fillAsyms; vector<double> fillAsymsE; vector<double> fillVec; TLorentzVector sum; TLorentzVector sumY; TLorentzVector sumB; //random number for randomizing spin. //set seed to zero to gaurenty unique numbers each time. TRandom3 r; r.SetSeed(0); int rand5 = 0; int rand6 = 0; int rand9 = 0; int rand10 = 0; int totalPairsFinal = 0; int blueD = 0; int blueU = 0; int yellowD = 0; int yellowU = 0; int pionStarNumber = 0; int runsProcessed = 0; double currentFillNo = 0; double currentRunNo = 0; for (int iPair = pionStarNumber; iPair < pairTree->GetEntries(); iPair++) { if (iPair%10000 == 0) {cout << "processing pair number " << iPair << endl;} //if (iPair == pionStarNumber+300000){break;} pairTree->GetEntry(iPair); //if (runsProcessed > 4){break;} if (pair1->runInfo().beamFillNumber(1) != currentFillNo && currentFillNo != 0 && currentFillNo != 16427) //if (pair1->runInfo().runId() != currentRunNo && currentRunNo != 0) { runsProcessed++; cout << "runsProcessed " << runsProcessed << endl; double* asym = new double(); double* asymE = new double(); calcAsyms(hAut, hNumberUp, hNumberDown, polOfBin, asym, asymE); fillAsyms.push_back(*asym); fillAsymsE.push_back(*asymE); fillVec.push_back(runsProcessed); hNumberUp->Reset(); hNumberDown->Reset(); hAut->Reset(); for (int i=0; i<binNumber; i++) { polOfBin[i]->Reset(); } } else if (currentRunNo == 16427) { //fillAsyms.push_back(*asym); //fillAsymsE.push_back(*asymE); //fillVec.push_back(runsProcessed); hNumberUp->Reset(); hNumberDown->Reset(); hAut->Reset(); for (int i=0; i<binNumber; i++) { polOfBin[i]->Reset(); } } currentRunNo = pair1->runInfo().runId(); currentFillNo = pair1->runInfo().beamFillNumber(1); if (pair1->withinRadius(0.05, 0.3)) { bool triggerFired = false; bool fromKaon = false; bool passInitialCut_B = false; bool passInitialCut_Y = false; bool passDCAcut = false; StTriggerId trigId = pair1->triggerIds(); //JP0,JP1,JP2,AJP if (trigId.isTrigger(370601) || trigId.isTrigger(370611) || trigId.isTrigger(370621) || trigId.isTrigger(370641)) { triggerFired = true; } //BHT0VPD,BHT1VPD,BHT2BBC,BHT2 if (trigId.isTrigger(370501) || trigId.isTrigger(370511) || trigId.isTrigger(370522) || trigId.isTrigger(370531)) { triggerFired = true; } if (triggerFired) { blueFillNo = pair1->runInfo().beamFillNumber(1); //1 = blue beam yellowFillNo = pair1->runInfo().beamFillNumber(0); //0 = yellow beam sum = pair1->piPlusLV() + pair1->piMinusLV(); sumB = sum; //blue beam. //yellow beam must rotate around y axis by pi so the eta cut can be the same for both beams. sumY = sum; sumY.RotateY(PI); if (sumB.Pt() >= lowLimitPt && sumB.Pt() <= hiLimitPt && sumB.M() >= lowLimitMass && sumB.M() <= hiLimitMass && sumB.Eta() >= lowLimitEta && sumB.Eta() <= hiLimitEta) { passInitialCut_B = true; } if (sumY.Pt() >= lowLimitPt && sumY.Pt() <= hiLimitPt && sumY.M() >= lowLimitMass && sumY.M() <= hiLimitMass && sumY.Eta() >= lowLimitEta && sumY.Eta() <= hiLimitEta) { passInitialCut_Y = true; } if (passInitialCut_B && useBlueBeam) { //BLUE BEAM SPIN UP: spin bin 9 and 10 if (pair1->spinBit() == 9 || pair1->spinBit() == 10) { hNumberUp->Fill(pair1->phiSR('b')); phiSRbin = hNumberUp->FindBin(pair1->phiSR('b')); polOfBin[phiSRbin-1]->Fill(polarizationOfFill_B[blueFillNo]); /*if (iPair > 39000) { cout << "polarization = " << polarizationOfFill_B[blueFillNo] << " " << blueFillNo << endl; }*/ } //BLUE BEAM SPIN DOWN: spin bin 5 and 6 if (pair1->spinBit() == 5 || pair1->spinBit() == 6) { hNumberDown->Fill(pair1->phiSR('b')); phiSRbin = hNumberDown->FindBin(pair1->phiSR('b')); polOfBin[phiSRbin-1]->Fill(polarizationOfFill_B[blueFillNo]); } }//done with blue beam if (passInitialCut_Y && useYellowBeam) { //YELLOW BEAM SPIN UP: spin bin 6 and 10 if (pair1->spinBit() == 6 || pair1->spinBit() == 10) { hNumberUp->Fill(pair1->phiSR('y')); phiSRbin = hNumberUp->FindBin(pair1->phiSR('y')); polOfBin[phiSRbin-1]->Fill(polarizationOfFill_Y[yellowFillNo]); } //YELLOW BEAM SPIN DOWN: spin bit 5 and 9 if (pair1->spinBit() == 5 || pair1->spinBit() == 9) { hNumberDown->Fill(pair1->phiSR('y')); phiSRbin = hNumberDown->FindBin(pair1->phiSR('y')); polOfBin[phiSRbin-1]->Fill(polarizationOfFill_Y[yellowFillNo]); } }//done with yellow beam }//end trigger check }//end radius check }//end pion tree loop cout << "out of tree loop" << endl; cout << fillAsyms.size() << endl; TGraphErrors* gAsymVsFill = new TGraphErrors(fillAsyms.size(), &fillVec[0], &fillAsyms[0], 0, &fillAsymsE[0]); gAsymVsFill->Draw("AP"); TFile* outFile = new TFile(outFileName.c_str(),"recreate"); gAsymVsFill->Write(); }
//should include inttype 11, 12, 13 as the signal void TMVAClassificationApplication_cc1presv2_bdt_ver3noveract( TString myMethodList = "", TString fname ) { #ifdef __CINT__ gROOT->ProcessLine( ".O0" ); // turn off optimization in CINT #endif //--------------------------------------------------------------- // This loads the library TMVA::Tools::Instance(); // Default MVA methods to be trained + tested std::map<std::string,int> Use; // // --- Boosted Decision Trees Use["BDT"] = 1; // uses Adaptive Boost std::cout << std::endl; std::cout << "==> Start TMVAClassificationApplication" << std::endl; // Select methods (don't look at this code - not of interest) if (myMethodList != "") { for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0; std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' ); for (UInt_t i=0; i<mlist.size(); i++) { std::string regMethod(mlist[i]); if (Use.find(regMethod) == Use.end()) { std::cout << "Method \"" << regMethod << "\" not known in TMVA under this name. Choose among the following:" << std::endl; for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) { std::cout << it->first << " "; } std::cout << std::endl; return; } Use[regMethod] = 1; } } // -------------------------------------------------------------------------------------------------- // --- Create the Reader object TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" ); // Create a set of variables and declare them to the reader // - the variable names MUST corresponds in name and type to those given in the weight file(s) used Float_t mumucl, pmucl; Float_t pang_t, muang_t; Float_t veract; Float_t ppe, mupe; Float_t range, coplanarity; Float_t opening;//newadd reader->AddVariable( "mumucl", &mumucl ); reader->AddVariable( "pmucl", &pmucl ); reader->AddVariable( "pang_t", &pang_t ); reader->AddVariable( "muang_t", &muang_t ); //reader->AddVariable( "veract", &veract ); reader->AddVariable( "ppe", &ppe); reader->AddVariable( "mupe", &mupe); reader->AddVariable( "range", &range); reader->AddVariable( "coplanarity", &coplanarity); reader->AddVariable( "opening", &opening);//newadd // Spectator variables declared in the training have to be added to the reader, too Int_t fileIndex, inttype; Float_t nuE, norm, totcrsne; reader->AddSpectator( "fileIndex", &fileIndex ); reader->AddSpectator( "nuE", &nuE ); reader->AddSpectator( "inttype", &inttype ); reader->AddSpectator( "norm", &norm ); reader->AddSpectator( "totcrsne", &totcrsne ); reader->AddSpectator( "veract", &veract ); // --- Book the MVA methods TString dir = "weights/"; TString prefix = "TMVAClassification_cc1presv2_ver3noveract";//newchange // Book method(s) for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) { if (it->second) { TString methodName = TString(it->first) + TString(" method"); TString weightfile = dir + prefix + TString("_") + TString(it->first) + TString(".weights.xml"); reader->BookMVA( methodName, weightfile ); } } // Prepare input tree (this must be replaced by your data source) // in this example, there is a toy tree with signal and one with background events // we'll later on use only the "signal" events for the test in this example. // /*//TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/data_merged_ccqe_addpid_ver3noveract_pid1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pm_merged_ccqe_tot_addpid_ver3noveract_pid1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pmbar_merged_ccqe_addpid_ver3noveract_pid1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/ingrid_merged_nd3_ccqe_tot_addpid_ver3noveract_pid1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/wall_merged_ccqe_tot_addpid_ver3noveract_pid1pres.root"; //check genie signal TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/genie_merged_ccqe_coh_addpid_ver3noveract_pid1pres.root";*/ //add for event with more than 2 track //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/data_merged_ccqe_processl2trk.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pm_merged_ccqe_tot_processl2trk.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pmbar_merged_ccqe_processl2trk.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/ingrid_merged_nd3_ccqe_tot_processl2trk.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/wall_merged_ccqe_tot_processl2trk.root"; //check genie signal //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/genie_merged_ccqe_coh_processl2trk.root"; //for correct cc1pres pid //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/data_merged_ccqe_correct1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pm_merged_ccqe_tot_correct1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/pmbar_merged_ccqe_correct1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/ingrid_merged_nd3_ccqe_tot_correct1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/wall_merged_ccqe_tot_correct1pres.root"; //TString fname = "/home/cvson/cc1picoh/frkikawa/meAna/ip4tmva/genie_merged_ccqe_coh_correct1pres.root"; //for correct prange/pang_t and additional information //TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/data_merged_ccqe_addpidFF.root"; // TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/pm_merged_ccqe_tot_addpidFF.root"; //TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/pmbar_merged_ccqe_addpidFF.root"; //TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/ingrid_merged_nd3_ccqe_tot_addpidFF.root"; //TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/wall_merged_ccqe_tot_addpidFF.root"; //TString fname = "/home/cvson/cc1picoh/dataProcess/fix20150420/genie_merged_ccqe_tot_addpidFF.root"; // std::cout << "--- Selecting data sample" << std::endl; TFile *pfile = new TFile(fname,"update"); TTree* theTree = (TTree*)pfile->Get("tree"); theTree->SetBranchAddress( "mumucl", &mumucl ); theTree->SetBranchAddress( "pmucl", &pmucl ); theTree->SetBranchAddress( "pang_t", &pang_t ); theTree->SetBranchAddress( "muang_t", &muang_t ); theTree->SetBranchAddress( "veract", &veract ); theTree->SetBranchAddress( "ppe", &ppe); theTree->SetBranchAddress( "mupe", &mupe); theTree->SetBranchAddress( "range", &range); theTree->SetBranchAddress( "coplanarity", &coplanarity); theTree->SetBranchAddress( "opening", &opening); Int_t Ntrack; theTree->SetBranchAddress( "Ntrack", &Ntrack ); Float_t pid1pres; TBranch *bpid1pres = theTree->Branch("pid1pres",&pid1pres,"pid1pres/F"); std::vector<Float_t> vecVar(9); // vector for EvaluateMVA tests Long64_t nentries = theTree->GetEntriesFast(); Long64_t iprintProcess = Long64_t(nentries/100.); std::cout << "--- Processing: " << nentries << " events" << std::endl; TStopwatch sw; sw.Start(); for (Long64_t ievt=0; ievt<nentries;ievt++) { if (ievt%iprintProcess == 0) cout<<"Processing "<<int(ievt*100./nentries)<<"% of events"<<endl; theTree->GetEntry(ievt); Float_t pid_tem; if (Use["BDT"]) { //if (Ntrack!=2) pid_tem = -999;//change here if (Ntrack<2) pid_tem = -999; else pid_tem = reader->EvaluateMVA("BDT method"); } pid1pres = pid_tem; bpid1pres->Fill(); } theTree->Write(); delete pfile; // Get elapsed time sw.Stop(); std::cout << "--- End of event loop: "; sw.Print(); delete reader; std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl; }
void ppEffJpsiSysSFsSTA__idx_() { double minRap = 0.0; double maxRap = 2.4; double minPt = 6.5; double maxPt = 30.0; // if you want to measure low pT, you can set up minRap = 1.6 and minPt = 3.0, maxPt = 6.5; gROOT->SetStyle("Plain"); gStyle->SetPalette(1); gStyle->SetFrameBorderMode(0); gStyle->SetFrameFillColor(0); gStyle->SetCanvasColor(0); gStyle->SetTitleFillColor(0); gStyle->SetStatColor(0); gStyle->SetPadBorderSize(0); gStyle->SetCanvasBorderSize(0); gStyle->SetOptTitle(0); // at least most of the time gStyle->SetOptStat(0); // most of the time, sometimes "nemriou" might be useful to display name, //number of entries, mean, rms, integral, overflow and underflow gStyle->SetOptFit(0); // set to 1 only if you want to display fit results //==================================== Define Histograms==================================================== //==============================================Define Acc Eff Stuff here=========================================== // Pt bin sizes // 0-1.5, 1.5-3, 3-4.5, 4.5-6, 6-7.5... TFile *outfile; char tmp_output[512]; sprintf(tmp_output,"ppPrJpsi_pT_%0.1f_%0.1f_y_%0.1f_%0.1f_HighQ_tnpWgt.root", minPt, maxPt, minRap, maxRap); outfile =new TFile(tmp_output, "Recreate"); for(int iSpec = 0; iSpec < 2; iSpec++){ const int nPtBins = 4; const int nRapBins = 3; const int ndPhiBins = 4; double pt_bound[nPtBins+1] = {6.5, 8.0, 10.0, 13.0, 30.0}; double xpt_bound[nPtBins] = {0.0}; //double rap_bound[nRapBins+1] = {0.0, 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4}; double rap_bound[nRapBins+1] = {0.0, 1.2, 1.6, 2.4}; double xrap_bound[nRapBins] = {0.0}; double dphi_bound[ndPhiBins+1] = {0.0, TMath::Pi()/8, TMath::Pi()/4, 3*TMath::Pi()/8, TMath::Pi()/2}; double xdphi_bound[ndPhiBins] = {0.0}; const char *cSp[2] = {"Pts","Raps"}; char OutTextFile[100]; sprintf(OutTextFile,"ppPromp_eff_%s_pT_%0.1f_%0.1f_y_%0.1f_%0.1f_HighQ.tex", cSp[iSpec], minPt, maxPt, minRap, maxRap); ofstream dataFile(OutTextFile); //ofstream dataFile(Form(OutTextFile)); cout<< "%%%% Getting Efficiency starts : %s !!!!! %%%%%" << endl; //dataFile<< "%%%% Getting Efficiency starts : %s !!!!! %%%%%" << endl; // x, y, z - axis //dataFile<<""<<endl; //dataFile<<"xaxis of pT"<<endl; for(int i = 0; i < nPtBins; i++){ xpt_bound[i] = pt_bound[i] + (pt_bound[i+1]-pt_bound[i])/2; cout<<"xpt_bound["<<i<<"] : "<<xpt_bound[i]<<endl; //dataFile<<"xpt_bound["<<i<<"] : "<<xpt_bound[i]<<endl; } //dataFile<<""<<endl; //dataFile<<"xaxis of rap"<<endl; for(int i = 0; i < nRapBins; i++){ xrap_bound[i] = rap_bound[i] + (rap_bound[i+1]-rap_bound[i])/2; cout<<"xrap_bound["<<i<<"] : "<<xrap_bound[i]<<endl; //dataFile<<"xrap_bound["<<i<<"] : "<<xrap_bound[i]<<endl; } //dataFile<<""<<endl; //dataFile<<"xaxis of dphi"<<endl; for(int i = 0; i < ndPhiBins; i++){ xdphi_bound[i] = dphi_bound[i] + (dphi_bound[i+1]-dphi_bound[i])/2; cout<<"xdphi_bound["<<i<<"] : "<<xdphi_bound[i]<<endl; //dataFile<<"xdphi_bound["<<i<<"] : "<<xdphi_bound[i]<<endl; } int nBins_tmp = 0; if(iSpec == 0) { nBins_tmp = nPtBins; } if(iSpec == 1) { nBins_tmp = nRapBins; } const int nBins = nBins_tmp; TH1F *hTempMass = new TH1F("hTempMass","",100, 2.0, 4.0); TH1F *hGenDiMuon[nBins]; TH1F *hRecoDiMuon[nBins]; double genNo[nBins]; double genErr[nBins]; double recoNo[nBins]; double recoErr[nBins]; double eff[nBins]; double effErr[nBins]; for(int i = 0; i < nBins; i++){ hGenDiMuon[i] = (TH1F*)hTempMass->Clone(); hRecoDiMuon[i] = (TH1F*)hTempMass->Clone(); hGenDiMuon[i]->Sumw2(); hRecoDiMuon[i]->Sumw2(); } char fileName[10][512]; // loop for pT cout<<"==================Prompt PrJpsi================================================"<<endl; sprintf(fileName[0],"/Users/dmoon/Dropbox/Analysis/HiMC/EffStudy/gRpAngRootFiles_538_pp/HiDiMuonAna_538_pp_NonPromptJpsi_20140317_Trg21.root"); TFile *infile; TTree *tree; TTree *gentree; TTree *evttree; infile=new TFile(fileName[0],"R"); tree=(TTree*)infile->Get("SingleMuonTree"); gentree=(TTree*)infile->Get("SingleGenMuonTree"); evttree=(TTree*)infile->Get("EventTree"); //Event variables int eventNb,runNb,lumiBlock; int hbit1; //double vertexZ; //double GenvertexZ; //Jpsi Variables Double_t JpsiMass,JpsiPt,JpsiRap, JpsiCharge; Double_t JpsiVprob; Double_t JpsiPhi; Double_t JpsiEta; //2.) muon variables RECO double muPosPx, muPosPy, muPosPz, muPosEta, muPosPt, muPosP, muPosPhi; double muNegPx, muNegPy, muNegPz, muNegEta, muNegPt, muNegP, muNegPhi; //(1).Positive Muon double muPos_nchi2In, muPos_dxy, muPos_dz, muPos_nchi2Gl; int muPos_found, muPos_pixeLayers, muPos_nValidMuHits,muPos_arbitrated; bool muPos_matches,muPos_tracker; int muPos_Trigger10, muPos_Trigger2, muPos_Trigger21, muPos_Trigger22; //(2).Negative Muon double muNeg_nchi2In, muNeg_dxy, muNeg_dz, muNeg_nchi2Gl; int muNeg_found, muNeg_pixeLayers, muNeg_nValidMuHits,muNeg_arbitrated; bool muNeg_matches,muNeg_tracker; int muNeg_Trigger10, muNeg_Trigger2, muNeg_Trigger21, muNeg_Trigger22; //Gen Level variables //Gen PrJpsi Variables double GenJpsiMass, GenJpsiPt, GenJpsiRap; double GenJpsiPx, GenJpsiPy, GenJpsiPz; double GenJpsiPhi; double GenJpsiEta; //2.) Gen muon variables double GenmuPosPx, GenmuPosPy, GenmuPosPz, GenmuPosEta, GenmuPosPt, GenmuPosPhi; double GenmuNegPx, GenmuNegPy, GenmuNegPz, GenmuNegEta, GenmuNegPt, GenmuNegPhi; double zVtx; //Event variables tree->SetBranchAddress("eventNb",&eventNb); tree->SetBranchAddress("runNb",&runNb); tree->SetBranchAddress("lumiBlock",&lumiBlock); tree->SetBranchAddress("hbit1",&hbit1); tree->SetBranchAddress("zVtx",&zVtx); //tree->SetBranchAddress("vertexZ",&vertexZ); //Jpsi Variables tree->SetBranchAddress("JpsiCharge",&JpsiCharge); tree->SetBranchAddress("JpsiMass",&JpsiMass); tree->SetBranchAddress("JpsiPt",&JpsiPt); tree->SetBranchAddress("JpsiPhi",&JpsiPhi); tree->SetBranchAddress("JpsiEta",&JpsiEta); tree->SetBranchAddress("JpsiRap",&JpsiRap); tree->SetBranchAddress("JpsiVprob",&JpsiVprob); //muon variable tree->SetBranchAddress("muPosPx",&muPosPx); tree->SetBranchAddress("muPosPy",&muPosPy); tree->SetBranchAddress("muPosPz",&muPosPz); tree->SetBranchAddress("muPosEta",&muPosEta); tree->SetBranchAddress("muPosPhi",&muPosPhi); tree->SetBranchAddress("muNegPx", &muNegPx); tree->SetBranchAddress("muNegPy", &muNegPy); tree->SetBranchAddress("muNegPz", &muNegPz); tree->SetBranchAddress("muNegEta", &muNegEta); tree->SetBranchAddress("muNegPhi", &muNegPhi); //1). Positive Muon tree->SetBranchAddress("muPos_nchi2In", &muPos_nchi2In); tree->SetBranchAddress("muPos_dxy", &muPos_dxy); tree->SetBranchAddress("muPos_dz", &muPos_dz); tree->SetBranchAddress("muPos_nchi2Gl", &muPos_nchi2Gl); tree->SetBranchAddress("muPos_found", &muPos_found); tree->SetBranchAddress("muPos_pixeLayers", &muPos_pixeLayers); tree->SetBranchAddress("muPos_nValidMuHits", &muPos_nValidMuHits); tree->SetBranchAddress("muPos_matches", &muPos_matches); tree->SetBranchAddress("muPos_tracker", &muPos_tracker); tree->SetBranchAddress("muPos_arbitrated", &muPos_arbitrated); tree->SetBranchAddress("muPos_Trigger10", &muPos_Trigger10); tree->SetBranchAddress("muPos_Trigger2", &muPos_Trigger2); tree->SetBranchAddress("muPos_Trigger21", &muPos_Trigger21); tree->SetBranchAddress("muPos_Trigger22", &muPos_Trigger22); //2). Negative Muon tree->SetBranchAddress("muNeg_nchi2In", &muNeg_nchi2In); tree->SetBranchAddress("muNeg_dxy", &muNeg_dxy); tree->SetBranchAddress("muNeg_dz", &muNeg_dz); tree->SetBranchAddress("muNeg_nchi2Gl", &muNeg_nchi2Gl); tree->SetBranchAddress("muNeg_found", &muNeg_found); tree->SetBranchAddress("muNeg_pixeLayers", &muNeg_pixeLayers); tree->SetBranchAddress("muNeg_nValidMuHits", &muNeg_nValidMuHits); tree->SetBranchAddress("muNeg_matches", &muNeg_matches); tree->SetBranchAddress("muNeg_tracker", &muNeg_tracker); tree->SetBranchAddress("muNeg_arbitrated", &muNeg_arbitrated); tree->SetBranchAddress("muNeg_Trigger10", &muNeg_Trigger10); tree->SetBranchAddress("muNeg_Trigger2", &muNeg_Trigger2); tree->SetBranchAddress("muNeg_Trigger21", &muNeg_Trigger21); tree->SetBranchAddress("muNeg_Trigger22", &muNeg_Trigger22); //====================================Gen Variables========================================================= //Gen Jpsi Variables gentree->SetBranchAddress("GenJpsiMass", &GenJpsiMass); gentree->SetBranchAddress("GenJpsiPt", &GenJpsiPt); gentree->SetBranchAddress("GenJpsiPhi", &GenJpsiPhi); gentree->SetBranchAddress("GenJpsiRap", &GenJpsiRap); gentree->SetBranchAddress("GenJpsiEta", &GenJpsiEta); gentree->SetBranchAddress("GenJpsiPx", &GenJpsiPx); gentree->SetBranchAddress("GenJpsiPy", &GenJpsiPy); gentree->SetBranchAddress("GenJpsiPz", &GenJpsiPz); //muon variable gentree->SetBranchAddress("GenmuPosPx", &GenmuPosPx); gentree->SetBranchAddress("GenmuPosPy", &GenmuPosPy); gentree->SetBranchAddress("GenmuPosPz", &GenmuPosPz); gentree->SetBranchAddress("GenmuPosEta", &GenmuPosEta); gentree->SetBranchAddress("GenmuPosPhi", &GenmuPosPhi); gentree->SetBranchAddress("GenmuNegPx", &GenmuNegPx); gentree->SetBranchAddress("GenmuNegPy", &GenmuNegPy); gentree->SetBranchAddress("GenmuNegPz", &GenmuNegPz); gentree->SetBranchAddress("GenmuNegEta", &GenmuNegEta); gentree->SetBranchAddress("GenmuNegPhi", &GenmuNegPhi); //gentree->SetBranchAddress("GenvertexZ",&GenvertexZ); //====================================================== Gen tree loop ================================================ int NAccep=0; int nGenEntries=gentree->GetEntries(); cout<<" Total Entries in GenLevel Tree for pT range: "<<fileName[0]<<" "<< nGenEntries<< " ==============="<<endl; for(int i=0; i< nGenEntries; i++) { //cout<<"i : "<<i<<endl; if(!(gentree->GetEntry(i))) continue; //cout<<" gentree ("<<i<<")"<<endl; //Only printing if(i%1000000==0){ cout<<" processing record "<<i<<"/"<<nGenEntries<<endl; //cout<<" Mass "<< GenJpsiMass<< " pT "<< GenJpsiPt << " Y " <<GenJpsiRap<<endl; } bool GenPosIn=0, GenNegIn=0; GenmuPosPt= TMath::Sqrt(GenmuPosPx*GenmuPosPx + GenmuPosPy*GenmuPosPy); GenmuNegPt= TMath::Sqrt(GenmuNegPx*GenmuNegPx + GenmuNegPy*GenmuNegPy); if(IsAccept(GenmuPosPt, GenmuPosEta)) {GenPosIn=1;} if(IsAccept(GenmuNegPt, GenmuNegEta)) {GenNegIn=1;} int AccJpsi = 0; //if(GenJpsiPt < 6.5) continue; if((GenJpsiPt >= minPt && GenJpsiPt <= maxPt && fabs(GenJpsiRap) >= minRap && TMath::Abs(GenJpsiRap) <= maxRap && GenPosIn == 1 && GenNegIn == 1) && GenJpsiMass > 2.0 && GenJpsiMass < 4.0 ) {AccJpsi = 1;} if((GenPosIn ==1 && GenNegIn==1)) NAccep++; //cout<<"1. GenJpsiPt : "<<GenJpsiPt<<", GenJpsiEta : "<<GenJpsiEta<<", GenJpsiRap : "<<GenJpsiRap<<", |GenJpsiPsi| : "<<TMath::Abs(GenJpsiPsi)<<endl; //cout<<"1. GenPosIn : "<<GenPosIn<<", GenNegIn : "<<GenNegIn<<endl; double vars = 0.0, bin1 = 0.0, bin2 = 0.0; if(iSpec == 0) vars = GenJpsiPt; if(iSpec == 1) vars = fabs(GenJpsiRap); for(int j = 0; j < nBins; j++){ if(iSpec == 0){ bin1 = pt_bound[j]; bin2 = pt_bound[j+1]; if( (AccJpsi==1) && (vars >= bin1 && vars < bin2) && fabs(GenJpsiRap) >= minRap && TMath::Abs(GenJpsiRap) <= maxRap && TMath::Abs(GenJpsiRap) >= minRap) { hGenDiMuon[j]->Fill(GenJpsiMass); } } if(iSpec == 1){ bin1 = rap_bound[j]; bin2 = rap_bound[j+1]; if( (AccJpsi==1) && (vars >= bin1 && vars < bin2) && GenJpsiPt >= minPt && GenJpsiPt <= maxPt) { hGenDiMuon[j]->Fill(GenJpsiMass); } } } }//gen loop end //cout<<" accepted no "<< NAccep<<endl; //=============== Rec Tree Loop ============================================================================== int nRecEntries=tree->GetEntries(); cout<<"Total Entries in reconstructed Tree for pT range "<<fileName[0]<<" "<<nRecEntries<< "====="<<endl; for(int i=0; i<nRecEntries; i++) { tree->GetEntry(i); //Only printing if(i%1000000==0){ cout<<" processing record "<<i<<"/"<<nRecEntries<<endl; //cout<<" processing Run " <<runNb <<" event "<<eventNb<<" lum block "<<lumiBlock<<endl; //cout<<" Mass "<< JpsiMass<< " pT "<< JpsiPt << " Y " <<JpsiRap<<" "<<JpsiVprob<<" charge "<<JpsiCharge<<" rbin "<<rbin<<endl; } bool PosPass=0, NegPass=0, AllCut=0 ,PosIn=0, NegIn=0; muPosPt= TMath::Sqrt(muPosPx*muPosPx + muPosPy*muPosPy); muPosP = TMath::Sqrt(muPosPx*muPosPx + muPosPy*muPosPy+ muPosPz*muPosPz); muNegPt= TMath::Sqrt(muNegPx*muNegPx + muNegPy*muNegPy); muNegP = TMath::Sqrt(muNegPx*muNegPx + muNegPy*muNegPy +muNegPz*muNegPz); double tnpWgt1 = 0.0, tnpWgt2 = 0.0; double staWgt1 = 0.0, staWgt2 = 0.0; double x = 0.0; double xta = 0.0; // tnp MuonID X Trg if(fabs(muPosEta) < 0.9){ x = muPosPt; tnpWgt1 = tnpSF1->Eval(x); }else if(fabs(muPosEta) < 1.6){ x = muPosPt; tnpWgt1 = tnpSF2->Eval(x); }else if(fabs(muPosEta) < 2.1){ x = muPosPt; tnpWgt1 = tnpSF3->Eval(x); }else{ x = muPosPt; tnpWgt1 = tnpSF4->Eval(x); } if(fabs(muNegEta) < 0.9){ x = muNegPt; tnpWgt2 = tnpSF1->Eval(x); }else if(fabs(muNegEta) < 1.6){ x = muNegPt; tnpWgt2 = tnpSF2->Eval(x); }else if(fabs(muNegEta) < 2.1){ x = muNegPt; tnpWgt2 = tnpSF3->Eval(x); }else{ x = muNegPt; tnpWgt2 = tnpSF4->Eval(x); } // tnp STA if(fabs(muPosEta) < 1.6){ xta = muPosPt; staWgt1 = fun1->Eval(xta); }else{ xta = muPosPt; staWgt1 = fun2->Eval(xta); } if(fabs(muNegEta) < 1.6){ xta = muNegPt; staWgt2 = fun1->Eval(xta); }else{ xta = muNegPt; staWgt2 = fun2->Eval(xta); } double RecWeight = 1.0; RecWeight = tnpWgt1*tnpWgt2*staWgt1*staWgt2; if(IsAccept(muPosPt, muPosEta)){PosIn=1;} if(IsAccept(muNegPt, muNegEta)){NegIn=1;} int AccJpsi = 0; //if(JpsiPt < 6.5) continue; if((JpsiPt >= minPt && JpsiPt <= maxPt && fabs(JpsiRap) >= minRap && TMath::Abs(JpsiRap) <= maxRap && PosIn == 1 && NegIn == 1) && (JpsiMass >= 2.95 && JpsiMass < 3.25) ) {AccJpsi = 1;} bool mu_Global = ((muPos_nchi2Gl >=0) && (muNeg_nchi2Gl >=0)); bool mu_Tracker = ((muPos_tracker==1) && (muNeg_tracker==1)); if(muPos_found > 10 && muPos_pixeLayers > 0 && muPos_nchi2In < 4.0 && TMath::Abs(muPos_dxy) < 3 && TMath::Abs(muPos_dz) < 15 && muPos_nchi2Gl < 20 && muPos_arbitrated==1 && muPos_tracker==1){PosPass=1;} if(muNeg_found > 10 && muNeg_pixeLayers > 0 && muNeg_nchi2In < 4.0 && TMath::Abs(muNeg_dxy) < 3 && TMath::Abs(muNeg_dz) < 15 && muNeg_nchi2Gl < 20 && muNeg_arbitrated==1 && muNeg_tracker==1){NegPass=1;} // Trigger10 : HLT_PAL2DoubleMu3_v1, Trigger 2 : HLT_PAL1DoubleMu0_HighQ_v1, Trigger 1 : HLT_PAL1DoubleMu0_v1 // muPos_matches : HLT_PAL1DoubleMuOpen_v1 //if((muPos_Trigger21==1 && muNeg_Trigger21==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} if(hbit1 == 1 && (muPos_Trigger22==1 && muNeg_Trigger22==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} //if(hbit1 == 1 && (muPos_Trigger2==1 && muNeg_Trigger2==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} //if((muPos_matches==1 && muNeg_matches==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} //if((muPos_Trigger10==1 && muNeg_Trigger10==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} // without trigger matched // if((PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} //Eff loop for reco double vars = 0.0, bin1 = 0.0, bin2 = 0.0; if(iSpec == 0) vars = JpsiPt; if(iSpec == 1) vars = fabs(JpsiRap); if((JpsiCharge == 0) && (JpsiVprob > 0.01)) { for(int j = 0; j < nBins; j++){ if(iSpec == 0){ bin1 = pt_bound[j]; bin2 = pt_bound[j+1]; if( AccJpsi == 1 && (AllCut == 1) && (vars >= bin1 && vars < bin2) && TMath::Abs(JpsiRap) <= maxRap && TMath::Abs(JpsiRap) >= minRap) { hRecoDiMuon[j]->Fill(JpsiMass,RecWeight); } } if(iSpec == 1){ bin1 = rap_bound[j]; bin2 = rap_bound[j+1]; if( AccJpsi == 1 && (AllCut == 1) && (vars >= bin1 && vars < bin2) && JpsiPt >= minPt && JpsiPt <= maxPt) { hRecoDiMuon[j]->Fill(JpsiMass,RecWeight); } } } } } //rec tree loop ends //====================== File loop Starts ============================ /////////////////////////////////////////////////////////////////// cout<< " adding "<<endl; char gtmp[512], gtmp1[512]; char rtmp[512], rtmp1[512]; for(int i = 0; i < nBins; i++){ if(iSpec == 1) sprintf(gtmp,"hGenDiMuon_Pt_%0.1f_%0.1f",pt_bound[i],pt_bound[i+1]); if(iSpec == 2) sprintf(gtmp,"hGenDiMuon_Rap_%0.1f_%0.1f",rap_bound[i],rap_bound[i+1]); if(iSpec == 1) sprintf(gtmp1,"plots/Gen/hGenDiMuon_Pt_%0.1f_%0.1f.png",pt_bound[i],pt_bound[i+1]); if(iSpec == 2) sprintf(gtmp1,"plots/Gen/hGenDiMuon_Rap_%0.1f_%0.1f.png",rap_bound[i],rap_bound[i+1]); if(iSpec == 1) sprintf(rtmp,"hRecDiMuon_Pt_%0.1f_%0.1f",pt_bound[i],pt_bound[i+1]); if(iSpec == 2) sprintf(rtmp,"hRecDiMuon_Rap_%0.1f_%0.1f",rap_bound[i],rap_bound[i+1]); if(iSpec == 1) sprintf(rtmp1,"plots/Rec/hRecDiMuon_Pt_%0.1f_%0.1f.png",pt_bound[i],pt_bound[i+1]); if(iSpec == 2) sprintf(rtmp1,"plots/Rec/hRecDiMuon_Rap_%0.1f_%0.1f.png",rap_bound[i],rap_bound[i+1]); hGenDiMuon[i]->SetName(gtmp); hRecoDiMuon[i]->SetName(rtmp); } cout<<"Starts to calculate efficiency"<<endl; //dataFile<<""<<endl; //=====================Loop for eff========================================================================================// //define stuff here for error on weighted samples for(int i = 0; i < nBins; i++){ int Gbinlow =hGenDiMuon[i]->GetXaxis()->FindBin(2.0);//2.95 int Gbinhi=hGenDiMuon[i]->GetXaxis()->FindBin(4.0);//2.95 int Rbinlow =hRecoDiMuon[i]->GetXaxis()->FindBin(2.95);//2.95 int Rbinhi=hRecoDiMuon[i]->GetXaxis()->FindBin(3.25);//2.95 genNo[i] = hGenDiMuon[i]->IntegralAndError(Gbinlow, Gbinhi, genErr[i]); recoNo[i] = hRecoDiMuon[i]->IntegralAndError(Rbinlow, Rbinhi, recoErr[i]); //calculate Eff if(genNo[i] == 0 || recoNo[i] == 0) { eff[i] = 0; effErr[i] = 0; }else{ eff[i] = recoNo[i]/genNo[i]; effErr[i] = recoNo[i]/genNo[i]*TMath::Sqrt(genErr[i]*genErr[i]/(genNo[i]*genNo[i]) + recoErr[i]*recoErr[i]/(recoNo[i]*recoNo[i])); //error without weight //dataFile<<" Bin ["<<i<<"] - "<< " Reco Jpsi : "<< recoNo[i] <<", Gen Jpsi : "<< genNo[i] <<endl; //dataFile<<" Eff ["<<i<<"] - "<< eff[i] <<" Error "<< effErr[i] <<endl; cout<<" Bin ["<<i<<"] - "<< " Reco Jpsi : "<< recoNo[i] <<", Gen Jpsi : "<< genNo[i] <<endl; cout<<" Eff ["<<i<<"] - "<< eff[i] <<" Error "<< effErr[i] <<endl; } } TH1F *hEff = new TH1F(); int nEffBins = 0; if(iSpec == 0) {hEff = new TH1F("hEff","hEff;p_{T} GeV/c;Efficiency",nPtBins,pt_bound); nEffBins = nPtBins;} if(iSpec == 1) {hEff = new TH1F("hEff","hEff;y;Efficiency",nRapBins,rap_bound); nEffBins = nRapBins;} //dataFile<<"Efficiency"<<endl; for(int i = 0; i < nEffBins; i++){ hEff->SetBinContent(i+1,eff[i]); hEff->SetBinError(i+1,effErr[i]); cout<<"Trying to measure eff vs "<<cSp[iSpec]<<endl; cout<<"Eff : "<<eff[i]<<", err : "<<effErr[i]<<endl; dataFile<<eff[i]<<endl; } //dataFile<<""<<endl; //dataFile<<"Errors"<<endl; for(int i = 0; i < nEffBins; i++){ hEff->SetBinContent(i+1,eff[i]); hEff->SetBinError(i+1,effErr[i]); cout<<"Trying to measure eff vs "<<cSp[iSpec]<<endl; cout<<"Eff : "<<eff[i]<<", err : "<<effErr[i]<<endl; //dataFile<<effErr[i]<<endl; } outfile->cd(); hEff->Draw(); char tmp_histo[512]; sprintf(tmp_histo,"hEff_%s",cSp[iSpec]); hEff->SetName(tmp_histo); hEff->Write(); //dataFile<<""<<endl; //dataFile.close(); } outfile->Write(); }
int main(int argc, char* argv[]) { printf("Before tool\n"); BCHTool::BCHCleaningToolRoot thebchtool("thebchtool"); thebchtool.SetResponseVsBCHFile("BCHCleaningTool/share/BCH_Response.root"); ///TileTripReader initialisation and tests outside BCH tool //prepare a TileTripReader instance Root::TTileTripReader *ttr=new Root::TTileTripReader("thetripreader"); ttr->setTripFile("TileTripReader/data/CompleteTripList_2011-2012.root"); ttr->setVerbosity(0); //here we ask the TTR directly to give us the answer of a jet that is on the edge //the edges haven't yet been changed, so the answer should be no. bool isInDeadRegionBeforeEdgeChange = ttr->checkEtaPhi(211787,25000,0.1,0.35); cout << "In dead region, before edge change? " << isInDeadRegionBeforeEdgeChange << endl; //Set the edges ttr->m_LBOffsets.eta1=0.1; ttr->m_LBOffsets.eta2=0.1; ttr->m_LBOffsets.phi1=TMath::Pi()/32.; ttr->m_LBOffsets.phi2=TMath::Pi()/32.; //here we ask the TTR directly to give us the answer of a jet that is on the edge //the edges have now been changed, so the answer should be yes. bool isInDeadRegionAfterEdgeChange = ttr->checkEtaPhi(211787,25000,0.1,0.35); //NOTE: THIS IS WHERE IT DOES NOT GIVE ME THE RIGHT ANSWER!!! it should be TRUE below cout << "In dead region, after edge change? " << isInDeadRegionAfterEdgeChange << endl; ///PRW initialisation and tests //prepare a PRW instance Root::TPileupReweighting *prw=new Root::TPileupReweighting("thepileupreweighting"); //initialise it with a MC file, a data file and tell it what to do with unmatched data prw->AddConfigFile("RootFilesForTests/ExcitedQ_2000.prw.root"); prw->AddLumiCalcFile("RootFilesForTests/ilumicalc_histograms_None_200841-204158.root"); prw->SetUnrepresentedDataAction(2); prw->Initialize(); //initialize the BCH tool (for MC at the moment) //this will change the edges for the offsets of the TTR thebchtool.InitializeTool(false, ttr, prw); //here we ask the TTR directly to give us the answer of a jet that is on the edge //the edges haven't yet been changed, so the answer should be no. isInDeadRegionAfterEdgeChange = ttr->checkEtaPhi(211787,25000,0.1,0.35); cout << "In dead region, after edge change from BCH tool? " << isInDeadRegionAfterEdgeChange << endl; ///Stress test TFile* stressfulFile = TFile::Open("RootFilesForTests/stress_test.root"); TTree* stressfulTree = (TTree*) stressfulFile->Get("physics"); ///Some random q* MC //TODO add a different sample here std::vector<float> * v_jets_pt=0; std::vector<float> * v_jets_eta=0; std::vector<float> * v_jets_phi=0; stressfulTree->SetBranchAddress("jet_AntiKt4LCTopo_pt", &v_jets_pt); stressfulTree->SetBranchAddress("jet_AntiKt4LCTopo_eta", &v_jets_eta); stressfulTree->SetBranchAddress("jet_AntiKt4LCTopo_phi", &v_jets_phi); for (Int_t i=0;i<stressfulTree->GetEntries();i++) { stressfulTree->GetEntry(i); for (UInt_t ijet=0; ijet<v_jets_pt->size(); ijet++) { cout << "Jet pt:" << v_jets_pt->at(ijet) << endl; cout << "Jet eta:" << v_jets_eta->at(ijet) << endl; cout << "Jet phi:" << v_jets_phi->at(ijet) << endl; ///testing the basic functionality //note: need to pass the random number from MC to the BCHCleaningTool!! One can decide at this point whether to use mu or not //Here I've passed the RunNumber from a MC sample double mu = 20; int randomRunNumber = prw->GetRandomRunNumber(195847, mu); std::cout << "Random run number: " << randomRunNumber << std::endl; bool isInMaskedRegionBCH = thebchtool.IsInMaskedRegion(195847, v_jets_pt->at(ijet),v_jets_eta->at(ijet),v_jets_phi->at(ijet),mu); cout << "In dead region from BCHCleaningTool? " << isInMaskedRegionBCH << endl; //testing straight from the TTR ttr->setVerbosity(0); bool isInMaskedRegionTTR = ttr->checkEtaPhi(randomRunNumber,v_jets_pt->at(ijet),v_jets_eta->at(ijet),v_jets_phi->at(ijet)); cout << "In dead region from TTR? " << isInMaskedRegionTTR << endl; ///testing the response estimate cout << "Jet pT after response correction:" << thebchtool.EstimateJetResponseNoBCH(v_jets_pt->at(ijet), 0.3) << endl; } } printf("After tool\n"); return 0; }
void csv(TString input="tmva.csvoutput.txt", TString par1="par2", TString par2="par3", TString par3="", TString value="eventEffScaled_5") { std::cout << "Usage:" << std::endl << ".x scripts/csv.C with default arguments" << std::endl << ".x scripts/csv.C(filename, par1, par2, value)" << std::endl << std::endl << " Optional arguments:" << std::endl << " filename path to CSV file" << std::endl << " par1 name of X-parameter branch" << std::endl << " par2 name of Y-parameter branch (if empty, efficiency is drawn as a function of par1)" << std::endl << " value name of result (efficiency) branch" << std::endl << std::endl; TTree *tree = new TTree("data", "data"); tree->ReadFile(input); gStyle->SetPalette(1); gStyle->SetPadRightMargin(0.14); TCanvas *canvas = new TCanvas("csvoutput", "CSV Output", 1200, 900); tree->SetMarkerStyle(kFullDotMedium); tree->SetMarkerColor(kRed); if(par2.Length() > 0) { //tree->Draw(Form("%s:%s", par2.Data(), par1.Data())); if(par3.Length() > 0) tree->Draw(Form("%s:%s:%s:%s", par1.Data(), par2.Data(), par3.Data(), value.Data()), "", "COLZ"); //, "", "Z"); else tree->Draw(Form("%s:%s:%s", par2.Data(), par1.Data(), value.Data()), "", "COLZ"); //, "", "Z"); TH1 *histo = tree->GetHistogram(); if(!histo) return; histo->SetTitle(Form("%s with different classifier parameters", value.Data())); histo->GetXaxis()->SetTitle(Form("Classifier parameter %s", par1.Data())); histo->GetYaxis()->SetTitle(Form("Classifier parameter %s", par2.Data())); if(par3.Length() > 0) histo->GetZaxis()->SetTitle(Form("Classifier parameter %s", par3.Data())); else histo->GetZaxis()->SetTitle(""); if(par3.Length() == 0) { float x = 0; float y = 0; float val = 0; double maxVal = tree->GetMaximum(value); double minVal = tree->GetMinimum(value); tree->SetBranchAddress(par1, &x); tree->SetBranchAddress(par2, &y); tree->SetBranchAddress(value, &val); TLatex l; l.SetTextSize(0.03); Long64_t nentries = tree->GetEntries(); for(Long64_t entry=0; entry < nentries; ++entry) { tree->GetEntry(entry); l.SetTextColor(textColor(val, maxVal, minVal)); l.DrawLatex(x, y, Form("%.3f", val*100)); } } } else { tree->Draw(Form("%s:%s", value.Data(), par1.Data())); TH1 *histo = tree->GetHistogram(); if(!histo) return; histo->SetTitle(Form("%s with different classifier parameters", value.Data())); histo->GetXaxis()->SetTitle(Form("Classifier parameter %s", par1.Data())); histo->GetYaxis()->SetTitle(value); } }
void ReadTree_normDet(){ bool testrun = 0; const int norder_ = 2; static const int ptBinMin = 0; static const int ptBinMax = nptbinsDefault-1; static const int etaBinMin = 0; //0; static const int etaBinMax = netabinsDefault-1; TFile * fAna; TTree * tree; double centval; double vtx; TH2D * sumw; TH2D * sumwqx; TH2D * sumwqy; TH2I * hMult; TFile * fVNDet; TH1D * hVNDetX_0; TH1D * hVNDetY_0; TH1D * hVNDetX_1; TH1D * hVNDetY_1; TH1D * hVNDetX_full; TH1D * hVNDetY_full; TFile * fHists; TDirectory * qwebye; TH2D * hVn2Dfull[NCENT]; TH2D * hVn2Dsub0[NCENT]; TH2D * hVn2Dsub1[NCENT]; TH2D * hVn2D0v1[NCENT]; TH1D * hVnFull[NCENT]; TH1D * hVnSub0[NCENT]; TH1D * hVnSub1[NCENT]; TH1I * Mult[NCENT]; TH2D * h2Vn2D0v1[NCENT]; TH1D * h2Vn2D0v1Magnitude[NCENT]; double VnRaw_x_0; double VnRaw_y_0; double VnRaw_x_1; double VnRaw_y_1; double VnRaw_x_full; double VnRaw_y_full; double sumw_0; double sumw_1; double sumw_full; double VnCorrected_x_0; double VnCorrected_y_0; double VnCorrected_x_1; double VnCorrected_y_1; double VnCorrected_x_full; double VnCorrected_y_full; int evtMult_0; int evtMult_1; int evtMult_full; // // MAIN // setTDRStyle(); TH1D::SetDefaultSumw2(); TH2D::SetDefaultSumw2(); TH1I::SetDefaultSumw2(); //-- Set up analyzer objects fAna = new TFile(fAnaTreeName); tree = (TTree *) fAna->Get("ebyeana/tree"); sumwqx = new TH2D(Form("sumwqx%i", norder_), Form("sumwqx%i", norder_), nptbinsDefault, ptbinsDefault, netabinsDefault, etabinsDefault); sumwqy = new TH2D(Form("sumwqy%i", norder_), Form("sumwqy%i", norder_), nptbinsDefault, ptbinsDefault, netabinsDefault, etabinsDefault); sumw = new TH2D("sumw", "sumw", nptbinsDefault, ptbinsDefault, netabinsDefault, etabinsDefault); hMult = new TH2I("hMult", "hMult", nptbinsDefault, ptbinsDefault, netabinsDefault, etabinsDefault); tree->SetBranchAddress("Cent", ¢val); tree->SetBranchAddress("Vtx", &vtx); tree->SetBranchAddress("mult", &hMult); tree->SetBranchAddress(Form("sumwqx%i", norder_), &sumwqx); tree->SetBranchAddress(Form("sumwqy%i", norder_), &sumwqy); tree->SetBranchAddress("sumw", &sumw); //-- Set up VN detector objects fVNDet = new TFile( Form("V%iDet.root", norder_ ) ); hVNDetX_0 = (TH1D*) fVNDet->Get("SubEvt_0/hVNDetX_0"); hVNDetY_0 = (TH1D*) fVNDet->Get("SubEvt_0/hVNDetY_0"); hVNDetX_1 = (TH1D*) fVNDet->Get("SubEvt_1/hVNDetX_1"); hVNDetY_1 = (TH1D*) fVNDet->Get("SubEvt_1/hVNDetY_1"); hVNDetX_full = (TH1D*) fVNDet->Get("FullEvt/hVNDetX_full"); hVNDetY_full = (TH1D*) fVNDet->Get("FullEvt/hVNDetY_full"); //-- Setup the output objects fHists = new TFile("CastleEbyE.root","recreate"); qwebye = (TDirectory*) fHists->mkdir("qwebye"); for(int icent = 0; icent < NCENT; icent++){ qwebye->cd(); hVn2Dfull[icent] = new TH2D(Form("hVn2Dfull_c%i", icent), Form("hVn2Dfull_c%i", icent), 2*NBins, -vnMax[norder_], vnMax[norder_], 2*NBins, -vnMax[norder_], vnMax[norder_] ); hVn2Dfull[icent]->SetOption("colz"); hVn2Dfull[icent]->GetXaxis()->SetTitle( Form("v_{%i,x}^{obs}", norder_) ); hVn2Dfull[icent]->GetYaxis()->SetTitle( Form("v_{%i,y}^{obs}", norder_) ); hVn2Dsub0[icent] = new TH2D( Form("hVn2Dsub0_c%i", icent), Form("hVn2Dsub0_c%i", icent), 2*NBins, -vnMax[norder_], vnMax[norder_], 2*NBins, -vnMax[norder_], vnMax[norder_] ); hVn2Dsub0[icent]->SetOption("colz"); hVn2Dsub0[icent]->GetXaxis()->SetTitle( Form("v_{%i,x}^{obs,a}", norder_) ); hVn2Dsub0[icent]->GetYaxis()->SetTitle( Form("v_{%i,y}^{obs,a}", norder_) ); hVn2Dsub1[icent] = new TH2D( Form("hVn2Dsub1_c%i", icent), Form("hVn2Dsub1_c%i", icent), 2*NBins, -vnMax[norder_], vnMax[norder_], 2*NBins, -vnMax[norder_], vnMax[norder_] ); hVn2Dsub1[icent]->SetOption("colz"); hVn2Dsub1[icent]->GetXaxis()->SetTitle( Form("v_{%i,x}^{obs,b}", norder_) ); hVn2Dsub1[icent]->GetYaxis()->SetTitle( Form("v_{%i,y}^{obs,b}", norder_) ); hVn2D0v1[icent] = new TH2D( Form("hVn2D0v1_c%i", icent), Form("hVn2D0v1_c%i", icent), 2*NBins, -vnMax[norder_], vnMax[norder_], 2*NBins, -vnMax[norder_], vnMax[norder_] ); hVn2D0v1[icent]->SetOption("colz"); hVn2D0v1[icent]->GetXaxis()->SetTitle( Form("v_{%i,x}^{obs,a} - v_{%i,x}^{obs,b}", norder_, norder_) ); hVn2D0v1[icent]->GetYaxis()->SetTitle( Form("v_{%i,y}^{obs,a} - v_{%i,y}^{obs,b}", norder_, norder_) ); hVnFull[icent] = new TH1D( Form("hVnFull_c%i", icent), Form("hVnFull_c%i", icent), NBins, 0., vnMax[norder_] ); hVnFull[icent]->GetXaxis()->SetTitle( Form("v_{%i}", norder_) ); hVnFull[icent]->GetYaxis()->SetTitle( "Events" ); hVnSub0[icent] = new TH1D( Form("hVnSub0_c%i", icent), Form("hVnSub0_c%i", icent), NBins, 0., vnMax[norder_] ); hVnSub0[icent]->GetXaxis()->SetTitle( Form("v_{%i}^{obs,a}", norder_) ); hVnSub1[icent] = new TH1D( Form("hVnSub1_c%i", icent), Form("hVnSub1_c%i", icent), NBins, 0., vnMax[norder_] ); hVnSub1[icent]->GetXaxis()->SetTitle( Form("v_{%i}^{obs,b}", norder_) ); Mult[icent] = new TH1I( Form("Mult_c%i", icent), Form("Mult_c%i", icent), 300, 1, 1500 ); Mult[icent]->GetXaxis()->SetTitle("Multiplicity"); h2Vn2D0v1[icent] = new TH2D( Form("h2Vn2D0v1_c%i", icent), Form("h2Vn2D0v1_c%i", icent), 2*NBins, -vnMax[norder_], vnMax[norder_], 2*NBins, -vnMax[norder_], vnMax[norder_] ); h2Vn2D0v1[icent]->GetXaxis()->SetTitle( Form("(v_{%i,x}^{obs,a} - v_{%i,x}^{obs,b})/2", norder_, norder_) ); h2Vn2D0v1[icent]->GetYaxis()->SetTitle( Form("(v_{%i,y}^{obs,a} - v_{%i,y}^{obs,b})/2", norder_, norder_) ); h2Vn2D0v1[icent]->SetOption("colz"); h2Vn2D0v1Magnitude[icent] = new TH1D( Form("h2Vn2D0v1Magnitude_c%i", icent), Form("h2Vn2D0v1Magnitude_c%i", icent), NBins, 0., vnMax[norder_] ); h2Vn2D0v1Magnitude[icent]->GetXaxis()->SetTitle( Form("|(v_{%i,x}^{obs,a} - v_{%i,x}^{obs,b})/2|", norder_, norder_) ); } // // Tree Loop // cout<<"Begin FINAL loop, contains "<<tree->GetEntries()<<" Events"<<endl; int N; if( testrun ) N = 10000; else N = tree->GetEntries(); for(int ievent = 0; ievent < N; ievent++) { if((ievent+1)% 500000 == 0) cout<<"Processing Event "<<ievent+1<<"\t"<<100.*(ievent+1)/(double)N<<"% Completed"<<endl; tree->GetEntry(ievent); //-- Vertex Cut if(TMath::Abs(vtx) > 3.0) continue; //-- Calculate centbin if( centval > cent_max[NCENT-1]) continue; int icent = hCentBins.FindBin(centval)-1; //-- Reset raw and sumw values VnRaw_x_0 = 0; VnRaw_y_0 = 0; VnRaw_x_1 = 0; VnRaw_y_1 = 0; VnRaw_x_full = 0; VnRaw_y_full = 0; sumw_0 = 0; sumw_1 = 0; sumw_full = 0; evtMult_0 = 0; evtMult_1 = 0; evtMult_full = 0; //-- Begin analyzer histogram loops for(int ipt = ptBinMin; ipt <= ptBinMax; ipt++){ for(int ieta = etaBinMin; ieta <= etaBinMax; ieta++){ if(sumw->GetBinContent(ipt+1,ieta+1) !=0){ //-- Subevent 0 (eta >= 0) if(etabinsDefault[ieta] >= 0){ VnRaw_x_0 += sumwqx->GetBinContent(ipt+1,ieta+1); VnRaw_y_0 += sumwqy->GetBinContent(ipt+1,ieta+1); sumw_0 += sumw->GetBinContent(ipt+1,ieta+1); evtMult_0 += hMult->GetBinContent(ipt+1,ieta+1); } //-- Subevent 1 (eta < 0) else{ VnRaw_x_1 += sumwqx->GetBinContent(ipt+1,ieta+1); VnRaw_y_1 += sumwqy->GetBinContent(ipt+1,ieta+1); sumw_1 += sumw->GetBinContent(ipt+1,ieta+1); evtMult_1 += hMult->GetBinContent(ipt+1,ieta+1); } //-- Full Event VnRaw_x_full += sumwqx->GetBinContent(ipt+1,ieta+1); VnRaw_y_full += sumwqy->GetBinContent(ipt+1,ieta+1); sumw_full += sumw->GetBinContent(ipt+1,ieta+1); evtMult_full += hMult->GetBinContent(ipt+1,ieta+1); } } //-- End eta loop } //-- End pt loop //-- Fill Histograms, only use events that have at least two tracks in each SE if(sumw_0 == 0 || sumw_1 == 0 || evtMult_1 < 2 || evtMult_full < 2) continue; VnRaw_x_full /= sumw_full; VnRaw_y_full /= sumw_full; VnRaw_x_0 /= sumw_0; VnRaw_y_0 /= sumw_0; VnRaw_x_1 /= sumw_1; VnRaw_y_1 /= sumw_1; //-- Full Tracker VnCorrected_x_full = VnRaw_x_full - hVNDetX_full->GetBinContent(icent+1); VnCorrected_y_full = VnRaw_y_full - hVNDetY_full->GetBinContent(icent+1); double vn_full = TMath::Sqrt( VnCorrected_x_full * VnCorrected_x_full + VnCorrected_y_full * VnCorrected_y_full); hVnFull[icent] -> Fill( vn_full ); hVn2Dfull[icent] -> Fill(VnCorrected_x_full, VnCorrected_y_full); Mult[icent]->Fill(evtMult_full); //-- SubEvt 0 (Eta > 0) VnCorrected_x_0 = VnRaw_x_0 - hVNDetX_0->GetBinContent(icent+1); VnCorrected_y_0 = VnRaw_y_0 - hVNDetY_0->GetBinContent(icent+1); double vn_0 = TMath::Sqrt( VnCorrected_x_0 * VnCorrected_x_0 + VnCorrected_y_0 * VnCorrected_y_0 ); hVnSub0[icent] -> Fill( vn_0 ); hVn2Dsub0[icent] -> Fill(VnCorrected_x_0, VnCorrected_y_0); //-- SubEvt 1 (Eta < 0) VnCorrected_x_1 = VnRaw_x_1 - hVNDetX_1->GetBinContent(icent+1); VnCorrected_y_1 = VnRaw_y_1 - hVNDetY_1->GetBinContent(icent+1); double vn_1 = TMath::Sqrt( VnCorrected_x_1 * VnCorrected_x_1 + VnCorrected_y_1 *VnCorrected_y_1 ); hVnSub1[icent] -> Fill( vn_1 ); hVn2Dsub1[icent] -> Fill(VnCorrected_x_1, VnCorrected_y_1); //-- SubEvt Difference double vn0m1_x = VnCorrected_x_0 - VnCorrected_x_1; double vn0m1_y = VnCorrected_y_0 - VnCorrected_y_1; hVn2D0v1[icent]->Fill(vn0m1_x, vn0m1_y); //-- SubEvt Difference for DD response double vn0m1_x2 = (VnCorrected_x_0 - VnCorrected_x_1) / 2.; double vn0m1_y2 = (VnCorrected_y_0 - VnCorrected_y_1) / 2.; h2Vn2D0v1[icent]->Fill(vn0m1_x2, vn0m1_y2); double vn0m12 = TMath::Sqrt( pow(vn0m1_x2, 2) + pow(vn0m1_y2, 2) ); h2Vn2D0v1Magnitude[icent]->Fill(vn0m12); } //-- End Event loop cout<<"End FINAL loop!"<<endl; fHists->Write(); cout<<"File written, process completed"<<endl; }
void gastof_simple() { const unsigned int run_id = 725; TFile* f = new TFile(Form("../../gastof_inner_run%d.root", run_id)); //FIXME TTree* t = (TTree*)f->Get("tdc"); const unsigned int channels_to_probe = 32; //64; const double tot_min = 70., tot_max = -1.; const double lead_min = 6.8, lead_max = 6.95; // in \mus int num_hits; unsigned int ettt; double leading_edge[5000], tot[5000]; int channel_id[5000]; t->SetBranchStatus("*", 0); t->SetBranchStatus("num_measurements", 1); t->SetBranchAddress("num_measurements", &num_hits); t->SetBranchStatus("leading_edge", 1); t->SetBranchAddress("leading_edge", leading_edge); t->SetBranchStatus("channel_id", 1); t->SetBranchAddress("channel_id", channel_id); t->SetBranchStatus("tot", 1); t->SetBranchAddress("tot", tot); const unsigned int num_triggers = t->GetEntries(); TH1D* h_tot_all_channels = new TH1D("h_tot_all_channels", "", 250, 0., 1000.); TH1D* h_lead_all_channels = new TH1D("h_lead_all_channels", "", 500, 0., 10.); double last_ettt = -1.; unsigned int num_overfl = 0; unsigned int mult[channels_to_probe]; for (unsigned int i=0; i<num_triggers; i++) { t->GetEntry(i); for (unsigned int j=0; j<channels_to_probe; j++) { // lead[j].clear(); //lead[] not defined in gastof_simple mult[j] = 0; } if (i%10000==0) cerr << "Processing event " << i << " / " << num_triggers << endl; for (int j=0; j<num_hits; j++) { h_lead_all_channels->Fill(leading_edge[j]/1.e3, 1./num_triggers); if (leading_edge[j]<lead_min*1.e3 or leading_edge[j]>lead_max*1.e3) continue; h_tot_all_channels->Fill(tot[j]); } } GastofCanvas c_tot_all_chan("tot_all-channels", Form("Run %d, all channels", run_id)); h_tot_all_channels->Draw(); h_tot_all_channels->GetXaxis()->SetTitle("Time over threshold (ns)"); h_tot_all_channels->GetYaxis()->SetTitle("Hits"); { TPaveText* cuts = new TPaveText(0.4, 0.8, 0.5, 0.85, "ndc"); cuts->SetTextAlign(13); cuts->SetTextFont(43); cuts->SetTextSize(18); cuts->SetFillColor(kWhite); cuts->SetLineColor(kWhite); //cuts->AddText(Form("ToT > %.1f ns", tot_min)); cuts->AddText(Form("Lead. edge #in [%.1f-%.2f] #mus", lead_min, lead_max)); cuts->Draw("same"); } c_tot_all_chan.Pad()->SetLogy(); { TLine* line = new TLine(tot_min, 0., tot_min, h_tot_all_channels->GetMaximum()*0.8); //constructor for line: TLine( x1, y1, x2, y2) line->SetLineColor(kBlack); line->SetLineStyle(2); line->SetLineWidth(2); line->Draw("same"); } // if (tot_max>0.) { //<- condition never met in gastof_simple // TLine* line = new TLine(tot_max, 0., tot_max, h_tot_all_channels->GetMaximum()*0.8); // line->SetLineColor(kBlack); // line->SetLineStyle(2); // line->SetLineWidth(2); // line->Draw("same"); }
void TMVARegressionApplication( TString myMethodList = "" ) { //--------------------------------------------------------------- // This loads the library TMVA::Tools::Instance(); // Default MVA methods to be trained + tested std::map<std::string,int> Use; // --- Mutidimensional likelihood and Nearest-Neighbour methods Use["PDERS"] = 0; Use["PDEFoam"] = 1; Use["KNN"] = 1; // // --- Linear Discriminant Analysis Use["LD"] = 1; // // --- Function Discriminant analysis Use["FDA_GA"] = 1; Use["FDA_MC"] = 0; Use["FDA_MT"] = 0; Use["FDA_GAMT"] = 0; // // --- Neural Network Use["MLP"] = 1; // // --- Support Vector Machine Use["SVM"] = 0; // // --- Boosted Decision Trees Use["BDT"] = 0; Use["BDTG"] = 1; // --------------------------------------------------------------- std::cout << std::endl; std::cout << "==> Start TMVARegressionApplication" << std::endl; // Select methods (don't look at this code - not of interest) if (myMethodList != "") { for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0; std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' ); for (UInt_t i=0; i<mlist.size(); i++) { std::string regMethod(mlist[i]); if (Use.find(regMethod) == Use.end()) { std::cout << "Method \"" << regMethod << "\" not known in TMVA under this name. Choose among the following:" << std::endl; for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) std::cout << it->first << " "; std::cout << std::endl; return; } Use[regMethod] = 1; } } // -------------------------------------------------------------------------------------------------- // --- Create the Reader object TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" ); // Create a set of variables and declare them to the reader // - the variable names MUST corresponds in name and type to those given in the weight file(s) used Float_t var1, var2; reader->AddVariable( "var1", &var1 ); reader->AddVariable( "var2", &var2 ); // Spectator variables declared in the training have to be added to the reader, too Float_t spec1,spec2; reader->AddSpectator( "spec1:=var1*2", &spec1 ); reader->AddSpectator( "spec2:=var1*3", &spec2 ); // --- Book the MVA methods TString dir = "weights/"; TString prefix = "TMVARegression"; // Book method(s) for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) { if (it->second) { TString methodName = it->first + " method"; TString weightfile = dir + prefix + "_" + TString(it->first) + ".weights.xml"; reader->BookMVA( methodName, weightfile ); } } // Book output histograms TH1* hists[100]; Int_t nhists = -1; for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) { TH1* h = new TH1F( it->first.c_str(), TString(it->first) + " method", 100, -100, 600 ); if (it->second) hists[++nhists] = h; } nhists++; // Prepare input tree (this must be replaced by your data source) // in this example, there is a toy tree with signal and one with background events // we'll later on use only the "signal" events for the test in this example. // TFile *input(0); TString fname = "./tmva_reg_example.root"; if (!gSystem->AccessPathName( fname )) { input = TFile::Open( fname ); // check if file in local directory exists } else { input = TFile::Open( "http://root.cern.ch/files/tmva_reg_example.root" ); // if not: download from ROOT server } if (!input) { std::cout << "ERROR: could not open data file" << std::endl; exit(1); } std::cout << "--- TMVARegressionApp : Using input file: " << input->GetName() << std::endl; // --- Event loop // Prepare the tree // - here the variable names have to corresponds to your tree // - you can use the same variables as above which is slightly faster, // but of course you can use different ones and copy the values inside the event loop // TTree* theTree = (TTree*)input->Get("TreeR"); std::cout << "--- Select signal sample" << std::endl; theTree->SetBranchAddress( "var1", &var1 ); theTree->SetBranchAddress( "var2", &var2 ); std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl; TStopwatch sw; sw.Start(); for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) { if (ievt%1000 == 0) { std::cout << "--- ... Processing event: " << ievt << std::endl; } theTree->GetEntry(ievt); // Retrieve the MVA target values (regression outputs) and fill into histograms // NOTE: EvaluateRegression(..) returns a vector for multi-target regression for (Int_t ih=0; ih<nhists; ih++) { TString title = hists[ih]->GetTitle(); Float_t val = (reader->EvaluateRegression( title ))[0]; hists[ih]->Fill( val ); } } sw.Stop(); std::cout << "--- End of event loop: "; sw.Print(); // --- Write histograms TFile *target = new TFile( "TMVARegApp.root","RECREATE" ); for (Int_t ih=0; ih<nhists; ih++) hists[ih]->Write(); target->Close(); std::cout << "--- Created root file: \"" << target->GetName() << "\" containing the MVA output histograms" << std::endl; delete reader; std::cout << "==> TMVARegressionApplication is done!" << std::endl << std::endl; }
int main(int argc, char* argv[]) { TFile* f = new TFile("example/ntuple.root","READ"); TTree* t = (TTree*) f->Get("EleTauKinFit"); TH1F* h_mH = new TH1F("h_mH", "distribution of mH_{fit};mH_{fit} [GeV];entries/5GeV", 40,200,400); TH1F* h_chi2 = new TH1F("h_chi2", "distribution of #chi^{2}_{fit};#chi^{2}_{fit};entries/1", 100,0,25); TH1F* h_prob = new TH1F("h_prob", "distribution of fit probability;P_{fit};entries/0.05", 100,0,1); TH1F* h_pull1 = new TH1F("h_pull1","pull distribution E_{b1};pull;entries/0.25", 20,-5,5); TH1F* h_pull2 = new TH1F("h_pull2","pull distribution E_{b2};pull;entries/0.25", 20,-5,5); TH1F* h_pullB = new TH1F("h_pullB","pull distribution balance;pull;entries/0.25", 20,-5,5); Int_t max_nevent = t->GetEntriesFast(); //Leaf types Int_t njets; Double_t b1_dR; Double_t b1_csv; Double_t b1_px; Double_t b1_py; Double_t b1_pz; Double_t b1_E; Double_t b2_dR; Double_t b2_csv; Double_t b2_px; Double_t b2_py; Double_t b2_pz; Double_t b2_E; Double_t tauvis1_dR; Double_t tauvis1_px; Double_t tauvis1_py; Double_t tauvis1_pz; Double_t tauvis1_E; Double_t tauvis2_dR; Double_t tauvis2_px; Double_t tauvis2_py; Double_t tauvis2_pz; Double_t tauvis2_E; Double_t met_pt; Double_t met_px; Double_t met_py; Double_t met_cov00; Double_t met_cov10; Double_t met_cov01; Double_t met_cov11; // List of branches TBranch *b_njets; TBranch *b_b1_dR; TBranch *b_b1_csv; TBranch *b_b1_px; TBranch *b_b1_py; TBranch *b_b1_pz; TBranch *b_b1_E; TBranch *b_b2_dR; TBranch *b_b2_csv; TBranch *b_b2_px; TBranch *b_b2_py; TBranch *b_b2_pz; TBranch *b_b2_E; TBranch *b_tauvis1_dR; TBranch *b_tauvis1_px; TBranch *b_tauvis1_py; TBranch *b_tauvis1_pz; TBranch *b_tauvis1_E; TBranch *b_tauvis2_dR; TBranch *b_tauvis2_px; TBranch *b_tauvis2_py; TBranch *b_tauvis2_pz; TBranch *b_tauvis2_E; TBranch *b_met_pt; TBranch *b_met_px; TBranch *b_met_py; TBranch *b_met_cov00; TBranch *b_met_cov10; TBranch *b_met_cov01; TBranch *b_met_cov11; t->SetBranchAddress("Njets", &njets, &b_njets); t->SetBranchAddress("b1_dR", &b1_dR, &b_b1_dR); t->SetBranchAddress("b1_csv", &b1_csv, &b_b1_csv); t->SetBranchAddress("b1_px", &b1_px, &b_b1_px); t->SetBranchAddress("b1_py", &b1_py, &b_b1_py); t->SetBranchAddress("b1_pz", &b1_pz, &b_b1_pz); t->SetBranchAddress("b1_E", &b1_E, &b_b1_E); t->SetBranchAddress("b2_dR", &b2_dR, &b_b2_dR); t->SetBranchAddress("b2_csv", &b2_csv, &b_b2_csv); t->SetBranchAddress("b2_px", &b2_px, &b_b2_px); t->SetBranchAddress("b2_py", &b2_py, &b_b2_py); t->SetBranchAddress("b2_pz", &b2_pz, &b_b2_pz); t->SetBranchAddress("b2_E", &b2_E, &b_b2_E); t->SetBranchAddress("tauvis1_dR", &tauvis1_dR, &b_tauvis1_dR); t->SetBranchAddress("tauvis1_px", &tauvis1_px, &b_tauvis1_px); t->SetBranchAddress("tauvis1_py", &tauvis1_py, &b_tauvis1_py); t->SetBranchAddress("tauvis1_pz", &tauvis1_pz, &b_tauvis1_pz); t->SetBranchAddress("tauvis1_E", &tauvis1_E, &b_tauvis1_E); t->SetBranchAddress("tauvis2_dR", &tauvis2_dR, &b_tauvis2_dR); t->SetBranchAddress("tauvis2_px", &tauvis2_px, &b_tauvis2_px); t->SetBranchAddress("tauvis2_py", &tauvis2_py, &b_tauvis2_py); t->SetBranchAddress("tauvis2_pz", &tauvis2_pz, &b_tauvis2_pz); t->SetBranchAddress("tauvis2_E", &tauvis2_E, &b_tauvis2_E); t->SetBranchAddress("met_pt", &met_pt, &b_met_pt); t->SetBranchAddress("met_px", &met_px, &b_met_px); t->SetBranchAddress("met_py", &met_py, &b_met_py); t->SetBranchAddress("met_cov00", &met_cov00, &b_met_cov00); t->SetBranchAddress("met_cov10", &met_cov10, &b_met_cov10); t->SetBranchAddress("met_cov01", &met_cov01, &b_met_cov01); t->SetBranchAddress("met_cov11", &met_cov11, &b_met_cov11); //define the testd hypotheses std::vector<Int_t> hypo_mh1; hypo_mh1.push_back(125); std::vector<Int_t> hypo_mh2; hypo_mh2.push_back(125); // event loop for (int i = 0; i < max_nevent; i++) { t->GetEntry(i); //use only btaged jets and check for correct gen match if (b1_csv<0.681 || b2_csv<0.681 || njets < 2 || b1_dR > 0.2 || b2_dR > 0.2 || tauvis1_dR > 0.1 || tauvis2_dR > 0.1) continue; //define input vectors TLorentzVector b1 = TLorentzVector(b1_px,b1_py,b1_pz,b1_E); TLorentzVector b2 = TLorentzVector(b2_px,b2_py,b2_pz,b2_E); TLorentzVector tau1vis = TLorentzVector(tauvis1_px,tauvis1_py,tauvis1_pz,tauvis1_E); TLorentzVector tau2vis = TLorentzVector(tauvis2_px,tauvis2_py,tauvis2_pz,tauvis2_E); TLorentzVector ptmiss = TLorentzVector(met_px,met_py,0,met_pt); TMatrixD metcov(2,2); metcov(0,0)=met_cov00; metcov(1,0)=met_cov10; metcov(0,1)=met_cov01; metcov(1,1)=met_cov11; //intance of fitter master class HHKinFitMaster kinFits = HHKinFitMaster(&b1,&b2,&tau1vis,&tau2vis); kinFits.setAdvancedBalance(&ptmiss,metcov); //kinFits.setSimpleBalance(ptmiss.Pt(),10); //alternative which uses only the absolute value of ptmiss in the fit kinFits.addMh1Hypothesis(hypo_mh1); kinFits.addMh2Hypothesis(hypo_mh2); kinFits.doFullFit(); //obtain results from different hypotheses Double_t chi2_best = kinFits.getBestChi2FullFit(); Double_t mh_best = kinFits.getBestMHFullFit(); std::pair<Int_t, Int_t> bestHypo = kinFits.getBestHypoFullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_chi2 = kinFits.getChi2FullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_fitprob = kinFits.getFitProbFullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_mH = kinFits.getMHFullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_pull_b1 = kinFits.getPullB1FullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_pull_b2 = kinFits.getPullB2FullFit(); std::map< std::pair<Int_t, Int_t>, Double_t> fit_results_pull_balance = kinFits.getPullBalanceFullFit(); std::map< std::pair<Int_t, Int_t>, Int_t> fit_convergence = kinFits.getConvergenceFullFit(); std::cout << "#############################" << std::endl; std::cout << "EVENT" << i << std::endl; std::cout << "#############################" << std::endl; std::cout << "=====================================" << std::endl; std::cout << "event: " << i << std::endl; std::cout << "best chi2: " << chi2_best << std::endl; std::cout << "best hypothesis: " << bestHypo.first << " " << bestHypo.second << std::endl; std::cout << "best mH= " << mh_best << std::endl; std::cout << "*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*" << std::endl; //individual loop over results for (std::vector<Int_t>::iterator mh2 = hypo_mh2.begin(); mh2 != hypo_mh2.end(); mh2++){ for (std::vector<Int_t>::iterator mh1 = hypo_mh1.begin(); mh1 != hypo_mh1.end(); mh1++){ std::pair< Int_t, Int_t > hypo(*mh1,*mh2); //sanity cuts: use only converged fits and events with chi2<25 and make sure used cov was positive definit (this needs to be fixed!) if (fit_convergence.at(hypo)>0 && fit_results_chi2.at(hypo)<25 && fit_results_pull_balance.at(hypo)>0){ std::cout << *mh1 << " " << *mh2 << " " << "chi2_fit: " << fit_results_chi2.at(hypo) << std::endl; std::cout << *mh1 << " " << *mh2 << " " << "prob_fit: " << fit_results_fitprob.at(hypo) << std::endl; std::cout << *mh1 << " " << *mh2 << " " << "mH_fit= " << fit_results_mH.at(hypo) << std::endl; std::cout << "*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*" << std::endl; h_mH->Fill(fit_results_mH.at(hypo)); h_chi2->Fill(fit_results_chi2.at(hypo)); h_prob->Fill(fit_results_fitprob.at(hypo)); h_pull1->Fill(fit_results_pull_b1.at(hypo)); h_pull2->Fill(fit_results_pull_b2.at(hypo)); h_pullB->Fill(fit_results_pull_balance.at(hypo)); } } } } TFile fout("result.root","RECREATE"); h_mH->Write(); h_chi2->Write(); h_prob->Write(); h_pull1->Write(); h_pull2->Write(); h_pullB->Write(); return (0); }
void cut_eff2() { // TString inputpath = "/afs/cern.ch/work/m/mwang/public/EDBR/trees/productionv1_1130/fullrange/"; TString inputpath = "/afs/cern.ch/work/m/mwang/public/EDBR/trees/productionv1_1206/fullrange/"; TString cut = "btag_eff"; vector<TString> dataSamples; vector<TString> bkgSamples; vector<TString> sigSamples; /* dataSamples.push_back("data_xwh"); bkgSamples.push_back("TTBARpowheg_xwh"); bkgSamples.push_back("VV_xwh"); bkgSamples.push_back("WJetsPt180_xwh"); bkgSamples.push_back("DYJets_xwh"); bkgSamples.push_back("SingleTop_xwh"); sigSamples.push_back("MWp_1000_gg_xwh"); sigSamples.push_back("MWp_1500_gg_xwh"); sigSamples.push_back("MWp_2000_gg_xwh"); sigSamples.push_back("MWp_1000_cc_xwh"); sigSamples.push_back("MWp_1500_cc_xwh"); sigSamples.push_back("MWp_2000_cc_xwh"); sigSamples.push_back("MWp_1000_bb_xwh"); sigSamples.push_back("MWp_1500_bb_xwh"); sigSamples.push_back("MWp_2000_bb_xwh"); sigSamples.push_back("MWp_1000_xwh"); sigSamples.push_back("MWp_1500_xwh"); sigSamples.push_back("MWp_2000_xwh"); */ dataSamples.push_back(""); bkgSamples.push_back("TTBARmadgraph_xwh"); bkgSamples.push_back("WJetsPt180_xwh"); sigSamples.push_back("MWp_1000_gg_xwh"); sigSamples.push_back("MWp_1000_cc_xwh"); sigSamples.push_back("MWp_1000_bb_xwh"); sigSamples.push_back("MWp_1000_xwh"); sigSamples.push_back("MWp_1500_gg_xwh"); sigSamples.push_back("MWp_1500_cc_xwh"); sigSamples.push_back("MWp_1500_bb_xwh"); sigSamples.push_back("MWp_1500_xwh"); sigSamples.push_back("MWp_2000_gg_xwh"); sigSamples.push_back("MWp_2000_cc_xwh"); sigSamples.push_back("MWp_2000_bb_xwh"); sigSamples.push_back("MWp_2000_xwh"); int ndata = 0;//dataSamples.size(); int nbkg = bkgSamples.size(); int nsig = sigSamples.size(); cout<<"data samples "<<ndata<<" bkg samples "<<nbkg<<" signal samples "<<nsig<<endl; //TH1F * h1 = new TH1F (cut,cut,ndata+nbkg+nsig+1,0,ndata+nbkg+nsig+1); TH1F * h1 = new TH1F (cut,cut,14 ,0,14);// number of samples //h1->GetYaxis()->SetRangeUser(0,1); h1->SetBit(TH1::kCanRebin); h1->SetStats(0); gStyle->SetPaintTextFormat("1.4f"); //h1->Sumw2(); TH1F *h2 = (TH1F*)h1->Clone(cut+"_2"); TH1F *h3 = (TH1F*)h1->Clone(cut+"_3"); TH1F *h4 = (TH1F*)h1->Clone(cut+"_4"); TH1F *h5 = (TH1F*)h1->Clone(cut+"_5"); TH1F *h6 = (TH1F*)h1->Clone(cut+"_6"); TH1F *h7 = (TH1F*)h1->Clone(cut+"_7"); TH1F *h8 = (TH1F*)h1->Clone(cut+"_8"); TH1F *h9 = (TH1F*)h1->Clone(cut+"_9"); TH1F *h10 = (TH1F*)h1->Clone(cut+"_10"); TH1F *h11 = (TH1F*)h1->Clone(cut+"_11"); TH1F *h12 = (TH1F*)h1->Clone(cut+"_12"); TH1F *h13 = (TH1F*)h1->Clone(cut+"_13"); TH1F *h14 = (TH1F*)h1->Clone(cut+"_14"); TH1F *h15 = (TH1F*)h1->Clone(cut+"_15"); TH1F *h16 = (TH1F*)h1->Clone(cut+"_16"); TH1F *h17 = (TH1F*)h1->Clone(cut+"_17"); TH1F *h18 = (TH1F*)h1->Clone(cut+"_18"); TCanvas * c1 = new TCanvas(); for(int i =0; i<ndata+nbkg+nsig; i++ ) { TString filename; TString samplename; if(i<ndata) { filename = "treeEDBR_"+dataSamples.at(i)+".root"; samplename = dataSamples.at(i);//data_xwh samplename.Remove(samplename.Length()-4,4);//data //samplename.Remove(0,12);//2012A_13Jul2012 } else if(i>=ndata&&i<(ndata+nbkg)) { filename = "treeEDBR_"+bkgSamples.at(i-ndata)+".root"; samplename = bkgSamples.at(i-ndata);//TTBAR_xwh samplename.Remove(samplename.Length()-4,4);//TTBAR } else if(i>=(ndata+nbkg)) { filename = "treeEDBR_"+sigSamples.at(i-ndata-nbkg)+".root"; samplename = sigSamples.at(i-ndata-nbkg);//MWp_1000_gg_xwh //RSG_WW_lvjj_c0p2_M1500_xww,BulkG_WW_lvjj_c1p0_M1500_xww samplename.Remove(samplename.Length()-4,4);//MWp_1000_gg // RSG_WW_lvjj_c0p2_M1500,BulkG_WW_lvjj_c1p0_M1500 if(samplename.Contains("RSG"))samplename.Remove(4,8);//RSG_c0p2_M1500 if(samplename.Contains("BulkG"))samplename.Remove(6,8);//BulkG_c1p0_M1500 } cout<<filename<<endl; cout<<samplename<<endl; TFile *fp = new TFile(inputpath+"/"+filename); TTree * tree = (TTree *) fp->Get("SelectedCandidates"); int entries = tree->GetEntries(); cout<<"entries: "<<entries<<endl; double pass1=0; double pass2=0; double pass3=0; double pass4=0; double pass5=0; double pass6=0; double pass7=0; double pass8=0; double pass9=0; double pass10=0; double pass11=0; double pass12=0; double pass13=0; double pass14=0; double pass15=0; double pass16=0; double pass17=0; double pass18=0; double total=0; int nLooseEle; int nLooseMu; float nsubjetbtagL[99]; float nsubjetbtagM[99]; float nsubjetbtagT[99]; float nfatjetbtagL[99]; float nfatjetbtagM[99]; float nfatjetbtagT[99]; //to make cuts double met; double ptlep1[99]; double ptZll[99]; double ptZjj[99]; double lep[99]; int nCands; int nXjets[99]; double region[99]; // event weight double weight=-1; tree->SetBranchAddress("nLooseMu", &nLooseMu); tree->SetBranchAddress("nLooseEle",&nLooseEle); tree->SetBranchAddress("nsubjetbtagL",nsubjetbtagL); tree->SetBranchAddress("nsubjetbtagM",nsubjetbtagM); tree->SetBranchAddress("nsubjetbtagT",nsubjetbtagT); tree->SetBranchAddress("nfatjetbtagL",nfatjetbtagL); tree->SetBranchAddress("nfatjetbtagM",nfatjetbtagM); tree->SetBranchAddress("nfatjetbtagT",nfatjetbtagT); tree->SetBranchAddress("ptlep1", ptlep1); tree->SetBranchAddress("ptZll", ptZll); tree->SetBranchAddress("ptZjj", ptZjj); tree->SetBranchAddress("met", &met); tree->SetBranchAddress("nXjets", nXjets); tree->SetBranchAddress("lep", lep); tree->SetBranchAddress("nCands", &nCands); tree->SetBranchAddress("region", ®ion); tree->SetBranchAddress("weight", &weight); bool filled = 0; for(int j=0;j<entries;j++) { tree->GetEntry(j); //per event weight double actualWeight = weight*19538.85; if(i<ndata) actualWeight =1; //for data //cout<<actualWeight<<endl; filled = 0; //if(nCands==0)continue; for(int ivec=0;ivec<nCands;ivec++){ if(filled==0) { //cout<<nXjets[ivec]<<endl; //make cuts if((nLooseEle+nLooseMu)!=1)continue; //if(met<80)continue; if(lep[ivec]!=1.)continue;//mu if(nXjets[ivec]!=1)continue; if(region[ivec]!=1)continue; total = total + actualWeight; if(nsubjetbtagL[ivec]>=1&&nfatjetbtagL[ivec]>=1)pass1=pass1+actualWeight; if(nsubjetbtagM[ivec]>=1&&nfatjetbtagL[ivec]>=1)pass2=pass2+actualWeight; if(nsubjetbtagT[ivec]>=1&&nfatjetbtagL[ivec]>=1)pass3=pass3+actualWeight; if(nsubjetbtagL[ivec]>=2&&nfatjetbtagL[ivec]>=1)pass4=pass4+actualWeight; if(nsubjetbtagM[ivec]>=2&&nfatjetbtagL[ivec]>=1)pass5=pass5+actualWeight; if(nsubjetbtagT[ivec]>=2&&nfatjetbtagL[ivec]>=1)pass6=pass6+actualWeight; if(nsubjetbtagL[ivec]>=1&&nfatjetbtagM[ivec]>=1)pass7=pass7+actualWeight; if(nsubjetbtagM[ivec]>=1&&nfatjetbtagM[ivec]>=1)pass8=pass8+actualWeight; if(nsubjetbtagT[ivec]>=1&&nfatjetbtagM[ivec]>=1)pass9=pass9+actualWeight; if(nsubjetbtagL[ivec]>=2&&nfatjetbtagM[ivec]>=1)pass10=pass10+actualWeight; if(nsubjetbtagM[ivec]>=2&&nfatjetbtagM[ivec]>=1)pass11=pass11+actualWeight; if(nsubjetbtagT[ivec]>=2&&nfatjetbtagM[ivec]>=1)pass12=pass12+actualWeight; if(nsubjetbtagL[ivec]>=1&&nfatjetbtagT[ivec]>=1)pass13=pass13+actualWeight; if(nsubjetbtagM[ivec]>=1&&nfatjetbtagT[ivec]>=1)pass14=pass14+actualWeight; if(nsubjetbtagT[ivec]>=1&&nfatjetbtagT[ivec]>=1)pass15=pass15+actualWeight; if(nsubjetbtagL[ivec]>=2&&nfatjetbtagT[ivec]>=1)pass16=pass16+actualWeight; if(nsubjetbtagM[ivec]>=2&&nfatjetbtagT[ivec]>=1)pass17=pass17+actualWeight; if(nsubjetbtagT[ivec]>=2&&nfatjetbtagT[ivec]>=1)pass18=pass18+actualWeight; filled =1; } }//end of candidates loop }//end of tree loop double eff1=0; double eff2=0; double eff3=0; double eff4=0; double eff5=0; double eff6=0; double eff7=0; double eff8=0; double eff9=0; double eff10=0; double eff11=0; double eff12=0; double eff13=0; double eff14=0; double eff15=0; double eff16=0; double eff17=0; double eff18=0; if(total!=0) { eff1 = (double)pass1/(double)total; eff2 = (double)pass2/(double)total; eff3 = (double)pass3/(double)total; eff4 = (double)pass4/(double)total; eff5 = (double)pass5/(double)total; eff6 = (double)pass6/(double)total; eff7 = (double)pass7/(double)total; eff8 = (double)pass8/(double)total; eff9 = (double)pass9/(double)total; eff10 = (double)pass10/(double)total; eff11 = (double)pass11/(double)total; eff12 = (double)pass12/(double)total; eff13 = (double)pass13/(double)total; eff14 = (double)pass14/(double)total; eff15 = (double)pass15/(double)total; eff16 = (double)pass16/(double)total; eff17 = (double)pass17/(double)total; eff18 = (double)pass18/(double)total; } cout<<"total: "<<total<<" pass1: "<<pass1<<" eff: "<<eff1<<endl; cout<<"total: "<<total<<" pass2: "<<pass2<<" eff: "<<eff2<<endl; cout<<"total: "<<total<<" pass3: "<<pass3<<" eff: "<<eff3<<endl; cout<<"total: "<<total<<" pass4: "<<pass4<<" eff: "<<eff4<<endl; cout<<"total: "<<total<<" pass5: "<<pass5<<" eff: "<<eff5<<endl; cout<<"total: "<<total<<" pass6: "<<pass6<<" eff: "<<eff6<<endl; cout<<"total: "<<total<<" pass7: "<<pass7<<" eff: "<<eff7<<endl; cout<<"total: "<<total<<" pass8: "<<pass8<<" eff: "<<eff8<<endl; cout<<"total: "<<total<<" pass9: "<<pass9<<" eff: "<<eff9<<endl; cout<<"total: "<<total<<" pass10: "<<pass10<<" eff: "<<eff10<<endl; cout<<"total: "<<total<<" pass11: "<<pass11<<" eff: "<<eff11<<endl; cout<<"total: "<<total<<" pass12: "<<pass12<<" eff: "<<eff12<<endl; cout<<"total: "<<total<<" pass13: "<<pass13<<" eff: "<<eff13<<endl; cout<<"total: "<<total<<" pass14: "<<pass14<<" eff: "<<eff14<<endl; cout<<"total: "<<total<<" pass15: "<<pass15<<" eff: "<<eff15<<endl; cout<<"total: "<<total<<" pass16: "<<pass16<<" eff: "<<eff16<<endl; cout<<"total: "<<total<<" pass17: "<<pass17<<" eff: "<<eff17<<endl; cout<<"total: "<<total<<" pass18: "<<pass18<<" eff: "<<eff18<<endl; h1->Fill(samplename,eff1); h2->Fill(samplename,eff2); h3->Fill(samplename,eff3); h4->Fill(samplename,eff4); h5->Fill(samplename,eff5); h6->Fill(samplename,eff6); h7->Fill(samplename,eff7); h8->Fill(samplename,eff8); h9->Fill(samplename,eff9); h10->Fill(samplename,eff10); h11->Fill(samplename,eff11); h12->Fill(samplename,eff12); h13->Fill(samplename,eff13); h14->Fill(samplename,eff14); h15->Fill(samplename,eff15); h16->Fill(samplename,eff16); h17->Fill(samplename,eff17); h18->Fill(samplename,eff18); }//end of sample loop c1->SetGridy(1); h1->SetTitle(cut+"_subL1fatL1"); h1->Draw(); h1->Draw("TEXT0same"); c1->SaveAs(cut+"_subL1fatL1.png"); h2->SetTitle(cut+"_subM1fatL1"); h2->Draw(); h2->Draw("TEXT0same"); c1->SaveAs(cut+"_subM1fatL1.png"); h3->SetTitle(cut+"_subT1fatL1"); h3->Draw(); h3->Draw("TEXT0same"); c1->SaveAs(cut+"_subT1fatL1.png"); h4->SetTitle(cut+"_subL2fatL1"); h4->Draw(); h4->Draw("TEXT0same"); c1->SaveAs(cut+"_subL2fatL1.png"); h5->SetTitle(cut+"_subM2fatL1"); h5->Draw(); h5->Draw("TEXT0same"); c1->SaveAs(cut+"_subM2fatL1.png"); h6->SetTitle(cut+"_subT2fatL1"); h6->Draw(); h6->Draw("TEXT0same"); c1->SaveAs(cut+"_subT2fatL1.png"); h7->SetTitle(cut+"_subL1fatM1"); h7->Draw(); h7->Draw("TEXT0same"); c1->SaveAs(cut+"_subL1fatM1.png"); h8->SetTitle(cut+"_subM1fatM1"); h8->Draw(); h8->Draw("TEXT0same"); c1->SaveAs(cut+"_subM1fatM1.png"); h9->SetTitle(cut+"_subT1fatM1"); h9->Draw(); h9->Draw("TEXT0same"); c1->SaveAs(cut+"_subT1fatM1.png"); h10->SetTitle(cut+"_subL2fatM1"); h10->Draw(); h10->Draw("TEXT0same"); c1->SaveAs(cut+"_subL2fatM1.png"); h11->SetTitle(cut+"_subM2fatM1"); h11->Draw(); h11->Draw("TEXT0same"); c1->SaveAs(cut+"_subM2fatM1.png"); h12->SetTitle(cut+"_subT2fatM1"); h12->Draw(); h12->Draw("TEXT0same"); c1->SaveAs(cut+"_subT2fatM1.png"); h13->SetTitle(cut+"_subL1fatT1"); h13->Draw(); h13->Draw("TEXT0same"); c1->SaveAs(cut+"_subL1fatT1.png"); h14->SetTitle(cut+"_subM1fatT1"); h14->Draw(); h14->Draw("TEXT0same"); c1->SaveAs(cut+"_subM1fatT1.png"); h15->SetTitle(cut+"_subT1fatT1"); h15->Draw(); h15->Draw("TEXT0same"); c1->SaveAs(cut+"_subT1fatT1.png"); h16->SetTitle(cut+"_subL2fatT1"); h16->Draw(); h16->Draw("TEXT0same"); c1->SaveAs(cut+"_subL2fatT1.png"); h17->SetTitle(cut+"_subM2fatT1"); h17->Draw(); h17->Draw("TEXT0same"); c1->SaveAs(cut+"_subM2fatT1.png"); h18->SetTitle(cut+"_subT2fatT1"); h18->Draw(); h18->Draw("TEXT0same"); c1->SaveAs(cut+"_subT2fatT1.png"); }
void MergeRootfile(std::map<std::pair<std::string, std::string>, TObject*>& outputMap, std::vector<std::pair<std::string, TObject*> >& outputVec, TDirectory *target, TFile *source) { using namespace std; string path(target->GetPath()); path = path.substr(path.find(":") + 1); source->cd(path.c_str()); TDirectory *current_sourcedir = gDirectory; //gain time, do not add the objects in the list in memory Bool_t status = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); // loop over all keys in this directory TIter nextkey( current_sourcedir->GetListOfKeys() ); TKey *key, *oldkey = 0; while(key = (TKey*)nextkey()) { //keep only the highest cycle number for each key if (oldkey && !strcmp(oldkey->GetName(), key->GetName())) continue; oldkey = key; // read object from source file source->cd(path.c_str()); TObject *obj = key->ReadObj(); if(obj->IsA()->InheritsFrom(TH1::Class())) { if(verbosity >= 4) { printf("| Found TH1: %s\n", obj->GetName()); fflush(stdout); } string path(target->GetPath()); pair<string, string> okey(path.substr(path.find(':') + 2), obj->GetName()); //cout << okey.first << "\t" << okey.second << endl; if(outputMap.find(okey) == outputMap.end()) { outputVec.push_back(make_pair(path.substr(path.find(':') + 2), obj)); outputMap[okey] = obj; } else { ((TH1*)outputMap[okey])->Add((TH1*)obj); ((TH1*)obj)->Delete(); } } else if(obj->IsA()->InheritsFrom(TTree::Class())) { string path(target->GetPath()); if(verbosity >= 4) { printf("| Found Tree: %s\n", obj->GetName()); fflush(stdout); } pair<string, string> okey(path.substr(path.find(':') + 2), obj->GetName()); if(outputMap.find(okey) == outputMap.end()) { string fname(okey.first); fname = fname + "_" + obj->GetName() + "tmpfile"; for(size_t pos; (pos = fname.find('/')) != size_t(-1); ) fname[pos] = '_'; tmpFiles.push_back(make_pair(fname, new TFile(fname.c_str(), "RECREATE"))); TTree* tree = ((TTree*)obj)->CloneTree(); ((TTree*)obj)->GetListOfClones()->Remove(tree); ((TTree*)obj)->ResetBranchAddresses(); tree->ResetBranchAddresses(); outputVec.push_back(make_pair(path.substr(path.find(':') + 2), (TObject*)tree)); outputMap[okey] = (TObject*)tree; } else { TTree* tm = (TTree*)outputMap[okey]; TTree* ts = (TTree*)obj; tm->CopyAddresses(ts); for(int i = 0; i < ts->GetEntries(); i++) { ts->GetEntry(i); tm->Fill(); } ts->ResetBranchAddresses(); if (tm->GetTreeIndex()) tm->GetTreeIndex()->Append(ts->GetTreeIndex(), kTRUE); ((TTree*)obj)->Delete(); } } else if(obj->IsA()->InheritsFrom(TDirectory::Class())) { if(verbosity >= 3) { printf("Hadding Directory: %s\n", ((TDirectory*)obj)->GetPath()); fflush(stdout); } string path(((TDirectory*)obj)->GetPath()); pair<string, string> okey(path.substr(path.find(':') + 2), " -------- "); if(outputMap.find(okey) == outputMap.end()) { outputVec.push_back(make_pair(path.substr(path.find(':') + 2), (TDirectory*)0)); outputMap[okey] = 0; } MergeRootfile(outputMap, outputVec, (TDirectory*)obj, source); } else { printf("Unknown object type, name: %s title: %s\n", obj->GetName(), obj->GetTitle()); fflush(stdout); } } // while ( ( TKey *key = (TKey*)nextkey() ) ) }
double TrimEventContent(Int_t iRapBin = 1, Int_t iPTBin = 1, Double_t fracL = 0.5, Double_t nSigma = 2., Int_t nUpsState=0,//[0]... 1S, [1]... 2S, [2]... 3S bool UpsMC=false, bool f_BG_zero=false, bool ProjectLSBdata=false, bool ProjectRSBdata=false, bool CombineSignalPeaks=false, bool Y1Sto2S_SB=false, bool LeftSided=false, bool RightSided=false, bool MassScan=false, bool adjustOverlapBorders=true ){ printf("\n\n\nfracL = %1.3f, nSigma = %1.1f, iState = %d, rap %d, pT %d\n", fracL, nSigma, nUpsState, iRapBin, iPTBin); Char_t name[100], title[100]; Char_t fileNameIn[100]; sprintf(fileNameIn, "tmpFiles/data_Ups_rap%d_pT%d.root", iRapBin, iPTBin); //============================== //read inputs from input file: TFile *fIn = new TFile(fileNameIn); TLorentzVector *lepP; TLorentzVector *lepN; TTree *treeIn = (TTree *) gDirectory->Get("selectedData"); if(gDirectory->Get("selectedData")==NULL){ printf("\n\n\nskip processing this bin.\n\n\n"); return -999.; } TH2D *hBG_cosThetaPhiLR[onia::kNbFrames][2]; for(int iFrame = 0; iFrame < onia::kNbFrames; iFrame++){ sprintf(name, "hBG_cosThetaPhi_%s_L", onia::frameLabel[iFrame]); hBG_cosThetaPhiLR[iFrame][L] = (TH2D *) gDirectory->Get(name); sprintf(name, "hBG_cosThetaPhi_%s_R", onia::frameLabel[iFrame]); hBG_cosThetaPhiLR[iFrame][R] = (TH2D *) gDirectory->Get(name); } //============================== //definition of output variables Char_t fileNameOut[100]; sprintf(fileNameOut, "AllStates_%1.2fSigma_FracLSB%dPercent/data_%dSUps_rap%d_pT%d.root", nSigma, int(fracL*100), nUpsState+1, iRapBin, iPTBin); TFile *fOut = new TFile(fileNameOut, "RECREATE"); gStyle->SetPadRightMargin(0.2); TTree *treeOut = treeIn->CloneTree(0); // treeOut->SetName("data"); TH2D *hBG_cosThetaPhi[onia::kNbFrames]; // TH2D *hBG_cosThetaPhiSignal[onia::kNbFrames]; for(int iFrame = 0; iFrame < onia::kNbFrames; iFrame++){ // //book the histo for the signal // sprintf(name, "total_%s", onia::frameLabel[iFrame]); // sprintf(title, ";cos#theta_{%s};#phi_{%s} [deg]", onia::frameLabel[iFrame], onia::frameLabel[iFrame]); // hBG_cosThetaPhiSignal[iFrame] = new TH2D(name, title, onia::kNbBinsCosT, onia::cosTMin, onia::cosTMax, // onia::kNbBinsPhiPol, onia::phiPolMin, onia::phiPolMax); // hBG_cosThetaPhiSignal[iFrame]->Sumw2(); //copy the L and R sideband histos into one output BG histogram hBG_cosThetaPhiLR[iFrame][L]->Scale(fracL/hBG_cosThetaPhiLR[iFrame][L]->Integral()); hBG_cosThetaPhiLR[iFrame][R]->Scale((1.-fracL)/hBG_cosThetaPhiLR[iFrame][R]->Integral()); sprintf(name, "background_costhphi%s", onia::frameLabel[iFrame]); hBG_cosThetaPhi[iFrame] = (TH2D *) hBG_cosThetaPhiLR[iFrame][L]->Clone(name); hBG_cosThetaPhi[iFrame]->Add(hBG_cosThetaPhiLR[iFrame][R]); } //========================================================== //reading fit parameters to establish signal mass window //as well as the L and R sideband window for the 3D BG histo //========================================================== fIn->cd(); TTree *treeFitPar = (TTree *) gDirectory->Get("massFitParameters"); TF1 *fUps[kNbSpecies], *fBG = 0; fUps[0] = 0, fUps[1] = 0, fUps[2] = 0; treeFitPar->SetBranchAddress("fUps1S", &fUps[0]); treeFitPar->SetBranchAddress("fUps2S", &fUps[1]); treeFitPar->SetBranchAddress("fUps3S", &fUps[2]); treeFitPar->SetBranchAddress("fBG", &fBG); treeFitPar->LoadTree(0); treeFitPar->GetEntry(0); Double_t mass[kNbSpecies], sigma[kNbSpecies]; for(int iState = 0; iState < kNbSpecies; iState++){ mass[iState] = fUps[iState]->GetParameter(1); sigma[iState] = fUps[iState]->GetParameter(2); } printf("1S: mass = %1.3f GeV, sigma = %1.3f GeV\n", mass[UPS1S], sigma[UPS1S]); printf("2S: mass = %1.3f GeV, sigma = %1.3f GeV\n", mass[UPS2S], sigma[UPS2S]); printf("3S: mass = %1.3f GeV, sigma = %1.3f GeV\n", mass[UPS3S], sigma[UPS3S]); Double_t poleMass = mass[nUpsState], massMin, massMax; massMin = poleMass - nSigma*sigma[nUpsState]; massMax = poleMass + nSigma*sigma[nUpsState]; if(LeftSided){ massMin = poleMass - nSigma*sigma[nUpsState]; massMax = poleMass; } if(RightSided){ massMin = poleMass; massMax = poleMass + nSigma*sigma[nUpsState]; } // massMin = poleMass - 3.*sigma[nUpsState]; // massMax = poleMass - 1.*sigma[nUpsState]; // massMin = poleMass + 1.*sigma[nUpsState]; // massMax = poleMass + 3.*sigma[nUpsState]; cout<<"massMin = "<<massMin<<endl; cout<<"massMax = "<<massMax<<endl; if(adjustOverlapBorders){ if( nUpsState==2 && mass[2]-nSigma*sigma[2]<mass[1]+nSigma*sigma[1] ){ cout<<"adjusting lower border of Y(3S) mass window due to overlap"<<endl; massMin=(sigma[2]*mass[1]+sigma[1]*mass[2])/(sigma[1]+sigma[2]); } if( nUpsState==1 && mass[1]-nSigma*sigma[1]<mass[0]+nSigma*sigma[0] ){ cout<<"adjusting lower border of Y(2S) mass window due to overlap"<<endl; massMin=(sigma[1]*mass[0]+sigma[0]*mass[1])/(sigma[1]+sigma[0]); } if( nUpsState==1 && mass[2]-nSigma*sigma[2]<mass[1]+nSigma*sigma[1] ){ cout<<"adjusting upper border of Y(2S) mass window due to overlap"<<endl; massMax=(sigma[2]*mass[1]+sigma[1]*mass[2])/(sigma[1]+sigma[2]); } if( nUpsState==0 && mass[1]-nSigma*sigma[1]<mass[0]+nSigma*sigma[0] ){ cout<<"adjusting upper border of Y(1S) mass window due to overlap"<<endl; massMax=(sigma[1]*mass[0]+sigma[0]*mass[1])/(sigma[1]+sigma[0]); } } if( nUpsState==0){ contamination2Sin1S=fUps[1]->Integral(massMin, massMax)/(fUps[0]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax)); cout<<"Contamination of the 1S sample by 2S events = "<<contamination2Sin1S*100<<" %"<<endl; } if( nUpsState==1){ contamination1Sin2S=fUps[0]->Integral(massMin, massMax)/(fUps[0]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax)); contamination3Sin2S=fUps[2]->Integral(massMin, massMax)/(fUps[2]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax)); cout<<"Contamination of the 2S sample by 1S events = "<<contamination1Sin2S*100<<" %"<<endl; cout<<"Contamination of the 2S sample by 3S events = "<<contamination3Sin2S*100<<" %"<<endl; } if( nUpsState==2){ contamination2Sin3S=fUps[1]->Integral(massMin, massMax)/(fUps[2]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax)); cout<<"Contamination of the 3S sample by 2S events = "<<contamination2Sin3S*100<<" %"<<endl; } if(CombineSignalPeaks) { massMin=9.15; massMax=10.65; } if(Y1Sto2S_SB){ massMin = mass[0] + 3.*sigma[0]; massMax = mass[1] - 4.*sigma[1]; } ////////////////// Background mass scan const int nMassScan=12; int nMassScanCurrent; //double MassScanBorders[nMassScan+1] = {8.6, 8.95, 9.3, 9.45, 9.6, 9.85, 10.0125, 10.175, 10.3425, 10.51, 10.8, 11.1, 11.4}; double MassScanBorders[nMassScan+1] = {8.6, 8.95, 9.3, 9.45, 9.6, 9.85, 10.0125, 10.175, 10.3425, 10.51, 10.8, 11.1, 11.4}; for(int i=1;i<nMassScan+1;i++){ if(nSigma<i+0.5) {nMassScanCurrent=i; break;} } double BuffMinL=onia::massMinL; double BuffMaxL=mass[UPS1S] - onia::nSigmaL*sigma[UPS1S]; double BuffMinR=mass[UPS3S] + onia::nSigmaR*sigma[UPS3S]; double BuffMaxR=onia::massMaxR; double MassScanMin=MassScanBorders[nMassScanCurrent-1]; double MassScanMax=MassScanBorders[nMassScanCurrent]; if(nSigma==1){ MassScanMin=BuffMinL; MassScanMax=BuffMinL+1./3.*(BuffMaxL-BuffMinL); } if(nSigma==2){ MassScanMin=BuffMinL+1./3.*(BuffMaxL-BuffMinL); MassScanMax=BuffMinL+2./3.*(BuffMaxL-BuffMinL); } if(nSigma==3){ MassScanMin=BuffMinL+2./3.*(BuffMaxL-BuffMinL); MassScanMax=BuffMaxL; } if(nSigma==4){ MassScanMin=BuffMinL; MassScanMax=BuffMaxL; } if(nSigma==5){ MassScanMin=BuffMinR; MassScanMax=BuffMinR+1./3.*(BuffMaxR-BuffMinR); } if(nSigma==6){ MassScanMin=BuffMinR+1./3.*(BuffMaxR-BuffMinR); MassScanMax=BuffMinR+2./3.*(BuffMaxR-BuffMinR); } if(nSigma==7){ MassScanMin=BuffMinR+2./3.*(BuffMaxR-BuffMinR); MassScanMax=BuffMaxR; } if(nSigma==8){ MassScanMin=BuffMinR; MassScanMax=BuffMaxR; } if(nSigma>8){ BuffMaxL=mass[UPS1S] - 7*sigma[UPS1S]; BuffMinR=mass[UPS3S] + onia::nSigmaR*sigma[UPS3S]; } if(nSigma==9){ MassScanMin=BuffMinL; MassScanMax=BuffMinL+1./3.*(BuffMaxL-BuffMinL); } if(nSigma==10){ MassScanMin=BuffMinL+1./3.*(BuffMaxL-BuffMinL); MassScanMax=BuffMinL+2./3.*(BuffMaxL-BuffMinL); } if(nSigma==11){ MassScanMin=BuffMinL+2./3.*(BuffMaxL-BuffMinL); MassScanMax=BuffMaxL; } if(nSigma==12){ MassScanMin=BuffMinL; MassScanMax=BuffMaxL; } if(MassScan){ massMin=MassScanMin; massMax=MassScanMax; } ///////////////////////////////////// printf("--> signal mass window: %1.3f < M < %1.3f GeV\n", massMin, massMax); //calculate the fraction of BG under the signal mass window Double_t nBG = fBG->Integral(massMin, massMax); // Double_t nSignal = fUps[nUpsState]->Integral(massMin, massMax); Double_t nSignal = fUps[0]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax)+fUps[2]->Integral(massMin, massMax); Double_t fracBG = nBG / (nBG + nSignal); sprintf(name, ";;fraction of BG in %1.1f sigma window", nSigma); TH1D *hFracBG = new TH1D("background_fraction", name, 1, 0., 1.); if(!UpsMC&&!f_BG_zero) hFracBG->SetBinContent(1, fracBG); if(UpsMC||f_BG_zero) hFracBG->SetBinContent(1, 0.001); /* fBG->ReleaseParameter(1); cout<<"fBG "<<fBG->Integral(massMin, massMax) / (fBG->Integral(massMin, massMax) + fUps[nUpsState]->Integral(massMin, massMax))<<endl; double fBGPar0=fBG->GetParameter(1); double err_fBGPar0=fBG->GetParError(1); cout<<"fBGPar0 "<<fBGPar0<<endl; cout<<"err_fBGPar0 "<<err_fBGPar0<<endl; fBG->FixParameter(1,fBGPar0+100*err_fBGPar0); cout<<"fBGPar0 "<<fBG->GetParameter(1)<<endl; cout<<"fBG "<<fBG->Integral(massMin, massMax) / (fBG->Integral(massMin, massMax) + fUps[nUpsState]->Integral(massMin, massMax))<<endl; fBG->SetParameter(1,fBGPar0); cout<<"fBG "<<fBG->Integral(massMin, massMax) / (fBG->Integral(massMin, massMax) + fUps[nUpsState]->Integral(massMin, massMax))<<endl; */ if(Y1Sto2S_SB){ cout<<"Y1Sto2S_SB fBG = "<<fBG->Integral(massMin, massMax) / (fBG->Integral(massMin, massMax) + fUps[0]->Integral(massMin, massMax)+fUps[1]->Integral(massMin, massMax))<<endl; } backgroundFrac=fracBG; //calculate the L and R mass windows: Double_t massMinBG[2], massMaxBG[2]; massMinBG[L] = onia::massMinL; massMaxBG[L] = mass[UPS1S] - onia::nSigmaL*sigma[UPS1S]; massMinBG[R] = mass[UPS3S] + onia::nSigmaR*sigma[UPS3S]; massMaxBG[R] = onia::massMaxR; printf("--> L mass window: %1.3f < M < %1.3f GeV\n", massMinBG[L], massMaxBG[L]); printf("--> R mass window: %1.3f < M < %1.3f GeV\n", massMinBG[R], massMaxBG[R]); //cout<<"here?"<<endl; bool PseudoBin=false; if(CombineSignalPeaks) { massMin=9.15; massMax=10.65; } if(!UpsMC){ if(massMaxBG[L] > massMin){ printf("the right sideband window is LARGER than the left signal window!!!!\n\n\n\n"); massMaxBG[L]=9.; massMinBG[L]=8.6; massMin=9.; PseudoBin=true; // exit(0); } if(massMinBG[R] < massMax){ printf("the left sideband window is SMALLER than the right signal window!!!!\n\n\n\n"); massMaxBG[R]=11.4; massMinBG[R]=11.; massMax=10.; PseudoBin=true; // exit(0); } } if(ProjectLSBdata){ massMin=massMinBG[L]; massMax=massMaxBG[L]; } if(ProjectRSBdata){ massMin=massMinBG[R]; massMax=massMaxBG[R]; } if(CombineSignalPeaks) { massMin=9.15; massMax=10.65; } double meanMass=0; double MassDistCurrent=0.001; TH1D *hMassScanInfo = new TH1D("hMassScanInfo", "hMassScanInfo", 2, 0., 1.); if(MassScan){ massMin=MassScanMin; massMax=MassScanMax; double IntCurrent = fBG->Integral(massMin, massMax); for(int i=1;i<1000000;i++){ if(fBG->Integral(massMin, massMin+i*MassDistCurrent)>IntCurrent/2.) {meanMass=massMin+i*MassDistCurrent; break;} } hMassScanInfo->SetBinContent(1,meanMass); hMassScanInfo->SetBinContent(2,1-fracBG); } if(Y1Sto2S_SB){ massMin = mass[0] + 3.*sigma[0]; massMax = mass[1] - 4.*sigma[1]; double IntCurrent = fBG->Integral(massMin, massMax); for(int i=1;i<1000000;i++){ if(fBG->Integral(massMin, massMin+i*MassDistCurrent)>IntCurrent/2.) {meanMass=massMin+i*MassDistCurrent; break;} } hMassScanInfo->SetBinContent(1,meanMass); hMassScanInfo->SetBinContent(2,1-fracBG); } if(UpsMC&&iPTBin>5&&fracL<0.35){ cout<<"using exact mass window definition of data"<<endl; Double_t massMinUps1S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.38372, 9.38435, 9.38425, 9.38487, 9.38326}, {0,0,0,0,0, 9.35644, 9.3574, 9.35555, 9.35522, 9.34896}}; Double_t massMaxUps1S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.518, 9.51711, 9.51826, 9.51701, 9.51941}, {0,0,0,0,0, 9.53728, 9.53853, 9.5394, 9.54169, 9.54538}}; Double_t massMinUps2S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.94218, 9.94285, 9.94275, 9.9434, 9.94169}, {0,0,0,0,0, 9.91328, 9.91429, 9.91234, 9.91198, 9.90535}}; Double_t massMaxUps2S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.0844, 10.0835, 10.0847, 10.0834, 10.086}, {0,0,0,0,0, 10.1049, 10.1062, 10.1071, 10.1096, 10.1135}}; Double_t massMinUps3S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.2715, 10.2722, 10.2721, 10.2728, 10.271}, {0,0,0,0,0, 10.2416, 10.2427, 10.2407, 10.2403, 10.2335}}; Double_t massMaxUps3S_1sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.4185, 10.4175, 10.4188, 10.4174, 10.42}, {0,0,0,0,0, 10.4396, 10.441, 10.4419, 10.4444, 10.4485}}; //============================= Double_t massMinUps1S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.24945, 9.2516, 9.25025, 9.25273, 9.24711}, {0,0,0,0,0, 9.1756, 9.17626, 9.17171, 9.16874, 9.15253}}; Double_t massMaxUps1S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.65227, 9.64987, 9.65227, 9.64915, 9.65557}, {0,0,0,0,0, 9.71811, 9.71966, 9.72048, 9.72149, 9.72017}}; Double_t massMinUps2S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 9.79992, 9.80219, 9.80076, 9.80339, 9.79744}, {0,0,0,0,0, 9.72168, 9.72238, 9.72048, 9.72149, 9.72017}}; Double_t massMaxUps2S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.1765, 10.1763, 10.1769, 10.1765, 10.177}, {0,0,0,0,0, 10.1721, 10.1733, 10.1728, 10.1739, 10.1725}}; Double_t massMinUps3S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.1765, 10.1763, 10.1769, 10.1765, 10.177}, {0,0,0,0,0, 10.1721, 10.1733, 10.1728, 10.1739, 10.1725}}; Double_t massMaxUps3S_3sigma[3][10] = { {0,0,0,0,0, 0,0,0,0,0}, {0,0,0,0,0, 10.5655, 10.5628, 10.5655, 10.562, 10.5691}, {0,0,0,0,0, 10.6375, 10.6392, 10.6432, 10.6485, 10.6635}}; if(nSigma==1){ if(nUpsState==0){ massMin=massMinUps1S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps1S_1sigma[iRapBin][iPTBin-1]; } if(nUpsState==1){ massMin=massMinUps2S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps2S_1sigma[iRapBin][iPTBin-1]; } if(nUpsState==2){ massMin=massMinUps3S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps3S_1sigma[iRapBin][iPTBin-1]; } } if(nSigma==3){ if(nUpsState==0){ massMin=massMinUps1S_3sigma[iRapBin][iPTBin-1]; massMax=massMaxUps1S_3sigma[iRapBin][iPTBin-1]; } if(nUpsState==1){ massMin=massMinUps2S_3sigma[iRapBin][iPTBin-1]; massMax=massMaxUps2S_3sigma[iRapBin][iPTBin-1]; } if(nUpsState==2){ massMin=massMinUps3S_3sigma[iRapBin][iPTBin-1]; massMax=massMaxUps3S_3sigma[iRapBin][iPTBin-1]; } } if(nSigma==0.5){ if(nUpsState==0){ massMin=massMinUps1S_1sigma[iRapBin][iPTBin-1]+(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/4.; massMax=massMaxUps1S_1sigma[iRapBin][iPTBin-1]-(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/4.; } if(nUpsState==1){ massMin=massMinUps2S_1sigma[iRapBin][iPTBin-1]+(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/4.; massMax=massMaxUps2S_1sigma[iRapBin][iPTBin-1]-(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/4.; } if(nUpsState==2){ massMin=massMinUps3S_1sigma[iRapBin][iPTBin-1]+(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/4.; massMax=massMaxUps3S_1sigma[iRapBin][iPTBin-1]-(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/4.; } } if(nSigma==0.1){ if(nUpsState==0){ massMin=massMinUps1S_1sigma[iRapBin][iPTBin-1]+(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/20.; massMax=massMaxUps1S_1sigma[iRapBin][iPTBin-1]-(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/20.; } if(nUpsState==1){ massMin=massMinUps2S_1sigma[iRapBin][iPTBin-1]+(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/20.; massMax=massMaxUps2S_1sigma[iRapBin][iPTBin-1]-(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/20.; } if(nUpsState==2){ massMin=massMinUps3S_1sigma[iRapBin][iPTBin-1]+(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/20.; massMax=massMaxUps3S_1sigma[iRapBin][iPTBin-1]-(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/20.; } } if(nSigma==9){ if(nUpsState==0){ massMin=massMinUps1S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps1S_1sigma[iRapBin][iPTBin-1]-(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/2.; } if(nUpsState==1){ massMin=massMinUps2S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps2S_1sigma[iRapBin][iPTBin-1]-(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/2.; } if(nUpsState==2){ massMin=massMinUps3S_1sigma[iRapBin][iPTBin-1]; massMax=massMaxUps3S_1sigma[iRapBin][iPTBin-1]-(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/2.; } } if(nSigma==10){ if(nUpsState==0){ massMax=massMaxUps1S_1sigma[iRapBin][iPTBin-1]; massMin=massMaxUps1S_1sigma[iRapBin][iPTBin-1]-(massMaxUps1S_1sigma[iRapBin][iPTBin-1]-massMinUps1S_1sigma[iRapBin][iPTBin-1])/2.; } if(nUpsState==1){ massMax=massMaxUps2S_1sigma[iRapBin][iPTBin-1]; massMin=massMaxUps2S_1sigma[iRapBin][iPTBin-1]-(massMaxUps2S_1sigma[iRapBin][iPTBin-1]-massMinUps2S_1sigma[iRapBin][iPTBin-1])/2.; } if(nUpsState==2){ massMax=massMaxUps3S_1sigma[iRapBin][iPTBin-1]; massMin=massMaxUps3S_1sigma[iRapBin][iPTBin-1]-(massMaxUps3S_1sigma[iRapBin][iPTBin-1]-massMinUps3S_1sigma[iRapBin][iPTBin-1])/2.; } } } ActualMassMin=massMin; ActualMassMax=massMax; //calculate central fracL double fracLCentral; if(!f_BG_zero){ double mean_LSB; double mean_RSB; double mean_nS; double MassDist=0.001; double IntLSB = fBG->Integral(massMinBG[L], massMaxBG[L]); for(int i=1;i<1000000;i++){ if(fBG->Integral(massMinBG[L], massMinBG[L]+i*MassDist)>IntLSB/2.) {mean_LSB=massMinBG[L]+i*MassDist; break;} } double IntRSB = fBG->Integral(massMinBG[R], massMaxBG[R]); for(int i=1;i<1000000;i++){ if(fBG->Integral(massMinBG[R], massMinBG[R]+i*MassDist)>IntRSB/2.) {mean_RSB=massMinBG[R]+i*MassDist; break;} } double IntSig = fBG->Integral(massMin, massMax); for(int i=1;i<1000000;i++){ if(fBG->Integral(massMin, massMin+i*MassDist)>IntSig/2.) {mean_nS=massMin+i*MassDist; break;} } fracLCentral=1-(mean_nS-mean_LSB)/(mean_RSB-mean_LSB); cout<<"Median LSB: "<<mean_LSB<<endl; cout<<"Median RSB: "<<mean_RSB<<endl; cout<<"Median signal region: "<<mean_nS<<endl; cout<<"Central FracL: "<<fracLCentral<<endl; } //build the 3D (pT, |y|, M) histos for the L and R mass sideband TH3D *hBG_pTRapMass[2]; hBG_pTRapMass[L] = new TH3D("hBG_pTRapMass_L", ";p_{T} [GeV/c]; |y|; M [GeV]", 7, onia::pTRange[iRapBin][iPTBin-1], onia::pTRange[iRapBin][iPTBin], 2, onia::rapForPTRange[iRapBin-1], onia::rapForPTRange[iRapBin], 7, massMin, massMax);//*signal* mass window! hBG_pTRapMass[L]->Sumw2(); // hBG_pTRapMass[R] = new TH3D("hBG_pTRapMass_R", ";p_{T} [GeV/c]; |y|; M [GeV]", 7, onia::pTRange[iRapBin][iPTBin-1], onia::pTRange[iRapBin][iPTBin], 2, onia::rapForPTRange[iRapBin-1], onia::rapForPTRange[iRapBin], 7, massMin, massMax);//*signal* mass window! hBG_pTRapMass[R]->Sumw2(); lepP = 0; lepN = 0; treeIn->SetBranchAddress("lepP", &lepP); treeIn->SetBranchAddress("lepN", &lepN); TLorentzVector *onia = new TLorentzVector(); Double_t onia_mass; for(int iEn = 0; iEn < treeIn->GetEntries(); iEn++){ Long64_t iEntry = treeIn->LoadTree(iEn); treeIn->GetEntry(iEntry); if(iEn % 10000 == 0) cout << "entry " << iEntry << " out of " << treeIn->GetEntries() << endl; *onia = *(lepP) + *(lepN); onia_mass = onia->M(); if(UpsMC||f_BG_zero) hBG_pTRapMass[L]->Fill(onia->Pt(), TMath::Abs(onia->Rapidity()), gRandom->Uniform(massMin, massMax)); if(UpsMC||f_BG_zero) hBG_pTRapMass[R]->Fill(onia->Pt(), TMath::Abs(onia->Rapidity()), gRandom->Uniform(massMin, massMax)); if(!UpsMC&&!f_BG_zero){ if(onia_mass > massMinBG[L] && onia_mass < massMaxBG[L]) hBG_pTRapMass[L]->Fill(onia->Pt(), TMath::Abs(onia->Rapidity()), fBG->GetRandom(massMin, massMax)); else if(onia_mass > massMinBG[R] && onia_mass < massMaxBG[R]) hBG_pTRapMass[R]->Fill(onia->Pt(), TMath::Abs(onia->Rapidity()), fBG->GetRandom(massMin, massMax)); } if(onia_mass > massMin && onia_mass < massMax){ treeOut->Fill(); //stores TLorenzVectors of the two muons // //store now the cosTheta and phi distributions of the signal window: // calcPol(*lepP, *lepN); // for(int iFrame = 0; iFrame < onia::kNbFrames; iFrame++) // hCosThetaPhiSignal[iFrame]->Fill(thisCosTh[iFrame], thisPhi[iFrame]); } } /* Char_t name2[100]; sprintf(name2, "Reco_Onia_mass_rap%d_pT%d", iRapBin, iPTBin); TH1F* hMass = (TH1F*) gDirectory->Get(name2); hMass->Rebin(2); double binWidth = hMass->GetBinWidth(1); //valid only for an equal bin histogram! printf("binwidth = %1.2e\n", binWidth); */ double nY[3]; double nBG_; double binWidth = 0.02; //You have to manually change that parameter from the mass fit!!! nY[2] = fUps[2]->Integral(massMin, massMax)/binWidth; nY[1] = fUps[1]->Integral(massMin, massMax)/binWidth; nY[0] = fUps[0]->Integral(massMin, massMax)/binWidth; nBG_ = fBG->Integral(massMin, massMax)/binWidth; double nAll=nY[0]+nY[1]+nY[2]+nBG_; printf("1 sigma region num background = %1.3f\n",nBG_); printf("1 sigma region num 1S = %1.3f\n",nY[0]); printf("1 sigma region num 2S = %1.3f\n",nY[1]); printf("1 sigma region num 3S = %1.3f\n",nY[2]); printf("1 sigma region num all = %1.3f\n",nAll); printf("1 sigma region calcNumAll - numEventsInDataSet = %1.3f\n",nAll-treeOut->GetEntries()); double tempBfrac=nBG_/(treeOut->GetEntries()); printf("1 sigma region background fraction = %1.3f\n",tempBfrac); printf("Used background fraction = %1.3f\n",backgroundFrac); SignalEvents=nY[nUpsState]; double BackgroundEvents=SignalEvents*(1-backgroundFrac)/backgroundFrac; err_backgroundFrac=TMath::Power(SignalEvents*BackgroundEvents,0.5)/TMath::Power(SignalEvents+BackgroundEvents,1.5); //now, add the L and R 3D (pT, |y|, M) histos TH3D *hBG_pTRapMassSum; hBG_pTRapMass[L]->Scale(fracL/hBG_pTRapMass[L]->Integral()); hBG_pTRapMass[R]->Scale((1.-fracL)/hBG_pTRapMass[R]->Integral()); sprintf(name, "background_pTrapMass"); hBG_pTRapMassSum = (TH3D*) hBG_pTRapMass[L]->Clone(name); hBG_pTRapMassSum->Add(hBG_pTRapMass[R]); //write the output fOut->cd(); treeOut->Write(); for(int iFrame = 0; iFrame < onia::kNbFrames; iFrame++){ hBG_cosThetaPhi[iFrame]->Write(); hBG_cosThetaPhiLR[iFrame][L]->Write(); hBG_cosThetaPhiLR[iFrame][R]->Write(); // hCosThetaPhiSignal[iFrame]->Write(); } hBG_pTRapMassSum->Write(); hFracBG->Write(); if(MassScan){ hMassScanInfo->Write(); } fOut->Close(); fIn->Close(); return fracLCentral; }
void MakeTree_2012(){ //gROOT->LoadMacro("setTDRStyle_modified.C"); //setTDRStyle(); TFile *f = TFile::Open("Upsilon_Histos_191212_FULL.root"); //TFile *f = TFile::Open("/castor/cern.ch/user/t/tdahms/Jpsi_Histos_ppReReco.root"); TTree *t =(TTree*)f->Get("myTree"); Long64_t nentries = t->GetEntries(); const int NMAX=100; UInt_t eventNb; UInt_t runNb; Int_t Centrality; Int_t HLTriggers; Int_t Reco_QQ_size; Int_t Reco_QQ_trig[NMAX]; Int_t Reco_QQ_type[NMAX]; Int_t Reco_QQ_sign[NMAX]; Float_t Reco_QQ_VtxProb[NMAX]; TClonesArray *Reco_QQ_4mom; TClonesArray *Reco_QQ_mupl_4mom; TClonesArray *Reco_QQ_mumi_4mom; Int_t Reco_mu_size; Int_t Reco_mu_type[NMAX]; Int_t Reco_mu_charge[NMAX]; TClonesArray *Reco_mu_4mom; int nPlusMu; int nMinusMu; float muPt[NMAX]; float muEta[NMAX]; float muPhi[NMAX]; //Int_t nReco_QQ; Float_t invariantMass; Int_t QQtrig; Int_t QQsign; float weight; float weight2; Float_t upsPt; Float_t upsEta; Float_t upsRapidity; Float_t vProb; Float_t muPlusPt; Float_t muMinusPt; Float_t muPlusEta; Float_t muMinusEta; Float_t muPlusPhi; Float_t muMinusPhi; Float_t RmuPlusPhi = 0; Float_t RmuMinusPhi = 0; //float theta_HX; //float phi_HX; //float theta_CS; //float phi_CS; float QQmuPlusDxy[100]; float QQmuPlusDz[100]; int QQmuPlusNhits[100]; int QQmuPlusNPixelhits[100]; int QQmuPlusNPxlLayers[100]; float QQmuPlusInnerChi[100]; float QQmuPlusGlobalChi[100]; int QQmuPlusNMuonhits[100]; float QQmuPlusDB[100]; float QQmuMinusDxy[100]; float QQmuMinusDz[100]; int QQmuMinusNhits[100]; int QQmuMinusNPixelhits[100]; int QQmuMinusNPxlLayers[100]; float QQmuMinusInnerChi[100]; float QQmuMinusGlobalChi[100]; int QQmuMinusNMuonhits[100]; float QQmuMinusDB[100]; float muPlusDxy; float muPlusDz; int muPlusNhits; int muPlusNPixelhits; int muPlusNPxlLayers; float muPlusInnerChi; float muPlusGlobalChi; int muPlusNMuonhits; float muPlusDB; float muMinusDxy; float muMinusDz; int muMinusNhits; int muMinusNPixelhits; int muMinusNPxlLayers; float muMinusInnerChi; float muMinusGlobalChi; int muMinusNMuonhits; float muMinusDB; t->SetBranchAddress("Centrality", &Centrality ); t->SetBranchAddress("eventNb", &eventNb ); t->SetBranchAddress("runNb", &runNb ); t->SetBranchAddress("HLTriggers", &HLTriggers ); t->SetBranchAddress("Reco_QQ_size", &Reco_QQ_size ); t->SetBranchAddress("Reco_QQ_trig", &Reco_QQ_trig ); t->SetBranchAddress("Reco_QQ_type", Reco_QQ_type ); t->SetBranchAddress("Reco_QQ_sign", Reco_QQ_sign ); t->SetBranchAddress("Reco_QQ_VtxProb", Reco_QQ_VtxProb); t->SetBranchAddress("Reco_QQ_4mom", &Reco_QQ_4mom ); t->SetBranchAddress("Reco_QQ_mupl_4mom", &Reco_QQ_mupl_4mom); t->SetBranchAddress("Reco_QQ_mumi_4mom", &Reco_QQ_mumi_4mom); /* t->SetBranchAddress("muPlusDxy",QQmuPlusDxy); t->SetBranchAddress("muPlusDz",QQmuPlusDz); t->SetBranchAddress("muPlusNhits",QQmuPlusNhits); t->SetBranchAddress("muPlusNPixelhits",QQmuPlusNPixelhits); t->SetBranchAddress("muPlusNPxlLayers",QQmuPlusNPxlLayers); t->SetBranchAddress("muPlusInnerChi",QQmuPlusInnerChi); t->SetBranchAddress("muPlusGlobalChi",QQmuPlusGlobalChi); t->SetBranchAddress("muPlusNMuonhits",QQmuPlusNMuonhits); t->SetBranchAddress("muPlusDB",QQmuPlusDB); t->SetBranchAddress("muMinusDxy",QQmuMinusDxy); t->SetBranchAddress("muMinusDz",QQmuMinusDz); t->SetBranchAddress("muMinusNhits",QQmuMinusNhits); t->SetBranchAddress("muMinusNPixelhits",QQmuMinusNPixelhits); t->SetBranchAddress("muMinusNPxlLayers",QQmuMinusNPxlLayers); t->SetBranchAddress("muMinusInnerChi",QQmuMinusInnerChi); t->SetBranchAddress("muMinusGlobalChi",QQmuMinusGlobalChi); t->SetBranchAddress("muMinusNMuonhits",QQmuMinusNMuonhits); t->SetBranchAddress("muMinusDB",QQmuMinusDB); */ t->SetBranchAddress("Reco_mu_size", &Reco_mu_size ); t->SetBranchAddress("Reco_mu_type", Reco_mu_type ); t->SetBranchAddress("Reco_mu_charge",Reco_mu_charge ); t->SetBranchAddress("Reco_mu_4mom", &Reco_mu_4mom); TH1F *h_QQ_mass = new TH1F("h_QQ_mass","",70,7,14); TH1F *h_QQ_mass_1 = new TH1F("h_QQ_mass_1","",70,7,14); TH1F *h_QQ_mass_2 = new TH1F("h_QQ_mass_2","",70,7,14); TFile *f1 = new TFile("dimuonTree_fullFiltered.root","RECREATE"); TTree *MuTree = new TTree("MuTree","MuTree"); TTree *UpsilonTree = new TTree("UpsilonTree","UpsilonTree"); TTree *UpsilonTree_allsign = new TTree("UpsilonTree_allsign","UpsilonTree_allsign"); TTree *UpsilonTree_trkRot = new TTree("UpsilonTree_trkRot","UpsilonTree_trkRot"); MuTree->Branch("Reco_mu_size", &Reco_mu_size, "Reco_mu_size/I"); MuTree->Branch("nPlusMu", &nPlusMu, "nPlusMu/I"); MuTree->Branch("nMinusMu", &nMinusMu, "nMinusMu/I"); MuTree->Branch("muPt", &muPt, "muPt[Reco_mu_size]/F"); MuTree->Branch("muEta", &muEta, "muEta[Reco_mu_size]/F"); MuTree->Branch("muPhi", &muPhi, "muPhi[Reco_mu_size]/F"); MuTree->Branch("Reco_mu_type", Reco_mu_type, "Reco_mu_type[Reco_mu_size]/I"); MuTree->Branch("Reco_mu_charge", Reco_mu_charge, "Reco_mu_charge[Reco_mu_size]/I" ); MuTree->Branch("eventNb", &eventNb, "eventNb/I"); MuTree->Branch("runNb", &runNb, "runNb/I"); //UpsilonTree->Branch("nReco_QQ", &nReco_QQ, "nReco_QQ/I"); UpsilonTree->Branch("Centrality", &Centrality, "Centrality/I"); UpsilonTree->Branch("HLTriggers", &HLTriggers, "HLTriggers/I"); UpsilonTree->Branch("QQtrig", &QQtrig, "QQtrig/I"); UpsilonTree->Branch("QQsign", &QQsign, "QQsign/I"); UpsilonTree->Branch("vProb", &vProb, "vProb/F"); UpsilonTree->Branch("eventNb", &eventNb, "eventNb/I"); UpsilonTree->Branch("runNb", &runNb, "runNb/I"); UpsilonTree->Branch("invariantMass", &invariantMass, "invariantMass/F"); UpsilonTree->Branch("upsPt", &upsPt, "upsPt/F"); UpsilonTree->Branch("upsEta", &upsEta, "upsEta/F"); UpsilonTree->Branch("upsRapidity", &upsRapidity, "upsRapidity/F"); UpsilonTree->Branch("muPlusPt", &muPlusPt, "muPlusPt/F"); UpsilonTree->Branch("muMinusPt", &muMinusPt, "muMinusPt/F"); UpsilonTree->Branch("muPlusEta", &muPlusEta, "muPlusEta/F"); UpsilonTree->Branch("muMinusEta", &muMinusEta, "muMinusEta/F"); UpsilonTree->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F"); UpsilonTree->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F"); // UpsilonTree->Branch("theta_HX", &theta_HX, "theta_HX/F"); // UpsilonTree->Branch("phi_HX", &phi_HX, "phi_HX/F"); // UpsilonTree->Branch("theta_CS", &theta_CS, "theta_CS/F"); // UpsilonTree->Branch("phi_CS", &phi_CS, "phi_CS/F"); /* UpsilonTree->Branch("muPlusDxy", &muPlusDxy,"muPlusDxy/F"); UpsilonTree->Branch("muPlusDz", &muPlusDz,"muPlusDz/F"); UpsilonTree->Branch("muPlusNhits", &muPlusNhits,"muPlusNhits/I"); UpsilonTree->Branch("muPlusNPixelhits", &muPlusNPixelhits,"muPlusNPixelhits/I"); UpsilonTree->Branch("muPlusNPxlLayers", &muPlusNPxlLayers,"muPlusNPxlLayers/I"); UpsilonTree->Branch("muPlusInnerChi", &muPlusInnerChi,"muPlusInnerChi/F"); UpsilonTree->Branch("muPlusGlobalChi", &muPlusGlobalChi,"muPlusGlobalChi/F"); UpsilonTree->Branch("muPlusNMuonhits", &muPlusNMuonhits,"muPlusNMuonhits/I"); UpsilonTree->Branch("muPlusDB", &muPlusDB,"muPlusDB/F"); UpsilonTree->Branch("muMinusDxy", &muMinusDxy,"muMinusDxy/F"); UpsilonTree->Branch("muMinusDz", &muMinusDz,"muMinusDz/F"); UpsilonTree->Branch("muMinusNhits", &muMinusNhits,"muMinusNhits/I"); UpsilonTree->Branch("muMinusNPixelhits", &muMinusNPixelhits,"muMinusNPixelhits/I"); UpsilonTree->Branch("muMinusNPxlLayers", &muMinusNPxlLayers,"muMinusNPxlLayers/I"); UpsilonTree->Branch("muMinusInnerChi", &muMinusInnerChi,"muMinusInnerChi/F"); UpsilonTree->Branch("muMinusGlobalChi", &muMinusGlobalChi,"muMinusGlobalChi/F"); UpsilonTree->Branch("muMinusNMuonhits", &muMinusNMuonhits,"muMinusNMuonhits/I"); UpsilonTree->Branch("muMinusDB", &muMinusDB,"muMinusDB/F"); */ UpsilonTree_allsign->Branch("Centrality", &Centrality, "Centrality/I"); UpsilonTree_allsign->Branch("HLTriggers", &HLTriggers, "HLTriggers/I"); UpsilonTree_allsign->Branch("QQtrig", &QQtrig, "QQtrig/I"); UpsilonTree_allsign->Branch("QQsign", &QQsign, "QQsign/I"); UpsilonTree_allsign->Branch("weight", &weight, "weight/F"); UpsilonTree_allsign->Branch("weight2", &weight2, "weight2/F"); UpsilonTree_allsign->Branch("vProb", &vProb, "vProb/F"); UpsilonTree_allsign->Branch("eventNb", &eventNb, "eventNb/I"); UpsilonTree_allsign->Branch("runNb", &runNb, "runNb/I"); UpsilonTree_allsign->Branch("invariantMass", &invariantMass, "invariantMass/F"); UpsilonTree_allsign->Branch("upsPt", &upsPt, "upsPt/F"); UpsilonTree_allsign->Branch("upsEta", &upsEta, "upsEta/F"); UpsilonTree_allsign->Branch("upsRapidity", &upsRapidity, "upsRapidity/F"); UpsilonTree_allsign->Branch("muPlusPt", &muPlusPt, "muPlusPt/F"); UpsilonTree_allsign->Branch("muMinusPt", &muMinusPt, "muMinusPt/F"); UpsilonTree_allsign->Branch("muPlusEta", &muPlusEta, "muPlusEta/F"); UpsilonTree_allsign->Branch("muMinusEta", &muMinusEta, "muMinusEta/F"); UpsilonTree_allsign->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F"); UpsilonTree_allsign->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F"); // UpsilonTree_allsign->Branch("theta_HX", &theta_HX, "theta_HX/F"); // UpsilonTree_allsign->Branch("phi_HX", &phi_HX, "phi_HX/F"); // UpsilonTree_allsign->Branch("theta_CS", &theta_CS, "theta_CS/F"); // UpsilonTree_allsign->Branch("phi_CS", &phi_CS, "phi_CS/F"); UpsilonTree_trkRot->Branch("Centrality", &Centrality, "Centrality/I"); UpsilonTree_trkRot->Branch("HLTriggers", &HLTriggers, "HLTriggers/I"); UpsilonTree_trkRot->Branch("QQtrig", &QQtrig, "QQtrig/I"); UpsilonTree_trkRot->Branch("QQsign", &QQsign, "QQsign/I"); UpsilonTree_trkRot->Branch("weight", &weight, "weight/F"); UpsilonTree_trkRot->Branch("weight2", &weight2, "weight2/F"); UpsilonTree_trkRot->Branch("vProb", &vProb, "vProb/F"); UpsilonTree_trkRot->Branch("eventNb", &eventNb, "eventNb/I"); UpsilonTree_trkRot->Branch("runNb", &runNb, "runNb/I"); UpsilonTree_trkRot->Branch("invariantMass", &invariantMass, "invariantMass/F"); UpsilonTree_trkRot->Branch("upsPt", &upsPt, "upsPt/F"); UpsilonTree_trkRot->Branch("upsEta", &upsEta, "upsEta/F"); UpsilonTree_trkRot->Branch("upsRapidity", &upsRapidity, "upsRapidity/F"); UpsilonTree_trkRot->Branch("muPlusPt", &muPlusPt, "muPlusPt/F"); UpsilonTree_trkRot->Branch("muMinusPt", &muMinusPt, "muMinusPt/F"); UpsilonTree_trkRot->Branch("muPlusEta", &muPlusEta, "muPlusEta/F"); UpsilonTree_trkRot->Branch("muMinusEta", &muMinusEta, "muMinusEta/F"); UpsilonTree_trkRot->Branch("muPlusPhi", &muPlusPhi, "muPlusPhi/F"); UpsilonTree_trkRot->Branch("muMinusPhi", &muMinusPhi, "muMinusPhi/F"); for (int i=0; i<nentries; i++) { t->GetEntry(i); //nReco_QQ=0; if (i%1000==0) cout<<i<<endl; nPlusMu=0; nMinusMu=0; for(int iMu = 0; iMu < Reco_mu_size; iMu++){ if (Reco_mu_charge[iMu] == 1) nPlusMu++; else nMinusMu++; TLorentzVector *Reco_mu = (TLorentzVector *) Reco_mu_4mom->At(iMu); muPt[iMu]=Reco_mu->Pt(); muEta[iMu]=Reco_mu->Eta(); muPhi[iMu]=Reco_mu->Phi(); } MuTree->Fill(); for(int iQQ = 0; iQQ < Reco_QQ_size; iQQ++){ //eventNb=eventNb[iQQ]; //runNb=runNb[iQQ]; vProb = Reco_QQ_VtxProb[iQQ]; QQtrig = Reco_QQ_trig[iQQ]; QQsign = Reco_QQ_sign[iQQ]; if (Reco_QQ_sign[iQQ] == 0) { weight = 1; weight2 = 1; } else { weight = -1; float likesign_comb = (float)nPlusMu*(nPlusMu-1.0)/2.0+(float)nMinusMu*(nMinusMu-1.0)/2.0; float unlikesign_bkgd_comb = (float)nPlusMu*nMinusMu - (nPlusMu>nMinusMu?nMinusMu:nPlusMu); weight2 = -1.0 * unlikesign_bkgd_comb/likesign_comb; } TLorentzVector *Reco_QQ = (TLorentzVector *) Reco_QQ_4mom->At(iQQ); TLorentzVector *Reco_QQ_mupl = (TLorentzVector *) Reco_QQ_mupl_4mom->At(iQQ); TLorentzVector *Reco_QQ_mumi = (TLorentzVector *) Reco_QQ_mumi_4mom->At(iQQ); invariantMass=Reco_QQ->M(); upsPt=Reco_QQ->Pt(); upsEta=Reco_QQ->Eta(); upsRapidity=Reco_QQ->Rapidity(); muMinusPt=Reco_QQ_mumi->Pt(); muMinusEta=Reco_QQ_mumi->Eta(); muMinusPhi=Reco_QQ_mumi->Phi(); muPlusPt=Reco_QQ_mupl->Pt(); muPlusEta=Reco_QQ_mupl->Eta(); muPlusPhi=Reco_QQ_mupl->Phi(); // theta_HX = GetAngles_HX(*Reco_QQ_mupl,*Reco_QQ_mumi).first; // phi_HX = GetAngles_HX(*Reco_QQ_mupl,*Reco_QQ_mumi).second; // theta_CS = GetAngles_CS(*Reco_QQ_mupl,*Reco_QQ_mumi).first; // phi_CS = GetAngles_CS(*Reco_QQ_mupl,*Reco_QQ_mumi).second; muPlusDxy=QQmuPlusDxy[iQQ]; muPlusDz=QQmuPlusDz[iQQ]; muPlusNhits=QQmuPlusNhits[iQQ]; muPlusNPixelhits=QQmuPlusNPixelhits[iQQ]; muPlusNPxlLayers=QQmuPlusNPxlLayers[iQQ]; muPlusInnerChi=QQmuPlusInnerChi[iQQ]; muPlusGlobalChi=QQmuPlusGlobalChi[iQQ]; muPlusNMuonhits=QQmuPlusNMuonhits[iQQ]; muPlusDB=QQmuPlusDB[iQQ]; muMinusDxy=QQmuMinusDxy[iQQ]; muMinusDz=QQmuMinusDz[iQQ]; muMinusNhits=QQmuMinusNhits[iQQ]; muMinusNPixelhits=QQmuMinusNPixelhits[iQQ]; muMinusNPxlLayers=QQmuMinusNPxlLayers[iQQ]; muMinusInnerChi=QQmuMinusInnerChi[iQQ]; muMinusGlobalChi=QQmuMinusGlobalChi[iQQ]; muMinusNMuonhits=QQmuMinusNMuonhits[iQQ]; muMinusDB=QQmuMinusDB[iQQ]; /* if (fabs(muPlusDxy)<3 && fabs(muPlusDz)<15 && muPlusNhits>10 && muPlusNPxlLayers>0 && muPlusNMuonhits>6 && muPlusInnerChi<4 && muPlusGlobalChi<6 && fabs(muMinusDxy)<3 && fabs(muMinusDz)<15 && muMinusNhits>10 && muMinusNPxlLayers>0 && muMinusNMuonhits>6 && muMinusInnerChi<4 && muMinusGlobalChi<6 && vProb>0.01) if (fabs(muPlusDxy)<3 && fabs(muPlusDz)<15 && muPlusNhits>10 && muPlusNPxlLayers>0 && muPlusNMuonhits>12 && muPlusInnerChi<2.1 && muPlusGlobalChi<2.7 && fabs(muMinusDxy)<3 && fabs(muMinusDz)<15 && muMinusNhits>10 && muMinusNPxlLayers>0 && muMinusNMuonhits>12 && muMinusInnerChi<2.1 && muMinusGlobalChi<2.7 && vProb>0.19) */ if ((HLTriggers&1)==1 && (Reco_QQ_trig[iQQ]&1)==1 && (Reco_QQ_type[iQQ]<3) ) { UpsilonTree_allsign->Fill(); if (Reco_QQ_sign[iQQ]==0) { UpsilonTree->Fill(); if (Reco_QQ->M()>8.5 && Reco_QQ->M()<11.5) { h_QQ_mass->Fill(Reco_QQ->M()); } if (Reco_QQ_mupl->Pt()>=ptcut && Reco_QQ_mumi->Pt()>=ptcut && Reco_QQ->M()>8.5 && Reco_QQ->M()<11.5) { h_QQ_mass_1->Fill(Reco_QQ->M()); } } else if (Reco_QQ_mupl->Pt()>=ptcut && Reco_QQ_mumi->Pt()>=ptcut && Reco_QQ->M()>8.5 && Reco_QQ->M()<11.5) { h_QQ_mass_2->Fill(Reco_QQ->M()); } //track rotation Double_t ran = gRandom->Rndm(); if(ran < 0.5 ) RmuPlusPhi = muPlusPhi + TMath::Pi(); else RmuMinusPhi = muMinusPhi + TMath::Pi(); TLorentzVector mu1; mu1.SetPtEtaPhiM( muPlusPt, muPlusEta, RmuPlusPhi, 0.105); TLorentzVector mu2; mu2.SetPtEtaPhiM( muMinusPt, muMinusEta, RmuMinusPhi, 0.105); TLorentzVector dimuon; dimuon = mu1 + mu2; invariantMass=dimuon.M(); upsPt=dimuon.Pt(); upsEta=dimuon.Eta(); upsRapidity=dimuon.Rapidity(); if ((HLTriggers&1)==2 && (Reco_QQ_trig[iQQ]&1)==1 && (Reco_QQ_type[iQQ]==0) ) { UpsilonTree_trkRot->Fill(); } /* for (int k=0;k<10;k++){ //track rotation //if(ran < 0.5 ) RmuPlusPhi = muPlusPhi + TMath::Pi(); //else RmuMinusPhi = muMinusPhi + TMath::Pi(); Double_t ran = gRandom->Rndm(); if (k<5) { muMinusPhi = muMinusPhi + TMath::Pi()*ran; } else { muPlusPhi = muPlusPhi + TMath::Pi()*ran; } TLorentzVector mu1; mu1.SetPtEtaPhiM( muPlusPt, muPlusEta, muPlusPhi, 0.105); TLorentzVector mu2; mu2.SetPtEtaPhiM( muMinusPt, muMinusEta, muMinusPhi, 0.105); TLorentzVector dimuon; dimuon = mu1 + mu2; invariantMass=dimuon.M(); upsPt=dimuon.Pt(); upsEta=dimuon.Eta(); upsRapidity=dimuon.Rapidity(); UpsilonTree_trkRot->Fill(); } */ } } // UpsilonTree->Fill(); } gROOT->SetStyle("Plain"); gStyle->SetPalette(1); gStyle->SetFrameBorderMode(0); gStyle->SetFrameFillColor(0); gStyle->SetCanvasColor(0); gStyle->SetTitleFillColor(0); gStyle->SetStatColor(0); gStyle->SetPadBorderSize(0); gStyle->SetCanvasBorderSize(0); gStyle->SetOptTitle(0); // at least most of the time gStyle->SetOptStat(0); // most of the time, sometimes "nemriou" might be useful to display name, number of entries, mean, rms, integral, overflow and underflow gStyle->SetOptFit(0); // set to 1 only if you want to display fit results TCanvas *c1 = new TCanvas("c1","c1"); //h_QQ_mass->GetYaxis()->SetRangeUser(0,180); h_QQ_mass->SetMarkerColor(kRed); h_QQ_mass->SetMarkerStyle(22); h_QQ_mass->SetXTitle("m_{#mu#mu} (GeV/c^{2})"); h_QQ_mass->SetYTitle("Events/(0.1 GeV/c^{2})"); h_QQ_mass->Draw("PE"); h_QQ_mass_1->SetMarkerColor(kBlue); h_QQ_mass_1->SetMarkerStyle(20); h_QQ_mass_1->GetXaxis()->CenterTitle(kTRUE); h_QQ_mass_1->SetXTitle("m_{#mu#mu} (GeV/c^{2})"); h_QQ_mass_1->SetYTitle("Events/(0.1 GeV/c^{2})"); h_QQ_mass_1->Draw("PEsame"); //h_QQ_mass_2->GetYaxis()->SetRangeUser(0,400); h_QQ_mass_2->SetMarkerColor(kRed); h_QQ_mass_2->SetMarkerStyle(24); h_QQ_mass_2->GetXaxis()->CenterTitle(kTRUE); h_QQ_mass_2->SetXTitle("m_{#mu#mu} (GeV/c^{2})"); h_QQ_mass_2->SetYTitle("Events/(0.1 MeV/c^{2})"); h_QQ_mass_2->Draw("PEsame"); TLegend *legend = new TLegend(.5,.7,.9,.9); legend->AddEntry(h_QQ_mass,"N_{#mu^{+}#mu^{-}} acceptance cut","P"); legend->AddEntry(h_QQ_mass_1,"Unlike-Sign, N_{#mu^{+}#mu^{-}}","P"); legend->AddEntry(h_QQ_mass_2,"Like-sign, N_{#mu^{+}#mu^{+}}+N_{#mu^{-}#mu^{-}}","P"); legend->AddEntry((TObject*)0,"#mu p_{T} > 3 GeV/c",""); legend->Draw(); h_QQ_mass->Write(); h_QQ_mass_1->Write(); h_QQ_mass_2->Write(); c1->SaveAs("dimuon_likesign_pt4.pdf"); c1->SaveAs("dimuon_likesign_pt4.gif"); c1->Write(); f1->Write(); }
void kanaelec::Loop(int wda, int wsp, const char *outfilename) { if (fChain == 0) return; Long64_t nentries = fChain->GetEntries(); // Out Put File Here TFile fresults = TFile(outfilename,"RECREATE"); TTree *newtree = fChain->CloneTree(); Float_t fit_mu_px=0, fit_mu_py =0, fit_mu_pz=0, fit_mu_e=0; Float_t fit_nv_px=0, fit_nv_py =0, fit_nv_pz=0, fit_nv_e=0; Float_t fit_aj_px=0, fit_aj_py =0, fit_aj_pz=0, fit_aj_e=0; Float_t fit_bj_px=0, fit_bj_py =0, fit_bj_pz=0, fit_bj_e=0; Float_t fit_mlvjj=0, fit_chi2 =999; Int_t fit_NDF =999, fit_status=999, gdevtt =0; TBranch *branch_mu_px = newtree->Branch("fit_el_px", &fit_mu_px, "fit_el_px/F"); TBranch *branch_mu_py = newtree->Branch("fit_el_py", &fit_mu_py, "fit_el_py/F"); TBranch *branch_mu_pz = newtree->Branch("fit_el_pz", &fit_mu_pz, "fit_el_pz/F"); TBranch *branch_mu_e = newtree->Branch("fit_el_e", &fit_mu_e, "fit_el_e/F"); TBranch *branch_nv_px = newtree->Branch("fit_nv_px", &fit_nv_px, "fit_nv_px/F"); TBranch *branch_nv_py = newtree->Branch("fit_nv_py", &fit_nv_py, "fit_nv_py/F"); TBranch *branch_nv_pz = newtree->Branch("fit_nv_pz", &fit_nv_pz, "fit_nv_pz/F"); TBranch *branch_nv_e = newtree->Branch("fit_nv_e", &fit_nv_e, "fit_nv_e/F"); TBranch *branch_aj_px = newtree->Branch("fit_aj_px", &fit_aj_px, "fit_aj_px/F"); TBranch *branch_aj_py = newtree->Branch("fit_aj_py", &fit_aj_py, "fit_aj_py/F"); TBranch *branch_aj_pz = newtree->Branch("fit_aj_pz", &fit_aj_pz, "fit_aj_pz/F"); TBranch *branch_aj_e = newtree->Branch("fit_aj_e", &fit_aj_e, "fit_aj_e/F"); TBranch *branch_bj_px = newtree->Branch("fit_bj_px", &fit_bj_px, "fit_bj_px/F"); TBranch *branch_bj_py = newtree->Branch("fit_bj_py", &fit_bj_py, "fit_bj_py/F"); TBranch *branch_bj_pz = newtree->Branch("fit_bj_pz", &fit_bj_pz, "fit_bj_pz/F"); TBranch *branch_bj_e = newtree->Branch("fit_bj_e", &fit_bj_e, "fit_bj_e/F"); TBranch *branch_mlvjj = newtree->Branch("fit_mlvjj", &fit_mlvjj, "fit_mlvjj/F"); TBranch *branch_chi2 = newtree->Branch("fit_chi2", &fit_chi2, "fit_chi2/F"); TBranch *branch_NDF = newtree->Branch("fit_NDF", &fit_NDF, "fit_NDF/I"); TBranch *branch_status= newtree->Branch("fit_status",&fit_status, "fit_status/I"); TBranch *branch_gdevtt= newtree->Branch("gdevtt", &gdevtt, "gdevtt/I"); Float_t fi2_mu_px=0, fi2_mu_py =0, fi2_mu_pz=0, fi2_mu_e=0; Float_t fi2_nv_px=0, fi2_nv_py =0, fi2_nv_pz=0, fi2_nv_e=0; Float_t fi2_aj_px=0, fi2_aj_py =0, fi2_aj_pz=0, fi2_aj_e=0; Float_t fi2_bj_px=0, fi2_bj_py =0, fi2_bj_pz=0, fi2_bj_e=0; Float_t fi2_mlvjj=0, fi2_chi2 =999; Int_t fi2_NDF =999, fi2_status=999; TBranch *branc2_mu_px = newtree->Branch("fi2_el_px", &fi2_mu_px, "fi2_el_px/F"); TBranch *branc2_mu_py = newtree->Branch("fi2_el_py", &fi2_mu_py, "fi2_el_py/F"); TBranch *branc2_mu_pz = newtree->Branch("fi2_el_pz", &fi2_mu_pz, "fi2_el_pz/F"); TBranch *branc2_mu_e = newtree->Branch("fi2_el_e", &fi2_mu_e, "fi2_el_e/F"); TBranch *branc2_nv_px = newtree->Branch("fi2_nv_px", &fi2_nv_px, "fi2_nv_px/F"); TBranch *branc2_nv_py = newtree->Branch("fi2_nv_py", &fi2_nv_py, "fi2_nv_py/F"); TBranch *branc2_nv_pz = newtree->Branch("fi2_nv_pz", &fi2_nv_pz, "fi2_nv_pz/F"); TBranch *branc2_nv_e = newtree->Branch("fi2_nv_e", &fi2_nv_e, "fi2_nv_e/F"); TBranch *branc2_aj_px = newtree->Branch("fi2_aj_px", &fi2_aj_px, "fi2_aj_px/F"); TBranch *branc2_aj_py = newtree->Branch("fi2_aj_py", &fi2_aj_py, "fi2_aj_py/F"); TBranch *branc2_aj_pz = newtree->Branch("fi2_aj_pz", &fi2_aj_pz, "fi2_aj_pz/F"); TBranch *branc2_aj_e = newtree->Branch("fi2_aj_e", &fi2_aj_e, "fi2_aj_e/F"); TBranch *branc2_bj_px = newtree->Branch("fi2_bj_px", &fi2_bj_px, "fi2_bj_px/F"); TBranch *branc2_bj_py = newtree->Branch("fi2_bj_py", &fi2_bj_py, "fi2_bj_py/F"); TBranch *branc2_bj_pz = newtree->Branch("fi2_bj_pz", &fi2_bj_pz, "fi2_bj_pz/F"); TBranch *branc2_bj_e = newtree->Branch("fi2_bj_e", &fi2_bj_e, "fi2_bj_e/F"); TBranch *branc2_mlvjj = newtree->Branch("fi2_mlvjj", &fi2_mlvjj, "fi2_mlvjj/F"); TBranch *branc2_chi2 = newtree->Branch("fi2_chi2", &fi2_chi2, "fi2_chi2/F"); TBranch *branc2_NDF = newtree->Branch("fi2_NDF", &fi2_NDF, "fi2_NDF/I"); TBranch *branc2_status= newtree->Branch("fi2_status",&fi2_status, "fi2_status/I"); // Loop over all events Long64_t nbytes = 0, nb = 0; for (Long64_t jentry=0; jentry<nentries;jentry++) { //Long64_t ientry = LoadTree(jentry); //if (ientry < 0) break; nb = newtree->GetEntry(jentry); nbytes += nb; // Cut variable definitions double jess = 1.00; // control the jet energy scale //double muoniso = (W_muon_trackiso+W_muon_hcaliso+W_muon_ecaliso-event_RhoForLeptonIsolation*3.141592653589*0.09)/W_muon_pt; double dijetpt = sqrt(JetPFCor_Pt[0]*JetPFCor_Pt[0]+ JetPFCor_Pt[1]*JetPFCor_Pt[1]+ 2*JetPFCor_Pt[0]*JetPFCor_Pt[1]*cos(JetPFCor_Phi[0]-JetPFCor_Phi[1])); // Save variable initialization fit_mu_px = 0; fit_mu_py = 0; fit_mu_pz = 0; fit_mu_e = 0; fit_nv_px = 0; fit_nv_py = 0; fit_nv_pz = 0; fit_nv_e = 0; fit_aj_px = 0; fit_aj_py = 0; fit_aj_pz = 0; fit_aj_e = 0; fit_bj_px = 0; fit_bj_py = 0; fit_bj_pz = 0; fit_bj_e = 0; fit_mlvjj = 0; fit_chi2 =999;fit_NDF =999; fit_status=999; gdevtt = 0; fi2_mu_px = 0; fi2_mu_py = 0; fi2_mu_pz = 0; fi2_mu_e = 0; fi2_nv_px = 0; fi2_nv_py = 0; fi2_nv_pz = 0; fi2_nv_e = 0; fi2_aj_px = 0; fi2_aj_py = 0; fi2_aj_pz = 0; fi2_aj_e = 0; fi2_bj_px = 0; fi2_bj_py = 0; fi2_bj_pz = 0; fi2_bj_e = 0; fi2_mlvjj = 0; fi2_chi2 =999;fi2_NDF =999; fi2_status=999; // Good Event Selection Requirement if (JetPFCor_Pt[0]>30. && JetPFCor_Pt[1]>30. && JetPFCor_Pt[2]<0.5 && abs(JetPFCor_Eta[0]-JetPFCor_Eta[1])<1.5 && W_electron_et>30. && W_electron_isWP80==1 && (W_electron_trackiso+W_electron_hcaliso+W_electron_ecaliso-event_RhoForLeptonIsolation*3.141592653589*0.09)/W_electron_pt<0.05 && ((abs(W_electron_eta)<1.5 && abs(W_electron_deltaphi_in)<0.03 && abs(W_electron_deltaeta_in)<0.004) || (abs(W_electron_eta)>1.5 && abs(W_electron_deltaphi_in)<0.02 && abs(W_electron_deltaeta_in)<0.005)) && sqrt((W_electron_vx-event_BeamSpot_x)*(W_electron_vx-event_BeamSpot_x)+(W_electron_vy-event_BeamSpot_y)*(W_electron_vy-event_BeamSpot_y))<0.02 && JetPFCor_bDiscriminator[0]<1.19 && JetPFCor_bDiscriminator[1]<1.19 && cosJacksonAngle2j_PFCor<0.8 && cosJacksonAngle2j_PFCor>-0.6 && event_met_pfmet>30. && W_mt>40. && dijetpt > 40. ) { gdevtt = 1; // Do the kinematic fit for all event!!! int Aj = 0, Bj = 1; TLorentzVector mup, nvp, ajp, bjp; mup.SetPtEtaPhiE(W_electron_pt, W_electron_eta, W_electron_phi, W_electron_e ); nvp.SetPxPyPzE(event_met_pfmet * cos(event_met_pfmetPhi), event_met_pfmet * sin(event_met_pfmetPhi), W_pzNu1, sqrt(event_met_pfmet*event_met_pfmet + W_pzNu1*W_pzNu1) ); ajp.SetPtEtaPhiE(jess * JetPFCor_Pt[Aj], JetPFCor_Eta[Aj], JetPFCor_Phi[Aj], jess * JetPFCor_E[Aj] ); bjp.SetPtEtaPhiE(jess * JetPFCor_Pt[Bj], JetPFCor_Eta[Bj], JetPFCor_Phi[Bj], jess * JetPFCor_E[Bj] ); TLorentzVector fit_mup(0,0,0,0), fit_nvp(0,0,0,0), fit_ajp(0,0,0,0), fit_bjp(0,0,0,0) ; doKinematicFit( 1, mup, nvp, ajp, bjp, fit_mup, fit_nvp, fit_ajp, fit_bjp, fit_chi2, fit_NDF, fit_status); fit_mu_px = fit_mup.Px(); fit_mu_py = fit_mup.Py(); fit_mu_pz = fit_mup.Pz(); fit_mu_e = fit_mup.E(); fit_nv_px = fit_nvp.Px(); fit_nv_py = fit_nvp.Py(); fit_nv_pz = fit_nvp.Pz(); fit_nv_e = fit_nvp.E(); fit_aj_px = fit_ajp.Px(); fit_aj_py = fit_ajp.Py(); fit_aj_pz = fit_ajp.Pz(); fit_aj_e = fit_ajp.E(); fit_bj_px = fit_bjp.Px(); fit_bj_py = fit_bjp.Py(); fit_bj_pz = fit_bjp.Pz(); fit_bj_e = fit_bjp.E(); fit_mlvjj = (fit_mup+fit_nvp+fit_ajp+fit_bjp).M(); TLorentzVector fi2_mup(0,0,0,0), fi2_nvp(0,0,0,0), fi2_ajp(0,0,0,0), fi2_bjp(0,0,0,0) ; doKinematicFit( 2, mup, nvp, ajp, bjp, fi2_mup, fi2_nvp, fi2_ajp, fi2_bjp, fi2_chi2, fi2_NDF, fi2_status); fi2_mu_px = fi2_mup.Px(); fi2_mu_py = fi2_mup.Py(); fi2_mu_pz = fi2_mup.Pz(); fi2_mu_e = fi2_mup.E(); fi2_nv_px = fi2_nvp.Px(); fi2_nv_py = fi2_nvp.Py(); fi2_nv_pz = fi2_nvp.Pz(); fi2_nv_e = fi2_nvp.E(); fi2_aj_px = fi2_ajp.Px(); fi2_aj_py = fi2_ajp.Py(); fi2_aj_pz = fi2_ajp.Pz(); fi2_aj_e = fi2_ajp.E(); fi2_bj_px = fi2_bjp.Px(); fi2_bj_py = fi2_bjp.Py(); fi2_bj_pz = fi2_bjp.Pz(); fi2_bj_e = fi2_bjp.E(); fi2_mlvjj = (fi2_mup+fi2_nvp+fi2_ajp+fi2_bjp).M(); } // Only Good event will be performed kinematic fit branch_mu_px->Fill(); branch_mu_py->Fill(); branch_mu_pz->Fill(); branch_mu_e ->Fill(); branch_nv_px->Fill(); branch_nv_py->Fill(); branch_nv_pz->Fill(); branch_nv_e ->Fill(); branch_aj_px->Fill(); branch_aj_py->Fill(); branch_aj_pz->Fill(); branch_aj_e ->Fill(); branch_bj_px->Fill(); branch_bj_py->Fill(); branch_bj_pz->Fill(); branch_bj_e ->Fill(); branch_mlvjj->Fill(); branch_chi2 ->Fill(); branch_NDF ->Fill(); branch_status->Fill(); branch_gdevtt->Fill(); branc2_mu_px->Fill(); branc2_mu_py->Fill(); branc2_mu_pz->Fill(); branc2_mu_e ->Fill(); branc2_nv_px->Fill(); branc2_nv_py->Fill(); branc2_nv_pz->Fill(); branc2_nv_e ->Fill(); branc2_aj_px->Fill(); branc2_aj_py->Fill(); branc2_aj_pz->Fill(); branc2_aj_e ->Fill(); branc2_bj_px->Fill(); branc2_bj_py->Fill(); branc2_bj_pz->Fill(); branc2_bj_e ->Fill(); branc2_mlvjj->Fill(); branc2_chi2 ->Fill(); branc2_NDF ->Fill(); branc2_status->Fill(); } // end event loop fresults.cd(); newtree->Write("WJet"); fresults.Close(); std::cout << wda << "-" << wsp << " :: " << outfilename << " "<< nentries << std::endl; }
/* EXAMPLE root .L particleDrawer.C++ particleDrawer("../test/test.root",11,2) */ void particleDrawer(TString filename, int entry = 0, int PVAssoc = 2, bool debug = false) { cout << "particleDrawer::Setting the TDR style ... "; setTDRStyle(); cout << "DONE" << endl; cout << "particleDrawer::Drawing the default (TDR) frame ... " << endl; TH1D* frame = new TH1D(); frame->GetXaxis()->SetLimits(-5,5); frame->GetXaxis()->SetTitle("#eta"); frame->GetYaxis()->SetRangeUser(-TMath::Pi(),TMath::Pi()); frame->GetYaxis()->SetTitle("#phi"); TCanvas* c = tdrCanvas("particleBasedEvent",frame,4,0,true); c->GetPad(0)->SetLogz(); cout << "\r\r\r\r\r\r" << flush; cout << setw(52) << " " << "DONE" << endl << endl; cout << "particleDrawer::Opening the input file (" << filename << " ) ... "; TFile* inFile = TFile::Open(filename,"READ"); assert(inFile!=NULL); cout << "DONE" << endl; cout << "particleDrawer::Getting the input trees ... "; TTree* puppiTree = (TTree*)inFile->Get("puppiReader/puppiTree"); assert(puppiTree!=NULL); TTree* jetTree = (TTree*)inFile->Get("nt_AK4PFchs/t"); assert(jetTree!=NULL); cout << "DONE" << endl; cout << "particleDrawer::Making the ntuples ... "; puppiNtuple* pNtuple = new puppiNtuple(puppiTree); validatorNtuple* jNtuple = new validatorNtuple(jetTree); cout << "DONE" << endl; cout << "particleDrawer::Getting entry " << entry << " for puppiTree ... "; puppiTree->GetEntry(entry); cout << "DONE" << endl; cout << "particleDrawer::Filling the histograms ... "; TH2F* hPU = new TH2F("hPU","hPU",50,-5,5,60,-TMath::Pi(),TMath::Pi()); TH2F* hHard = new TH2F("hHard","hHard",50,-5,5,60,-TMath::Pi(),TMath::Pi()); for(unsigned int iparticle=0; iparticle<(*pNtuple->px).size(); iparticle++) { TLorentzVector tempVect((*pNtuple->px)[iparticle],(*pNtuple->py)[iparticle], (*pNtuple->pz)[iparticle],(*pNtuple->e)[iparticle]); if((*pNtuple->fromPV)[iparticle]<PVAssoc) { if(debug) cout << "Filling PU::fromPV = " << (*pNtuple->fromPV)[iparticle] << endl; hPU->Fill(tempVect.Eta(),tempVect.Phi(),tempVect.Pt()); } else { if(debug) cout << "Filling hard-scatter:: fromPV = " << (*pNtuple->fromPV)[iparticle] << endl; hHard->Fill(tempVect.Eta(),tempVect.Phi(),tempVect.Pt()); } } if(debug) { cout << "hPU->GetEntries() = " << hPU->GetEntries() << endl; cout << "hHard->GetEntries() = " << hHard->GetEntries() << endl; } else cout << "DONE" << endl; cout << "particleDrawer::Drawing the histograms ... "; //tdrDraw(hPU,"BOX",kFullSquare,kNone,kSolid,kGray,kNone,kNone); //tdrDraw(hHard,"colz"); THStack* stack = new THStack("stack","stack"); hPU->SetLineStyle(kSolid); hPU->SetLineColor(kGray); hPU->SetFillStyle(1001); hPU->SetFillColor(kNone); hPU->SetMarkerStyle(kFullSquare); hPU->SetMarkerColor(kNone); if(hHard->GetEntries()>0) stack->Add(hHard,"colz"); if(hPU->GetEntries()>0) stack->Add(hPU,"BOX"); tdrDraw(stack,"nostack"); set_plot_style(); c->Update(); c->RedrawAxis(); cout << "DONE" << endl; cout << "particleDrawer::Getting entry " << entry << " for jetTree ... "; jetTree->GetEntry(entry); cout << "DONE" << endl; cout << "particleDrawer::Drawing the jets ... " << endl; vector<JetCircle> jets; for(unsigned int ijet=0; ijet<jNtuple->nref; ijet++) { if((*jNtuple->jtpt)[ijet]<20) continue; double RJet = TMath::Sqrt((*jNtuple->jtarea)[ijet]/TMath::Pi()); jets.push_back(JetCircle((*jNtuple->jteta)[ijet],(*jNtuple->jtphi)[ijet],RJet,(*jNtuple->jtpt)[ijet])); } for(unsigned int ijet=0; ijet<jets.size(); ijet++) { for(unsigned int jjet=ijet+1; jjet<jets.size(); jjet++) { if(check_overlap(jets[ijet].getX(),jets[ijet].getY(),jets[ijet].getRadius(), jets[jjet].getX(),jets[jjet].getY(),jets[jjet].getRadius())) { cout << "Jet " << ijet << " overlaps with jet " << jjet << endl; if(jets[ijet].getPt()>jets[jjet].getPt()) { //find angle for jjet; jets[jjet].findAngles(jets[ijet]); } else if(jets[ijet].getPt()<jets[jjet].getPt()) { //find angle for ijet jets[ijet].findAngles(jets[jjet]); } else { //must find angle for both jets //then must draw a straight line between the two intersection points jets[jjet].findAngles(jets[ijet]); jets[ijet].findAngles(jets[jjet]); //NEED TO COMPLETE THIS FUNCTION. CURRENTLY DOESNOT DRAW LINE BETWEEN THE JETS. } cout << "Jet " << ijet << ": \n" << jets[ijet] << endl; cout << "Jet " << jjet << ": \n" << jets[jjet] << endl; } } } for(unsigned int ijet=0; ijet<jets.size(); ijet++) { loadbar2(ijet+1, jets.size()); TEllipse* cJet = new TEllipse(jets[ijet].getX(),jets[ijet].getY(), jets[ijet].getRadius(),jets[ijet].getRadius(), jets[ijet].getStartAngle(),jets[ijet].getEndAngle()); cJet->SetFillStyle(0); cJet->SetFillColor(kNone); cJet->SetLineStyle(kSolid); cJet->SetLineColor(kRed); cJet->SetLineWidth(3); cJet->Draw("only same"); } //cout << "\r\r\r\r" << flush; //cout << setw(37) << " " << "DONE" << endl << endl; cout << "particleDrawer::Saving the canvas ... "; TString name = Form("particleMap_entry%i_PVAssoc%i",entry,PVAssoc); c->SaveAs(name+".png"); c->SaveAs(name+".pdf"); c->SaveAs(name+".C"); cout << "DONE" << endl; }
void SkimClassification(TString process="ZnnH125") { gROOT->LoadMacro("HelperFunctions.h" ); // make functions visible to TTreeFormula gROOT->SetBatch(1); //TChain * chain = new TChain("tree"); //TString fname = ""; //TString dijet = "DiJetPt_"; //TString dirMC = "dcache:/pnfs/cms/WAX/resilient/jiafu/ZnunuHbb/" + tagMC + "/"; //TString dirData = "dcache:/pnfs/cms/WAX/resilient/jiafu/ZnunuHbb/" + tagData + "/"; TString indir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Spring15_PU20bx25/skimV12_v2/step3/"; TString outdir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Spring15_PU20bx25/skimV12_v2/step3/skim_ZnnH_classification/"; TString prefix = "Step3_"; TString suffix = ".root"; TFile *input = TFile::Open(indir + prefix + process + suffix); if (!input) { std::cout << "ERROR: Could not open input file." << std::endl; exit(1); } TTree *tree = (TTree *) input->Get("tree"); Long64_t entries = tree->GetEntriesFast(); // Make output directory if it doesn't exist if (gSystem->AccessPathName(outdir)) gSystem->mkdir(outdir); TString outname = outdir + prefix + Form("%s.root", process.Data()); TFile* output = TFile::Open(outname, "RECREATE"); // Get selections const std::vector < std::string > & selExpressions = GetSelExpressions("ZnunuHighPt") ; // const UInt_t nsels = 3; // ZnunuHighPt, ZnunuLowPt, ZnunuLowCSV const UInt_t nsels = 1; // just one now... ZnunuHighPt, ZnunuLowPt, ZnunuLowCSV // assert(nsels == selExpressions.size()); <-- fixME // even-number events for training, odd-number events for testing TCut evenselection = "evt %2 == 0"; TCut oddselection = "evt %2 == 1"; TTreeFormula *ttf = 0; std::vector < TTreeFormula * >::const_iterator formIt, formItEnd; // Loop over selections std::vector<Long64_t> ventries; for (unsigned int i = 0; i < nsels; i++) { TString selname = "ZnunuHighPt"; if (i == 1) { selname = "ZnunuMedPt"; // selExpressions = GetSelExpressions("ZnunuMedPt") ; } else if (i == 2) { selname = "ZnunuLowPt"; // selExpressions = GetSelExpressions("ZnunuLowPt") ; } TTree *t1 = (TTree*) tree->CloneTree(0); TTree *t2 = (TTree*) tree->CloneTree(0); t1->SetName(TString::Format("%s_%s_train", tree->GetName(), selname.Data())); t2->SetName(TString::Format("%s_%s", tree->GetName(), selname.Data())); // The clones should not delete any shared i/o buffers. ResetDeleteBranches(t1); ResetDeleteBranches(t2); ttf = new TTreeFormula(Form("ttfsel%i", i), selExpressions.at(i).c_str(), tree); ttf->SetQuickLoad(1); TTreeFormula *ttf1 = new TTreeFormula(Form("ttfeven%i", i), evenselection, tree); ttf1->SetQuickLoad(1); TTreeFormula *ttf2 = new TTreeFormula(Form("ttfodd%i", i), oddselection, tree); ttf2->SetQuickLoad(1); if (!ttf || !ttf->GetNdim()) { std::cerr << "ERROR: Failed to find any TTree variable from the selection: " << selExpressions.at(i) << std::endl; return; } /// Loop over events Int_t curTree = tree->GetTreeNumber(); const Long64_t nentries = tree->GetEntries(); for (Long64_t ievt = 0; ievt < nentries; ievt++) { Long64_t entryNumber = tree->GetEntryNumber(ievt); if (entryNumber < 0) break; Long64_t localEntry = tree->LoadTree(entryNumber); if (localEntry < 0) break; if (tree->GetTreeNumber() != curTree) { curTree = tree->GetTreeNumber(); ttf ->UpdateFormulaLeaves(); // if using TChain ttf1->UpdateFormulaLeaves(); // if using TChain ttf2->UpdateFormulaLeaves(); // if using TChain } const Int_t ndata = ttf->GetNdata(); Bool_t keep = kFALSE; for(Int_t current = 0; current<ndata && !keep; current++) { keep |= (bool(ttf->EvalInstance(current)) != 0); } if (!keep) continue; bool even = (bool) ttf1->EvalInstance(); bool odd = (bool) ttf2->EvalInstance(); if (even && odd) { std::cerr << "ERROR: An event cannot be even and odd at the same time." << std::cout; return; } tree->GetEntry(entryNumber, 1); // get all branches if (even) { t1->Fill(); } else { t2->Fill(); } } // end loop over events t1->Write(); t2->Write(); ventries.push_back(t1->GetEntriesFast() + t2->GetEntriesFast()); delete ttf; delete ttf1; delete ttf2; } std::clog << process << ": skimmed from " << entries << " to " << ventries[0] << " (ZnunuHighPt), " << ventries[1] << " (ZnunuLowPt), " << ventries[2] << " (ZnunuLowCSV) " << " entries." << std::endl; output->Close(); input->Close(); delete output; delete input; return; }
void Fitting(){ TString RootFile_Name; TString Target, Arm; gSystem->Exec("ls -l *.root"); cerr<<" --- Target (H2,He3,He4) = "; cin >> Target; cerr<<" --- Arm (L, R) = "; cin >> Arm; RootFile_Name = Form("%s_Yield_%s_All.root",Target.Data(),Arm.Data()); TFile *f1 = new TFile(RootFile_Name.Data(),"r"); TTree *T = (TTree*) gDirectory->Get("T"); TString OutFile_Name = RootFile_Name; OutFile_Name.ReplaceAll(".root",".out"); ofstream outfile(OutFile_Name); TString File_Name1 = RootFile_Name; TString File_Name2 = RootFile_Name; TString File_Name3 = RootFile_Name; TString File_Name4 = RootFile_Name; File_Name1.ReplaceAll(".root",".png"); File_Name2.ReplaceAll(".root",".pdf"); File_Name3.ReplaceAll(".root","_0.png"); File_Name4.ReplaceAll(".root","_0.pdf"); double VZ, I, Y, Y_Err; int size, runno, Bin; T->SetBranchAddress("runsize",&size); T->SetBranchAddress("Bin",&Bin); T->SetBranchAddress("RunNo",&runno); T->SetBranchAddress("I",&I); T->SetBranchAddress("Y",&Y); T->SetBranchAddress("Y_Err",&Y_Err); T->SetBranchAddress("VZ",&VZ); int N = T->GetEntries(); T->GetEntry(0); const int Size = size; int temp=20; if(Target=="C12"||Target=="Ca40"||Target=="Ca48") temp=1; const int Bin_Size = temp; /*Read Root File{{{*/ cerr<<" @@@ Reading Root File ..."<<endl; double vI[Bin_Size][Size]; double vI_Err[Bin_Size][Size]; double vY[Bin_Size][Size]; double vY_Err[Bin_Size][Size]; double vVZ[Bin_Size]; double Y_Max=-1e32,Y_Min=1e32, X_Max=-1000,X_Min=1000; int k=0; for(int j=0;j<Bin_Size; j++){ k=0; for(int i=0;i<N;i++){ T->GetEntry(i); if(Y>-0.5 && Bin==j){ vI[j][k]=I; vI_Err[j][k]=0.; vY[j][k]=Y; vY_Err[j][k]=Y_Err; vVZ[j] = VZ; if(X_Max<vI[j][k]) X_Max = vI[j][k]; if(X_Min>vI[j][k]) X_Min = vI[j][k]; if(Y_Max<vY[j][k]) Y_Max = vY[j][k]; if(Y_Min>vY[j][k]) Y_Min = vY[j][k]; // Y_Max = Y_Max?vY[j][k]:Y_Max<vY[j][k]; // Y_Min = Y_Min?vY[j][k]:Y_Min>vY[j][k]; // X_Max = X_Max?vI[j][k]:X_Max<vI[j][k]; // X_Min = X_Min?vI[j][k]:X_Min>vI[j][k]; cerr<<Form("--- Bin = %d, VZ=%6.4f, I=%6.4f, Y=%e", Bin, VZ, I, Y)<<endl; k++; if(k>Size) cerr<<"*** Something wrong?!"<<endl; } } } /*}}}*/ /*Plot and Fit{{{*/ cerr<<" @@@ Making Plots and Fitting ..."<<endl; cerr<<Form(" ---- X_Min=%f, X_Max=%f, Y_Min=%e, Y_Max=%e",X_Min,X_Max, Y_Min, Y_Max)<<endl; TCanvas *c3 = new TCanvas("c3","c3",1200,700); c3->cd(); TH2F *h3 = new TH2F("h3","",300,X_Min-2.0,X_Max+2.0,300,0.0,Y_Max/Y_Min*1.12); h3->SetStats(kFALSE); h3->SetXTitle("I (uA)"); h3->GetXaxis()->CenterTitle(1); h3->GetXaxis()->SetTitleFont(32); h3->GetXaxis()->SetTitleSize(0.06); h3->GetYaxis()->SetTitleOffset(0.8); h3->SetYTitle("Yield_{normalized}"); h3->GetYaxis()->CenterTitle(1); h3->GetYaxis()->SetTitleFont(32); h3->GetYaxis()->SetTitleSize(0.06); h3->GetYaxis()->SetTitleOffset(0.8); gStyle->SetOptStat(1); gStyle->SetOptFit(1); double S[Bin_Size],S_Err[Bin_Size]; double Y0[Bin_Size],Y0_Err[Bin_Size]; double BF[Bin_Size],BF_Err[Bin_Size]; double Zero[Bin_Size]; for(int l=0; l<Bin_Size; l++){ for(int m=0; m<Size; m++){ vY[l][m]/=Y_Min; vY_Err[l][m]/=Y_Min; } } TLatex *tex; outfile<<Form("%12s %12s %12s %12s %12s", "VZ","Y0","Y0_Err","BF","BF_Err")<<endl; Y_Max=-1e32,Y_Min=1e32; for(int l=0; l<Bin_Size; l++){ h3->Draw(); for(int m=0;m<Size;m++) cerr<<Form(" VZ=%6.4f, I = %6.3f, Y = %e", vVZ[l], vI[l][m],vY[l][m])<<endl; TGraphErrors *ex = new TGraphErrors(Size, vI[l], vY[l], vI_Err[l], vY_Err[l]); ex->SetMarkerStyle(25); ex->SetMarkerColor(4); ex->SetLineColor(4); ex->Draw("P"); ex->Fit("pol1","IM","",X_Min,X_Max); if(l==0){//For C12 only // if(l==30){ tex=new TLatex(0.25, 0.6, Form("%s Boiling Effect Fit at z_{react} = %4.2f cm on HRS-%s",Target.Data(), vVZ[l]*100, Arm.Data())); tex->SetNDC(); tex->SetTextFont(32); tex->SetTextSize(0.05); tex->Draw(); c3->Print(File_Name3.Data()); c3->Print(File_Name4.Data()); } Y0[l] = ex->GetFunction("pol1")->GetParameter(0) ; Y0_Err[l] = ex->GetFunction("pol1")->GetParError(0) ; S[l] = ex->GetFunction("pol1")->GetParameter(1); S_Err[l] = ex->GetFunction("pol1")->GetParError(1); BF[l] = S[l]/Y0[l]; BF_Err[l] = BF[l] * sqrt( pow(Y0_Err[l]/Y0[l],2) + pow(S_Err[l]/S[l],2) ); Zero[l] = 0.0; if(Y_Max<S[l]) Y_Max = S[l]; if(Y_Min>S[l]) Y_Min = S[l]; cerr<<Form(" VZ=%f, Slop=%f",vVZ[l],S[l])<<endl; outfile<<Form(" %12.8f %12.8f %12.8f %12.8f %12.8f",vVZ[l],Y0[l], Y0_Err[l], BF[l],BF_Err[l])<<endl; c3->Clear(); } c3->Close(); TCanvas *c4 = new TCanvas("c4","c4",1200,700); c4->cd(); TH2F *h4 = new TH2F("h4","",300, -0.14, 0.14, 300, -0.011, 0.001); h4->SetStats(kFALSE); h4->SetXTitle("z_{react} (m)"); h4->GetXaxis()->CenterTitle(1); h4->GetXaxis()->SetTitleFont(32); h4->GetXaxis()->SetTitleSize(0.06); h4->GetXaxis()->SetTitleOffset(0.7); h4->SetYTitle("BF"); h4->GetYaxis()->CenterTitle(1); h4->GetYaxis()->SetTitleFont(32); h4->GetYaxis()->SetTitleSize(0.04); h4->GetYaxis()->SetTitleOffset(1.2); h4->Draw(); TGraphErrors *ex1 = new TGraphErrors(Bin_Size, vVZ, BF, Zero, BF_Err); ex1->SetMarkerStyle(20); ex1->SetMarkerColor(4); ex1->SetLineColor(4); ex1->Draw("P"); tex=new TLatex(0.3, 0.2, Form("%s Boiling Effect on HRS-%s",Target.Data(), Arm.Data())); tex->SetNDC(); tex->SetTextFont(32); tex->SetTextSize(0.05); tex->Draw(); c4->Print(File_Name1.Data()); c4->Print(File_Name2.Data()); /*}}}*/ }
void makeQnCuts(){ bool testrun = 0; const int NBins = 1000; double qn_min = 0; double qn_max = 0.61; int qnselect_ = 2; double vtxCut = 15.; TFile * fIn; TTree * tree; double centval; double vtx; double qnHFx_EP[NumEPNames]; double qnHFy_EP[NumEPNames]; double sumET_EP[NumEPNames]; TFile * fQNDet; TH1D * hqnHFDet_x[NumEPNames]; TH1D * hqnHFDet_y[NumEPNames]; TFile * fOut; TH1D * hqnHF_EP[NCENT][NEPSymm]; TCanvas * chqnHF_EP[NCENT][NEPSymm]; double splitBinMin[NCENT][NEPSymm][NQN]; double splitBinMax[NCENT][NEPSymm][NQN]; TLine * splitLine[NCENT][NEPSymm][NQN-1]; TH1D * hqbins[NCENT][NEPSymm]; double qbins[NCENT][NEPSymm][NQN+1]; TLatex latex; // // MAIN // setTDRStyle(); latex.SetNDC(); //-- Get the analyzer file fIn = new TFile(fAnaTreeName); //-- Get the analyzer tree and set the branches tree = (TTree*) fIn->Get("ebyeana/tree"); tree->SetBranchAddress("Cent", ¢val); tree->SetBranchAddress("Vtx", &vtx); tree->SetBranchAddress("qnHFx_EP", &qnHFx_EP); tree->SetBranchAddress("qnHFy_EP", &qnHFy_EP); tree->SetBranchAddress("sumET_EP", &sumET_EP); //-- Get the QN Detector histograms fQNDet = new TFile( Form("../../../v%i/eta2.4/AnalyzerResults/Q%iDet.root", qnselect_, qnselect_) ); for(int iEP = 0; iEP < NumEPNames; iEP++){ int EPbin = EPSymmPartnerBin[iEP]; if( EPbin != EPSymmBin ) continue; hqnHFDet_x[iEP] = (TH1D*) fQNDet->Get( Form("hqnHFDet_x_%s", EPNames[iEP].data()) ); hqnHFDet_y[iEP] = (TH1D*) fQNDet->Get( Form("hqnHFDet_y_%s", EPNames[iEP].data()) ); } //-- Make the output file fOut = new TFile( Form("q%iCuts.root", qnselect_), "recreate" ); //-- Initialize the 1D histograms for(int iEP = 0; iEP < NEPSymm; iEP++){ if( iEP != EPSymmBin ) continue; for(int icent = 0; icent < NCENT; icent++){ fOut->cd(); hqnHF_EP[icent][iEP] = new TH1D( Form("hqnHF_c%i_EP%i", icent, iEP), Form("hqnHF_c%i_EP%i", icent, iEP), NBins, qn_min, qn_max ); hqnHF_EP[icent][iEP]->GetXaxis()->SetTitle( Form("q_{%i}", qnselect_) ); hqnHF_EP[icent][iEP]->GetYaxis()->SetTitle( "Events" ); } } //-- Begin Event loop int Nevt; if(!testrun) Nevt = tree->GetEntries(); else Nevt = 10000; std::cout<<"Begin QN SPLIT loop, contains "<< Nevt << " events..." << std::endl; for(int ievt = 0; ievt < Nevt; ievt++){ if((ievt+1)% 500000 == 0) cout<<"Processing Event "<<ievt+1<<"\t"<<(100.*(ievt+1)/Nevt)<<"% Completed"<<endl; tree->GetEntry(ievt); //-- Vertex Cut if(TMath::Abs(vtx) > vtxCut) continue; //-- Calculate centbin if( centval > cent_max[NCENT-1]) continue; int icent = hCentBins.FindBin(centval)-1; //-- Begin EP loop for(int iEP = 0; iEP < NEP; iEP++){ int EPbin = EPSymmPartnerBin[iEP]; if( EPbin != EPSymmBin ) continue; double qx = qnHFx_EP[iEP]; double qy = qnHFy_EP[iEP]; double qxDet = hqnHFDet_x[iEP]->GetBinContent(icent+1); double qyDet = hqnHFDet_y[iEP]->GetBinContent(icent+1); double sumET = sumET_EP[iEP]; if(sumET == 0) continue; qx -= qxDet; qy -= qyDet; qx /= sumET; qy /= sumET; double qn = TMath::Sqrt( qx*qx + qy*qy ); //-- Consolodate into symmetric HF bins hqnHF_EP[icent][EPbin]->Fill(qn); } //-- End EP loop } //-- End event loop std::cout<<"End QN loop"<<std::endl; //-- Divide each histogram into NQN equal areas bool splitSuccess = 1; for(int icent = 0; icent < NCENT; icent++){ for(int iEP = 0; iEP < NEPSymm; iEP++){ if( iEP != EPSymmBin ) continue; double integral = hqnHF_EP[icent][iEP]->Integral(1, NBins); double binwidth = integral/(double)NQN; int startbin = 1; double sum = 0.; for(int iqn = 0; iqn < NQN-1; iqn++){ splitBinMin[icent][iEP][iqn] = startbin; for(int ibin = startbin; ibin <= NBins; ibin++){ double A = hqnHF_EP[icent][iEP]->Integral(startbin, ibin); if( A > binwidth ){ double B = hqnHF_EP[icent][iEP]->Integral(startbin, ibin-1); if( fabs(A - binwidth) < fabs(B - binwidth) ){ startbin = ibin+1; splitBinMax[icent][iEP][iqn] = ibin; break; } else{ startbin = ibin; splitBinMax[icent][iEP][iqn] = ibin-1; break; } } }//-- End bin loop sum += hqnHF_EP[icent][iEP]->Integral(splitBinMin[icent][iEP][iqn], splitBinMax[icent][iEP][iqn]); double binc = hqnHF_EP[icent][iEP]->GetBinCenter(startbin); double max = hqnHF_EP[icent][iEP]->GetBinContent(startbin); splitLine[icent][iEP][iqn] = new TLine(binc, 0, binc, max); splitLine[icent][iEP][iqn]->SetLineColor(2); splitLine[icent][iEP][iqn]->SetLineStyle(2); splitLine[icent][iEP][iqn]->SetLineWidth(2); } //-- End split loop splitBinMin[icent][iEP][NQN-1] = splitBinMax[icent][iEP][NQN-2] + 1; // Make the last bin edge to be the bin where the integral is full for(int ibin = 1; ibin <= NBins; ibin++){ double integ = hqnHF_EP[icent][iEP]->Integral(1, ibin); if( integ == integral ){ splitBinMax[icent][iEP][NQN-1] = ibin; break; } } //-- End bin loop sum += hqnHF_EP[icent][iEP]->Integral(splitBinMin[icent][iEP][NQN-1], splitBinMax[icent][iEP][NQN-1]); if(sum == integral) std::cout<<"Histogram division check..."<<"\tCent bin = "<<icent<<"\tEP bin = "<<iEP<<"\tPASS!"<<std::endl; else{ std::cout<<"Histogram division check..."<<"\tCent bin = "<<icent<<"\tEP bin = "<<iEP<<"\tFAIL!"<<std::endl; splitSuccess = 0; } } //-- End EP loop } //-- End cent loop if( !splitSuccess ){ std::cout << "Histogram area splitting failed in one or more bin!" << std::endl; std::cout << "Refusing to go futher, please fix and run again." <<std::endl; std::cout << "Exiting... Have a nice day." << std::endl; //exit(0); } //-- If all is good, proceed to fill the 2D arrays that contain the bin boundaries for qn for(int iqn = 0; iqn <= NQN; iqn++){ for(int icent = 0; icent < NCENT; icent++){ for(int iEP = 0; iEP < NEPSymm; iEP++){ if( iEP != EPSymmBin ) continue; if( iqn < NQN ){ int bmin = splitBinMin[icent][iEP][iqn]; double qmin = hqnHF_EP[icent][iEP]->GetBinLowEdge(bmin); qbins[icent][iEP][iqn] = qmin; } else{ int bmax = splitBinMax[icent][iEP][NQN-1] + 1; double qmax = hqnHF_EP[icent][iEP]->GetBinLowEdge(bmax); qbins[icent][iEP][iqn] = qmax; } } } } //-- Set up histograms based on these arrays (so I can use the find bin option in the subsequent programs) for(int icent = 0; icent < NCENT; icent++){ for(int iEP = 0; iEP < NEPSymm; iEP++){ if( iEP != EPSymmBin ) continue; fOut->cd(); hqbins[icent][iEP] = new TH1D( Form("hqbins_%s_c%i", EPSymmNames[iEP].data(), icent), Form("hqbins_%s_c%i", EPSymmNames[iEP].data(), icent), NQN, qbins[icent][iEP] ); hqbins[icent][iEP]->GetXaxis()->SetTitle( Form("q_%i", qnselect_) ); for(int iqn = 1; iqn <= NQN; iqn++) hqbins[icent][iEP]->SetBinContent( iqn, iqn ); } } //-- Draw the observed qn histograms with the split lines and save the canvases for(int iEP = 0; iEP < NEPSymm; iEP++){ if( iEP != EPSymmBin ) continue; for(int icent = 0; icent < NCENT; icent++){ chqnHF_EP[icent][iEP] = new TCanvas(Form("chqnHF_%s_c%i", EPSymmNames[iEP].data(), icent), Form("chqnHF_%s_c%i", EPSymmNames[iEP].data(), icent), 500, 500); chqnHF_EP[icent][iEP]->cd(); chqnHF_EP[icent][iEP]->SetLogy(); hqnHF_EP[icent][iEP]->Draw(); for(int i = 0; i < NQN-1; i++) splitLine[icent][iEP][i]->Draw("same"); //latex.DrawLatex(0.56,0.88, Form("%s", EPSymmNames[iEP].data()) ); latex.DrawLatex(0.56,0.88, Form("Centrality %i - %i%s", cent_min[icent], cent_max[icent], "%") ); latex.DrawLatex(0.56,0.82, Form("%.1f < |#eta| < %.1f", EPSymmAbsEtaMin[iEP], EPSymmAbsEtaMax[iEP]) ); chqnHF_EP[icent][iEP]->SaveAs( Form("../plots/qnsplitting/hq%i_%s_c%i.C", qnselect_, EPSymmNames[iEP].data(), icent) ); } } fOut->Write(); }
//_________________________________________________________________________________________ Int_t checkPullTree(TString pathTree, TString pathNameThetaMap, TString pathNameSigmaMap, TString mapSuffix, const Int_t collType /*0: pp, 1: pPb, 2: PbPb*/, const Bool_t plotPull = kTRUE, const Double_t downScaleFactor = 1, TString pathNameSplinesFile = "", TString prSplinesName = "", TString fileNameTree = "bhess_PIDetaTree.root", TString treeName = "fTree") { const Bool_t isNonPP = collType != 0; const Double_t massProton = AliPID::ParticleMass(AliPID::kProton); Bool_t recalculateExpecteddEdx = pathNameSplinesFile != ""; TFile* f = 0x0; f = TFile::Open(Form("%s/%s", pathTree.Data(), fileNameTree.Data())); if (!f) { std::cout << "Failed to open tree file \"" << Form("%s/%s", pathTree.Data(), fileNameTree.Data()) << "\"!" << std::endl; return -1; } // Extract the data Tree TTree* tree = dynamic_cast<TTree*>(f->Get(treeName.Data())); if (!tree) { std::cout << "Failed to load data tree!" << std::endl; return -1; } // Extract the splines, if desired TSpline3* splPr = 0x0; if (recalculateExpecteddEdx) { std::cout << "Loading splines to recalculate expected dEdx!" << std::endl << std::endl; TFile* fSpl = TFile::Open(pathNameSplinesFile.Data()); if (!fSpl) { std::cout << "Failed to open spline file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl; return 0x0; } TObjArray* TPCPIDResponse = (TObjArray*)fSpl->Get("TPCPIDResponse"); if (!TPCPIDResponse) { splPr = (TSpline3*)fSpl->Get(prSplinesName.Data()); // If splines are in file directly, without TPCPIDResponse object, try to load them if (!splPr) { std::cout << "Failed to load object array from spline file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl; return 0x0; } } else { splPr = (TSpline3*)TPCPIDResponse->FindObject(prSplinesName.Data()); if (!splPr) { std::cout << "Failed to load splines from file \"" << pathNameSplinesFile.Data() << "\"!" << std::endl; return 0x0; } } } else std::cout << "Taking dEdxExpected from Tree..." << std::endl << std::endl; // Extract the correction maps TFile* fMap = TFile::Open(pathNameThetaMap.Data()); if (!fMap) { std::cout << "Failed to open thetaMap file \"" << pathNameThetaMap.Data() << "\"! Will not additionally correct data...." << std::endl; } TH2D* hMap = 0x0; if (fMap) { hMap = dynamic_cast<TH2D*>(fMap->Get(Form("hRefined%s", mapSuffix.Data()))); if (!hMap) { std::cout << "Failed to load theta map!" << std::endl; return -1; } } TFile* fSigmaMap = TFile::Open(pathNameSigmaMap.Data()); if (!fSigmaMap) { std::cout << "Failed to open simgaMap file \"" << pathNameSigmaMap.Data() << "\"!" << std::endl; return -1; } TH2D* hThetaMapSigmaPar1 = dynamic_cast<TH2D*>(fSigmaMap->Get("hThetaMapSigmaPar1")); if (!hThetaMapSigmaPar1) { std::cout << "Failed to load sigma map for par 1!" << std::endl; return -1; } Double_t c0 = -1; TNamed* c0Info = dynamic_cast<TNamed*>(fSigmaMap->Get("c0")); if (!c0Info) { std::cout << "Failed to extract c0 from file with sigma map!" << std::endl; return -1; } TString c0String = c0Info->GetTitle(); c0 = c0String.Atof(); printf("Loaded parameter 0 for sigma: %f\n\n", c0); if (plotPull) std::cout << "Plotting pull..." << std::endl << std::endl; else std::cout << "Plotting delta'..." << std::endl << std::endl; Long64_t nTreeEntries = tree->GetEntriesFast(); Double_t dEdx = 0.; // Measured dE/dx Double_t dEdxExpected = 0.; // Expected dE/dx according to parametrisation Double_t tanTheta = 0.; // Tangens of (local) theta at TPC inner wall Double_t pTPC = 0.; // Momentum at TPC inner wall UShort_t tpcSignalN = 0; // Number of clusters used for dEdx UChar_t pidType = 0; Int_t fMultiplicity = 0; //Double_t phiPrime = 0; // Only activate the branches of interest to save processing time tree->SetBranchStatus("*", 0); // Disable all branches tree->SetBranchStatus("pTPC", 1); tree->SetBranchStatus("dEdx", 1); tree->SetBranchStatus("dEdxExpected", 1); tree->SetBranchStatus("tanTheta", 1); tree->SetBranchStatus("tpcSignalN", 1); tree->SetBranchStatus("pidType", 1); //tree->SetBranchStatus("phiPrime", 1); if (isNonPP) tree->SetBranchStatus("fMultiplicity", 1); tree->SetBranchAddress("dEdx", &dEdx); tree->SetBranchAddress("dEdxExpected", &dEdxExpected); tree->SetBranchAddress("tanTheta", &tanTheta); tree->SetBranchAddress("tpcSignalN", &tpcSignalN); tree->SetBranchAddress("pTPC", &pTPC); tree->SetBranchAddress("pidType", &pidType); //tree->SetBranchAddress("phiPrime", &phiPrime); if (isNonPP) tree->SetBranchAddress("fMultiplicity", &fMultiplicity); // Output file TDatime daTime; TString savefileName = Form("%s%s_checkPullSigma_%04d_%02d_%02d__%02d_%02d.root", fileNameTree.ReplaceAll(".root", "").Data(), recalculateExpecteddEdx ? "_recalcdEdx" : "", daTime.GetYear(), daTime.GetMonth(), daTime.GetDay(), daTime.GetHour(), daTime.GetMinute()); TFile* fSave = TFile::Open(Form("%s/%s", pathTree.Data(), savefileName.Data()), "recreate"); if (!fSave) { std::cout << "Failed to open save file \"" << Form("%s/%s", pathTree.Data(), savefileName.Data()) << "\"!" << std::endl; return -1; } const Double_t pBoundLow = 0.1; const Double_t pBoundUp = 5; const Int_t nBins1 = TMath::Ceil(180 / downScaleFactor); const Int_t nBins2 = TMath::Ceil(100 / downScaleFactor); const Int_t nBins3 = TMath::Ceil(60 / downScaleFactor); const Int_t nPbinsForMap = nBins1 + nBins2 + nBins3; Double_t binsPforMap[nPbinsForMap + 1]; Double_t binWidth1 = (1.0 - pBoundLow) / nBins1; Double_t binWidth2 = (2.0 - 1.0 ) / nBins2; Double_t binWidth3 = (pBoundUp - 2.0) / nBins3; for (Int_t i = 0; i < nBins1; i++) { binsPforMap[i] = pBoundLow + i * binWidth1; } for (Int_t i = nBins1, j = 0; i < nBins1 + nBins2; i++, j++) { binsPforMap[i] = 1.0 + j * binWidth2; } for (Int_t i = nBins1 + nBins2, j = 0; i < nBins1 + nBins2 + nBins3; i++, j++) { binsPforMap[i] = 2.0 + j * binWidth3; } binsPforMap[nPbinsForMap] = pBoundUp; TH2D* hPull = new TH2D("hPull", "Pull vs. p_{TPC} integrated over tan(#Theta);p_{TPC} (GeV/c);Pull", nPbinsForMap, binsPforMap, plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6); TH2D* hPullAdditionalCorr = (TH2D*)hPull->Clone("hPullAdditionalCorr"); hPullAdditionalCorr->SetTitle("Pull vs. p_{TPC} integrated over tan(#Theta) with additional dEdx correction w.r.t. tan(#Theta)"); /* const Int_t nThetaHistos = 3; TH2D* hPullTheta[nThetaHistos]; TH2D* hPullAdditionalCorrTheta[nThetaHistos]; Double_t tThetaLow[nThetaHistos] = { 0.0, 0.4, 0.9 }; Double_t tThetaHigh[nThetaHistos] = { 0.1, 0.5, 1.0 }; */ const Int_t nThetaHistos = 10; TH2D* hPullTheta[nThetaHistos]; TH2D* hPullAdditionalCorrTheta[nThetaHistos]; Double_t tThetaLow[nThetaHistos] = { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 }; Double_t tThetaHigh[nThetaHistos] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 }; for (Int_t i = 0; i < nThetaHistos; i++) { hPullTheta[i] = new TH2D(Form("hPullTheta_%d", i), Form("Pull vs. p_{TPC} for %.2f <= |tan(#Theta)| < %.2f;p_{TPC} (GeV/c);Pull", tThetaLow[i], tThetaHigh[i]), nPbinsForMap, binsPforMap, plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6); hPullAdditionalCorrTheta[i] = new TH2D(Form("hPullAdditionalCorrTheta_%d", i), Form("Pull vs. p_{TPC} for %.2f <= |tan(#Theta)| < %.2f with additional dEdx correction w.r.t. tan(#Theta);p_{TPC} (GeV/c);Pull", tThetaLow[i], tThetaHigh[i]), nPbinsForMap, binsPforMap, plotPull ? 120 : 240, plotPull ? -6 : -0.6, plotPull ? 6 : 0.6); } TF1 corrFuncMult("corrFuncMult", "[0] + [1]*TMath::Max([4], TMath::Min(x, [3])) + [2] * TMath::Power(TMath::Max([4], TMath::Min(x, [3])), 2)", 0., 0.2); TF1 corrFuncMultTanTheta("corrFuncMultTanTheta", "[0] * (x -[2]) + [1] * (x * x - [2] * [2])", -1.5, 1.5); TF1 corrFuncSigmaMult("corrFuncSigmaMul", "TMath::Max(0, [0] + [1]*TMath::Min(x, [3]) + [2] * TMath::Power(TMath::Min(x, [3]), 2))", 0., 0.2); // LHC13b.pass2 if (isNonPP) printf("Using corr Parameters for 13b.pass2\n!"); corrFuncMult.SetParameter(0, -5.906e-06); corrFuncMult.SetParameter(1, -5.064e-04); corrFuncMult.SetParameter(2, -3.521e-02); corrFuncMult.SetParameter(3, 2.469e-02); corrFuncMult.SetParameter(4, 0); corrFuncMultTanTheta.SetParameter(0, -5.32e-06); corrFuncMultTanTheta.SetParameter(1, 1.177e-05); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, 0.); corrFuncSigmaMult.SetParameter(1, 0.); corrFuncSigmaMult.SetParameter(2, 0.); corrFuncSigmaMult.SetParameter(3, 0.); /* OK, but PID task was not very satisfying corrFuncMult.SetParameter(0, -6.27187e-06); corrFuncMult.SetParameter(1, -4.60649e-04); corrFuncMult.SetParameter(2, -4.26450e-02); corrFuncMult.SetParameter(3, 2.40590e-02); corrFuncMult.SetParameter(4, 0); corrFuncMultTanTheta.SetParameter(0, -5.338e-06); corrFuncMultTanTheta.SetParameter(1, 1.220e-05); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, 7.89237e-05); corrFuncSigmaMult.SetParameter(1, -1.30662e-02); corrFuncSigmaMult.SetParameter(2, 8.91548e-01); corrFuncSigmaMult.SetParameter(3, 1.47931e-02); */ /* // LHC11a10a if (isNonPP) printf("Using corr Parameters for 11a10a\n!"); corrFuncMult.SetParameter(0, 6.90133e-06); corrFuncMult.SetParameter(1, -1.22123e-03); corrFuncMult.SetParameter(2, 1.80220e-02); corrFuncMult.SetParameter(3, 0.1); corrFuncMult.SetParameter(4, 6.45306e-03); corrFuncMultTanTheta.SetParameter(0, -2.85505e-07); corrFuncMultTanTheta.SetParameter(1, -1.31911e-06); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, -4.29665e-05); corrFuncSigmaMult.SetParameter(1, 1.37023e-02); corrFuncSigmaMult.SetParameter(2, -6.36337e-01); corrFuncSigmaMult.SetParameter(3, 1.13479e-02); */ /* OLD without saturation and large error for negative slopes corrFuncSigmaMult.SetParameter(0, -4.79684e-05); corrFuncSigmaMult.SetParameter(1, 1.49938e-02); corrFuncSigmaMult.SetParameter(2, -7.15269e-01); corrFuncSigmaMult.SetParameter(3, 1.06855e-02); */ /* OLD very good try, but with fewer pBins for the fitting corrFuncMult.SetParameter(0, 6.88365e-06); corrFuncMult.SetParameter(1, -1.22324e-03); corrFuncMult.SetParameter(2, 1.81625e-02); corrFuncMult.SetParameter(3, 0.1); corrFuncMult.SetParameter(4, 6.36890e-03); corrFuncMultTanTheta.SetParameter(0, -2.85505e-07); corrFuncMultTanTheta.SetParameter(1, -1.31911e-06); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, -4.28401e-05); corrFuncSigmaMult.SetParameter(1, 1.24812e-02); corrFuncSigmaMult.SetParameter(2, -5.28531e-01); corrFuncSigmaMult.SetParameter(3, 1.25147e-02); */ /*OLD good try corrFuncMult.SetParameter(0, 7.50321e-06); corrFuncMult.SetParameter(1, -1.25250e-03); corrFuncMult.SetParameter(2, 1.85437e-02); corrFuncMult.SetParameter(3, 0.1); corrFuncMult.SetParameter(4, 6.21192e-03); corrFuncMultTanTheta.SetParameter(0, -1.43112e-07); corrFuncMultTanTheta.SetParameter(1, -1.53e-06); corrFuncMultTanTheta.SetParameter(2, 0.3); corrFuncSigmaMult.SetParameter(0, -2.54019e-05); corrFuncSigmaMult.SetParameter(1, 8.68883e-03); corrFuncSigmaMult.SetParameter(2, -3.36176e-01); corrFuncSigmaMult.SetParameter(3, 1.29230e-02); */ /* // LHC10h.pass2 if (isNonPP) printf("Using corr Parameters for 10h.pass2\n!"); corrFuncMult.SetParameter(0, 3.21636e-07); corrFuncMult.SetParameter(1, -6.65876e-04); corrFuncMult.SetParameter(2, 1.28786e-03); corrFuncMult.SetParameter(3, 1.47677e-02); corrFuncMult.SetParameter(4, 0.); corrFuncMultTanTheta.SetParameter(0, 7.23591e-08); corrFuncMultTanTheta.SetParameter(1, 2.7469e-06); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, -1.22590e-05); corrFuncSigmaMult.SetParameter(1, 6.88888e-03); corrFuncSigmaMult.SetParameter(2, -3.20788e-01); corrFuncSigmaMult.SetParameter(3, 1.07345e-02); */ /*OLD bad try corrFuncMult.SetParameter(0, 2.71514e-07); corrFuncMult.SetParameter(1, -6.92031e-04); corrFuncMult.SetParameter(2, 3.56042e-03); corrFuncMult.SetParameter(3, 1.47497e-02); corrFuncMult.SetParameter(4, 0.); corrFuncMultTanTheta.SetParameter(0, 8.53204e-08); corrFuncMultTanTheta.SetParameter(1, 2.85591e-06); corrFuncMultTanTheta.SetParameter(2, -0.5); corrFuncSigmaMult.SetParameter(0, -6.82477e-06); corrFuncSigmaMult.SetParameter(1, 4.97051e-03); corrFuncSigmaMult.SetParameter(2, -1.64954e-01); corrFuncSigmaMult.SetParameter(3, 9.21061e-03); */ //TODO NOW TF1* fShapeSmallP = new TF1("fShapeSmallP", "pol5", -0.4, 0.4); fShapeSmallP->SetParameters(1.01712, -0.0202725, -0.260692, 0.261623, 0.671854, -1.14014); for (Long64_t i = 0; i < nTreeEntries; i++) { tree->GetEntry(i); if (dEdx <= 0 || dEdxExpected <= 0 || tpcSignalN <= 10) continue; /* Double_t pT = pTPC*TMath::Sin(-TMath::ATan(tanTheta)+TMath::Pi()/2.0); if ((phiPrime > 0.072/pT+TMath::Pi()/18.0-0.035 && phiPrime < 0.07/pT/pT+0.1/pT+TMath::Pi()/18.0+0.035)) continue; */ if (pidType != kMCid) { if (pidType == kTPCid && pTPC > 0.6) continue; if (pidType == kTPCandTOFid && (pTPC < 0.6 || pTPC > 2.0)) continue; if ((collType == 2) && pidType == kTPCandTOFid && pTPC > 1.0) continue;// Only V0's in case of PbPb above 1.0 GeV/c if (pidType == kV0idPlusTOFrejected) //TODO NOW NEW continue; } if (recalculateExpecteddEdx) { dEdxExpected = 50. * splPr->Eval(pTPC / massProton); //WARNING: What, if MIP is different from 50.? Seems not to be used (tested for pp, MC_pp, PbPb and MC_PbPb), but can in principle happen } //TODO NOW /* if (TMath::Abs(tanTheta) <= 0.4) { Double_t p0 = fShapeSmallP->Eval(tanTheta) - 1.0; // Strength of the correction Double_t p1 = -9.0; // How fast the correction is turned off Double_t p2 = -0.209; // Turn off correction around 0.2 GeV/c Double_t p3 = 1.0; // Delta' for large p should be 1 Double_t corrFactor = TMath::Erf((pTPC + p2) * p1) * p0 + p3 + p0; // Add p0 to have 1 for p3 = 1 and large pTPC dEdxExpected *= corrFactor; }*/ /*TODO old unsuccessful try Double_t thetaGlobalTPC = -TMath::ATan(tanTheta) + TMath::Pi() / 2.; Double_t pTtpc = pTPC * TMath::Sin(thetaGlobalTPC); Double_t pTtpcInv = (pTtpc > 0) ? 1. / pTtpc : 0; Double_t p0 = 1.0; Double_t p1 = 1./ 0.5;//TODO 2.0; Double_t p2 = -0.2;//TODO 0.1 Double_t pTcorrFactor = p0 + (pTtpcInv > p1) * p2 * (pTtpcInv - p1); dEdxExpected *= pTcorrFactor; */ // From the momentum (via dEdxExpected) and the tanTheta of the track, the expected dEdx can be calculated (correctedDeDxExpected). // If the splines are correct, this should give in average the same value as dEdx. // Now valid: Maps created from corrected data with splines adopted to corrected data, so lookup should be for dEdxExpected=dEdxSplines (no further // eta correction) or the corrected dEdx from the track (which should ideally be = dEdxSplines) // Tested with corrected data for LHC10d.pass2: using dEdx for the lookup (which is the corrected value and should ideally be = dEdxSplines): // Results almost the same. Maybe slightly better for dEdxExpected. // No longer valid: Note that the maps take always the uncorrected dEdx w.r.t. // tanTheta, so that correctedDeDxExpected is needed here normally. However, the information for the correction will be lost at some point. // Therefore, dEdxExpected can be used instead and should provide a good approximation. Double_t c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected)); Double_t expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN); Double_t pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected); // Fill pull histo hPull->Fill(pTPC, pull); Double_t tanThetaAbs = TMath::Abs(tanTheta); for (Int_t j = 0; j < nThetaHistos; j++) { if (tanThetaAbs >= tThetaLow[j] && tanThetaAbs < tThetaHigh[j]) { hPullTheta[j]->Fill(pTPC, pull); } } if (!hMap) continue; Double_t correctionFactor = 1.; if (isNonPP) { // 1. Correct eta dependence correctionFactor = hMap->GetBinContent(getBinX(hMap, tanTheta), getBinY(hMap, 1./dEdxExpected)); // 2. Correct for multiplicity dependence: Double_t multCorrectionFactor = 1.; if (fMultiplicity > 0) { Double_t relSlope = corrFuncMult.Eval(1. / (dEdxExpected * correctionFactor)); relSlope += corrFuncMultTanTheta.Eval(tanTheta); multCorrectionFactor = 1. + relSlope * fMultiplicity; } c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected)); // Multiplicity dependence of sigma depends on the real dEdx at zero multiplicity, i.e. the eta (only) corrected dEdxExpected value has to be used // since all maps etc. have been created for ~zero multiplicity Double_t relSigmaSlope = corrFuncSigmaMult.Eval(1. / (dEdxExpected * correctionFactor)); Double_t multSigmaCorrectionFactor = 1. + relSigmaSlope * fMultiplicity; dEdxExpected *= correctionFactor * multCorrectionFactor; expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN); expectedSigma *= multSigmaCorrectionFactor; pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected); } else { correctionFactor = hMap->GetBinContent(getBinX(hMap, tanTheta), getBinY(hMap, 1./dEdxExpected)); c1FromSigmaMap = hThetaMapSigmaPar1->GetBinContent(getBinX(hThetaMapSigmaPar1, tanTheta), getBinY(hThetaMapSigmaPar1, 1./dEdxExpected)); dEdxExpected *= correctionFactor; // If data is not corrected, but the sigma map is for corrected data, re-do analysis with corrected dEdx expectedSigma = dEdxExpected * TMath::Sqrt( c0 * c0 + (c1FromSigmaMap * c1FromSigmaMap) / tpcSignalN); pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected); } pull = (dEdx - dEdxExpected) / (plotPull ? expectedSigma: dEdxExpected); hPullAdditionalCorr->Fill(pTPC, pull); for (Int_t j = 0; j < nThetaHistos; j++) { if (tanThetaAbs >= tThetaLow[j] && tanThetaAbs < tThetaHigh[j]) { hPullAdditionalCorrTheta[j]->Fill(pTPC, pull); } } } /* // Mean, Sigma, chi^2/NDF of pull of different theta bins and all in one plot TCanvas* canvPullMean = new TCanvas("canvPullMean", "canvPullMean", 100,10,1380,800); canvPullMean->SetLogx(kTRUE); canvPullMean->SetGridx(kTRUE); canvPullMean->SetGridy(kTRUE); TCanvas* canvPullSigma = new TCanvas("canvPullSigma", "canvPullSigma", 100,10,1380,800); canvPullSigma->SetLogx(kTRUE); canvPullSigma->SetGridx(kTRUE); canvPullSigma->SetGridy(kTRUE); TCanvas* canvPullChi2 = new TCanvas("canvPullChi2", "canvPullChi2", 100,10,1380,800); canvPullChi2->SetLogx(kTRUE); canvPullChi2->SetGridx(kTRUE); canvPullChi2->SetGridy(kTRUE); TCanvas* canvPull[nThetaHistos + 1]; for (Int_t i = 0, j = nThetaHistos; i < nThetaHistos + 1; i++, j--) { canvPull[i] = new TCanvas(Form("canvPull_%d", i), "canvPull", 100,10,1380,800); canvPull[i]->cd(); canvPull[i]->SetLogx(kTRUE); canvPull[i]->SetLogz(kTRUE); canvPull[i]->SetGrid(kTRUE, kTRUE); TH2D* hTemp = 0x0; TString thetaString = ""; if (i == nThetaHistos) { hTemp = hPull; thetaString = "tan(#Theta) integrated"; } else { hTemp = hPullTheta[i]; thetaString = Form("%.2f #leq |tan(#Theta)| < %.2f", tThetaLow[i], tThetaHigh[i]); } normaliseHisto(hTemp); hTemp->FitSlicesY(); hTemp->GetYaxis()->SetNdivisions(12); hTemp->GetXaxis()->SetMoreLogLabels(kTRUE); TH1D* hTempMean = (TH1D*)gDirectory->Get(Form("%s_1", hTemp->GetName())); hTempMean->SetTitle(Form("mean(pull), %s", thetaString.Data())); hTempMean->GetXaxis()->SetMoreLogLabels(kTRUE); hTempMean->SetLineWidth(2); hTempMean->SetMarkerStyle(20); TH1D* hTempSigma = (TH1D*)gDirectory->Get(Form("%s_2", hTemp->GetName())); hTempSigma->SetTitle(Form("#sigma(pull), %s", thetaString.Data())); hTempSigma->GetXaxis()->SetMoreLogLabels(kTRUE); hTempSigma->SetLineColor(kMagenta); hTempSigma->SetMarkerStyle(20); hTempSigma->SetMarkerColor(kMagenta); hTempSigma->SetLineWidth(2); TH1D* hTempChi2 = (TH1D*)gDirectory->Get(Form("%s_chi2", hTemp->GetName())); hTempChi2->SetTitle(Form("#chi^{2} / NDF (pull), %s", thetaString.Data())); hTempChi2->GetXaxis()->SetMoreLogLabels(kTRUE); hTempChi2->SetLineColor(kMagenta + 2); hTempChi2->SetMarkerStyle(20); hTempChi2->SetMarkerColor(kMagenta + 2); hTempChi2->SetLineWidth(2); hTemp->DrawCopy("colz"); hTempMean->DrawCopy("same"); hTempSigma->DrawCopy("same"); hTempChi2->Scale(-1./10.); hTempChi2->DrawCopy("same"); hTempChi2->Scale(-10.); canvPullMean->cd(); hTempMean->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempMean->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempMean->DrawCopy((i == 0 ? "" : "same")); canvPullSigma->cd(); hTempSigma->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempSigma->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempSigma->DrawCopy((i == 0 ? "" : "same")); canvPullChi2->cd(); hTempChi2->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempChi2->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempChi2->DrawCopy((i == 0 ? "" : "same")); } canvPullMean->BuildLegend(); canvPullSigma->BuildLegend(); canvPullChi2->BuildLegend(); */ // Histograms with additional correction TCanvas* canvPullMeanCorr = 0x0; TCanvas* canvPullSigmaCorr = 0x0; TCanvas* canvPullChi2Corr = 0x0; TCanvas* canvPullCorr[nThetaHistos + 1]; for (Int_t i = 0; i < nThetaHistos + 1; i++) canvPullCorr[i] = 0x0; if (hMap) { // Mean, Sigma, chi^2/NDF of pull of different theta bins and all in one plot canvPullMeanCorr = new TCanvas("canvPullMeanCorr", "canvPullMeanCorr", 100,10,1380,800); canvPullMeanCorr->SetLogx(kTRUE); canvPullMeanCorr->SetGridx(kTRUE); canvPullMeanCorr->SetGridy(kTRUE); canvPullSigmaCorr = new TCanvas("canvPullSigmaCorr", "canvPullSigmaCorr", 100,10,1380,800); canvPullSigmaCorr->SetLogx(kTRUE); canvPullSigmaCorr->SetGridx(kTRUE); canvPullSigmaCorr->SetGridy(kTRUE); canvPullChi2Corr = new TCanvas("canvPullChi2Corr", "canvPullChi2Corr", 100,10,1380,800); canvPullChi2Corr->SetLogx(kTRUE); canvPullChi2Corr->SetGridx(kTRUE); canvPullChi2Corr->SetGridy(kTRUE); for (Int_t i = 0, j = nThetaHistos; i < nThetaHistos + 1; i++, j--) { canvPullCorr[i] = new TCanvas(Form("canvPullCorr_%d", i), "canvPullCorr", 100,10,1380,800); canvPullCorr[i]->cd(); canvPullCorr[i]->SetLogx(kTRUE); canvPullCorr[i]->SetLogz(kTRUE); canvPullCorr[i]->SetGrid(kTRUE, kTRUE); TH2D* hTemp = 0x0; TString thetaString = ""; if (i == nThetaHistos) { hTemp = hPullAdditionalCorr; thetaString = "tan(#Theta) integrated"; } else { hTemp = hPullAdditionalCorrTheta[i]; thetaString = Form("%.2f #leq |tan(#Theta)| < %.2f", tThetaLow[i], tThetaHigh[i]); } normaliseHisto(hTemp); hTemp->FitSlicesY(); hTemp->GetYaxis()->SetNdivisions(12); hTemp->GetXaxis()->SetMoreLogLabels(kTRUE); TH1D* hTempMean = (TH1D*)gDirectory->Get(Form("%s_1", hTemp->GetName())); hTempMean->SetTitle(Form("mean(pull), %s", thetaString.Data())); hTempMean->GetXaxis()->SetMoreLogLabels(kTRUE); hTempMean->SetLineWidth(2); hTempMean->SetMarkerStyle(20); TH1D* hTempSigma = (TH1D*)gDirectory->Get(Form("%s_2", hTemp->GetName())); hTempSigma->SetTitle(Form("#sigma(pull), %s", thetaString.Data())); hTempSigma->GetXaxis()->SetMoreLogLabels(kTRUE); hTempSigma->SetLineColor(kMagenta); hTempSigma->SetMarkerStyle(20); hTempSigma->SetMarkerColor(kMagenta); hTempSigma->SetLineWidth(2); TH1D* hTempChi2 = (TH1D*)gDirectory->Get(Form("%s_chi2", hTemp->GetName())); hTempChi2->SetTitle(Form("#chi^{2} / NDF (pull), %s", thetaString.Data())); hTempChi2->GetXaxis()->SetMoreLogLabels(kTRUE); hTempChi2->SetLineColor(kMagenta + 2); hTempChi2->SetMarkerStyle(20); hTempChi2->SetMarkerColor(kMagenta + 2); hTempChi2->SetLineWidth(2); hTemp->DrawCopy("colz"); hTempMean->DrawCopy("same"); hTempSigma->DrawCopy("same"); hTempChi2->Scale(-1./10.); hTempChi2->DrawCopy("same"); hTempChi2->Scale(-10.); canvPullMeanCorr->cd(); hTempMean->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempMean->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempMean->DrawCopy((i == 0 ? "" : "same")); canvPullSigmaCorr->cd(); hTempSigma->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempSigma->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempSigma->DrawCopy((i == 0 ? "" : "same")); canvPullChi2Corr->cd(); hTempChi2->SetLineColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempChi2->SetMarkerColor(1 + ((j >= 9) ? (39 + 2 * (j - 9)) : j)); hTempChi2->DrawCopy((i == 0 ? "" : "same")); } canvPullMeanCorr->BuildLegend(); canvPullSigmaCorr->BuildLegend(); canvPullChi2Corr->BuildLegend(); } fSave->cd(); /*canvPullMean->Write(); canvPullSigma->Write(); canvPullChi2->Write(); for (Int_t i = 0; i < nThetaHistos + 1; i++) { canvPull[i]->Write(); }*/ canvPullMeanCorr->Write(); canvPullSigmaCorr->Write(); canvPullChi2Corr->Write(); for (Int_t i = 0; i < nThetaHistos + 1; i++) { canvPullCorr[i]->Write(); } TNamed* info = new TNamed(Form("Theta map: %s\n\nSigma map: %s\n\nSplines file: %s\n\nSplines name: %s", pathNameThetaMap.Data(), pathNameSigmaMap.Data(), pathNameSplinesFile.Data(), prSplinesName.Data()), "info"); info->Write(); fSave->Close(); return 0; }
void centralityCalibrationRD(TString inHiForestFileName, TString outFileName) { TFile *outFile = new TFile(outFileName,"RECREATE"); TFile *inFile = TFile::Open(inHiForestFileName); TTree *fEvtTree = (TTree*)inFile->Get("hiEvtAnalyzer/HiTree"); TTree *fSkimTree = (TTree*)inFile->Get("skimanalysis/HltTree"); TTree *l1Tree = (TTree*)inFile->Get("UnpackerResults/L1UpgradeTree"); TTree *hltTree = (TTree*)inFile->Get("hltanalysis/HltTree"); TFile *inFileCen = new TFile("/data/yilmaz/centrality2015/friendly_centrality_HiForest_Streamer_run262315.root"); TTree* tcen = (TTree*)inFileCen->Get("anaCentrality"); l1Tree->AddFriend(tcen); Int_t l1_event, l1_run, l1_lumi; vector<int> *legacyregion_et; vector<int> *legacyregion_gctEta; vector<int> *legacyregion_bx; TBranch *b_legacyregion_et; //! TBranch *b_legacyregion_gctEta; //! TBranch *b_legacyregion_bx; //! Int_t HLT_HIL1MinimumBiasHF1AND_v1; // Int_t L1_Centrality_ext0_100_HFplusANDminusTH0; hltTree->SetBranchAddress("HLT_HIL1MinimumBiasHF1AND_v1",&HLT_HIL1MinimumBiasHF1AND_v1); // hltTree->SetBranchAddress("L1_Centrality_ext0_100_HFplusANDminusTH0",&L1_Centrality_ext0_100_HFplusORminusTH0); Int_t f_evt, f_run, f_lumi,f_phfCoincFilter3; Float_t vz; Int_t hiBin; float hiHF; legacyregion_et=0; legacyregion_gctEta=0; legacyregion_bx=0; l1Tree->SetBranchAddress("event",&l1_event); l1Tree->SetBranchAddress("run",&l1_run); l1Tree->SetBranchAddress("lumi",&l1_lumi); l1Tree->SetBranchAddress("legacyregion_et", &legacyregion_et, &b_legacyregion_et); l1Tree->SetBranchAddress("legacyregion_gctEta", &legacyregion_gctEta, &b_legacyregion_gctEta); l1Tree->SetBranchAddress("legacyregion_bx", &legacyregion_bx, &b_legacyregion_bx); l1Tree->SetBranchAddress("anaBin",&hiBin); fSkimTree->SetBranchAddress("phfCoincFilter3",&f_phfCoincFilter3); fEvtTree->SetBranchAddress("evt",&f_evt); fEvtTree->SetBranchAddress("run",&f_run); fEvtTree->SetBranchAddress("lumi",&f_lumi); fEvtTree->SetBranchAddress("vz",&vz); //fEvtTree->SetBranchAddress("hiBin",&hiBin); fEvtTree->SetBranchAddress("hiHF",&hiHF); Int_t pcollisionEventSelection; //Int_t pHBHENoiseFilterResultProducer; pcollisionEventSelection = 1; //pHBHENoiseFilterResultProducer = 1; //fSkimTree->SetBranchAddress("pcollisionEventSelection",&pcollisionEventSelection); //fSkimTree->SetBranchAddress("pHBHENoiseFilterResultProducer",&pHBHENoiseFilterResultProducer); TH2D *hcorrl1EtsumPlusVscorrl1EtsumMinus = new TH2D("hcorrl1EtsumPlusVscorrl1EtsumMinus","L1 EtsumPlus vs L1 EtsumMinus; L1 EtsumMinus ; L1 EtsumPlus",100,0,9000,100,0,9000); TH2D *hcorrl1EtsumPlusVscorrl1EtsumMinusNoEvSel = new TH2D("hcorrl1EtsumPlusVscorrl1EtsumMinusNoEvSel","L1 EtsumPlus vs L1 EtsumMinus; L1 EtsumMinus ; L1 EtsumPlus",100,0,9000,100,0,9000); TH2D *hcorrl1EtsumVsofflineCentrality = new TH2D("hcorrl1EtsumVsofflineCentrality","L1 Etsum vs offline centrality; offline centrality ; L1 Etsum",100,0,200,100,0,9000); TH2D *hcorrofflineCentralityVsl1Etsum = new TH2D("hcorrofflineCentralityVsl1Etsum","Offline centrality vs L1 Etsum; L1 Etsum ; offline centrality",100,0,9000,100,0,200); TH2D *hcorrL1CentralityVsfflineCentrality = new TH2D("hcorrL1CentralityVsfflineCentrality","Online centrality vs offline centrality; L1 Etsum ; offline centrality",200,0,200,200,0,200); TH1D *hofflineCentrality = new TH1D("hofflineCentrality","Offline cent; Offline centrality; Entries",40,0.,200.); TH1D *hl1Etsum = new TH1D("hl1Etsum","L1 Etsum ; L1 Etsum; Entries ",40,0.,9000.); TH1D *hofflineEtsum = new TH1D("hofflineEtsum","Offline Etsum ; Offline Etsum; Entries ",40,0.,9000.); TH2D *hcorrOfflineEtsumVsL1Etsum = new TH2D("hcorrOfflineEtsumVsL1Etsum","Offline Etsum vs L1 Etsum; Offline Etsum; L1 Etsum",100,0.,9000.,100,0.,9000.); TProfile *profilel1EtsumVsofflineCentrality = new TProfile("profilel1EtsumVsofflineCentrality","L1 Etsum vs offline centrality; offline centrality ; L1 Etsum",100,0,200,0,9000); TProfile *profileofflineCentralityVsl1Etsum = new TProfile("profileofflineCentralityVsl1Etsum","Offline centrality vs L1 Etsum; L1 Etsum ; offline centrality",400,0,9000,0,200); TProfile *profileofflineCentralityVsl1Etsum_Calibration = new TProfile("profileofflineCentralityVsl1Etsum_Calibration","Offline centrality vs L1 Etsum; L1 Etsum ; offline centrality",200,0,9000,0,200); TProfile *profilel1EtsumVsofflineCentrality_Calibration = new TProfile("profilel1EtsumVsofflineCentrality_Calibration","Offline centrality vs L1 Etsum; L1 Etsum ; offline centrality",50,0,200,0,9000); TProfile *profilel1CentralityVsofflineCentrality = new TProfile("profilel1CentralityVsofflineCentrality","L1 centrality vs Offline Centrality; Offline Centrality ; L1 centrality",100,0,200,0,200); TH1D *fCenOffline = new TH1D("fCenOffline",";Offline Centrality",nBins,0,maxCen); TH1D *hOffline[NBINSCentrality]; for(int i = 0; i < NBINSCentrality; ++i){ hOffline[i]= new TH1D(Form("hOffline_Bin%d",i),Form("hOffline_Bin%d; Offline Centrality; Entries",i),220,-10,210); } TH1D *accepted[12]; for(int i = 0; i < 12; ++i){ accepted[i]= new TH1D(Form("accepted_cen%d",(int)(L1_THRESHOLD[i])),"",nBins,0,maxCen); } int countCalib = 0; Long64_t entries = l1Tree->GetEntries(); //Long64_t entries=10000; for(Long64_t j = 0; j < entries; ++j) { if(j % 10000 == 0) printf("%lld / %lld\n",j,entries); // Only use good collision events ******** fEvtTree->GetEntry(j); fSkimTree->GetEntry(j); l1Tree->GetEntry(j); hltTree->GetEntry(j); bool goodEvent = false; if((HLT_HIL1MinimumBiasHF1AND_v1==1 &&pcollisionEventSelection == 1 && f_phfCoincFilter3==1) && (TMath::Abs(vz) < 15)) //if((HLT_HIL1MinimumBiasHF1AND_v1==1 &&pcollisionEventSelection == 1) && (TMath::Abs(vz) < 15)) { goodEvent = true; } if(!goodEvent) continue; int etsum=0; int l1_etsumPlus=0; int l1_etsumMinus=0; int maxsizevector=legacyregion_gctEta->size(); for (int i=0;i<maxsizevector; i++){ if(legacyregion_bx->at(i)==0){ if (legacyregion_gctEta->at(i)<=3) l1_etsumPlus=l1_etsumPlus+legacyregion_et->at(i); if (legacyregion_gctEta->at(i)>=18) l1_etsumMinus=l1_etsumMinus+legacyregion_et->at(i); } } etsum=l1_etsumPlus+l1_etsumMinus; //std::cout<<"etsum="<<etsum<<std::endl; //std::cout<<"l1_etsumPlus="<<l1_etsumPlus<<std::endl; //std::cout<<"l1_etsumMinus="<<l1_etsumMinus<<std::endl; profileofflineCentralityVsl1Etsum_Calibration->Fill(etsum,hiBin); profilel1EtsumVsofflineCentrality_Calibration->Fill(hiBin,etsum); countCalib++; } //************** second loop ************** TF1 *fprofileofflineCentralityVsl1Etsum_Calibration = new TF1("fprofileofflineCentralityVsl1Etsum_Calibration","pol9",0,3500); profileofflineCentralityVsl1Etsum_Calibration->Fit("fprofileofflineCentralityVsl1Etsum_Calibration"); TF1 *fprofileofflinel1EtsumVsCentrality_Calibration = new TF1("fprofileofflinel1EtsumVsCentrality_Calibration","pol9",0,7000); profilel1EtsumVsofflineCentrality_Calibration->Fit("fprofileofflinel1EtsumVsCentrality_Calibration"); printf("Matching entries: %d\n",countCalib); double L1centrality=0.; for(Long64_t j = 0; j < entries; ++j) { if(j % 10000 == 0) printf("%lld / %lld\n",j,entries); // Only use good collision events ******** fEvtTree->GetEntry(j); fSkimTree->GetEntry(j); l1Tree->GetEntry(j); hltTree->GetEntry(j); bool goodEvent = false; if((HLT_HIL1MinimumBiasHF1AND_v1==1 &&pcollisionEventSelection == 1 && f_phfCoincFilter3==1) && (TMath::Abs(vz) < 15)) //if((HLT_HIL1MinimumBiasHF1AND_v1==1 &&pcollisionEventSelection == 1) && (TMath::Abs(vz) < 15)) { goodEvent = true; } if(!goodEvent) continue; int etsum=0; int l1_etsumPlus=0; int l1_etsumMinus=0; int maxsizevector2=legacyregion_gctEta->size(); for (int i=0;i<maxsizevector2; i++){ if(legacyregion_bx->at(i)==0){ if (legacyregion_gctEta->at(i)<=3) l1_etsumPlus=l1_etsumPlus+legacyregion_et->at(i); if (legacyregion_gctEta->at(i)>=18) l1_etsumMinus=l1_etsumMinus+legacyregion_et->at(i); } } etsum=l1_etsumPlus+l1_etsumMinus; //printf("et value %d\n",etsum); //printf("hiBin %d\n",hiBin); //printf("hiHF %f\n",hiHF); hcorrl1EtsumPlusVscorrl1EtsumMinus->Fill(l1_etsumMinus,l1_etsumPlus); hcorrl1EtsumVsofflineCentrality->Fill(hiBin,etsum); hcorrofflineCentralityVsl1Etsum->Fill(etsum,hiBin); hofflineCentrality->Fill(hiBin); hl1Etsum->Fill(etsum); hofflineEtsum->Fill(hiHF); hcorrOfflineEtsumVsL1Etsum->Fill(hiHF,etsum); profileofflineCentralityVsl1Etsum->Fill(etsum,hiBin); profilel1EtsumVsofflineCentrality->Fill(hiBin,etsum); //L1centrality=fprofileofflineCentralityVsl1Etsum_Calibration->Eval(etsum); L1centrality=fprofileofflinel1EtsumVsCentrality_Calibration->GetX(etsum); //printf("L1centrality %f\n",L1centrality); hcorrL1CentralityVsfflineCentrality->Fill(hiBin,L1centrality); profilel1CentralityVsofflineCentrality->Fill(hiBin,L1centrality); double Etsum_Bin[10]; double newResLimit[10]; for (int j=0; j<10;j++){ if (j==0 || (j%2)==0){ newResLimit[j]=limit[j]+deltaC[j]; } else {newResLimit[j]=limit[j]-deltaC[j];} Etsum_Bin[j]=fprofileofflinel1EtsumVsCentrality_Calibration->Eval((double)(newResLimit[j])); //std::cout<< "etSum = " << Etsum_Bin[j] << endl; } if(etsum>Etsum_Bin[0]) {hOffline[0]->Fill(hiBin);} if(etsum>Etsum_Bin[2] && etsum<Etsum_Bin[1]) {hOffline[1]->Fill(hiBin);} if(etsum>Etsum_Bin[4] && etsum<Etsum_Bin[3]) {hOffline[2]->Fill(hiBin);} if(etsum>Etsum_Bin[6] && etsum<Etsum_Bin[5]) {hOffline[3]->Fill(hiBin);} if(etsum>Etsum_Bin[8] && etsum<Etsum_Bin[7]) {hOffline[4]->Fill(hiBin);} if(etsum<Etsum_Bin[9]) {hOffline[5]->Fill(hiBin);} fCenOffline->Fill(hiBin); for(int k = 0; k < 12; ++k){ if(L1centrality>L1_THRESHOLD[k]){ accepted[k]->Fill(hiBin); } } } outFile->cd(); hcorrl1EtsumPlusVscorrl1EtsumMinus->Write(); hcorrl1EtsumPlusVscorrl1EtsumMinusNoEvSel->Write(); hcorrl1EtsumVsofflineCentrality->Write(); hcorrofflineCentralityVsl1Etsum->Write(); hofflineCentrality->Write(); hl1Etsum->Write(); hofflineEtsum->Write(); hcorrOfflineEtsumVsL1Etsum->Write(); profilel1EtsumVsofflineCentrality->Write(); profileofflineCentralityVsl1Etsum->Write(); profileofflineCentralityVsl1Etsum_Calibration->Write(); fprofileofflineCentralityVsl1Etsum_Calibration->SetName("fprofileofflineCentralityVsl1Etsum_Calibration"); fprofileofflineCentralityVsl1Etsum_Calibration->Write(); fprofileofflinel1EtsumVsCentrality_Calibration->SetName("fprofileofflinel1EtsumVsCentrality_Calibration"); fprofileofflinel1EtsumVsCentrality_Calibration->Write(); hcorrL1CentralityVsfflineCentrality->Write(); profilel1CentralityVsofflineCentrality->Write(); profilel1EtsumVsofflineCentrality_Calibration->Write(); for(int i = 0; i < NBINSCentrality; ++i){ hOffline[i]->Write(); } TGraphAsymmErrors *a[12]; for(int k = 0; k < 12; ++k){ a[k] = new TGraphAsymmErrors(); a[k]->BayesDivide(accepted[k],fCenOffline); a[k]->SetName(Form("asymm_cen_%d_cen",(int)(L1_THRESHOLD[k]))); } fCenOffline->Write(); for(int k = 0; k < 12; ++k){ accepted[k]->Write(); a[k]->Write(); } outFile->Close(); }
void mk_tree(const char * acc_file="datfiles/acc.dat") { // read acc file into tree TTree * acc = new TTree("acc","counts tree from acc.dat"); char cols[2048]; char bbc_cols[256]; char zdc_cols[256]; char vpd_cols[256]; for(Int_t i=0; i<=7; i++) { if(i==0) { sprintf(bbc_cols,"bbc_%d/D",i); sprintf(zdc_cols,"zdc_%d/D",i); sprintf(vpd_cols,"vpd_%d/D",i); } else { sprintf(bbc_cols,"%s:bbc_%d/D",bbc_cols,i); sprintf(zdc_cols,"%s:zdc_%d/D",zdc_cols,i); sprintf(vpd_cols,"%s:vpd_%d/D",vpd_cols,i); }; }; sprintf(cols,"i/I:runnum/I:fi/I:fill/I:t/D:bx/I:%s:%s:%s:tot_bx/D:blue/I:yell/I",bbc_cols,zdc_cols,vpd_cols); printf("%s\n",cols); acc->ReadFile(acc_file,cols); acc->Print(); Int_t IMAX_tmp = acc->GetMaximum("i"); const Int_t IMAX = IMAX_tmp; // set branch addresses to read through acc tree Int_t index,runnum,fill_index,fill,bx; Double_t bbc[8]; Double_t zdc[8]; Double_t vpd[8]; Double_t time; Double_t tot_bx; Int_t blue,yell; acc->SetBranchAddress("i",&index); acc->SetBranchAddress("runnum",&runnum); acc->SetBranchAddress("fi",&fill_index); acc->SetBranchAddress("fill",&fill); acc->SetBranchAddress("t",&time); acc->SetBranchAddress("bx",&bx); char str[16]; for(Int_t i=0; i<8; i++) { sprintf(str,"bbc_%d",i); acc->SetBranchAddress(str,&bbc[i]); }; for(Int_t i=0; i<8; i++) { sprintf(str,"zdc_%d",i); acc->SetBranchAddress(str,&zdc[i]); }; for(Int_t i=0; i<8; i++) { sprintf(str,"vpd_%d",i); acc->SetBranchAddress(str,&vpd[i]); }; acc->SetBranchAddress("tot_bx",&tot_bx); acc->SetBranchAddress("blue",&blue); acc->SetBranchAddress("yell",&yell); // build arrays for restructuring; arrays are needed so that // we can implement bXing shift corrections Double_t bbce_arr[IMAX][120]; Double_t bbcw_arr[IMAX][120]; Double_t bbcx_arr[IMAX][120]; Double_t zdce_arr[IMAX][120]; Double_t zdcw_arr[IMAX][120]; Double_t zdcx_arr[IMAX][120]; Double_t vpde_arr[IMAX][120]; Double_t vpdw_arr[IMAX][120]; Double_t vpdx_arr[IMAX][120]; Int_t runnum_arr[IMAX]; Int_t fi_arr[IMAX]; Int_t fill_arr[IMAX]; Double_t time_arr[IMAX]; Double_t tot_bx_arr[IMAX][120]; Int_t blue_arr[IMAX][120]; Int_t yell_arr[IMAX][120]; Bool_t kicked_arr[IMAX][120]; // restructure tree into one suitable for analysis TTree * sca = new TTree("sca","restructured tree"); Double_t bbce,bbcw,bbcx; // e=east, w=west, x=coincidence Double_t zdce,zdcw,zdcx; Double_t vpde,vpdw,vpdx; Bool_t okEntry,kicked; sca->Branch("i",&index,"i/I"); sca->Branch("runnum",&runnum,"runnum/I"); sca->Branch("fi",&fill_index,"fi/I"); sca->Branch("fill",&fill,"fill/I"); sca->Branch("t",&time,"t/D"); sca->Branch("bx",&bx,"bx/I"); sca->Branch("bbce",&bbce,"bbce/D"); sca->Branch("bbcw",&bbcw,"bbcw/D"); sca->Branch("bbcx",&bbcx,"bbcx/D"); sca->Branch("zdce",&zdce,"zdce/D"); sca->Branch("zdcw",&zdcw,"zdcw/D"); sca->Branch("zdcx",&zdcx,"zdcx/D"); sca->Branch("vpde",&vpde,"vpde/D"); sca->Branch("vpdw",&vpdw,"vpdw/D"); sca->Branch("vpdx",&vpdx,"vpdx/D"); sca->Branch("tot_bx",&tot_bx,"tot_bx/D"); sca->Branch("blue",&blue,"blue/I"); sca->Branch("yell",&yell,"yell/I"); sca->Branch("kicked",&kicked,"kicked/O"); // read kicked bunches tree from "kicked" file TTree * kicked_tr = new TTree(); kicked_tr->ReadFile("kicked","fill/I:bx/I:spinbit/I"); Int_t kicked_fill,kicked_bx,kicked_spinbit; kicked_tr->SetBranchAddress("fill",&kicked_fill); kicked_tr->SetBranchAddress("bx",&kicked_bx); kicked_tr->SetBranchAddress("spinbit",&kicked_spinbit); for(Int_t q=0; q<acc->GetEntries(); q++) { acc->GetEntry(q); // -- see doc for bit details // BBC, ZDC, VPD bits: [ x w e ] bbce = bbc[1] + bbc[3] + bbc[5] + bbc[7]; // e + we + xe + xwe bbcw = bbc[2] + bbc[3] + bbc[6] + bbc[7]; // w + we + xw + xwe bbcx = bbc[3] + bbc[7]; // we + xwe zdce = zdc[1] + zdc[3] + zdc[5] + zdc[7]; // e + we + xe + xwe zdcw = zdc[2] + zdc[3] + zdc[6] + zdc[7]; // w + we + xw + xwe zdcx = zdc[3] + zdc[7]; // we + xwe vpde = vpd[1] + vpd[3] + vpd[5] + vpd[7]; // e + we + xe + xwe vpdw = vpd[2] + vpd[3] + vpd[6] + vpd[7]; // w + we + xw + xwe vpdx = vpd[3] + vpd[7]; // we + xwe // KICKED BUNCHES // manually omit empty bunches documented in pathologies.dat -- CLEAN UP PROCEDURE // (see 09.01.14 log entry) okEntry=true; // kicked bunches (presumably empty) /* if(fill==17384 && (bx==29 || bx==30 || bx==117)) okEntry=false; if(fill==17416 && bx==79) okEntry=false; if(fill==17491 && bx==105) okEntry=false; if(fill==17519 && (bx==94 || bx==109)) okEntry=false; if(fill==17520 && bx==0) okEntry=false; if(fill==17529 && bx==97) okEntry=false; if(fill==17534 && bx==112) okEntry=false; if(fill==17553 && bx==73) okEntry=false; if(fill==17554 && (bx==7 || bx==14)) okEntry=false; if(fill==17555 && bx==61) okEntry=false; if(fill==17576 && bx==94) okEntry=false; // afterpulse-like bunches -- remove 1st 2 bunches after abort gaps //if(fill==17512 && (bx>=40 && bx<=59)) okEntry=false; //if((fill>=17513 && fill<=17520) && ((bx>=0 && bx<=19) || (bx>=40 && bx<=59))) okEntry=false; */ for(Int_t kk=0; kk<kicked_tr->GetEntries(); kk++) { kicked_tr->GetEntry(kk); if(fill==kicked_fill && bx==kicked_bx) okEntry=false; }; kicked=!okEntry; // cleaned up analysis //kicked=0; // take all bXings // store data into arrays, implementing bXing shift corrections on scalers if(fill==16570 || fill==16567) { bbce_arr[index-1][(bx+113)%120] = bbce; // shift down 7 bXings bbcw_arr[index-1][(bx+113)%120] = bbcw; bbcx_arr[index-1][(bx+113)%120] = bbcx; zdce_arr[index-1][(bx+113)%120] = zdce; // shift down 7 bXings zdcw_arr[index-1][(bx+113)%120] = zdcw; zdcx_arr[index-1][(bx+113)%120] = zdcx; vpde_arr[index-1][(bx+113)%120] = vpde; // shift down 7 bXings vpdw_arr[index-1][(bx+113)%120] = vpdw; vpdx_arr[index-1][(bx+113)%120] = vpdx; } else if(fill == 16582 || fill == 16586 || fill == 16587 || fill == 16592 || fill == 16593 || fill == 16594 || fill == 16597 || fill == 16602) { bbce_arr[index-1][bx] = bbce; // no shift bbcw_arr[index-1][bx] = bbcw; bbcx_arr[index-1][bx] = bbcx; zdce_arr[index-1][bx] = zdce; // no shift zdcw_arr[index-1][bx] = zdcw; zdcx_arr[index-1][bx] = zdcx; vpde_arr[index-1][(bx+1)%120] = vpde; // shift up 1 bXings vpdw_arr[index-1][(bx+1)%120] = vpdw; vpdx_arr[index-1][(bx+1)%120] = vpdx; } else { bbce_arr[index-1][bx] = bbce; bbcw_arr[index-1][bx] = bbcw; bbcx_arr[index-1][bx] = bbcx; zdce_arr[index-1][bx] = zdce; zdcw_arr[index-1][bx] = zdcw; zdcx_arr[index-1][bx] = zdcx; vpde_arr[index-1][bx] = vpde; vpdw_arr[index-1][bx] = vpdw; vpdx_arr[index-1][bx] = vpdx; }; runnum_arr[index-1] = runnum; fi_arr[index-1] = fill_index; fill_arr[index-1] = fill; time_arr[index-1] = time; tot_bx_arr[index-1][bx] = tot_bx; blue_arr[index-1][bx] = blue; yell_arr[index-1][bx] = yell; kicked_arr[index-1][bx] = kicked; }; // fill restructured tree for(Int_t i=0; i<IMAX; i++) { index = i+1; runnum = runnum_arr[i]; fill_index = fi_arr[i]; fill = fill_arr[i]; time = time_arr[i]; for(Int_t b=0; b<120; b++) { bx = b; bbce = bbce_arr[i][b]; bbcw = bbcw_arr[i][b]; bbcx = bbcx_arr[i][b]; zdce = zdce_arr[i][b]; zdcw = zdcw_arr[i][b]; zdcx = zdcx_arr[i][b]; vpde = vpde_arr[i][b]; vpdw = vpdw_arr[i][b]; vpdx = vpdx_arr[i][b]; tot_bx = tot_bx_arr[i][b]; blue = blue_arr[i][b]; yell = yell_arr[i][b]; kicked = kicked_arr[i][b]; sca->Fill(); }; }; TFile * outfile = new TFile("counts.root","RECREATE"); acc->Write("acc"); sca->Write("sca"); printf("counts.root written\n"); };
void DrawCosmicResult(){ TFile* tf = new TFile("Cosmic3Out.root"); TTree* trin = (TTree*)tf->Get("trOut"); const int nCSI = 2716; Int_t RunNumber; Int_t EventNumber; Double_t ScintiSignal = 0; Double_t ScintiHHTime = -500.; Double_t ScintiTime =-500.; Int_t nCSIDigi = 0; Double_t CSIDigiE[nCSI];//nCSIDigi Double_t CSIDigiTime[nCSI];//nCSIDigi Double_t CSIDigiHHTime[nCSI];//nCSIDigi Int_t CSIDigiID[nCSI];//nCSIDigi Double_t CSIDigiSignal[nCSI];//nCSIDigi Double_t FitP0[2]; Double_t FitP1[2]; Double_t FitChisq[2]; Double_t CSIDigiDeltaT0[nCSI];//nCSIDigi Double_t CSIDigiDeltaT1[nCSI];//nCSIDigi Int_t CosmicTrigUp; Int_t CosmicTrigDn; Double_t Roh; Double_t Theta; trin->SetBranchAddress( "RunNumber" , &RunNumber ); trin->SetBranchAddress( "EventNumber" , &EventNumber ); trin->SetBranchAddress( "ScintiSignal" , &ScintiSignal ); trin->SetBranchAddress( "ScintiHHTimne" , &ScintiHHTime ); trin->SetBranchAddress( "ScintiTime" , &ScintiTime ); trin->SetBranchAddress( "nCSIDigi" , &nCSIDigi ); trin->SetBranchAddress( "CSIDigiE" , CSIDigiE ); trin->SetBranchAddress( "CSIDigiTime" , CSIDigiTime ); trin->SetBranchAddress( "CSIDigiHHTime" , CSIDigiHHTime ); trin->SetBranchAddress( "CSIDigiID" , CSIDigiID ); trin->SetBranchAddress( "CSIDigiSignal" , CSIDigiSignal ); trin->SetBranchAddress( "CSIDigiDeltaT0" , CSIDigiDeltaT0 ); trin->SetBranchAddress( "CSIDigiDeltaT1" , CSIDigiDeltaT1 ); trin->SetBranchAddress( "FitP0" , FitP0 ); trin->SetBranchAddress( "FitP1" , FitP1 ); trin->SetBranchAddress( "FitChisq" , FitChisq ); trin->SetBranchAddress( "CosmicTrigUp" , &CosmicTrigUp ); trin->SetBranchAddress( "CosmicTrigDn" , &CosmicTrigDn ); trin->SetBranchAddress( "Roh" , &Roh ); trin->SetBranchAddress( "Theta" , &Theta ); TFile* tfout = new TFile("CosmicOut_hist3.root", "recreate"); TH2D* hisDeltaChannel = new TH2D("hisDeltaChannel","hisDeltaChannel",2716,0,2716,100,-10,10); TH1D* hisDelta[2716]; TGraphErrors* grDelta = new TGraphErrors(); TGraphErrors* grRES = new TGraphErrors(); TCanvas *can = new TCanvas("can","",800,800); for( int i = 0; i< 2716; i++){ hisDelta[i] = new TH1D(Form("hisDelta%d",i ),Form("hisDelta%d",i),100,-10,10); } for( int ievent = 0; ievent < trin->GetEntries(); ievent++){ trin->GetEntry(ievent); for( int idigi = 0; idigi < nCSIDigi ; idigi++){ hisDelta[ CSIDigiID[ idigi ] ]->Fill( CSIDigiDeltaT1[ idigi ] ); hisDeltaChannel->Fill( CSIDigiID[ idigi ] , CSIDigiDeltaT1[ idigi ] ); //std::cout << CSIDigiID[ idigi ] << std::endl; } } for( int i = 0; i< 2716; i++){ //std::cout << hisDelta[i]->GetEntries() << std::endl; if( hisDelta[i]->GetEntries() > 10){ int rst = hisDelta[i]->Fit("gaus","Q","",hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() ) - 3, hisDelta[i]->GetBinCenter( hisDelta[i]->GetMaximumBin() )+3); TF1* func = NULL; func = hisDelta[i]->GetFunction("gaus"); if( func != NULL ){ grDelta->SetPoint( grDelta->GetN(), i, func->GetParameter(1)); grDelta->SetPointError( grDelta->GetN()-1, 0, func->GetParError(2)); grRES->SetPoint( grRES->GetN() , i , func->GetParameter(2)); } } /* hisDelta[i]->Draw(); can->Modified(); can->Update(); getchar(); */ hisDelta[ i ] ->Write(); } std::ofstream ofs("TimeResolutionCosmic3.dat"); int ID[2716]; double Delta[2716]; double Resolution[2716]; for( int i = 0; i< 2716; i++){ Resolution[i] = 0xFFFF; Delta[i] = 0xFFFF; } for( int i = 0; i< grRES->GetN(); i++){ Delta[(int)(grDelta->GetX()[i])] = grDelta->GetY()[i]; Resolution[(int)(grRES->GetX()[i])] = grRES->GetY()[i] ; } for( int i = 0; i< 2716; i++){ ofs << i << "\t" << Delta[i] << "\t" << Resolution[i] << "\n"; } grDelta->SetNameTitle("grDelta","grDelta"); grRES->SetNameTitle("grRES","grRES"); grDelta->Write(); grRES->Write(); hisDeltaChannel->Write(); tfout->Close(); ofs.close(); }
void cutFlowStudyMu( TString weightFile = "TMVAClassificationPtOrd_qqH115vsWZttQCD_Cuts.weights.xml", Double_t effS_ = 0.3) { ofstream out("cutFlow-MuTauStream.txt"); out.precision(4); TMVA::Tools::Instance(); TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" ); Float_t pt1, pt2; Float_t Deta, Mjj; Float_t eta1,eta2; reader->AddVariable( "pt1", &pt1); reader->AddVariable( "pt2", &pt2); reader->AddVariable( "Deta",&Deta); reader->AddVariable( "Mjj", &Mjj); reader->AddSpectator("eta1",&eta1); reader->AddSpectator("eta2",&eta2); reader->BookMVA( "Cuts", TString("/home/llr/cms/lbianchini/CMSSW_3_9_9/src/Bianchi/TauTauStudies/test/Macro/weights/")+weightFile ); TFile *fFullSignalVBF = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_VBFH115-Mu-powheg-PUS1.root","READ"); TFile *fFullSignalGGH = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_GGFH115-Mu-powheg-PUS1.root","READ"); TFile *fFullBackgroundDYTauTau = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DYToTauTau-Mu-20-PUS1.root","READ"); TFile *fFullBackgroundDYMuMu = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DYToMuMu-20-PUS1.root","READ"); TFile *fFullBackgroundWJets = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_WJets-Mu-madgraph-PUS1.root","READ"); TFile *fFullBackgroundQCD = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_QCDmu.root","READ"); TFile *fFullBackgroundTTbar = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_TTJets-Mu-madgraph-PUS1.root","READ"); TFile *fFullBackgroundDiBoson = new TFile("/data_CMS/cms/lbianchini//MuTauStream2011/treeMuTauStream_DiBoson-Mu.root","READ"); // OpenNTuples TString fSignalNameVBF = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleVBFH115-Mu-powheg-PUS1_Open_MuTauStream.root"; TString fSignalNameGGH = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleGGFH115-Mu-powheg-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDYTauTau = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDYToTauTau-Mu-20-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDYMuMu = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDYToMuMu-20-PUS1_Open_MuTauStream.root"; TString fBackgroundNameWJets = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleWJets-Mu-madgraph-PUS1_Open_MuTauStream.root"; TString fBackgroundNameQCD = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleQCDmu_Open_MuTauStream.root"; TString fBackgroundNameTTbar = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleTTJets-Mu-madgraph-PUS1_Open_MuTauStream.root"; TString fBackgroundNameDiBoson = "/data_CMS/cms/lbianchini/VbfJetsStudy/OpenNtuples/MuTauStream2011/v2/nTupleDiBoson-Mu_Open_MuTauStream.root"; TFile *fSignalVBF(0); TFile *fSignalGGH(0); TFile *fBackgroundDYTauTau(0); TFile *fBackgroundDYMuMu(0); TFile *fBackgroundWJets(0); TFile *fBackgroundQCD(0); TFile *fBackgroundTTbar(0); TFile *fBackgroundDiBoson(0); fSignalVBF = TFile::Open( fSignalNameVBF ); fSignalGGH = TFile::Open( fSignalNameGGH ); fBackgroundDYTauTau = TFile::Open( fBackgroundNameDYTauTau ); fBackgroundDYMuMu = TFile::Open( fBackgroundNameDYMuMu ); fBackgroundWJets = TFile::Open( fBackgroundNameWJets ); fBackgroundQCD = TFile::Open( fBackgroundNameQCD ); fBackgroundTTbar = TFile::Open( fBackgroundNameTTbar ); fBackgroundDiBoson = TFile::Open( fBackgroundNameDiBoson ); if(!fSignalVBF || !fBackgroundDYTauTau || !fBackgroundWJets || !fBackgroundQCD || !fBackgroundTTbar || !fSignalGGH || !fBackgroundDYMuMu || !fBackgroundDiBoson ){ std::cout << "ERROR: could not open files" << std::endl; exit(1); } TString tree = "outTreePtOrd"; TTree *signalVBF = (TTree*)fSignalVBF->Get(tree); TTree *signalGGH = (TTree*)fSignalGGH->Get(tree); TTree *backgroundDYTauTau = (TTree*)fBackgroundDYTauTau->Get(tree); TTree *backgroundDYMuMu = (TTree*)fBackgroundDYMuMu->Get(tree); TTree *backgroundWJets = (TTree*)fBackgroundWJets->Get(tree); TTree *backgroundQCD = (TTree*)fBackgroundQCD->Get(tree); TTree *backgroundTTbar = (TTree*)fBackgroundTTbar->Get(tree); TTree *backgroundDiBoson = (TTree*)fBackgroundDiBoson->Get(tree); // here I define the map between a sample name and its tree std::map<std::string,TTree*> tMap; tMap["ggH115"]=signalGGH; tMap["qqH115"]=signalVBF; tMap["Ztautau"]=backgroundDYTauTau; tMap["Zmumu"]=backgroundDYMuMu; tMap["Wjets"]=backgroundWJets; tMap["QCD"]=backgroundQCD; tMap["TTbar"]=backgroundTTbar; tMap["DiBoson"]=backgroundDiBoson; std::map<std::string,TTree*>::iterator jt; Float_t pt1_, pt2_; Float_t Deta_, Mjj_; Float_t Dphi,diTauSVFitPt,diTauSVFitEta,diTauVisMass,diTauSVFitMass,ptL1,ptL2,etaL1,etaL2,diTauCharge,MtLeg1,numPV,combRelIsoLeg1,sampleWeight,ptVeto,HLT; Int_t tightestHPSWP; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// // here I choose the order in the stack std::vector<string> samples; samples.push_back("ggH115"); samples.push_back("qqH115"); samples.push_back("DiBoson"); samples.push_back("TTbar"); samples.push_back("Wjets"); samples.push_back("Zmumu"); samples.push_back("Ztautau"); samples.push_back("QCD"); std::map<std::string,float> crossSec; crossSec["ggH115"]=( 7.65e-02 * 18.13 ); crossSec["qqH115"]=( 0.1012); crossSec["DiBoson"]=( -1 ); crossSec["TTbar"]=( 157.5 ); crossSec["Wjets"]=( 31314.0); crossSec["Zmumu"]=( 1666 ); crossSec["Ztautau"]=( 1666 ); crossSec["QCD"]=( 296600000*0.0002855 ); float Lumi = 1000; // here I choose the order in the stack std::vector<string> filters; filters.push_back("total"); filters.push_back("vertex"); filters.push_back("1-mu"); filters.push_back("0-e"); filters.push_back("mu-ID"); filters.push_back("tau-ID"); filters.push_back("Delta R mu-tau"); filters.push_back("mu-iso"); filters.push_back("tau-iso"); filters.push_back("Mt"); filters.push_back("OS"); filters.push_back("2-jets"); filters.push_back("VBF cuts"); filters.push_back("jet-veto"); filters.push_back("HLT"); // here I define the map between a sample name and its file ptr std::map<std::string,TFile*> fullMap; fullMap["ggH115"] = fFullSignalGGH; fullMap["qqH115"] = fFullSignalVBF; fullMap["Ztautau"] = fFullBackgroundDYTauTau; fullMap["Zmumu"] = fFullBackgroundDYMuMu; fullMap["Wjets"] = fFullBackgroundWJets; fullMap["QCD"] = fFullBackgroundQCD; fullMap["TTbar"] = fFullBackgroundTTbar; fullMap["DiBoson"] = fFullBackgroundDiBoson; std::map<std::string,TFile*>::iterator it; std::map<std::string,float> cutMap_allEventsFilter; std::map<std::string,float> cutMap_allEventsFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); float tot = totalEvents; if(crossSec[it->first]>0) tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; cutMap_allEventsFilter[it->first] = tot; cutMap_allEventsFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_vertexScrapingFilter; std::map<std::string,float> cutMap_vertexScrapingFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("vertexScrapingFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_vertexScrapingFilter[it->first] = tot; cutMap_vertexScrapingFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_oneElectronFilter; std::map<std::string,float> cutMap_oneElectronFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("oneMuonFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_oneElectronFilter[it->first] = tot; cutMap_oneElectronFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_noMuonFilter; std::map<std::string,float> cutMap_noMuonFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("noElecFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_noMuonFilter[it->first] = tot; cutMap_noMuonFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_electronLegFilter; std::map<std::string,float> cutMap_electronLegFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("muonLegFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_electronLegFilter[it->first] = tot; cutMap_electronLegFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_tauLegFilter; std::map<std::string,float> cutMap_tauLegFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("tauLegFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_tauLegFilter[it->first] = tot; cutMap_tauLegFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_atLeastOneDiTauFilter; std::map<std::string,float> cutMap_atLeastOneDiTauFilterE; for(it = fullMap.begin(); it != fullMap.end(); it++){ TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); allEvents = (TH1F*)(it->second)->Get("atLeastOneDiTauFilter/totalEvents"); float tot = allEvents->GetBinContent(1); float totalEquivalentEvents = allEvents->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_atLeastOneDiTauFilter[it->first] = tot; cutMap_atLeastOneDiTauFilterE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; } std::map<std::string,float> cutMap_ElecIso; std::map<std::string,float> cutMap_ElecIsoE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_ElecIso[it->first] = tot; cutMap_ElecIsoE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_TauIso; std::map<std::string,float> cutMap_TauIsoE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_TauIso[it->first] = tot; cutMap_TauIsoE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_Mt; std::map<std::string,float> cutMap_MtE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && MtLeg1<40" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && MtLeg1<40)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_Mt[it->first] = tot; cutMap_MtE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_OS; std::map<std::string,float> cutMap_OSE; for(it = fullMap.begin(); it != fullMap.end(); it++){ cout<<it->first<<endl; TH1F* allEvents = (TH1F*)(it->second)->Get("allEventsFilter/totalEvents"); float totalEvents = allEvents->GetBinContent(1); TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = (crossSec[it->first]>0) ? "(chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40" : "weight*((chIsoLeg1+nhIsoLeg1+phIsoLeg1)/diTauLegsP4[0].Pt()<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; ((TTree*) (it->second->Get("muTauStreamAnalyzer/tree")) )->Draw("diTauLegsP4[0].Eta()>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); if(crossSec[it->first]>0){ tot *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; //totalEquivalentEvents *= (Lumi/ (totalEvents/crossSec[it->first]) ) ; } cutMap_OS[it->first] = tot; cutMap_OSE[it->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_VBFPre; std::map<std::string,float> cutMap_VBFPreE; for(jt = tMap.begin(); jt != tMap.end(); jt++){ cout<<jt->first<<endl; TH1F* h1 = new TH1F("h1","",1,-10,10); TCut cut = "sampleWeight*(pt1>0 && combRelIsoLeg1<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; jt->second->Draw("etaL1>>h1",cut); float tot = h1->Integral(); float totalEquivalentEvents = h1->GetEffectiveEntries(); cutMap_VBFPre[jt->first] = tot; cutMap_VBFPreE[jt->first] = totalEquivalentEvents>0 ? sqrt(totalEquivalentEvents)*(tot/totalEquivalentEvents) : 0; delete h1; } std::map<std::string,float> cutMap_VBF; std::map<std::string,float> cutMap_VBFE; std::map<std::string,float> cutMap_JetVeto; std::map<std::string,float> cutMap_JetVetoE; std::map<std::string,float> cutMap_HLT; std::map<std::string,float> cutMap_HLTE; for(jt = tMap.begin(); jt != tMap.end(); jt++){ cout<<jt->first<<endl; TCut cut = "(pt1>0 && combRelIsoLeg1<0.1 && tightestHPSWP>0 && diTauCharge==0 && MtLeg1<40)"; TFile* dummy = new TFile("dummy.root","RECREATE"); TTree* currentTree = (TTree*)(jt->second)->CopyTree(cut); float tot = 0; int counter = 0; float tot2 = 0; int counter2 = 0; float tot3 = 0; int counter3 = 0; currentTree->SetBranchAddress( "pt1", &pt1_ ); currentTree->SetBranchAddress( "pt2", &pt2_ ); currentTree->SetBranchAddress( "Deta",&Deta_ ); currentTree->SetBranchAddress( "Mjj", &Mjj_ ); currentTree->SetBranchAddress( "diTauSVFitPt",&diTauSVFitPt); //currentTree->SetBranchAddress( "diTauSVFitEta",&diTauSVFitEta); currentTree->SetBranchAddress( "diTauSVFitMass",&diTauSVFitMass); currentTree->SetBranchAddress( "diTauVisMass",&diTauVisMass); currentTree->SetBranchAddress( "ptL1", &ptL1 ); currentTree->SetBranchAddress( "ptL2", &ptL2 ); currentTree->SetBranchAddress( "etaL1", &etaL1 ); currentTree->SetBranchAddress( "etaL2", &etaL2 ); currentTree->SetBranchAddress( "combRelIsoLeg1",&combRelIsoLeg1); currentTree->SetBranchAddress( "tightestHPSWP",&tightestHPSWP); currentTree->SetBranchAddress( "diTauCharge",&diTauCharge); currentTree->SetBranchAddress( "MtLeg1",&MtLeg1); currentTree->SetBranchAddress( "numPV",&numPV); currentTree->SetBranchAddress( "sampleWeight",&sampleWeight); currentTree->SetBranchAddress( "ptVeto",&ptVeto); currentTree->SetBranchAddress( "HLT",&HLT); for (Long64_t ievt=0; ievt<currentTree->GetEntries();ievt++) { currentTree->GetEntry(ievt); if (ievt%10000 == 0){ std::cout << (jt->first) << " ---> processing event: " << ievt << " ..." <<std::endl; } pt1 = pt1_; pt2 = pt2_; Deta = Deta_; Mjj = Mjj_; bool pass = effS_>0 ? reader->EvaluateMVA( "Cuts", effS_ ) : (pt1>0); if(pass){ tot+=sampleWeight; counter++; if(ptVeto<20){ tot2+=sampleWeight; counter2++; if(HLT>0.5 && HLT<1.5){ tot3+=sampleWeight; counter3++; } } } }// end loop cutMap_VBF[jt->first] = tot; cutMap_VBFE[jt->first] = counter>0 ? sqrt(counter)*tot/counter : 0; cutMap_JetVeto[jt->first] = tot2; cutMap_JetVetoE[jt->first] = counter2>0 ? sqrt(counter2)*tot2/counter2 : 0; cutMap_HLT[jt->first] = tot3; cutMap_HLTE[jt->first] = counter3>0 ? sqrt(counter3)*tot3/counter3 : 0; } std::vector< std::map<std::string,float> > allFilters; allFilters.push_back(cutMap_allEventsFilter); allFilters.push_back(cutMap_vertexScrapingFilter); allFilters.push_back(cutMap_oneElectronFilter); allFilters.push_back(cutMap_noMuonFilter); allFilters.push_back(cutMap_electronLegFilter); allFilters.push_back(cutMap_tauLegFilter); allFilters.push_back(cutMap_atLeastOneDiTauFilter); allFilters.push_back(cutMap_ElecIso); allFilters.push_back(cutMap_TauIso); allFilters.push_back(cutMap_Mt); allFilters.push_back(cutMap_OS); allFilters.push_back(cutMap_VBFPre); allFilters.push_back(cutMap_VBF); allFilters.push_back(cutMap_JetVeto); allFilters.push_back(cutMap_HLT); std::vector< std::map<std::string,float> > allFiltersE; allFiltersE.push_back(cutMap_allEventsFilterE); allFiltersE.push_back(cutMap_vertexScrapingFilterE); allFiltersE.push_back(cutMap_oneElectronFilterE); allFiltersE.push_back(cutMap_noMuonFilterE); allFiltersE.push_back(cutMap_electronLegFilterE); allFiltersE.push_back(cutMap_tauLegFilterE); allFiltersE.push_back(cutMap_atLeastOneDiTauFilterE); allFiltersE.push_back(cutMap_ElecIsoE); allFiltersE.push_back(cutMap_TauIsoE); allFiltersE.push_back(cutMap_MtE); allFiltersE.push_back(cutMap_OSE); allFiltersE.push_back(cutMap_VBFPreE); allFiltersE.push_back(cutMap_VBFE); allFiltersE.push_back(cutMap_JetVetoE); allFiltersE.push_back(cutMap_HLTE); //out<<"\\begin{center}"<<endl; out<<"\\begin{tabular}[!htbp]{|c"; for(int k = 0 ; k < samples.size(); k++) out<<"|c"; out<<"|} \\hline"<<endl; out<< "Cut & "; for(int k = 0 ; k < samples.size(); k++){ out << (fullMap.find(samples[k]))->first; if(k!=samples.size()-1) out <<" & " ; else out << " \\\\ " << endl; } out << " \\hline" << endl; for(int i = 0; i < allFilters.size(); i++){ out << filters[i] << " & "; for(int k = 0 ; k < samples.size(); k++){ out << (allFilters[i].find(samples[k]))->second << " $\\pm$ " << (allFiltersE[i].find(samples[k]))->second; if(k!=samples.size()-1) out <<" & " ; else out << " \\\\ " << endl; } out << " \\hline" << endl; } out<<"\\end{tabular}"<<endl; //out<<"\\end{center}"<<endl; return; }
void MCCTRapDep() { for(int iSpec = 0; iSpec < 3; iSpec++){ int Prompt =1; int PutWeight = 1; bool bDefault = true; // true : cowboy only, false : salior bool bCowboy = false; // true : cowboy only, false : salior bool bSailor = false; // true : cowboy only, false : salior double fake_v2 = 0.3; // iSpec : choose the condition for default/cowboy/sailor if(iSpec == 0) {bDefault = true;bCowboy = false;bSailor = false;} if(iSpec == 1) {bDefault = false;bCowboy = true;bSailor = false;} if(iSpec == 2) {bDefault = false;bCowboy = false;bSailor = true;} char cCond[512]; int iCond = 0; // the number of the cases, 1 : default, 2 : cowboy, 3 : sailor if(bDefault) {sprintf(cCond, "default"); iCond = 0;} if(bCowboy) {sprintf(cCond, "cowboy"); iCond = 1;} if(bSailor) {sprintf(cCond, "sailor"); iCond = 2;} // iCat : decide the categories for Rapidity (1: 0.0 - 1.2, 2: 1.2 - 1.6, 3: 1.6 - 2.4) for(int iCat = 0; iCat < 4; iCat++){ gROOT->SetStyle("Plain"); gStyle->SetPalette(1); gStyle->SetFrameBorderMode(0); gStyle->SetFrameFillColor(0); gStyle->SetCanvasColor(0); gStyle->SetTitleFillColor(0); gStyle->SetStatColor(0); gStyle->SetPadBorderSize(0); gStyle->SetCanvasBorderSize(0); gStyle->SetOptTitle(0); // at least most of the time gStyle->SetOptStat("emri"); gStyle->SetOptFit(1); // set to 1 only if you want to display fit results //==================================== Define Histograms==================================================== char OutTextFile[100]; if(iCat == 0) sprintf(OutTextFile,"MCCT_PrJpsi_Raps_0012_dPhi_%s.tex", cCond); if(iCat == 1) sprintf(OutTextFile,"MCCT_PrJpsi_Raps_1216_dPhi_%s.tex", cCond); if(iCat == 2) sprintf(OutTextFile,"MCCT_PrJpsi_Raps_1624H_dPhi_%s.tex", cCond); if(iCat == 3) sprintf(OutTextFile,"MCCT_PrJpsi_Raps_1624L_dPhi_%s.tex", cCond); ofstream dataFile(Form(OutTextFile)); TH1D *diMuonsInvMass_Gen = new TH1D("diMuonsInvMass_Gen","diMuonsInvMass_Gen", 100,2.98,3.16); TH1D *diMuonsPt_Gen = new TH1D("diMuonsPt_Gen","diMuonsPt_Gen", 100,0,50); TH1D *Bin_Gen = new TH1D("Bin_Gen","Bin_Gen", 40,0,40); //==============================================Define Acc Eff Stuff here=========================================== // Pt bin sizes // 0-1.5, 1.5-3, 3-4.5, 4.5-6, 6-7.5... const int nFiles = 6; const int ndPhiBins = 4; double dphi_bound[100] = {0}; dphi_bound[0] = 0.0; dphi_bound[1] = TMath::Pi()*2/16; dphi_bound[2] = TMath::Pi()*4/16; dphi_bound[3] = TMath::Pi()*6/16; dphi_bound[4] = TMath::Pi()*8/16; //X Axis error on Eff graph double xdphi_bound[ndPhiBins] = {0.0}; for(int i = 0; i < ndPhiBins; i++){ xdphi_bound[i] = dphi_bound[i] + (dphi_bound[i+1]-dphi_bound[i])/2; cout<<"xdphi_bound["<<i<<"] : "<<xdphi_bound[i]<<endl; dataFile<<"xdphi_bound["<<i<<"] : "<<xdphi_bound[i]<<endl; } double mom_err[ndPhiBins] = {0.0}; double genError, recError; double gen_pt[100]={0}, gen_ptError[100]={0}; double rec_pt[100]={0}, rec_ptError[100]={0}; double Eff_cat_1[100]={0},Err_Eff_cat_1[100]={0}; // Histogram 2D Arrays TH1D *diMuonsInvMass_GenA[10][1000]; TH1D *diMuonsInvMass_RecA[10][1000]; TH1D *diMuonsPt_GenA[10][1000]; TH1D *diMuonsPt_RecA[10][1000]; char nameGen[10][500], nameRec[10][500], nameGenPt[10][500], nameRecPt[10][500]; char namePt_1B[500];//for bkg func for (int ifile = 0; ifile < nFiles; ifile++) { for (Int_t idphi = 0; idphi < ndPhiBins; idphi++) { sprintf(nameGen[ifile],"DiMuonMassGen_pt_%d_%d_%d",ifile,iCat,idphi); sprintf(nameRec[ifile],"DiMuonMassRec_pt_%d_%d_%d",ifile,iCat,idphi); sprintf(nameGenPt[ifile],"DiMuonPtGen_pt_%d_%d_%d",ifile,iCat,idphi); sprintf(nameRecPt[ifile],"DiMuonPtRec_pt_%d_%d_%d",ifile,iCat,idphi); diMuonsInvMass_GenA[ifile][idphi]= new TH1D(nameGen[ifile],nameGen[ifile], 100,2.98,3.16); //for eff Gen; diMuonsInvMass_GenA[ifile][idphi]->Sumw2(); diMuonsInvMass_GenA[ifile][idphi]->SetMarkerStyle(7); diMuonsInvMass_GenA[ifile][idphi]->SetMarkerColor(4); diMuonsInvMass_GenA[ifile][idphi]->SetLineColor(4); diMuonsInvMass_RecA[ifile][idphi] = new TH1D(nameRec[ifile],nameRec[ifile], 100,2.98,3.16); //for eff Rec; diMuonsInvMass_RecA[ifile][idphi]->Sumw2(); diMuonsInvMass_RecA[ifile][idphi]->SetMarkerStyle(8); diMuonsInvMass_RecA[ifile][idphi]->SetMarkerColor(4); diMuonsInvMass_RecA[ifile][idphi]->SetLineColor(4); diMuonsPt_GenA[ifile][idphi]= new TH1D(nameGenPt[ifile],nameGenPt[ifile], 100,0,40); //for eff Gen; diMuonsPt_RecA[ifile][idphi]= new TH1D(nameRecPt[ifile],nameRecPt[ifile], 100,0,40); //for eff Rec; } } //===========================================Input Root File============================================================ char fileName[10][500]; //scales for different pT bins double scale[10]={0}; scale[0]=2.35829e-07; scale[1]=1.99854e-07; scale[2]=4.48263e-08; scale[3]=1.01144e-08; scale[4]=4.89604e-09; scale[5]=2.62102e-09; if(PutWeight==0){scale[0]=(1);scale[1]=(1);scale[2]=(1);scale[3]=(1);scale[4]=(1);scale[5]=(1);} if(Prompt ==1){ cout<<"==================Prompt PrJpsi================================================"<<endl; sprintf(fileName[0],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt0003_total.root"); sprintf(fileName[1],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt0306_total.root"); sprintf(fileName[2],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt0609_total.root"); sprintf(fileName[3],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt0912_total.root"); sprintf(fileName[4],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt1215_total.root"); sprintf(fileName[5],"/Users/donghomoon/Analysis/2011HIRData/2011JpsiV2/20111126_Jpsi_Psi/EffCorrection/JpsiEff_New_0329_NewBins_3DEff/0430_4Deff_lowPt_With_dPhi_JpsiGenPsi_HighPt/gRpRootFiles/DiMuonTTree_PromptJpsi_Pt1530_total.root"); //sprintf(fileName[6],"../RootFiles/DiMuonTTree_PromptJpsi_Pt30XX_total.root"); } TFile *infile; TTree *tree; TTree *gentree; //====================== File loop Starts ============================ for(int ifile = 0; ifile < nFiles; ifile++){ infile=new TFile(fileName[ifile],"R"); tree=(TTree*)infile->Get("SingleMuonTree"); gentree=(TTree*)infile->Get("SingleGenMuonTree"); //Event variables int eventNb,runNb,lumiBlock, gbin, rbin; //Jpsi Variables Double_t JpsiMass,JpsiPt,JpsiRap, JpsiCharge; Double_t JpsiVprob; Double_t JpsiPhi; Double_t JpsiEta; Double_t JpsiPsi[38]; Double_t JpsiGenPsi; //2.) muon variables RECO double muPosPx, muPosPy, muPosPz, muPosEta, muPosPt,muPosP, muPosPhi; double muNegPx, muNegPy, muNegPz, muNegEta, muNegPt,muNegP, muNegPhi; //(1).Positive Muon double muPos_nchi2In, muPos_dxy, muPos_dz, muPos_nchi2Gl; int muPos_found, muPos_pixeLayers, muPos_nValidMuHits,muPos_arbitrated; bool muPos_matches,muPos_tracker; //(2).Negative Muon double muNeg_nchi2In, muNeg_dxy, muNeg_dz, muNeg_nchi2Gl; int muNeg_found, muNeg_pixeLayers, muNeg_nValidMuHits,muNeg_arbitrated; bool muNeg_matches,muNeg_tracker; //Gen Level variables //Gen PrJpsi Variables double GenJpsiMass, GenJpsiPt, GenJpsiRap; double GenJpsiPx, GenJpsiPy, GenJpsiPz; double GenJpsiPhi; double GenJpsiEta; double GenJpsiPsi; //2.) Gen muon variables double GenmuPosPx, GenmuPosPy, GenmuPosPz, GenmuPosEta, GenmuPosPt, GenmuPosPhi; double GenmuNegPx, GenmuNegPy, GenmuNegPz, GenmuNegEta, GenmuNegPt, GenmuNegPhi; // HLTrigger int hbit1; //Event variables tree->SetBranchAddress("eventNb",&eventNb); tree->SetBranchAddress("runNb",&runNb); tree->SetBranchAddress("lumiBlock",&lumiBlock); tree->SetBranchAddress("hbit1",&hbit1); //Jpsi Variables tree->SetBranchAddress("JpsiCharge",&JpsiCharge); tree->SetBranchAddress("JpsiMass",&JpsiMass); tree->SetBranchAddress("JpsiPt",&JpsiPt); tree->SetBranchAddress("JpsiPhi",&JpsiPhi); tree->SetBranchAddress("JpsiEta",&JpsiEta); tree->SetBranchAddress("JpsiPsi",&JpsiPsi); tree->SetBranchAddress("JpsiGenPsi",&JpsiGenPsi); //tree->SetBranchAddress("JpsiPsi",&JpsiPsi[38]); tree->SetBranchAddress("JpsiRap",&JpsiRap); tree->SetBranchAddress("JpsiVprob",&JpsiVprob); tree->SetBranchAddress("rbin",&rbin); //muon variable tree->SetBranchAddress("muPosPx",&muPosPx); tree->SetBranchAddress("muPosPy",&muPosPy); tree->SetBranchAddress("muPosPz",&muPosPz); tree->SetBranchAddress("muPosEta",&muPosEta); tree->SetBranchAddress("muPosPhi",&muPosPhi); tree->SetBranchAddress("muNegPx", &muNegPx); tree->SetBranchAddress("muNegPy", &muNegPy); tree->SetBranchAddress("muNegPz", &muNegPz); tree->SetBranchAddress("muNegEta", &muNegEta); tree->SetBranchAddress("muNegPhi", &muNegPhi); //1). Positive Muon tree->SetBranchAddress("muPos_nchi2In", &muPos_nchi2In); tree->SetBranchAddress("muPos_dxy", &muPos_dxy); tree->SetBranchAddress("muPos_dz", &muPos_dz); tree->SetBranchAddress("muPos_nchi2Gl", &muPos_nchi2Gl); tree->SetBranchAddress("muPos_found", &muPos_found); tree->SetBranchAddress("muPos_pixeLayers", &muPos_pixeLayers); tree->SetBranchAddress("muPos_nValidMuHits", &muPos_nValidMuHits); tree->SetBranchAddress("muPos_matches", &muPos_matches); tree->SetBranchAddress("muPos_tracker", &muPos_tracker); tree->SetBranchAddress("muPos_arbitrated", &muPos_arbitrated); //2). Negative Muon tree->SetBranchAddress("muNeg_nchi2In", &muNeg_nchi2In); tree->SetBranchAddress("muNeg_dxy", &muNeg_dxy); tree->SetBranchAddress("muNeg_dz", &muNeg_dz); tree->SetBranchAddress("muNeg_nchi2Gl", &muNeg_nchi2Gl); tree->SetBranchAddress("muNeg_found", &muNeg_found); tree->SetBranchAddress("muNeg_pixeLayers", &muNeg_pixeLayers); tree->SetBranchAddress("muNeg_nValidMuHits", &muNeg_nValidMuHits); tree->SetBranchAddress("muNeg_matches", &muNeg_matches); tree->SetBranchAddress("muNeg_tracker", &muNeg_tracker); tree->SetBranchAddress("muNeg_arbitrated", &muNeg_arbitrated); //====================================Gen Variables========================================================= //Gen Jpsi Variables gentree->SetBranchAddress("GenJpsiMass", &GenJpsiMass); gentree->SetBranchAddress("GenJpsiPt", &GenJpsiPt); gentree->SetBranchAddress("GenJpsiPhi", &GenJpsiPhi); gentree->SetBranchAddress("GenJpsiEta", &GenJpsiEta); gentree->SetBranchAddress("GenJpsiPsi", &GenJpsiPsi); gentree->SetBranchAddress("GenJpsiRap", &GenJpsiRap); gentree->SetBranchAddress("GenJpsiPx", &GenJpsiPx); gentree->SetBranchAddress("GenJpsiPy", &GenJpsiPy); gentree->SetBranchAddress("GenJpsiPz", &GenJpsiPz); gentree->SetBranchAddress("gbin",&gbin); //muon variable gentree->SetBranchAddress("GenmuPosPx", &GenmuPosPx); gentree->SetBranchAddress("GenmuPosPy", &GenmuPosPy); gentree->SetBranchAddress("GenmuPosPz", &GenmuPosPz); gentree->SetBranchAddress("GenmuPosEta", &GenmuPosEta); gentree->SetBranchAddress("GenmuPosPhi", &GenmuPosPhi); gentree->SetBranchAddress("GenmuNegPx", &GenmuNegPx); gentree->SetBranchAddress("GenmuNegPy", &GenmuNegPy); gentree->SetBranchAddress("GenmuNegPz", &GenmuNegPz); gentree->SetBranchAddress("GenmuNegEta", &GenmuNegEta); gentree->SetBranchAddress("GenmuNegPhi", &GenmuNegPhi); //====================================================== Gen tree loop ================================================ int NAccep=0; int nGenEntries=gentree->GetEntries(); cout<<" Total Entries in GenLevel Tree for pT range: "<<fileName[ifile]<<" "<< nGenEntries<< " ==============="<<endl; for(int i=0; i< nGenEntries; i++) { gentree->GetEntry(i); //Only printing if(i%100000==0){ //cout<<" processing record "<<i<<"/"<<nGenEntries<<endl; //cout<<" Mass "<< GenJpsiMass<< " pT "<< GenJpsiPt << " Y " <<GenJpsiRap<<endl; } //if(GenJpsiPt < 6.5) continue; bool GenPosIn=0, GenNegIn=0; GenmuPosPt= TMath::Sqrt(GenmuPosPx*GenmuPosPx + GenmuPosPy*GenmuPosPy); GenmuNegPt= TMath::Sqrt(GenmuNegPx*GenmuNegPx + GenmuNegPy*GenmuNegPy); diMuonsInvMass_Gen->Fill(GenJpsiMass); diMuonsPt_Gen->Fill(GenJpsiPt); if(IsAccept(GenmuPosPt, GenmuPosEta)) {GenPosIn=1;} if(IsAccept(GenmuNegPt, GenmuNegEta)) {GenNegIn=1;} int AccHighPtJpsi = 0; int AccLowPtJpsi = 0; if(GenJpsiPt >= 6.5 && fabs(GenJpsiRap) < 2.4 && GenPosIn == 1 && GenNegIn == 1) AccHighPtJpsi = 1; if(GenJpsiPt < 6.5 && GenJpsiPt >= 3.0 && fabs(GenJpsiRap) >= 1.6 && fabs(GenJpsiRap) < 2.4 && GenPosIn == 1 && GenNegIn == 1) AccLowPtJpsi = 1; double gdPhi2mu = GenmuPosPhi - GenmuNegPhi; while (gdPhi2mu > TMath::Pi()) gdPhi2mu -= 2*TMath::Pi(); while (gdPhi2mu <= -TMath::Pi()) gdPhi2mu += 2*TMath::Pi(); double gchkCowboy = 1*gdPhi2mu; if(bCowboy && !(gchkCowboy > 0.)) continue; if(bSailor && (gchkCowboy > 0.)) continue; if((GenPosIn ==1 && GenNegIn==1)) NAccep++; Bin_Gen->Fill(gbin); double GenCenWeight =0, GenWeight =0; GenCenWeight=FindCenWeight(gbin); double gJpsidPhi = TMath::Abs(GenJpsiPsi); double gmean_dphi = TMath::Pi()/16; if (gJpsidPhi>TMath::Pi()/8) gmean_dphi = 3*TMath::Pi()/16; if (gJpsidPhi>TMath::Pi()/4) gmean_dphi = 5*TMath::Pi()/16; if (gJpsidPhi>3*TMath::Pi()/8) gmean_dphi = 7*TMath::Pi()/16; GenWeight=GenCenWeight*scale[ifile]*(2.0/TMath::Pi()*(1+2*fake_v2*cos(2*gJpsidPhi)*TMath::Gaus(GenJpsiPt,15,4,0))); if(PutWeight==0) GenWeight=1; for (Int_t idphi = 0; idphi < ndPhiBins; idphi++) { //adding pT of all pt bins to see diss is cont if(iCat == 0) { if( AccHighPtJpsi == 1 && (gbin >= 4 && gbin < 24) && (GenPosIn==1 && GenNegIn==1) && (GenJpsiPt >= 6.5 && GenJpsiPt < 40.0) && (TMath::Abs(GenJpsiRap)<1.2 && TMath::Abs(GenJpsiRap) >= 0.0 ) && (TMath::Abs(GenJpsiPsi)>=dphi_bound[idphi] && TMath::Abs(GenJpsiPsi)<dphi_bound[idphi+1])){diMuonsInvMass_GenA[ifile][idphi]->Fill(GenJpsiMass,GenWeight);} } if(iCat == 1) { if( AccHighPtJpsi == 1 && (gbin >= 4 && gbin < 24) && (GenPosIn==1 && GenNegIn==1) && (GenJpsiPt >= 6.5 && GenJpsiPt < 40.0) && (TMath::Abs(GenJpsiRap)<1.6 && TMath::Abs(GenJpsiRap) >= 1.2 ) && (TMath::Abs(GenJpsiPsi)>=dphi_bound[idphi] && TMath::Abs(GenJpsiPsi)<dphi_bound[idphi+1])){diMuonsInvMass_GenA[ifile][idphi]->Fill(GenJpsiMass,GenWeight);} } if(iCat == 2) { if( AccHighPtJpsi == 1 && (gbin >= 4 && gbin < 24) && (GenPosIn==1 && GenNegIn==1) && (GenJpsiPt >= 6.5 && GenJpsiPt < 40.0) && (TMath::Abs(GenJpsiRap)<2.4 && TMath::Abs(GenJpsiRap) >= 1.6 ) && (TMath::Abs(GenJpsiPsi)>=dphi_bound[idphi] && TMath::Abs(GenJpsiPsi)<dphi_bound[idphi+1])){diMuonsInvMass_GenA[ifile][idphi]->Fill(GenJpsiMass,GenWeight);} } if(iCat == 3) { if( AccLowPtJpsi == 1 && (gbin >= 4 && gbin < 24) && (GenPosIn==1 && GenNegIn==1) && (GenJpsiPt >= 3.0 && GenJpsiPt < 6.5) && (TMath::Abs(GenJpsiRap)<2.4 && TMath::Abs(GenJpsiRap) >= 1.6 ) && (TMath::Abs(GenJpsiPsi)>=dphi_bound[idphi] && TMath::Abs(GenJpsiPsi)<dphi_bound[idphi+1])){diMuonsInvMass_GenA[ifile][idphi]->Fill(GenJpsiMass,GenWeight);} } } }//gen loop end cout<<" accepted no "<< NAccep<<endl; dataFile<<" accepted no "<< NAccep<<endl; //dataFile<<" accepted no "<< NAccep<<endl; // new TCanvas; //diMuonsInvMass_Gen->Draw(); //gPad->Print("plots/diMuonsInvMass_Gen.png"); new TCanvas; diMuonsPt_Gen->Draw(); //=============== Rec Tree Loop ============================================================================== // start to fill up reco corrected by efficiency char tmp_eff_input[512], tmp_input_histo[512]; if(!(iCat == 3)) sprintf(tmp_eff_input,"../../EffRoots_New/PrJpsi_HighPt_%s.root", cCond); if(iCat == 3) sprintf(tmp_eff_input,"../../EffRoots_New/PrJpsi_LowPt_%s.root", cCond); sprintf(tmp_input_histo,"eff_%s", cCond); TFile *eff_input; eff_input=new TFile(tmp_eff_input,"R"); int nRecEntries=tree->GetEntries(); cout<<"Total Entries in reconstructed Tree for pT range "<<fileName[ifile]<<" "<<nRecEntries<< "====="<<endl; for(int i=0; i<nRecEntries; i++) { tree->GetEntry(i); //if(bCowboy && !(gchkCowboy > 0.)) {cout<<"This is not Cowboy from Gen"<<endl; continue;} //if(bSailor && (gchkCowboy > 0.)) {cout<<"This is not Sailor from Gen"<<endl; continue;} //Only printing if(i%10000==0){ //cout<<" processing record "<<i<<"/"<<nRecEntries<<endl; //cout<<" processing Run " <<runNb <<" event "<<eventNb<<" lum block "<<lumiBlock<<endl; //cout<<" Mass "<< JpsiMass<< " pT "<< JpsiPt << " Y " <<JpsiRap<<" "<<JpsiVprob<<" charge "<<JpsiCharge<<" rbin "<<rbin<<endl; } //if(JpsiPt < 6.5) continue; bool PosPass=0, NegPass=0, AllCut=0 ,PosIn=0, NegIn=0; muPosPt= TMath::Sqrt(muPosPx*muPosPx + muPosPy*muPosPy); muPosP = TMath::Sqrt(muPosPx*muPosPx + muPosPy*muPosPy+ muPosPz*muPosPz); muNegPt= TMath::Sqrt(muNegPx*muNegPx + muNegPy*muNegPy); muNegP = TMath::Sqrt(muNegPx*muNegPx + muNegPy*muNegPy +muNegPz*muNegPz); if(IsAccept(muPosPt, muPosEta)){PosIn=1;} if(IsAccept(muNegPt, muNegEta)){NegIn=1;} bool mu_Global = ((muPos_nchi2Gl >=0) && (muNeg_nchi2Gl >=0)); bool mu_Tracker = ((muPos_tracker==1) && (muNeg_tracker==1)); double dPhi2mu = muPosPhi - muNegPhi; while (dPhi2mu > TMath::Pi()) dPhi2mu -= 2*TMath::Pi(); while (dPhi2mu <= -TMath::Pi()) dPhi2mu += 2*TMath::Pi(); double chkCowboy = 1*dPhi2mu; if(bCowboy && !(chkCowboy > 0.)) continue; if(bSailor && (chkCowboy > 0.)) continue; if(muPos_found > 10 && muPos_pixeLayers > 0 && muPos_nchi2In < 4.0 && TMath::Abs(muPos_dxy) < 3 && TMath::Abs(muPos_dz) < 15 && muPos_nchi2Gl < 20 && muPos_arbitrated==1 && muPos_tracker==1){PosPass=1;} if(muNeg_found >10 && muNeg_pixeLayers >0 && muNeg_nchi2In <4.0 && TMath::Abs(muNeg_dxy) < 3 && TMath::Abs(muNeg_dz) < 15 && muNeg_nchi2Gl < 20 && muNeg_arbitrated==1 && muNeg_tracker==1){NegPass=1;} //cout<<"Cut checks, muPos_matches : "<<muPos_matches<<", muNeg_matches : "<<muNeg_matches<<", PosIn : "<<PosIn<<", NegIn : "<<NegIn // <<", PosPass : "******", NegPass : "******", mu_Global : "<<mu_Global<<", mu_Tracker : "<<mu_Tracker<<endl; //if((PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} int AccHighPtJpsi = 0; int AccLowPtJpsi = 0; if(JpsiPt >= 6.5 && fabs(JpsiRap) < 2.4 && PosIn == 1 && NegIn == 1) AccHighPtJpsi = 1; if(JpsiPt < 6.5 && JpsiPt >= 3.0 && fabs(JpsiRap) >= 1.6 && fabs(JpsiRap) < 2.4 && PosIn == 1 && NegIn == 1) AccLowPtJpsi = 1; if(hbit1 == 1 && (muPos_matches==1 && muNeg_matches==1) && (PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} //AllCut = 1; //without ID cut // if((muPos_matches==1 && muNeg_matches==1) && (PosIn==1 && NegIn==1) && mu_Global && mu_Tracker){AllCut=1;} //without trigger matched //if((PosIn==1 && NegIn==1) && (PosPass==1 && NegPass==1)&& mu_Global && mu_Tracker){AllCut=1;} double eff_cor[2]; double RecCenWeight=0,RecWeight=0; RecCenWeight=FindCenWeight(rbin); double JpsidPhi = 0.0; JpsidPhi = TMath::Abs(JpsiGenPsi); double rmean_dphi = TMath::Pi()/16; if (JpsidPhi>TMath::Pi()/8) rmean_dphi = 3*TMath::Pi()/16; if (JpsidPhi>TMath::Pi()/4) rmean_dphi = 5*TMath::Pi()/16; if (JpsidPhi>3*TMath::Pi()/8) rmean_dphi = 7*TMath::Pi()/16; RecWeight=RecCenWeight*scale[ifile]*(2.0/TMath::Pi()*(1+2*fake_v2*cos(2*JpsidPhi)*TMath::Gaus(JpsiPt,15,4,0))); if(PutWeight==0)RecWeight=1; //Eff loop for reco for (Int_t idphi = 0; idphi < ndPhiBins; idphi++) { if((JpsiCharge == 0) && (JpsiVprob > 0.01)) { if(iCat == 0) { if(AccHighPtJpsi == 1 && (AllCut==1) && (rbin >= 4 && rbin < 24) && (JpsiPt>=6.5 && JpsiPt<40.0) && (TMath::Abs(JpsiRap) < 1.2 && TMath::Abs(JpsiRap) >= 0.0) && (TMath::Abs(JpsiGenPsi) > dphi_bound[idphi] && TMath::Abs(JpsiGenPsi) <=dphi_bound[idphi+1])){ DoEffCor3D(eff_input, iCond, rbin, JpsiPt, fabs(JpsiRap), eff_cor); diMuonsInvMass_RecA[ifile][idphi]->Fill(JpsiMass,RecWeight*((double)1.0/eff_cor[0]));} } if(iCat == 1) { if(AccHighPtJpsi == 1 && (AllCut==1) && (rbin >= 4 && rbin < 24) && (JpsiPt>=6.5 && JpsiPt<40.0) && (TMath::Abs(JpsiRap) < 1.6 && TMath::Abs(JpsiRap) >= 1.2) && (TMath::Abs(JpsiGenPsi) > dphi_bound[idphi] && TMath::Abs(JpsiGenPsi) <=dphi_bound[idphi+1])){ DoEffCor3D(eff_input, iCond, rbin, JpsiPt, fabs(JpsiRap), eff_cor); diMuonsInvMass_RecA[ifile][idphi]->Fill(JpsiMass,RecWeight*((double)1.0/eff_cor[0]));} } if(iCat == 2) { if(AccHighPtJpsi == 1 && (AllCut==1) && (rbin >= 4 && rbin < 24) && (JpsiPt>=6.5 && JpsiPt<40.0) && (TMath::Abs(JpsiRap) < 2.4 && TMath::Abs(JpsiRap) >= 1.6) && (TMath::Abs(JpsiGenPsi) > dphi_bound[idphi] && TMath::Abs(JpsiGenPsi) <=dphi_bound[idphi+1])){ DoEffCor3D(eff_input, iCond, rbin, JpsiPt, fabs(JpsiRap), eff_cor); diMuonsInvMass_RecA[ifile][idphi]->Fill(JpsiMass,RecWeight*((double)1.0/eff_cor[0]));} } if(iCat == 3) { if(AccLowPtJpsi == 1 && (AllCut==1) && (rbin >= 4 && rbin < 24) && (JpsiPt>=3.0 && JpsiPt<6.5) && (TMath::Abs(JpsiRap) < 2.4 && TMath::Abs(JpsiRap) >= 1.6) && (TMath::Abs(JpsiGenPsi) > dphi_bound[idphi] && TMath::Abs(JpsiGenPsi) <=dphi_bound[idphi+1])){ DoEffCor3D(eff_input, iCond, rbin, JpsiPt, fabs(JpsiRap), eff_cor); diMuonsInvMass_RecA[ifile][idphi]->Fill(JpsiMass,RecWeight*((double)1.0/eff_cor[0]));} } } } }//rec tree loop ends } // file loop ends /////////////////////////////////////////////////////////////////// cout<< " adding "<<endl; TH1D *diMuonsInvMass_RecA1[100]; TH1D *diMuonsInvMass_GenA1[100]; TH1D *diMuonsPt_GenA1[100]; TH1D *diMuonsPt_RecA1[100]; TF1 *backfun_1; for(Int_t idphi = 0; idphi < ndPhiBins; idphi++){ diMuonsInvMass_RecA1[idphi] = diMuonsInvMass_RecA[0][idphi]; diMuonsInvMass_GenA1[idphi] = diMuonsInvMass_GenA[0][idphi]; diMuonsPt_GenA1[idphi] = diMuonsPt_GenA[0][idphi]; diMuonsPt_RecA1[idphi] = diMuonsPt_RecA[0][idphi]; for (int ifile = 1; ifile < nFiles; ifile++) { diMuonsInvMass_RecA1[idphi]->Add(diMuonsInvMass_RecA[ifile][idphi]); diMuonsInvMass_GenA1[idphi]->Add(diMuonsInvMass_GenA[ifile][idphi]); diMuonsPt_GenA1[idphi]->Add(diMuonsPt_GenA[ifile][idphi]); diMuonsPt_RecA1[idphi]->Add(diMuonsPt_RecA[ifile][idphi]); } } //===========================Fitting=================================================================================// // Fit ranges double mass_low, mass_high; double MassJpsi, WeidthJpsi; // Fit Function crystall ball // Jpsi Settings MassJpsi = 3.096; WeidthJpsi = 0.028; mass_low = 2.945; mass_high = 3.24; // Fit ranges TF1 *GAUSPOL = new TF1("GAUSPOL",CrystalBall,2.4,3.8,6);//2.4,3.8,6); GAUSPOL->SetParNames("Yield (J/#psi)","BinWidth","Mean","Sigma","#alpha","n"); GAUSPOL->SetParameter(2, MassJpsi); GAUSPOL->SetParameter(3, WeidthJpsi); //GAUSPOL->SetParLimits(3, 0.1*WeidthJpsi,2.0*WeidthJpsi); GAUSPOL->SetParameter(4, 1.2); GAUSPOL->SetParameter(5, 20.0); GAUSPOL->SetLineWidth(2.0); GAUSPOL->SetLineColor(2); //=====================Loop for eff========================================================================================// //define stuff here for error on weighted samples double GenNo[100]={0}; double GenError[100]={0}; double RecError[100]={0}; for (Int_t idphi = 0; idphi < ndPhiBins; idphi++) { gen_pt[idphi] = diMuonsInvMass_GenA1[idphi]->IntegralAndError(1, 100, genError); gen_ptError[idphi]= genError; cout<<" gen_pt[idphi] "<< gen_pt[idphi] <<" error "<< gen_ptError[idphi]<<endl; // cout<<" *********************** "<<diMuonsInvMass_RecA1[idphi]->GetMaximum()<<endl; //giving inetial value for crystall ball fourth parameter GAUSPOL->SetParameter(0, diMuonsInvMass_RecA1[idphi]->Integral(0,50)); GAUSPOL->FixParameter(1, diMuonsInvMass_RecA1[idphi]->GetBinWidth(1)); //GAUSPOL->SetParameter(0, diMuonsInvMass_RecA1[idphi]->GetMaximum()); //new TCanvas; //diMuonsInvMass_RecA1[idphi]->Draw(); new TCanvas; diMuonsInvMass_RecA1[idphi]->Fit("GAUSPOL","EMRQ", "", mass_low, mass_high); // Jpsi //diMuonsInvMass_RecA1[idphi]->Fit("GAUSPOL","LLMERQ", "", 8.5,10.5); // Jpsi //diMuonsInvMass_RecA1[idphi]->Fit("GAUSPOL","LLMER", "", mass_low, mass_high); // Jpsi diMuonsInvMass_RecA1[idphi]->DrawCopy("EPLsame"); // new TCanvas; //diMuonsInvMass_RecA1[idphi]->Fit("GAUSPOL_1","LLMER", "", mass_low, mass_high); //diMuonsInvMass_RecA1[idphi]->DrawCopy("EPLsame"); //gPad->Print(PlotName); //gPad->Print(PlotName1); // cout << GAUSPOL_1->GetChisquare()<<endl; //for(int i=0;i<=100;i++) {cout<<i<<" "<<diMuonsInvMass_RecA1[idphi]->GetBinContent(i)<<endl;} //return; //double JpsiMass = GAUSPOL_1->GetParameter(2); //double JpsiWidth = GAUSPOL_1->GetParameter(3); //double JpsiYield = GAUSPOL_1->GetParameter(4); double JpsiMass = GAUSPOL->GetParameter(2); double JpsiWidth = GAUSPOL->GetParameter(3); double JpsiYield = GAUSPOL->GetParameter(0); Double_t JpsiYieldError = GAUSPOL->GetParError(0); //cout<<JpsiYieldError<<"*****************"<<endl; //if(TMath::IsNan(JpsiYieldError)=1) {JpsiYieldError=TMath::Sqrt(JpsiYield);} double par[20]; GAUSPOL->GetParameters(par); sprintf(namePt_1B,"pt_1B_%d",idphi); backfun_1 = new TF1(namePt_1B, Pol2, mass_low, mass_high, 3); backfun_1->SetParameters(&par[3]); double MassLow=(JpsiMass-3*JpsiWidth); double MassHigh=(JpsiMass+3*JpsiWidth); int binlow =diMuonsInvMass_RecA1[idphi]->GetXaxis()->FindBin(MassLow); int binhi =diMuonsInvMass_RecA1[idphi]->GetXaxis()->FindBin(MassHigh); //double binwidth=diMuonsInvMass_RecA1[idphi]->GetBinWidth(1); //yield by function //rec_pt[idphi] = JpsiYield; //rec_ptError[idphi]= JpsiYieldError; //yield by histogram integral binlow = 1; binhi = 100; rec_pt[idphi] = diMuonsInvMass_RecA1[idphi]->IntegralAndError(binlow, binhi,recError); rec_ptError[idphi]= recError; } TFile *outfile; char tmp_output[512]; if(iCat == 0) sprintf(tmp_output,"MCCT_PrJpsi_Raps_0012_dPhi_%s.root",cCond); if(iCat == 1) sprintf(tmp_output,"MCCT_PrJpsi_Raps_1216_dPhi_%s.root",cCond); if(iCat == 2) sprintf(tmp_output,"MCCT_PrJpsi_Raps_1624H_dPhi_%s.root",cCond); if(iCat == 3) sprintf(tmp_output,"MCCT_PrJpsi_Raps_1624L_dPhi_%s.root",cCond); outfile =new TFile(tmp_output,"Recreate"); double gsum = 0.0; double gen_pt_Norm[ndPhiBins]; double gen_ptError_Norm[ndPhiBins]; for(int i = 0; i < ndPhiBins; i++){ gsum += gen_pt[i]; } gsum = gsum*(dphi_bound[1]-dphi_bound[0]); for(int i = 0; i < ndPhiBins; i++){ gen_pt_Norm[i] = gen_pt[i]/gsum; gen_ptError_Norm[i] = gen_ptError[i]/gsum; } double sum = 0.0; double rec_pt_Norm[ndPhiBins]; double rec_ptError_Norm[ndPhiBins]; for(int i = 0; i < ndPhiBins; i++){ sum += rec_pt[i]; } sum = sum*(dphi_bound[1]-dphi_bound[0]); for(int i = 0; i < ndPhiBins; i++){ rec_pt_Norm[i] = rec_pt[i]/sum; rec_ptError_Norm[i] = rec_ptError[i]/sum; } TH1F *hJpsi_Gen = new TH1F("hJpsi_Gen","hJpsi_Gen",ndPhiBins,0,TMath::Pi()/2); TH1F *hJpsi_Reco = new TH1F("hJpsi_Reco","hJpsi_Reco",ndPhiBins,0,TMath::Pi()/2); hJpsi_Gen->Sumw2(); hJpsi_Reco->Sumw2(); for(int i = 0; i < ndPhiBins; i++){ hJpsi_Gen->SetBinContent(i+1,gen_pt[i]); hJpsi_Gen->SetBinError(i+1,gen_ptError[i]); hJpsi_Reco->SetBinContent(i+1,rec_pt[i]); hJpsi_Reco->SetBinError(i+1,rec_ptError[i]); } TGraphErrors *Jpsi_Reco_Norm = new TGraphErrors(ndPhiBins, xdphi_bound, rec_pt_Norm, mom_err, rec_ptError_Norm); TGraphErrors *Jpsi_Gen_Norm = new TGraphErrors(ndPhiBins, xdphi_bound, gen_pt_Norm, mom_err, gen_ptError_Norm); if(iCat == 0){ hJpsi_Gen->SetName("hGen_Jpsi_Raps_0012"); hJpsi_Reco->SetName("hReco_Jpsi_Raps_0012"); Jpsi_Reco_Norm->SetName("nReco_Jpsi_Raps_0012"); Jpsi_Gen_Norm->SetName("nGen_Jpsi_Raps_0012"); } if(iCat == 1){ hJpsi_Gen->SetName("hGen_Jpsi_Raps_1216"); hJpsi_Reco->SetName("hReco_Jpsi_Raps_1216"); Jpsi_Reco_Norm->SetName("nReco_Jpsi_Raps_1216"); Jpsi_Gen_Norm->SetName("nGen_Jpsi_Raps_1216"); } if(iCat == 2){ hJpsi_Gen->SetName("hGen_Jpsi_Raps_1624H"); hJpsi_Reco->SetName("hReco_Jpsi_Raps_1624H"); Jpsi_Reco_Norm->SetName("nReco_Jpsi_Raps_1624H"); Jpsi_Gen_Norm->SetName("nGen_Jpsi_Raps_1624H"); } if(iCat == 3){ hJpsi_Gen->SetName("hGen_Jpsi_Raps_1624L"); hJpsi_Reco->SetName("hReco_Jpsi_Raps_1624L"); Jpsi_Reco_Norm->SetName("nReco_Jpsi_Raps_1624L"); Jpsi_Gen_Norm->SetName("nGen_Jpsi_Raps_1624L"); } hJpsi_Gen->Write(); hJpsi_Reco->Write(); Jpsi_Reco_Norm->Write(); Jpsi_Gen_Norm->Write(); outfile->Write(); outfile->Close(); } } }
//int add_branch(TString particle,int energy_flag){ int main(){ TString particle; cerr<<"--- Particle (n or p)"; cin>>particle; Int_t energy_flag; cerr<<"--- Energy Flag (11 or 8)"; cin>>energy_flag; gStyle->SetOptStat(1); //const double Lumi = 1.0e36; // cm-2*s-1, for He3 nuclear not for nucleons //const double KHz = 1e-3; //const double nBcm2 = 1e-33; double hMass = 0.0; double EBeam = 0.0; TString Target = ""; TString TargetName = ""; TString Energy = ""; gRandom->SetSeed(0); /* Target and Energy variables{{{*/ if(particle=="p"){ TargetName = "Proton"; Target = "NH3"; hMass = 0.938272; if(energy_flag==11){ Energy = "11GeV"; EBeam = 11.0; } else if(energy_flag==8){ Energy = "8.8GeV"; EBeam = 8.80; } }else if(particle=="n"){ TargetName = "Neutron"; Target = "3he"; hMass = 0.939565; if(energy_flag==11){ Energy = "11GeV"; EBeam = 11.0; } else if(energy_flag==8){ Energy = "8.8GeV"; EBeam = 8.80; } }/*}}}*/ /*CLEO{{{*/ TCanvas *dummycavan = new TCanvas(); TFile *file_negative=new TFile("../acceptance/acceptance_solid_SIDIS_NH3_electron_output.root","r"); TFile *file_positive=new TFile("../acceptance/acceptance_solid_SIDIS_NH3_pionp_output.root","r"); TFile *file_photon =new TFile("../acceptance/acceptance_solid_SIDIS_NH3_photon_output.root","r"); //negative particle forward angle acceptance TH3F *accep_ele_forward=(TH3F*)file_negative->Get("acceptance_ThetaPhiP_forwardangle"); //negative particle large angle acceptance TH3F *accep_ele_large=(TH3F*)file_negative->Get("acceptance_ThetaPhiP_largeangle"); //neutral particle forward angle acceptance TH3F *accep_pho_forward=(TH3F*)file_photon->Get("acceptance_ThetaPhiP_forwardangle"); //neutral particle large angle acceptance TH3F *accep_pho_large=(TH3F*)file_photon->Get("acceptance_ThetaPhiP_largeangle"); TH3F *accep_had_forward; TH3F *accep_had_large; if(particle=="pim"){//pionm is the same as electron acceptance accep_had_forward=(TH3F*)accep_ele_forward->Clone("accep_had_forward"); accep_had_large =(TH3F*)accep_ele_large->Clone("accep_had_large"); } if(particle=="pip"){ // for positive pions accep_had_forward=(TH3F*)file_positive->Get("acceptance_ThetaPhiP_forwardangle"); accep_had_large=(TH3F*)file_positive->Get("acceptance_ThetaPhiP_largeangle"); } if(particle=="p"){ // for positive pions accep_had_forward=(TH3F*)file_positive->Get("acceptance_ThetaPhiP_forwardangle"); accep_had_large=(TH3F*)file_positive->Get("acceptance_ThetaPhiP_largeangle"); } if(particle=="n"){ // for positive pions // accep_had_forward=(TH3F*)file_photon->Get("acceptance_ThetaPhiP_forwardangle"); // accep_had_large=(TH3F*)file_photon->Get("acceptance_ThetaPhiP_largeangle"); accep_had_forward=(TH3F*)accep_pho_forward->Clone("accep_had_forward"); accep_had_large =(TH3F*)accep_pho_large->Clone("accep_had_large"); } /*}}}*/ /*Vectors & Variables{{{*/ TLorentzVector *P_E0 = new TLorentzVector();//incoming electron TLorentzVector *P_e_i = new TLorentzVector();//scattered electron TLorentzVector *P_e_f = new TLorentzVector();//scattered electron with Eloss TLorentzVector *P_g = new TLorentzVector();//photon TLorentzVector *P_h = new TLorentzVector();//proton or neutron TLorentzVector *P_t = new TLorentzVector();//target, either proton or neutron TLorentzVector *P_e_res = new TLorentzVector();//scattered electron with resolution TLorentzVector *P_g_res = new TLorentzVector();//photon with resolution Double_t vertexz, E0; Double_t ePx_ini, ePy_ini, ePz_ini; //Double_t hP_ini, hPx_ini, hPy_ini,hPz_ini,hTheta_ini,hPhi_ini; Double_t ePx, ePy, ePz, gPx, gPy, gPz, hPx, hPy, hPz; Double_t eP_ini,eP, gP,hP; Double_t Q2, x, t, phi, XS_P, XS_M, XS_BHp, XS_BHm, PSF; Double_t ePhi_ini, ePhi, gPhi,hPhi; Double_t eTheta_ini, eTheta, gTheta,hTheta; Int_t Ngen,Nacc; //Define new measured quantities that include detector resolutions double eE_i, eE_f, gE, hE; double eE_i_res, eE_f_res,eP_res, eTheta_res, ePhi_res, ePx_res, ePy_res, ePz_res; double gP_res, gTheta_res, gPhi_res, gPx_res, gPy_res, gPz_res; double MM = 0.0,MM_res = 0.0, W=0.0, Wp=0.0; int e_theta_bin= 0, e_phi_bin= 0, e_p_bin=0; int h_theta_bin= 0, h_phi_bin= 0, h_p_bin=0; int g_theta_bin= 0, g_phi_bin=0, g_p_bin=0; double e_acc_f= 0.0, e_acc_l= 0.0, g_acc_f=0, g_acc_l=0, h_acc_f=0, h_acc_l=0; /*}}}*/ /*DVCS: Define Rootfile and variables{{{*/ TString filename = ""; if(particle=="p"){ if(energy_flag==11) filename = "../DVCS_Proton_11GeV.root"; else if(energy_flag==8) filename = "../DVCS_Proton_8.8GeV.root"; }else if(particle=="n"){ if(energy_flag==11) filename = "../DVCS_Neutron_11GeV.root"; else if(energy_flag==8) filename = "../DVCS_Neutron_8.8GeV.root"; } TFile *file = new TFile(filename.Data(), "r"); TTree *T = (TTree*) file->Get("T"); T->SetBranchAddress("vertexz", &vertexz); T->SetBranchAddress("E0", &E0); T->SetBranchAddress("eP_ini", &eP_ini); T->SetBranchAddress("ePx_ini", &ePx_ini); T->SetBranchAddress("ePy_ini", &ePy_ini); T->SetBranchAddress("ePz_ini", &ePz_ini); T->SetBranchAddress("eTheta_ini",&eTheta_ini); T->SetBranchAddress("ePhi_ini",&ePhi_ini); T->SetBranchAddress("eP", &eP); T->SetBranchAddress("ePx", &ePx); T->SetBranchAddress("ePy", &ePy); T->SetBranchAddress("ePz", &ePz); T->SetBranchAddress("eTheta",&eTheta); T->SetBranchAddress("ePhi",&ePhi); T->SetBranchAddress("gP", &gP); T->SetBranchAddress("gPx", &gPx); T->SetBranchAddress("gPy", &gPy); T->SetBranchAddress("gPz", &gPz); T->SetBranchAddress("gTheta", &gTheta); T->SetBranchAddress("gPhi", &gPhi); T->SetBranchAddress("hP", &hP); T->SetBranchAddress("hPx", &hPx); T->SetBranchAddress("hPy", &hPy); T->SetBranchAddress("hPz", &hPz); T->SetBranchAddress("hTheta",&hTheta); T->SetBranchAddress("hPhi",&hPhi); T->SetBranchAddress("Q2", &Q2); T->SetBranchAddress("x", &x); T->SetBranchAddress("t", &t); T->SetBranchAddress("phi", &phi); T->SetBranchAddress("XS_P", &XS_P); T->SetBranchAddress("XS_M", &XS_M); T->SetBranchAddress("XS_BHp", &XS_BHp); T->SetBranchAddress("XS_BHm", &XS_BHm); T->SetBranchAddress("PSF", &PSF); T->SetBranchAddress("Ngen", &Ngen); T->SetBranchAddress("Nacc", &Nacc); Long64_t N_entries=T->GetEntries(); T->GetEntry(0); Long64_t N_gen = Ngen; cout<<"DVCS: total generated events number: "<<N_gen<<"--- and accepted: "<<N_entries<<endl; /*}}}*/ /*Add new branches{{{*/ filename.ReplaceAll(".root","_New0.root"); TFile *newfile = new TFile(filename.Data(), "recreate"); TTree *NewT = T->CloneTree(0);; NewT->Branch("W", &W, "W/D"); NewT->Branch("Wp", &Wp, "Wp/D"); NewT->Branch("MM", &MM, "MM/D"); NewT->Branch("MM_res", &MM_res, "MM_res/D"); NewT->Branch("e_acc_f", &e_acc_f, "e_acc_f/D"); NewT->Branch("e_acc_l", &e_acc_l, "e_acc_l/D"); NewT->Branch("g_acc_f", &g_acc_f, "g_acc_f/D"); NewT->Branch("g_acc_l", &g_acc_l, "g_acc_l/D"); NewT->Branch("h_acc_f", &h_acc_f, "h_acc_f/D"); NewT->Branch("h_acc_l", &h_acc_l, "h_acc_l/D"); NewT->Branch("eP_res", &eP_res, "eP_res/D"); NewT->Branch("ePx_res", &ePx_res, "ePx_res/D"); NewT->Branch("ePy_res", &ePy_res, "ePy_res/D"); NewT->Branch("ePz_res", &ePz_res, "ePz_res/D"); NewT->Branch("eTheta_res", &eTheta_res, "eTheta_res/D"); NewT->Branch("ePhi_res", &ePhi_res, "ePhi_res/D"); NewT->Branch("gP_res", &gP_res, "gP_res/D"); NewT->Branch("gPx_res", &gPx_res, "gPx_res/D"); NewT->Branch("gPy_res", &gPy_res, "gPy_res/D"); NewT->Branch("gPz_res", &gPz_res, "gPz_res/D"); NewT->Branch("gTheta_res", &gTheta_res, "gTheta_res/D"); NewT->Branch("gPhi_res", &gPhi_res, "gPhi_res/D"); Double_t tmin, BSA_L, TSA_L, DSA_L; Double_t Sigma_L, SigmaPP_L,SigmaPM_L, SigmaMP_L, SigmaMM_L; Double_t BSA_Tx, TSA_Tx, DSA_Tx; Double_t Sigma_Tx, SigmaPP_Tx,SigmaPM_Tx, SigmaMP_Tx, SigmaMM_Tx; Double_t BSA_Ty, TSA_Ty, DSA_Ty; Double_t Sigma_Ty, SigmaPP_Ty,SigmaPM_Ty, SigmaMP_Ty, SigmaMM_Ty; NewT->Branch("tmin", &tmin, "tmin/D"); NewT->Branch("Sigma_L", &Sigma_L, "Sigma_L/D"); NewT->Branch("SigmaPP_L", &SigmaPP_L, "SigmaPP_L/D"); NewT->Branch("SigmaPM_L", &SigmaPM_L, "SigmaPM_L/D"); NewT->Branch("SigmaMP_L", &SigmaMP_L, "SigmaMP_L/D"); NewT->Branch("SigmaMM_L", &SigmaMM_L, "SigmaMM_L/D"); NewT->Branch("BSA_L", &BSA_L, "BSA_L/D"); NewT->Branch("TSA_L", &TSA_L, "TSA_L/D"); NewT->Branch("DSA_L", &DSA_L, "DSA_L/D"); NewT->Branch("Sigma_Tx", &Sigma_Tx, "Sigma_Tx/D"); NewT->Branch("SigmaPP_Tx", &SigmaPP_Tx, "SigmaPP_Tx/D"); NewT->Branch("SigmaPM_Tx", &SigmaPM_Tx, "SigmaPM_Tx/D"); NewT->Branch("SigmaMP_Tx", &SigmaMP_Tx, "SigmaMP_Tx/D"); NewT->Branch("SigmaMM_Tx", &SigmaMM_Tx, "SigmaMM_Tx/D"); NewT->Branch("BSA_Tx", &BSA_Tx, "BSA_Tx/D"); NewT->Branch("TSA_Tx", &TSA_Tx, "TSA_Tx/D"); NewT->Branch("DSA_Tx", &DSA_Tx, "DSA_Tx/D"); NewT->Branch("Sigma_Ty", &Sigma_Ty, "Sigma_Ty/D"); NewT->Branch("SigmaPP_Ty", &SigmaPP_Ty, "SigmaPP_Ty/D"); NewT->Branch("SigmaPM_Ty", &SigmaPM_Ty, "SigmaPM_Ty/D"); NewT->Branch("SigmaMP_Ty", &SigmaMP_Ty, "SigmaMP_Ty/D"); NewT->Branch("SigmaMM_Ty", &SigmaMM_Ty, "SigmaMM_Ty/D"); NewT->Branch("BSA_Ty", &BSA_Ty, "BSA_Ty/D"); NewT->Branch("TSA_Ty", &TSA_Ty, "TSA_Ty/D"); NewT->Branch("DSA_Ty", &DSA_Ty, "DSA_Ty/D"); /*}}}*/ TString Data_Dir = "/work/halla/solid/yez/dvcs/DVCS_XS_Grid/"; TString TargetPol = ""; //Tx, Ty, L Int_t Debug = 0, err = 0; DVCSGrid *grid = new DVCSGrid(); grid->Init(EBeam,TargetName.Data(), Data_Dir.Data(), Debug); /*Loop DVCS Events{{{*/ for(int i=0;i<N_entries; i++){ T->GetEntry(i); grid->FindBin(Q2, x, -t, phi);// here -t was used instead of t //grid->PrintRanges(); tmin = grid->GetTMin(); /*Reading the Longitudinal Target Spin{{{*/ SigmaPP_L = 1e-36; SigmaPM_L = 1e-36; SigmaMP_L = 1e-36; SigmaMM_L = 1e-36; Sigma_L = 1e-36; BSA_L = 1e-36; TSA_L = 1e-36; DSA_L = 1e-36; TargetPol = "L"; err = grid->LoadXS(TargetPol); if(err>=0){ //grid->PrintXS(); SigmaPP_L = grid->GetSigmaPP();//++ SigmaPM_L = grid->GetSigmaPM();//+- SigmaMP_L = grid->GetSigmaMP();//-+ SigmaMM_L = grid->GetSigmaMM();//-- Sigma_L = grid->GetSigma();//average of four XSs above BSA_L = grid->GetBSA();//beam spin asym TSA_L = grid->GetTSA();//target spin asym DSA_L = grid->GetDSA();//double spin asym } /*Reading the Longitudinal Target Spin}}}*/ /*Reading the Transverse Target Spin on x{{{*/ SigmaPP_Tx = 1e-36;SigmaPM_Tx = 1e-36; SigmaMP_Tx = 1e-36; SigmaMM_Tx = 1e-36; Sigma_Tx = 1e-36; BSA_Tx = 1e-36;TSA_Tx = 1e-36;DSA_Tx = 1e-36; TargetPol = "Tx"; err = grid->LoadXS(TargetPol); if(err>=0){ //grid->PrintXS(); SigmaPP_Tx = grid->GetSigmaPP();//++ SigmaPM_Tx = grid->GetSigmaPM();//+- SigmaMP_Tx = grid->GetSigmaMP();//-+ SigmaMM_Tx = grid->GetSigmaMM();//-- Sigma_Tx = grid->GetSigma();//average of four XSs above BSA_Tx = grid->GetBSA();//beam spin asym TSA_Tx = grid->GetTSA();//target spin asym DSA_Tx = grid->GetDSA();//double spin asym // cerr<<Form("-Tx-- BS = %e (%e)", BSA_Tx, (SigmaPP_Tx+SigmaPM_Tx - SigmaMP_Tx-SigmaMM_Tx)/4. )<<endl; // cerr<<Form("-Tx-- TS = %e (%e)", TSA_Tx, (SigmaPP_Tx+SigmaMP_Tx - SigmaPM_Tx-SigmaMM_Tx)/4. )<<endl; // cerr<<Form("-Tx-- DS = %e (%e)", DSA_Tx, (SigmaPP_Tx+SigmaMM_Tx - SigmaPM_Tx-SigmaMP_Tx)/4. )<<endl; // cerr<<Form("-Tx-- AVG = %e ", Sigma_Tx)<<endl; } /*Reading the Transverse Target Spin on x}}}*/ /*Reading the Transverse Target Spin on y{{{*/ SigmaPP_Ty = 1e-36;SigmaPM_Ty = 1e-36; SigmaMP_Ty = 1e-36; SigmaMM_Ty = 1e-36; Sigma_Ty = 1e-36; BSA_Ty = 1e-36;TSA_Ty = 1e-36;DSA_Ty = 1e-36; TargetPol = "Ty"; err = grid->LoadXS(TargetPol); if(err>=0){ //grid->PrintXS(); SigmaPP_Ty = grid->GetSigmaPP();//++ SigmaPM_Ty = grid->GetSigmaPM();//+- SigmaMP_Ty = grid->GetSigmaMP();//-+ SigmaMM_Ty = grid->GetSigmaMM();//-- Sigma_Ty = grid->GetSigma();//average of four XSs above BSA_Ty = grid->GetBSA();//beam spin asym TSA_Ty = grid->GetTSA();//target spin asym DSA_Ty = grid->GetDSA();//double spin asym } /*Reading the Transverse Target Spin on y}}}*/ /*Acceptance{{{*/ e_theta_bin= 0; e_phi_bin=0;; e_p_bin=0; e_acc_f= -1e6; e_acc_l= -1e6; g_acc_f= -1e6; g_acc_l= -1e6; MM = -1e6; MM_res = -1e6; W = -1e6;; Wp = -1e6; eP_res = -1e6; ePx_res = -1e6; ePy_res = -1e6; ePz_res = -1e6; eTheta_res = -1e6; ePhi_res = -1e6; gP_res = -1e6; gPx_res = -1e6; gPy_res = -1e6; gPz_res = -1e6; gTheta_res = -1e6; gPhi_res = -1e6; e_theta_bin=int(eTheta/0.5)+1; //0.5 degree per bin e_phi_bin=int(ePhi/2.0)+1; //2 degree per bin e_p_bin=int(eP/0.1)+1; //0.1 GeV per bin for mom e_acc_f=accep_ele_forward->GetBinContent(e_theta_bin,e_phi_bin,e_p_bin); e_acc_l=accep_ele_large->GetBinContent(e_theta_bin,e_phi_bin,e_p_bin); if(eP<1.0||eTheta>14.5||eTheta<8.0)//GeV, CLEO e_acc_f=0.0;//Farward-Angle EC Cut at 1 GeV if(eP<1.0||eTheta<15.5||eTheta>24)//GeV,CLEO e_acc_l=0.0; //Larger-Angle EC Cut at 3 GeV if(e_acc_f>1.) e_acc_f=1.0; if(e_acc_l>1.) e_acc_l=1.0; h_theta_bin=int(hTheta/0.5)+1; //0.5 degree per bin h_phi_bin=int(hPhi/2.0)+1; //2 degree per bin h_p_bin=int(hP/0.1)+1; //0.1 GeV per bin h_acc_f=accep_had_forward->GetBinContent(h_theta_bin,h_phi_bin,h_p_bin); h_acc_l=accep_had_large->GetBinContent(h_theta_bin,h_phi_bin,h_p_bin); g_theta_bin=int(gTheta/0.5)+1; //0.5 degree per bin g_phi_bin=int(gPhi/2.0)+1; //2.0 degree per bin g_p_bin=int(gP/0.1)+1; //0.1 GeV per bin for mom g_acc_f=accep_pho_forward->GetBinContent(g_theta_bin,g_phi_bin,g_p_bin); g_acc_l=accep_pho_large->GetBinContent(g_theta_bin,g_phi_bin,g_p_bin); /*Additional cuts{{{*/ /* if(gTheta<=14.8&&gTheta>=8.0&&gP>=1.0&&gP<=11.){ g_acc_f=1.0; g_acc_l=0.0; } else if(gTheta<=24.0&&gTheta>=16.&&gP>=1.0&&gP<=11.){ g_acc_f=0.0; g_acc_l=1.0; }else{ g_acc_f=0.0; g_acc_l=0.0; } */ /*}}}*/ // double e_acceptance = e_acc_f+e_acc_l; // double g_acceptance = g_acc_f+g_acc_l; // double eg_acceptance = e_acceptance*g_acceptance; //double event_weight=(XS_P+XS_M)*PSF/N_gen*Lumi*nBcm2; //put into Hz, Note, XS in nb /*Acceptance}}}*/ /*Missing Mass w/o resolutions{{{*/ eE_i = sqrt(eP_ini*eP_ini + eMass*eMass); eE_f = sqrt(eP*eP + eMass*eMass); hE = sqrt(hP*hP + hMass*hMass); gE = gP; P_E0->SetPxPyPzE(0.,0.,E0, E0); P_t->SetPxPyPzE(0.,0.,0., hMass); P_e_i->SetPxPyPzE(ePx_ini, ePy_ini, ePz_ini, eE_i); P_e_f->SetPxPyPzE(ePx, ePy, ePz, eE_f); P_g->SetPxPyPzE(gPx, gPy, gPz, gE); P_h->SetPxPyPzE(hPx, hPy, hPz, hE); int err = CheckLaws(P_t, P_E0, P_e_i, P_g, P_h);//Check whether momentum and energy conserve first if (err < 1e-33){ cerr<<"---- Momentum and Energy Conservation Laws are broken!! Something is wrong!!!"<<endl; return -222; } MM = GetMM(P_t, P_E0, P_e_i, P_g); /*}}}*/ /*Missing Mass w resolutions{{{*/ ////////////////////////////////////////////////////////////////////////// //Now consider the detector resolution here ////////////////////////////////////////////////////////////////////////// // ///////////////////////////////////////// //Electron w/o E-loss eP_res = gRandom->Gaus(eP_ini, Sigma_EC_E*eP_ini);//GeV, for electron, E ~= P eTheta_res = gRandom->Gaus(eTheta_ini*Deg2Rad, Sigma_Theta_E);//rad ePhi_res = gRandom->Gaus(ePhi_ini*Deg2Rad, Sigma_Phi_E);//rad ePx_res = eP_res * sin(eTheta_res)*cos(ePhi_res); ePy_res = eP_res * sin(eTheta_res)*sin(ePhi_res); ePz_res = eP_res * cos(eTheta_res); eE_i_res = sqrt(eP_res*eP_res + eMass*eMass); P_e_res->SetPxPyPzE(ePx_res, ePy_res, ePz_res, eE_i_res); ///////////////////////////////////////// //Electron with E-loss /* eP_res = gRandom->Gaus(eP, Sigma_EC_E*sqrt(eP));//GeV, for electron, E ~= P eTheta_res = gRandom->Gaus(eTheta*Deg2Rad, Sigma_Theta_E);//rad ePhi_res = gRandom->Gaus(ePhi*Deg2Rad, Sigma_Phi_E);//rad ePx_res = eP_res * sin(eTheta_res)*cos(ePhi_res); ePy_res = eP_res * sin(eTheta_res)*sin(ePhi_res); ePz_res = eP_res * cos(eTheta_res); eE_f_res = sqrt(eP_res*eP_res + eMass*eMass); //P_e_res->SetPxPyPzE(ePx_res, ePy_res, ePz_res, eE_i_res); */ ///////////////////////////////////////// //Photon double gZ = Length-vertexz; double gX = gZ * tan(gTheta*Deg2Rad)*cos(gPhi*Deg2Rad); double gY = gZ * tan(gTheta*Deg2Rad)*sin(gPhi*Deg2Rad); double gX_res =gRandom->Gaus(gX, Sigma_X_G);//cm double gY_res =gRandom->Gaus(gY, Sigma_Y_G);//cm double gZ_res =gRandom->Gaus(gZ, Sigma_VZ);//cm gP_res = gRandom->Gaus(gP, Sigma_EC_G*sqrt(gP));//GeV, for photon, E = P gPhi_res = atan2(gY_res, gX_res); gTheta_res = atan2(sqrt(gX_res*gX_res+gY_res*gY_res), gZ_res); gPx_res = gP_res * sin(gTheta_res)*cos(gPhi_res); gPy_res = gP_res * sin(gTheta_res)*sin(gPhi_res); gPz_res = gP_res * cos(gTheta_res); P_g_res->SetPxPyPzE(gPx_res, gPy_res, gPz_res, gP_res); ///////////////////////////////////////// MM_res = GetMM(P_t, P_E0, P_e_res, P_g_res); ///////////////////////////////////////// /*}}}*/ W = (*P_E0 + *P_t - *P_e_i)*(*P_E0 + *P_t - *P_e_i); Wp = (*P_E0 + *P_t - *P_e_i - *P_h)*(*P_E0 + *P_t - *P_e_i - *P_h); W = sqrt(W); Wp = sqrt(Wp); if(!(i%1000)) cerr<<Form("--- Processing #event = %d/%d", i,(int)(N_entries) ) <<"\r"; NewT->Fill(); } /*}}}*/ /*Save and Free{{{*/ NewT->Write("",TObject::kOverwrite); newfile->Close(); file->Close(); delete grid; delete P_g; delete P_t; delete P_e_i; delete P_e_f; delete P_h; delete P_e_res; delete P_g_res; /*Save and Free}}}*/ }
int makesigback(){ TFile * infile = new TFile("../root/combo115.root"); // TFile * infile = new TFile("../root/combo160.root"); Int_t type1 = 1; Int_t type2 = 0; Double_t weight; Int_t switchpoint; TTree * intree = (TTree*)infile->Get("combotree"); TTree * inmeta = (TTree*)infile->Get("metadata"); inmeta->SetBranchAddress("BeginIndex", &switchpoint); inmeta->GetEntry(2); cout << switchpoint << endl; TObjArray* lob = intree->GetListOfBranches(); intree->SetBranchStatus("*",0); for (Int_t i = 0; i < lob->GetEntriesFast(); ++i) { TBranch * branch = (TBranch *)lob->At(i); string bname = string(branch -> GetName()); if(string(bname).compare(0,4,"type")){ if (bname == "weight") { continue; } intree->SetBranchStatus(bname.c_str(),1); } } TFile *newfile = new TFile("../root/combo115sb.root","recreate"); TTree *newtree = intree->CloneTree(0); newtree->Branch("type1", &type1); newtree->Branch("type2", &type2); newtree->Branch("weight", &weight); weight = (1. / Double_t(switchpoint) ); for (UInt_t j = 0; j < intree->GetEntriesFast(); ++j) { if (j == switchpoint) { type1 = 0; type2 = 1; weight = (1. / Double_t(intree->GetEntriesFast() - switchpoint) ); } intree->GetEntry(j); newtree->Fill(); } Int_t newbegin; Int_t newend; TString newchannelname; TTree * newmeta = new TTree("metadata", "metadata"); newmeta->Branch("BeginIndex", &newbegin); newmeta->Branch("EndIndex", &newend); newmeta->Branch("ChannelName",&newchannelname,256000,0); newbegin = 0; newend = switchpoint - 1; newchannelname = "signal"; newmeta->Fill(); newbegin = switchpoint; newend = (intree->GetEntriesFast()) - 1; newchannelname = "backgr"; newmeta->Fill(); newfile->Write(); delete infile; delete newfile; // vector <TFile*> files; // vector <TTree*> trees; // vector < vector<Double_t> > Int_lum; // vector <TFile*> outfiles; // vector <TTree*> outtrees; // vector <string> names; // Int_lum.resize(15); // Int_lum[0].push_back(7852.); // Int_lum[1].push_back(3831.); // Int_lum[2].push_back(36823.); // Int_lum[3].push_back(11400.); // Int_lum[4].push_back(10.4); // Int_lum[5].push_back(8.4); // Int_lum[6].push_back(47.2); // Int_lum[7].push_back(6.28); // Int_lum[8].push_back(7.94); // Int_lum[9].push_back(18.1); // Int_lum[10].push_back(2562.); // Int_lum[11].push_back(243.); // Int_lum[12].push_back(3483.); // Int_lum[13].push_back(3483.); // Int_lum[14].push_back(331.); // names.push_back("AH115"); // names.push_back("AH115bb"); // names.push_back("AH160"); // names.push_back("AH160bb"); // names.push_back("QCD_BCtoE_Pt20to30"); // names.push_back("QCD_BCtoE_Pt30to80"); // names.push_back("QCD_BCtoE_Pt80to170"); // names.push_back("QCD_EMenriched_Pt20to30"); // names.push_back("QCD_EMenriched_Pt30to80"); // names.push_back("QCD_EMenriched_Pt80to170"); // names.push_back("TTplusJets"); // names.push_back("WplusJets"); // names.push_back("Zbb"); // names.push_back("Zcc"); // names.push_back("ZplusJets"); // for (UInt_t i = 0; i < names.size(); ++i) { // files.push_back(new TFile( ("../root/oldroot/"+names[i]+".root").c_str() )); // trees.push_back( (TTree*)files[i]->Get("bbAHCutTree") ); // outfiles.push_back(new TFile ( ("../root/"+names[i]+".root").c_str() , "RECREATE")); // outtrees.push_back( trees[i]->CloneTree(0) ); // outtrees[i]->Branch("intlum", &(Int_lum[i])); // for (UInt_t j = 0; j < trees[i]->GetEntriesFast(); ++j) { // trees[i]->GetEntry(j); // outtrees[i]->Fill(); // } // outfiles[i]->Write(); // } return 0; }
void absorbedSubtraction (char* bkgndTreeName, char* absTreeName, char* outHistName, int numberOfSlices,float sliceWidth ,int extent, float modifier,TFile* backgroundFile, TFile* inFile, TFile* outFile,float startY, int nBinsX, int nBinsZ,float xMax, float xMin,float zMax, float zMin) { // ******************** absorbed muon tree double xCut, xGrad, zCut, zGrad; TTree* abs = (TTree*) inFile->Get(absTreeName); abs->SetBranchAddress("xCut",&xCut); abs->SetBranchAddress("yCut",&zCut); abs->SetBranchAddress("xGrad",&xGrad); abs->SetBranchAddress("yGrad",&zGrad); int nEntriesS = abs->GetEntries(); // ******************** background absorbed muon tree double xCutB, xGradB, zCutB, zGradB; TTree* absB = (TTree*) backgroundFile->Get(bkgndTreeName); absB->SetBranchAddress("xCut",&xCutB); absB->SetBranchAddress("yCut",&zCutB); absB->SetBranchAddress("xGrad",&xGradB); absB->SetBranchAddress("yGrad",&zGradB); int nEntriesB = absB->GetEntries(); // ******************** calculate the threshold and similar float vol = std::pow ((float) (2*extent+1),3); float threshold = modifier; float scalingConstant = ((float) nEntriesS) / ((float)nEntriesB); // ******************** run for each slice for (int j = 0; j < numberOfSlices; j++) { double y = (j*sliceWidth + startY); // the 'real' value of y char name [25]; char nameS [25]; char nameB [25]; char yVal [5]; sprintf (yVal, "%d",(int)y); strcpy (name,outHistName); strcat (name, yVal); strcpy (nameB, outHistName); strcat (nameB, "B"); strcat (nameB, yVal); strcpy (nameS, outHistName); strcat (nameS, "S"); strcat (nameS, yVal); TH2D* out = new TH2D (name, name, nBinsX,xMin,xMax, nBinsZ,zMin,zMax); TH2D* outS = new TH2D (nameS,nameS, nBinsX,xMin,xMax, nBinsZ,zMin,zMax); TH2D* outB = new TH2D (nameB,nameB, nBinsX,xMin,xMax, nBinsZ,zMin,zMax); // ******************** create the source histo for (int entry = 0; entry < nEntriesS; entry++) { abs->GetEntry(entry); if(xGrad == 0 || zGrad == 0) continue; // if there is null gradient ignore and continue double x = (y - xCut)/ xGrad; // calculate x and z positions using the y value (x = (y-cut)/grad) double z = (y - zCut)/ zGrad; outS->Fill (x,z,1); } outFile->Add(outS); // ******************** create background histo for (int entryB = 0; entryB < nEntriesB; entryB++) { absB->GetEntry(entryB); if(xGradB == 0 || zGradB == 0) continue; // if there is null gradient ignore and continue double x = (y - xCutB)/ xGradB; // calculate x and z positions using the y value (x = (y-cut)/grad) double z = (y - zCutB)/ zGradB; outB->Fill (x,z,1); } outFile->Add(outB); // ******************** test the source density against background density for (int i =0; i < nBinsX; i++) { for (int k = 0; k < nBinsZ; k++) { float bkgnd = 0; float test = 0; for (int io = -extent; io <= extent; io++) { for (int ko = -extent; ko <= extent; ko++) { test += outS->GetBinContent ((i+io),(k+ko)); bkgnd += outB->GetBinContent ((i+io),(k+ko)); } } test = (test/vol) /scalingConstant; // ensures that the densities are comparable bkgnd = (bkgnd/vol)*scalingConstant; if (std::fabs (test-bkgnd) > threshold) { out->SetBinContent (i,k,1); } } if (!(i%10)) std::cout<<(j*nBinsX)+ i<<" of "<<(numberOfSlices*nBinsX)<<std::endl; } outFile->Add(out); } std::cout<<vol<<" "<<threshold<<std::endl; }
// draw the same thing but after reco void genPlots02(std::string fullPath, int nOverlay = 500, bool custBinning = false) { const int fVerbose(1); setTDRStyle(); gStyle->SetOptStat(112211); gStyle->SetPalette(1); // Canvas c = new TCanvas("c2","c2",1000,600); const unsigned int nPadX = 1; const unsigned int nPadY = 1; c->Divide(nPadX,nPadY); const unsigned int nPads=nPadX*nPadY; for(unsigned int i=1; i<=nPads; i++) { TPad* pad= (TPad*)c->cd(i); pad->SetTopMargin(0.10); pad->SetRightMargin(0.20); pad->SetLeftMargin(0.15); } // Open file TFile *f = TFile::Open(fullPath.c_str()); if (f==0) { cout << "File " << fullPath << " not found -- exiting" << endl; return; } if(fVerbose>0) cout << "Succesfully opened file " << fullPath << endl; // Get TTree TTree* t = (TTree*) f->Get("events"); if(fVerbose>0) cout << "Got TTree with " << t->GetEntries() << " entries" << endl; // Do a cut, if needed //t->Draw(">>lst","chi2lb>.1&&mlb>5.61&&mlb<5.63"); //t->Draw(">>lst","chi2lb>.1&&isSig==1"); t->Draw(">>lst","(rid1m&4)==4&&(rid2m&4)==4&&mjp>2.895&&mjp<3.295&&prob1m>0.1&&prob2m>0.1&&ptjp>2&&probjp>0.005&&ml0>1.101&&ml0<1.129&&probpr>0.02&&probpi>0.02&&rptpr>rptpi&&ptl0>3&&rptpr>1&&rptpi>0.5&&probl0>0.02&&alphal0<0.3&&d3l0>1&&d3l0/d3El0>10&&problb>0.001&&alphalb<0.3"); TEventList *lst; lst = (TEventList*)gDirectory->Get("lst"); t->SetEventList(lst); if(fVerbose>0) cout << "Got TTree with " << t->GetEntries() << " entries" << endl; // Do plots c->cd(1); //doPlot2d(t,"hrzL0vtx", "vrl0:TMath::Abs(vzl0)",30,0,300,30,0,120,"Tit","|z|","r","cm","cm"); if (custBinning) { double newbinsX[]={0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50}; const int newbinsX_size = sizeof(newbinsX)/sizeof(double); std::vector<double> binvecX(newbinsX,newbinsX+newbinsX_size); //double newbinsY[]={0,1,2,3,4,5,6,7,8,9,10}; double newbinsY[]={0,0.5,1,2,4,8,16,32}; const int newbinsY_size = sizeof(newbinsY)/sizeof(double); std::vector<double> binvecY(newbinsY,newbinsY+newbinsY_size); doPlot2d(t,"hrzL0vtxreco", "vrl0:TMath::Abs(vzl0)",binvecX, binvecY,"#Lambda vertices","|z|","r","cm","cm"); } else { doPlot2d(t,"hrzL0vtxreco", "vrl0:TMath::Abs(vzl0)",30,0,50,30,0,30,"#Lambda vertices","|z|","r","cm","cm"); } // add tracker TPad* pad; pad = (TPad*)c->cd(1); pad->Modified(); pad->Update(); repositionPalette("hrzL0vtxreco"); pad->Update(); pad->SetLogz(); drawTracker(pad); if (nOverlay<=0) return; int maxN = nOverlay; if (maxN > t->GetEntries()) maxN = t->GetEntries(); double vrl0,vzl0,ppr,ppi,etapr,etapi; t->SetBranchAddress("vrl0",&vrl0); t->SetBranchAddress("vzl0",&vzl0); t->SetBranchAddress("ppr",&ppr); t->SetBranchAddress("etapr",&etapr); t->SetBranchAddress("ppi",&ppi); t->SetBranchAddress("etapi",&etapi); double scalepr = 4; double scalepi = 8; { // reference indicator const double x1pr = 0; const double y1pr = -3; const double x2pr = scalepr; const double y2pr = y1pr; const double versatz = 14; const double x1pi = x1pr+versatz; const double y1pi = -3; const double x2pi = x2pr+versatz+scalepi; const double y2pi = y1pi; TArrow *a; a = new TArrow(x1pr,y1pr,x2pr,y2pr,.01,">"); a->SetLineColor(24); a->Draw(); TLatex tl; tl.SetTextSize(20); tl.SetTextFont(4); tl.DrawLatex(x1pr,y2pr-1.2,"p(p) / 1 GeV"); a = new TArrow(x1pi,y1pi,x2pi,y2pi,.01,">"); a->SetLineColor(20); a->Draw(); tl.SetTextSize(20); tl.SetTextFont(4); tl.DrawLatex(x1pi,y2pi-1.2,"p(#pi) / 1 GeV"); } for (int i = 0; i!=maxN; i++) { t->GetEntry(i); const double thetapr = 2*TMath::ATan(TMath::Exp(-TMath::Abs(etapr))); const double thetapi = 2*TMath::ATan(TMath::Exp(-TMath::Abs(etapi))); const double x1=TMath::Abs(vzl0); const double y1=vrl0; const double x2pr=x1+scalepr*ppr*TMath::Cos(thetapr); const double y2pr=y1+scalepr*ppr*TMath::Sin(thetapr); const double x2pi=x1+scalepi*ppi*TMath::Cos(thetapi); const double y2pi=y1+scalepi*ppi*TMath::Sin(thetapi); TArrow *a; a = new TArrow(x1,y1,x2pr,y2pr,.01,">"); a->SetLineColor(24); a->Draw(); a = new TArrow(x1,y1,x2pi,y2pi,.01,">"); a->SetLineColor(20); a->Draw(); TMarker *m = new TMarker(x1,y1,7); m->SetMarkerColor(28); m->Draw(); } }
// ------------ method called for each event ------------ void LYZ::calcV(int way) //way=0: Prod way=1: Sum { using namespace std; TComplex g[ntheta][nstepr]; double Q[ntheta]; double Qx; double Qy; int mult, ntrk; Float_t phi[10000], eta[10000], pt[10000]; TFile *infile = TFile::Open(filename); TTree* t = (TTree*)infile->Get("tree"); t->SetBranchAddress("n",&mult); t->SetBranchAddress("ptg",pt); t->SetBranchAddress("phig",phi); t->SetBranchAddress("etag",eta); int nevent = t->GetEntries(); for(int ievt=0; ievt<nevent; ievt++){ t->GetEntry(ievt); // if(ievt%10000==0) cout<<"has processed "<<ievt<<" events"<<endl; for(int itheta=0;itheta<ntheta;itheta++){ Q[itheta]=0; for(int ir=0; ir<nstepr; ir++) if(way==0) g[itheta][ir]=1.; else g[itheta][ir]=0.; } Qx=0,Qy=0; ntrk = mult; int nTracks = ntrk; int xbin=-1; for(int j=0;j<nbin;j++) if(nTracks<trkbin[j]&&nTracks>=trkbin[j+1]) xbin=j; if(xbin<0 || xbin==nbin) continue; tottrk[xbin]+=ntrk; for(int imult=0;imult<mult;imult++){ // if(eta[imult]<-2.40||eta[imult]>2.40) continue; // if(pt[imult]<ptmin||pt[imult]>ptmax) continue; //event selection Qx+=1.*cos(nn*phi[imult]); Qy+=1.*sin(nn*phi[imult]); for(int itheta=0;itheta<ntheta;itheta++){ double temp=TMath::Cos(nn*(phi[imult]-theta[itheta])); for(int ir=0; ir<nstepr; ir++) if(way==0){ g[itheta][ir]*=TComplex(1.,r[xbin][ir]*temp); } // else // g[itheta][0]+=temp; } totptall[xbin]+=pt[imult]; totetaall[xbin]+=eta[imult]; totmultall[xbin]++; } Qx1[xbin]+=Qx; Qy1[xbin]+=Qy; Qx2[xbin]+=Qx*Qx; Qy2[xbin]+=Qy*Qy; for(int itheta=0;itheta<ntheta;itheta++){ Q[itheta]=Qx*TMath::Cos(nn*theta[itheta])+Qy*TMath::Sin(nn*theta[itheta]); for(int ir=0; ir<nstepr; ir++){ if(way!=0) g[itheta][ir]=TComplex::Exp(TComplex(0,r[xbin][ir]*Q[itheta]));//g[itheta][0] GRe[xbin][itheta][ir]+=g[itheta][ir].Re(); GIm[xbin][itheta][ir]+=g[itheta][ir].Im(); } } Nevent[xbin]++; } infile->Close(); }