FarOverNearFitLED Class Reference

#include <FarOverNearFitLED.h>

Inheritance diagram for FarOverNearFitLED:
NuMMRun

List of all members.

Public Types

enum  whichPred { CC, NC }
enum  whichDet { ND, FD }
enum  BinningScheme { LE, ME }

Public Member Functions

 FarOverNearFitLED ()
virtual ~FarOverNearFitLED ()
void SetNDMC (TFile *MC_file, TFile *Nue_file, TFile *NuTau_file)
void SetNDData (TFile *Data_file)
void SetNDBaseline (double baseline)
void SetFDMC (TFile *MC_file, TFile *Nue_file, TFile *NuTau_file)
void SetFDData (TFile *Data_file)
void SetFDBaseline (double baseline)
void SetMatrices (TFile *Data_file)
void SetPOT (double POT_)
virtual Double_t ComparePredWithData (const NuMMParameters &pars)
virtual std::vector< TH1D > WriteFDPredHistos (const NuMMParameters &pars) const
TH1D * FDPrediction (const NuMMParameters &pars, whichPred Pred)
TH1D * FDPrediction (NuXMLConfig *xml_config, whichPred Pred)
virtual TH1D * MCOscillated (const NuMMParameters &pars, whichPred Pred, whichDet Det)
TH1D * MCOscillated (NuXMLConfig *xml_config, whichPred Pred, whichDet Det)
virtual void GetHistos ()
virtual void GetMatrices ()
Double_t ChiSqFunction (TH1D *rPred, TH1D *rData, TMatrixD *CoVarInvert)
Double_t ChiSqFunctionLowEnergyCutoff (TH1D *rPred, TH1D *rData, TMatrixD *CoVarInvert, Double_t energyCutoff)
Double_t NDNormPenaltyTerm (TString Type)
void CalculateNDIntegrals ()
virtual NuMMParameters UnOscillatedPars ()
TH1D * Rebin4Chi (TH1D *Orig, whichPred Pred)
double GetNDBaseline ()
double GetFDBaseline ()
TFile * GetMatrixTFile ()
void SetFluxUncertainty (double err)
void SetUseCC (bool use)
void SetUseNC (bool use)
void SetUseGhostFitter (bool use)
void SetFakeDataFluctuation (Int_t seed)
bool GetUseCC ()
bool GetUseNC ()
Double_t ComparePredWithDataNC (const NuMMParameters &pars)
Double_t ComparePredWithDataCC (const NuMMParameters &pars)
virtual Double_t ComparePredWithDataGhostFitter (const NuMMParameters &pars)
void FluctuateFakeData (Int_t seed)
void CalculateDataFarOverNearRatio ()
void Initialize ()
void SetQuietMode (bool quiet)
void SetBinningScheme (BinningScheme b)
BinningScheme GetBinningScheme ()
void SetLowEnergyCutoffNC (Double_t cutoff)
Double_t GetLowEnergyCutoffNC ()
Bool_t GetQuietMode ()
void SetInitialized (bool i)
void Add (FarOverNearFitLED *fnf)
pair< TH1D *, TH1D * > GetPredGhostFitter (const NuMMParameters &pars)
void SetGhostFitterGrid (THnSparseF *h1)
void SetTemplateDir (TString dir)
void SetFakeData (const NuMMParameters pars, Int_t randomSeed)
void SetFakeDataGhostFitter (NuMMParameters pars, Int_t randomSeed)

Public Attributes

TH1D * oscAvgOverBinNC
TH1D * oscAvgOverBinNuMu
TGraph * oscIterOverBinNC
TGraph * oscIterOverBinNuMu
TMatrixD * CoVarCCinvert
TMatrixD * CoVarNCinvert
TMatrixD * CoVarCC
TMatrixD * CoVarNC
TH1D * oscTrueNC
TH1D * oscNuMu
TH1D * oscBeamNue
TH1D * oscAppNue
TH1D * oscAppNuTau
TH1F * ND_MC_POT
TH1F * ND_Nue_POT
TH1F * ND_NuTau_POT
TH1F * ND_data_POT
TH1F * FD_MC_POT
TH1F * FD_Nue_POT
TH1F * FD_NuTau_POT
TH2D * NDNC_TrueNC
TH2D * NDNC_NuMu
TH2D * NDNC_BeamNue
TH2D * NDNC_AppNue
TH2D * NDNC_AppNuTau
TH2D * NDCC_TrueNC
TH2D * NDCC_NuMu
TH2D * NDCC_BeamNue
TH2D * NDCC_AppNue
TH2D * NDCC_AppNuTau
TH2D * FDNC_TrueNC
TH2D * FDNC_NuMu
TH2D * FDNC_BeamNue
TH2D * FDNC_AppNue
TH2D * FDNC_AppNuTau
TH2D * FDCC_TrueNC
TH2D * FDCC_NuMu
TH2D * FDCC_BeamNue
TH2D * FDCC_AppNue
TH2D * FDCC_AppNuTau
TH1D * FD_dataNC
TH1D * FD_dataCC
TH1D * ND_dataNC
TH1D * ND_dataCC
TH1D * FDOscCC_MC
TH1D * NDOscCC_MC
TH1D * FDOscNC_MC
TH1D * NDOscNC_MC
TH1D * RpredCC
TH1D * RpredNC
TH1D * RdataCC
TH1D * RdataNC
Double_t TotalNDNC
Double_t TotalNDCC

Private Member Functions

virtual void cleanup ()
virtual NuMMParameters XMLtoParameters (NuXMLConfig *xml_config)
 ClassDef (FarOverNearFitLED, 0)

Private Attributes

THnSparseF * hGhostFitterGrid
TFile * fTemplateFile [2]
TString templateDir
double ND_baseline
double FD_baseline
TFile * ND_MC
TFile * ND_Nue
TFile * ND_NuTau
TFile * ND_data
TFile * FD_MC
TFile * FD_Nue
TFile * FD_NuTau
TFile * FD_data
TFile * matrix
double POT
double fluxUncertainty
double TotalNDDataCC
double TotalNDDataNC
bool useCC
bool useNC
bool useGhostFitter
bool initialized
Int_t randomSeed
bool quietMode
BinningScheme binningFit
Double_t lowEnergyCutoffNC

Detailed Description

Definition at line 27 of file FarOverNearFitLED.h.


Member Enumeration Documentation

Enumerator:
LE 
ME 

Definition at line 32 of file FarOverNearFitLED.h.

00032 {LE, ME};

Enumerator:
ND 
FD 

Definition at line 31 of file FarOverNearFitLED.h.

00031 {ND, FD};

Enumerator:
CC 
NC 

Definition at line 30 of file FarOverNearFitLED.h.

00030 {CC, NC};


Constructor & Destructor Documentation

FarOverNearFitLED::FarOverNearFitLED (  ) 

Definition at line 22 of file FarOverNearFitLED.cxx.

References Munits::km.

00022                                        : oscAvgOverBinNC(0),  oscAvgOverBinNuMu(0),
00023                                      oscIterOverBinNC(0), oscIterOverBinNuMu(0),
00024                                      oscTrueNC(0), oscNuMu(0), oscBeamNue(0),
00025                                      oscAppNue(0), oscAppNuTau(0),
00026                                      ND_MC(0), ND_Nue(0), ND_NuTau(0), ND_data(0),
00027                                      FD_MC(0), FD_Nue(0), FD_NuTau(0), FD_data(0),
00028                                      POT(0.0), 
00029                                      fluxUncertainty(0.5),
00030                                      useCC(true), useNC(true),
00031                                      initialized(false), randomSeed(-1),
00032                                      quietMode(false), 
00033                                      binningFit(LE),
00034                                      useGhostFitter(false),
00035                                      lowEnergyCutoffNC(-1.),
00036                                      hGhostFitterGrid(0)
00037 {
00038   ND_baseline = 0. * Munits::km;
00039   FD_baseline = 0. * Munits::km;
00040   fTemplateFile[0] = 0;
00041   fTemplateFile[1] = 0;
00042 }

FarOverNearFitLED::~FarOverNearFitLED (  )  [virtual]

Definition at line 60 of file FarOverNearFitLED.cxx.

References cleanup().

00061 {
00062   cleanup();
00063 }


Member Function Documentation

void FarOverNearFitLED::Add ( FarOverNearFitLED fnf  ) 

Definition at line 229 of file FarOverNearFitLED.cxx.

References FD_dataCC, FD_dataNC, FDCC_AppNue, FDCC_AppNuTau, FDCC_BeamNue, FDCC_NuMu, FDCC_TrueNC, FDNC_AppNue, FDNC_AppNuTau, FDNC_BeamNue, FDNC_NuMu, FDNC_TrueNC, ND_dataCC, ND_dataNC, NDCC_AppNue, NDCC_AppNuTau, NDCC_BeamNue, NDCC_NuMu, NDCC_TrueNC, NDNC_AppNue, NDNC_AppNuTau, NDNC_BeamNue, NDNC_NuMu, and NDNC_TrueNC.

