int mp104_processH1()
{
// MacOSX may generate connection to WindowServer errors
gROOT->SetBatch(kTRUE);
TStopwatch stp;
// Prepare dataset: vector of files
std::vector<std::string> files;
for (int i = 0; i < 4; i++) {
files.push_back(fh1[i]);
}
// Check and fit lambdas
#include "mp_H1_lambdas.C"
ROOT::TTreeProcessorMP pool(3);
std::cout << tutname << "processing the H1 dataset with a lambda \n";
auto hListFun = pool.Process(files, doH1, "h42");
// Check the output
if (checkH1(hListFun) < 0) return -1;
// Do the fit
if (doFit(hListFun, logfile.c_str()) < 0) return -1;
stp.Print();
stp.Start();
// Run the analysis with a selector
TString selectorPath = gROOT->GetTutorialDir();
selectorPath += "/tree/h1analysisTreeReader.C+";
std::cout << tutname << "processing the H1 dataset with selector '" << selectorPath << "'\n";
TSelector *sel = TSelector::GetSelector(selectorPath);
// In a second run we use sel
gSystem->RedirectOutput(logfile.c_str(), "w", &gRH);
auto hListSel = pool.Process(files, *sel, "h42");
gSystem->RedirectOutput(0, 0, &gRH);
// Check the output
if (checkH1(hListSel) < 0) return -1;
// Do the fit
if (doFit(hListSel, logfile.c_str()) < 0) return -1;
stp.Print();
stp.Start();
return 0;
}
void callFit(pulsar *psr,int npsr){
int iteration;
double globalParameter = 0.0;
for (iteration=0;iteration<2;iteration++)
{
formBatsAll(psr,npsr);
/* Form residuals */
formResiduals(psr,npsr,0);
/* Do the fitting */
if (iteration==0) doFit(psr,npsr,0);
else textOutput(psr,npsr,globalParameter,0,0,0,"");
}
}
void photonTemplateProducer(int cutOpt=3, int ppHI = kHI, int isoChoice = kSumIso, int isoCut = -100, bool onlygjEvents=false, float specialSbCut=10, float mcSigShift=0, float sbBkgShift=0) {
CutAndBinCollection cab;
cab.setCuts(cutOpt);
int nPtBin = cab.getNPtBin();
vector<double> ptBinVector = cab.getPtBin();
double ptBin[100];
for ( int i = 0 ; i<=nPtBin ;i++) {
ptBin[i] = ptBinVector[i];
}
int nCentBin = cab.getNCentBin();
vector<double> centBinVector = cab.getCentBin();
double centBin[100];
for ( int i = 0 ; i<=nCentBin ;i++) {
centBin[i] = centBinVector[i];
}
TString pphiLabel = "";
if ( ppHI == kPP) pphiLabel = "pp";
TCanvas* c1[5];
TH1D* hData[5][5];
TH1D* hSig[5][5];
TH1D* hBkg[5][5];
// TH1D* hDatapp[5];
// TH1D* hSigpp[5];
// TH1D* hBkgpp[5];
TH1D* hBkgMCsr[5][5];
TH1D* hBkgMCsb[5][5];
TH1D* rawSpectra[5];
TH1D* finSpectra[5];
TH2D* hPurity2D = new TH2D("hPurity2D",";pT(GeV);Centrality bin",nPtBin,ptBin,nCentBin,centBin);
int nCent(-1);
if ( ppHI == kHI ) nCent = nCentBin;
if ( ppHI == kPP ) nCent = 1;
for ( int icent = 1 ; icent<=nCent ; icent++) {
rawSpectra[icent] = new TH1D(Form("rawSpec_icent%d_%s",icent,getIsoLabel(isoChoice).Data()),"",nPtBin,ptBin);
}
for (int ipt = 1; ipt <= nPtBin ; ipt++) {
c1[ipt] = new TCanvas(Form("c1_ipt%d",ipt),"",700,700);
if ( ppHI == kHI ) makeMultiPanelCanvas(c1[ipt],nCent/2,2,0.0,0.0,0.2,0.15,0.02);
TCut ptCut = Form("corrPt>%.2f && corrPt<%.2f",(float)ptBin[ipt-1],(float)ptBin[ipt]);
for ( int icent = 1 ; icent<=nCent ; icent++) {
int lowCent = centBinVector[icent-1];
int highCent = centBinVector[icent]-1;
hData[icent][ipt] = new TH1D(Form("hData_cent%d_pt%d",icent,ipt),";shower shape (#sigma_{#eta#eta});Entries per photon candidate;",25,0,0.025);
hSig[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hSig_cent%d_pt%d",icent,ipt));
hBkg[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hBkg_cent%d_pt%d",icent,ipt));
hBkgMCsr[icent][ipt] = (TH1D*)hData[icent][ipt]->Clone(Form("hBkgMCsr_cent%d_pt%d",icent,ipt));
hBkgMCsb[icent][ipt] =(TH1D*)hData[icent][ipt]->Clone(Form("hBkgMCsb_cent%d_pt%d",icent,ipt));
TString fNamedata = fNameHIdata;
if ( ppHI == kPP ) fNamedata = fNamePPdata;
getTemplate(ppHI, hSig[icent][ipt],"meaningless",isoChoice,isoCut, kSig,lowCent,highCent,ptCut,onlygjEvents,specialSbCut,mcSigShift);
getTemplate(ppHI, hData[icent][ipt],fNamedata ,isoChoice,isoCut, kData,lowCent,highCent,ptCut,onlygjEvents,specialSbCut);
if ( ppHI == kHI) {
getTemplate(ppHI, hBkg[icent][ipt], fNamedata ,isoChoice,isoCut, kSBB,lowCent,highCent,ptCut,onlygjEvents,specialSbCut,sbBkgShift);
}
if ( ppHI == kPP)
getTemplate(ppHI, hBkg[icent][ipt], fNamedata ,isoChoice,isoCut, kSBBpp,lowCent,highCent,ptCut,onlygjEvents,specialSbCut);
}
for ( int icent = 1 ; icent<=nCent ; icent++) {
int lowerCent = centBinVector[icent-1];
int upperCent =centBinVector[icent]-1;
c1[ipt]->cd(nCent - icent+1);
fitResult fitr = doFit ( hSig[icent][ipt], hBkg[icent][ipt], hData[icent][ipt], 0.005,0.025);
if ( icent== nCent) drawPatch(0,0,0.05,0.14,0,1001, "ndc");
cout << " shift = " << mcSigShift << endl;
cout << " purity = " << fitr.purity010 << endl;
if ( ptBin[ipt]> 200)
drawText(Form(" E_{T}^{#gamma} > %d GeV", (int)ptBin[ipt-1]),0.5680963,0.529118);
else
drawText(Form("%d - %d GeV", (int)ptBin[ipt-1], (int)ptBin[ipt]),0.5680963,0.529118);
if ( ppHI == kHI) {
drawText(Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),0.5680963,0.4369118);
}
else if ( ppHI == kPP) {
drawText("7TeV pp",0.5680963,0.4369118);
}
if ( (icent == nCent) || (icent == 2))
drawText(Form("Purity(#sigma_{#eta#eta} < 0.01) : %.0f%%", (float)fitr.purity010*100),0.5680963,0.3569118,1,15);
else
drawText(Form("Purity(#sigma_{#eta#eta} < 0.01) : %.0f%%", (float)fitr.purity010*100),0.4980963,0.3569118,1,15);
drawText(Form("#pm %.0f%% (stat)", float( 100. * fitr.purity010 * (float)fitr.nSigErr / (float)fitr.nSig ) ),0.6680963,0.2869118,1,15);
hPurity2D->SetBinContent(ipt,icent,fitr.purity010);
hPurity2D->SetBinError (ipt,icent,fitr.purity010* fitr.nSigErr/fitr.nSig);
rawSpectra[icent]->SetBinContent( ipt, fitr.nSig);
rawSpectra[icent]->SetBinError( ipt,fitr.nSigErr);
TString aa = "";
if (isoChoice == kSumIso) aa = "Sum Iso Method";
if (isoChoice == k3dIso) aa = "3d Cut Method";
if (isoChoice == kFisher) aa = "Fisher Method";
if ( (ppHI == kHI) && ( icent==nCent -1) )
drawText(aa.Data(),0.1980963,0.8569118,1,20);
else if ( ppHI == kPP)
drawText(aa.Data(),0.1980963,0.8569118,1,20);
if ( icent<= 2) drawPatch(0,0,0.05,0.14,0,1001, ndcOpt);
// drawPatch(0.9,0.05,1.01,0.14,0,1001,ndcOpt);
if ( (ppHI == kPP) && ( mcSigShift != 0 ))
drawText(Form("Signal template shifted by %f",mcSigShift),0.1980963,0.7569118,1,15);
if ( (ppHI == kHI) && ( mcSigShift != 0 ) && (icent==3))
drawText(Form("Signal template shifted by %f",mcSigShift),0.1980963,0.7569118,1,15);
}
TString ppLabel ="";
if ( ppHI == kPP) ppLabel = "_pp";
TString shiftLabel="";
if ( mcSigShift != 0 ) shiftLabel = Form("_%fSigShifted",(float)mcSigShift);
c1[ipt]->SaveAs(Form("fittingPurity%s_%s_pt%d%s.pdf",ppLabel.Data(), getIsoLabel(isoChoice).Data(),ipt,shiftLabel.Data()));
}
// efficiency plots
TCanvas* c2 = new TCanvas("c2","",700,700); //100 + nCent_std*300,400);
if ( ppHI == kHI) makeMultiPanelCanvas(c2,nCent/2,2,0.0,0.0,0.2,0.15,0.02);
TH1D* heff[7][5];
TH1D* heffGj[5];
TH1D* heffDphi[5];
TH1D* effSingleBin = new TH1D("effSingleBin","",1,60,100000);
TGraphAsymmErrors* geff[7][5];
TGraphAsymmErrors* gSingleBin = new TGraphAsymmErrors();
TGraphAsymmErrors* geffGj[5];
TGraphAsymmErrors* geffDphi[5];
for (int icent = 1; icent <=nCent; icent++) {
for ( int iid=1 ; iid<=5; iid++) {
heff[icent][iid] = new TH1D(Form("heff_icent%d_id%d",icent,iid),";photon E_{T} (GeV);Efficiency",nPtBin, ptBin);
if ( isoChoice == kSumIso2)
heff[icent][iid]->SetName(Form("heff_icent%d_id%d_isoCut%d",icent,iid,(int)isoCut));
if ( isoChoice == kSumIso3)
heff[icent][iid]->SetName(Form("heff_icent%d_id%d_sbIsoCut%d",icent,iid,(int)specialSbCut));
geff[icent][iid] = new TGraphAsymmErrors();
geff[icent][iid]->SetName(Form("geff_%s",heff[icent][iid]->GetName()));
}
heffGj[icent] = new TH1D(Form("heff_icent%d_Gj", icent),";x_J#gamma;Efficiency",10,0,2);
heffDphi[icent] = new TH1D(Form("heff_icent%d_Dphi",icent),";#Delta#phi of pair;Efficiency",9,0.3141592,3.141592);
geffGj[icent] = new TGraphAsymmErrors();
geffDphi[icent] = new TGraphAsymmErrors();
}
TCut srIsoCut = getIsoCut(isoChoice,isoCut);
int nId=4;
for (int icent = 1; icent <=nCent ; icent++) {
int lowCent = centBinVector[icent-1];
int highCent = centBinVector[icent]-1;
TCut centCut = Form("yEvt.hiBin >= %d && yEvt.hiBin<= %d",lowCent,highCent);
if ( ppHI == kPP ) centCut = "";
getEff("genMatchedPt",heff[icent][1],geff[icent][1],centCut, "swissCrx<0.90 && seedTime<4");
getEff("genMatchedPt",heff[icent][2],geff[icent][2],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1");
getEff("genMatchedPt",heff[icent][3],geff[icent][3],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1" && srIsoCut);
getEff("genMatchedPt",heff[icent][4],geff[icent][4],centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1 && sigmaIetaIeta<0.010"&& srIsoCut);
effSingleBin->Reset();
getEff("genMatchedPt",effSingleBin, gSingleBin, centCut, "swissCrx<0.90 && seedTime<4 && hadronicOverEm<0.1" && srIsoCut);
cout << " here Gj" << endl;
getEff("yJet.jtpt/photonEt",heffGj[icent],geffGj[icent], centCut && " genIso<5 && abs(genMomId)<=22 && photonEt>60 && abs(yJet.jteta)<2 && yJet.jtpt>30 && acos(cos(photonPhi-yJet.jtphi))>2.749", "hovere<0.1 && sigmaIetaIeta<0.010 && (cc4+cr4+ct4PtCut20)/0.9<1",true);
getEff("acos(cos(photonPhi-yJet.jtphi))",heffDphi[icent],geffDphi[icent],centCut && " genIso<5 && abs(genMomId)<=22 && photonEt>60 && abs(yJet.jteta)<2 && yJet.jtpt>30", "hovere<0.1 && sigmaIetaIeta<0.010 && (cc4+cr4+ct4PtCut20)/0.9<1",true);
}
for (int icent = 1; icent <=nCent; icent++) {
for ( int iid=1 ; iid<=nId ; iid++) {
handsomeTH1(heff[icent][iid],ycolor[iid]);
handsomeTGraph(geff[icent][iid],ycolor[iid]);
}
}
TH1D* htmp = (TH1D*)heff[1][1]->Clone("htmp");
htmp->Reset();
htmp->SetAxisRange(0,1.3,"Y");
htmp->SetYTitle("Efficiency");
handsomeTH1(htmp);
for (int icent = 1; icent <=nCent; icent++) {
int lowerCent = centBinVector[icent-1];
int upperCent = centBinVector[icent]-1;
if ( ppHI == kHI) c2->cd(nCent - icent + 1);
htmp->DrawCopy();
for ( int iid=1 ; iid<=nId ; iid++) {
heff[icent][iid]->Draw("p same");
geff[icent][iid]->Draw("p");
}
if ( ( icent == nCent ) || ( ppHI == kPP) )
{
TLegend* leg1 = new TLegend(0.25,0.20,0.95,0.55,NULL,"brNDC");
easyLeg(leg1,"Photon ID efficiency");
leg1->AddEntry(heff[icent][1],"spike rejection","lp");
leg1->AddEntry(heff[icent][2],"+ H/E < 0.1","lp");
if (isoChoice == kSumIso)
leg1->AddEntry(heff[icent][3],"+ SumIso cut","lp");
if (isoChoice == kFisher)
leg1->AddEntry(heff[icent][3],"+ Fisher cut","lp");
leg1->AddEntry(heff[icent][4],"+ #sigma_{#eta#eta} <0.010","lp");
leg1->Draw();
}
drawText(Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),0.5680963,0.8369118);
if ( icent<=2) drawPatch(0,0,0.05,0.14,0,1001,ndcOpt);
// drawPatch(0.9,0.05,1.01,0.14,0,1001,ndcOpt);
}
c2->SaveAs(Form("photonID_efficiency_%s.pdf",getIsoLabel(isoChoice).Data()));
TCanvas* c2b = new TCanvas("c2b","",1000,500); //100 + nCent_std*300,400);
c2b->Divide(2,1);
c2b->cd(1);
TH1D* htmpG = (TH1D*)heffGj[1]->Clone("htmpG");
htmpG->Reset();
htmpG->SetAxisRange(0,1.3,"Y");
htmpG->SetYTitle("Efficiency");
handsomeTH1(htmpG);
TLegend* legCent = new TLegend(0.4657258,0.2245763,1,0.4512712,NULL,"brNDC");
easyLeg(legCent,"Centrality");
if (isoChoice == kSumIso) easyLeg(legCent,"SumIso Method");
if (isoChoice == kFisher) easyLeg(legCent,"Fisher Method");
cout<< " heffGj "<< endl << endl<< endl;
for (int icent = 1; icent <=nCent; icent++) {
handsomeTH1(heffGj[icent],ycolor[icent]);
heffGj[icent]->Fit("pol1");
heffGj[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]);
heffGj[icent]->GetFunction("pol1")->SetLineStyle(7);
}
htmpG->DrawCopy();
for (int icent = 1; icent <=nCent; icent++) {
heffGj[icent]->Draw("same");
int lowerCent = centBinVector[icent-1]; int upperCent = centBinVector[icent]-1;
legCent->AddEntry(heffGj[icent],Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),"pl");
}
legCent->Draw();
c2b->cd(2);
TH1D* htmpDp = new TH1D("htmpDp",";#Delta#phi of pair;Efficiency",10,0,3.14);
htmpDp->Reset();
htmpDp->SetAxisRange(0,1.3,"Y");
htmpDp->SetYTitle("Efficiency");
handsomeTH1(htmpDp);
cout << " heffDphi " << endl << endl << endl ;
for (int icent = 1; icent <=nCent; icent++) {
handsomeTH1(heffDphi[icent],ycolor[icent]);
heffDphi[icent]->Fit("pol1");
heffDphi[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]);
heffDphi[icent]->GetFunction("pol1")->SetLineStyle(7);
}
htmpDp->DrawCopy();
for (int icent = 1; icent <=nCent; icent++) {
heffDphi[icent]->Draw("same");
}
legCent->Draw();
c2b->SaveAs(Form("photonID_efficiency_%s_2.pdf",getIsoLabel(isoChoice).Data()));
TCanvas* c3 = new TCanvas("cPurity","",500,500);
TH1D* hPurity[10];
for (int icent = 1; icent <=nCent; icent++) {
hPurity[icent] = (TH1D*)hPurity2D->ProjectionX(Form("purity1D_icent%d",icent),icent,icent);
hPurity[icent]->Fit("pol1");
hPurity[icent]->GetFunction("pol1")->SetLineColor(ycolor[icent]);
hPurity[icent]->GetFunction("pol1")->SetLineStyle(7);
}
TH1D* tempPurity = (TH1D*)hPurity[1]->Clone("purityTemp");
tempPurity->Reset();
handsomeTH1(tempPurity,1);
tempPurity->SetXTitle("pT (Gev)");
tempPurity->SetYTitle("Purity");
tempPurity->SetAxisRange(0.45,1.2,"Y");
tempPurity->Draw();
for (int icent = 1; icent <=nCent; icent++) {
handsomeTH1(hPurity[icent],ycolor[icent]);
hPurity[icent]->Draw("same");
}
TLegend* legPurity = new TLegend(0.4657258,0.2245763,1,0.4512712,NULL,"brNDC");
easyLeg(legPurity,"Purity");
if (isoChoice == kSumIso) easyLeg(legPurity,"SumIso Method");
if (isoChoice == kFisher) easyLeg(legPurity,"Fisher Method");
for (int icent = 1; icent <=nCent; icent++){
int lowerCent = centBinVector[icent-1]; int upperCent = centBinVector[icent]-1;
legPurity->AddEntry(hPurity[icent],Form("%.0f%% - %.0f%%", float((float)lowerCent*2.5), float((float)(upperCent+1)*2.5)),"pl");
}
legPurity->Draw();
if ( !onlygjEvents)
drawText("inclusive photon",0.25,0.2);
c3->SaveAs(Form("purity_%s.pdf",getIsoLabel(isoChoice).Data()));
TCanvas* c4 = new TCanvas("efficiencyCorrection","",1000,500);
c4->Divide(2,1);
c4->cd(1);
for (int icent = 1; icent <=nCent; icent++) {
TH1ScaleByWidth(rawSpectra[icent]); // divide by width
finSpectra[icent] = (TH1D*)rawSpectra[icent]->Clone(Form("finSpec_icent%d_%s",icent,getIsoLabel(isoChoice).Data()));
if ( isoChoice == kSumIso2)
finSpectra[icent]->SetName(Form("finSpec_icent%d_%s_isoCut%d",icent,getIsoLabel(isoChoice).Data(),(int)isoCut));
if ( isoChoice == kSumIso3)
finSpectra[icent]->SetName(Form("finSpec_icent%d_%s_sbisoCut%d",icent,getIsoLabel(isoChoice).Data(),(int)specialSbCut));
finSpectra[icent]->Divide(heff[icent][3]);
handsomeTH1(finSpectra[icent],ycolor[icent]);
}
// TAA and centrality
//
TFile outf = TFile(cab.getPurityFileName(),"recreate");
hPurity2D->Write();
for ( int icent=1 ; icent<=nCent ; icent++) {
heff[icent][3]->Write();
heff[icent][4]->Write();
finSpectra[icent]->Write();
hPurity[icent]->Write();
for (int ipt = 1; ipt <= nPtBin ; ipt++) {
hData[icent][ipt]->Write();
}
// hBkgMCRatioFit[icent][1]->Write();
}
outf.Close();
}
/* The main function has to be called this, even if no
* graphics are involved ;)
*/
extern "C" int graphicalInterface(int argc, char *argv[],
pulsar *psr, int *npsr)
{
char parFile[MAX_PSR][MAX_FILELEN];
char timFile[MAX_PSR][MAX_FILELEN];
*npsr = 1; // Necessary, I guess?
printf("Chi2 grid plugin for tempo2\n");
printf("Author: Paul Demorest\n");
printf("Version: 0.0\n");
parFile[0][0]='\0';
timFile[0][0]='\0';
// Parse command line.. there has to be a better way to do this..
double m2_min = 0.0, m2_max = 2.0;
double sini_min = 0.5, sini_max = 1.0;
int m2_steps = 128, sini_steps = 128;
for (unsigned i=1; i<argc; i++) {
if (strcmp(argv[i], "-f")==0) {
strcpy(parFile[0], argv[i+1]);
strcpy(timFile[0], argv[i+2]);
} else if (strcmp(argv[i], "-sini_min")==0) {
sini_min = atof(argv[i+1]);
} else if (strcmp(argv[i], "-sini_max")==0) {
sini_max = atof(argv[i+1]);
} else if (strcmp(argv[i], "-sini_steps")==0) {
sini_steps = atoi(argv[i+1]);
} else if (strcmp(argv[i], "-m2_min")==0) {
m2_min = atof(argv[i+1]);
} else if (strcmp(argv[i], "-m2_max")==0) {
m2_max = atof(argv[i+1]);
} else if (strcmp(argv[i], "-m2_steps")==0) {
m2_steps = atoi(argv[i+1]);
}
}
if (parFile[0][0]=='\0' || timFile[0][0]=='\0') {
fprintf(stderr, "Please provide .par and .tim files using -f\n");
fprintf(stderr, "Optional arguments:\n");
fprintf(stderr, " -sini_min N Minimum sin(i) value (0.5)\n");
fprintf(stderr, " -sini_max N Maximum sin(i) value (1.0)\n");
fprintf(stderr, " -sini_steps N Number of sin(i) steps (128)\n");
fprintf(stderr, " -m2_min N Minimum m2 value (0.0)\n");
fprintf(stderr, " -m2_max N Maximum m2 value (2.0)\n");
fprintf(stderr, " -m2_steps N Number of m2 steps (128)\n");
exit(1);
}
// Read the stuff
readParfile(psr, parFile, timFile, *npsr);
readTimfile(psr, timFile, *npsr);
preProcess(psr, *npsr, argc, argv);
// Do an initial fit to get best-fit params to use as a starting
// place.
formBatsAll(psr, *npsr);
formResiduals(psr, *npsr, 0); // Final arg is "removeMean"
doFit(psr, *npsr, 0); // Final arg is "writeModel"
formBatsAll(psr, *npsr); // Run these again to get post-fit
formResiduals(psr, *npsr, 0); // residuals.
// Get initial chi2, etc.
double init_chi2 = psr_chi2(psr);
// step size, etc
double delta_m2 = (m2_max - m2_min)/(double)m2_steps;
double delta_sini = (sini_max - sini_min)/(double)sini_steps;
// Store current parameters in psr[1], trial params in psr[0]
store_params(psr);
// Print header lines
printf("# chi2_0=%.5e\n", init_chi2);
printf("# SINI M2 chi2-chi2_0\n");
// Main iteration loop
signal(SIGINT, cc);
double cur_m2, cur_sini, cur_chi2;
for (cur_sini=sini_min; cur_sini<sini_max; cur_sini+=delta_sini) {
for (cur_m2=m2_min; cur_m2<m2_max; cur_m2+=delta_m2) {
reset_params(psr);
psr[0].param[param_sini].val[0] = cur_sini;
psr[0].param[param_sini].paramSet[0] = 1;
psr[0].param[param_m2].val[0] = cur_m2;
psr[0].param[param_m2].paramSet[0] = 1;
// updateBats or FormBats?
int ok=1;
updateBatsAll(psr, *npsr);
try {
formResiduals(psr, *npsr, 0);
doFit(psr, *npsr, 0);
} catch (int e) {
// Note, this is a hack to ignore spots in
// M2-sini parameter space where the fit does not
// converge. Plain tempo2 exit()'s here, killing
// the whole process. I've modified my copy to
// throw an error instead so we can continue on
// with the gridding.
if (e==5) { ok=0; }
}
if (ok) {
updateBatsAll(psr, *npsr);
formResiduals(psr, *npsr, 0);
cur_chi2 = psr_chi2(psr);
} else {
cur_chi2 = 1e6;
}
printf("%.9f %.5f %.10e\n", cur_sini, cur_m2, cur_chi2-init_chi2);
if (run==0) break;
}
if (run==0) break;
}
}
void minuitFit()
{
TH1F::SetDefaultSumw2();
TH1D::SetDefaultSumw2();
cout << "Must Use Same Binning as previous Analysis!" << endl;
gStyle->SetOptFit(1111);
gStyle->SetOptStat(0);
haveName = kFALSE;
char fname[100];
TFile* file;
Bool_t makePDF = checkMakePDF();
Bool_t makeROOT = checkMakeRoot();
if(makeROOT){
sprintf(fname,"/Users/zach/Research/pythia/200GeVTemplate/FFOutput/%s_FIT.root",FileNameR);
file = new TFile(fname,"RECREATE");
if (file->IsOpen()==kFALSE)
{
std::cout << "!!! Outfile Not Opened !!!" << std::endl;
makeROOT = kFALSE;
}
}
char name[1000];
sprintf(name,"/Users/zach/Research/pythia/200GeVTemplate/currentTemplate.root");
TFile *fT = new TFile(name,"READ");
sprintf(name,"/Users/zach/Research/rootFiles/run12NPEhPhi/currentData.root");
TFile *fD = new TFile(name,"READ");
if (fT->IsOpen()==kFALSE || fD->IsOpen()==kFALSE)
{ std::cout << "!!!!!! Either B,C, or Data File not found !!!!!!" << std::endl
<< "Looking for currentB.root, currentC.root, and currentData.root" << std::endl;
exit(1); }
// Set constants and projection bins (from header file anaConst, analysis constants)
Float_t lowpt[numPtBins],highpt[numPtBins];
for(Int_t c=0; c< numPtBins; c++){
lowpt[c] = anaConst::lpt[c];
highpt[c] = anaConst::hpt[c];
}
Float_t hptCut=anaConst::hptCut;
// Make Canvases
TCanvas* deltaPhi = new TCanvas("deltaPhi","Pythia Delta Phi",150,0,1150,1000);
TCanvas* deltaPhi2 = new TCanvas("deltaPhi2","Pythia Delta Phi",150,0,1150,1000);
TCanvas* fitResult0 = new TCanvas("fitResult0","RB Extraction HT0",150,0,1150,1000);
TCanvas* fitResult2 = new TCanvas("fitResult2","RB Extraction HT2",150,0,1150,1000);
TCanvas* fitResultC = new TCanvas("fitResultC","RB Extraction Combined Trigs",150,0,1150,1000);
TCanvas* fitResultP = new TCanvas("fitResultP","RB Previous Analysis",150,0,1150,1000);
TCanvas* scaleCheck = new TCanvas("scaleCheck","Check scale diff",150,0,1150,1000);
TCanvas* prettyPlot = new TCanvas("prettyPlot","PrettyPlot",150,0,1150,1000);
deltaPhi ->Divide(3,3);
deltaPhi2 ->Divide(3,3);
fitResult0->Divide(3,4);
fitResult2->Divide(3,4);
fitResultC->Divide(3,4);
fitResultP->Divide(2,2);
scaleCheck->Divide(1,2);
// Get and Draw histos
TPaveText* lbl[numPtBins];
TPaveText* stat[4][numPtBins];
char statLabel[100];
char textLabel[100];
Int_t plotbin;
Double_t norm0,norm2,normB,normC;
// Get ptbin independent hists
histoNorms = (TH2F*)fD->Get("histoNorms");
// Get Previous Analysis
TFile *file3 = new TFile("/Users/zach/Research/previousNPEhFigures/Chi2_25_35.root");
Hdphi[0] = (TH1D*)file3->Get("fit_25_35");
HpphiD[0] = (TH1D*)file3->Get("De_25_35");
HpphiB[0] = (TH1D*)file3->Get("Be_25_35");
TFile *file4 = new TFile("/Users/zach/Research/previousNPEhFigures/Chi2_55_65.root");
Hdphi[1] = (TH1D*)file4->Get("fit_55_65");
HpphiD[1] = (TH1D*)file4->Get("De_55_65");
HpphiB[1] = (TH1D*)file4->Get("Be_55_65");
for(Int_t ptbin=0; ptbin<numPtBins; ptbin++)
{
bPtNorms[ptbin] = (TH1F*)fT->Get(Form("beEventTally_%i",ptbin));
cPtNorms[ptbin] = (TH1F*)fT->Get(Form("ceEventTally_%i",ptbin));
norm0 = histoNorms->GetBinContent(histoNorms->GetBin(1,ptbin+1));
norm2 = histoNorms->GetBinContent(histoNorms->GetBin(3,ptbin+1));
normB = bPtNorms[ptbin]->GetBinContent(1);
normC = cPtNorms[ptbin]->GetBinContent(1);
cout << ptbin << "; 0: " << norm0 << " 2: " << norm2 << endl;
if( norm0 == 0)
{
cout << ptbin << " For this bin, some norm0 = 0" << endl;
continue;
}
if( norm2 == 0 )
{
cout << ptbin << " For this bin, some norm2 = 0" << endl;
continue;
}
if( normB == 0 )
{
cout << ptbin << " For this bin, some normB = 0" << endl;
continue;
}
if( normC == 0)
{
cout << ptbin << " For this bin, some normC = 0" << endl;
continue;
}
plotbin = ptbin;
// Init necessary plotting tools
lbl[ptbin] = new TPaveText(.15,.15,.35,.23,Form("NB NDC%i",ptbin));
sprintf(textLabel,"%.1f < P_{T,e} < %.1f",lowpt[ptbin],highpt[ptbin]);
lbl[ptbin]->AddText(textLabel);
lbl[ptbin]->SetFillColor(kWhite);
projB[ptbin] = (TH1D*)fT->Get(Form("hdPhiRawbe_%i",ptbin));
projC[ptbin] = (TH1D*)fT->Get(Form("hdPhiRawce_%i",ptbin));
projData0[ptbin]= (TH1D*)fD->Get(Form("NPEhDelPhi_0_%i",ptbin));
projData2[ptbin]= (TH1D*)fD->Get(Form("NPEhDelPhi_2_%i",ptbin));
pileupCorrect[ptbin][0] = (TH1D*)fD->Get(Form("pileupCorrection_%i_0",ptbin));
pileupCorrect[ptbin][1] = (TH1D*)fD->Get(Form("pileupCorrection_%i_2",ptbin));
pileupCorrect[ptbin][0]->Sumw2();
pileupCorrect[ptbin][1]->Sumw2();
// Do any rebinning
Int_t RB = 1;
projB[ptbin]->Rebin(RB);
projC[ptbin]->Rebin(RB);
projData0[ptbin]->Rebin(RB);
projData2[ptbin]->Rebin(RB);
// Clone to make plots without effecting fits
plotD0[ptbin] = (TH1D*) projData0[ptbin]->Clone();
plotD2[ptbin] = (TH1D*) projData2[ptbin]->Clone();
plotB[ptbin] = (TH1D*) projB[ptbin]->Clone();
plotC[ptbin] = (TH1D*) projC[ptbin]->Clone();
// Set features that are the same in plots
projData0[ptbin]->SetLineColor(kBlue);
projData2[ptbin]->SetLineColor(kGreen+3);
projB[ptbin]->SetLineColor(kRed);
projC[ptbin]->SetLineColor(kBlack);
projC[ptbin]->GetXaxis()->SetRangeUser(-3.5,3.5);
plotD0[ptbin]->SetLineColor(kBlue);
plotD2[ptbin]->SetLineColor(kGreen+3);
plotD0[ptbin]->SetMarkerStyle(20);
plotD0[ptbin]->SetMarkerColor(kBlue);
plotD0[ptbin]->SetMarkerSize(0.4);
plotB[ptbin]->SetLineColor(kRed);
plotC[ptbin]->SetLineColor(kBlack);
plotC[ptbin]->GetXaxis()->SetRangeUser(-3.5,3.5);
combData[ptbin] = (TH1D*) projData0[ptbin]->Clone();
combData[ptbin] -> Add(projData2[ptbin]);
combData[ptbin]->SetLineColor(kBlue);
combData[ptbin]->SetMarkerStyle(20);
combData[ptbin]->SetMarkerColor(kBlue);
combData[ptbin]->SetMarkerSize(0.4);
combData[ptbin]->SetTitle("");
// Normalize
projB[ptbin] -> Scale(1./normB);
projC[ptbin] -> Scale(1./normC);
projData0[ptbin] -> Scale(1./norm0);
projData2[ptbin] -> Scale(1./norm2);
plotD0[ptbin] -> Scale(1./norm0);
plotD2[ptbin] -> Scale(1./norm2);
plotB[ptbin] -> Scale(1./normB);
plotC[ptbin] -> Scale(1./normC);
combData[ptbin] -> Scale(1./(norm0+norm2));
// Subtract Pileup correction (data only)
projData0[ptbin]->Sumw2();projData2[ptbin]->Sumw2();
//projData0[ptbin]->Add(pileupCorrect[ptbin][0],-1);
//projData2[ptbin]->Add(pileupCorrect[ptbin][1],-1);
// Draw Templates on own plots
if(ptbin+1 <= 9) deltaPhi->cd(plotbin+1);
if(ptbin+1 > 9) deltaPhi2->cd(ptbin-8);
plotC[ptbin]->GetYaxis()->SetRangeUser(-.1,0.8);
plotC[ptbin] -> Draw("hist");
plotB[ptbin] -> Draw("same hist");
plotD0[ptbin] -> Draw("same");
plotD2[ptbin] -> Draw("same");
lbl[ptbin] -> Draw("same");
TLegend* leg = new TLegend(0.65,0.6,0.85,0.85);
leg->AddEntry(projB[ptbin],"b#bar{b}->NPE","lpe");
leg->AddEntry(projC[ptbin],"c#bar{c}->NPE","lpe");
leg->AddEntry(projData0[ptbin],"HT0","lpe");
leg->AddEntry(projData2[ptbin],"HT2","lpe");
leg->Draw();
deltaPhi->cd(1);
Hdphi[0]->Draw("same");
deltaPhi->cd(4);
Hdphi[1]->Draw("same");
if(ptbin == 1)
{
prettyPlot->cd();
plotC[ptbin]->GetYaxis()->SetRangeUser(0,0.35);
plotC[ptbin]->SetMarkerStyle(20);
plotC[ptbin]->SetMarkerSize(0.6);
plotB[ptbin]->SetMarkerStyle(21);
plotB[ptbin]->SetMarkerSize(0.6);
plotB[ptbin]->SetMarkerColor(kRed);
plotD0[ptbin]->SetMarkerStyle(22);
plotD0[ptbin]->SetMarkerSize(0.9);
plotC[ptbin]->GetXaxis()->SetTitle("#Delta#phi_{NPE-h} (rad)");
plotC[ptbin]->GetYaxis()->SetTitle("#frac{1}{N_{NPE}} #frac{dN}{d(#Delta#phi)}");
plotC[ptbin]->DrawClone("P");
plotB[ptbin]->DrawClone("same P");
plotD0[ptbin]->DrawClone("same P");
TLegend* legPret = new TLegend(0.65,0.6,0.85,0.85);
legPret->AddEntry(plotB[ptbin],"B #rightarrow NPE-h, Monte Carlo","LPE");
legPret->AddEntry(plotC[ptbin],"D #rightarrow NPE-h, Monte Carlo","LPE");
legPret->AddEntry(plotD0[ptbin],"NPE-h 2012 STAR Data","LPE");
lbl[ptbin]->Draw("same");
legPret->Draw("same");
}
/*// Draw Scale Check
scaleCheck->cd(1);
TH1F* HT0 = (TH1F*) plotD0[0]->Clone();
HT0->Divide(HT0,Hdphi[0],1,1);
HT0->Draw();
scaleCheck->cd(2);
TH1F* HT2 = (TH1F*) plotD2[3]->Clone();
HT2->Divide(HT2,Hdphi[1],1,1);
HT0->GetXaxis()->SetRangeUser(-3.5,3.5);
HT2->GetXaxis()->SetRangeUser(-3.5,3.5);
HT2->Draw();
lbl[ptbin]->Draw("same");
TLegend* legSC = new TLegend(0.65,0.6,0.85,0.85);
legSC->AddEntry(HT0,"HT0/prevdata","lpe");
legSC->AddEntry(HT2,"HT2/prevdata","lpe");
legSC->Draw();*/
/////////////////////
// Do the actual fits
/////////////////////
currentPtBin = ptbin;
cout << "!!!!!!! HT0 ptbin: " << highpt[ptbin] << "-" << lowpt[ptbin] <<" !!!!!!!"<< endl;
TMinuit* gMinuit = new TMinuit(1);
gMinuit->SetFCN(chi2_0);
currentPtBin = ptbin;
doFit(gMinuit,p01[ptbin],p00[ptbin],e01[ptbin],e00[ptbin]);
// assign to plotting variables
if(highpt[ptbin] < 6)
{
pT[ptbin] = (lowpt[ptbin]+highpt[ptbin])/2.;
dx[plotCount0] = 0.;
ptOFF1[plotCount0] = pT[ptbin];
Rb0[plotCount0] = p01[ptbin];///(p01[ptbin]+p00[ptbin]);
eb0[plotCount0] = e01[ptbin];
plotCount0++;
}
// Plot results
fitResult0->cd(ptbin+1);
TH1D* dClone = (TH1D*) projData0[ptbin]->Clone();
TH1D* cClone = (TH1D*) projC[ptbin]->Clone();
TH1D* bClone = (TH1D*) projB[ptbin]->Clone();
stat[0][ptbin] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%i",ptbin));
sprintf(statLabel,"Chi2/NDF: %.2f/%.0f",curChi2,curNDF);
stat[0][ptbin]->InsertText(statLabel);
stat[0][ptbin]->SetFillColor(kWhite);
cClone->Scale((1.-p01[ptbin])*p00[ptbin]); bClone->Scale(p00[ptbin]*p01[ptbin]); // scale by contribution param
cClone->Add(bClone);
//cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
dClone->Draw();
cClone->Draw("same");
stat[0][ptbin]->Draw("same");
lbl[ptbin]->Draw("same");
cout << "!!!!!!! HT2 ptbin: " << highpt[ptbin] << "-" << lowpt[ptbin] <<" !!!!!!!"<< endl;
gMinuit->SetFCN(chi2_2);
doFit(gMinuit,p21[ptbin],p20[ptbin],e21[ptbin],e20[ptbin]);
// assign to plotting variables
if(highpt[ptbin] > 3.6)
{
pT[ptbin] = (lowpt[ptbin]+highpt[ptbin])/2.;
ptOFF2[plotCount2] = pT[ptbin];
Rb2[plotCount2] = p21[ptbin];///(p21[ptbin]+p20[ptbin]);
eb2[plotCount2] = e21[ptbin];
plotCount2++;
}
// Plot results
fitResult2->cd(ptbin+1);
dClone = (TH1D*) projData2[ptbin]->Clone();
cClone = (TH1D*) projC[ptbin]->Clone();
bClone = (TH1D*) projB[ptbin]->Clone();
stat[2][ptbin] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%i",ptbin));
sprintf(statLabel,"Chi2/NDF: %.2f/%.2f",curChi2,curNDF);
stat[2][ptbin]->InsertText(statLabel);
stat[2][ptbin]->SetFillColor(kWhite);
cClone->Scale((1.-p21[ptbin])*p20[ptbin]); bClone->Scale(p20[ptbin]*p21[ptbin]); // scale by contribution param
cClone->Add(bClone);
// cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
dClone->Draw();
cClone->Draw("same");
stat[2][ptbin]->Draw("same");
lbl[ptbin]->Draw("same");
cout << "!!!!!!! HTC ptbin: " << highpt[ptbin] << "-" << lowpt[ptbin] <<" !!!!!!!"<< endl;
gMinuit->SetFCN(chi2_C);
doFit(gMinuit,pC1[ptbin],pC0[ptbin],eC1[ptbin],eC0[ptbin]);
// assign to plotting variables
pT[ptbin] = (lowpt[ptbin]+highpt[ptbin])/2.;
RbC[plotCount] = pC1[ptbin];///(p21[ptbin]+p20[ptbin]);
ebC[plotCount] = eC1[ptbin];
plotCount++;
}
cout << "!!!!!!! Previous Data: 0"<<" !!!!!!!"<< endl;
//////////
// 2.5-3.5 GeV Bin
//////////
gMinuit->SetFCN(chi2_P0);
doFit(gMinuit,RbP[0],SF[0],EbP[0],eSF[0]);
// assign plotting variables
pTP[0] = 3.;
// Plot results
fitResultP->cd(1);
/*TH1D* dClone = (TH1D*) Hdphi[0]->Clone();
TH1D* cClone = (TH1D*) projC[0]->Clone();
TH1D* bClone = (TH1D*) projB[0]->Clone();*/
TH1D* dClone = (TH1D*) projData0[0]->Clone();
TH1D* cClone = (TH1D*) HpphiD[0]->Clone();
TH1D* bClone = (TH1D*) HpphiB[0]->Clone();
stat[3][0] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%iP",0));
sprintf(statLabel,"Chi2/NDF: %.2f/%.2f",curChi2,curNDF);
stat[3][0]->InsertText(statLabel);
stat[3][0]->SetFillColor(kWhite);
cClone->Scale((1.-RbP[0])*SF[0]); bClone->Scale(RbP[0]*SF[0]); // scale by contribution param
cClone->Add(bClone);
// cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
cClone->SetLineColor(kRed);
dClone->Draw();
cClone->Draw("same");
stat[3][0]->Draw("same");
////////
// 5.5-6.5 GeV Bin
////////
gMinuit->SetFCN(chi2_P1);
doFit(gMinuit,RbP[1],SF[1],EbP[1],eSF[1]);
// assign plotting variables
pTP[1] = 6.;
// Plot results
fitResultP->cd(2);
/*dClone = (TH1D*) Hdphi[1]->Clone();
cClone = (TH1D*) projC[3]->Clone();
bClone = (TH1D*) projB[3]->Clone();*/
dClone = (TH1D*) projData2[3]->Clone();
cClone = (TH1D*) HpphiD[1]->Clone();
bClone = (TH1D*) HpphiB[1]->Clone();
stat[3][1] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%iP",0));
sprintf(statLabel,"Chi2/NDF: %.2f/%.2f",curChi2,curNDF);
stat[3][1]->InsertText(statLabel);
stat[3][1]->SetFillColor(kWhite);
cClone->Scale((1.-RbP[1])*SF[1]); bClone->Scale(RbP[1]*SF[1]); // scale by contribution param
cClone->Add(bClone);
// cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
cClone->SetLineColor(kRed);
dClone->Draw();
cClone->Draw("same");
stat[3][1]->Draw("same");
////////
// Old Data, Old Template
///////
gMinuit->SetFCN(chi2_PP);
doFit(gMinuit,RbPP[0],SFPP[0],EbPP[0],eSFPP[0]);
// assign plotting variables
pTPP[0] = 3.;
// Plot results
fitResultP->cd(3);
dClone = (TH1D*) Hdphi[0]->Clone();
cClone = (TH1D*) HpphiD[0]->Clone();
bClone = (TH1D*) HpphiB[0]->Clone();
stat[3][2] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%iP",0));
sprintf(statLabel,"Chi2/NDF: %.2f/%.2f",curChi2,curNDF);
stat[3][2]->InsertText(statLabel);
stat[3][2]->SetFillColor(kWhite);
cClone->Scale((1.-RbPP[0])*SFPP[0]); bClone->Scale(RbPP[0]*SFPP[0]); // scale by contribution param
cClone->Add(bClone);
// cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
cClone->SetLineColor(kRed);
dClone->Draw();
cClone->Draw("same");
stat[3][2]->Draw("same");
// Bin at 6 GeV
gMinuit->SetFCN(chi2_PP1);
doFit(gMinuit,RbPP[1],SFPP[1],EbPP[1],eSFPP[1]);
// assign plotting variables
pTPP[1] = 6.;
// Plot results
fitResultP->cd(4);
dClone = (TH1D*) Hdphi[1]->Clone();
cClone = (TH1D*) HpphiD[1]->Clone();
bClone = (TH1D*) HpphiB[1]->Clone();
stat[3][3] = new TPaveText(.4,.75,.85,.85,Form("NB NDC%iP",0));
sprintf(statLabel,"Chi2/NDF: %.2f/%.2f",curChi2,curNDF);
stat[3][3]->InsertText(statLabel);
stat[3][3]->SetFillColor(kWhite);
cClone->Scale((1.-RbPP[1])*SFPP[1]); bClone->Scale(RbPP[1]*SFPP[1]); // scale by contribution param
cClone->Add(bClone);
// cClone->Scale(dClone->GetMaximum()/cClone->GetMaximum());
dClone->GetXaxis()->SetRangeUser(anaConst::lowPhi,anaConst::highPhi);
dClone->GetYaxis()->SetRangeUser(-0.1,0.6);
cClone->SetLineColor(kRed);
dClone->Draw();
cClone->Draw("same");
stat[3][3]->Draw("same");
// Get FONLL Calc
Int_t l=0;
char line[1000];
Float_t xF[100],yF[100],minF[100],maxF[100];
ifstream fp("/Users/zach/Research/pythia/200GeVTemplate/FONLL.txt",ios::in);
while (!fp.eof()){
fp.getline(line,1000);
sscanf(line,"%f %f %f %f",&xF[l],&yF[l],&minF[l],&maxF[l]);
// printf("L: %f %f\n",xF[l],yF[l]);
l++;
}
fp.close();
// Get Previous Analysis
Int_t p=0;
Float_t xP[100],yP[100],dyP[100];
ifstream fp1("/Users/zach/Research/pythia/200GeVTemplate/run5_6.txt",ios::in);
while (!fp1.eof()){
fp1.getline(line,1000);
sscanf(line,"%f %f %f",&xP[p],&yP[p],&dyP[p]);
// printf("L: %f %f\n",xF[l],yF[l]);
p++;
}
fp1.close();
//cout << "at bottom contrib plot" << endl;
TCanvas* c1 = new TCanvas("c1","Bottom Contribution",150,0,1150,1000);
TGraphErrors *gr0 = new TGraphErrors(plotCount0-1,ptOFF1,Rb0,dx,eb0);
TGraphErrors *gr2 = new TGraphErrors(plotCount2-1,ptOFF2,Rb2,dx,eb2);
TGraphErrors *grC = new TGraphErrors(plotCount-1,pT,RbC,dx,ebC);
TGraphErrors *grF = new TGraphErrors(l-1,xF,yF);
TGraphErrors *grFmax = new TGraphErrors(l-1,xF,maxF);
TGraphErrors *grFmin = new TGraphErrors(l-1,xF,minF);
TGraphErrors *grP = new TGraphErrors(p-1,xP,yP,0,dyP);
TGraphErrors *grPr = new TGraphErrors(2,pTP,RbP,0,EbP);
TGraphErrors *grPPr = new TGraphErrors(2,pTPP,RbPP,0,EbPP);
c1->cd(1);
grP->SetTitle("");
grP->GetXaxis()->SetTitle("NPE p_{T} (GeV/c)");
grP->GetYaxis()->SetTitle("r_{B}");
gr0->SetMarkerStyle(20);
gr0->SetMarkerSize(1);
gr0->SetLineColor(kBlue);
gr0->SetMarkerColor(kBlue);
gr2->SetMarkerStyle(22);
gr2->SetMarkerSize(1);
gr2->SetLineColor(kRed);
gr2->SetMarkerColor(kRed);
grC->SetMarkerStyle(21);
grC->SetMarkerSize(1);
grC->SetLineColor(kRed);
grC->SetMarkerColor(kRed);
grP->GetXaxis()->SetLimits(0,10);
grP->GetYaxis()->SetRangeUser(0,1);
grF->SetLineStyle(1);
grFmax->SetLineStyle(2);
grFmin->SetLineStyle(2);
grP->SetMarkerStyle(33);
grP->SetMarkerColor(kBlack);
grPr->SetMarkerStyle(29);
grPr->SetMarkerColor(9);
grPr->SetLineColor(9);
grPPr->SetMarkerStyle(29);
grPPr->SetMarkerColor(49);
grPPr->SetLineColor(49);
grP->Draw("AP");
//grC->Draw("same P");
gr2->Draw("same P");
grF->Draw("same");
grFmax->Draw("same");
grFmin->Draw("same");
gr0->Draw("same P");
// grPr->Draw("same P");
//grPPr->Draw("same P");
TLegend* leg2 = new TLegend(0.15,0.68,0.48,0.85);
leg2->AddEntry(gr0,"STAR Run 12 - Low p_{T} Analysis","pe");
leg2->AddEntry(gr2,"STAR Run 12 - High p_{T} Analysis","pe");
//leg2->AddEntry(grC,"Combined Trigs","pe");
leg2->AddEntry(grP,"STAR Run 6 Analysis (Stat. Uncertainty)","pe");
// leg2->AddEntry(grPr,"Run 12 Data, Run 5/6 Templates)","pe");
//leg2->AddEntry(grPPr,"Run 5/6 Refit (prev Template)","pe");
leg2->AddEntry(grF,"FONLL Calculation","l");
leg2->Draw("same");
// Write to Root File if open
if(makeROOT){
file3->Close();
file4->Close();
file->cd();
grP->Write("PreviousData");
//grC->Write("same P");
gr2->Write("HT2");
grF->Write("FONLL");
grFmax->Write("FONLLmax");
grFmin->Write("FONLLmin");
gr0->Write("HT0");
// grPr->Write("PrevTempMyData");
//grPPr->Write("PrevTempPreData");
}
// Make PDF with output canvases
if(makePDF)
{
//Set front page
TCanvas* fp = new TCanvas("fp","Front Page",100,0,1000,900);
fp->cd();
TBox *bLabel = new TBox(0.01, 0.88, 0.99, 0.99);
bLabel->SetFillColor(38);
bLabel->Draw();
TLatex tl;
tl.SetNDC();
tl.SetTextColor(kWhite);
tl.SetTextSize(0.033);
char tlName[100];
char tlName2[100];
TString titlename = FileName;
int found = titlename.Last('/');
if(found >= 0){
titlename.Replace(0, found+1, "");
}
sprintf(tlName, "RUN 12 NPE-h #Delta#phi Correlations");
tl.SetTextSize(0.05);
tl.SetTextColor(kWhite);
tl.DrawLatex(0.05, 0.92,tlName);
TBox *bFoot = new TBox(0.01, 0.01, 0.99, 0.12);
bFoot->SetFillColor(38);
bFoot->Draw();
tl.SetTextColor(kWhite);
tl.SetTextSize(0.05);
tl.DrawLatex(0.05, 0.05, (new TDatime())->AsString());
tl.SetTextColor(kBlack);
tl.SetTextSize(0.03);
tl.DrawLatex(0.1, 0.14, titlename);
sprintf(tlName,"TEST");
tl.DrawLatex(0.1, 0.8,tlName);
// Place canvases in order
TCanvas* temp = new TCanvas();
sprintf(name, "FFOutput/%s.pdf[", FileName);
temp->Print(name);
sprintf(name, "FFOutput/%s.pdf", FileName);
temp = deltaPhi;
temp->Print(name);
temp = fitResult0;
temp->Print(name);
temp = fitResult2;
temp->Print(name);
// temp = fitResultC;
// temp->Print(name);
temp = c1;
temp->Print(name);
sprintf(name, "FFOutput/%s.pdf]", FileName);
temp->Print(name);
}
if(makeROOT)
{
file->Write();
file->Close();
}
}
fitResult getPurity(TString fname, sampleType collision, TCut evtSeltCut, TCut sbEvtCut, TString canvasName, float photonPtThr, float photonPtThrUp) {
double purity(0);
multiTreeUtil* tgj = new multiTreeUtil();
multiTreeUtil* tgjMC = new multiTreeUtil();
cout <<" 1 " << endl;
tgj->addFile(fname, "tgj", "", 1);
cout <<" 2 " << endl;
tgj->AddFriend("yJet");
if (collision==kPPDATA) {
tgjMC->addFile(fnamePPMC_AllQcdPho30to50, "tgj", "", wPPMC_AllQcdPho30to50 );
tgjMC->addFile(fnamePPMC_AllQcdPho50to80, "tgj", "", wPPMC_AllQcdPho50to80 );
tgjMC->addFile(fnamePPMC_AllQcdPho80to120, "tgj", "", wPPMC_AllQcdPho80to120);
tgjMC->addFile(fnamePPMC_AllQcdPho120to9999, "tgj", "", wPPMC_AllQcdPho120to9999);
}
else if (collision==kPADATA) {
tgjMC->addFile(fnamePAMC_AllQcdPho30to50, "tgj","", wPAMC_AllQcdPho30to50);
tgjMC->addFile(fnamePAMC_AllQcdPho50to80, "tgj","", wPAMC_AllQcdPho50to80);
tgjMC->addFile(fnamePAMC_AllQcdPho80to120, "tgj","", wPAMC_AllQcdPho80to120);
tgjMC->addFile(fnamePAMC_AllQcdPho120to9999, "tgj","", wPAMC_AllQcdPho120to9999);
}
else if (collision==kHIDATA) {
tgjMC->addFile(fnameHIMC_AllQcdPho30to50, "tgj", "",wHIMC_AllQcdPho30to50);
tgjMC->addFile(fnameHIMC_AllQcdPho50to80, "tgj", "",wHIMC_AllQcdPho50to80);
tgjMC->addFile(fnameHIMC_AllQcdPho80to9999, "tgj", "",wHIMC_AllQcdPho80to9999);
}
else {
cout << " Error: getPurity. check the type of the collision! " << endl;
fitResult fitr0;
return fitr0;
}
TH1D* hCand = new TH1D("cand","",25,0,0.025);
TH1D* hBkg = (TH1D*)hCand->Clone("bkg"); TH1D* hSig = (TH1D*)hCand->Clone("sig");
tgj->Draw2( hCand, "sigmaIetaIeta", evtSeltCut , "");
tgj->Draw2( hBkg, "sigmaIetaIeta", sbEvtCut , "");
tgjMC->Draw2( hSig, "sigmaIetaIeta", evtSeltCut && "genIso<5 && abs(genMomId)<=22", "");
handsomeTH1(hCand,1);
handsomeTH1(hSig,2);
handsomeTH1(hBkg,4);
TCanvas* cPurity = new TCanvas("cpurity","",500,500);
fitResult fitr = doFit ( hSig, hBkg, hCand, 0.005, 0.025);
drawText(Form("Purity : %.2f", (float)fitr.purity010), 0.5680963,0.429118);
drawText(Form("p_{T}^{#gamma}: %d-%d GeV", (int)photonPtThr, (int)photonPtThrUp), 0.568,0.529118);
cPurity->SaveAs( Form("%s.pdf",canvasName.Data() ) );
gPad->SetLogy();
cPurity->SaveAs( Form("%s_logScale.pdf",canvasName.Data() ) );
TCanvas* c1 = new TCanvas("c1","",100,100);
delete tgj;
delete tgjMC;
delete hSig;
delete hBkg;
delete hCand;
return fitr;
}
int main()
{
randomnessGenerator = new TRandom();
system((string("mkdir -p ")+OUTPUT_FOLDER).c_str());
// ###########################
// # Prepare final SFR table #
// ###########################
vector<string> columns = { "SFR-1ltop", "SFR-Wjets" };
vector<string> listAllSignalRegion = listCutAndCounts;
vector<string> listRawRegion = listIndividualCuts;
Table tableSFRToBeUsed(columns,listAllSignalRegion);
Table tableRawSFR(columns,listRawRegion);
columns.clear();
columns = {"NormPeak_1ltop", "NormTail_1ltop", "SFR-1ltop", "NormPeak_Wjets", "NormTail_Wjets", "SFR-Wjets"};
Table tableRawNormValues(columns,listRawRegion);
// Create observables
RooRealVar var(OBSERVABLE_FOR_FIT,OBSERVABLE_FOR_FIT,0,600) ;
string varname(OBSERVABLE_FOR_FIT);
FitSetup setup;
FitResult res;
string conditions;
// ########################
// # _____ _____ #
// # / __ \ ___ / __ \ #
// # | / \/( _ ) | / \/ #
// # | | / _ \/\ | #
// # | \__/\ (_> < \__/\ #
// # \____/\___/\/\____/ #
// # #
// ########################
std::map<string,Figure> SFR_CC_1ltop_map;
std::map<string,Figure> SFR_CC_Wjets_map;
//Create histos
TH1F h_SF_MTpeak_CC_1ltop ("h_SF_MTpeak_CC_1ltop", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
TH1F h_SF_MTtail_CC_1ltop ("h_SF_MTtail_CC_1ltop", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
TH1F h_SFR_CC_1ltop ("h_SFR_CC_1ltop", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
TH1F h_SF_MTpeak_CC_Wjets ("h_SF_MTpeak_CC_Wjets", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
TH1F h_SF_MTtail_CC_Wjets ("h_SF_MTtail_CC_Wjets", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
TH1F h_SFR_CC_Wjets ("h_SFR_CC_Wjets", "", listIndividualCuts_MTtail.size(), 0, listIndividualCuts_MTtail.size());
for(unsigned int i=0;i<listIndividualCuts.size();i++)
{
cout<<"%%%%%%%%%%%%%%%%%% "<<listIndividualCuts_MTtail[i]<<endl;
string label = listIndividualCuts[i];
Figure SFR_1ltop;
Figure SFR_Wjets;
//MT tail
setup.Reset();
conditions="sigRegions_CC_tail";
setup.region=listIndividualCuts_MTtail[i];
setup.varname=varname;
setup.varMin=0;
setup.varMax=600;
//test on Ndata
/*
vector<int> Ndata = {100,200,500,1000,5000,10000};
//vector<int> Ndata = {100,200};//,500,1000,5000,10000};
*/
TFile* file = new TFile("closure.root","RECREATE");
//for(unsigned int c=0;c<Ndata.size();c++){
/*
TString dirname;
dirname+=Ndata[c];
file->mkdir(dirname.Data());
*/
TH1F* h_tt1l_Pull = new TH1F("h_tt1l_Pull", "Pull distrib. SF_1ltop", 30, -3, 3);
TH1F* h_Wjets_Pull = new TH1F("h_Wjets_Pull", "Pull distrib. SF_1ltop", 30, -3, 3);
TH1F* h_tt1l_uncert = new TH1F("h_tt1l_uncert", "Uncertainty on SF_1ltop", 100, 0, 5);
TH1F* h_Wjets_uncert = new TH1F("h_Wjets_uncert", "Uncertainty on SF_1ltop", 100, 0, 1);
//setup.Ndata = Ndata[c];
for(int np = 0; np<5000; np++){
res = doFit(setup,conditions);
Figure NormTail_1ltop(res.SF_1ltop.first,res.SF_1ltop.second);
Figure NormTail_Wjets=Figure(res.SF_Wjets.first,res.SF_Wjets.second);
cout<<NormTail_1ltop.Print()<<endl;
cout<<NormTail_Wjets.Print()<<endl;
h_tt1l_Pull->Fill((res.SF_1ltop.first-1)/res.SF_1ltop.second);
h_Wjets_Pull->Fill((res.SF_Wjets.first-1)/res.SF_Wjets.second);
h_tt1l_uncert->Fill(res.SF_1ltop.second/res.SF_1ltop.first);
h_Wjets_uncert->Fill(res.SF_Wjets.second/res.SF_Wjets.first);
//cout<<<<" "<<NormTail_Wjets<<endl;
//tableRawNormValues.Set("NormTail_1ltop",listIndividualCuts[i],NormTail_1ltop);
//tableRawNormValues.Set("NormTail_Wjets",listIndividualCuts[i],NormTail_Wjets);
/*
h_SF_MTtail_CC_1ltop.SetBinContent(i+1,res.SF_1ltop.first);
h_SF_MTtail_CC_1ltop.SetBinError(i+1,res.SF_1ltop.second);
h_SF_MTtail_CC_1ltop.GetXaxis()->SetBinLabel(i+1,label.c_str());
h_SF_MTtail_CC_Wjets.SetBinContent(i+1,res.SF_Wjets.first);
h_SF_MTtail_CC_Wjets.SetBinError(i+1,res.SF_Wjets.second);
h_SF_MTtail_CC_Wjets.GetXaxis()->SetBinLabel(i+1,label.c_str());
*/
}
//file->cd(dirname.Data());
file->cd();
h_tt1l_Pull->Write();
h_Wjets_Pull->Write();
h_tt1l_uncert->Write();
h_Wjets_uncert->Write();
file->cd();
//}
file->Close();
}
//Save plots in roofile
TFile fCR1_CC((string(OUTPUT_FOLDER)+"/results_CC.root").c_str(),"RECREATE");
h_SF_MTpeak_CC_1ltop.Write();
h_SF_MTpeak_CC_Wjets.Write();
h_SF_MTtail_CC_1ltop.Write();
h_SF_MTtail_CC_Wjets.Write();
h_SFR_CC_1ltop.Write();
h_SFR_CC_Wjets.Write();
//---------------------------------------------
// Results for C&C
//---------------------------------------------
initCutAndCountCuts();
vector<string> cuts;
for(unsigned int r=0;r<listCutAndCounts.size();r++)
{
cuts = listCutAndCounts_cuts[listCutAndCounts[r]];
Figure SFR_CC_1ltop;
Figure SFR_CC_Wjets;
for(unsigned i=0;i<cuts.size();i++)
{
cout<<cuts[i]<<" "<<SFR_CC_1ltop_map[cuts[i]].Print()<<endl;
if(i == 0) SFR_CC_1ltop = SFR_CC_1ltop_map[cuts[i]];
else SFR_CC_1ltop = Figure(SFR_CC_1ltop.value(),
sqrt(pow(SFR_CC_1ltop.error(),2)
+pow(SFR_CC_1ltop.value()
-SFR_CC_1ltop_map[cuts[i].c_str()].value(),2)
));
if(i == 0) SFR_CC_Wjets = SFR_CC_Wjets_map[cuts[i]];
else SFR_CC_Wjets = Figure(SFR_CC_Wjets.value(),
sqrt(pow(SFR_CC_Wjets.error(),2)
+pow(SFR_CC_Wjets.value()
-SFR_CC_Wjets_map[cuts[i].c_str()].value(),2)
));
}
// Add 20% of uncertainty for fit itself (JES, MC stat. ...)
SFR_CC_1ltop *= Figure(1.0,TEMPLATE_FIT_METHOD_UNCERTAINTY);
SFR_CC_Wjets *= Figure(1.0,TEMPLATE_FIT_METHOD_UNCERTAINTY);
tableSFRToBeUsed.Set("SFR-1ltop",listCutAndCounts[r],SFR_CC_1ltop);
tableSFRToBeUsed.Set("SFR-Wjets",listCutAndCounts[r],SFR_CC_Wjets);
}
tableRawSFR.Print(string(OUTPUT_FOLDER)+"/rawSFR.tab" ,4);
tableRawNormValues.Print(string(OUTPUT_FOLDER)+"/rawNormValues.tab" ,4);
tableSFRToBeUsed.Print(string(OUTPUT_FOLDER)+"/SF_MTtail.tab",4);
tableRawSFR.PrintLatex(string(OUTPUT_FOLDER)+"/SF_MTtail.tex",4);
}
void makeDatacard(double mh, double massLow, double massHigh, double merrHigh, int ch, std::string cat, std::map<std::string, std::string> file, bool useModZ, bool doMassErr) {
RooMsgService::instance().setSilentMode(kTRUE);
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING) ;
if (doMassErr && cat != "BB" && cat != "XX" && cat != "YY") {
std::cout << "When using event-by-event mass errors, set cat = BB or XX or YY" << std::endl;
return;
}
/* Setting up the strings */
std::string chstr = getChannelName(ch);
stringstream mh_ss;
mh_ss << mh;
std::cout << "Creating datacard for " << mh_ss.str() << " GeV mass point, channel " << chstr << " and category " << cat << " ... " << std::endl;
std::stringstream card_name_ss;
card_name_ss << "card_";
if (!doMassErr) card_name_ss << "1D_";
else card_name_ss << "2D_merr_";
card_name_ss << "m" << mh_ss.str() << "_";
card_name_ss << chstr << "_" << cat;
std::string card_name = card_name_ss.str();
std::string workspace = card_name+"_workspace.root";
/* Higgs mass and dimuon mass variables */
const char* massvarstr = "CMS_hmumu_mass";
const char* merrvarstr = "CMS_hmumu_merr";
const char* scalevarstr = "CMS_hmumu_scale";
const char* resvarstr = "CMS_hmumu_res";
const char* mhvarstr = "MH";
RooRealVar rmh ("MH" , "MH" , mh);
RooRealVar m2mu (massvarstr , "Dimuon mass", mh , massLow, massHigh, "GeV/c^{2}");
RooRealVar merr (merrvarstr , "Mass Error" , 0.0 , 0.0 , merrHigh, "" );
RooRealVar scale(scalevarstr, "Scale unc. ", 0.0 , 0.0 , 1.0 , "GeV/c^{2}");
RooRealVar res (resvarstr , "RFes. unc. ", 0.0 , 0.0 , 1.0);
m2mu.setBins(200);
merr.setBins(200);
/* RooDataSet of the observed data */
RooDataSet* data_obs = getDataSet(file["dat"].c_str(), false, ch, cat, massLow, massHigh, merrHigh, "data_obs", massvarstr, merrvarstr, false);
/* Extract shape parameters */
std::cout << "Extracting the signal fit parameters" << std::endl;
std::map<std::string, double> sparams = doFit(file["ggH"], true, 6, cat, 125.0, int(massHigh-massLow)*2, massLow, 140.0, false, true, useModZ, false);
std::cout << "Extracting the background fit parameters" << std::endl;
std::map<std::string, double> bparams = doFit(file["dat"], false, ch, cat, 125.0, int(massHigh-massLow) , massLow, massHigh, false, false, useModZ, true );
std::string ecat = "XX";
if (cat == "BB") ecat = "BB";
if (cat == "YY") ecat = "YY";
std::map<std::string, double> esparams;
std::map<std::string, double> ebparams;
if (doMassErr) {
if (cat == "BB") {
std::cout << "Extracting the signal mass error fit parameters" << std::endl;
esparams = doEbEFit(file["ggH"], true, ch, ecat, 140, 0.006, 0.013, massLow, massHigh, true, true, true);
std::cout << "Extracting the background mass error fit parameters" << std::endl;
ebparams = doEbEFit(file["DY"] , true, ch, ecat, 140, 0.006, 0.013, massLow, massHigh, true, true, false);
}
else {
std::cout << "Extracting the signal mass error fit parameters" << std::endl;
esparams = doEbEFit(file["ggH"], true, ch, ecat, 240, 0.005, 0.035, massLow, massHigh, true, true, true);
std::cout << "Extracting the background mass error fit parameters" << std::endl;
ebparams = doEbEFit(file["DY"] , true, ch, ecat, 240, 0.005, 0.035, massLow, massHigh, true, true, false);
}
}
/* Compute yields */
double bkg_yield = computeYield(data_obs, massvarstr, false, true);
bkg_yield *= bparams["bkgsf"];
std::cout << "Computing the expected background yield from the side-bands : " << bkg_yield << std::endl;
RooDataSet* sig_gH_dset = getDataSet(file["ggH"], true, ch, cat, massLow, massHigh, merrHigh, "dset_gH", massvarstr, merrvarstr, false);
RooDataSet* sig_qH_dset = getDataSet(file["qqH"], true, ch, cat, massLow, massHigh, merrHigh, "dset_qH", massvarstr, merrvarstr, false);
RooDataSet* sig_PH_dset = getDataSet(file["WPH"], true, ch, cat, massLow, massHigh, merrHigh, "dset_PH", massvarstr, merrvarstr, false);
RooDataSet* sig_MH_dset = getDataSet(file["WMH"], true, ch, cat, massLow, massHigh, merrHigh, "dset_MH", massvarstr, merrvarstr, false);
RooDataSet* sig_ZH_dset = getDataSet(file["ZH" ], true, ch, cat, massLow, massHigh, merrHigh, "dset_ZH", massvarstr, merrvarstr, false);
double sig_gH_yield = computeYield(sig_gH_dset, massvarstr, true, false);
double sig_qH_yield = computeYield(sig_qH_dset, massvarstr, true, false);
double sig_WH_yield = computeYield(sig_PH_dset, massvarstr, true, false);
sig_WH_yield += computeYield(sig_MH_dset, massvarstr, true, false);
double sig_ZH_yield = computeYield(sig_ZH_dset, massvarstr, true, false);
double sig_tH_yield = 1e-5;
delete sig_gH_dset;
delete sig_qH_dset;
delete sig_PH_dset;
delete sig_MH_dset;
delete sig_ZH_dset;
std::cout << "Computing the ggH signal yield : " << sig_gH_yield << std::endl;
std::cout << "Computing the qqH signal yield : " << sig_qH_yield << std::endl;
std::cout << "Computing the WH signal yield : " << sig_WH_yield << std::endl;
std::cout << "Computing the ZH signal yield : " << sig_ZH_yield << std::endl;
std::cout << "Computing the ttH signal yield : " << sig_tH_yield << std::endl;
std::string spdfstart = "";
std::string bpdfstart = "";
if (doMassErr) spdfstart = "sig_mass_merr_";
else spdfstart = "sig_mass_";
if (doMassErr) bpdfstart = "bkg_mass_merr_";
else bpdfstart = "bkg_mass_";
RooRealVar ggH_norm((spdfstart+"ggH_"+chstr+"_"+cat+"_pdf_norm").c_str(), "", sig_gH_yield);
RooRealVar qqH_norm((spdfstart+"qqH_"+chstr+"_"+cat+"_pdf_norm").c_str(), "", sig_qH_yield);
RooRealVar WH_norm ((spdfstart+"WH_" +chstr+"_"+cat+"_pdf_norm").c_str(), "", sig_WH_yield);
RooRealVar ZH_norm ((spdfstart+"ZH_" +chstr+"_"+cat+"_pdf_norm").c_str(), "", sig_ZH_yield);
RooRealVar ttH_norm((spdfstart+"ttH_"+chstr+"_"+cat+"_pdf_norm").c_str(), "", sig_tH_yield);
RooRealVar bkg_norm((bpdfstart+"" +chstr+"_"+cat+"_pdf_norm").c_str(), "", bkg_yield );
ggH_norm.setConstant(kTRUE);
WH_norm .setConstant(kTRUE);
ZH_norm .setConstant(kTRUE);
ggH_norm.setConstant(kTRUE);
ttH_norm.setConstant(kTRUE);
bkg_norm.setConstant(kTRUE);
/* Define PDFs */
// Background
RooRealVar ra_mass(("bkg_mass_"+chstr+cat+"_a" ).c_str(), "", bparams["a"], 0.0, 1.0 );
RooRealVar rb_mass(("bkg_mass_"+chstr+cat+"_b" ).c_str(), "", bparams["b"], -1.0, 10.0);
RooRealVar rp_mass(("bkg_mass_"+chstr+cat+"_p" ).c_str(), "", bparams["p"], -2.0, 2.0 );
RooRealVar rq_mass(("bkg_mass_"+chstr+cat+"_q" ).c_str(), "", bparams["q"], -2.0, 2.0 );
RooRealVar rr_mass(("bkg_mass_"+chstr+cat+"_r" ).c_str(), "", bparams["r"], -2.0, 2.0 );
RooAbsPdf* bkg_mass_pdf = NULL;
if (useModZ) {
RooModZPdf* bkg_mass_mz_pdf = new RooModZPdf (("bkg_mass_"+chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, rp_mass, rq_mass, rr_mass);
bkg_mass_pdf = bkg_mass_mz_pdf;
}
else {
RooZPhotonPdf* bkg_mass_zg_pdf = new RooZPhotonPdf(("bkg_mass_"+chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, ra_mass, rb_mass);
bkg_mass_pdf = bkg_mass_zg_pdf;
}
// Signal
std::stringstream meanss;
std::stringstream sigmass;
meanss << "@0 - " << sparams["mean"] << " + " << "@0*@1";
if (!doMassErr) sigmass << sparams["sigma"] << " * " << "(1+@0)";
else sigmass << "(@0*@1)" << " * " << "(1+@2)";
RooArgList sigmalist;
if (!doMassErr) sigmalist.add(res);
else {
sigmalist.add(merr);
sigmalist.add(m2mu);
sigmalist.add(res);
}
RooFormulaVar fmean_mass (("sig_mass_"+chstr+"_"+cat+"_fmean" ).c_str(), "", meanss .str().c_str(), RooArgList(rmh, scale));
RooFormulaVar fsigma_mass(("sig_mass_"+chstr+"_"+cat+"_fsigma").c_str(), "", sigmass.str().c_str(), sigmalist);
RooRealVar raL_mass (("sig_mass_"+chstr+"_"+cat+"_aL" ).c_str(), "", sparams["aL"]);
RooRealVar rnL_mass (("sig_mass_"+chstr+"_"+cat+"_nL" ).c_str(), "", sparams["nL"]);
RooRealVar raR_mass (("sig_mass_"+chstr+"_"+cat+"_aR" ).c_str(), "", sparams["aR"]);
RooRealVar rnR_mass (("sig_mass_"+chstr+"_"+cat+"_nR" ).c_str(), "", sparams["nR"]);
RooDoubleCB sig_mass_gH_pdf(("sig_mass_ggH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, fmean_mass, fsigma_mass, raL_mass, rnL_mass, raR_mass, rnR_mass);
RooDoubleCB sig_mass_qH_pdf(("sig_mass_qqH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, fmean_mass, fsigma_mass, raL_mass, rnL_mass, raR_mass, rnR_mass);
RooDoubleCB sig_mass_WH_pdf(("sig_mass_WH_" +chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, fmean_mass, fsigma_mass, raL_mass, rnL_mass, raR_mass, rnR_mass);
RooDoubleCB sig_mass_ZH_pdf(("sig_mass_ZH_" +chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, fmean_mass, fsigma_mass, raL_mass, rnL_mass, raR_mass, rnR_mass);
RooDoubleCB sig_mass_tH_pdf(("sig_mass_ttH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", m2mu, fmean_mass, fsigma_mass, raL_mass, rnL_mass, raR_mass, rnR_mass);
// Event-by-event mass error
RooRealVar rm1_merr_sig (("sig_merr_"+chstr+"_"+cat+"_m1" ).c_str(), "", esparams["m1"] );
RooRealVar rs1_merr_sig (("sig_merr_"+chstr+"_"+cat+"_s1" ).c_str(), "", esparams["s1"] );
RooRealVar raL1_merr_sig(("sig_merr_"+chstr+"_"+cat+"_aL1").c_str(), "", esparams["aL1"]);
RooRealVar rnL1_merr_sig(("sig_merr_"+chstr+"_"+cat+"_nL1").c_str(), "", esparams["nL1"]);
RooRealVar raR1_merr_sig(("sig_merr_"+chstr+"_"+cat+"_aR1").c_str(), "", esparams["aR1"]);
RooRealVar rnR1_merr_sig(("sig_merr_"+chstr+"_"+cat+"_nR1").c_str(), "", esparams["nR1"]);
RooRealVar rm2_merr_sig (("sig_merr_"+chstr+"_"+cat+"_m2" ).c_str(), "", esparams["m2"] );
RooRealVar rs2_merr_sig (("sig_merr_"+chstr+"_"+cat+"_s2" ).c_str(), "", esparams["s2"] );
RooRealVar raL2_merr_sig(("sig_merr_"+chstr+"_"+cat+"_aL2").c_str(), "", esparams["aL2"]);
RooRealVar rnL2_merr_sig(("sig_merr_"+chstr+"_"+cat+"_nL2").c_str(), "", esparams["nL2"]);
RooRealVar raR2_merr_sig(("sig_merr_"+chstr+"_"+cat+"_aR2").c_str(), "", esparams["aR2"]);
RooRealVar rnR2_merr_sig(("sig_merr_"+chstr+"_"+cat+"_nR2").c_str(), "", esparams["nR2"]);
RooRealVar rm3_merr_sig (("sig_merr_"+chstr+"_"+cat+"_m3" ).c_str(), "", esparams["m3"] );
RooRealVar rs3_merr_sig (("sig_merr_"+chstr+"_"+cat+"_s3" ).c_str(), "", esparams["s3"] );
RooRealVar rc0_merr_sig (("sig_merr_"+chstr+"_"+cat+"_c0" ).c_str(), "", esparams["c0"] );
RooRealVar rc1_merr_sig (("sig_merr_"+chstr+"_"+cat+"_c1" ).c_str(), "", esparams["c1"] );
RooRealVar rc2_merr_sig (("sig_merr_"+chstr+"_"+cat+"_c2" ).c_str(), "", esparams["c2"] );
RooRealVar rm1_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_m1" ).c_str(), "", ebparams["m1"] );
RooRealVar rs1_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_s1" ).c_str(), "", ebparams["s1"] );
RooRealVar raL1_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_aL1").c_str(), "", ebparams["aL1"]);
RooRealVar rnL1_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_nL1").c_str(), "", ebparams["nL1"]);
RooRealVar raR1_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_aR1").c_str(), "", ebparams["aR1"]);
RooRealVar rnR1_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_nR1").c_str(), "", ebparams["nR1"]);
RooRealVar rm2_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_m2" ).c_str(), "", ebparams["m2"] );
RooRealVar rs2_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_s2" ).c_str(), "", ebparams["s2"] );
RooRealVar raL2_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_aL2").c_str(), "", ebparams["aL2"]);
RooRealVar rnL2_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_nL2").c_str(), "", ebparams["nL2"]);
RooRealVar raR2_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_aR2").c_str(), "", ebparams["aR2"]);
RooRealVar rnR2_merr_bkg(("bkg_merr_"+chstr+"_"+cat+"_nR2").c_str(), "", ebparams["nR2"]);
RooRealVar rm3_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_m3" ).c_str(), "", ebparams["m3"] );
RooRealVar rs3_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_s3" ).c_str(), "", ebparams["s3"] );
RooRealVar rc0_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_c0" ).c_str(), "", ebparams["c0"] );
RooRealVar rc1_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_c1" ).c_str(), "", ebparams["c1"] );
RooRealVar rc2_merr_bkg (("bkg_merr_"+chstr+"_"+cat+"_c2" ).c_str(), "", ebparams["c2"] );
RooDoubleCB sig_merr_gH_pd1(("sig_merr_ggH_"+chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_sig, rs1_merr_sig, raL1_merr_sig, rnL1_merr_sig, raR1_merr_sig, rnR1_merr_sig);
RooDoubleCB sig_merr_qH_pd1(("sig_merr_qqH_"+chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_sig, rs1_merr_sig, raL1_merr_sig, rnL1_merr_sig, raR1_merr_sig, rnR1_merr_sig);
RooDoubleCB sig_merr_WH_pd1(("sig_merr_WH_" +chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_sig, rs1_merr_sig, raL1_merr_sig, rnL1_merr_sig, raR1_merr_sig, rnR1_merr_sig);
RooDoubleCB sig_merr_ZH_pd1(("sig_merr_ZH_" +chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_sig, rs1_merr_sig, raL1_merr_sig, rnL1_merr_sig, raR1_merr_sig, rnR1_merr_sig);
RooDoubleCB sig_merr_tH_pd1(("sig_merr_ttH_"+chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_sig, rs1_merr_sig, raL1_merr_sig, rnL1_merr_sig, raR1_merr_sig, rnR1_merr_sig);
RooDoubleCB sig_merr_gH_pd2(("sig_merr_ggH_"+chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_sig, rs2_merr_sig, raL2_merr_sig, rnL2_merr_sig, raR2_merr_sig, rnR2_merr_sig);
RooDoubleCB sig_merr_qH_pd2(("sig_merr_qqH_"+chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_sig, rs2_merr_sig, raL2_merr_sig, rnL2_merr_sig, raR2_merr_sig, rnR2_merr_sig);
RooDoubleCB sig_merr_WH_pd2(("sig_merr_WH_" +chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_sig, rs2_merr_sig, raL2_merr_sig, rnL2_merr_sig, raR2_merr_sig, rnR2_merr_sig);
RooDoubleCB sig_merr_ZH_pd2(("sig_merr_ZH_" +chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_sig, rs2_merr_sig, raL2_merr_sig, rnL2_merr_sig, raR2_merr_sig, rnR2_merr_sig);
RooDoubleCB sig_merr_tH_pd2(("sig_merr_ttH_"+chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_sig, rs2_merr_sig, raL2_merr_sig, rnL2_merr_sig, raR2_merr_sig, rnR2_merr_sig);
RooGaussian sig_merr_gH_pd3(("sig_merr_ggH_"+chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_sig, rs3_merr_sig);
RooGaussian sig_merr_qH_pd3(("sig_merr_qqH_"+chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_sig, rs3_merr_sig);
RooGaussian sig_merr_WH_pd3(("sig_merr_WH_" +chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_sig, rs3_merr_sig);
RooGaussian sig_merr_ZH_pd3(("sig_merr_ZH_" +chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_sig, rs3_merr_sig);
RooGaussian sig_merr_tH_pd3(("sig_merr_ttH_"+chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_sig, rs3_merr_sig);
RooAddPdf sig_merr_gH_pda(("sig_merr_ggH_"+chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(sig_merr_gH_pd1, sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc1_merr_sig, rc2_merr_sig));
RooAddPdf sig_merr_qH_pda(("sig_merr_qqH_"+chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(sig_merr_qH_pd1, sig_merr_qH_pd2, sig_merr_qH_pd3), RooArgList(rc1_merr_sig, rc2_merr_sig));
RooAddPdf sig_merr_WH_pda(("sig_merr_WH_" +chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(sig_merr_WH_pd1, sig_merr_WH_pd2, sig_merr_WH_pd3), RooArgList(rc1_merr_sig, rc2_merr_sig));
RooAddPdf sig_merr_ZH_pda(("sig_merr_ZH_" +chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(sig_merr_ZH_pd1, sig_merr_ZH_pd2, sig_merr_ZH_pd3), RooArgList(rc1_merr_sig, rc2_merr_sig));
RooAddPdf sig_merr_tH_pda(("sig_merr_ttH_"+chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(sig_merr_tH_pd1, sig_merr_tH_pd2, sig_merr_tH_pd3), RooArgList(rc1_merr_sig, rc2_merr_sig));
RooAddPdf sig_merr_gH_pdb(("sig_merr_ggH_"+chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc0_merr_sig ));
RooAddPdf sig_merr_qH_pdb(("sig_merr_qqH_"+chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc0_merr_sig ));
RooAddPdf sig_merr_WH_pdb(("sig_merr_WH_" +chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc0_merr_sig ));
RooAddPdf sig_merr_ZH_pdb(("sig_merr_ZH_" +chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc0_merr_sig ));
RooAddPdf sig_merr_tH_pdb(("sig_merr_ttH_"+chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( sig_merr_gH_pd2, sig_merr_gH_pd3), RooArgList(rc0_merr_sig ));
RooDoubleCB bkg_merr_pd1 (("bkg_merr_" +chstr+"_"+cat+"_pd1" ).c_str(), "", merr, rm1_merr_bkg, rs1_merr_bkg, raL1_merr_bkg, rnL1_merr_bkg, raR1_merr_bkg, rnR1_merr_bkg);
RooDoubleCB bkg_merr_pd2 (("bkg_merr_" +chstr+"_"+cat+"_pd2" ).c_str(), "", merr, rm2_merr_bkg, rs2_merr_bkg, raL2_merr_bkg, rnL2_merr_bkg, raR2_merr_bkg, rnR2_merr_bkg);
RooGaussian bkg_merr_pd3 (("bkg_merr_" +chstr+"_"+cat+"_pd3" ).c_str(), "", merr, rm3_merr_bkg, rs3_merr_bkg);
RooAddPdf bkg_merr_pda (("bkg_merr_" +chstr+"_"+cat+"_pda" ).c_str(), "", RooArgList(bkg_merr_pd1, bkg_merr_pd2, bkg_merr_pd3), RooArgList(rc1_merr_bkg, rc2_merr_bkg));
RooAddPdf bkg_merr_pdb (("bkg_merr_" +chstr+"_"+cat+"_pdb" ).c_str(), "", RooArgList( bkg_merr_pd2, bkg_merr_pd3), RooArgList(rc0_merr_bkg ));
RooAbsPdf* sig_merr_gH_abspdf;
RooAbsPdf* sig_merr_qH_abspdf;
RooAbsPdf* sig_merr_WH_abspdf;
RooAbsPdf* sig_merr_ZH_abspdf;
RooAbsPdf* sig_merr_tH_abspdf;
RooAbsPdf* bkg_merr_abspdf;
if (cat == "BB") {
sig_merr_gH_abspdf = &sig_merr_gH_pd1;
sig_merr_qH_abspdf = &sig_merr_qH_pd1;
sig_merr_WH_abspdf = &sig_merr_WH_pd1;
sig_merr_ZH_abspdf = &sig_merr_ZH_pd1;
sig_merr_tH_abspdf = &sig_merr_tH_pd1;
bkg_merr_abspdf = &bkg_merr_pd1;
}
else if (cat == "XX") {
sig_merr_gH_abspdf = &sig_merr_gH_pda;
sig_merr_qH_abspdf = &sig_merr_qH_pda;
sig_merr_WH_abspdf = &sig_merr_WH_pda;
sig_merr_ZH_abspdf = &sig_merr_ZH_pda;
sig_merr_tH_abspdf = &sig_merr_tH_pda;
bkg_merr_abspdf = &bkg_merr_pda;
}
else {
sig_merr_gH_abspdf = &sig_merr_gH_pdb;
sig_merr_qH_abspdf = &sig_merr_qH_pdb;
sig_merr_WH_abspdf = &sig_merr_WH_pdb;
sig_merr_ZH_abspdf = &sig_merr_ZH_pdb;
sig_merr_tH_abspdf = &sig_merr_tH_pdb;
bkg_merr_abspdf = &bkg_merr_pdb;
}
RooProdPdf sig_mass_merr_gH_pdf(("sig_mass_merr_ggH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", *sig_merr_gH_abspdf, RooFit::Conditional(sig_mass_gH_pdf , RooArgSet(m2mu)));
RooProdPdf sig_mass_merr_qH_pdf(("sig_mass_merr_qqH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", *sig_merr_qH_abspdf, RooFit::Conditional(sig_mass_qH_pdf , RooArgSet(m2mu)));
RooProdPdf sig_mass_merr_WH_pdf(("sig_mass_merr_WH_" +chstr+"_"+cat+"_pdf" ).c_str(), "", *sig_merr_WH_abspdf, RooFit::Conditional(sig_mass_WH_pdf , RooArgSet(m2mu)));
RooProdPdf sig_mass_merr_ZH_pdf(("sig_mass_merr_ZH_" +chstr+"_"+cat+"_pdf" ).c_str(), "", *sig_merr_ZH_abspdf, RooFit::Conditional(sig_mass_ZH_pdf , RooArgSet(m2mu)));
RooProdPdf sig_mass_merr_tH_pdf(("sig_mass_merr_ttH_"+chstr+"_"+cat+"_pdf" ).c_str(), "", *sig_merr_tH_abspdf, RooFit::Conditional(sig_mass_tH_pdf , RooArgSet(m2mu)));
RooProdPdf bkg_mass_merr_pdf (("bkg_mass_merr_" +chstr+"_"+cat+"_pdf" ).c_str(), "", *bkg_mass_pdf , *bkg_merr_abspdf);
/* Creating the workspace the workspace */
RooWorkspace w("w", "");
w.import(*data_obs);
w.import(ggH_norm);
w.import(qqH_norm);
w.import(WH_norm);
w.import(ZH_norm);
w.import(ttH_norm);
w.import(bkg_norm);
if (doMassErr) {
w.import(sig_mass_merr_gH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_merr_qH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_merr_WH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_merr_ZH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_merr_tH_pdf, RooFit::RecycleConflictNodes());
w.import(bkg_mass_merr_pdf , RooFit::RecycleConflictNodes());
RooDataSet* data_pseudo = bkg_mass_merr_pdf.generate(RooArgSet(m2mu, merr), int(bkg_norm.getVal()));
data_pseudo->SetName("data_pseudo");
w.import(*data_pseudo);
}
else {
w.import(sig_mass_gH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_qH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_WH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_ZH_pdf, RooFit::RecycleConflictNodes());
w.import(sig_mass_tH_pdf, RooFit::RecycleConflictNodes());
w.import(*bkg_mass_pdf , RooFit::RecycleConflictNodes());
RooDataSet* data_pseudo = bkg_mass_pdf->generate(RooArgSet(m2mu), int(bkg_norm.getVal()));
data_pseudo->SetName("data_pseudo");
w.import(*data_pseudo);
}
w.writeToFile(workspace.c_str());
/* Create the data card text file */
std::string card = createCardTemplate(mh, ch, cat, workspace, doMassErr);
std::ofstream ofile;
ofile.open ((card_name +".txt").c_str());
ofile << card;
ofile.close();
if (bkg_mass_pdf != NULL) delete bkg_mass_pdf;
delete data_obs;
}
extern "C" int pluginFitFunc(pulsar *psr,int npsr,int writeModel)
{
int p,i,k,j;
int count=0;
int flags[MAX_PSR];
longdouble* preobs[MAX_PSR];
printf(" <DMMODEL> Reset DM component of error to 0\n");
for (p=0; p < npsr; p++){
if (psr[p].param[param_dmmodel].fitFlag[0]==1){
flags[p]=1;
count++;
for(i=0; i < psr[p].nobs; i++){
psr[p].obsn[i].toaErr=psr[p].obsn[i].origErr;
psr[p].obsn[i].toaDMErr=0;
}
} else flags[p]=0;
}
strcpy(psr[0].fitFunc,"default");
printf(" <DMMODEL> First fit...\n");
if (strcmp(dcmFile,"NULL")==0 && strcmp(covarFuncFile,"NULL")==0)
doFit(psr,npsr,writeModel);
else
doFitDCM(psr,dcmFile,covarFuncFile,npsr,0);
for (p=0; p < npsr; p++){
char** labels = (char**)malloc(sizeof(char*)*MAX_PARAMS);
for (i=0;i<MAX_PARAMS;i++){
labels[i]= (char*)malloc(80);
strcpy(labels[i],"UNK_PARAM");
}
getFitLabels(psr,p,labels);
double** cvm=psr[p].covar;
int npol = psr[p].nFit - psr[p].fitNfree;
bool warn=false;
for (i=0;i<npol;i++){
for (j=0;j<i;j++){
double cv=fabs(cvm[i][j]/sqrt((cvm[j][j])*(cvm[i][i])));
if(cv > 0.5){
if(!warn){
printf(" <DMMODEL> Warning: highly covariant parameters in fit!\n");
warn=true;
}
printf(" % 15s % 15s %lg\n",labels[i],labels[j],cv);
}
}
}
for (i=0;i<MAX_PARAMS;i++)free(labels[i]);
free(labels);
}
if(count){
printf(" <DMMODEL> Disable DMMODEL\n");
// we also save the pre-fit residuals so it appears as if only one fit has happened
for (p=0; p < npsr; p++){
preobs[p] = (longdouble*)malloc(sizeof(longdouble)*psr[p].nobs);
for(i=0; i < psr[p].nobs; i++){
preobs[p][i]=psr[p].obsn[i].prefitResidual;
}
psr[p].param[param_dmmodel].fitFlag[0]=0;
}
formBatsAll(psr,npsr);
formResiduals(psr,npsr,0);
printf(" <DMMODEL> Second Fit...\n");
if (strcmp(dcmFile,"NULL")==0 && strcmp(covarFuncFile,"NULL")==0)
doFit(psr,npsr,writeModel);
else
doFitDCM(psr,dcmFile,covarFuncFile,npsr,0);
printf(" <DMMODEL> Enable DMMODEL\n");
for (p=0; p < npsr; p++){
psr[p].param[param_dmmodel].fitFlag[0]=flags[p];
// restore the pre-fit residuals
for(i=0; i < psr[p].nobs; i++){
psr[p].obsn[i].prefitResidual=preobs[p][i];
}
}
}
strcpy(psr[0].fitFunc,"dmmodel");
return 0;
}
int bootstrap(pulsar *psr,int p,int npsr)
{
longdouble param[MAX_PARAMS],err[MAX_PARAMS],psq[MAX_PARAMS],xmean[MAX_PARAMS];
longdouble result[MAX_PARAMS][MAX_ITER];
longdouble fac,x1,x2,xmid,sum,sumwt,wgt,x,dt,mean,meansq,sdev;
int nFit=0,nFit2,npts,okay;
int i,j,k,ii,nboot,iter,l;
int il1,il2,ih1,ih2;
double globalParam;
long idum = -999; /* Should be set be clock, or user */
const char *CVS_verNum = "$Id: 6b34ebfda6648825ae3d3f51fb5041e0763c9ec1 $";
if (displayCVSversion == 1) CVSdisplayVersion("bootstrap.C","bootstrap()",CVS_verNum);
printf("Bootstrap1 = %d\n",psr[0].bootStrap);
copyPSR(psr,p,npsr); /* Have a copy of the pulsar */
for (i=0;i<MAX_PARAMS;i++)
copyParam(psr[0].param[i],&(psr[npsr].param[i]));
printf("Bootstrap = %d %d\n",psr[0].bootStrap,psr[1].bootStrap);
nboot = (int)pow(2,psr[p].bootStrap);
for (i=0;i<psr[p].nobs;i++)
psr[p].obsn[i].residual = psr[p].obsn[i].prefitResidual;
/* Store the current post-fit parameters and their errors */
for (i=0;i<MAX_PARAMS;i++)
{
for (k=0;k<psr[p].param[i].aSize;k++)
{
if (psr[p].param[i].fitFlag[k] == 1)
{
param[nFit] = psr[p].param[i].val[k]; /* - psr[p].param[i].prefit[k]; */
ld_printf("Initial param = %s %Lf %Lf\n",psr[p].param[i].label[0],
psr[p].param[i].val[k], psr[p].param[i].prefit[k]);
err[nFit] = psr[p].param[i].err[k];
psq[nFit] = 0.0;
nFit++;
psr[p].param[i].val[k] = psr[p].param[i].prefit[k];
}
}
}
/* Determine number of TOAs */
npts=0;
okay=0;
for (i=0;i<psr[p].nobs;i++)
{
if (psr[p].obsn[i].deleted==0)
okay=1;
/* Check for START and FINISH flags */
if (psr[p].param[param_start].paramSet[0]==1 && psr[p].param[param_start].fitFlag[0]==1 &&
psr[p].param[param_start].val[0] > psr[p].obsn[i].bat)
okay=0;
if (psr[p].param[param_finish].paramSet[0]==1 && psr[p].param[param_finish].fitFlag[0]==1 &&
psr[p].param[param_finish].val[0] < psr[p].obsn[i].bat)
okay=0;
if (okay==1)
npts++;
}
/* Do the bootstrap monte-carlo */
fac = sqrt((double)npts);
x1 = 0.342*nboot;
x2 = 0.477*nboot;
xmid = 0.5*(nboot+1);
il1 = (int)((xmid-x1)+0.5);
il2 = (int)((xmid-x2)+0.5);
ih1 = (int)((xmid+x1)+0.5);
ih2 = (int)((xmid+x2)+0.5);
for (iter=0;iter<nboot;iter++)
{
sum = 0.0;
sumwt = 0.0;
for (j=0;j<nFit;j++)
xmean[j] = 0.0;
for (i=0;i<npts;i++)
{
if (psr[npsr].fitMode==1)
wgt = 1.0 /
(1.0e-6*psr[npsr].obsn[i].toaErr*psr[npsr].param[param_f].val[0]*
1.0e-6*psr[npsr].obsn[i].toaErr*psr[npsr].param[param_f].val[0]);
else wgt=1.0/(1.0e-6*psr[npsr].param[param_f].val[0]*1.0e-6*psr[npsr].param[param_f].val[0]);
dt = psr[npsr].obsn[i].residual;
ii = (int)(npts*random(&idum)); /* Randomise the data index */
for (j=0;j<nFit;j++)
xmean[j]+=wgt; /* *fctn[j]; --- NEEDS TO BE IN -- WHAT IS THIS FOR ANYWAY?? */
sum+=wgt*dt;
sumwt+=wgt;
/* */
/* Randomly change around the observation order */
/* */
psr[p].obsn[i].prefitResidual = psr[npsr].obsn[ii].prefitResidual;
psr[p].obsn[i].residual = psr[npsr].obsn[ii].residual;
psr[p].obsn[i].sat = psr[npsr].obsn[ii].sat;
psr[p].obsn[i].bat = psr[npsr].obsn[ii].bat;
psr[p].obsn[i].deleted = psr[npsr].obsn[ii].deleted;
psr[p].obsn[i].freq = psr[npsr].obsn[ii].freq;
psr[p].obsn[i].freqSSB = psr[npsr].obsn[ii].freqSSB;
psr[p].obsn[i].toaErr = psr[npsr].obsn[ii].toaErr;
strcpy(psr[p].obsn[i].fname,psr[npsr].obsn[ii].fname);
strcpy(psr[p].obsn[i].telID,psr[npsr].obsn[ii].telID);
for (l=0;l<3;l++)
{
psr[p].obsn[i].earth_ssb[l] = psr[npsr].obsn[ii].earth_ssb[l];
psr[p].obsn[i].observatory_earth[l] = psr[npsr].obsn[ii].observatory_earth[l];
}
}
writeTim("testout.tim",psr,"fred");
psr[p].bootStrap = 0;
doFit(&psr[p],1,0);
/* textOutput(psr,npsr,globalParam,0,0,0,""); */ /* Output results to the screen */
j=0;
for (i=0;i<MAX_PARAMS;i++)
{
for (k=0;k<psr[p].param[i].aSize;k++)
{
if (psr[p].param[i].fitFlag[k] == 1)
{
/* x = fac*((psr[p].param[i].val[k] - psr[p].param[i].prefit[k])-param[j])/err[j]; */
/* WHY IS FACTOR USED HERE? */
x = ((psr[p].param[i].val[k] - psr[p].param[i].prefit[k])-param[j]);
result[j][iter] = psr[p].param[i].val[k]-param[j];
psq[j]+=x*x;
j++;
}
}
}
/* Store the current post-fit parameters and their errors */
for (i=0;i<psr[p].nobs;i++)
psr[p].obsn[i].residual = psr[npsr].obsn[i].prefitResidual;
for (i=0;i<MAX_PARAMS;i++)
{
for (k=0;k<psr[p].param[i].aSize;k++)
{
if (psr[p].param[i].fitFlag[k] == 1)
{
psr[p].param[i].prefit[k] = psr[npsr].param[i].prefit[k];
psr[p].param[i].val[k] = psr[npsr].param[i].prefit[k];
}
}
}
printf("Finished iteration %d of %d, so %g percent done.\n", (int)(iter+1.5),(int)(nboot+0.5),(double)((double)(iter+1.5)*100/nboot));
}
/* Restore the post-fit parameters, but use the Monte-carlo error estimates */
nFit2=0;
for (i=0;i<MAX_PARAMS;i++)
{
for (k=0;k<psr[p].param[i].aSize;k++)
{
if (psr[p].param[i].fitFlag[k] == 1)
{
mean=longdouble(0.0);
meansq=longdouble(0.0);
for (l=0;l<nboot;l++)
{
mean += (result[nFit2][l])/nboot;
meansq+= (result[nFit2][l]*result[nFit2][l])/nboot;
ld_printf("bootstrap parameters [%s] = %.14Lg\n",psr[p].param[i].shortlabel[k],
result[nFit2][l]+param[nFit2]);
}
/* mean/=(longdouble)nboot;
meansq/=(longdouble)nboot; */
sdev = (longdouble)sqrt(meansq-mean*mean);
ld_printf("Bootstrap mean difference: %Lf mean squared: %.14Lf rms: %.14Lf; sigma: %.14Lf, mean value: %.14Lf\n",
mean,(mean*mean),meansq,sdev,(mean+param[nFit2]));
/* psr[p].param[i].val[k] = psr[npsr].param[i].val[k]; */
psr[p].param[i].val[k] = mean+param[nFit2];
psr[p].param[i].err[k] = sdev;
/* psr[p].param[i].err[k] = err[nFit2]*sqrt(psq[nFit2]/nboot); */
/* psr[p].param[i].err[k] = sqrt(psq[nFit2]/(nboot-1)); */
/* sort(nboot,a[1][j]);
fl1[nFit2] = a[il1][j];
fl2[nFit2] = a[il2][j];
fh1[nFit2] = a[ih1][j];
fh2[nFit2] = a[ih2][j]; */
nFit2++;
}
}
}
return 0;
}
