void kirk_dune() { // this binning is a primary determinant of the time this macro takes to run // very coarse binning, just to test macro, will worsen results: ~ 45 min // int binsnumuE = 4; // int binsnumuPID = 4; // int binsnueE = 4; // int binsnuePID = 4; // full binning: 2-3 hours int binsnumuE = 15; int binsnumuPID = 15; int binsnueE = 15; int binsnuePID = 20; int binsnumu2d = binsnumuE*binsnumuPID; int binsnue2d = binsnumuE*binsnumuPID; rootlogon(); // style // POT/yr * 3.5yrs * mass correction const double pot = 3.5 * 1.47e21 * 40/1.13; SpectrumLoader loaderNumu("/pnfs/dune/persistent/TaskForce_AnaTree/far/train/v2.2/numutest.root"); SpectrumLoader loaderNue("/pnfs/dune/persistent/TaskForce_AnaTree/far/train/v2.2/nuetest.root"); SpectrumLoader loaderNumuRHC("/pnfs/dune/persistent/TaskForce_AnaTree/far/train/v2.2/anumutest.root"); SpectrumLoader loaderNueRHC("/pnfs/dune/persistent/TaskForce_AnaTree/far/train/v2.2/anuetest.root"); osc::IOscCalculatorAdjustable* calc = DefaultOscCalc(); calc->SetL(1300); calc->SetdCP(TMath::Pi()*1.5); // Standard DUNE numbers from Matt Bass calc->SetTh12(0.5857); calc->SetTh13(0.148); calc->SetTh23(0.7854); calc->SetDmsq21(0.000075); calc->SetDmsq32(0.002524-0.000075); // quoted value is 31 osc::IOscCalculatorAdjustable* calci = DefaultOscCalc(); calci->SetL(1300); calci->SetdCP(TMath::Pi()*1.5); // Standard DUNE numbers from Matt Bass calci->SetTh12(0.5857); calci->SetTh13(0.148); calci->SetTh23(0.7854); calci->SetDmsq21(0.000075); calci->SetDmsq32(-(0.002524+0.000075)); // quoted value is 31 // One sigma errors // (t12,t13,t23,dm21,dm32)=(0.023,0.018,0.058,0.0,0.024,0.016) auto* loaderNumuBeam = loaderNumu.LoaderForRunPOT(20000001); auto* loaderNumuNue = loaderNumu.LoaderForRunPOT(20000002); auto* loaderNumuNuTau = loaderNumu.LoaderForRunPOT(20000003); auto* loaderNumuNC = loaderNumu.LoaderForRunPOT(0); auto* loaderNueBeam = loaderNue.LoaderForRunPOT(20000001); auto* loaderNueNue = loaderNue.LoaderForRunPOT(20000002); auto* loaderNueNuTau = loaderNue.LoaderForRunPOT(20000003); auto* loaderNueNC = loaderNue.LoaderForRunPOT(0); auto* loaderNumuBeamRHC = loaderNumuRHC.LoaderForRunPOT(20000004); auto* loaderNumuNueRHC = loaderNumuRHC.LoaderForRunPOT(20000005); auto* loaderNumuNuTauRHC = loaderNumuRHC.LoaderForRunPOT(20000006); auto* loaderNumuNCRHC = loaderNumuRHC.LoaderForRunPOT(0); auto* loaderNueBeamRHC = loaderNueRHC.LoaderForRunPOT(20000004); auto* loaderNueNueRHC = loaderNueRHC.LoaderForRunPOT(20000005); auto* loaderNueNuTauRHC = loaderNueRHC.LoaderForRunPOT(20000006); auto* loaderNueNCRHC = loaderNueRHC.LoaderForRunPOT(0); Loaders loadersdunenue; loadersdunenue.AddLoader(loaderNueBeam, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNonSwap); loadersdunenue.AddLoader(loaderNueNue, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNue); loadersdunenue.AddLoader(loaderNueNuTau, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kTau); loadersdunenue.AddLoader(loaderNueNC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNC); Loaders loadersdunenuerhc; loadersdunenuerhc.AddLoader(loaderNueBeamRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNonSwap); loadersdunenuerhc.AddLoader(loaderNueNueRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNue); loadersdunenuerhc.AddLoader(loaderNueNuTauRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kTau); loadersdunenuerhc.AddLoader(loaderNueNCRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNC); Loaders loadersdunenumu; loadersdunenumu.AddLoader(loaderNumuBeam, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNonSwap); loadersdunenumu.AddLoader(loaderNumuNue, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNue); loadersdunenumu.AddLoader(loaderNumuNuTau, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kTau); loadersdunenumu.AddLoader(loaderNumuNC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNC); Loaders loadersdunenumurhc; loadersdunenumurhc.AddLoader(loaderNumuBeamRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNonSwap); loadersdunenumurhc.AddLoader(loaderNumuNueRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNue); loadersdunenumurhc.AddLoader(loaderNumuNuTauRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kTau); loadersdunenumurhc.AddLoader(loaderNumuNCRHC, caf::kFARDET, Loaders::kMC, ana::kBeam, Loaders::kNC); const Var Enu_reco = SIMPLEVAR(dune.Ev_reco); const Var pid_reco = SIMPLEVAR(dune.mvaresult); float kNumuMVACutFHC = 0.25; float kNumuMVACutRHC = 0.5; float kNueMVACut = 0.8; const Cut kSelNumu = SIMPLEVAR(dune.mvaresult) > kNumuMVACutFHC; const Cut kSelNumuRHC = SIMPLEVAR(dune.mvaresult) > kNumuMVACutRHC; const Cut kSelNue = SIMPLEVAR(dune.mvaresult) > kNueMVACut; const Cut kSelNueRHC = SIMPLEVAR(dune.mvaresult) > kNueMVACut; std::vector<const ISyst*> systsE = {&kEnergyScaleSyst, &kEnergyResSyst}; std::vector<const ISyst*> systsnorm = {&kNCSyst, &kNutauSyst, &kNueBeamSyst}; std::vector<const ISyst*> systsall = {&kEnergyScaleSyst, &kEnergyResSyst, &kNCSyst, &kNutauSyst, &kNueBeamSyst}; std::vector<const ISyst*> systsall2 = {&kEnergyScaleSyst, &kEnergyResSyst, &kNCSyst2, &kNutauSyst, &kNueBeamSyst}; const Var kEnuPidNumu = Var2D(Enu_reco, Binning::Simple(binsnumuE, 0, 10), pid_reco, Binning::Simple(binsnumuPID, -1, +1)); const Var kEnuPidNue = Var2D(Enu_reco, Binning::Simple(binsnueE, 0, 6), pid_reco, Binning::Simple(binsnuePID, -1, +1)); // 2D w/ Loaders NoExtrapGenerator gendunenumu(HistAxis("PID/E2d", Binning::Simple(binsnumu2d,0,binsnumu2d), kEnuPidNumu), kNoCut); NoExtrapGenerator gendunenue (HistAxis("PID/E2d", Binning::Simple(binsnue2d,0,binsnue2d), kEnuPidNue), kNoCut); PredictionInterp preddunenumu(systsall, calc, gendunenumu, loadersdunenumu); PredictionInterp preddunenue (systsall, calc, gendunenue, loadersdunenue); NoExtrapGenerator gendunenumurhc(HistAxis("PID/E2d", Binning::Simple(binsnumu2d,0,binsnumu2d), kEnuPidNumu), kNoCut); NoExtrapGenerator gendunenuerhc (HistAxis("PID/E2d", Binning::Simple(binsnue2d,0,binsnue2d), kEnuPidNue), kNoCut); PredictionInterp preddunenumurhc(systsall, calc, gendunenumurhc, loadersdunenumurhc); PredictionInterp preddunenuerhc (systsall, calc, gendunenuerhc, loadersdunenuerhc); // 1D w/ Loaders NoExtrapGenerator gendunenumu1d(HistAxis("Reconstructed Energy (GeV)", Binning::Simple(80,0,10), Enu_reco), kSelNumu); NoExtrapGenerator gendunenue1d (HistAxis("Reconstructed Energy (GeV)", Binning::Simple(80,0,10), Enu_reco), kSelNue); PredictionInterp preddunenumu1d(systsall, calc, gendunenumu1d, loadersdunenumu); PredictionInterp preddunenue1d (systsall, calc, gendunenue1d, loadersdunenue); NoExtrapGenerator gendunenumu1drhc(HistAxis("Reconstructed Energy (GeV)", Binning::Simple(80,0,10), Enu_reco), kSelNumuRHC); NoExtrapGenerator gendunenue1drhc (HistAxis("Reconstructed Energy (GeV)", Binning::Simple(80,0,10), Enu_reco), kSelNueRHC); PredictionInterp preddunenumu1drhc(systsall, calc, gendunenumu1drhc, loadersdunenumurhc); PredictionInterp preddunenue1drhc (systsall, calc, gendunenue1drhc, loadersdunenuerhc); // SpectrumLoader instead of Loaders PredictionNoExtrap predNumuPID(*loaderNumuBeam, *loaderNumuNue, *loaderNumuNuTau, *loaderNumuNC, "PID", Binning::Simple(100, -1, +1), SIMPLEVAR(dune.mvaresult), kNoCut); PredictionNoExtrap predNumuPIDRHC(*loaderNumuBeamRHC, *loaderNumuNueRHC, *loaderNumuNuTauRHC, *loaderNumuNCRHC, "PID", Binning::Simple(100, -1, +1), SIMPLEVAR(dune.mvaresult), kNoCut); PredictionNoExtrap predNuePID(*loaderNueBeam, *loaderNueNue, *loaderNueNuTau, *loaderNueNC, "PID", Binning::Simple(100, -1, +1), SIMPLEVAR(dune.mvaresult), kNoCut); PredictionNoExtrap predNuePIDRHC(*loaderNueBeamRHC, *loaderNueNueRHC, *loaderNueNuTauRHC, *loaderNueNCRHC, "PID", Binning::Simple(100, -1, +1), SIMPLEVAR(dune.mvaresult), kNoCut); PredictionNoExtrap pred(*loaderNumuBeam, *loaderNumuNue, *loaderNumuNuTau, *loaderNumuNC, "Reconstructed E (GeV)", Binning::Simple(80, 0, 10), Enu_reco, kSelNumu); PredictionNoExtrap pred2d(*loaderNumuBeam, *loaderNumuNue, *loaderNumuNuTau, *loaderNumuNC, "Reconstructed E (GeV)", Binning::Simple(binsnumu2d, 0, binsnumu2d), kEnuPidNumu, kNoCut); PredictionNoExtrap predRHC(*loaderNumuBeamRHC, *loaderNumuNueRHC, *loaderNumuNuTauRHC, *loaderNumuNCRHC, "Reconstructed E (GeV)", Binning::Simple(80, 0, 10), Enu_reco, kSelNumuRHC); PredictionNoExtrap predNue(*loaderNueBeam, *loaderNueNue, *loaderNueNuTau, *loaderNueNC, "Reconstructed E (GeV)", Binning::Simple(24, 0, 6), Enu_reco, kSelNue); PredictionNoExtrap predNue2d(*loaderNueBeam, *loaderNueNue, *loaderNueNuTau, *loaderNueNC, "Reconstructed E (GeV)", Binning::Simple(binsnue2d, 0, binsnue2d), kEnuPidNue, kNoCut); PredictionNoExtrap predNueRHC(*loaderNueBeamRHC, *loaderNueNueRHC, *loaderNueNuTauRHC, *loaderNueNCRHC, "Reconstructed E (GeV)", Binning::Simple(24, 0, 6), Enu_reco, kSelNueRHC); // test systematics are really shifting SystShifts scaleshift, resshift; scaleshift.SetShift(&kEnergyScaleSyst, +3); resshift.SetShift(&kEnergyResSyst, +3); Spectrum nom2(*loaderNumuBeam, HistAxis("blah", Binning::Simple(binsnumuE,0,binsnumuE), Enu_reco), kNoCut); Spectrum scale2(*loaderNumuBeam, HistAxis("blah", Binning::Simple(binsnumuE,0,binsnumuE), Enu_reco), kNoCut, scaleshift); Spectrum res2(*loaderNumuBeam, HistAxis("blah", Binning::Simple(binsnumuE,0,binsnumuE), Enu_reco), kNoCut, resshift); loaderNumu.Go(); loaderNue.Go(); loaderNumuRHC.Go(); loaderNueRHC.Go(); // have to have this for each prediction from a Loaders or it doesn't work; TODO fix this in source code preddunenue.LoadedCallback(); preddunenumu.LoadedCallback(); preddunenuerhc.LoadedCallback(); preddunenumurhc.LoadedCallback(); preddunenue1d.LoadedCallback(); preddunenumu1d.LoadedCallback(); preddunenue1drhc.LoadedCallback(); preddunenumu1drhc.LoadedCallback(); SaveToFile(preddunenue, "pred_nue_fhc.root", "pred"); SaveToFile(preddunenuerhc, "pred_nue_rhc.root", "pred"); SaveToFile(preddunenumu, "pred_numu_fhc.root", "pred"); SaveToFile(preddunenumurhc, "pred_numu_rhc.root", "pred"); Spectrum mock = pred.Predict(calc).FakeData(pot); SingleSampleExperiment expt(&pred, mock); Spectrum mock2d = pred2d.Predict(calc).FakeData(pot); SingleSampleExperiment expt2d(&pred2d, mock2d); Spectrum mock2dsysts = preddunenumu.Predict(calc).FakeData(pot); SingleSampleExperiment expt2dsysts(&preddunenumu, mock2dsysts); Spectrum mock2dsystsrhc = preddunenumurhc.Predict(calc).FakeData(pot); SingleSampleExperiment expt2dsystsrhc(&preddunenumurhc, mock2dsystsrhc); Spectrum mock2di = pred2d.Predict(calci).FakeData(pot); SingleSampleExperiment expt2di(&pred2d, mock2di); Spectrum mock2disysts = preddunenumu.Predict(calci).FakeData(pot); SingleSampleExperiment expt2disysts(&preddunenumu, mock2disysts); Spectrum mock2disystsrhc = preddunenumurhc.Predict(calci).FakeData(pot); SingleSampleExperiment expt2disystsrhc(&preddunenumurhc, mock2disystsrhc); Spectrum mockRHC = predRHC.Predict(calc).FakeData(pot); SingleSampleExperiment exptRHC(&predRHC, mockRHC); Spectrum mockNue = predNue.Predict(calc).FakeData(pot); SingleSampleExperiment exptNue(&predNue, mockNue); Spectrum mockNue2d = predNue2d.Predict(calc).FakeData(pot); SingleSampleExperiment exptNue2d(&predNue2d, mockNue2d); Spectrum mockNue2dsysts = preddunenue.Predict(calc).FakeData(pot); SingleSampleExperiment exptNue2dsysts(&preddunenue, mockNue2dsysts); Spectrum mockNue2dsystsrhc = preddunenuerhc.Predict(calc).FakeData(pot); SingleSampleExperiment exptNue2dsystsrhc(&preddunenuerhc, mockNue2dsystsrhc); Spectrum mockNue2di = predNue2d.Predict(calci).FakeData(pot); SingleSampleExperiment exptNue2di(&predNue2d, mockNue2di); Spectrum mockNue2disysts = preddunenue.Predict(calci).FakeData(pot); SingleSampleExperiment exptNue2disysts(&preddunenue, mockNue2disysts); Spectrum mockNue2disystsrhc = preddunenuerhc.Predict(calci).FakeData(pot); SingleSampleExperiment exptNue2disystsrhc(&preddunenuerhc, mockNue2disystsrhc); Spectrum mockNueRHC = predNueRHC.Predict(calc).FakeData(pot); SingleSampleExperiment exptNueRHC(&predNueRHC, mockNueRHC); Spectrum mockNuePID = predNuePID.Predict(calc).FakeData(pot); Spectrum mockNuePIDRHC = predNuePIDRHC.Predict(calc).FakeData(pot); Spectrum mockNumuPID = predNumuPID.Predict(calc).FakeData(pot); Spectrum mockNumuPIDRHC = predNumuPIDRHC.Predict(calc).FakeData(pot); Surface surf(&expt, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55); Surface surf2d(&expt2d, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55); Surface surf2dcheck(&expt2dsysts, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55); //should be same as previous line, let's check Surface surf2dsysts(&expt2dsysts, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55, {}, systsnorm); Surface surf2dsystsall(&expt2dsysts, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55, {}, systsall); Surface surfRHC(&exptRHC, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55); MultiExperiment numuall({&expt2dsysts, &expt2dsystsrhc}); Surface surfAll(&numuall, calc, &kFitSinSqTheta23, 20, .4, .6, &kFitDmSq32Scaled, 20, 2.35, 2.55, {}, systsall); MultiExperiment me({&expt, &exptNue, new SolarConstraints()}); MultiExperiment me2d({&expt2d, &exptNue2d, new SolarConstraints()}); MultiExperiment me2dsysts({&expt2dsysts, &exptNue2dsysts, new SolarConstraints()}); MultiExperiment me2di({&expt2di, &exptNue2di, new SolarConstraints()}); MultiExperiment me2disysts({&expt2disysts, &exptNue2disysts, new SolarConstraints()}); MultiExperiment meRHC({&exptRHC, &exptNueRHC, new SolarConstraints()}); MultiExperiment meAll({&exptNue2dsysts, &exptNue2dsystsrhc, &expt2dsysts, &expt2dsystsrhc, new SolarConstraints()}); Surface surfNue(&me, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6); Surface surfNue2d(&me2d, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6); Surface surfNue2dsysts(&me2dsysts, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6, {}, systsnorm); Surface surfNue2dsystsall(&me2dsysts, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6, {}, systsall); Surface surfNue2dsystsall2(&me2dsysts, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6, {}, systsall2); Surface surfNueRHC(&meRHC, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6); Surface surfNueAll(&meAll, calc, &kFitDeltaInPiUnits, 20, 0, 2, &kFitSinSqTheta23, 20, .4, .6, {}, systsall); new TCanvas; TH1* h3 = DataMCComparisonComponents(mock, &pred, calc); h3->SetTitle("#nu_{#mu} FHC selection (MVA>0.25) 3.5yrs #times 40kt"); CenterTitles(h3); Legend(); gPad->Print("components.pdf"); gPad->Print("components.C"); new TCanvas; TH1* h3r = DataMCComparisonComponents(mockRHC, &predRHC, calc); h3r->SetTitle("#nu_{#mu} RHC selection (MVA>0.5) 3.5yrs #times 40kt"); CenterTitles(h3); Legend(); gPad->Print("components_rhc.pdf"); gPad->Print("components_rhc.C"); new TCanvas; TH1* h4 = DataMCComparisonComponents(mockNue, &predNue, calc); h4->SetTitle("#nu_{e} FHC selection (MVA>0.8) 3.5yrs #times 40kt"); CenterTitles(h4); Legend(); gPad->Print("components_nue.pdf"); gPad->Print("components_nue.C"); new TCanvas; TH1* h4r = DataMCComparisonComponents(mockNueRHC, &predNueRHC, calc); h4r->SetTitle("#nu_{e} RHC selection (MVA>0.8) 3.5yrs #times 40kt"); CenterTitles(h4); Legend(); gPad->Print("components_nue_rhc.pdf"); gPad->Print("components_nue_rhc.C"); new TCanvas; TH1* h2 = DataMCComparisonComponents(mockNumuPID, &predNumuPID, calc); h2->SetTitle("#nu_{#mu} FHC 3.5yrs #times 40kt"); CenterTitles(h2); Legend(); h2->GetYaxis()->SetRangeUser(1, 1e4); gPad->SetLogy(); gPad->Print("components_pid.pdf"); gPad->Print("components_pid.C"); new TCanvas; TH1* h2d = DataMCComparisonComponents(mock2d, &pred2d, calc); h2d->SetTitle("#nu_{#mu} FHC 3.5yrs #times 40kt"); CenterTitles(h2); Legend(); h2->GetYaxis()->SetRangeUser(1, 1e4); gPad->SetLogy(); gPad->Print("components_pid_2d.pdf"); gPad->Print("components_pid_2d.C"); new TCanvas; TH1* h2r = DataMCComparisonComponents(mockNumuPIDRHC, &predNumuPIDRHC, calc); h2r->SetTitle("#nu_{#mu} RHC 3.5yrs #times 40kt"); CenterTitles(h2); Legend(); h2->GetYaxis()->SetRangeUser(1, 1e4); gPad->SetLogy(); gPad->Print("components_pid_rhc.pdf"); gPad->Print("components_pid_rhc.C"); new TCanvas; TH1* h = DataMCComparisonComponents(mockNuePID, &predNuePID, calc); h->SetTitle("#nu_{e} FHC 3.5yrs #times 40kt"); CenterTitles(h); Legend(); h->GetYaxis()->SetRangeUser(0, 600); gPad->Print("components_nue_pid.pdf"); gPad->Print("components_nue_pid.C"); new TCanvas; TH1* hd = DataMCComparisonComponents(mockNue2d, &predNue2d, calc); hd->SetTitle("#nu_{e} FHC 3.5yrs #times 40kt"); CenterTitles(h); Legend(); h->GetYaxis()->SetRangeUser(0, 600); gPad->Print("components_nue_pid_2d.pdf"); gPad->Print("components_nue_pid_2d.C"); new TCanvas; TH1* hr = DataMCComparisonComponents(mockNuePIDRHC, &predNuePIDRHC, calc); h->SetTitle("#nu_{e} RHC 3.5yrs #times 40kt"); CenterTitles(h); Legend(); h->GetYaxis()->SetRangeUser(0, 600); gPad->Print("components_nue_pid_rhc.pdf"); gPad->Print("components_nue_pid_rhc.C"); new TCanvas; surf.DrawContour(Gaussian90Percent2D(surf), kSolid, 4); // surfRHC.DrawContour(Gaussian90Percent2D(surfRHC), kSolid, kGreen+2); surf2d.DrawContour(Gaussian90Percent2D(surf2d), kSolid, 1); surf2dcheck.DrawContour(Gaussian90Percent2D(surf2d), kSolid, 1); // if there are 2 solid black lines there is a problem surf2dsysts.DrawContour(Gaussian90Percent2D(surf2dsysts), kSolid, kGreen+2); surf2dsystsall.DrawContour(Gaussian90Percent2D(surf2dsystsall), kSolid, 2); surf.DrawBestFit(kRed); surfAll.DrawContour(Gaussian90Percent2D(surfAll), 1, kMagenta); gPad->Print("cont.pdf"); new TCanvas; surfNue.DrawContour(Gaussian90Percent2D(surfNue), kSolid, 4); surfNue2d.DrawContour(Gaussian90Percent2D(surfNue2d), kSolid, 1); surfNue2dsysts.DrawContour(Gaussian90Percent2D(surfNue2dsysts), kSolid, kGreen+2); surfNue2dsystsall.DrawContour(Gaussian90Percent2D(surfNue2dsystsall), kSolid, 2); // surfNue2dsystsall2.DrawContour(Gaussian90Percent2D(surfNue2dsystsall2), kSolid, kMagenta); // just a check that a 50% NC syst is same as a 5% surfNueAll.DrawContour(Gaussian90Percent2D(surfNueAll), kSolid, kMagenta); surfNue.DrawBestFit(kRed); gPad->Print("cont_nue.pdf"); Spectrum testnom = preddunenumu.Predict(calc); Spectrum scaleshifted = preddunenumu.PredictSyst(calc,scaleshift); Spectrum resshifted = preddunenumu.PredictSyst(calc,resshift); new TCanvas; TH1* htestnom = testnom.ToTH1(pot); TH1* hscaleshifted = scaleshifted.ToTH1(pot); TH1* hresshifted = resshifted.ToTH1(pot); htestnom->SetLineWidth(2); hscaleshifted->SetLineWidth(2); hresshifted->SetLineWidth(2); hscaleshifted->SetLineColor(2); hresshifted->SetLineColor(4); htestnom->Draw(); hscaleshifted->Draw("same"); hresshifted->Draw("same"); gPad->Print("testsysts.pdf"); // yes things are really shifting, here we can see it happen new TCanvas; TH1* hnom2 = nom2.ToTH1(pot); TH1* hscale2 = scale2.ToTH1(pot); TH1* hres2 = res2.ToTH1(pot); hnom2->SetLineWidth(2); hscale2->SetLineWidth(2); hres2->SetLineWidth(2); hscale2->SetLineColor(2); hres2->SetLineColor(4); hnom2->Draw(); hscale2->Draw("same"); hres2->Draw("same"); gPad->Print("testsysts2.pdf"); // check shifts are happening in 2D variable also new TCanvas; // This is a very cheesy way to make the McD plot - would have to be very // different if we were varying any other parameters; leave in for now but don't trust this calc->SetdCP(0); Spectrum zeroNumu = pred.Predict(calc).FakeData(pot); Spectrum zeroNue = predNue.Predict(calc).FakeData(pot); Spectrum zeroNumu2d = pred2d.Predict(calc).FakeData(pot); Spectrum zeroNue2d = predNue2d.Predict(calc).FakeData(pot); Spectrum zeroNumuRHC = predRHC.Predict(calc).FakeData(pot); Spectrum zeroNueRHC = predNueRHC.Predict(calc).FakeData(pot); calc->SetdCP(TMath::Pi()); Spectrum oneNumu = pred.Predict(calc).FakeData(pot); Spectrum oneNue = predNue.Predict(calc).FakeData(pot); Spectrum oneNumu2d = pred2d.Predict(calc).FakeData(pot); Spectrum oneNue2d = predNue2d.Predict(calc).FakeData(pot); Spectrum oneNumuRHC = predRHC.Predict(calc).FakeData(pot); Spectrum oneNueRHC = predNueRHC.Predict(calc).FakeData(pot); TGraph* g = new TGraph; TGraph* g2d = new TGraph; TGraph* grhc = new TGraph; TGraph* gold = new TGraph; TGraph* gold2 = new TGraph; for(int i = -100; i <= 100; ++i){ calc->SetdCP(i/100.*TMath::Pi()); Spectrum mockNumu = pred.Predict(calc).FakeData(pot); Spectrum mockNue = predNue.Predict(calc).FakeData(pot); Spectrum mockNumu2d = pred2d.Predict(calc).FakeData(pot); Spectrum mockNue2d = predNue2d.Predict(calc).FakeData(pot); Spectrum mockNumuRHC = predRHC.Predict(calc).FakeData(pot); Spectrum mockNueRHC = predNueRHC.Predict(calc).FakeData(pot); const double llZero = LogLikelihood(zeroNumu.ToTH1(pot), mockNumu.ToTH1(pot))+ LogLikelihood(zeroNue.ToTH1(pot), mockNue.ToTH1(pot)); const double llOne = LogLikelihood(oneNumu.ToTH1(pot), mockNumu.ToTH1(pot))+ LogLikelihood(oneNue.ToTH1(pot), mockNue.ToTH1(pot)); const double llZero2d = LogLikelihood(zeroNumu2d.ToTH1(pot), mockNumu2d.ToTH1(pot))+ LogLikelihood(zeroNue2d.ToTH1(pot), mockNue2d.ToTH1(pot)); const double llOne2d = LogLikelihood(oneNumu2d.ToTH1(pot), mockNumu2d.ToTH1(pot))+ LogLikelihood(oneNue2d.ToTH1(pot), mockNue2d.ToTH1(pot)); const double llZeroRHC = LogLikelihood(zeroNumuRHC.ToTH1(pot), mockNumuRHC.ToTH1(pot))+LogLikelihood(zeroNumu.ToTH1(pot), mockNumu.ToTH1(pot))+ LogLikelihood(zeroNueRHC.ToTH1(pot), mockNueRHC.ToTH1(pot))+LogLikelihood(zeroNue.ToTH1(pot), mockNue.ToTH1(pot)); const double llOneRHC = LogLikelihood(oneNumuRHC.ToTH1(pot), mockNumuRHC.ToTH1(pot))+LogLikelihood(oneNumu.ToTH1(pot), mockNumu.ToTH1(pot))+ LogLikelihood(oneNueRHC.ToTH1(pot), mockNueRHC.ToTH1(pot))+LogLikelihood(oneNue.ToTH1(pot), mockNue.ToTH1(pot)); const double ll = std::min(llZero, llOne); const double ll2d = std::min(llZero2d, llOne2d); const double llrhc = std::min(llZeroRHC, llOneRHC); if(ll>0) g->SetPoint(g->GetN(), i/100., sqrt(ll)); if(ll2d>0) g2d->SetPoint(g2d->GetN(), i/100., sqrt(ll2d)); if(llrhc>0) grhc->SetPoint(grhc->GetN(), i/100., sqrt(llrhc)); } TH2* axes = new TH2F("", "3.5yrs #times 40kt, stats only;#delta / #pi;#sqrt{#chi^{2}}", 200, -1, +1, 50, 0, 8); CenterTitles(axes); axes->Draw(); g2d->SetLineWidth(2); g2d->SetLineColor(1); g2d->Draw("l same"); g->SetLineWidth(2); g->SetLineColor(4); g->Draw("l same"); grhc->SetLineWidth(2); grhc->SetLineColor(kMagenta); grhc->Draw("l same"); gPad->SetGridx(); gPad->SetGridy(); gPad->Print("mcd_hacky.pdf"); gPad->Print("mcd_hacky.C"); new TCanvas; // now try to make the plot right TH2* axes2 = new TH2F("", "3.5yrs #times 40kt, stats only;#delta / #pi;#sqrt{#chi^{2}}", 100, -1, +1, 50, 0, 8); TGraph* gr1d = new TGraph; // IH+NH, all systs, 1D (E only) TGraph* grfull = new TGraph; // IH+NH, all systs, 2D (ExPID) TGraph* gr2 = new TGraph; // IH+NH, norm systs only, 2D TGraph* gr3 = new TGraph; // FHC only, all systs, 2D, IH+NH TGraph* grstat = new TGraph; // FHC only, no systs, 2D, IH+NH TGraph* grnh = new TGraph; // NH only part of previous TGraph* grih = new TGraph; // IH only part // lots of possible combinations here: 2 hierarchies x 2 (FHC, RHC) x 2 expts (numu, nue) 2 x variables (1D, 2D) = 16, at 2 values of dCP = 32 // do dCP = 0 case calc->SetdCP(0); calci->SetdCP(0); Spectrum tempnumu = preddunenumu.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumu(&preddunenumu, tempnumu); Spectrum tempnue = preddunenue.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnue(&preddunenue, tempnue); Spectrum tempnumui = preddunenumu.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumui(&preddunenumu, tempnumu); Spectrum tempnuei = preddunenue.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnuei(&preddunenue, tempnue); Spectrum tempnumurhc = preddunenumurhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumurhc(&preddunenumurhc, tempnumurhc); Spectrum tempnuerhc = preddunenuerhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnuerhc(&preddunenuerhc, tempnuerhc); Spectrum tempnumuirhc = preddunenumurhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumuirhc(&preddunenumurhc, tempnumurhc); Spectrum tempnueirhc = preddunenuerhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnueirhc(&preddunenuerhc, tempnuerhc); Spectrum tempnumu1d = preddunenumu1d.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumu1d(&preddunenumu1d, tempnumu1d); Spectrum tempnue1d = preddunenue1d.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnue1d(&preddunenue1d, tempnue1d); Spectrum tempnumui1d = preddunenumu1d.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumui1d(&preddunenumu1d, tempnumu1d); Spectrum tempnuei1d = preddunenue1d.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnuei1d(&preddunenue1d, tempnue1d); Spectrum tempnumurhc1d = preddunenumu1drhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumurhc1d(&preddunenumu1drhc, tempnumurhc1d); Spectrum tempnuerhc1d = preddunenue1drhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnuerhc1d(&preddunenue1drhc, tempnuerhc1d); Spectrum tempnumuirhc1d = preddunenumu1drhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumuirhc1d(&preddunenumu1drhc, tempnumurhc1d); Spectrum tempnueirhc1d = preddunenue1drhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnueirhc1d(&preddunenue1drhc, tempnuerhc1d); MultiExperiment tempme({&expttempnumu, &expttempnue, new SolarConstraints()}); // FHC only NH numu+nue MultiExperiment tempmei({&expttempnumui, &expttempnuei, new SolarConstraints()}); // FHC only IH numu+nue MultiExperiment tempmefull({&expttempnumu, &expttempnue, &expttempnumurhc, &expttempnuerhc, new SolarConstraints()}); // nue+numu FHC+RHC NH 2D MultiExperiment tempmeifull({&expttempnumui, &expttempnuei, &expttempnumuirhc, &expttempnueirhc, new SolarConstraints()}); // nue+numu FHC+RHC IH 2D MultiExperiment tempmefull1d({&expttempnumu1d, &expttempnue1d, &expttempnumurhc1d, &expttempnuerhc1d, new SolarConstraints()}); // nue+numu FHC+RHC NH 1D MultiExperiment tempmeifull1d({&expttempnumui1d, &expttempnuei1d, &expttempnumuirhc1d, &expttempnueirhc1d, new SolarConstraints()}); // nue+numu FHC+RHC IH 1D // now dCP = PI case calc->SetdCP(TMath::Pi()); calci->SetdCP(TMath::Pi()); Spectrum tempnumu2 = preddunenumu.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumu2(&preddunenumu, tempnumu2); Spectrum tempnue2 = preddunenue.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnue2(&preddunenue, tempnue2); Spectrum tempnumui2 = preddunenumu.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumui2(&preddunenumu, tempnumu2); Spectrum tempnuei2 = preddunenue.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnuei2(&preddunenue, tempnue2); Spectrum tempnumurhc2 = preddunenumurhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumurhc2(&preddunenumurhc, tempnumurhc2); Spectrum tempnuerhc2 = preddunenuerhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnuerhc2(&preddunenuerhc, tempnuerhc2); Spectrum tempnumuirhc2 = preddunenumurhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumuirhc2(&preddunenumurhc, tempnumurhc2); Spectrum tempnueirhc2 = preddunenuerhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnueirhc2(&preddunenuerhc, tempnuerhc2); Spectrum tempnumu1d2 = preddunenumu1d.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumu1d2(&preddunenumu1d, tempnumu1d2); Spectrum tempnue1d2 = preddunenue1d.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnue1d2(&preddunenue1d, tempnue1d2); Spectrum tempnumui1d2 = preddunenumu1d.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumui1d2(&preddunenumu1d, tempnumu1d2); Spectrum tempnuei1d2 = preddunenue1d.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnuei1d2(&preddunenue1d, tempnue1d2); Spectrum tempnumurhc1d2 = preddunenumu1drhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnumurhc1d2(&preddunenumu1drhc, tempnumurhc1d2); Spectrum tempnuerhc1d2 = preddunenue1drhc.Predict(calc).FakeData(pot); SingleSampleExperiment expttempnuerhc1d2(&preddunenue1drhc, tempnuerhc1d2); Spectrum tempnumuirhc1d2 = preddunenumu1drhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnumuirhc1d2(&preddunenumu1drhc, tempnumurhc1d2); Spectrum tempnueirhc1d2 = preddunenue1drhc.Predict(calci).FakeData(pot); SingleSampleExperiment expttempnueirhc1d2(&preddunenue1drhc, tempnuerhc1d2); MultiExperiment tempme2({&expttempnumu2, &expttempnue2, new SolarConstraints()}); MultiExperiment tempmei2({&expttempnumui2, &expttempnuei2, new SolarConstraints()}); MultiExperiment tempmefull2({&expttempnumu2, &expttempnue2, &expttempnumurhc2, &expttempnuerhc2, new SolarConstraints()}); MultiExperiment tempmeifull2({&expttempnumui2, &expttempnuei2, &expttempnumuirhc2, &expttempnueirhc2, new SolarConstraints()}); MultiExperiment tempmefull1d2({&expttempnumu1d2, &expttempnue1d2, &expttempnumurhc1d2, &expttempnuerhc1d2, new SolarConstraints()}); MultiExperiment tempmeifull1d2({&expttempnumui1d2, &expttempnuei1d2, &expttempnumuirhc1d2, &expttempnueirhc1d2, new SolarConstraints()}); // now make fitters that will do actual fits // TODO make variable names intelligible // these allow Dmsq32, sinsqth23, sinsq2th13 to float, constrained only by the data itself // they also allow Dmsq21 and sinsq2th12 to float, constrained be external solar data (see CAFAna/Experiments/SolarConstraints.*) // dCP = 0 fits Fitter fit(&tempme, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsnorm); // FHC only, NH, norm systs only Fitter fit2(&tempme, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}); // FHC only, NH, no systs Fitter fit3(&tempme, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); // FHC only, NH, all systs Fitter fitfull(&tempmefull, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); // FHC+ RHC, NH, all systs Fitter fitfull1d(&tempmefull1d, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); // FHC+ RHC, NH, all systs, 1D SystShifts systsout = SystShifts::Nominal(); Fitter fiti(&tempmei, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsnorm); // same but IH now Fitter fit2i(&tempmei, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}); Fitter fit3i(&tempmei, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter fitfulli(&tempmeifull, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter fitfull1di(&tempmeifull1d, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); SystShifts systsouti = SystShifts::Nominal(); // dCP = PI fits Fitter xfit(&tempme2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsnorm); Fitter xfit2(&tempme2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}); Fitter xfit3(&tempme2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter xfitfull(&tempmefull2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter xfitfull1d(&tempmefull1d2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); SystShifts xsystsout = SystShifts::Nominal(); Fitter xfiti(&tempmei2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsnorm); Fitter xfit2i(&tempmei2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}); Fitter xfit3i(&tempmei2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter xfitfulli(&tempmeifull2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); Fitter xfitfull1di(&tempmeifull1d2, {&kFitDmSq32Scaled, &kFitSinSq2Theta23, &kFitSinSq2Theta13, &kFitSinSq2Theta12, &kFitDmSq21}, systsall); SystShifts xsystsouti = SystShifts::Nominal(); for(int i = -50; i <= 50; ++i){ // scan over dCP, create fake data at each dCP value, compare to dCP = 0 or PI cases, for each hierarchy calc->SetdCP(i/50.*TMath::Pi()); calci->SetdCP(i/50.*TMath::Pi()); std::cout << "Doing fits for dCP significance: " << i+50 << "%" << std::endl; // do the actual fits here, returns are chisq value of fits double throwaway = fit.Fit(calc, systsout, Fitter::kQuiet); // debugging some odd behavior double chisqout = fit.Fit(calc, systsout, Fitter::kQuiet); double chisqouti = fiti.Fit(calci, systsouti, Fitter::kQuiet); double chisqout2 = fit2.Fit(calc, systsout, Fitter::kQuiet); double chisqout2i = fit2i.Fit(calci, systsout, Fitter::kQuiet); double chisqout3 = fit3.Fit(calc, systsout, Fitter::kQuiet); double chisqout3i = fit3i.Fit(calci, systsouti, Fitter::kQuiet); double chisqoutfull = fitfull.Fit(calc, systsout, Fitter::kQuiet); double chisqoutfulli = fitfulli.Fit(calci, systsout, Fitter::kQuiet); double chisqoutfull1d = fitfull1d.Fit(calc, systsout, Fitter::kQuiet); double chisqoutfull1di = fitfull1di.Fit(calci, systsout, Fitter::kQuiet); double xthrowaway = xfit.Fit(calc, systsout, Fitter::kQuiet); double xchisqout = xfit.Fit(calc, systsout, Fitter::kQuiet); double xchisqouti = xfiti.Fit(calci, systsouti, Fitter::kQuiet); double xchisqout2 = xfit2.Fit(calc, systsout, Fitter::kQuiet); double xchisqout2i = xfit2i.Fit(calci, systsout, Fitter::kQuiet); double xchisqout3 = xfit3.Fit(calc, systsout, Fitter::kQuiet); double xchisqout3i = xfit3i.Fit(calci, systsouti, Fitter::kQuiet); double xchisqoutfull = xfitfull.Fit(calc, systsout, Fitter::kQuiet); double xchisqoutfulli = xfitfulli.Fit(calci, systsout, Fitter::kQuiet); double xchisqoutfull1d = xfitfull1d.Fit(calc, systsout, Fitter::kQuiet); double xchisqoutfull1di = xfitfull1di.Fit(calci, systsout, Fitter::kQuiet); // std::cout << " for dcp = " << i/50.*TMath::Pi() << " chisqs are: " << chisqout << " " << chisqouti << " " << sqrt(std::min(chisqout,chisqouti)) << std::endl; // debug // prevent possible errors if(chisqout < 0) chisqout = 0; if(chisqouti < 0) chisqouti = 0; if(chisqout2 < 0) chisqout = 0; if(chisqout2i < 0) chisqouti = 0; if(chisqout3 < 0) chisqout = 0; if(chisqout3i < 0) chisqouti = 0; if(chisqoutfull < 0) chisqoutfull = 0; if(chisqoutfulli < 0) chisqoutfulli = 0; if(chisqoutfull1d < 0) chisqoutfull1d = 0; if(chisqoutfull1di < 0) chisqoutfull1di = 0; if(xchisqout < 0) xchisqout = 0; if(xchisqouti < 0) xchisqouti = 0; if(xchisqout2 < 0) xchisqout = 0; if(xchisqout2i < 0) xchisqouti = 0; if(xchisqout3 < 0) xchisqout = 0; if(xchisqout3i < 0) xchisqouti = 0; if(xchisqoutfull < 0) xchisqoutfull = 0; if(xchisqoutfulli < 0) xchisqoutfulli = 0; if(xchisqoutfull1d < 0) xchisqoutfull1d = 0; if(xchisqoutfull1di < 0) xchisqoutfull1di = 0; //chisq for each point is minimum chisq of fit comparing to dCP = 0, PI, for either hierarchy gr2->SetPoint(gr2->GetN(), i/50., sqrt(std::min( std::min(chisqout,chisqouti), std::min(xchisqout,xchisqouti) ))); gr3->SetPoint(gr3->GetN(), i/50., sqrt(std::min(std::min(chisqout3,chisqout3i),std::min(xchisqout3,xchisqout3i)))); grnh->SetPoint(grnh->GetN(), i/50., sqrt(std::min(chisqout2,xchisqout2))); grih->SetPoint(grih->GetN(), i/50., sqrt(std::min(chisqout2i,xchisqout2i))); grstat->SetPoint(grstat->GetN(), i/50., sqrt(std::min(std::min(chisqout2i,chisqout2),std::min(xchisqout2i,xchisqout2)))); grfull->SetPoint(grfull->GetN(), i/50., sqrt(std::min(std::min(chisqoutfulli,chisqoutfull),std::min(xchisqoutfulli,xchisqoutfull)))); gr1d->SetPoint(gr1d->GetN(), i/50., sqrt(std::min(std::min(chisqoutfull1di,chisqoutfull1d),std::min(xchisqoutfull1di,xchisqoutfull1d)))); } axes2->Draw(); grfull->SetLineWidth(2); grfull->SetLineColor(2); grfull->Draw("l same"); gr1d->SetLineWidth(2); gr1d->SetLineColor(4); gr1d->Draw("l same"); gr2->SetLineWidth(2); gr2->SetLineColor(4); // gr2->Draw("l same"); gr3->SetLineWidth(2); gr3->SetLineColor(kGreen+2); gr3->Draw("l same"); grnh->SetLineWidth(2); grnh->SetLineColor(1); // grnh->Draw("l same"); grih->SetLineWidth(2); grih->SetLineColor(2); // grih->Draw("l same"); grstat->SetLineWidth(2); grstat->SetLineColor(1); grstat->Draw("l same"); gPad->SetGridx(); gPad->SetGridy(); gPad->Print("mcd.pdf"); gPad->Print("mcd.C"); }