00229                                                    {
00230 
00231   // data
00232   FD_dataNC->Add(fnFit->FD_dataNC);
00233   FD_dataCC->Add(fnFit->FD_dataCC);
00234   ND_dataNC->Add(fnFit->ND_dataNC);
00235   ND_dataCC->Add(fnFit->ND_dataCC);
00236 
00237   // ND
00238   NDNC_TrueNC   ->Add(fnFit->NDNC_TrueNC);
00239   NDNC_NuMu     ->Add(fnFit->NDNC_NuMu);
00240   NDNC_BeamNue  ->Add(fnFit->NDNC_BeamNue);
00241   NDNC_AppNue   ->Add(fnFit->NDNC_AppNue);
00242   NDNC_AppNuTau ->Add(fnFit->NDNC_AppNuTau);
00243 
00244   NDCC_TrueNC   ->Add(fnFit->NDCC_TrueNC);
00245   NDCC_NuMu     ->Add(fnFit->NDCC_NuMu);
00246   NDCC_BeamNue  ->Add(fnFit->NDCC_BeamNue);
00247   NDCC_AppNue   ->Add(fnFit->NDCC_AppNue);
00248   NDCC_AppNuTau ->Add(fnFit->NDCC_AppNuTau);
00249 
00250   // FD
00251   FDNC_TrueNC   ->Add(fnFit->FDNC_TrueNC);
00252   FDNC_NuMu     ->Add(fnFit->FDNC_NuMu);
00253   FDNC_BeamNue  ->Add(fnFit->FDNC_BeamNue);
00254   FDNC_AppNue   ->Add(fnFit->FDNC_AppNue);
00255   FDNC_AppNuTau ->Add(fnFit->FDNC_AppNuTau);
00256 
00257   FDCC_TrueNC   ->Add(fnFit->FDCC_TrueNC);
00258   FDCC_NuMu     ->Add(fnFit->FDCC_NuMu);
00259   FDCC_BeamNue  ->Add(fnFit->FDCC_BeamNue);
00260   FDCC_AppNue   ->Add(fnFit->FDCC_AppNue);
00261   FDCC_AppNuTau ->Add(fnFit->FDCC_AppNuTau);
00262 
00263   cout << "Add done" << endl;
00264 }

void FarOverNearFitLED::CalculateDataFarOverNearRatio (  ) 

Definition at line 472 of file FarOverNearFitLED.cxx.

References CC, FD_dataCC, FD_dataNC, NC, ND_dataCC, ND_dataNC, RdataCC, RdataNC, and Rebin4Chi().

Referenced by Initialize(), and SetFakeData().

00472                                                      {
00473 
00474   RdataNC = (TH1D*)(Rebin4Chi(FD_dataNC, NC)->Clone());
00475   RdataNC->Divide(Rebin4Chi(ND_dataNC, NC));
00476 
00477   RdataCC = (TH1D*)(Rebin4Chi(FD_dataCC, CC)->Clone());
00478   RdataCC->Divide(Rebin4Chi(ND_dataCC, CC));
00479 
00480   cout << "CalculateDataFarOverNearRatio done" << endl;
00481 }

void FarOverNearFitLED::CalculateNDIntegrals (  ) 

Definition at line 531 of file FarOverNearFitLED.cxx.

References CC, MCOscillated(), NC, ND, ND_dataCC, ND_dataNC, TotalNDCC, TotalNDDataCC, TotalNDDataNC, TotalNDNC, and UnOscillatedPars().

Referenced by Initialize(), and SetFakeData().

00532 {
00533   // This function will save two numbers the CC and NC ND Integrals from 0 - 40 Gev
00534   // Firt create a NuMMPars which is zero oscills for the ND
00535   NuMMParameters Unpars = UnOscillatedPars();
00536 
00537   TH1D* NDCCUnosc = MCOscillated(Unpars, CC, ND);
00538   TH1D* NDNCUnosc = MCOscillated(Unpars, NC, ND);
00539 
00540   // I need to find the bin index for 40 gev for intergal
00541   TotalNDCC = NDCCUnosc->Integral(1, NDCCUnosc->FindFixBin(40) );
00542   TotalNDNC = NDNCUnosc->Integral(1, NDNCUnosc->FindFixBin(40) );
00543 
00544   TotalNDDataCC = ND_dataCC->Integral(1, ND_dataCC->FindFixBin(40));
00545   TotalNDDataNC = ND_dataNC->Integral(1, ND_dataNC->FindFixBin(40));
00546 
00547   cout << "CalculateNDIntegrals done" << endl;
00548 }

Double_t FarOverNearFitLED::ChiSqFunction ( TH1D *  rPred,
TH1D *  rData,
TMatrixD *  CoVarInvert 
)

Definition at line 509 of file FarOverNearFitLED.cxx.

Referenced by ComparePredWithDataCC(), ComparePredWithDataGhostFitter(), and ComparePredWithDataNC().

00510 {
00511 
00512   if(!(rPred->GetNbinsX() == rData->GetNbinsX())){ 
00513     std::cout << "Incorrect Binning agreement. Asserting" << std::endl;
00514     assert(false);
00515   }
00516 
00517   Int_t NumberOfBins = rPred->GetNbinsX() - 1; // miss out the last bin as its 40Gev+
00518   TVectorD Difference(NumberOfBins);
00519   for(Int_t i=1; i<=NumberOfBins; ++i){
00520     Difference(i-1) = (rData->GetBinContent(i) - rPred->GetBinContent(i));
00521   }
00522 
00523   TVectorD temp = Difference;
00524   temp *= (*CoVarInvert);
00525   Double_t TotalChiSq = temp*Difference;
00526 
00527   return TotalChiSq;
00528 }

Double_t FarOverNearFitLED::ChiSqFunctionLowEnergyCutoff ( TH1D *  rPred,
TH1D *  rData,
TMatrixD *  CoVarInvert,
Double_t  energyCutoff 
)

Definition at line 484 of file FarOverNearFitLED.cxx.

Referenced by ComparePredWithDataNC().

00484                                                                                                                               {
00485 
00486   Int_t binCutoff = rPred->GetXaxis()->FindBin(energyCutoff);
00487 
00488   if(!(rPred->GetNbinsX() == rData->GetNbinsX())){ 
00489     std::cout << "Incorrect Binning agreement. Asserting" << std::endl;
00490     assert(false);
00491   }
00492 
00493   Int_t NumberOfBins = rPred->GetNbinsX() - 1;
00494   TVectorD Difference(NumberOfBins);
00495   for(Int_t i=1; i<=NumberOfBins; ++i)
00496     Difference(i-1) = (rData->GetBinContent(i) - rPred->GetBinContent(i));
00497 
00498   TVectorD differenceSub = Difference.GetSub(binCutoff - 1, NumberOfBins - 1);
00499   TMatrixD CoVarInvertSub = CoVarInvert->GetSub(binCutoff - 1, NumberOfBins - 1, binCutoff - 1, NumberOfBins - 1);
00500 
00501   TVectorD tempSub = differenceSub;
00502   tempSub *= CoVarInvertSub;
00503   Double_t TotalChiSqSub = tempSub * differenceSub;
00504 
00505   return TotalChiSqSub;
00506 }

FarOverNearFitLED::ClassDef ( FarOverNearFitLED  ,
 
) [private]
void FarOverNearFitLED::cleanup (  )  [private, virtual]

Definition at line 45 of file FarOverNearFitLED.cxx.

References oscAppNue, oscAppNuTau, oscAvgOverBinNC, oscAvgOverBinNuMu, oscBeamNue, oscIterOverBinNC, oscIterOverBinNuMu, oscNuMu, and oscTrueNC.

Referenced by ~FarOverNearFitLED().

00046 {
00047   if(oscAvgOverBinNC)    { delete oscAvgOverBinNC;    oscAvgOverBinNC    = 0; }
00048   if(oscAvgOverBinNuMu)  { delete oscAvgOverBinNuMu;  oscAvgOverBinNuMu  = 0; }
00049   if(oscIterOverBinNC)   { delete oscIterOverBinNC;   oscIterOverBinNC   = 0; }
00050   if(oscIterOverBinNuMu) { delete oscIterOverBinNuMu; oscIterOverBinNuMu = 0; }
00051 
00052   if(oscTrueNC)   { delete oscTrueNC;   oscTrueNC   = 0; }
00053   if(oscNuMu)     { delete oscNuMu;     oscNuMu     = 0; }
00054   if(oscBeamNue)  { delete oscBeamNue;  oscBeamNue  = 0; }
00055   if(oscAppNue)   { delete oscAppNue;   oscAppNue   = 0; }
00056   if(oscAppNuTau) { delete oscAppNuTau; oscAppNuTau = 0; }
00057 }

Double_t FarOverNearFitLED::ComparePredWithData ( const NuMMParameters pars  )  [virtual]

Implements NuMMRun.

Definition at line 413 of file FarOverNearFitLED.cxx.

References ComparePredWithDataCC(), ComparePredWithDataGhostFitter(), ComparePredWithDataNC(), initialized, quietMode, useCC, useGhostFitter, and useNC.

00413                                                                          {
00414 
00415   if(!initialized){
00416     cout << "Initialize() is required" << endl;
00417     abort();
00418   }
00419 
00420   Double_t chisq = 0.;
00421   if(useGhostFitter)
00422       chisq += ComparePredWithDataGhostFitter(pars);
00423   else{
00424     if(useCC)
00425       chisq += ComparePredWithDataCC(pars);
00426     if(useNC)
00427       chisq += ComparePredWithDataNC(pars);
00428   }
00429   if(!quietMode){
00430     cout << "the total chi2 is " << chisq << endl;
00431     cout << endl;
00432   }
00433 
00434   return chisq;
00435 }

