//______________________________________________________________________________ TEveCaloDataVec* MakeVecData(Int_t ncells=0) { // Example how to fill data when bins can be iregular. // If ncells = 0 (default) whole histogram is taken, // otherwise just ncells cells around the maximum. TFile::SetCacheFileDir("."); TFile* hf = TFile::Open(histFile, "CACHEREAD"); TH2F* h1 = (TH2F*)hf->Get("ecalLego"); TH2F* h2 = (TH2F*)hf->Get("hcalLego"); TEveCaloDataVec* data = new TEveCaloDataVec(2); data->RefSliceInfo(0).Setup("ECAL", 0.3, kRed); data->RefSliceInfo(1).Setup("HCAL", 0.1, kBlue); TAxis *ax = h1->GetXaxis(); TAxis *ay = h1->GetYaxis(); Int_t xm = 1, xM = ax->GetNbins(); Int_t ym = 1, yM = ay->GetNbins(); if (ncells != 0) { Int_t cx, cy, cz; h1->GetMaximumBin(cx, cy, cz); xm = TMath::Max(xm, cx-ncells); xM = TMath::Min(xM, cx+ncells); ym = TMath::Max(ym, cy-ncells); yM = TMath::Min(yM, cy+ncells); } // Take every second cell and set a random size. for(Int_t i=xm; i<=xM; i+=2) { for(Int_t j=ym; j<=yM; j+=2) { if ( (i+j) % 3) { data->AddTower(ax->GetBinLowEdge(i), ax->GetBinUpEdge(i), ay->GetBinLowEdge(j), ay->GetBinUpEdge(j)); data->FillSlice(0, h1->GetBinContent(i, j)); data->FillSlice(1, h2->GetBinContent(i, j)); } else { data->AddTower(ax->GetBinLowEdge(i), 2 * ax->GetBinWidth(i) + ax->GetBinLowEdge(i), ay->GetBinLowEdge(j), 2 * ay->GetBinWidth(j) + ay->GetBinLowEdge(j)); data->FillSlice(0, h2->GetBinContent(i, j)); data->FillSlice(1, h2->GetBinContent(i, j)); } } } data->SetEtaBins(ax); data->SetPhiBins(ay); data->DataChanged(); return data; }
////////////////////////////////////////////////// // addXAxis - add X axis information unsigned int addXAxis(SEXP data, SEXP dataNames, unsigned int j, TH1* hist) { int n = hist->GetNbinsX(); TAxis* axis = hist->GetXaxis(); // Determine breaks-- // Add to list SEXP breaks = addNumericVector(data, dataNames, j++, n+1, "breaks"); // Get information for ( unsigned int i=0; i<n; ++i ) { NUMERIC_POINTER(breaks)[i] = axis->GetBinLowEdge(i+1); } // Add the high edge NUMERIC_POINTER(breaks)[n] = axis->GetBinUpEdge(n); // Determine mids-- SEXP mids = addNumericVector(data, dataNames, j++, n, "mids"); // Get information for ( unsigned int i=0; i<n; ++i ) { NUMERIC_POINTER(mids)[i] = axis->GetBinCenter(i+1); } // Get name of axis SEXP xname = addCharVector(data, dataNames, j++, 1, "xname"); SET_STRING_ELT( xname, 0, mkChar( axis->GetTitle() ) ); // Done return j; }
/** * Make a GraphSysErr object * * @param o Output stream * @param h Histogram * @param c1 Lower centrality bound * @param c2 Upper centrality bound * @param reweigh True if reweighed * @param fac Scaling factor */ void MakeGSE(std::ostream& o, const TH1* h, Double_t c1, Double_t c2, Bool_t reweigh, Double_t fac=1) { // These are correlated Double_t bgMid = CSysEval(c2, 100*0.02, 100*0.002); Double_t cSys = CSysEval(c2, 100*0.005, 100*0.075); Double_t strMid = 100*0.005; Double_t strFwd = 100*0.05; Double_t pidMid = 100*0; Double_t pidFwd = 100*0.01; // Double_t bgSys = (1-c1/100)*(2-0.2) + 0.2; // Double_t cSys = TMath::Power(c1/100,2)*(7.5-0.5) + 0.5; o << "*dataset:\n" << "*dscomment: The pseudo-rapidity density of charged particle\n" << "*reackey: PB PB --> CHARGED X\n" << "*obskey: DN/DETARAP\n" << "*qual: CENTRALITY IN PCT : " << c1 << " TO " << c2 << "\n" << "*qual: SQRT(S)/NUCLEON IN GEV : 5023\n"; if (!reweigh) { o << "*dserror: " << strMid << " PCT : Weak decays\n" << "*dserror: " << pidMid << " PCT : Particle composition\n" << "*dserror: " << bgMid << " PCT : Background subtraction\n"; } o << "*dserror: 1 PCT : pT extrapolation\n" << "*dserror: " << cSys << " PCT : Centrality\n" << "*xheader: ETARAP\n" << "*yheader: DN/DETARAP\n" << "*data: x : y" << std::endl; // Define points TAxis* xa = h->GetXaxis(); for (Int_t i = 0; i < h->GetNbinsX(); i++) { Int_t j = i+1; Double_t cc = h->GetBinContent(j)*fac; Double_t x = h->GetXaxis()->GetBinCenter(j); Double_t ex = h->GetXaxis()->GetBinWidth(j)/2; Double_t xo = TMath::Abs(x)+ex; if (cc < 1e-8) continue; o << " " << xa->GetBinLowEdge(j) << " TO " << xa->GetBinUpEdge(j) << "; " << cc << " +-" << h->GetBinError(j) << " (DSYS=" << 0.01+0.01*TMath::Power(xo/2,2) << " PCT:Acceptance"; if (reweigh) { Double_t bg = EtaSysEval(xo, bgMid, 3*bgMid); Double_t pid = EtaSysEval(xo, pidMid, pidFwd); Double_t str = EtaSysEval(xo, strMid, strFwd); o << ",DSYS=" << bg << " PCT:Background subtraction" << ",DSYS=" << pid << " PCT:Particle composition" << ",DSYS=" << str << " PCT:Weak decay"; } o << ");" << std::endl; } o << "*dataend:\n" << std::endl; }
void GetInt(TH1F *hzj,float xmin,float xmax,double& integralfull, double& integral) { TAxis *axis = hzj->GetXaxis(); int bmin = axis->FindBin(xmin); int bmax = axis->FindBin(xmax); integralfull = hzj->Integral(); integral = hzj->Integral(bmin,bmax); integral -= hzj->GetBinContent(bmin)*(xmin-axis->GetBinLowEdge(bmin))/axis->GetBinWidth(bmin); integral -= hzj->GetBinContent(bmax)*(axis->GetBinUpEdge(bmax)-xmax)/axis->GetBinWidth(bmax); fout<<"Full Integral: "<<integralfull<<endl; }
double integralInRange( TH1F * var_h, float lower, float upper ){ TAxis *axis = var_h->GetXaxis(); int bmin = axis->FindBin(lower); int bmax = axis->FindBin(upper); double integr = var_h->Integral(bmin,bmax); integr -= ( (var_h->GetBinContent(bmin)) * (lower - (axis->GetBinLowEdge(bmin))) )/ axis->GetBinWidth(bmin); integr -= ( (var_h->GetBinContent(bmax)) * ( (axis->GetBinUpEdge(bmax)) - upper) )/ axis->GetBinWidth(bmax); return integr; }
double integrate(TH1F* h, double xmin, double xmax){ TAxis *axis = h->GetXaxis(); int bmin = axis->FindBin(xmin); //in your case xmin=-1.5 int bmax = axis->FindBin(xmax); //in your case xmax=0.8 double integral = h->Integral(bmin,bmax); integral -= h->GetBinContent(bmin)*(xmin-axis->GetBinLowEdge(bmin))/axis->GetBinWidth(bmin); integral -= h->GetBinContent(bmax)*(axis->GetBinUpEdge(bmax)-xmax)/axis->GetBinWidth(bmax); return integral; }
void GetIntg(TH1F *hzj,float xmin,float xmax,double& count1, double& count2) { TAxis *axis = hzj->GetXaxis(); int bmin = axis->FindBin(xmin); int bmax = axis->FindBin(xmax); double integralfull = hzj->Integral(); double integral = hzj->Integral(bmin,bmax); integral -= hzj->GetBinContent(bmin)*(xmin-axis->GetBinLowEdge(bmin))/axis->GetBinWidth(bmin); integral -= hzj->GetBinContent(bmax)*(axis->GetBinUpEdge(bmax)-xmax)/axis->GetBinWidth(bmax); count1=count1+integralfull; count2=count2+integral; // cout<<count1<<'\t'<<count2<<endl; }
void Bin2DTree::constrainSplit(int axis, double& cut, bool& veto) /*****************************************************************/ { if(m_gridConstraint && !m_vetoSplitXY[axis]) { TAxis* gridAxis = NULL; if(axis==0) { gridAxis = m_gridConstraint->GetXaxis(); } else { gridAxis = m_gridConstraint->GetYaxis(); } // Find the closest grid constraint for the cut // And modify the cut according to this constraint int b = gridAxis->FindBin(cut); double low = gridAxis->GetBinLowEdge(b); double up = gridAxis->GetBinUpEdge(b); if(fabs(up-cut)<fabs(cut-low)) { cut = up; // If the constrained cut is outside the bin boundaries, try the other grid constraint if(cut>=getBinBoundaries()[axis].second) { cut = low; } } else { cut = low; // If the constrained cut is outside the bin boundaries, try the other grid constraint if(cut<=getBinBoundaries()[axis].first) { cut = up; } } // If the constrained cut is still outside the bin boundaries, veto this bin and axis if(cut<=getBinBoundaries()[axis].first || cut>=getBinBoundaries()[axis].second) { m_vetoSplitXY[axis] = true; } } veto = m_vetoSplitXY[axis]; }
TH1D* TH2toTH1(TH2D* h2, Int_t massbin) { TString massbinname = (TString)_s(massbin); TString origname = (TString)h2->GetName(); // origname.ReplaceAll("hg4Mass_template_",""); TString name = origname+"_mll_"+massbinname; //------------------------------------------------------------ const Int_t nbins = h2->GetNbinsY(); Double_t bins[nbins+1]; TAxis* yaxis = (TAxis*)h2->GetYaxis(); for(int i=0 ; i<nbins ; i++) bins[i] = yaxis->GetBinLowEdge(i+1); bins[nbins] = yaxis->GetBinUpEdge(nbins); //------------------------------------------------------------ TH1D* h1 = new TH1D(name,"#frac{dN}{dg^{4}};g^{4};dN/dg^{4}",nbins,bins); for(Int_t bin=1 ; bin<=nbins ; bin++) { h1->SetBinContent(bin, h2->GetBinContent(massbin+bins2chop,bin)); } return h1; }
inline TH1D* hGeV2TeV(TH1D* hGeV) { const Int_t nbins = hGeV->GetNbinsX(); Double_t bins[nbins+1]; TAxis* xaxis = (TAxis*)hGeV->GetXaxis(); TAxis* yaxis = (TAxis*)hGeV->GetYaxis(); for(int i=0 ; i<nbins ; i++) { bins[i] = xaxis->GetBinLowEdge(i+1)/1000.; cout << "|" << bins[i]; } bins[nbins] = xaxis->GetBinUpEdge(nbins)/1000.; cout << "|" << bins[nbins] << "|" << endl; TString name = (TString)hGeV->GetName(); TString title = (TString)hGeV->GetTitle(); TString xtitle = (TString)xaxis->GetTitle(); TString ytitle = (TString)yaxis->GetTitle(); TH1D* hTeV = new TH1D(name+"_TeV",title+";"+xtitle+";"+ytitle, nbins,bins); for(Int_t b=0 ; b<=nbins+1 ; b++) hTeV->SetBinContent(b, hGeV->GetBinContent(b)); return hTeV; }
TauAnalysisSelector::TauAnalysisSelector(const std::string& puWeight, bool isEmbedded, const std::string& embeddingWTauMuFile, const std::string& embeddingWTauMuPath, const std::string& mcTauMultiplicity, const std::string& mcTauMode, const std::string& embeddingNormalizationMode, TH1 *embeddingMuonWeights): BaseSelector(), //fMuons("Emb"), fGenTaus(isEmbedded ? "gentausOriginal" : "gentaus", true), fGenTausEmbedded("gentausEmbedded", true), fPuWeightName(puWeight), fIsEmbedded(isEmbedded), fEmbeddingWTauMuWeights(0), fMCTauMultiplicity(parseMCTauMultiplicity(mcTauMultiplicity)), fMCTauMode(parseMCTauMode(mcTauMode)), fEmbeddingNormalizationMode(parseEmbeddingNormalizationMode(embeddingNormalizationMode)), fEmbeddingMuonWeights(embeddingMuonWeights), cAll(fEventCounter.addCounter("All events")), //cElectronVeto(fEventCounter.addCounter("Electron veto")), cGeneratorWeight(fEventCounter.addCounter("Vis. pt weight")), cTauBRWeight(fEventCounter.addCounter("Tau BR weighting")), cGenTauFound(fEventCounter.addCounter("Gen tau found")), cTauMCSelection(fEventCounter.addCounter("Tau MC requirement")), cOnlyWMu(fEventCounter.addCounter("Only W->mu")), cWTauMuWeight(fEventCounter.addCounter("W->tau->mu weighting")), cTriggerEffWeight(fEventCounter.addCounter("Muon trigger eff weighting")), cIdEffWeight(fEventCounter.addCounter("Muon ID eff weighting")), cMuonWeight(fEventCounter.addCounter("Muon corr weighting (from argument)")), cJetSelection(fEventCounter.addCounter("Jet selection")), cPrimaryVertex(fEventCounter.addCounter("Primary vertex")), cAllTauCandidates(fEventCounter.addCounter(">= 1 tau candidate")), cPrePtCut(fEventCounter.addCounter("Pre Pt cut")), cDecayModeFinding(fEventCounter.addCounter("Decay mode finding")), cEtaCut(fEventCounter.addCounter("Eta cut")), cPtCut(fEventCounter.addCounter("Pt cut")), cLeadingTrackPtCut(fEventCounter.addCounter("Leading track pt")), cEcalCracks(fEventCounter.addCounter("ECAL fiducial: cracks")), cEcalGap(fEventCounter.addCounter("ECAL fiducial: gap")), cAgainstElectron(fEventCounter.addCounter("Against electron")), cAgainstMuon(fEventCounter.addCounter("Against muon")), cIsolation(fEventCounter.addCounter("Isolation")), cOneProng(fEventCounter.addCounter("One prong")), cRtau(fEventCounter.addCounter("Rtau")), cMuTrigger(fEventCounter.addCounter("Mu trigger")) { if(isEmbedded && !embeddingWTauMuFile.empty()) { TFile *file = TFile::Open(embeddingWTauMuFile.c_str()); TEfficiency *eff = dynamic_cast<TEfficiency *>(file->Get(embeddingWTauMuPath.c_str())); TAxis *xaxis = eff->GetPassedHistogram()->GetXaxis(); fEmbeddingWTauMuWeights = new TH1F("weights", "weights", xaxis->GetNbins(), xaxis->GetBinLowEdge(xaxis->GetFirst()), xaxis->GetBinUpEdge(xaxis->GetLast())); fEmbeddingWTauMuWeights->SetDirectory(0); for(int bin=1; bin <= xaxis->GetNbins(); ++bin) { fEmbeddingWTauMuWeights->SetBinContent(bin, eff->GetEfficiency(bin)); std::cout << "Bin " << bin << " low edge " << fEmbeddingWTauMuWeights->GetXaxis()->GetBinLowEdge(bin) << " value " << fEmbeddingWTauMuWeights->GetBinContent(bin) << std::endl; } fEmbeddingWTauMuWeights->SetBinContent(xaxis->GetNbins()+1, fEmbeddingWTauMuWeights->GetBinContent(xaxis->GetNbins())); file->Close(); } if(isEmbedded) { fMuons.setIdEfficiencyName("efficiency_Run2011AB"); fMuons.setTriggerEfficiencyName("efficiency_trigger"); } }
TH1F *QCD_MatrixMethod_qcdhist(TH1F *looseH, TH1F *tightH, TH1F*epsqcd_hist, Double_t EpsSig, Double_t EpsSigErr,Bool_t makeGlobal, Double_t *NQCD_glob, Double_t *NQCD_glob_err, Bool_t witherror) { printf("we use the histo method for qcd determination!\n"); Double_t EpsQCD=0.0; Double_t EpsQCDErr=0.0; Int_t binhelp=0; TH1F *QCDH(0); char NewName[500], NewTitle[500], NewHist[1000]; sprintf(NewName,"%s_QCD",looseH->GetName()); TAxis *xaxis = looseH ->GetXaxis(); TAxis *yaxis = looseH->GetYaxis(); Int_t Nbins=looseH->GetNbinsX(); Double_t firstbinx= xaxis->GetBinLowEdge(1); Double_t lastbin= xaxis->GetBinUpEdge(Nbins); const char* xTitle=xaxis->GetTitle(); const char* yTitle=yaxis->GetTitle(); sprintf(NewTitle,"%s - QCD-Histogramm",xTitle); sprintf(NewHist,"%s;%s;%s",NewTitle, xTitle ,yTitle); // for global: number of QCD-Background alltogether Double_t NQCD_all=0.0, NQCD_all_Error=0.0 ; // The same idea as in QCD_MatrixMethod but this time assume Loose, // Tight and EpsilonQCD are histograms with several bins (instead of // scalar values). Thus calculate NQCD_all as a sum of corresponding // values per bin. for(Int_t i=0;i<Nbins;i++) { if(i<12) //just to have not too crappy values { binhelp=epsqcd_hist->FindBin(looseH->GetBinCenter(i+1)); EpsQCD=epsqcd_hist->GetBinContent(binhelp); EpsQCDErr=epsqcd_hist->GetBinError(binhelp); } Double_t NQCD_all_help=(EpsSig*looseH->GetBinContent(i+1)- tightH->GetBinContent(i+1))/(EpsSig - EpsQCD); // if(NQCD_all_help>0.0) NQCD_all+=EpsQCD*NQCD_all_help; Double_t N1=looseH->GetBinContent(i+1) - tightH->GetBinContent(i+1); // Double_t N1Error=TMath::Sqrt(N1); Double_t N1Error=TMath::Sqrt(pow(looseH->GetBinError(i+1),2.0) - pow(tightH->GetBinError(i+1),2.0)); Double_t N2=tightH->GetBinContent(i+1); // Double_t N2Error=TMath::Sqrt(N2); Double_t N2Error=tightH->GetBinError(i+1); Double_t NtQEpsSig=EpsQCD*(N2 - EpsQCD* (N1 + N2))/pow((EpsSig - EpsQCD),2); Double_t NtQEpsQCD=EpsSig*(EpsSig*(N1+N2) - N2 )/pow((EpsSig - EpsQCD),2); Double_t NtQN1=EpsQCD*EpsSig/(EpsSig - EpsQCD); Double_t NtQN2=EpsQCD*(EpsSig-1)/(EpsSig - EpsQCD); Double_t binContentErrorSquare=pow(NtQEpsSig,2)*pow(EpsSigErr,2) + pow(NtQEpsQCD,2)*pow(EpsQCDErr,2) + pow(NtQN1,2)*pow(N1Error,2) + pow(NtQN2,2)* pow(N2Error,2); Double_t binContentError=TMath::Sqrt(binContentErrorSquare); // if(NQCD_all_help>0.0) NQCD_all_Error+=binContentErrorSquare; // printf("Anzahl QCD gesamt:%f, Fehler dieser Anzahl:%f\n\n",NQCD_gesamt,NQCD_gesamt_Error); } // End loop over bins NQCD_all_Error=TMath::Sqrt(NQCD_all_Error); // End for global if(makeGlobal && NQCD_glob) { *NQCD_glob=NQCD_all; if(NQCD_glob_err) *NQCD_glob_err=NQCD_all_Error; return QCDH; } QCDH=new TH1F(NewName,NewHist,Nbins,firstbinx, lastbin); QCDH->Sumw2(); for(Int_t i=0;i<Nbins;i++) { if(i<12) //just to have not too crappy values { binhelp=epsqcd_hist->FindBin(looseH->GetBinCenter(i+1)); EpsQCD=epsqcd_hist->GetBinContent(binhelp); EpsQCDErr=epsqcd_hist->GetBinError(binhelp); } Double_t binContentloose=looseH->GetBinContent(i+1); Double_t binContenttight=tightH->GetBinContent(i+1); Double_t NQCD=(EpsSig*binContentloose - binContenttight)/(EpsSig - EpsQCD); Double_t binContent=EpsQCD*NQCD; // QCDEffizienz+= binContent; if(binContent <0.0) binContent=0.0; QCDH->SetBinContent(i+1,binContent); // printf("QCDEffizienz:%f\n",QCDEffizienz); if(witherror) { Double_t N1=binContentloose - binContenttight; // Double_t N1Error=TMath::Sqrt(N1); Double_t N1Error=TMath::Sqrt(looseH->GetBinError(i+1) - tightH->GetBinError(i+1)); Double_t N2=binContenttight; // Double_t N2Error=TMath::Sqrt(N2); Double_t N2Error=TMath::Sqrt(tightH->GetBinError(i+1)); Double_t NtQEpsSig=EpsQCD*(N2 - EpsQCD* (N1 + N2))/pow((EpsSig - EpsQCD),2); Double_t NtQEpsQCD=EpsSig*(EpsSig*(N1+N2) - N2 )/pow((EpsSig - EpsQCD),2); Double_t NtQN1=EpsQCD*EpsSig/(EpsSig - EpsQCD); Double_t NtQN2=EpsQCD*(EpsSig-1)/(EpsSig - EpsQCD); Double_t binContentErrorSquare=pow(NtQEpsSig,2)*pow(EpsSigErr,2) + pow(NtQEpsQCD,2)*pow(EpsQCDErr,2) + pow(NtQN1,2)*pow(N1Error,2) + pow(NtQN2,2)* pow(N2Error,2); Double_t binContentError=TMath::Sqrt(binContentErrorSquare); QCDH->SetBinError(i+1,binContentError); } } return QCDH; }
TH1F *QCD_MatrixMethod(TH1F *looseH, TH1F *tightH, Double_t EpsQCD, Double_t EpsSig, Double_t EpsQCDErr, Double_t EpsSigErr,Bool_t makeGlobal, Double_t *NQCD_glob, Double_t *NQCD_glob_err, Bool_t witherror,Double_t *NW_glob, Double_t *NW_glob_err) { TH1F *QCDH(0); char NewName[500], NewTitle[500], NewHist[1000]; sprintf(NewName,"%s_QCD",looseH->GetName()); TAxis *xaxis = looseH ->GetXaxis(); TAxis *yaxis = looseH->GetYaxis(); Int_t Nbins=looseH->GetNbinsX(); Double_t firstbinx= xaxis->GetBinLowEdge(1); Double_t lastbin= xaxis->GetBinUpEdge(Nbins); const char* xTitle=xaxis->GetTitle(); const char* yTitle=yaxis->GetTitle(); sprintf(NewTitle,"%s - QCD-Histogramm",xTitle); sprintf(NewHist,"%s;%s;%s",NewTitle, xTitle ,yTitle); // for global: number of QCD-Background alltogether Double_t NQCD_all=0.0, NQCD_all_Error=0.0 ; Double_t NW_all=0.0, NW_all_Error=0.0 ; // Functions with one bin only that would count how many loose or tight // events are there. TH1F *qcd_all_loose=new TH1F(hn(),"total number of QCD events",1,0.0,1.0); TH1F *qcd_all_tight=new TH1F(hn(),"total number of QCD events",1,0.0,1.0); qcd_all_loose->Sumw2(); qcd_all_tight->Sumw2(); // Count events for(Int_t i=0;i<=Nbins;i++) { Double_t binContentloose=looseH->GetBinContent(i+1); Double_t binContenttight=tightH->GetBinContent(i+1); qcd_all_loose->Fill(0.5,binContentloose); qcd_all_tight->Fill(0.5,binContenttight); } for(Int_t i=0;i<1;i++) { NQCD_all=(EpsSig*qcd_all_loose->GetBinContent(i+1)- qcd_all_tight->GetBinContent(i+1))/(EpsSig - EpsQCD); NQCD_all=EpsQCD*NQCD_all; Double_t N1=qcd_all_loose->GetBinContent(i+1) - qcd_all_tight->GetBinContent(i+1); // Double_t N1Error=TMath::Sqrt(N1); // Double_t N1Error=TMath::Sqrt(pow(qcd_all_loose->GetBinError(i+1),2.0) - pow(qcd_all_tight->GetBinError(i+1),2.0)); Double_t N1Error=TMath::Sqrt(N1); Double_t N2=qcd_all_tight->GetBinContent(i+1); // Double_t N2Error=TMath::Sqrt(N2); // Double_t N2Error=qcd_all_tight->GetBinError(i+1); Double_t N2Error=TMath::Sqrt(N2); Double_t NtQEpsSig=EpsQCD*(N2 - EpsQCD* (N1 + N2))/pow((EpsSig - EpsQCD),2); Double_t NtQEpsQCD=EpsSig*(EpsSig*(N1+N2) - N2 )/pow((EpsSig - EpsQCD),2); Double_t NtQN1=EpsQCD*EpsSig/(EpsSig - EpsQCD); Double_t NtQN2=EpsQCD*(EpsSig-1)/(EpsSig - EpsQCD); Double_t binContentErrorSquare=pow(NtQEpsSig,2)*pow(EpsSigErr,2) + pow(NtQEpsQCD,2)*pow(EpsQCDErr,2) + pow(NtQN1,2)*pow(N1Error,2) + pow(NtQN2,2)* pow(N2Error,2); Double_t binContentError=TMath::Sqrt(binContentErrorSquare); NQCD_all_Error=binContentError; // printf("N1: %f N2: %f\n", N1, N2); // printf("NtQEpsSig: %f NtQEpsQCD:%f %f %f %f\n", NtQEpsSig, NtQEpsQCD, N2 - EpsQCD* (N1 + N2), EpsSig*(N1+N2) - N2 , pow((EpsSig - EpsQCD),2)); // printf("the bin error: %f where value is %f\n", binContentError, NQCD_all); // printf("the single contributions: %f %f %f %f\n", pow(NtQEpsSig,2)*pow(EpsSigErr,2),pow(NtQEpsQCD,2)*pow(EpsQCDErr,2), pow(NtQN1,2)*pow(N1Error,2), pow(NtQN2,2)* pow(N2Error,2)); // printf("Anzahl QCD gesamt:%f, Fehler dieser Anzahl:%f\n\n",NQCD_gesamt,NQCD_gesamt_Error); } // End for global if(makeGlobal && NQCD_glob) { //set the NQCD value to 0 if it's smaller if(NQCD_all < 0.0) NQCD_all=0.0; *NQCD_glob=NQCD_all; if(NQCD_glob_err) *NQCD_glob_err=NQCD_all_Error; } for(Int_t i=0;i<1;i++) { NW_all=( qcd_all_tight->GetBinContent(i+1) - EpsQCD * qcd_all_loose->GetBinContent(i+1))/(EpsSig - EpsQCD); NW_all=EpsSig*NW_all; Double_t N1=qcd_all_loose->GetBinContent(i+1) - qcd_all_tight->GetBinContent(i+1); // Double_t N1Error=TMath::Sqrt(N1); // Double_t N1Error=TMath::Sqrt(pow(qcd_all_loose->GetBinError(i+1),2.0) - pow(qcd_all_tight->GetBinError(i+1),2.0)); Double_t N1Error=TMath::Sqrt(N1); Double_t N2=qcd_all_tight->GetBinContent(i+1); // Double_t N2Error=TMath::Sqrt(N2); // Double_t N2Error=qcd_all_tight->GetBinError(i+1); Double_t N2Error=TMath::Sqrt(N2); Double_t NtWEpsSig=EpsQCD*(N2 - EpsQCD* (N1 + N2))/pow((EpsSig - EpsQCD),2); Double_t NtWEpsQCD=EpsSig*(EpsSig*(N1+N2) - N2 )/pow((EpsSig - EpsQCD),2); Double_t NtWN1=EpsQCD*EpsSig/(EpsSig - EpsQCD); Double_t NtWN2=EpsSig*(1-EpsQCD)/(EpsSig - EpsQCD); Double_t binContentErrorSquare=pow(NtWEpsSig,2)*pow(EpsSigErr,2) + pow(NtWEpsQCD,2)*pow(EpsQCDErr,2) + pow(NtWN1,2)*pow(N1Error,2) + pow(NtWN2,2)* pow(N2Error,2); Double_t binContentError=TMath::Sqrt(binContentErrorSquare); NW_all_Error=binContentError; // printf("N1: %f N2: %f\n", N1, N2); // printf("NtQEpsSig: %f NtQEpsQCD:%f %f %f %f\n", NtQEpsSig, NtQEpsQCD, N2 - EpsQCD* (N1 + N2), EpsSig*(N1+N2) - N2 , pow((EpsSig - EpsQCD),2)); // printf("the bin error: %f where value is %f\n", binContentError, NQCD_all); // printf("the single contributions: %f %f %f %f\n", pow(NtQEpsSig,2)*pow(EpsSigErr,2),pow(NtQEpsQCD,2)*pow(EpsQCDErr,2), pow(NtQN1,2)*pow(N1Error,2), pow(NtQN2,2)* pow(N2Error,2)); // printf("Anzahl QCD gesamt:%f, Fehler dieser Anzahl:%f\n\n",NQCD_gesamt,NQCD_gesamt_Error); } // End for global if(makeGlobal && NW_glob) { //set the NQCD value to 0 if it's smaller if(NW_all < 0.0) NW_all=0.0; *NW_glob=NW_all; if(NW_glob_err) *NW_glob_err=NW_all_Error; return QCDH; } if(makeGlobal && NQCD_glob) { return QCDH; } // Create QCDH histogram QCDH=new TH1F(NewName,NewHist,Nbins,firstbinx, lastbin); QCDH->Sumw2(); for(Int_t i=0;i<Nbins;i++) { Double_t binContentloose=looseH->GetBinContent(i+1); Double_t binContenttight=tightH->GetBinContent(i+1); Double_t NQCD=(EpsSig*binContentloose - binContenttight)/(EpsSig - EpsQCD); Double_t binContent=EpsQCD*NQCD; // QCDEffizienz+= binContent; if(binContent <0.0) binContent=0.0; QCDH->SetBinContent(i+1,binContent); // printf("QCDEffizienz:%f\n",QCDEffizienz); if(witherror) { Double_t N1=binContentloose - binContenttight; // Double_t N1Error=TMath::Sqrt(N1); // Double_t N1Error=TMath::Sqrt(looseH->GetBinError(i+1) - tightH->GetBinError(i+1)); Double_t N1Error=TMath::Sqrt(N1); Double_t N2=binContenttight; // Double_t N2Error=TMath::Sqrt(N2); // Double_t N2Error=TMath::Sqrt(tightH->GetBinError(i+1)); Double_t N2Error=TMath::Sqrt(N2); Double_t NtQEpsSig=EpsQCD*(N2 - EpsQCD* (N1 + N2))/pow((EpsSig - EpsQCD),2); Double_t NtQEpsQCD=EpsSig*(EpsSig*(N1+N2) - N2 )/pow((EpsSig - EpsQCD),2); Double_t NtQN1=EpsQCD*EpsSig/(EpsSig - EpsQCD); Double_t NtQN2=EpsQCD*(EpsSig-1)/(EpsSig - EpsQCD); Double_t binContentErrorSquare=pow(NtQEpsSig,2)*pow(EpsSigErr,2) + pow(NtQEpsQCD,2)*pow(EpsQCDErr,2) + pow(NtQN1,2)*pow(N1Error,2) + pow(NtQN2,2)* pow(N2Error,2); Double_t binContentError=TMath::Sqrt(binContentErrorSquare); QCDH->SetBinError(i+1,binContentError); } } return QCDH; }
void memstat(double update=0.01, const char* fname="*") { // Open the memstat data file, then call TTree::Draw to precompute // the arrays of positions and nbytes per entry. // update is the time interval in the data file in seconds after which // the display is updated. For example is the job producing the memstat.root file // took 100s to execute, an update of 0.1s will generate 1000 time views of // the memory use. // if fname=="*" (default), the most recent file memstat*.root will be taken. TString s; if (!fname || strlen(fname) <5 || strstr(fname,"*")) { //take the most recent file memstat*.root s = gSystem->GetFromPipe("ls -lrt memstat*.root"); Int_t ns = s.Length(); fname = strstr(s.Data()+ns-25,"memstat"); } printf("Analyzing file: %s\n",fname); f = TFile::Open(fname); if (!f) { printf("Cannot open file %s\n",fname); return; } T = (TTree*)f->Get("T"); if (!T) { printf("cannot find the TMemStat TTree named T in file %s\n",fname); return; } if (update <= 0) { printf("Illegal update value %g, changed to 0.01\n",update); update = 0.01; } if (update < 0.001) printf("Warning update parameter is very small, processing may be slow\n"); Long64_t nentries = T->GetEntries(); T->SetEstimate(nentries+10); Long64_t nsel = T->Draw("pos:nbytes:time:btid","","goff"); //now we compute the best binning for the histogram Int_t nbytes; Double_t pos; V1 = T->GetV1(); V2 = T->GetV2(); V3 = T->GetV3(); V4 = T->GetV4(); Long64_t imean = (Long64_t)TMath::Mean(nsel,V1); Long64_t irms = (Long64_t)TMath::RMS(nsel,V1); //Long64_t bw = 10000; Long64_t bw = 1000; imean = imean - imean%bw; irms = irms -irms%bw; Int_t nbins = Int_t(4*irms/bw); Long64_t ivmin = imean -bw*nbins/2; Long64_t ivmax = ivmin+bw*nbins; if (ivmax > 2000000000 && ivmin <2000000000) { //the data set has been likely generated on a 32 bits machine //we are mostly interested by the small allocations, so we select //only values below 2 GBytes printf("memory locations above 2GBytes will be ignored\n"); nsel = T->Draw("pos:nbytes:time:btid","pos <2e9","goff"); V1 = T->GetV1(); V2 = T->GetV2(); V3 = T->GetV3(); V4 = T->GetV4(); imean = (Long64_t)TMath::Mean(nsel,V1); irms = (Long64_t)TMath::RMS(nsel,V1); bw = 10000; imean = imean - imean%bw; irms = irms -irms%bw; nbins = Int_t(4*irms/bw); ivmin = imean -bw*nbins/2; ivmax = ivmin+bw*nbins; } update *= 0.0001*V3[nsel-1]; //convert time per cent in seconds Long64_t nvm = Long64_t(ivmax-ivmin+1); Long64_t *nbold = new Long64_t[nvm]; Int_t *ientry = new Int_t[nvm]; memset(nbold,0,nvm*8); Double_t dv = (ivmax-ivmin)/nbins; h = new TH1D("h",Form("%s;pos;per cent of pages used",fname),nbins,ivmin,ivmax); TAxis *axis = h->GetXaxis(); gStyle->SetOptStat("ie"); h->SetFillColor(kRed); h->SetMinimum(0); h->SetMaximum(100); halloc = new TH1D("halloc",Form("%s;pos;number of mallocs",fname),nbins,ivmin,ivmax); hfree = new TH1D("hfree", Form("%s;pos;number of frees",fname),nbins,ivmin,ivmax); //open a canvas and draw the empty histogram TCanvas *c1 = new TCanvas("c1","c1",1200,600); c1->SetFrameFillColor(kYellow-3); c1->SetGridx(); c1->SetGridy(); h->Draw(); //create a TPaveText to show the summary results TPaveText *pvt = new TPaveText(.5,.9,.75,.99,"brNDC"); pvt->Draw(); //create a TPaveLabel to show the time TPaveLabel *ptime = new TPaveLabel(.905,.7,.995,.76,"time","brNDC"); ptime->SetFillColor(kYellow-3); ptime->Draw(); //draw producer identifier TNamed *named = (TNamed*)T->GetUserInfo()->FindObject("SysInfo"); TText tmachine; tmachine.SetTextSize(0.02); tmachine.SetNDC(); if (named) tmachine.DrawText(0.01,0.01,named->GetTitle()); //start loop on selected rows Int_t bin,nb=0,j; Long64_t ipos; Double_t dbin,rest,time; Double_t updateLast = 0; Int_t nleaks = 0; Int_t i; for (i=0;i<nsel;i++) { pos = V1[i]; ipos = (Long64_t)(pos-ivmin); nbytes = (Int_t)V2[i]; time = 0.0001*V3[i]; bin = axis->FindBin(pos); if (bin<1 || bin>nbins) continue; dbin = axis->GetBinUpEdge(bin)-pos; if (nbytes > 0) { halloc->Fill(pos); if (dbin > nbytes) dbin = nbytes; //fill bytes in the first page h->AddBinContent(bin,100*dbin/dv); //fill bytes in full following pages nb = Int_t((nbytes-dbin)/dv); if (bin+nb >nbins) nb = nbins-bin; for (j=1;j<=nb;j++) h->AddBinContent(bin+j,100); //fill the bytes remaining in last page rest = nbytes-nb*dv-dbin; if (rest > 0) h->AddBinContent(bin+nb+1,100*rest/dv); //we save nbytes at pos. This info will be used when we free this slot if (nbold[ipos] > 0) printf("reallocating %d bytes (was %lld) at %lld, entry=%d\n",nbytes,nbold[ipos],ipos,i); if (nbold[ipos] == 0) { nleaks++; //save the Tree entry number where we made this allocation ientry[ipos] = i; } nbold[ipos] = nbytes; } else { hfree->Fill(pos); nbytes = nbold[ipos]; if (bin+nb >nbins) nb = nbins-bin; nbold[ipos] = 0; nleaks--; if (nbytes <= 0) continue; //fill bytes free in the first page if (dbin > nbytes) dbin = nbytes; h->AddBinContent(bin,-100*dbin/dv); //fill bytes free in full following pages nb = Int_t((nbytes-dbin)/dv); if (bin+nb >nbins) nb = nbins-bin; for (j=1;j<=nb;j++) h->AddBinContent(bin+j,-100); //fill the bytes free in in last page rest = nbytes-nb*dv-dbin; if (rest > 0) h->AddBinContent(bin+nb+1,-100*rest/dv); } if (time -updateLast > update) { //update canvas at regular intervals updateLast = time; h->SetEntries(i); c1->Modified(); pvt->GetListOfLines()->Delete(); Double_t mbytes = 0; Int_t nonEmpty = 0; Double_t w; for (Int_t k=1;k<nbins;k++) { w = h->GetBinContent(k); if (w > 0) { nonEmpty++; mbytes += 0.01*w*dv; } } Double_t occupancy = mbytes/(nonEmpty*0.01*dv); pvt->AddText(Form("memory used = %g Mbytes",mbytes*1e-6)); pvt->AddText(Form("page occupancy = %f per cent",occupancy)); pvt->AddText("(for non empty pages only)"); ptime->SetLabel(Form("%g sec",time)); c1->Update(); gSystem->ProcessEvents(); } } h->SetEntries(nsel); Int_t nlmax = nleaks; nleaks += 1000; Int_t *lindex = new Int_t[nleaks]; Int_t *entry = new Int_t[nleaks]; Int_t *ileaks = new Int_t[nleaks]; nleaks =0; for (Int_t ii=0;ii<nvm;ii++) { if (nbold[ii] > 0) { ileaks[nleaks] = (Int_t)nbold[ii]; entry[nleaks] = ientry[ii]; nleaks++; if (nleaks > nlmax) break; } } TMath::Sort(nleaks,ileaks,lindex); hentry = new TH1I("hentry","leak entry index",nleaks,0,nleaks); hleaks = new TH1I("hleaks","leaks;leak number;nbytes in leak",nleaks,0,nleaks); for (Int_t k=0;k<nleaks;k++) { Int_t kk = lindex[k]; i = entry[kk]; hentry->SetBinContent(k+1,i); hleaks->SetBinContent(k+1,ileaks[kk]); } hentry->SetEntries(nleaks); hleaks->SetEntries(nleaks); //open a second canvas and draw the histogram with leaks in decreasing order TCanvas *c2 = new TCanvas("c2","c2",1200,600); c2->SetFrameFillColor(kCyan-6); c2->SetGridx(); c2->SetGridy(); c2->SetLogy(); hleaks->SetFillColor(kRed-3); if (nleaks > 1000) hleaks->GetXaxis()->SetRange(1,1000); hleaks->Draw(); //draw producer identifier if (named) tmachine.DrawText(0.01,0.01,named->GetTitle()); //construct the tooltip TRootCanvas *rc = (TRootCanvas *)c2->GetCanvasImp(); TGMainFrame *frm = dynamic_cast<TGMainFrame *>(rc); // create the tooltip with a timeout of 250 ms if (!gTip) gTip = new TGToolTip(gClient->GetDefaultRoot(), frm, "", 250); c2->Connect("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)", 0, 0, "EventInfo(Int_t, Int_t, Int_t, TObject*)"); }
void compare() { msglvl[DBG] = SILENT; msglvl[INF] = VISUAL; msglvl[WRN] = VISUAL; msglvl[ERR] = VISUAL; msglvl[FAT] = VISUAL; TDirectory* oldDir = gDirectory; style(); TFile* f2ds = NULL; TFile* f2d = NULL; TH2D* h2ds = NULL; TH2D* h2d = NULL; TH1D* h1s = NULL; TH1D* h1 = NULL; TH1D* h1dy = NULL; Int_t g4bin = 50; TString model = "ZP"; int imassmin = 330; int imassmax = 4930; int dimass = 100; for(int imass=imassmin ; imass<=imassmax ; imass+=dimass) { TString mass = (TString)_s(imass); _INFO("enter "+(string)mass); TString modeltmp = (model=="ZP") ? "P" : "KK"; oldDir->cd(); f2ds = new TFile("~yiftahsi/KK_analysis_t301/2dtemplates_FEB1/templates2d_Xmass"+mass+".root","READ"); h2ds = (TH2D*)f2ds->Get("h2"+model+"/Z"+modeltmp+"_mXp"+mass)->Clone(); f2d = new TFile("~yiftahsi/KK_analysis_t301/2dtemplates_FEB2/templates2d_Xmass"+mass+".root","READ"); h2d = (TH2D*)f2d->Get("h2"+model+"/Z"+modeltmp+"_mXp"+mass)->Clone(); oldDir->cd(); //------------------------------------------------------------ const Int_t nbins = h2d->GetNbinsX(); Double_t bins[nbins+1]; TAxis* xaxis = (TAxis*)h2d->GetXaxis(); for(int i=0 ; i<nbins ; i++) bins[i] = xaxis->GetBinLowEdge(i+1); bins[nbins] = xaxis->GetBinUpEdge(nbins); //------------------------------------------------------------ Double_t g4 = h2d->GetYaxis()->GetBinLowEdge(g4bin); TString g = (TString)_s(sqrt(sqrt(g4)),2); TString modelname = (model=="ZP") ? "Z'" : "KK"; h1s = new TH1D(mass+"_subtracted","g="+g+", m_{"+modelname+"} = "+mass+" GeV;m_{ee} TeV;Events",nbins,bins); h1 = new TH1D(mass+"_inamplitude","g="+g+", m_{"+modelname+"} = "+mass+" GeV;m_{ee} TeV;Events",nbins,bins); h1dy = new TH1D(mass+"_dy","g="+g+", m_{"+modelname+"} = "+mass+" GeV;m_{ee} TeV;Events",nbins,bins); for(Int_t bin=0 ; bin<=nbins+1 ; bin++) { h1s->SetBinContent(bin, h2ds->GetBinContent(bin,g4bin)); h1->SetBinContent(bin, h2d->GetBinContent(bin,g4bin)); h1dy->SetBinContent(bin, h2d->GetBinContent(bin,1)); } TLegend* leg = new TLegend(0.55,0.72,0.85,0.85,NULL,"brNDC"); leg->SetFillStyle(4000); //will be transparent leg->SetFillColor(0); leg->SetTextFont(42); TCanvas* c = new TCanvas("c"+mass,"c"+mass,600,400); c->Draw(); c->cd(); c->SetTicks(1,1); c->SetLogy(); c->SetLogx(); c->SetGridy(); c->cd(); double ymin = getYmin(h1s); ymin = (getYmin(h1dy)<ymin) ? getYmin(h1dy): ymin; h1dy->SetMinimum( ymin*0.1); TLine* l = new TLine(0.12805,h1dy->GetMinimum(),0.12805,h1dy->GetMaximum()); l->SetLineColor(kGreen+2); h1dy->SetLineColor(kBlue); h1dy->SetLineStyle(1); h1dy->SetLineWidth(2); leg->AddEntry(h1dy,"DY, in-amplitude k_{F}","l"); h1dy->DrawCopy(); h1s->SetLineColor(kBlack); h1s->SetLineStyle(1); h1s->SetLineWidth(2); leg->AddEntry(h1s,modelname+", subtracted k_{F}","l"); h1s->DrawCopy("SAMES"); h1->SetLineColor(kRed); h1->SetLineStyle(3); h1->SetLineWidth(2); leg->AddEntry(h1,modelname+", in-amplitude k_{F}","l"); h1->DrawCopy("SAMES"); l->Draw("SAMES"); leg->Draw("SAMES"); _INFO("done "+(string)mass); c->RedrawAxis(); c->Update(); g.ReplaceAll(".",""); if(imass==imassmin) c->SaveAs("kfactors_g"+model+g+".pdf("); else if(imass==imassmax) c->SaveAs("kfactors_g"+model+g+".pdf)"); else c->SaveAs("kfactors_g"+model+g+".pdf"); } }
void writeSignalHistosForModel(std::vector<TH1D *>& vsd, const TString& sigmodel, TFile *allHistFile) { for (int ichan=0; ichan<NUMCHAN; ichan++) { TH1D * sdh = vsd[ichan]; // Find limit window from gaussian fit to signal peak. // double wid = sdh->GetRMS(); double mean = sdh->GetMean(); //TCanvas *c1 = new TCanvas(s,s,300,300); TFitResultPtr r = sdh->Fit("gaus","QNS","",mean-2.5*wid,mean+2.5*wid); cout<<" mean= "<<mean<<", RMS= "<<wid<<", Fit sigma= "<<r->Parameter(2)<<endl; //cout<<r->Parameter(0)<<" "<<r->Parameter(1)<<" "<<r->Parameter(2)<<endl; TAxis *xax = sdh->GetXaxis(); #if 0 int lobin = xax->FindFixBin(r->Parameter(1)-2*r->Parameter(2)); int hibin = xax->FindFixBin(r->Parameter(1)+2*r->Parameter(2)); sd.sumwinmin = xax->GetBinLowEdge(lobin); sd.sumwinmax = xax->GetBinUpEdge(hibin); #elif 0 int lobin = xax->FindFixBin(140); sd.sumwinmin=140; // 1 bin left, int hibin = xax->FindFixBin(170)-1; sd.sumwinmax=170; // 2 bins right #else int lobin = xax->FindFixBin(sumwinmin); int hibin = xax->FindFixBin(sumwinmax)-1; #endif int nbins = hibin-lobin+1; // for variable binning - all histos must have the same binning per channel TVectorD xbins = TVectorD(sdh->GetNbinsX(),sdh->GetXaxis()->GetXbins()->GetArray()); TVectorD xwindow = xbins.GetSub(lobin-1,hibin); xax->SetRange(lobin,hibin); // Copy contents to window-restricted signal histogram // and write to output file. // TString name = Form("Signal%s_%s",sigmodel.Data(),channames[ichan]); printf("Booking TH1D(%s,%s,%d,xwindowarray)\n", name.Data(),sdh->GetTitle(),nbins); TH1D *signm = new TH1D(name.Data(), sdh->GetTitle(), nbins, xwindow.GetMatrixArray()); // make copies of the histograms that are restricted to the // bin range lobin-hibin // for (int ibin=lobin; ibin<=hibin; ibin++) signm->SetBinContent((ibin-lobin+1), sdh->GetBinContent(ibin) *sdh->GetBinWidth(ibin) ); if (!sigmodel.CompareTo("wh")) signm->Scale(whsigscaleto); else signm->Scale(sigscaleto); allHistFile->WriteTObject(signm); } // channel loop } // writeSignalHistosForModel