00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00075
00076 #include "Minuit2/ContoursError.h"
00077 #include "Minuit2/MnContours.h"
00078 #include "Minuit2/MnMigrad.h"
00079 #include "Minuit2/MnPlot.h"
00080 #include "Minuit2/MnUserParameters.h"
00081 #include "Minuit2/FunctionMinimum.h"
00082 #include "TFile.h"
00083 #include "TFitterMinuit.h"
00084 #include "TGraph.h"
00085 #include "TGraph2DErrors.h"
00086 #include "TH1D.h"
00087 #include "TH2D.h"
00088 #include "TMath.h"
00089 #include "TMinuit.h"
00090
00091 #include "MessageService/MsgService.h"
00092 #include "NtupleUtils/NuSystematic.h"
00093 #include "NtupleUtils/NuTreeWrapper.h"
00094 #include "NtupleUtils/NuXFitAnalysis.h"
00095 #include "NtupleUtils/NuXMLConfig.h"
00096
00097 ClassImp(NuXFitAnalysis)
00098
00099 CVSID("$Id: NuXFitAnalysis.cxx,v 1.13 2008/05/02 19:39:22 evans Exp $");
00100
00101 using namespace NuXSecFit;
00102 using namespace ROOT::Minuit2;
00103
00104 using std::string;
00105 using std::vector;
00106
00107
00108 NuXFitAnalysis::NuXFitAnalysis()
00109 : fdoGridSearch(false),
00110 fwriteOutput(true),
00111 fUp(1.0),
00112 ffdDataPoT(0.0),
00113 ffdMCPoT(0.0),
00114 fdm2(0.0),
00115 fsn2(0.0),
00116 fBestDm2(-1.0),
00117 fBestSn2(-1.0),
00118 fBestDm2Bar(-1.0),
00119 fBestSn2Bar(-1.0)
00120 {
00121 fanalysisSetting = NuXFit::kUnknown;
00122 fanaVersion = NuCuts::kJJE1;
00123 fnuSystematic = new NuSystematic();
00124
00125 fSelEffFileName = "";
00126 fxsecfilename = "";
00127
00128 fOutputFile = 0;
00129
00130 ftFDDataTree = 0;
00131 ftFDMCTree = 0;
00132
00133 fhNuBarCCSelectionEfficiency = 0;
00134 fhNuMuCCSelectionEfficiency = 0;
00135 fNuBarCCCrossSectionGraph = 0;
00136 fNuMuCCCrossSectionGraph = 0;
00137 fhNuBarCCCrossSections = 0;
00138 fhNuMuCCCrossSections = 0;
00139
00140 fhFDNuMuCCDataFromFile = 0;
00141 fhFDNuMuBarCCDataFromFile = 0;
00142
00143 fhFDDataRecoENuMuCC = 0;
00144 fhFDDataRecoENuMuBarCC = 0;
00145 fhFDMCRecoENuMuCC = 0;
00146 fhFDMCRecoENuMuBarCC = 0;
00147
00148 fFitter = new TFitterMinuit();
00149 fFitter->CreateMinimizer();
00150 fFitter->SetMinuitFCN(this);
00151 }
00152
00153
00154 NuXFitAnalysis::NuXFitAnalysis(const NuXMLConfig& xmlConfig)
00155 : fdoGridSearch(false),
00156 fUp(1.0),
00157 ffdDataPoT(0.0),
00158 ffdMCPoT(0.0),
00159 fdm2(0.0),
00160 fsn2(0.0)
00161 {
00162 fanalysisSetting = NuXFit::kUnknown;
00163 fanaVersion = NuCuts::kJJE1;
00164 fnuSystematic = new NuSystematic(xmlConfig);
00165
00166 fSelEffFileName = "";
00167 fxsecfilename = "";
00168
00169 fOutputFile = 0;
00170
00171 ftFDDataTree = 0;
00172 ftFDMCTree = 0;
00173
00174 fhNuBarCCSelectionEfficiency = 0;
00175 fhNuMuCCSelectionEfficiency = 0;
00176 fNuBarCCCrossSectionGraph = 0;
00177 fNuMuCCCrossSectionGraph = 0;
00178 fhNuBarCCCrossSections = 0;
00179 fhNuMuCCCrossSections = 0;
00180
00181 fhFDNuMuCCDataFromFile = 0;
00182 fhFDNuMuBarCCDataFromFile = 0;
00183
00184 fhFDDataRecoENuMuCC = 0;
00185 fhFDDataRecoENuMuBarCC = 0;
00186 fhFDMCRecoENuMuCC = 0;
00187 fhFDMCRecoENuMuBarCC = 0;
00188
00189 fFitter = new TFitterMinuit();
00190 fFitter->CreateMinimizer();
00191 fFitter->SetMinuitFCN(this);
00192 }
00193
00194
00195
00196 NuXFitAnalysis::~NuXFitAnalysis()
00197 {
00198 if (fOutputFile){
00199 fOutputFile->Close();
00200 delete fOutputFile;
00201 fOutputFile = 0;
00202 }
00203
00204 if (fnuSystematic){delete fnuSystematic; fnuSystematic = 0;}
00205
00206 if (fhFDNuMuCCDataFromFile){
00207 delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00208 }
00209 if (fhFDNuMuBarCCDataFromFile){
00210 delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00211 }
00212 }
00213
00214
00215 double NuXFitAnalysis
00216 ::operator () (const vector<double>& pars) const
00217 {
00218 static Int_t fitcounter = 0;
00219 if (!(fitcounter%50)){
00220 cout << "Minuit FD XFit call " << fitcounter << endl;
00221 }
00222 ++fitcounter;
00223 if (NuXFit::kCPT == fanalysisSetting){
00224 this->FillCPTFDPrediction(pars);
00225 }
00226 else if(NuXFit::kTransition == fanalysisSetting){
00227 this->FillTransitionFDPrediction(pars);
00228 }
00229 else{
00230 MSG("NuXFitAnalysis.cxx",Msg::kFatal)
00231 << "Incorrect analysis setting" << endl;
00232 return -1.0;
00233 }
00234 return this->CalculateLikelihood();
00235 }
00236
00237
00238 const Double_t NuXFitAnalysis::CalculateLikelihood(const TH1D* fdPred,
00239 const TH1D* fdData)
00240 const
00241 {
00242
00243
00244 Double_t like = 0;
00245
00246 for (Int_t i=1; i<=fdPred->GetNbinsX(); ++i){
00247
00248 Double_t mnu = fdPred->GetBinContent(i);
00249 Double_t dnu = fdData->GetBinContent(i);
00250 if (mnu<0.0001){mnu = 0.0001;}
00251 if (dnu){
00252 like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00253 }
00254 else{like += 2*(mnu - dnu);}
00255 }
00256
00257 return like;
00258 }
00259
00260
00261 const Double_t NuXFitAnalysis::CalculateLikelihood() const
00262 {
00263
00264
00265 Double_t like = 0;
00266
00267 for (Int_t i=1; i<=fhFDMCRecoENuMuCC->GetNbinsX(); ++i){
00268
00269 Double_t mnu = fhFDMCRecoENuMuCC->GetBinContent(i);
00270 Double_t dnu = fhFDDataRecoENuMuCC->GetBinContent(i);
00271 if (mnu<0.0001){mnu = 0.0001;}
00272 if (dnu){
00273 like += 2*(mnu - dnu + dnu*log(dnu/mnu));
00274 }
00275 else{like += 2*(mnu - dnu);}
00276 }
00277
00278 for (Int_t i=1; i<=fhFDMCRecoENuMuBarCC->GetNbinsX(); ++i){
00279 Double_t mbar = fhFDMCRecoENuMuBarCC->GetBinContent(i);
00280 Double_t dbar = fhFDDataRecoENuMuBarCC->GetBinContent(i);
00281 if (mbar<0.0001){mbar = 0.0001;}
00282 if (dbar){
00283 like += 2*(mbar - dbar + dbar*log(dbar/mbar));
00284 }
00285 else{like += 2*(mbar - dbar);}
00286 }
00287
00288 return like;
00289 }
00290
00291
00292 void NuXFitAnalysis::OutputFileName(const string outFile)
00293 {
00294 if (fOutputFile){
00295 fOutputFile->Close();
00296 delete fOutputFile;
00297 fOutputFile = 0;
00298 }
00299 fOutputFile = new TFile(outFile.c_str(),"RECREATE");
00300 }
00301
00302
00303 const Bool_t NuXFitAnalysis::CreateFDNuMuBarCCDataHisto()
00304 {
00305 if (fhFDDataRecoENuMuBarCC) {
00306 delete fhFDDataRecoENuMuBarCC; fhFDDataRecoENuMuBarCC = 0;
00307 }
00308
00309 if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00310 fhFDDataRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00311 fhFDDataRecoENuMuBarCC->Reset();
00312 return true;
00313 }
00314
00315 Int_t size = fvFDRecoENuMuBarCCBins.size();
00316 if (!size){
00317 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00318 << "FD reconstructed energy binning not supplied."
00319 << endl;
00320 return false;
00321 }
00322
00323 Double_t* recoEBinEdges = new Double_t[size];
00324
00325 Int_t i=0;
00326 for (vector<Double_t>::const_iterator it =
00327 fvFDRecoENuMuBarCCBins.begin();
00328 it != fvFDRecoENuMuBarCCBins.end();
00329 ++it, ++i){
00330 recoEBinEdges[i] = *it;
00331 }
00332
00333 fhFDDataRecoENuMuBarCC = new TH1D("fhFDDataRecoENuMuBarCC",
00334 "FD NuMuBar CC data",
00335 size-1,
00336 recoEBinEdges);
00337
00338 if (!fhFDDataRecoENuMuBarCC) return false;
00339 return true;
00340 }
00341
00342
00343 const Bool_t NuXFitAnalysis::CreateFDNuMuCCDataHisto()
00344 {
00345 if (fhFDDataRecoENuMuCC) {
00346 delete fhFDDataRecoENuMuCC; fhFDDataRecoENuMuCC = 0;
00347 }
00348
00349 if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00350 fhFDDataRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00351 fhFDDataRecoENuMuCC->Reset();
00352 return true;
00353 }
00354
00355 Int_t size = fvFDRecoENuMuCCBins.size();
00356 if (!size){
00357 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00358 << "FD reconstructed energy binning not supplied."
00359 << endl;
00360 return false;
00361 }
00362
00363 Double_t* recoEBinEdges = new Double_t[size];
00364
00365 Int_t i=0;
00366 for (vector<Double_t>::const_iterator it =
00367 fvFDRecoENuMuCCBins.begin();
00368 it != fvFDRecoENuMuCCBins.end();
00369 ++it, ++i){
00370 recoEBinEdges[i] = *it;
00371 }
00372
00373 fhFDDataRecoENuMuCC = new TH1D("fhFDDataRecoENuMuCC",
00374 "FD NuMu CC data",
00375 size-1,
00376 recoEBinEdges);
00377
00378 if (!fhFDDataRecoENuMuCC) return false;
00379 return true;
00380 }
00381
00382
00383 const Bool_t NuXFitAnalysis::CreateFDNuMuBarCCMCHisto()
00384 {
00385 if (fhFDMCRecoENuMuBarCC) {
00386 delete fhFDMCRecoENuMuBarCC; fhFDMCRecoENuMuBarCC = 0;
00387 }
00388
00389 if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00390 fhFDMCRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
00391 fhFDMCRecoENuMuBarCC->Reset();
00392 return true;
00393 }
00394
00395 Int_t size = fvFDRecoENuMuBarCCBins.size();
00396 if (!size){
00397 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00398 << "FD reconstructed energy binning not supplied."
00399 << endl;
00400 return false;
00401 }
00402
00403 Double_t* recoEBinEdges = new Double_t[size];
00404
00405 Int_t i=0;
00406 for (vector<Double_t>::const_iterator it =
00407 fvFDRecoENuMuBarCCBins.begin();
00408 it != fvFDRecoENuMuBarCCBins.end();
00409 ++it, ++i){
00410 recoEBinEdges[i] = *it;
00411 }
00412
00413 fhFDMCRecoENuMuBarCC = new TH1D("fhFDMCRecoENuMuBarCC",
00414 "FD NuMuBar CC prediction",
00415 size-1,
00416 recoEBinEdges);
00417
00418 if (!fhFDMCRecoENuMuBarCC) return false;
00419 return true;
00420 }
00421
00422
00423 const Bool_t NuXFitAnalysis::CreateFDNuMuCCMCHisto()
00424 {
00425 if (fhFDMCRecoENuMuCC) {
00426 delete fhFDMCRecoENuMuCC; fhFDMCRecoENuMuCC = 0;
00427 }
00428
00429 if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
00430 fhFDMCRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
00431 fhFDMCRecoENuMuCC->Reset();
00432 return true;
00433 }
00434
00435 Int_t size = fvFDRecoENuMuCCBins.size();
00436 if (!size){
00437 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
00438 << "FD reconstructed energy binning not supplied."
00439 << endl;
00440 return false;
00441 }
00442
00443 Double_t* recoEBinEdges = new Double_t[size];
00444
00445 Int_t i=0;
00446 for (vector<Double_t>::const_iterator it =
00447 fvFDRecoENuMuCCBins.begin();
00448 it != fvFDRecoENuMuCCBins.end();
00449 ++it, ++i){
00450 recoEBinEdges[i] = *it;
00451 }
00452
00453 fhFDMCRecoENuMuCC = new TH1D("fhFDMCRecoENuMuCC",
00454 "FD NuMu CC prediction",
00455 size-1,
00456 recoEBinEdges);
00457
00458 if (!fhFDMCRecoENuMuCC) return false;
00459 return true;
00460 }
00461
00462
00463 void NuXFitAnalysis::FillCPTFDPrediction
00464 (const vector<double>& par) const
00465 {
00466
00467 fhFDMCRecoENuMuCC->Reset();
00468 fhFDMCRecoENuMuBarCC->Reset();
00469
00470 Double_t shwEShift=1.0;
00471 Double_t trkEShift = 1.0;
00472
00473 Double_t Dm2 = par[0];
00474 Double_t Sn2 = par[1];
00475 Double_t Dm2Bar = par[2];
00476 Double_t Sn2Bar = par[3];
00477
00478
00479 for (vector<NuEvent>::const_iterator itBar
00480 = fvFDMCCCNuMuBarEvents.begin();
00481 itBar!=fvFDMCCCNuMuBarEvents.end();
00482 ++itBar){
00483 NuEvent barEvent = *itBar;
00484 Int_t truthpar = this->TruthIndex(barEvent);
00485 Double_t barweight = 1.0;
00486 barweight *= barEvent.rw;
00487 if (truthpar>=0){
00488 barweight *= fvNDFitPars[truthpar];
00489 }
00490 Double_t thisSn2 = 0.0;
00491 Double_t thisDm2 = 0.0;
00492 if (1==barEvent.iaction){
00493 if (-14==barEvent.inu){
00494 thisSn2 = Sn2Bar;
00495 thisDm2 = Dm2Bar;
00496 }
00497 if (14==barEvent.inu){
00498 thisSn2 = Sn2;
00499 thisDm2 = Dm2;
00500 }
00501 }
00502 Double_t oscweightbar = 1.0-thisSn2*
00503 TMath::Sin(1.27*thisDm2*735.0/barEvent.neuEnMC)*
00504 TMath::Sin(1.27*thisDm2*735.0/barEvent.neuEnMC);
00505 barweight *= oscweightbar;
00506 Double_t recoNuE = shwEShift*(barEvent.shwEn)
00507 + trkEShift*(barEvent.trkEn);
00508 fhFDMCRecoENuMuBarCC->Fill(recoNuE,barweight);
00509 }
00510 if (ffdMCPoT){fhFDMCRecoENuMuBarCC->Scale(ffdDataPoT/ffdMCPoT);}
00511
00512
00513 for (vector<NuEvent>::const_iterator itNu
00514 = fvFDMCCCNuMuEvents.begin();
00515 itNu!=fvFDMCCCNuMuEvents.end();
00516 ++itNu){
00517 NuEvent nuEvent = *itNu;
00518 Int_t truthpar = this->TruthIndex(nuEvent);
00519 Double_t nuweight = 1.0;
00520 nuweight *= nuEvent.rw;
00521 if (truthpar>=0){
00522 nuweight *= fvNDFitPars[truthpar];
00523 }
00524 Double_t thisSn2 = 0.0;
00525 Double_t thisDm2 = 0.0;
00526 if (1==nuEvent.iaction){
00527 if (-14==nuEvent.inu){
00528 thisSn2 = Sn2Bar;
00529 thisDm2 = Dm2Bar;
00530 }
00531 if (14==nuEvent.inu){
00532 thisSn2 = Sn2;
00533 thisDm2 = Dm2;
00534 }
00535 }
00536 Double_t oscweight = 1.0-thisSn2*
00537 TMath::Sin(1.27*thisDm2*735.0/nuEvent.neuEnMC)*
00538 TMath::Sin(1.27*thisDm2*735.0/nuEvent.neuEnMC);
00539 nuweight *= oscweight;
00540 Double_t recoNuE = shwEShift*(nuEvent.shwEn)
00541 + trkEShift*(nuEvent.trkEn);
00542 fhFDMCRecoENuMuCC->Fill(recoNuE,nuweight);
00543 }
00544 if (ffdMCPoT){fhFDMCRecoENuMuCC->Scale(ffdDataPoT/ffdMCPoT);}
00545 }
00546
00547
00548 void NuXFitAnalysis::FillTransitionFDPrediction
00549 (const vector<double>& par) const
00550 {
00551
00552 fhFDMCRecoENuMuCC->Reset();
00553 fhFDMCRecoENuMuBarCC->Reset();
00554
00555 Double_t shwEShift=1.0;
00556 Double_t trkEShift = 1.0;
00557
00558 Double_t Dm2 = fdm2;
00559 Double_t Sn2 = fsn2;
00560 Double_t Dm2Bar = fdm2;
00561 Double_t Sn2Bar = fsn2;
00562 Double_t transitionProb = par[0];
00563
00564
00565 for (vector<NuEvent>::const_iterator itBar
00566 = fvFDMCCCNuMuBarEvents.begin();
00567 itBar!=fvFDMCCCNuMuBarEvents.end();
00568 ++itBar){
00569 NuEvent barEvent = *itBar;
00570 Int_t truthpar = this->TruthIndex(barEvent);
00571 Double_t barweight = 1.0;
00572 barweight *= barEvent.rw;
00573 if (truthpar>=0){
00574 barweight *= fvNDFitPars[truthpar];
00575 }
00576 Double_t thisSn2 = 0.0;
00577 Double_t thisDm2 = 0.0;
00578 if (1==barEvent.iaction){
00579 if (-14==barEvent.inu){
00580 thisSn2 = Sn2Bar;
00581 thisDm2 = Dm2Bar;
00582 }
00583 if (14==barEvent.inu){
00584 thisSn2 = Sn2;
00585 thisDm2 = Dm2;
00586 }
00587 }
00588 Double_t oscweightbar = 1.0-thisSn2*
00589 TMath::Sin(1.27*thisDm2*735.0/barEvent.neuEnMC)*
00590 TMath::Sin(1.27*thisDm2*735.0/barEvent.neuEnMC);
00591 Double_t transitionWeight = barweight;
00592 barweight *= oscweightbar;
00593 Double_t recoNuE = shwEShift*(barEvent.shwEn)
00594 + trkEShift*(barEvent.trkEn);
00595 Double_t trueNuE = barEvent.neuEnMC;
00596 fhFDMCRecoENuMuBarCC->Fill(recoNuE,barweight);
00597 if (1==barEvent.iaction){
00598 if (-14==barEvent.inu){
00599 transitionWeight *= 1.0-oscweightbar;
00600 transitionWeight *= transitionProb;
00601 Double_t nuBarSelEff = this->NuBarCCSelectionEfficiency(trueNuE);
00602 Double_t nuBarXSec = this->NuBarCCCrossSection(trueNuE);
00603 if (nuBarSelEff && nuBarXSec){
00604 transitionWeight /= nuBarSelEff;
00605 transitionWeight /= nuBarXSec;
00606 }
00607 transitionWeight *= this->NuMuCCSelectionEfficiency(trueNuE);
00608 transitionWeight *= this->NuMuCCCrossSection(trueNuE);
00609 fhFDMCRecoENuMuCC->Fill(recoNuE,transitionWeight);
00610 }
00611 }
00612 }
00613 if (ffdMCPoT){fhFDMCRecoENuMuBarCC->Scale(ffdDataPoT/ffdMCPoT);}
00614
00615
00616 for (vector<NuEvent>::const_iterator itNu
00617 = fvFDMCCCNuMuEvents.begin();
00618 itNu!=fvFDMCCCNuMuEvents.end();
00619 ++itNu){
00620 NuEvent nuEvent = *itNu;
00621 Int_t truthpar = this->TruthIndex(nuEvent);
00622 Double_t nuweight = 1.0;
00623 nuweight *= nuEvent.rw;
00624 if (truthpar>=0){
00625 nuweight *= fvNDFitPars[truthpar];
00626 }
00627 Double_t thisSn2 = 0.0;
00628 Double_t thisDm2 = 0.0;
00629 if (1==nuEvent.iaction){
00630 if (-14==nuEvent.inu){
00631 thisSn2 = Sn2Bar;
00632 thisDm2 = Dm2Bar;
00633 }
00634 if (14==nuEvent.inu){
00635 thisSn2 = Sn2;
00636 thisDm2 = Dm2;
00637 }
00638 }
00639 Double_t oscweight = 1.0-thisSn2*
00640 TMath::Sin(1.27*thisDm2*735.0/nuEvent.neuEnMC)*
00641 TMath::Sin(1.27*thisDm2*735.0/nuEvent.neuEnMC);
00642 Double_t transitionWeight = nuweight;
00643 nuweight *= oscweight;
00644 Double_t recoNuE = shwEShift*(nuEvent.shwEn)
00645 + trkEShift*(nuEvent.trkEn);
00646 Double_t trueNuE = nuEvent.neuEnMC;
00647 fhFDMCRecoENuMuCC->Fill(recoNuE,nuweight);
00648 if (1==nuEvent.iaction){
00649 if (14==nuEvent.inu){
00650 transitionWeight *= 1.0-oscweight;
00651 transitionWeight *= transitionProb;
00652 transitionWeight *= this->NuBarCCSelectionEfficiency(trueNuE);
00653 transitionWeight *= this->NuBarCCCrossSection(trueNuE);
00654 Double_t nuMuSelEff = this->NuMuCCSelectionEfficiency(trueNuE);
00655 Double_t nuMuXSec = this->NuMuCCCrossSection(trueNuE);
00656 if (nuMuSelEff && nuMuXSec){
00657 transitionWeight /= nuMuSelEff;
00658 transitionWeight /= nuMuXSec;
00659 }
00660 fhFDMCRecoENuMuBarCC->Fill(recoNuE,transitionWeight);
00661 }
00662 }
00663 }
00664 if (ffdMCPoT){fhFDMCRecoENuMuCC->Scale(ffdDataPoT/ffdMCPoT);}
00665 }
00666
00667
00668 const Double_t NuXFitAnalysis
00669 ::NuBarCCCrossSection(const Double_t trueNuE) const
00670 {
00671
00672 return fhNuBarCCCrossSections->
00673 GetBinContent(fhNuBarCCCrossSections->FindBin(trueNuE));
00674 }
00675
00676
00677 const Double_t NuXFitAnalysis
00678 ::NuBarCCSelectionEfficiency(const Double_t trueNuE) const
00679 {
00680 return fhNuBarCCSelectionEfficiency->
00681 GetBinContent(fhNuBarCCSelectionEfficiency->FindBin(trueNuE));
00682 }
00683
00684
00685 const Double_t NuXFitAnalysis
00686 ::NuMuCCCrossSection(const Double_t trueNuE) const
00687 {
00688
00689 return fhNuMuCCCrossSections->
00690 GetBinContent(fhNuMuCCCrossSections->FindBin(trueNuE));
00691 }
00692
00693
00694 const Double_t NuXFitAnalysis
00695 ::NuMuCCSelectionEfficiency(const Double_t trueNuE) const
00696 {
00697 return fhNuMuCCSelectionEfficiency->
00698 GetBinContent(fhNuMuCCSelectionEfficiency->FindBin(trueNuE));
00699 }
00700
00701
00702 const Int_t NuXFitAnalysis::TruthIndex(const NuEvent& info) const
00703 {
00704 Int_t numnubins = fvTrueEBinsNuMuCC.size();
00705 Int_t numbarbins = fvTrueEBinsNuMuBarCC.size();
00706
00707 Int_t type = info.inu;
00708 const vector<Double_t>* truthbins;
00709 Int_t offset = 0;
00710 Int_t numbins = 0;
00711 if (14 == type){
00712 truthbins = &fvTrueEBinsNuMuCC;
00713 numbins = numnubins;
00714 offset = 0;
00715 }
00716 else if (-14 == type){
00717 truthbins = &fvTrueEBinsNuMuBarCC;
00718 numbins = numbarbins;
00719 offset = numnubins;
00720 }
00721 else{
00722 return numnubins + numbarbins;
00723 }
00724 for (Int_t i=1; i<numbins; ++i){
00725 if ((*truthbins)[i]>info.neuEnMC){
00726 return i - 1 + offset;
00727 }
00728 }
00729 if ((14 == type) || (-14 == type)){
00730 return (numbins + offset);
00731 }
00732 return numnubins + numbarbins;
00733 }
00734
00735
00736 void NuXFitAnalysis::FDData(const string fdDataFileName)
00737 {
00738 if (ftFDDataTree){delete ftFDDataTree; ftFDDataTree = 0;}
00739 ftFDDataTree = new NuTreeWrapper(fdDataFileName);
00740
00741
00742 ffdDataPoT = ftFDDataTree->GetPoT();
00743
00744 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
00745 << "fdDataPoT: " << ffdDataPoT
00746 << endl;
00747 }
00748
00749
00750 void NuXFitAnalysis::FDNuMuBarCCData(const TH1D& fdData)
00751 {
00752 if (fhFDNuMuBarCCDataFromFile){
00753 delete fhFDNuMuBarCCDataFromFile; fhFDNuMuBarCCDataFromFile = 0;
00754 }
00755 fhFDNuMuBarCCDataFromFile = new TH1D(fdData);
00756 fhFDNuMuBarCCDataFromFile->SetDirectory(0);
00757 }
00758
00759
00760 void NuXFitAnalysis::FDNuMuCCData(const TH1D& fdData)
00761 {
00762 if (fhFDNuMuCCDataFromFile){
00763 delete fhFDNuMuCCDataFromFile; fhFDNuMuCCDataFromFile = 0;
00764 }
00765 fhFDNuMuCCDataFromFile = new TH1D(fdData);
00766 fhFDNuMuCCDataFromFile->SetDirectory(0);
00767 }
00768
00769
00770 void NuXFitAnalysis::FDMC(const string fdMCFileName)
00771 {
00772 if (ftFDMCTree){delete ftFDMCTree; ftFDMCTree = 0;}
00773 ftFDMCTree = new NuTreeWrapper(fdMCFileName);
00774
00775
00776 ffdMCPoT = ftFDMCTree->GetPoT();
00777
00778 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
00779 << "fdMCPoT: " << ffdMCPoT
00780 << endl;
00781 }
00782
00783
00784 const Bool_t NuXFitAnalysis::CreateHistograms()
00785 {
00786 Bool_t goodConfig = true;
00787 if (!this->CreateFDNuMuCCDataHisto()) goodConfig = false;
00788 if (!this->CreateFDNuMuBarCCDataHisto()) goodConfig = false;
00789 if (!this->CreateFDNuMuCCMCHisto()) goodConfig = false;
00790 if (!this->CreateFDNuMuBarCCMCHisto()) goodConfig = false;
00791 return goodConfig;
00792 }
00793
00794
00795 void NuXFitAnalysis::ConfigureForExternalFit
00796 (const NuXFit::NuXAnalysis_t analSetting)
00797 {
00798 fanalysisSetting = analSetting;
00799 this->CreateHistograms();
00800 this->FillFDDataHistograms();
00801 this->CacheFDMCEvents();
00802
00803 this->SetupPars();
00804 }
00805
00806
00807 void NuXFitAnalysis::CPTAnalysis()
00808 {
00809 fanalysisSetting = NuXFit::kCPT;
00810
00811 if (!this->CreateHistograms()){return;}
00812 if (!this->FillFDDataHistograms()){return;}
00813 if (!this->CacheFDMCEvents()){return;}
00814
00815 if (!fdoGridSearch){
00816 this->SetupPars();
00817
00818 fFitter->FixParameter(0);
00819 fFitter->FixParameter(1);
00820
00821 fFitter->Minimize();
00822 fFitter->PrintResults(0,0);
00823
00824 fBestDm2 = fFitter->GetParameter(0);
00825 fBestSn2 = fFitter->GetParameter(1);
00826 fBestDm2Bar = fFitter->GetParameter(2);
00827 fBestSn2Bar = fFitter->GetParameter(3);
00828 }
00829
00830 if (fdoGridSearch){
00831 Double_t bestChi2 = 1.0e10;
00832 Double_t bestsn2bar = 0.0;
00833 Double_t bestdm2bar = 0.0;
00834
00835 Double_t sn2BarLow = 0.8;
00836 Double_t sn2BarHigh = 1.0;
00837 Double_t sn2BarGranularity = 0.001;
00838 Double_t dm2BarLow = 1.0e-3;
00839 Double_t dm2BarHigh = 4.0e-3;
00840 Double_t dm2BarGranularity = 0.005e-3;
00841
00842
00843 Int_t numSn2BarBins = (Int_t) round((sn2BarHigh-sn2BarLow)/sn2BarGranularity) + 1;
00844 Int_t numDm2BarBins = (Int_t) round((dm2BarHigh-dm2BarLow)/dm2BarGranularity) + 1;
00845 TH2D hChi2Bar("hChi2Bar",
00846 "",
00847 numSn2BarBins,
00848 sn2BarLow-sn2BarGranularity/2.0,
00849 sn2BarHigh+sn2BarGranularity/2.0,
00850 numDm2BarBins,
00851 dm2BarLow-dm2BarGranularity/2.0,
00852 dm2BarHigh+dm2BarGranularity/2.0);
00853
00854 for (Double_t sn2bar = sn2BarLow;
00855 sn2bar <= sn2BarHigh+sn2BarGranularity/2.0;
00856 sn2bar += sn2BarGranularity){
00857 MSG("NuMatrixFitter.cxx",Msg::kInfo) << "sn2bar = " << sn2bar << endl;
00858 for (Double_t dm2bar = dm2BarLow;
00859 dm2bar <= dm2BarHigh+dm2BarGranularity/2.0;
00860 dm2bar += dm2BarGranularity){
00861
00862 vector<Double_t> vParameters;
00863 vParameters.push_back(2.38);
00864 vParameters.push_back(1.0);
00865 vParameters.push_back(dm2bar);
00866 vParameters.push_back(sn2bar);
00867 this->FillCPTFDPrediction(vParameters);
00868
00869 Double_t chi2 = this->CalculateLikelihood(fhFDMCRecoENuMuBarCC,
00870 fhFDDataRecoENuMuBarCC);
00871
00872
00873 Int_t xBin = hChi2Bar.GetXaxis()->FindBin(sn2bar);
00874 Int_t yBin = hChi2Bar.GetYaxis()->FindBin(dm2bar);
00875 Int_t bin2D = hChi2Bar.GetBin(xBin,yBin);
00876 hChi2Bar.SetBinContent(bin2D,chi2);
00877 if (chi2 < bestChi2){
00878 bestChi2 = chi2;
00879 bestsn2bar = sn2bar;
00880 bestdm2bar = dm2bar;
00881 }
00882 }
00883 }
00884
00885 fBestDm2 = 2.38;
00886 fBestSn2 = 1.0;
00887 fBestDm2Bar = bestdm2bar;
00888 fBestSn2Bar = bestsn2bar;
00889 }
00890
00891 vector<Double_t> vBestFit;
00892 vBestFit.push_back(fBestDm2);
00893 vBestFit.push_back(fBestSn2);
00894 vBestFit.push_back(fBestDm2Bar);
00895 vBestFit.push_back(fBestSn2Bar);
00896 this->FillCPTFDPrediction(vBestFit);
00897 if (fwriteOutput){
00898 fOutputFile->cd();
00899 fhFDMCRecoENuMuCC->Write("BestFitFDMCRecoENuMuCC");
00900 fhFDMCRecoENuMuBarCC->Write("BestFitFDMCRecoENuMuBarCC");
00901 }
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948 }
00949
00950
00951 void NuXFitAnalysis::TransitionAnalysis(const Double_t dm2,
00952 const Double_t sn2)
00953 {
00954 fanalysisSetting = NuXFit::kTransition;
00955 fdm2 = dm2;
00956 fsn2 = sn2;
00957
00958 if (!this->CacheFDMCEvents()){return;}
00959 if (!this->FillFDDataHistograms()){return;}
00960
00961 if (!fdoGridSearch){
00962 this->SetupPars();
00963
00964 fFitter->Minimize();
00965 fFitter->PrintResults(0,0);
00966
00967 fBestTransitionProb = fFitter->GetParameter(0);
00968 }
00969
00970 if (fdoGridSearch){
00971 Double_t bestChi2 = 1.0e10;
00972 Double_t bestTransitionProb = 0.0;
00973
00974 Double_t transitionProbLow = 0.0;
00975 Double_t transitionProbHigh = 1.0;
00976 Double_t transitionProbGranularity = 0.05;
00977
00978
00979 Int_t numTransitionProbBins =
00980 (Int_t) round((transitionProbHigh-transitionProbLow)/
00981 transitionProbGranularity) + 1;
00982 TH1D hChi2Trans("hChi2Trans",
00983 "",
00984 numTransitionProbBins,
00985 transitionProbLow-transitionProbGranularity/2.0,
00986 transitionProbHigh+transitionProbGranularity/2.0);
00987 for (Double_t transitionProb = transitionProbLow;
00988 transitionProb <= transitionProbHigh+transitionProbGranularity/2.0;
00989 transitionProb += transitionProbGranularity){
00990 MSG("NuMatrixFitter.cxx",Msg::kInfo)
00991 << "Fitting transitionProb = " << transitionProb << endl;
00992
00993 vector<Double_t> vParams;
00994 vParams.push_back(transitionProb);
00995 this->FillTransitionFDPrediction(vParams);
00996
00997 Double_t chi2 = this->CalculateLikelihood(fhFDMCRecoENuMuBarCC,
00998 fhFDDataRecoENuMuBarCC);
00999
01000 Int_t xBin = hChi2Trans.GetXaxis()->FindBin(transitionProb);
01001 hChi2Trans.SetBinContent(xBin,chi2);
01002 if (chi2 < bestChi2){
01003 bestChi2 = chi2;
01004 bestTransitionProb = transitionProb;
01005 }
01006 }
01007 fBestTransitionProb = bestTransitionProb;
01008 }
01009
01010 vector<Double_t> vBestFit;
01011 vBestFit.push_back(fBestTransitionProb);
01012 this->FillTransitionFDPrediction(vBestFit);
01013 if (fwriteOutput){
01014 fOutputFile->cd();
01015 fhFDMCRecoENuMuCC->Write("BestFitFDMCRecoENuMuCC");
01016 fhFDMCRecoENuMuBarCC->Write("BestFitFDMCRecoENuMuBarCC");
01017 }
01018 }
01019
01020
01021 void NuXFitAnalysis::SetupPars()
01022 {
01023 if (NuXFit::kCPT == fanalysisSetting){
01024 this->SetupCPTPars();
01025 return;
01026 }
01027 else if (NuXFit::kTransition == fanalysisSetting){
01028 this->SetupTransitionPars();
01029 return;
01030 }
01031 else{
01032 MSG("NuXFitAnalysis.cxx",Msg::kFatal)
01033 << "Incorrect analysis setting" << endl;
01034 return;
01035 }
01036 }
01037
01038
01039 void NuXFitAnalysis::SetupCPTPars()
01040 {
01041 fFitter->SetParameter(0,
01042 "Dm2",
01043 0.00238,0.2,1.0,0.0);
01044 fFitter->SetParameter(1,
01045 "Sn2",
01046 1.0,0.2,1.0,0.0);
01047 fFitter->SetParameter(2,
01048 "Dm2Bar",
01049 0.00238,0.2,1.0,0.0);
01050 fFitter->SetParameter(3,
01051 "Sn2Bar",
01052 1.0,0.2,1.0,0.0);
01053 }
01054
01055
01056 void NuXFitAnalysis::SetupTransitionPars()
01057 {
01058
01059 TFile *xsecfile = new TFile(fxsecfilename.c_str(),"READ");
01060
01061 if (fNuMuCCCrossSectionGraph){
01062 delete fNuMuCCCrossSectionGraph;
01063 fNuMuCCCrossSectionGraph = 0;
01064 }
01065 if (fhNuMuCCCrossSections){
01066 delete fhNuMuCCCrossSections;
01067 fhNuMuCCCrossSections = 0;
01068 }
01069 TH1F* XSec_CC = (TH1F*) xsecfile->Get("h_numu_cc_tot");
01070 fhNuMuCCCrossSections = new TH1F(*XSec_CC);
01071 fhNuMuCCCrossSections->SetDirectory(0);
01072 Float_t *x = new Float_t[XSec_CC->GetNbinsX()];
01073 Float_t *y = new Float_t[XSec_CC->GetNbinsX()];
01074 for(int i=0;i<XSec_CC->GetNbinsX();i++) {
01075 x[i] = XSec_CC->GetBinCenter(i+1);
01076 y[i] = XSec_CC->GetBinContent(i+1);
01077 }
01078 fNuMuCCCrossSectionGraph = new TGraph(XSec_CC->GetNbinsX(),x,y);
01079 if (x) {delete[] x; x = 0;}
01080 if (y) {delete[] y; y = 0;}
01081
01082 if (fNuBarCCCrossSectionGraph){
01083 delete fNuBarCCCrossSectionGraph;
01084 fNuBarCCCrossSectionGraph = 0;
01085 }
01086 if (fhNuBarCCCrossSections){
01087 delete fhNuBarCCCrossSections;
01088 fhNuBarCCCrossSections = 0;
01089 }
01090 XSec_CC = (TH1F*) xsecfile->Get("h_numubar_cc_tot");
01091 fhNuBarCCCrossSections = new TH1F(*XSec_CC);
01092 fhNuBarCCCrossSections->SetDirectory(0);
01093 x = new Float_t[XSec_CC->GetNbinsX()];
01094 y = new Float_t[XSec_CC->GetNbinsX()];
01095 for(int i=0;i<XSec_CC->GetNbinsX();i++) {
01096 x[i] = XSec_CC->GetBinCenter(i+1);
01097 y[i] = XSec_CC->GetBinContent(i+1);
01098 }
01099 fNuBarCCCrossSectionGraph = new TGraph(XSec_CC->GetNbinsX(),x,y);
01100 if (x) {delete[] x; x = 0;}
01101 if (y) {delete[] y; y = 0;}
01102
01103 xsecfile->Close();
01104 if (xsecfile){delete xsecfile; xsecfile = 0;}
01105
01106
01107 TFile* selEffFile = new TFile(fSelEffFileName.c_str(),"READ");
01108
01109 if (fhNuBarCCSelectionEfficiency){
01110 delete fhNuBarCCSelectionEfficiency;
01111 fhNuBarCCSelectionEfficiency = 0;
01112 }
01113 fhNuBarCCSelectionEfficiency = (TH1D*) selEffFile->Get("EfficiencyPQ_FD");
01114 fhNuBarCCSelectionEfficiency->SetDirectory(0);
01115
01116 if (fhNuMuCCSelectionEfficiency){
01117 delete fhNuMuCCSelectionEfficiency;
01118 fhNuMuCCSelectionEfficiency = 0;
01119 }
01120 fhNuMuCCSelectionEfficiency = (TH1D*) selEffFile->Get("Efficiency_FD");
01121 fhNuMuCCSelectionEfficiency->SetDirectory(0);
01122
01123 selEffFile->Close();
01124 if (selEffFile){delete selEffFile; selEffFile = 0;}
01125
01126
01127 fFitter->SetParameter(0,
01128 "transitionProb",
01129 0.0,0.2,1.0,0.0);
01130 }
01131
01132
01133 const Bool_t NuXFitAnalysis::FillFDDataHistograms()
01134 {
01135
01136 if (fhFDNuMuCCDataFromFile && fhFDNuMuBarCCDataFromFile){
01137 if (fhFDDataRecoENuMuCC){
01138 delete fhFDDataRecoENuMuCC; fhFDDataRecoENuMuCC = 0;
01139 }
01140 if (fhFDDataRecoENuMuBarCC){
01141 delete fhFDDataRecoENuMuBarCC; fhFDDataRecoENuMuBarCC = 0;
01142 }
01143 fhFDDataRecoENuMuCC = new TH1D(*fhFDNuMuCCDataFromFile);
01144 fhFDDataRecoENuMuBarCC = new TH1D(*fhFDNuMuBarCCDataFromFile);
01145
01146 if (fwriteOutput){
01147 fOutputFile->cd();
01148 fhFDDataRecoENuMuCC->Write("InputFDNuMuCCData");
01149 fhFDDataRecoENuMuBarCC->Write("InputFDNuMuBarCCData");
01150 }
01151 return true;
01152 }
01153
01154 if (!fhFDDataRecoENuMuCC){
01155 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01156 << "FD numu data histogram not created"
01157 << endl;
01158 return false;
01159 }
01160 if (!fhFDDataRecoENuMuBarCC){
01161 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01162 << "FD numubar data histogram not created"
01163 << endl;
01164 return false;
01165 }
01166 if (!ftFDDataTree){
01167 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01168 << "FD data not supplied"
01169 << endl;
01170 return false;
01171 }
01172
01173 fhFDDataRecoENuMuCC->Reset();
01174 fhFDDataRecoENuMuBarCC->Reset();
01175
01176 Double_t Sn2 = 1.0;
01177 Double_t Sn2Bar = 1.0;
01178 Double_t Dm2 = 0.003;
01179 Double_t Dm2Bar = 0.003;
01180
01181
01182
01183
01184
01185
01186 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01187 << "Looping over FD data:"
01188 << endl;
01189 Int_t dataEntries = ftFDDataTree->GetEntries();
01190 for (Int_t counter = 0;
01191 counter < dataEntries;
01192 ++counter){
01193 if (!(counter%10000)){
01194 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01195 << counter << " of " << dataEntries
01196 << endl;
01197 }
01198 NuEvent currentEvent = ftFDDataTree->GetInfoObject(counter);
01199 NuSelectionResult_t recoType = this->SelectedAs(currentEvent);
01200 Double_t recoEnergy = currentEvent.energy;
01201 Double_t nuweight = 1.0;
01202 nuweight *= currentEvent.rw;
01203
01204
01205 Double_t thisSn2 = 0.0;
01206 Double_t thisDm2 = 0.0;
01207 if (1==currentEvent.iaction){
01208 if (-14==currentEvent.inu){
01209 thisSn2 = Sn2Bar;
01210 thisDm2 = Dm2Bar;
01211 }
01212 if (14==currentEvent.inu){
01213 thisSn2 = Sn2;
01214 thisDm2 = Dm2;
01215 }
01216 }
01217 Double_t oscweight = 1.0-thisSn2*
01218 TMath::Sin(1.27*thisDm2*735.0/currentEvent.neuEnMC)*
01219 TMath::Sin(1.27*thisDm2*735.0/currentEvent.neuEnMC);
01220 nuweight *= oscweight;
01221
01222 if (recoType==NuXSecFit::kCCNuMu){
01223 fhFDDataRecoENuMuCC->Fill(recoEnergy,nuweight);
01224 }
01225 if (recoType==NuXSecFit::kCCNuMuBar){
01226 fhFDDataRecoENuMuBarCC->Fill(recoEnergy,nuweight);
01227 }
01228 }
01229
01230 if (fwriteOutput){
01231 fOutputFile->cd();
01232 fhFDDataRecoENuMuCC->Write("InputFDNuMuCCData");
01233 fhFDDataRecoENuMuBarCC->Write("InputFDNuMuBarCCData");
01234 }
01235
01236 return true;
01237 }
01238
01239
01240 const Bool_t NuXFitAnalysis::CacheFDMCEvents()
01241 {
01242 if (!ftFDMCTree){
01243 MSG("NuXFitAnalysis.cxx",Msg::kWarning)
01244 << "FD MC not supplied"
01245 << endl;
01246 return false;
01247 }
01248
01249 TH1D hFDRawMCRecoECCNuMuBar(*fhFDDataRecoENuMuBarCC);
01250 TH1D hFDRawMCRecoECCNuMu(*fhFDDataRecoENuMuCC);
01251 TH1D hFDNoOscPredRecoECCNuMuBar(*fhFDDataRecoENuMuBarCC);
01252 TH1D hFDNoOscPredRecoECCNuMu(*fhFDDataRecoENuMuCC);
01253
01254 fvFDMCCCNuMuEvents.clear();
01255 fvFDMCCCNuMuBarEvents.clear();
01256
01257 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01258 << "Looping over FD MC:"
01259 << endl;
01260 Int_t mcEntries = ftFDMCTree->GetEntries();
01261 for (Int_t counter = 0;
01262 counter < mcEntries;
01263 ++counter){
01264 if (!(counter%10000)){
01265 MSG("NuXFitAnalysis.cxx",Msg::kInfo)
01266 << counter << " of " << mcEntries
01267 << endl;
01268 }
01269 NuEvent currentEvent = ftFDMCTree->GetInfoObject(counter);
01270 fnuSystematic->Shift(currentEvent);
01271 NuSelectionResult_t recoType = this->SelectedAs(currentEvent);
01272 Double_t eventWeight = currentEvent.rw;
01273
01274 Int_t truthpar = this->TruthIndex(currentEvent);
01275 Double_t eventWeightPred = eventWeight;
01276 if (truthpar>=0){
01277 eventWeightPred *= fvNDFitPars[truthpar];
01278 }
01279
01280 if (NuXSecFit::kCCNuMu==recoType){
01281 fvFDMCCCNuMuEvents.push_back(currentEvent);
01282 hFDRawMCRecoECCNuMu.Fill(currentEvent.energy,eventWeight);
01283 hFDNoOscPredRecoECCNuMu.Fill(currentEvent.energy,eventWeightPred);
01284 }
01285 if (NuXSecFit::kCCNuMuBar==recoType){
01286 fvFDMCCCNuMuBarEvents.push_back(currentEvent);
01287 hFDRawMCRecoECCNuMuBar.Fill(currentEvent.energy,eventWeight);
01288 hFDNoOscPredRecoECCNuMuBar.Fill(currentEvent.energy,eventWeightPred);
01289 }
01290 }
01291
01292 if (ffdMCPoT){
01293 hFDNoOscPredRecoECCNuMu.Scale(ffdDataPoT/ffdMCPoT);
01294 hFDNoOscPredRecoECCNuMuBar.Scale(ffdDataPoT/ffdMCPoT);
01295 hFDRawMCRecoECCNuMu.Scale(ffdDataPoT/ffdMCPoT);
01296 hFDRawMCRecoECCNuMuBar.Scale(ffdDataPoT/ffdMCPoT);
01297 }
01298
01299 if (fwriteOutput){
01300 fOutputFile->cd();
01301 hFDNoOscPredRecoECCNuMu.Write("NoOscPredRecoECCNuMu");
01302 hFDNoOscPredRecoECCNuMuBar.Write("NoOscPredRecoECCNuMuBar");
01303 hFDRawMCRecoECCNuMu.Write("RawMCRecoECCNuMu");
01304 hFDRawMCRecoECCNuMuBar.Write("RawMCRecoECCNuMuBar");
01305 }
01306
01307 return true;
01308 }
01309
01310
01311 const NuSelectionResult_t
01312 NuXFitAnalysis::SelectedAs(NuEvent& nuEvent) const
01313 {
01314 NuCuts nuCuts;
01315 nuEvent.anaVersion = this->SelectionScheme();
01316
01317
01318 if (nuCuts.IsLI(nuEvent)) return NuXSecFit::kUnknown;
01319
01320 if (!nuCuts.IsGoodDataQuality(nuEvent)) return NuXSecFit::kUnknown;
01321
01322 if (!nuCuts.IsGoodTimeToNearestSpill(nuEvent)) return NuXSecFit::kUnknown;
01323
01324 if (!nuCuts.IsGoodBeam(nuEvent)) return NuXSecFit::kUnknown;
01325
01326
01327
01328
01329 if (!nuCuts.IsGoodNumberOfTracks(nuEvent)) return NuXSecFit::kUnknown;
01330
01331 if (!nuCuts.IsInFidVolTrk(nuEvent)) return NuXSecFit::kUnknown;
01332
01333
01334 if (!nuCuts.IsGoodTrackFitPass(nuEvent)) return NuXSecFit::kUnknown;
01335
01336 if (!nuCuts.IsGoodDirCos(nuEvent)) return NuXSecFit::kUnknown;
01337
01338
01339 if (!nuCuts.IsGoodPID(nuEvent)) {
01340 return NuXSecFit::kUnknown;
01341 }
01342
01343 if (!nuCuts.IsGoodSigmaQP_QP(nuEvent)) {
01344 return NuXSecFit::kUnknown;
01345 }
01346
01347 if (!nuCuts.IsGoodFitProb(nuEvent)) {
01348 return NuXSecFit::kUnknown;
01349 }
01350 if (!nuCuts.IsGoodMajorityCurvature(nuEvent)){
01351 return NuXSecFit::kUnknown;
01352 }
01353
01354 if (-1==nuEvent.charge){return NuXSecFit::kCCNuMu;}
01355 if (1==nuEvent.charge){return NuXSecFit::kCCNuMuBar;}
01356 return NuXSecFit::kUnknown;
01357 }