Double_t FarOverNearFitLED::ComparePredWithDataCC ( const NuMMParameters pars  ) 

Definition at line 360 of file FarOverNearFitLED.cxx.

References CC, ChiSqFunction(), CoVarCCinvert, FD, FDOscCC_MC, MCOscillated(), ND, NDNormPenaltyTerm(), NDOscCC_MC, quietMode, RdataCC, Rebin4Chi(), and RpredCC.

Referenced by ComparePredWithData().

00360                                                                            {
00361 
00362   NDOscCC_MC = MCOscillated(pars, CC, ND);
00363   FDOscCC_MC = MCOscillated(pars, CC, FD);
00364   Double_t NormCCpen = 0.0;
00365   NormCCpen = NDNormPenaltyTerm("CC");
00366 
00367   TH1D* NDOscCC_MCr = Rebin4Chi(NDOscCC_MC, CC);
00368   TH1D* FDOscCC_MCr = Rebin4Chi(FDOscCC_MC, CC);
00369 
00370   RpredCC = (TH1D*)FDOscCC_MCr->Clone();
00371   RpredCC->Divide(NDOscCC_MCr);
00372 
00373   Double_t chisqCC = 0.0;
00374   Double_t chisq = 0.0;
00375   chisqCC = ChiSqFunction(RpredCC, RdataCC, CoVarCCinvert);
00376 
00377   if(!quietMode)
00378     cout << "CC chi sq = " << chisqCC << ", Norm pen = " << NormCCpen << endl;
00379 
00380   chisq = chisqCC + NormCCpen;
00381   return chisq;
00382 }

Double_t FarOverNearFitLED::ComparePredWithDataGhostFitter ( const NuMMParameters pars  )  [virtual]

Definition at line 329 of file FarOverNearFitLED.cxx.

References ChiSqFunction(), CoVarCCinvert, CoVarNCinvert, GetPredGhostFitter(), GetQuietMode(), GetUseCC(), GetUseNC(), RdataCC, and RdataNC.

Referenced by ComparePredWithData().

00329                                                                                     {
00330 
00331   pair<TH1D*, TH1D*> hInterpolated = this->GetPredGhostFitter(pars);
00332   Double_t chisqCC;
00333   Double_t chisqNC;
00334   Double_t chisq = 0.;
00335 
00336   if(this->GetUseCC()){
00337     chisqCC = ChiSqFunction(hInterpolated.first, RdataCC, CoVarCCinvert);
00338     chisq += chisqCC;
00339     if(!GetQuietMode())
00340       std::cout << "chisqCC = " << chisqCC << std::endl;
00341   }
00342   if(this->GetUseNC()){
00343     chisqNC = ChiSqFunction(hInterpolated.second, RdataNC, CoVarNCinvert);
00344     chisq += chisqNC;
00345     if(!GetQuietMode())
00346       std::cout << "chisqNC = " << chisqNC << std::endl;
00347   }
00348 
00349   // As an approximation, the flux penalty is not added in order to reduce the template size.
00350   // This should not affect the result.
00351 
00352   delete hInterpolated.first;
00353   delete hInterpolated.second;
00354 
00355   return chisq;
00356 }

Double_t FarOverNearFitLED::ComparePredWithDataNC ( const NuMMParameters pars  ) 

Definition at line 385 of file FarOverNearFitLED.cxx.

References ChiSqFunction(), ChiSqFunctionLowEnergyCutoff(), CoVarNCinvert, FD, FDOscNC_MC, lowEnergyCutoffNC, MCOscillated(), NC, ND, NDNormPenaltyTerm(), NDOscNC_MC, quietMode, RdataNC, Rebin4Chi(), and RpredNC.

Referenced by ComparePredWithData().

00385                                                                            {
00386 
00387   NDOscNC_MC = MCOscillated(pars, NC, ND);
00388   FDOscNC_MC = MCOscillated(pars, NC, FD);
00389   Double_t NormNCpen = 0.0;
00390   NormNCpen = NDNormPenaltyTerm("NC");
00391 
00392   TH1D* NDOscNC_MCr = Rebin4Chi(NDOscNC_MC, NC);
00393   TH1D* FDOscNC_MCr = Rebin4Chi(FDOscNC_MC, NC);
00394 
00395   RpredNC = (TH1D*)FDOscNC_MCr->Clone();
00396   RpredNC->Divide(NDOscNC_MCr);
00397 
00398   Double_t chisqNC = 0.0;
00399   Double_t chisq = 0.0;
00400   if(lowEnergyCutoffNC < 0.)
00401     chisqNC = ChiSqFunction(RpredNC, RdataNC, CoVarNCinvert);
00402   else
00403     chisqNC = ChiSqFunctionLowEnergyCutoff(RpredNC, RdataNC, CoVarNCinvert, lowEnergyCutoffNC);
00404 
00405   if(!quietMode)
00406     cout << "NC chi sq = " << chisqNC << ", Norm pen = " << NormNCpen << endl;
00407 
00408   chisq = chisqNC + NormNCpen;
00409   return chisq;
00410 }

TH1D * FarOverNearFitLED::FDPrediction ( NuXMLConfig xml_config,
whichPred  Pred 
)

Definition at line 619 of file FarOverNearFitLED.cxx.

References FDPrediction(), and XMLtoParameters().

00620 {
00621   NuMMParameters pars = XMLtoParameters(xml_config);
00622   return FDPrediction(pars, Pred);
00623 }

TH1D * FarOverNearFitLED::FDPrediction ( const NuMMParameters pars,
whichPred  Pred 
)

Definition at line 582 of file FarOverNearFitLED.cxx.

References CC, FD, GetHistos(), MCOscillated(), NC, ND, ND_dataCC, ND_dataNC, oscAppNue, oscAppNuTau, oscBeamNue, oscNuMu, and oscTrueNC.

Referenced by FDPrediction().

00583 {
00584   GetHistos();
00585   TH1D *ND_dataE = 0;
00586   switch(Pred)
00587     {
00588     case NC:
00589       ND_dataE = ND_dataNC;
00590       break;
00591     case CC:
00592       ND_dataE = ND_dataCC;
00593       break;
00594     default:
00595       cout << "wrong pred type" << endl;
00596       break;
00597     }
00598   TH1D *cloneNDdata = (TH1D*)ND_dataE->Clone("cloneNDdata");
00599         
00600   TH1D *NDOsc_MC = MCOscillated(pars, Pred, ND);
00601   TH1D *FDOsc_MC = MCOscillated(pars, Pred, FD);
00602 
00603   cloneNDdata->Divide(NDOsc_MC);
00604   FDOsc_MC->Multiply(cloneNDdata);
00605 
00606   oscTrueNC->Multiply(cloneNDdata);
00607   oscNuMu->Multiply(cloneNDdata);
00608   oscBeamNue->Multiply(cloneNDdata);
00609   oscAppNue->Multiply(cloneNDdata);
00610   oscAppNuTau->Multiply(cloneNDdata);
00611 
00612   delete NDOsc_MC;
00613   delete cloneNDdata;
00614 
00615   return FDOsc_MC;
00616 }

void FarOverNearFitLED::FluctuateFakeData ( Int_t  seed  ) 

Definition at line 455 of file FarOverNearFitLED.cxx.

References CoVarCC, CoVarNC, MultiVarGauss::Generate(), RdataCC, RdataNC, and MultiVarGauss::SetRandomSeed().

Referenced by Initialize(), SetFakeData(), and SetFakeDataGhostFitter().

00455                                                    {
00456 
00457   cout << "random seed is " << seed << endl;
00458 
00459   MultiVarGauss SampleFlucCC(RdataCC, CoVarCC);
00460   MultiVarGauss SampleFlucNC(RdataNC, CoVarNC);
00461   SampleFlucCC.SetRandomSeed(seed);
00462   SampleFlucNC.SetRandomSeed(seed);
00463    
00464   RdataCC = new TH1D(*SampleFlucCC.Generate());
00465   RdataCC->SetDirectory(0);
00466   RdataNC = new TH1D(*SampleFlucNC.Generate());
00467   RdataNC->SetDirectory(0);
00468   std::cout << "FluctuateFakeData done" << std::endl;
00469 }

BinningScheme FarOverNearFitLED::GetBinningScheme (  )  [inline]

Definition at line 135 of file FarOverNearFitLED.h.

References binningFit.

00135 {return binningFit;};

double FarOverNearFitLED::GetFDBaseline (  )  [inline]

Definition at line 111 of file FarOverNearFitLED.h.

References FD_baseline.

Referenced by MCOscillated().

00111 {return FD_baseline;};

void FarOverNearFitLED::GetHistos (  )  [virtual]

Definition at line 134 of file FarOverNearFitLED.cxx.

References FD_data, FD_dataCC, FD_dataNC, FD_MC, FD_MC_POT, FD_Nue, FD_Nue_POT, FD_NuTau, FD_NuTau_POT, FDCC_AppNue, FDCC_AppNuTau, FDCC_BeamNue, FDCC_NuMu, FDCC_TrueNC, FDNC_AppNue, FDNC_AppNuTau, FDNC_BeamNue, FDNC_NuMu, FDNC_TrueNC, ND_data, ND_data_POT, ND_dataCC, ND_dataNC, ND_MC, ND_MC_POT, ND_Nue, ND_Nue_POT, ND_NuTau, ND_NuTau_POT, NDCC_AppNue, NDCC_AppNuTau, NDCC_BeamNue, NDCC_NuMu, NDCC_TrueNC, NDNC_AppNue, NDNC_AppNuTau, NDNC_BeamNue, NDNC_NuMu, and NDNC_TrueNC.

Referenced by FDPrediction(), and Initialize().

00135 {
00136   // GetObjects
00137   assert(FD_data);
00138   assert(ND_data);
00139   assert(ND_MC);
00140   assert(ND_Nue);
00141   assert(ND_NuTau);
00142   assert(FD_MC);
00143   assert(FD_Nue);
00144   assert(FD_NuTau);
00145 
00146   FD_data->GetObject("hRecoEnergyNC",    FD_dataNC); assert(FD_dataNC);
00147   FD_dataNC->SetName("hRecoEnergyNC_FD");
00148   FD_data->GetObject("hRecoEnergyCCAll", FD_dataCC); assert(FD_dataCC);
00149   FD_dataCC->SetName("hRecoEnergyCCAll_FD");
00150 
00151   ND_data->GetObject("hRecoEnergyNC",    ND_dataNC); assert(ND_dataNC);
00152   ND_dataNC->SetName("hRecoEnergyNC_ND");
00153   ND_data->GetObject("hRecoEnergyCCAll", ND_dataCC); assert(ND_dataCC);
00154   ND_dataCC->SetName("hRecoEnergyCCAll_ND");
00155 
00156   ND_MC->GetObject("hRecoToTrueNCSelectedTrueNC",      NDNC_TrueNC);   assert(NDNC_TrueNC);
00157   ND_MC->GetObject("hRecoToTrueNCSelectedTrueCCNuMu",  NDNC_NuMu);     assert(NDNC_NuMu);
00158   ND_MC->GetObject("hRecoToTrueNCSelectedBeamNue",     NDNC_BeamNue);  assert(NDNC_BeamNue);
00159   ND_Nue->GetObject("hRecoToTrueNCSelectedAppearNue",   NDNC_AppNue);   assert(NDNC_AppNue);
00160   ND_NuTau->GetObject("hRecoToTrueNCSelectedAppearNuTau", NDNC_AppNuTau); assert(NDNC_AppNuTau);
00161 
00162   ND_MC->GetObject("hRecoToTrueCCSelectedTrueNC",      NDCC_TrueNC);   assert(NDCC_TrueNC);
00163   ND_MC->GetObject("hRecoToTrueCCSelectedTrueCCNuMu",  NDCC_NuMu);     assert(NDCC_NuMu);
00164   ND_MC->GetObject("hRecoToTrueCCSelectedBeamNue",     NDCC_BeamNue);  assert(NDCC_BeamNue);
00165   ND_Nue->GetObject("hRecoToTrueCCSelectedAppearNue",   NDCC_AppNue);   assert(NDCC_AppNue);
00166   ND_NuTau->GetObject("hRecoToTrueCCSelectedAppearNuTau", NDCC_AppNuTau); assert(NDCC_AppNuTau);
00167 
00168   FD_MC->GetObject("hRecoToTrueNCSelectedTrueNC",      FDNC_TrueNC);   assert(FDNC_TrueNC);
00169   FD_MC->GetObject("hRecoToTrueNCSelectedTrueCCNuMu",  FDNC_NuMu);     assert(FDNC_NuMu);
00170   FD_MC->GetObject("hRecoToTrueNCSelectedBeamNue",     FDNC_BeamNue);  assert(FDNC_BeamNue);
00171   FD_Nue->GetObject("hRecoToTrueNCSelectedAppearNue",   FDNC_AppNue);   assert(FDNC_AppNue);
00172   FD_NuTau->GetObject("hRecoToTrueNCSelectedAppearNuTau", FDNC_AppNuTau); assert(FDNC_AppNuTau);
00173 
00174   FD_MC->GetObject("hRecoToTrueCCSelectedTrueNC",      FDCC_TrueNC);   assert(FDCC_TrueNC);
00175   FD_MC->GetObject("hRecoToTrueCCSelectedTrueCCNuMu",  FDCC_NuMu);     assert(FDCC_NuMu);
00176   FD_MC->GetObject("hRecoToTrueCCSelectedBeamNue",     FDCC_BeamNue);  assert(FDCC_BeamNue);
00177   FD_Nue->GetObject("hRecoToTrueCCSelectedAppearNue",   FDCC_AppNue);   assert(FDCC_AppNue);
00178   FD_NuTau->GetObject("hRecoToTrueCCSelectedAppearNuTau", FDCC_AppNuTau); assert(FDCC_AppNuTau);
00179 
00180   ND_data->GetObject("hTotalPot", ND_data_POT);  assert(ND_data_POT);
00181   ND_MC->GetObject("hTotalPot", ND_MC_POT);    assert(ND_MC_POT);
00182   ND_Nue->GetObject("hTotalPot", ND_Nue_POT);   assert(ND_Nue_POT);
00183   ND_NuTau->GetObject("hTotalPot", ND_NuTau_POT); assert(ND_NuTau_POT);
00184   FD_MC->GetObject("hTotalPot", FD_MC_POT);    assert(FD_MC_POT);
00185   FD_Nue->GetObject("hTotalPot", FD_Nue_POT);   assert(FD_Nue_POT);
00186   FD_NuTau->GetObject("hTotalPot", FD_NuTau_POT); assert(FD_NuTau_POT);
00187 
00188   // POT normalize
00189   double dataPOT = ND_data_POT->Integral();
00190   ND_dataNC->Scale(POT/dataPOT);
00191   ND_dataCC->Scale(POT/dataPOT);
00192         
00193   double ndmcPOT = ND_MC_POT->Integral();
00194   NDNC_TrueNC->Scale(POT/ndmcPOT);
00195   NDNC_NuMu->Scale(POT/ndmcPOT);
00196   NDNC_BeamNue->Scale(POT/ndmcPOT);
00197   NDCC_TrueNC->Scale(POT/ndmcPOT);
00198   NDCC_NuMu->Scale(POT/ndmcPOT);
00199   NDCC_BeamNue->Scale(POT/ndmcPOT);
00200 
00201   double ndnuePOT = ND_Nue_POT->Integral();
00202   NDNC_AppNue->Scale(POT/ndnuePOT);
00203   NDCC_AppNue->Scale(POT/ndnuePOT);
00204 
00205   double ndnutauPOT = ND_NuTau_POT->Integral();
00206   NDNC_AppNuTau->Scale(POT/ndnutauPOT);
00207   NDCC_AppNuTau->Scale(POT/ndnutauPOT);
00208 
00209   double fdmcPOT = FD_MC_POT->Integral();
00210   FDNC_TrueNC->Scale(POT/fdmcPOT);
00211   FDNC_NuMu->Scale(POT/fdmcPOT);
00212   FDNC_BeamNue->Scale(POT/fdmcPOT);
00213   FDCC_TrueNC->Scale(POT/fdmcPOT);
00214   FDCC_NuMu->Scale(POT/fdmcPOT);
00215   FDCC_BeamNue->Scale(POT/fdmcPOT);
00216 
00217   double fdnuePOT = FD_Nue_POT->Integral();
00218   FDNC_AppNue->Scale(POT/fdnuePOT);
00219   FDCC_AppNue->Scale(POT/fdnuePOT);
00220 
00221   double fdnutauPOT = FD_NuTau_POT->Integral();
00222   FDNC_AppNuTau->Scale(POT/fdnutauPOT);
00223   FDCC_AppNuTau->Scale(POT/fdnutauPOT);
00224 
00225   std::cout << "GetHistos done" << std::endl;
00226 }

Double_t FarOverNearFitLED::GetLowEnergyCutoffNC (  )  [inline]

Definition at line 137 of file FarOverNearFitLED.h.

References lowEnergyCutoffNC.

00137 {return lowEnergyCutoffNC;};

void FarOverNearFitLED::GetMatrices (  )  [virtual]

Definition at line 116 of file FarOverNearFitLED.cxx.

References CoVarCC, CoVarCCinvert, CoVarNC, CoVarNCinvert, GetMatrixTFile(), and matrix.

Referenced by Initialize().

00117 {
00118   assert(matrix);
00119 
00120   CoVarCCinvert = (TMatrixD*)matrix->Get("TotalInvertCC"); 
00121   CoVarNCinvert = (TMatrixD*)matrix->Get("TotalInvertNC");
00122 
00123   CoVarCC = (TMatrixD*)(GetMatrixTFile()->Get("TotalCCCovar")); 
00124   CoVarNC = (TMatrixD*)(GetMatrixTFile()->Get("TotalNCCovar")); 
00125 
00126   assert(CoVarCCinvert);
00127   assert(CoVarNCinvert);
00128   assert(CoVarCC);
00129   assert(CoVarNC);
00130   std::cout << "GetMatrices done" << std::endl;
00131 }

TFile* FarOverNearFitLED::GetMatrixTFile (  )  [inline]

Definition at line 112 of file FarOverNearFitLED.h.

References matrix.

Referenced by GetMatrices().

00112 {return matrix;};

double FarOverNearFitLED::GetNDBaseline (  )  [inline]

Definition at line 110 of file FarOverNearFitLED.h.

References ND_baseline.

Referenced by MCOscillated().

00110 {return ND_baseline;};

pair< TH1D *, TH1D * > FarOverNearFitLED::GetPredGhostFitter ( const NuMMParameters pars  ) 

Definition at line 839 of file FarOverNearFitLED.cxx.

References NuMMParameters::Dm2(), Form(), fTemplateFile, GetUseCC(), GetUseNC(), hGhostFitterGrid, NuMMParameters::LEDa(), NuMMParameters::LEDm0(), templateDir, and NuMMParameters::Theta23().

Referenced by ComparePredWithDataGhostFitter(), and SetFakeDataGhostFitter().

00839                                                                                   {
00840 
00841   const Int_t dimN = 4;
00842   const Int_t neighborN = 16;
00843 
00844   Double_t parList[dimN] = {pars.LEDa(), pars.LEDm0(), pars.Theta23(), pars.Dm2()};
00845   Int_t    binList[dimN];
00846   Int_t    rebinList[dimN] = {2, 2, 4, 2};
00847   Int_t    binAfterLowEdgeList[dimN];
00848   Double_t hyperEdgeList[dimN][2];      // 0 (1) for distance to low (up) edge
00849   Double_t hyperVolumeTotal = 1.;
00850 
00851   for(Int_t i = 0; i < dimN; i++){
00852     binList[i]              = hGhostFitterGrid->GetAxis(i)->FindBin(parList[i]);
00853     binAfterLowEdgeList[i]  = binList[i] - (binList[i] - 1) % rebinList[i];
00854     Double_t lowEdge        = hGhostFitterGrid->GetAxis(i)->GetBinLowEdge(binAfterLowEdgeList[i]);
00855     Int_t binAfterUpEdge    = binAfterLowEdgeList[i] + rebinList[i];
00856     Double_t upEdge         = hGhostFitterGrid->GetAxis(i)->GetBinLowEdge(binAfterUpEdge);
00857 
00858     hyperEdgeList[i][0]     = parList[i] - lowEdge; // distance to low edge
00859     hyperEdgeList[i][1]     = upEdge - parList[i];
00860     hyperVolumeTotal       *= upEdge - lowEdge;
00861   }
00862 
00863   TH1F*    hTemplateList[neighborN][2]; // 0 for CC, 1 for NC
00864   TString  templateNameList[neighborN];
00865   Double_t hyperVolumeList[neighborN];
00866 
00867   for(Int_t i = 0; i < 2; i++){
00868 
00869     delete fTemplateFile[i];
00870     fTemplateFile[i] = 0;
00871     fTemplateFile[i] = TFile::Open(templateDir + Form("/leda_%d.root", binAfterLowEdgeList[0] - (i - 1) * rebinList[0] - 1));
00872 
00873     for(Int_t j = 0; j < 2; j++)
00874       for(Int_t k = 0; k < 2; k++)
00875         for(Int_t l = 0; l < 2; l++){
00876 
00877           Int_t indexGlobal = l + k * 2 + j * 4 + i * 8;
00878           hyperVolumeList[indexGlobal] 
00879             = hyperEdgeList[0][i]
00880             * hyperEdgeList[1][j]
00881             * hyperEdgeList[2][k] 
00882             * hyperEdgeList[3][l];
00883 
00884           templateNameList[indexGlobal] = Form("%d_%d_%d_%d",
00885                                                binAfterLowEdgeList[0] - (i - 1) * rebinList[0] - 1, // i/j/k/l = 0 for up bin edge
00886                                                binAfterLowEdgeList[1] - (j - 1) * rebinList[1] - 1, // i/j/k/l = 1 for low bin edge
00887                                                binAfterLowEdgeList[2] - (k - 1) * rebinList[2] - 1,
00888                                                binAfterLowEdgeList[3] - (l - 1) * rebinList[3] - 1);
00889 
00890           hTemplateList[indexGlobal][0] = (TH1F*)fTemplateFile[i]->Get("hCC_" + templateNameList[indexGlobal]);
00891           hTemplateList[indexGlobal][1] = (TH1F*)fTemplateFile[i]->Get("hNC_" + templateNameList[indexGlobal]);
00892 
00893         }
00894   }
00895 
00896   TH1D* hInterpolatedCC = 0;
00897   TH1D* hInterpolatedNC = 0;
00898 
00899   for(Int_t i = 0; i < neighborN; i++){
00900 
00901     Double_t weight = hyperVolumeList[i] / hyperVolumeTotal;
00902     if(this->GetUseCC()){
00903       if(i == 0){
00904         hInterpolatedCC = (TH1D*)hTemplateList[i][0]->Clone("hInterpolatedCC");
00905         hInterpolatedCC->Reset();
00906       }
00907       hInterpolatedCC->Add(hTemplateList[i][0], weight);
00908     }
00909 
00910     if(this->GetUseNC()){
00911       if(i == 0){
00912         hInterpolatedNC = (TH1D*)hTemplateList[i][1]->Clone("hInterpolatedNC");
00913         hInterpolatedNC->Reset();
00914       }
00915       hInterpolatedNC->Add(hTemplateList[i][1], weight);
00916     }
00917   }
00918 
00919   pair<TH1D*, TH1D*> hInterpolated;
00920   hInterpolated.first  = hInterpolatedCC;
00921   hInterpolated.second = hInterpolatedNC;
00922 
00923   for(Int_t i = 0; i < neighborN; i++){
00924     delete hTemplateList[i][0];
00925     delete hTemplateList[i][1];
00926   }
00927 
00928   return hInterpolated;
00929 }

Bool_t FarOverNearFitLED::GetQuietMode (  )  [inline]

Definition at line 138 of file FarOverNearFitLED.h.

References quietMode.

Referenced by ComparePredWithDataGhostFitter().

00138 {return quietMode;};

bool FarOverNearFitLED::GetUseCC (  )  [inline]

Definition at line 122 of file FarOverNearFitLED.h.

References useCC.

Referenced by ComparePredWithDataGhostFitter(), and GetPredGhostFitter().

00122 {return useCC;};

bool FarOverNearFitLED::GetUseNC (  )  [inline]

Definition at line 123 of file FarOverNearFitLED.h.

References useNC.

Referenced by ComparePredWithDataGhostFitter(), and GetPredGhostFitter().

00123 {return useNC;};

void FarOverNearFitLED::Initialize (  ) 

Definition at line 438 of file FarOverNearFitLED.cxx.

References CalculateDataFarOverNearRatio(), CalculateNDIntegrals(), FluctuateFakeData(), GetHistos(), GetMatrices(), initialized, and randomSeed.

00438                                   {
00439 
00440   GetMatrices();
00441   GetHistos();
00442   CalculateDataFarOverNearRatio();
00443   CalculateNDIntegrals();
00444 
00445   if(randomSeed >= 0)
00446     FluctuateFakeData(randomSeed);
00447 
00448   initialized = true;
00449   cout << endl;
00450 }

TH1D * FarOverNearFitLED::MCOscillated ( NuXMLConfig xml_config,
whichPred  Pred,
whichDet  Det 
)

Definition at line 805 of file FarOverNearFitLED.cxx.

References MCOscillated(), and XMLtoParameters().

00806 {
00807   NuMMParameters pars = XMLtoParameters(xml_config);
00808   return MCOscillated(pars, Pred, Det);
00809 }

TH1D * FarOverNearFitLED::MCOscillated ( const NuMMParameters pars,
whichPred  Pred,
whichDet  Det 
) [virtual]

Definition at line 626 of file FarOverNearFitLED.cxx.

References CC, NuMMParameters::Delta1(), NuMMParameters::Dm2(), NuMMParameters::Dm221(), FD, FDCC_AppNue, FDCC_AppNuTau, FDCC_BeamNue, FDCC_NuMu, FDCC_TrueNC, FDNC_AppNue, FDNC_AppNuTau, FDNC_BeamNue, FDNC_NuMu, FDNC_TrueNC, GetFDBaseline(), GetNDBaseline(), Munits::km, NuOscProbCalc::LargeExtraDimensionDisappearanceWeight(), NuOscProbCalc::LargeExtraDimensionNuESurvivalProbability(), NuOscProbCalc::LargeExtraDimensionNuMuToNuEProbability(), NuOscProbCalc::LargeExtraDimensionNuMuToNuSProbability(), NuOscProbCalc::LargeExtraDimensionNuMuToNuTauProbability(), NuMMParameters::LEDa(), NuMMParameters::LEDm0(), NC, ND, NDCC_AppNue, NDCC_AppNuTau, NDCC_BeamNue, NDCC_NuMu, NDCC_TrueNC, NDNC_AppNue, NDNC_AppNuTau, NDNC_BeamNue, NDNC_NuMu, NDNC_TrueNC, oscAppNue, oscAppNuTau, oscAvgOverBinNC, oscAvgOverBinNuMu, oscBeamNue, oscIterOverBinNC, oscIterOverBinNuMu, oscNuMu, oscTrueNC, NuMMParameters::Theta12(), NuMMParameters::Theta13(), and NuMMParameters::Theta23().

Referenced by CalculateNDIntegrals(), ComparePredWithDataCC(), ComparePredWithDataNC(), FDPrediction(), MCOscillated(), and SetFakeData().

00626                                                                                              {
00627 
00628   Double_t baseline = 0;
00629   TString detName;
00630   switch (Det)
00631     {
00632     case ND:
00633       detName = "ND";
00634       break;
00635     case FD:
00636       detName = "FD";
00637       break;
00638     default:
00639       cout << "what detector???" << endl;
00640       break;
00641     }
00642 
00643   TString predName;
00644   switch (Pred)
00645     {
00646     case NC:
00647       predName = "NC";
00648       break;
00649     case CC:
00650       predName = "CC";
00651       break;
00652     default:
00653       cout << "what prediction???" << endl;
00654       break;
00655     }
00656 
00657   TH2D *TrueNC = 0;
00658   TH2D *NuMu = 0;
00659   TH2D *BeamNue = 0;
00660   TH2D *AppNue = 0;
00661   TH2D *AppNuTau = 0;
00662   switch(Det*1000+Pred)
00663     {
00664     case ND*1000+NC:
00665       TrueNC   = NDNC_TrueNC;
00666       NuMu     = NDNC_NuMu;
00667       BeamNue  = NDNC_BeamNue;
00668       AppNue   = NDNC_AppNue;
00669       AppNuTau = NDNC_AppNuTau;
00670       baseline = GetNDBaseline();
00671       break;
00672     case ND*1000+CC:
00673       TrueNC   = NDCC_TrueNC;
00674       NuMu     = NDCC_NuMu;
00675       BeamNue  = NDCC_BeamNue;
00676       AppNue   = NDCC_AppNue;
00677       AppNuTau = NDCC_AppNuTau;
00678       baseline = GetNDBaseline();
00679       break;
00680     case FD*1000+NC:
00681       TrueNC   = FDNC_TrueNC;
00682       NuMu     = FDNC_NuMu;
00683       BeamNue  = FDNC_BeamNue;
00684       AppNue   = FDNC_AppNue;
00685       AppNuTau = FDNC_AppNuTau;
00686       baseline = GetFDBaseline();
00687       break;
00688     case FD*1000+CC:
00689       TrueNC   = FDCC_TrueNC;
00690       NuMu     = FDCC_NuMu;
00691       BeamNue  = FDCC_BeamNue;
00692       AppNue   = FDCC_AppNue;
00693       AppNuTau = FDCC_AppNuTau;
00694       baseline = GetFDBaseline();
00695       break;
00696     default:
00697       cout << "what detector and what pred type???" << endl;
00698       break;
00699     }           
00700 
00701   TH1D *binTemplate = TrueNC->ProjectionY();
00702   binTemplate->Reset();
00703   oscTrueNC   = (TH1D*) binTemplate->Clone("oscTrueNC");
00704   oscNuMu     = (TH1D*) binTemplate->Clone("oscNuMu");
00705   oscBeamNue  = (TH1D*) binTemplate->Clone("oscBeamNue");
00706   oscAppNue   = (TH1D*) binTemplate->Clone("oscAppNue");
00707   oscAppNuTau = (TH1D*) binTemplate->Clone("oscAppNuTau");
00708 
00709   oscAvgOverBinNC    = (TH1D*) binTemplate->Clone("oscAvgOverBinNC");
00710   oscAvgOverBinNuMu  = (TH1D*) binTemplate->Clone("oscAvgOverBinNuMu");
00711   oscIterOverBinNC   = new TGraph();
00712   oscIterOverBinNuMu = new TGraph();
00713 
00714   TAxis *Yaxis = TrueNC->GetYaxis();
00715   TAxis *Xaxis = TrueNC->GetXaxis();
00716 
00717   for(Int_t x = 1; x <= Xaxis->GetNbins(); x++){
00718     Double_t oscWeightNC       = 0.;
00719     Double_t oscWeightNuMu     = 0.;
00720     Double_t oscWeightBeamNue  = 0.;
00721     Double_t oscWeightAppNue   = 0.;
00722     Double_t oscWeightAppNuTau = 0.;
00723 
00724     if(baseline > 0){
00725 
00726       const Int_t n_LoverE = 4; 
00727       Double_t energy = 1.;
00728 
00729       for(int i = 0; i < n_LoverE; i++){
00730 
00731         Double_t LoverE = Xaxis->GetBinLowEdge(x) + ((Double_t)i + 0.5) / (Double_t)n_LoverE * Xaxis->GetBinWidth(x);
00732         Double_t baseLine = LoverE * energy * Munits::km;
00733 
00734         oscWeightNC += NuOscProbCalc::LargeExtraDimensionNuMuToNuSProbability(pars.Theta12(), pars.Theta13(), pars.Theta23(),
00735                                                                               pars.Delta1(),
00736                                                                               pars.Dm221(), pars.Dm2(),
00737                                                                               pars.LEDm0(), pars.LEDa(),
00738                                                                               energy, baseLine);
00739       
00740         oscWeightNuMu += NuOscProbCalc::LargeExtraDimensionDisappearanceWeight(pars.Theta12(), pars.Theta13(), pars.Theta23(),
00741                                                                                pars.Delta1(),
00742                                                                                pars.Dm221(), pars.Dm2(),
00743                                                                                pars.LEDm0(), pars.LEDa(),
00744                                                                                energy, baseLine);
00745 
00746         oscWeightBeamNue += NuOscProbCalc::LargeExtraDimensionNuESurvivalProbability(pars.Theta12(), pars.Theta13(), pars.Theta23(),
00747                                                                                      pars.Delta1(),
00748                                                                                      pars.Dm221(), pars.Dm2(),
00749                                                                                      pars.LEDm0(), pars.LEDa(),
00750                                                                                      energy, baseLine);
00751                                 
00752         oscWeightAppNue += NuOscProbCalc::LargeExtraDimensionNuMuToNuEProbability(pars.Theta12(), pars.Theta13(), pars.Theta23(),
00753                                                                                   pars.Delta1(),
00754                                                                                   pars.Dm221(), pars.Dm2(),
00755                                                                                   pars.LEDm0(), pars.LEDa(),
00756                                                                                   energy, baseLine);
00757 
00758         oscWeightAppNuTau += NuOscProbCalc::LargeExtraDimensionNuMuToNuTauProbability(pars.Theta12(), pars.Theta13(), pars.Theta23(),
00759                                                                                       pars.Delta1(),
00760                                                                                       pars.Dm221(), pars.Dm2(),
00761                                                                                       pars.LEDm0(), pars.LEDa(),
00762                                                                                       energy, baseLine);
00763       }
00764 
00765       oscWeightNC       /= n_LoverE;
00766       oscWeightNuMu     /= n_LoverE;
00767       oscWeightBeamNue  /= n_LoverE;
00768       oscWeightAppNue   /= n_LoverE;
00769       oscWeightAppNuTau /= n_LoverE;    
00770     }
00771     else{
00772       oscWeightNC       = 0.;
00773       oscWeightNuMu     = 1.;
00774       oscWeightBeamNue  = 1.;
00775       oscWeightAppNue   = 0.;
00776       oscWeightAppNuTau = 0.;
00777     }
00778 
00779     oscAvgOverBinNC->SetBinContent(x, oscWeightNC);
00780     oscAvgOverBinNuMu->SetBinContent(x, oscWeightNuMu);
00781                                                 
00782     for(Int_t y = 1; y <= Yaxis->GetNbins(); y++){
00783       oscTrueNC->AddBinContent(  y,   TrueNC->GetBinContent(x, y) * (1. - oscWeightNC));
00784       oscNuMu->AddBinContent(    y,     NuMu->GetBinContent(x, y) * oscWeightNuMu);
00785       oscBeamNue->AddBinContent( y,  BeamNue->GetBinContent(x, y) * oscWeightBeamNue);
00786       oscAppNue->AddBinContent(  y,   AppNue->GetBinContent(x, y) * oscWeightAppNue);
00787       oscAppNuTau->AddBinContent(y, AppNuTau->GetBinContent(x, y) * oscWeightAppNuTau);
00788     }
00789   } 
00790 
00791   TString oscSumName = "oscSum_";
00792   oscSumName += detName;
00793   oscSumName += predName;
00794 
00795   TH1D *oscSum = (TH1D*)oscTrueNC->Clone(oscSumName);
00796   oscSum->Add(oscNuMu);
00797   oscSum->Add(oscBeamNue);
00798   oscSum->Add(oscAppNue);
00799   oscSum->Add(oscAppNuTau);
00800 
00801   return oscSum;
00802 }

Double_t FarOverNearFitLED::NDNormPenaltyTerm ( TString  Type  ) 

Definition at line 550 of file FarOverNearFitLED.cxx.

References fluxUncertainty, NDOscCC_MC, NDOscNC_MC, TotalNDCC, TotalNDDataCC, TotalNDDataNC, and TotalNDNC.

Referenced by ComparePredWithDataCC(), and ComparePredWithDataNC().

00551 {
00552   Double_t UnOsc = 0.0;
00553   Double_t TotalNDData = 0.0;
00554   Double_t TotalOscNDMC = 0.0;
00555 
00556   if(Type == "CC"){
00557     UnOsc = TotalNDCC;
00558     TotalNDData = TotalNDDataCC;
00559     TotalOscNDMC = NDOscCC_MC->Integral(1, NDOscCC_MC->FindFixBin(40));
00560   }
00561 
00562   if(Type == "NC"){
00563     UnOsc = TotalNDNC;
00564     TotalNDData = TotalNDDataNC;
00565     TotalOscNDMC = NDOscNC_MC->Integral(1, NDOscNC_MC->FindFixBin(40));
00566   }
00567 
00568   Double_t sigma = fluxUncertainty * UnOsc;
00569   Double_t Norm = (TotalNDData - TotalOscNDMC) * (TotalNDData - TotalOscNDMC);
00570   Norm = Norm / (sigma * sigma);
00571 
00572   return Norm;
00573 }

TH1D * FarOverNearFitLED::Rebin4Chi ( TH1D *  Orig,
whichPred  Pred 
)

Definition at line 267 of file FarOverNearFitLED.cxx.

References binningFit, CC, MuELoss::e, LE, ME, and NC.

Referenced by CalculateDataFarOverNearRatio(), ComparePredWithDataCC(), and ComparePredWithDataNC().

00268 {
00269 
00270   Double_t edges[300];
00271   edges[0] = 0;
00272   Int_t nbins = 1;
00273   
00274   if(binningFit == LE){
00275     if(Pred == CC){
00276       edges[nbins] = 2; nbins++; Double_t binWidth = 0.25;
00277       while(edges[nbins-1] < 5-1e-3 ){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00278       binWidth = 0.5;
00279       while(edges[nbins-1] < 15-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00280       binWidth = 1.00;
00281       while(edges[nbins-1] < 20-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00282       binWidth = 2.0;
00283       while(edges[nbins-1] < 30-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00284       binWidth = 2.0;
00285       while(edges[nbins-1] < 40-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00286     }
00287 
00288     if(Pred == NC){
00289       edges[nbins] = 0.5; nbins++; Double_t binWidth = 0.25;
00290       while(edges[nbins-1] < 5-1e-3 ){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00291       binWidth = 4;
00292       while(edges[nbins-1] < 20-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00293       binWidth = 19.00;
00294       while(edges[nbins-1] < 40-1e-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00295     }
00296   }
00297   else if(binningFit == ME){
00298     if(Pred == CC){
00299       edges[nbins] = 1.75; 
00300       nbins++; 
00301       Double_t binWidth = 0.25;
00302       while(edges[nbins-1] < 15. - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00303       binWidth = 1.;
00304       while(edges[nbins-1] < 30. - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00305       binWidth = 2.;
00306       while(edges[nbins-1] < 40. - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00307     }
00308     if(Pred == NC){
00309       edges[nbins] = 0.75; 
00310       nbins++; 
00311       Double_t binWidth = 0.25;
00312       while(edges[nbins-1] < 8.  - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00313       binWidth = 2.;
00314       while(edges[nbins-1] < 20. - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00315       binWidth = 10.;
00316       while(edges[nbins-1] < 40. - 1.E-3){ edges[nbins] = edges[nbins-1] + binWidth; nbins++;}
00317     }
00318   }
00319   else{
00320     cout << "binning scheme error" << endl;
00321     abort();
00322   }
00323   edges[nbins] = 200;
00324   
00325   return  (TH1D*)Orig->Rebin(nbins,"",edges); 
00326 }

void FarOverNearFitLED::SetBinningScheme ( BinningScheme  b  )  [inline]

Definition at line 134 of file FarOverNearFitLED.h.

References binningFit.

00134 {binningFit = b;};

void FarOverNearFitLED::SetFakeData ( const NuMMParameters  pars,
Int_t  randomSeed 
)

Definition at line 932 of file FarOverNearFitLED.cxx.

References CalculateDataFarOverNearRatio(), CalculateNDIntegrals(), CC, FD, FD_dataCC, FD_dataNC, FluctuateFakeData(), MCOscillated(), NC, ND, ND_dataCC, and ND_dataNC.

00932                                                                               {
00933 
00934   ND_dataCC = MCOscillated(pars, CC, ND);
00935   FD_dataCC = MCOscillated(pars, CC, FD);
00936   ND_dataNC = MCOscillated(pars, NC, ND);
00937   FD_dataNC = MCOscillated(pars, NC, FD);
00938   CalculateDataFarOverNearRatio();
00939   CalculateNDIntegrals();
00940   FluctuateFakeData(randomSeed);
00941   cout << "SetFakeData done" << endl;
00942 }

void FarOverNearFitLED::SetFakeDataFluctuation ( Int_t  seed  )  [inline]

Definition at line 121 of file FarOverNearFitLED.h.

References randomSeed.

00121 {randomSeed = seed;};

void FarOverNearFitLED::SetFakeDataGhostFitter ( NuMMParameters  pars,
Int_t  randomSeed 
)

Definition at line 945 of file FarOverNearFitLED.cxx.

References FluctuateFakeData(), GetPredGhostFitter(), RdataCC, and RdataNC.

00945                                                                                    {
00946 
00947   pair<TH1D*, TH1D*> hInterpolated = GetPredGhostFitter(pars);
00948   delete RdataCC;
00949   delete RdataNC;
00950   RdataCC = hInterpolated.first;
00951   RdataCC->SetDirectory(0);
00952   RdataNC = hInterpolated.second;
00953   RdataNC->SetDirectory(0);
00954 
00955   FluctuateFakeData(randomSeed);
00956   cout << "SetFakeDataGhostFitter done" << endl;
00957 }

void FarOverNearFitLED::SetFDBaseline ( double  baseline  ) 

Definition at line 104 of file FarOverNearFitLED.cxx.

References FD_baseline.

00105 {
00106   FD_baseline = baseline;
00107 }

void FarOverNearFitLED::SetFDData ( TFile *  Data_file  ) 

Definition at line 94 of file FarOverNearFitLED.cxx.

References FD_data.

00095 {
00096   FD_data = Data_file;
00097 }

void FarOverNearFitLED::SetFDMC ( TFile *  MC_file,
TFile *  Nue_file,
TFile *  NuTau_file 
)

Definition at line 86 of file FarOverNearFitLED.cxx.

References FD_MC, FD_Nue, and FD_NuTau.

00087 {
00088   FD_MC    = MC_file;
00089   FD_Nue   = Nue_file;
00090   FD_NuTau = NuTau_file;
00091 }

void FarOverNearFitLED::SetFluxUncertainty ( double  err  )  [inline]

Definition at line 114 of file FarOverNearFitLED.h.

References fluxUncertainty.

00114                                      {
00115     fluxUncertainty = err;
00116     std::cout << "fluxUncertainty = " << fluxUncertainty << std::endl;
00117   };

void FarOverNearFitLED::SetGhostFitterGrid ( THnSparseF *  h1  )  [inline]

Definition at line 143 of file FarOverNearFitLED.h.

References hGhostFitterGrid.

00143 {hGhostFitterGrid = h1;};

void FarOverNearFitLED::SetInitialized ( bool  i  )  [inline]

Definition at line 139 of file FarOverNearFitLED.h.

References initialized.

00139 {initialized = i;};

void FarOverNearFitLED::SetLowEnergyCutoffNC ( Double_t  cutoff  )  [inline]

Definition at line 136 of file FarOverNearFitLED.h.

References lowEnergyCutoffNC.

00136 {lowEnergyCutoffNC = cutoff;};

void FarOverNearFitLED::SetMatrices ( TFile *  Data_file  ) 

Definition at line 99 of file FarOverNearFitLED.cxx.

References matrix.

00100 {
00101   matrix = Data_file;
00102 }

void FarOverNearFitLED::SetNDBaseline ( double  baseline  ) 

Definition at line 80 of file FarOverNearFitLED.cxx.

References ND_baseline.

00081 {
00082   ND_baseline = baseline;
00083 }

void FarOverNearFitLED::SetNDData ( TFile *  Data_file  ) 

Definition at line 74 of file FarOverNearFitLED.cxx.

References ND_data.

00075 {
00076   ND_data = Data_file;
00077 }

void FarOverNearFitLED::SetNDMC ( TFile *  MC_file,
TFile *  Nue_file,
TFile *  NuTau_file 
)

Definition at line 66 of file FarOverNearFitLED.cxx.

References ND_MC, ND_Nue, and ND_NuTau.

00067 {
00068   ND_MC    = MC_file;
00069   ND_Nue   = Nue_file;
00070   ND_NuTau = NuTau_file;
00071 }

void FarOverNearFitLED::SetPOT ( double  POT_  ) 

Definition at line 110 of file FarOverNearFitLED.cxx.

00111 {
00112   POT = POT_;
00113 }

void FarOverNearFitLED::SetQuietMode ( bool  quiet  )  [inline]

Definition at line 133 of file FarOverNearFitLED.h.

References quietMode.

00133 {quietMode = quiet;};

void FarOverNearFitLED::SetTemplateDir ( TString  dir  )  [inline]

Definition at line 144 of file FarOverNearFitLED.h.

References templateDir.

00144 {templateDir = dir;};

void FarOverNearFitLED::SetUseCC ( bool  use  )  [inline]

Definition at line 118 of file FarOverNearFitLED.h.

References useCC.

00118 {useCC = use;};

void FarOverNearFitLED::SetUseGhostFitter ( bool  use  )  [inline]

Definition at line 120 of file FarOverNearFitLED.h.

References useGhostFitter.

00120 {useGhostFitter = use;};

void FarOverNearFitLED::SetUseNC ( bool  use  )  [inline]

Definition at line 119 of file FarOverNearFitLED.h.

References useNC.

00119 {useNC = use;};

NuMMParameters FarOverNearFitLED::UnOscillatedPars (  )  [virtual]

Definition at line 811 of file FarOverNearFitLED.cxx.

References NuMMParameters::Delta1(), NuMMParameters::Dm2(), NuMMParameters::Dm221(), NuMMParameters::LEDa(), NuMMParameters::LEDm0(), NuMMParameters::Theta12(), NuMMParameters::Theta13(), and NuMMParameters::Theta23().

Referenced by CalculateNDIntegrals().

00812 {
00813   NuMMParameters pars;
00814   pars.Dm2(0.0);
00815   pars.Dm221(0.0);
00816   pars.Theta23(0.0);
00817   pars.Theta13(0.0);
00818   pars.Theta12(0.0);
00819   pars.Delta1(0.0);
00820   pars.LEDm0(0.);
00821   pars.LEDa(1.E-9);
00822 
00823   return pars;
00824 }

std::vector< TH1D > FarOverNearFitLED::WriteFDPredHistos ( const NuMMParameters pars  )  const [virtual]

Implements NuMMRun.

Definition at line 576 of file FarOverNearFitLED.cxx.

00577 {
00578   return vector<TH1D>();
00579 }

NuMMParameters FarOverNearFitLED::XMLtoParameters ( NuXMLConfig xml_config  )  [private, virtual]

Definition at line 826 of file FarOverNearFitLED.cxx.

References NuMMParameters::Delta1(), NuXMLConfig::Delta1(), NuMMParameters::Dm2(), NuMMParameters::Dm221(), NuXMLConfig::DM221(), NuXMLConfig::DM2Nu(), NuXMLConfig::Theta12(), NuMMParameters::Theta12(), NuXMLConfig::Theta13(), NuMMParameters::Theta13(), NuMMParameters::Theta23(), and NuXMLConfig::Theta23().

Referenced by FDPrediction(), and MCOscillated().

00827 {
00828   NuMMParameters pars;
00829   pars.Dm2(     xml_config->DM2Nu());
00830   pars.Theta23( xml_config->Theta23());
00831   pars.Dm221(   xml_config->DM221());
00832   pars.Delta1(  xml_config->Delta1());
00833   pars.Theta12( xml_config->Theta12());
00834   pars.Theta13( xml_config->Theta13());
00835   return pars;
00836 }


Member Data Documentation

Definition at line 173 of file FarOverNearFitLED.h.

Referenced by GetBinningScheme(), Rebin4Chi(), and SetBinningScheme().

Definition at line 79 of file FarOverNearFitLED.h.

Referenced by FluctuateFakeData(), and GetMatrices().

Definition at line 80 of file FarOverNearFitLED.h.

Referenced by FluctuateFakeData(), and GetMatrices().

Definition at line 157 of file FarOverNearFitLED.h.

Referenced by GetFDBaseline(), and SetFDBaseline().

TFile * FarOverNearFitLED::FD_data [private]

Definition at line 160 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetFDData().

Definition at line 101 of file FarOverNearFitLED.h.

Referenced by Add(), CalculateDataFarOverNearRatio(), GetHistos(), and SetFakeData().

Definition at line 101 of file FarOverNearFitLED.h.

Referenced by Add(), CalculateDataFarOverNearRatio(), GetHistos(), and SetFakeData().

TFile* FarOverNearFitLED::FD_MC [private]

Definition at line 160 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetFDMC().

Definition at line 90 of file FarOverNearFitLED.h.

Referenced by GetHistos().

TFile * FarOverNearFitLED::FD_Nue [private]

Definition at line 160 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetFDMC().

Definition at line 90 of file FarOverNearFitLED.h.

Referenced by GetHistos().

TFile * FarOverNearFitLED::FD_NuTau [private]

Definition at line 160 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetFDMC().

Definition at line 90 of file FarOverNearFitLED.h.

Referenced by GetHistos().

Definition at line 98 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 98 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 98 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 98 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 98 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 97 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 97 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 97 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 97 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 97 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 104 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataCC().

Definition at line 104 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataNC().

Definition at line 164 of file FarOverNearFitLED.h.

Referenced by NDNormPenaltyTerm(), and SetFluxUncertainty().

TFile* FarOverNearFitLED::fTemplateFile[2] [private]

Definition at line 153 of file FarOverNearFitLED.h.

Referenced by GetPredGhostFitter().

THnSparseF* FarOverNearFitLED::hGhostFitterGrid [private]

Definition at line 152 of file FarOverNearFitLED.h.

Referenced by GetPredGhostFitter(), and SetGhostFitterGrid().

Definition at line 170 of file FarOverNearFitLED.h.

Referenced by ComparePredWithData(), Initialize(), and SetInitialized().

TFile* FarOverNearFitLED::matrix [private]

Definition at line 161 of file FarOverNearFitLED.h.

Referenced by GetMatrices(), GetMatrixTFile(), and SetMatrices().

Definition at line 156 of file FarOverNearFitLED.h.

Referenced by GetNDBaseline(), and SetNDBaseline().

TFile * FarOverNearFitLED::ND_data [private]

Definition at line 159 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetNDData().

Definition at line 89 of file FarOverNearFitLED.h.

Referenced by GetHistos().

TFile* FarOverNearFitLED::ND_MC [private]

Definition at line 159 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetNDMC().

Definition at line 89 of file FarOverNearFitLED.h.

Referenced by GetHistos().

TFile * FarOverNearFitLED::ND_Nue [private]

Definition at line 159 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetNDMC().

Definition at line 89 of file FarOverNearFitLED.h.

Referenced by GetHistos().

TFile * FarOverNearFitLED::ND_NuTau [private]

Definition at line 159 of file FarOverNearFitLED.h.

Referenced by GetHistos(), and SetNDMC().

Definition at line 89 of file FarOverNearFitLED.h.

Referenced by GetHistos().

Definition at line 94 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 94 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 94 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 94 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 94 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 93 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 93 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 93 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 93 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 93 of file FarOverNearFitLED.h.

Referenced by Add(), GetHistos(), and MCOscillated().

Definition at line 104 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataCC(), and NDNormPenaltyTerm().

Definition at line 104 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataNC(), and NDNormPenaltyTerm().

Definition at line 85 of file FarOverNearFitLED.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 86 of file FarOverNearFitLED.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 71 of file FarOverNearFitLED.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 72 of file FarOverNearFitLED.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 84 of file FarOverNearFitLED.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 73 of file FarOverNearFitLED.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 74 of file FarOverNearFitLED.h.

Referenced by cleanup(), and MCOscillated().

Definition at line 83 of file FarOverNearFitLED.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

Definition at line 82 of file FarOverNearFitLED.h.

Referenced by cleanup(), FDPrediction(), and MCOscillated().

double FarOverNearFitLED::POT [private]

Definition at line 163 of file FarOverNearFitLED.h.

Definition at line 171 of file FarOverNearFitLED.h.

Referenced by Initialize(), and SetFakeDataFluctuation().

Definition at line 105 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataCC().

Definition at line 105 of file FarOverNearFitLED.h.

Referenced by ComparePredWithDataNC().

TString FarOverNearFitLED::templateDir [private]

Definition at line 154 of file FarOverNearFitLED.h.

Referenced by GetPredGhostFitter(), and SetTemplateDir().

Definition at line 108 of file FarOverNearFitLED.h.

Referenced by CalculateNDIntegrals(), and NDNormPenaltyTerm().

Definition at line 165 of file FarOverNearFitLED.h.

Referenced by CalculateNDIntegrals(), and NDNormPenaltyTerm().

Definition at line 166 of file FarOverNearFitLED.h.

Referenced by CalculateNDIntegrals(), and NDNormPenaltyTerm().

Definition at line 108 of file FarOverNearFitLED.h.

Referenced by CalculateNDIntegrals(), and NDNormPenaltyTerm().

bool FarOverNearFitLED::useCC [private]

Definition at line 167 of file FarOverNearFitLED.h.

Referenced by ComparePredWithData(), GetUseCC(), and SetUseCC().

Definition at line 169 of file FarOverNearFitLED.h.

Referenced by ComparePredWithData(), and SetUseGhostFitter().

bool FarOverNearFitLED::useNC [private]

Definition at line 168 of file FarOverNearFitLED.h.

Referenced by ComparePredWithData(), GetUseNC(), and SetUseNC().


The documentation for this class was generated from the following files:

Generated on 22 Nov 2017 for loon by  doxygen 1.6.1