AtNuEventCounter Class Reference

#include <AtNuEventCounter.h>

List of all members.

Public Member Functions

 AtNuEventCounter ()
 ~AtNuEventCounter ()
void AddData (AtNuCounter::TrueEventType_t fileType, const char *file, Double_t ktyrs=0, Int_t Nevents=-1)
void Fill (AtNuCounter::TrueEventType_t trueType, AtNuCounter::AtmosNumuCVType_t atmosNumuCVType, AtNuCounter::AtmosNumuUPType_t atmosNumuUPType, AtNuCounter::AtmosNueCVType_t atmosNueCVType, AtNuCounter::AtmosEventType_t atmosType, AtNuCounter::SelectedEventType_t selectedType, Double_t weight)
Double_t GetCount (AtNuCounter::TrueEventType_t trueType, AtNuCounter::AtmosNumuCVType_t cutType)
Double_t GetCount (AtNuCounter::TrueEventType_t trueType, AtNuCounter::AtmosNumuUPType_t cutType)
Double_t GetCount (AtNuCounter::TrueEventType_t trueType, AtNuCounter::AtmosNueCVType_t cutType)
Double_t GetCount (AtNuCounter::TrueEventType_t trueType, AtNuCounter::AtmosEventType_t atmosType)
Double_t GetCount (AtNuCounter::TrueEventType_t trueType, AtNuCounter::SelectedEventType_t selectedType)
Double_t GetObservedCount (AtNuCounter::AtmosNumuCVType_t cutType)
Double_t GetExpectedCount (AtNuCounter::AtmosNumuCVType_t cutType)
Double_t GetObservedCount (AtNuCounter::AtmosNumuUPType_t cutType)
Double_t GetExpectedCount (AtNuCounter::AtmosNumuUPType_t cutType)
Double_t GetObservedCount (AtNuCounter::AtmosNueCVType_t cutType)
Double_t GetExpectedCount (AtNuCounter::AtmosNueCVType_t cutType)
Double_t GetObservedCount (AtNuCounter::AtmosEventType_t atmosType)
Double_t GetExpectedCount (AtNuCounter::AtmosEventType_t atmosType)
Double_t GetObservedCount (AtNuCounter::SelectedEventType_t selectedType)
Double_t GetExpectedCount (AtNuCounter::SelectedEventType_t selectedType)
Double_t GetObservedCount ()
Double_t GetExpectedCount ()
void PrintCount ()
void SetOscillations (Double_t dmsq, Double_t sinsq, Double_t sinsq13, Int_t hier)
void SetOscillations (Double_t dmsq, Double_t sinsq)
void SetKtYrs (Double_t ktyrs)
void SetShieldSignalRate (Double_t rate)
void SetShieldBackgroundRate (Double_t rate)
void DoProductionHeights (Bool_t doheights=1)
void ReDoProductionHeights (Bool_t doheights=1)
void DoSolarCycleWeights (Bool_t doweights=1)
void ReDoSolarCycleWeights (Bool_t doweights=1)
void DoFluxWeights (Bool_t doweights=1)
void ReDoFluxWeights (Bool_t doweights=1)
void ReweightToBartol ()
void ReweightToFluka ()
void ReweightToHonda ()
void SetFluxType (AtNuFlux::FluxType_t fluxType)
void SetTimePeriod (Int_t mintime, Int_t maxtime)
void UseFullNtuples (Bool_t yesno=1)
void WriteTemplates (const char *filename)
void Reset ()
void ResetChain ()

Private Member Functions

void FillTemplates (AtNuCounter::TrueEventType_t datatype, AtNuResolutionEventType::AtNuResolutionEventType_t eventtype, AtNuResolutionType::AtNuResolutionType_t resolutiontype, Double_t fillLogLE, Double_t fillWeight, Int_t updn, Int_t chg)

Private Attributes

Int_t unixtime
Int_t simflag
Int_t index
Int_t idnu
Int_t idact
Int_t idres
Double_t enu
Double_t pnux
Double_t pnuy
Double_t pnuz
Int_t goodslice
Int_t goodevent
Int_t goodtrack
Int_t goodshower
Int_t cv
Int_t ce
Int_t fc
Int_t pc
Int_t upmu
Int_t veto
Int_t spill
Int_t goodshield
Int_t gooddirection
Int_t goodenergy
Int_t goodcharge
Int_t positivecharge
Int_t negativecharge
Int_t atmosnumu
Int_t atmosnumucv
Int_t atmosnumuup
Int_t atmosnue
Int_t atmosnumucvcut1
Int_t atmosnumucvcut2
Int_t atmosnumucvcut3
Int_t atmosnumucvcut4
Int_t atmosnumuupcut1
Int_t atmosnumuupcut2
Int_t atmosnumuupcut3
Int_t atmosnumuupcut4
Int_t atmosnuecvcut1
Int_t atmosnuecvcut2
Int_t atmosnuecvcut3
Int_t atmosnuecvcut4
Int_t evttrkreco
Double_t evttrkemcharge
Double_t evttrkprange
Double_t evttrkpcurve
Double_t evttrkdiru
Double_t evttrkdirv
Double_t evttrkdirx
Double_t evttrkdiry
Double_t evttrkdirz
Int_t evtshwreco
Double_t evtshwdiru
Double_t evtshwdirv
Double_t evtshwdirx
Double_t evtshwdiry
Double_t evtshwdirz
Double_t evtshwgevlin
Double_t evtshwgevdwgt
Double_t evtvtxtime
Double_t evtvtxu
Double_t evtvtxv
Double_t evtvtxx
Double_t evtvtxy
Double_t evtvtxz
Int_t evtvtxplane
Int_t evttrkplanes
Int_t evtshwplanes
Double_t trueheight
Double_t truelength
Double_t trueemu
Double_t trueeshw
Double_t recolength
Double_t recoenu
Double_t recoemu
Double_t recoeshwlin
Double_t recoeshwdwgt
Double_t recoeshwnue
Int_t lores
Int_t hires1
Int_t hires2
Int_t hires3
Int_t hires4
Double_t solarweight
Double_t fluxcvupratio
Double_t fluxelmuratio
Bool_t fDoProductionHeights
Bool_t fReDoProductionHeights
Bool_t fDoSolarCycleWeights
Bool_t fReDoSolarCycleWeights
Bool_t fDoFluxWeights
Bool_t fReDoFluxWeights
Bool_t fReweightToFluka
Bool_t fReweightToHonda
Bool_t fUseFullNtuples
Double_t fKtYrsData
Double_t fShieldBkgRate
Double_t fShieldSigRate
Double_t fDmsq
Double_t fSinsq
Double_t fSinsq13
Int_t fHierarchy
Int_t fUseThreeFlavours
TChain * fChainData
Int_t fNumAtmosNumuCVBins
Int_t fNumAtmosNumuUPBins
Int_t fNumAtmosNueCVBins
Int_t fNumTrueBins
Int_t fNumAtmosBins
Int_t fNumSelectedBins
Double_t * fCtrAtmosNumuCV
Double_t * fCtrAtmosNumuUP
Double_t * fCtrAtmosNueCV
Double_t * fCtrAtmos
Double_t * fCtrSelected
AtNuOscillatefOscillator
AtNuOscFitTemplatefTemplateData
AtNuOscFitTemplatefTemplateMC

Detailed Description

Definition at line 14 of file AtNuEventCounter.h.


Constructor & Destructor Documentation

AtNuEventCounter::AtNuEventCounter (  ) 

Definition at line 14 of file AtNuEventCounter.cxx.

References AtNuCounter::GetNumAtmosBins(), AtNuCounter::GetNumAtmosNueCVBins(), AtNuCounter::GetNumAtmosNumuCVBins(), AtNuCounter::GetNumAtmosNumuUPBins(), AtNuCounter::GetNumSelectedBins(), AtNuCounter::GetNumTrueBins(), and AtNuTemplateType::kAtmosData.

00015 {
00016   std::cout << " *** AtNuEventCounter::AtNuEventCounter() *** " << std::endl;  
00017 
00018   // normalisation
00019   fKtYrsData = 0.0;
00020 
00021   // oscillations
00022   fDmsq = 0.0; 
00023   fSinsq = 0.0;
00024   fSinsq13 = 0.0;
00025 
00026   fHierarchy = 0;    
00027   fUseThreeFlavours = 0;    
00028 
00029   // veto shield
00030   fShieldSigRate = 1.0;
00031   fShieldBkgRate = 0.0;
00032 
00033   // settings
00034   fDoProductionHeights = 1;
00035   fReDoProductionHeights = 0;
00036   fDoSolarCycleWeights = 1;
00037   fReDoSolarCycleWeights = 0;
00038   fDoFluxWeights = 1;
00039   fReDoFluxWeights = 0;
00040 
00041   // use full ntuples
00042   fUseFullNtuples = 0;
00043 
00044   // switch flux model
00045   fReweightToFluka = 0;
00046   fReweightToHonda = 0;
00047 
00048   // inputted data
00049   fChainData = new TChain("ntuple","chainData");
00050 
00051   // event counter (binning)
00052   fNumAtmosNumuCVBins = AtNuCounter::GetNumAtmosNumuCVBins();
00053   fNumAtmosNumuUPBins = AtNuCounter::GetNumAtmosNumuUPBins();
00054   fNumAtmosNueCVBins = AtNuCounter::GetNumAtmosNueCVBins();
00055 
00056   fNumTrueBins = AtNuCounter::GetNumTrueBins();
00057   fNumAtmosBins = AtNuCounter::GetNumAtmosBins();
00058   fNumSelectedBins = AtNuCounter::GetNumSelectedBins();
00059 
00060   // event counter (array)
00061   fCtrAtmosNumuCV = new Double_t[fNumTrueBins*fNumAtmosNumuCVBins];
00062   fCtrAtmosNumuUP = new Double_t[fNumTrueBins*fNumAtmosNumuUPBins];
00063   fCtrAtmosNueCV  = new Double_t[fNumTrueBins*fNumAtmosNueCVBins];
00064 
00065   fCtrAtmos    = new Double_t[fNumTrueBins*fNumAtmosBins];
00066   fCtrSelected = new Double_t[fNumTrueBins*fNumSelectedBins];
00067 
00068   // three-flavour oscillations
00069   fOscillator = new AtNuOscillate();
00070   
00071   // initiliaze template
00072   fTemplateData = new AtNuOscFitTemplate(AtNuTemplateType::kAtmosData,25,-0.5,+4.5,0);;
00073   fTemplateMC   = new AtNuOscFitTemplate(AtNuTemplateType::kAtmosData,25,-0.5,+4.5,0);;
00074 
00075   // reset
00076   this->Reset();
00077 }

AtNuEventCounter::~AtNuEventCounter (  ) 

Definition at line 79 of file AtNuEventCounter.cxx.

References fCtrAtmos, fCtrAtmosNueCV, fCtrAtmosNumuCV, fCtrAtmosNumuUP, fCtrSelected, and fOscillator.

00080 {
00081   std::cout << " *** AtNuEventCounter::~AtNuEventCounter() *** " << std::endl;    
00082 
00083   delete [] fCtrAtmosNumuCV;
00084   delete [] fCtrAtmosNumuUP;
00085   delete [] fCtrAtmosNueCV;
00086 
00087   delete [] fCtrAtmos;
00088   delete [] fCtrSelected;
00089 
00090   delete fOscillator;
00091 }


Member Function Documentation

void AtNuEventCounter::AddData ( AtNuCounter::TrueEventType_t  fileType,
const char *  file,
Double_t  ktyrs = 0,
Int_t  Nevents = -1 
)

Definition at line 275 of file AtNuEventCounter.cxx.

References atmosnue, atmosnuecvcut1, atmosnuecvcut2, atmosnuecvcut3, atmosnuecvcut4, atmosnumu, atmosnumucv, atmosnumucvcut1, atmosnumucvcut2, atmosnumucvcut3, atmosnumucvcut4, atmosnumuup, atmosnumuupcut1, atmosnumuupcut2, atmosnumuupcut3, atmosnumuupcut4, AtNuOscillate::DoMatterEffects(), MuELoss::e, enu, evttrkdiry, fc, fChainData, fDmsq, fDoFluxWeights, fDoProductionHeights, fDoSolarCycleWeights, fHierarchy, Fill(), FillTemplates(), fKtYrsData, AtNuOsc::FlatProdHeight(), fluxcvupratio, fluxelmuratio, fOscillator, fReDoFluxWeights, fReDoProductionHeights, fReDoSolarCycleWeights, fReweightToFluka, fReweightToHonda, fShieldBkgRate, fShieldSigRate, fSinsq, fSinsq13, fUseThreeFlavours, SolarCycleRW::GenTime(), AtNuFluxRW::GetBartolFlavourRatio(), AtNuFluxRW::GetBartolFluxRatio(), AtNuFluxRW::GetFlukaFluxRatio(), AtNuFluxRW::GetHondaFluxRatio(), goodcharge, gooddirection, goodevent, hires1, hires2, hires3, hires4, idact, idnu, index, AtNuFluxRW::Instance(), SolarCycleRW::Instance(), AtNuCounter::kAtmosCV, AtNuCounter::kAtmosNue, AtNuCounter::kAtmosNueCVcut0, AtNuCounter::kAtmosNueCVcut1, AtNuCounter::kAtmosNueCVcut2, AtNuCounter::kAtmosNueCVcut3, AtNuCounter::kAtmosNueCVcut4, AtNuCounter::kAtmosNumuCVcut0, AtNuCounter::kAtmosNumuCVcut1, AtNuCounter::kAtmosNumuCVcut2, AtNuCounter::kAtmosNumuCVcut3, AtNuCounter::kAtmosNumuCVcut4, AtNuCounter::kAtmosNumuCVOnly_FC, AtNuCounter::kAtmosNumuCVOnly_PC, AtNuCounter::kAtmosNumuCVOnly_RAF, AtNuCounter::kAtmosNumuCVUP_FC, AtNuCounter::kAtmosNumuCVUP_PC, AtNuCounter::kAtmosNumuCVUP_RAF, AtNuCounter::kAtmosNumuUPcut0, AtNuCounter::kAtmosNumuUPcut1, AtNuCounter::kAtmosNumuUPcut2, AtNuCounter::kAtmosNumuUPcut3, AtNuCounter::kAtmosNumuUPcut4, AtNuCounter::kAtmosNumuUPOnly_FC, AtNuCounter::kAtmosNumuUPOnly_PC, AtNuCounter::kAtmosNumuUPOnly_RAF, AtNuCounter::kAtmosUpMu, AtNuCounter::kBackground, AtNuCounter::kCosmic, AtNuResolutionEventType::kCV, AtNuCounter::kCVCCNue, AtNuCounter::kCVCCNumuNeg, AtNuCounter::kCVCCNumuPos, AtNuCounter::kCVCCNutau, AtNuCounter::kCVNC, AtNuCounter::kData, AtNuCounter::kFCDownAmbig, AtNuCounter::kFCDownNeg, AtNuCounter::kFCDownPos, AtNuCounter::kFCLoRes, AtNuCounter::kFCPCNue, AtNuCounter::kFCUpAmbig, AtNuCounter::kFCUpNeg, AtNuCounter::kFCUpPos, AtNuResolutionType::kHiRes1, AtNuResolutionType::kHiRes2, AtNuResolutionType::kHiRes3, AtNuResolutionType::kHiRes4, AtNuResolutionType::kLoRes, AtNuResolutionType::kNone, AtNuResolutionEventType::kNUE, AtNuCounter::kNull, AtNuCounter::kPCDownAmbig, AtNuCounter::kPCDownNeg, AtNuCounter::kPCDownPos, AtNuCounter::kPCLoRes, AtNuCounter::kPCUpAmbig, AtNuCounter::kPCUpNeg, AtNuCounter::kPCUpPos, AtNuCounter::kRAFAmbig, AtNuCounter::kRAFNeg, AtNuCounter::kRAFPos, AtNuCounter::kUnknown, AtNuResolutionEventType::kUPMU, AtNuCounter::kUpMuNeg, AtNuCounter::kUpMuPos, lores, negativecharge, AtNuOscillate::OscProb(), pc, pnuy, positivecharge, AtNuOscillate::ProductionHeight(), AtNuOscillate::PropagationLength(), recoemu, recoenu, recolength, ResetChain(), AtNuOscillate::SetDMSq12(), AtNuOscillate::SetDMSq23(), AtNuOscillate::SetSinSq2Theta12(), AtNuOscillate::SetSinSq2Theta13(), AtNuOscillate::SetSinSq2Theta23(), solarweight, spill, trueheight, truelength, upmu, veto, and SolarCycleRW::Weight().

00276 {
00277   std::cout << " *** AtNuEventCounter::AddData() *** " << std::endl;
00278   std::cout << "   add data from: " << file << " (ktyrs=" << ktyrs << ")" << std::endl;
00279 
00280   // add new data
00281   // ============
00282   this->ResetChain();
00283 
00284   fChainData->Add(file);
00285 
00286   Int_t iLast = Nevents;
00287   Int_t iEntries = fChainData->GetEntries();
00288 
00289   if( iLast<0 || iLast>iEntries ){
00290     iLast = iEntries;
00291   }
00292 
00293   std::cout << "   entries=" << iEntries << std::endl;
00294 
00295   // sanity checks
00296   // =============
00297   if( fKtYrsData<=0 || iLast<=0 || iEntries<=0 ){
00298     std::cout << "   error: no data! [return] " << std::endl;
00299     return;
00300   }
00301 
00302   if( !( fileType==AtNuCounter::kAtmosCV 
00303       || fileType==AtNuCounter::kAtmosUpMu
00304       || fileType==AtNuCounter::kCosmic
00305       || fileType==AtNuCounter::kData ) ){
00306     std::cout << "   warning: not a valid data Type. [return] " << std::endl;
00307     return;
00308   }
00309 
00310   // normalisation
00311   // =============
00312   Double_t normweight = 1.0;
00313 
00314   if( ktyrs>0 ){
00315     normweight = ((double)iLast/(double)iEntries)*(fKtYrsData/ktyrs);
00316   }
00317   else{
00318     std::cout << "   note: not renormalising this sample " << std::endl;
00319   }
00320 
00321   // oscillations
00322   // ============
00323   if( fUseThreeFlavours ){
00324     Double_t fHier = 1.0;
00325     if( fHierarchy==+1 ) fHier = +1.0; 
00326     if( fHierarchy==-1 ) fHier = -1.0;
00327 
00328     fOscillator->SetDMSq23(fHier*fDmsq);
00329     fOscillator->SetDMSq12(8.0e-5);
00330     fOscillator->SetSinSq2Theta23(fSinsq);
00331     fOscillator->SetSinSq2Theta12(0.86);
00332     fOscillator->SetSinSq2Theta13(fSinsq13);
00333     fOscillator->DoMatterEffects(true);
00334   }
00335 
00336   // loop over data
00337   // ==============
00338   for( Int_t i=0; i<iLast; i++ ){
00339     if( i%1000==0 ) std::cout << "  [" << i << "/" << iLast << "] " << std::endl;
00340 
00341     fChainData->GetEntry(i);
00342 
00343     // Event selection
00344     // ===============
00345     if( index==0 && goodevent && !spill ) {
00346 
00347       // Neutrino weights
00348       // ================
00349       Double_t oscweight = 1.0;
00350       Double_t solweight = 1.0;
00351       Double_t vetoweight = 1.0;
00352       Double_t fluxweight = 1.0;
00353 
00354       // neutrino weights
00355       if( idnu!=0 ){
00356   
00357         Double_t trueY = pnuy/enu;
00358         Double_t trueE = enu;
00359         Double_t trueH = AtNuOsc::FlatProdHeight();
00360         Double_t trueL = AtNuOscillate::PropagationLength(0,idnu,-trueY,enu);
00361 
00362         Int_t solidnu = 0;
00363         Int_t soltime = 0;
00364         Double_t p_osc = 0.0;
00365 
00366         // production heights
00367         if( fDoProductionHeights 
00368          || fReDoProductionHeights ){
00369           if( fReDoProductionHeights ){
00370             trueH = AtNuOscillate::ProductionHeight(2,idnu,-trueY,enu);
00371             trueL = AtNuOscillate::PropagationLength(-trueY,trueH);
00372             // trueL = AtNuOscillate::PropagationLength(2,idnu,-trueY,enu);
00373           }
00374           else{
00375             trueH = trueheight;
00376             trueL = truelength;
00377           }
00378         }
00379 
00380         // solar cycle reweighting
00381         if( fDoSolarCycleWeights 
00382          || fReDoSolarCycleWeights ){
00383           if( fReDoSolarCycleWeights ){
00384             solidnu = idnu;
00385             if( solidnu==+16 ) solidnu = +14;
00386             if( solidnu==-16 ) solidnu = -14;  
00387             // soltime = unixtime;    // set to random time during run period
00388             // soltime = 1136073600;  // set to mid-point (1st January 2006 for now)
00389             soltime = SolarCycleRW::Instance()->GenTime();
00390             solweight = SolarCycleRW::Instance()->Weight(enu,-trueY,
00391                                                          solidnu,soltime);
00392           }
00393           else{
00394             solweight = solarweight;
00395           }
00396         }
00397 
00398         // flux weighting
00399         if( fDoFluxWeights
00400          || fReDoFluxWeights ){
00401 
00402           // Bartol96 to Bartol3D
00403           if( fReDoFluxWeights ){
00404             if( fileType==AtNuCounter::kAtmosUpMu ){
00405               fluxweight = AtNuFluxRW::Instance()->GetBartolFluxRatio(idnu,enu,-trueY);
00406             }
00407           }
00408           else{
00409             if( fileType==AtNuCounter::kAtmosUpMu ){
00410               fluxweight = fluxcvupratio;
00411             }
00412           }
00413         
00414           // Bartol3D to Fluka3D or Honda3D
00415           if( fReweightToFluka ){
00416             fluxweight *= AtNuFluxRW::Instance()->GetFlukaFluxRatio(idnu,enu,-trueY);
00417           }
00418           if( fReweightToHonda ){
00419             fluxweight *= AtNuFluxRW::Instance()->GetHondaFluxRatio(idnu,enu,-trueY);
00420           }
00421         }
00422 
00423         // three flavours
00424         if( fUseThreeFlavours ){
00425           if( idnu==+12 ) fluxelmuratio = AtNuFluxRW::Instance()->GetBartolFlavourRatio(+14,enu,-trueY);
00426           if( idnu==-12 ) fluxelmuratio = AtNuFluxRW::Instance()->GetBartolFlavourRatio(-14,enu,-trueY);
00427         }
00428 
00429         // reset taus to zero
00430         if( fabs(idnu)==16 ){
00431           oscweight = 0.0;
00432         }
00433 
00434         // charged-current interactions
00435         if( idact==1 ){
00436 
00437           // two-flavour oscillations
00438           if( !fUseThreeFlavours ){
00439             if( fabs(idnu)==14 || fabs(idnu)==16 ){
00440               p_osc = fSinsq*pow(sin(1.267*fDmsq*trueL/trueE),2.0);
00441 
00442               if( fabs(idnu)==14 && idact==1 ){ // numu CC
00443                 oscweight = 1.0 - p_osc;
00444               }
00445 
00446               if( fabs(idnu)==16 && idact==1 ){ // nutau CC
00447                 oscweight = p_osc;
00448               }
00449             }
00450           }
00451           
00452           // three-flavour oscillations
00453           else{
00454             Int_t epdg = 0;
00455             Int_t ipdg = idnu;
00456             Int_t jpdg = idnu;
00457       
00458             if( jpdg==+12 ){ epdg = +14; ipdg = +12; }
00459             if( jpdg==-12 ){ epdg = -14; ipdg = -12; }
00460             if( jpdg==+14 ){ epdg = +12; ipdg = +14; }
00461             if( jpdg==-14 ){ epdg = -12; ipdg = -14; }
00462             if( jpdg==+16 ){ epdg = +12; ipdg = +14; }
00463             if( jpdg==-16 ){ epdg = -12; ipdg = -14; }
00464 
00465             if( fabs(idnu)==12 ){  // P(nue->nue)+(Rmu/Re)*P(numu->nue)
00466               oscweight = fOscillator->OscProb(ipdg,jpdg,-trueY,trueE,trueH)
00467                         + (1.0/fluxelmuratio)*fOscillator->OscProb(epdg,jpdg,-trueY,trueE,trueH);
00468             }
00469 
00470             if( fabs(idnu)==14 ){  // P(numu->numu)+(Re/Rmu)*P(nue->numu) 
00471               oscweight = fOscillator->OscProb(ipdg,jpdg,-trueY,trueE,trueH)
00472                         + (1.0*fluxelmuratio)*fOscillator->OscProb(epdg,jpdg,-trueY,trueE,trueH);
00473             }
00474 
00475             if( fabs(idnu)==16 ){  // P(numu->nutau)
00476               oscweight = fOscillator->OscProb(ipdg,jpdg,-trueY,trueE,trueH);
00477             }
00478           }
00479         }
00480       }
00481 
00482       // Shield weight
00483       // =============
00484       vetoweight = 1.0;
00485 
00486       // apply to contained events only
00487       if( !atmosnumuup ){
00488 
00489         // atmospheric neutrinos
00490         if( fileType==AtNuCounter::kAtmosCV 
00491          || fileType==AtNuCounter::kAtmosUpMu ){
00492           vetoweight = fShieldSigRate;
00493         }
00494 
00495         // cosmic muons
00496         if( fileType==AtNuCounter::kCosmic ){
00497           vetoweight = fShieldBkgRate;
00498         }
00499       }    
00500 
00501       // True Event Type
00502       // ===============
00503       AtNuCounter::TrueEventType_t trueType = AtNuCounter::kUnknown;
00504 
00505       if( idnu!=0 ){
00506         if( fileType==AtNuCounter::kAtmosCV ){
00507           if( idact==1 ){
00508             if( idnu==-12 ) trueType = AtNuCounter::kCVCCNue;
00509             if( idnu==-14 ) trueType = AtNuCounter::kCVCCNumuPos;
00510             if( idnu==-16 ) trueType = AtNuCounter::kCVCCNutau;
00511             if( idnu==+12 ) trueType = AtNuCounter::kCVCCNue;
00512             if( idnu==+14 ) trueType = AtNuCounter::kCVCCNumuNeg;
00513             if( idnu==+16 ) trueType = AtNuCounter::kCVCCNutau;
00514           }
00515           else{
00516             trueType = AtNuCounter::kCVNC;
00517           }
00518         }
00519         if( fileType==AtNuCounter::kAtmosUpMu ){
00520           if( idact==1 ){
00521             if( idnu==-14 ) trueType = AtNuCounter::kUpMuPos;
00522             if( idnu==+14 ) trueType = AtNuCounter::kUpMuNeg;
00523           }
00524         }
00525       }
00526 
00527       else{
00528         if( fileType==AtNuCounter::kCosmic ){
00529           if( veto==1 && !atmosnumuup ) trueType = AtNuCounter::kCosmic; 
00530         }
00531         if( fileType==AtNuCounter::kData ){
00532           if( veto==0 || atmosnumuup ) trueType = AtNuCounter::kData; 
00533         }
00534       }
00535 
00536 
00537       // Cut Flow Data
00538       // =============
00539       AtNuCounter::AtmosNumuCVType_t atmosNumuCVcut = AtNuCounter::kAtmosNumuCVcut0;
00540 
00541       if( atmosnumucvcut4 )      atmosNumuCVcut = AtNuCounter::kAtmosNumuCVcut4;
00542       else if( atmosnumucvcut3 ) atmosNumuCVcut = AtNuCounter::kAtmosNumuCVcut3;
00543       else if( atmosnumucvcut2 ) atmosNumuCVcut = AtNuCounter::kAtmosNumuCVcut2;
00544       else if( atmosnumucvcut1 ) atmosNumuCVcut = AtNuCounter::kAtmosNumuCVcut1;
00545 
00546       AtNuCounter::AtmosNumuUPType_t atmosNumuUPcut = AtNuCounter::kAtmosNumuUPcut0;
00547 
00548       if( atmosnumuupcut4 )      atmosNumuUPcut = AtNuCounter::kAtmosNumuUPcut4;
00549       else if( atmosnumuupcut3 ) atmosNumuUPcut = AtNuCounter::kAtmosNumuUPcut3;
00550       else if( atmosnumuupcut2 ) atmosNumuUPcut = AtNuCounter::kAtmosNumuUPcut2;
00551       else if( atmosnumuupcut1 ) atmosNumuUPcut = AtNuCounter::kAtmosNumuUPcut1;
00552 
00553       AtNuCounter::AtmosNueCVType_t atmosNueCVcut = AtNuCounter::kAtmosNueCVcut0;
00554 
00555       if( atmosnuecvcut4 )      atmosNueCVcut = AtNuCounter::kAtmosNueCVcut4;
00556       else if( atmosnuecvcut3 ) atmosNueCVcut = AtNuCounter::kAtmosNueCVcut3;
00557       else if( atmosnuecvcut2 ) atmosNueCVcut = AtNuCounter::kAtmosNueCVcut2;
00558       else if( atmosnuecvcut1 ) atmosNueCVcut = AtNuCounter::kAtmosNueCVcut1;
00559 
00560 
00561       // Selected Event Type
00562       // ===================
00563       AtNuCounter::AtmosEventType_t atmosType = AtNuCounter::kBackground;
00564 
00565       // electron neutrino
00566       if( atmosnue ){
00567         atmosType = AtNuCounter::kAtmosNue;
00568       }
00569 
00570       // muon neutrino
00571       if( atmosnumu ){
00572         if(  atmosnumucv && !atmosnumuup ) {
00573           if( fc )   atmosType = AtNuCounter::kAtmosNumuCVOnly_FC;
00574           if( pc )   atmosType = AtNuCounter::kAtmosNumuCVOnly_PC;
00575           if( upmu ) atmosType = AtNuCounter::kAtmosNumuCVOnly_RAF;
00576         }
00577         if(  atmosnumucv &&  atmosnumuup ) {
00578           if( fc )   atmosType = AtNuCounter::kAtmosNumuCVUP_FC;
00579           if( pc )   atmosType = AtNuCounter::kAtmosNumuCVUP_PC;
00580           if( upmu ) atmosType = AtNuCounter::kAtmosNumuCVUP_RAF;
00581         }
00582         if( !atmosnumucv &&  atmosnumuup ) {
00583           if( fc )   atmosType = AtNuCounter::kAtmosNumuUPOnly_FC;
00584           if( pc )   atmosType = AtNuCounter::kAtmosNumuUPOnly_PC;
00585           if( upmu ) atmosType = AtNuCounter::kAtmosNumuUPOnly_RAF;
00586         }
00587       }
00588 
00589       // Direction and Charge
00590       // ====================
00591       Int_t trkupdn   = 0;  // direction
00592       Int_t trkcharge = 0;  // charge
00593      
00594       // muon neutrino
00595       if( atmosnumu ){
00596 
00597         if( gooddirection ){
00598           if( fc || pc ){
00599             if( evttrkdiry>=0 ) trkupdn = +1; 
00600             else trkupdn = -1;
00601           }
00602           else if( upmu ) trkupdn = +1; 
00603         }
00604   
00605         if( goodcharge ){
00606           if( negativecharge ) trkcharge = -1;
00607           if( positivecharge ) trkcharge = +1;
00608         }
00609       }
00610 
00611     
00612       // Selected Event Type (up/down, nu/nubar separation)
00613       // ==================================================
00614       AtNuCounter::SelectedEventType_t selectedType = AtNuCounter::kNull;
00615 
00616       // electron neutrino
00617       if( atmosnue ){
00618         selectedType = AtNuCounter::kFCPCNue; 
00619       }
00620 
00621       // muon neutrino
00622       if( atmosnumu ){
00623 
00624         if( fc ){
00625           if( trkupdn==0 ) selectedType = AtNuCounter::kFCLoRes; 
00626           if( trkupdn==+1 && trkcharge==-1 ) selectedType = AtNuCounter::kFCUpNeg;
00627           if( trkupdn==+1 && trkcharge==0 )  selectedType = AtNuCounter::kFCUpAmbig;
00628           if( trkupdn==+1 && trkcharge==+1 ) selectedType = AtNuCounter::kFCUpPos; 
00629           if( trkupdn==-1 && trkcharge==-1 ) selectedType = AtNuCounter::kFCDownNeg;
00630           if( trkupdn==-1 && trkcharge==0 )  selectedType = AtNuCounter::kFCDownAmbig;
00631           if( trkupdn==-1 && trkcharge==+1 ) selectedType = AtNuCounter::kFCDownPos;
00632         }
00633 
00634         if( pc ){
00635           if( trkupdn==0 ) selectedType = AtNuCounter::kPCLoRes; 
00636           if( trkupdn==+1 && trkcharge==-1 ) selectedType = AtNuCounter::kPCUpNeg;
00637           if( trkupdn==+1 && trkcharge==0 )  selectedType = AtNuCounter::kPCUpAmbig;
00638           if( trkupdn==+1 && trkcharge==+1 ) selectedType = AtNuCounter::kPCUpPos; 
00639           if( trkupdn==-1 && trkcharge==-1 ) selectedType = AtNuCounter::kPCDownNeg;
00640           if( trkupdn==-1 && trkcharge==0 )  selectedType = AtNuCounter::kPCDownAmbig;
00641           if( trkupdn==-1 && trkcharge==+1 ) selectedType = AtNuCounter::kPCDownPos;
00642         }
00643 
00644         if( upmu ){
00645           if( trkcharge==-1 ) selectedType = AtNuCounter::kRAFNeg;
00646           if( trkcharge==0 )  selectedType = AtNuCounter::kRAFAmbig;
00647           if( trkcharge==+1 ) selectedType = AtNuCounter::kRAFPos;
00648         }
00649       }
00650 
00651       // Count this event
00652       // ================     
00653       this->Fill(trueType,
00654                  atmosNumuCVcut,atmosNumuUPcut,atmosNueCVcut,
00655                  atmosType,selectedType,
00656                  normweight*oscweight*solweight*fluxweight*vetoweight); 
00657 
00658 
00659 
00660       // Resolution Binning
00661       // ==================
00662       AtNuResolutionType::AtNuResolutionType_t resolutiontype = AtNuResolutionType::kNone;
00663       if( lores ) resolutiontype = AtNuResolutionType::kLoRes;
00664       else if( hires4 ) resolutiontype = AtNuResolutionType::kHiRes4;
00665       else if( hires3 ) resolutiontype = AtNuResolutionType::kHiRes3;
00666       else if( hires2 ) resolutiontype = AtNuResolutionType::kHiRes2;
00667       else if( hires1 ) resolutiontype = AtNuResolutionType::kHiRes1;
00668 
00669       if( resolutiontype<=0 ){ trkupdn = 0; trkcharge = 0; }
00670 
00671       // Kinematics
00672       // ==========
00673       Double_t fillLogLE = 0.0;
00674 
00675       if( atmosnumu ){
00676         if( fc||pc ){
00677           if( resolutiontype>0 ) fillLogLE = log10(recolength/recoenu);
00678         }
00679         if( upmu ){
00680           if( resolutiontype>0 ) fillLogLE = log10(recolength/recoemu);
00681         }
00682       }
00683      
00684       // Fill Templates
00685       // ==============
00686       if( ( fileType==AtNuCounter::kAtmosCV || fileType==AtNuCounter::kAtmosUpMu )
00687        || ( fileType==AtNuCounter::kCosmic && trueType==AtNuCounter::kCosmic )
00688        || ( fileType==AtNuCounter::kData && trueType==AtNuCounter::kData ) ){
00689  
00690         Double_t fillWeight = normweight*oscweight*solweight*fluxweight*vetoweight;
00691 
00692         if( atmosnue ){
00693           FillTemplates( fileType,AtNuResolutionEventType::kNUE,resolutiontype,
00694                          fillLogLE, fillWeight, 0, 0 );
00695         }
00696 
00697         if( atmosnumu && (fc||pc) ){
00698           FillTemplates( fileType,AtNuResolutionEventType::kCV,resolutiontype,
00699                          fillLogLE, fillWeight, trkupdn, trkcharge ); 
00700         }
00701 
00702         if( atmosnumu && upmu ){
00703           FillTemplates( fileType,AtNuResolutionEventType::kUPMU,resolutiontype,
00704                          fillLogLE, fillWeight, trkupdn, trkcharge ); 
00705         }
00706       }
00707 
00708     }
00709   }
00710 
00711 
00712   return;
00713 }

void AtNuEventCounter::DoFluxWeights ( Bool_t  doweights = 1  )  [inline]

Definition at line 108 of file AtNuEventCounter.h.

References fDoFluxWeights.

00108                                           {
00109     fDoFluxWeights = doweights;
00110   }

void AtNuEventCounter::DoProductionHeights ( Bool_t  doheights = 1  )  [inline]

Definition at line 92 of file AtNuEventCounter.h.

References fDoProductionHeights.

00092                                                 {
00093     fDoProductionHeights = doheights;
00094   }

void AtNuEventCounter::DoSolarCycleWeights ( Bool_t  doweights = 1  )  [inline]

Definition at line 100 of file AtNuEventCounter.h.

References fDoSolarCycleWeights.

00100                                                 {
00101     fDoSolarCycleWeights = doweights;
00102   }

void AtNuEventCounter::Fill ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::AtmosNumuCVType_t  atmosNumuCVType,
AtNuCounter::AtmosNumuUPType_t  atmosNumuUPType,
AtNuCounter::AtmosNueCVType_t  atmosNueCVType,
AtNuCounter::AtmosEventType_t  atmosType,
AtNuCounter::SelectedEventType_t  selectedType,
Double_t  weight 
)

Definition at line 756 of file AtNuEventCounter.cxx.

References fCtrAtmos, fCtrAtmosNueCV, fCtrAtmosNumuCV, fCtrAtmosNumuUP, fCtrSelected, fNumAtmosBins, fNumAtmosNueCVBins, fNumAtmosNumuCVBins, fNumAtmosNumuUPBins, fNumSelectedBins, fNumTrueBins, AtNuCounter::GetAtmosBin(), AtNuCounter::GetAtmosNueCVBin(), AtNuCounter::GetAtmosNumuCVBin(), AtNuCounter::GetAtmosNumuUPBin(), AtNuCounter::GetSelectedBin(), and AtNuCounter::GetTrueBin().

Referenced by AddData().

00757 {
00758   Int_t trueBin        = AtNuCounter::GetTrueBin(trueType);
00759   Int_t atmosNumuCVBin = AtNuCounter::GetAtmosNumuCVBin(atmosNumuCVcut);
00760   Int_t atmosNumuUPBin = AtNuCounter::GetAtmosNumuUPBin(atmosNumuUPcut);
00761   Int_t atmosNueCVBin  = AtNuCounter::GetAtmosNueCVBin(atmosNueCVcut);
00762   Int_t atmosBin       = AtNuCounter::GetAtmosBin(atmosType);
00763   Int_t selectedBin    = AtNuCounter::GetSelectedBin(selectedType);
00764 
00765   if( trueBin>=0 && atmosNumuCVBin>=0
00766    && trueBin<fNumTrueBins && atmosNumuCVBin<fNumAtmosNumuCVBins ){
00767     fCtrAtmosNumuCV[trueBin*fNumAtmosNumuCVBins+atmosNumuCVBin] += weight;
00768   }
00769  
00770   if( trueBin>=0 && atmosNumuUPBin>=0
00771    && trueBin<fNumTrueBins && atmosNumuUPBin<fNumAtmosNumuUPBins ){
00772     fCtrAtmosNumuUP[trueBin*fNumAtmosNumuUPBins+atmosNumuUPBin] += weight;
00773   }
00774   
00775   if( trueBin>=0 && atmosNueCVBin>=0
00776    && trueBin<fNumTrueBins && atmosNueCVBin<fNumAtmosNueCVBins ){
00777     fCtrAtmosNueCV[trueBin*fNumAtmosNueCVBins+atmosNueCVBin] += weight;
00778   }
00779 
00780   if( trueBin>=0 && atmosBin>=0 
00781    && trueBin<fNumTrueBins && atmosBin<fNumAtmosBins ){
00782     fCtrAtmos[trueBin*fNumAtmosBins+atmosBin] += weight;
00783   }
00784 
00785   if( trueBin>=0 && selectedBin>=0 
00786    && trueBin<fNumTrueBins && selectedBin<fNumSelectedBins ){
00787     fCtrSelected[trueBin*fNumSelectedBins+selectedBin] += weight;
00788   }
00789 
00790   return;
00791 }  

void AtNuEventCounter::FillTemplates ( AtNuCounter::TrueEventType_t  datatype,
AtNuResolutionEventType::AtNuResolutionEventType_t  eventtype,
AtNuResolutionType::AtNuResolutionType_t  resolutiontype,
Double_t  fillLogLE,
Double_t  fillWeight,
Int_t  updn,
Int_t  chg 
) [private]

Definition at line 716 of file AtNuEventCounter.cxx.

References AtNuOscFitHistogram::Fill(), fTemplateData, fTemplateMC, AtNuOscFitTemplate::GetHistogram(), and AtNuCounter::kData.

Referenced by AddData().

00717 {
00718   AtNuOscFitTemplate* myTemplate = 0;
00719 
00720   if( datatype==AtNuCounter::kData ) myTemplate = fTemplateData;
00721   else                               myTemplate = fTemplateMC;
00722 
00723   AtNuOscFitHistogram* myHistogram = (AtNuOscFitHistogram*)(myTemplate->GetHistogram(eventtype,resolutiontype));
00724   if( myHistogram ) myHistogram->Fill( fillLogLE, fillWeight, updn, chg );
00725 }

Double_t AtNuEventCounter::GetCount ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::SelectedEventType_t  selectedType 
)

Definition at line 922 of file AtNuEventCounter.cxx.

References count, fCtrSelected, fNumSelectedBins, fNumTrueBins, AtNuCounter::GetSelectedType(), and AtNuCounter::GetTrueType().

00923 {
00924   Double_t count = 0.0;
00925 
00926   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00927     for( Int_t selectedBin=0; selectedBin<fNumSelectedBins; selectedBin++ ){
00928 
00929       AtNuCounter::TrueEventType_t trueBinType = AtNuCounter::GetTrueType(trueBin);
00930       AtNuCounter::SelectedEventType_t selectedBinType = AtNuCounter::GetSelectedType(selectedBin);
00931 
00932       if( (trueBinType&trueType)==trueBinType 
00933        && (selectedBinType&selectedType)==selectedBinType ){
00934         count += fCtrSelected[trueBin*fNumSelectedBins+selectedBin];
00935       }
00936 
00937     }
00938   }
00939 
00940   return count;
00941 }

Double_t AtNuEventCounter::GetCount ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::AtmosEventType_t  atmosType 
)

Definition at line 901 of file AtNuEventCounter.cxx.

References count, fCtrAtmos, fNumAtmosBins, fNumTrueBins, AtNuCounter::GetAtmosType(), and AtNuCounter::GetTrueType().

00902 {
00903   Double_t count = 0.0;
00904 
00905   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00906     for( Int_t atmosBin=0; atmosBin<fNumAtmosBins; atmosBin++ ){
00907 
00908       AtNuCounter::TrueEventType_t trueBinType = AtNuCounter::GetTrueType(trueBin);
00909       AtNuCounter::AtmosEventType_t atmosBinType = AtNuCounter::GetAtmosType(atmosBin);
00910 
00911       if( (trueBinType&trueType)==trueBinType 
00912        && (atmosBinType&atmosType)==atmosBinType ){
00913         count += fCtrAtmos[trueBin*fNumAtmosBins+atmosBin];
00914       }
00915 
00916     }
00917   }
00918 
00919   return count;
00920 }

Double_t AtNuEventCounter::GetCount ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::AtmosNueCVType_t  cutType 
)

Definition at line 880 of file AtNuEventCounter.cxx.

References count, fCtrAtmosNueCV, fNumAtmosNueCVBins, fNumTrueBins, AtNuCounter::GetAtmosNueCVType(), and AtNuCounter::GetTrueType().

00881 {
00882   Double_t count = 0.0;
00883 
00884   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00885     for( Int_t cutBin=0; cutBin<fNumAtmosNueCVBins; cutBin++ ){
00886 
00887       AtNuCounter::TrueEventType_t trueBinType = AtNuCounter::GetTrueType(trueBin);
00888       AtNuCounter::AtmosNueCVType_t cutBinType = AtNuCounter::GetAtmosNueCVType(cutBin);
00889 
00890       if( (trueBinType&trueType)==trueBinType 
00891        && (cutBinType&cutType)==cutBinType ){
00892         count += fCtrAtmosNueCV[trueBin*fNumAtmosNueCVBins+cutBin];
00893       }
00894 
00895     }
00896   }
00897 
00898   return count;
00899 }

Double_t AtNuEventCounter::GetCount ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::AtmosNumuUPType_t  cutType 
)

Definition at line 859 of file AtNuEventCounter.cxx.

References count, fCtrAtmosNumuUP, fNumAtmosNumuUPBins, fNumTrueBins, AtNuCounter::GetAtmosNumuUPType(), and AtNuCounter::GetTrueType().

00860 {
00861   Double_t count = 0.0;
00862 
00863   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00864     for( Int_t cutBin=0; cutBin<fNumAtmosNumuUPBins; cutBin++ ){
00865 
00866       AtNuCounter::TrueEventType_t trueBinType = AtNuCounter::GetTrueType(trueBin);
00867       AtNuCounter::AtmosNumuUPType_t cutBinType = AtNuCounter::GetAtmosNumuUPType(cutBin);
00868 
00869       if( (trueBinType&trueType)==trueBinType 
00870        && (cutBinType&cutType)==cutBinType ){
00871         count += fCtrAtmosNumuUP[trueBin*fNumAtmosNumuUPBins+cutBin];
00872       }
00873 
00874     }
00875   }
00876 
00877   return count;
00878 }

Double_t AtNuEventCounter::GetCount ( AtNuCounter::TrueEventType_t  trueType,
AtNuCounter::AtmosNumuCVType_t  cutType 
)

Definition at line 838 of file AtNuEventCounter.cxx.

References count, fCtrAtmosNumuCV, fNumAtmosNumuCVBins, fNumTrueBins, AtNuCounter::GetAtmosNumuCVType(), and AtNuCounter::GetTrueType().

Referenced by GetExpectedCount(), and GetObservedCount().

00839 {
00840   Double_t count = 0.0;
00841 
00842   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00843     for( Int_t cutBin=0; cutBin<fNumAtmosNumuCVBins; cutBin++ ){
00844 
00845       AtNuCounter::TrueEventType_t trueBinType = AtNuCounter::GetTrueType(trueBin);
00846       AtNuCounter::AtmosNumuCVType_t cutBinType = AtNuCounter::GetAtmosNumuCVType(cutBin);
00847 
00848       if( (trueBinType&trueType)==trueBinType 
00849        && (cutBinType&cutType)==cutBinType ){
00850         count += fCtrAtmosNumuCV[trueBin*fNumAtmosNumuCVBins+cutBin];
00851       }
00852 
00853     }
00854   }
00855 
00856   return count;
00857 }

Double_t AtNuEventCounter::GetExpectedCount (  ) 

Definition at line 998 of file AtNuEventCounter.cxx.

References GetCount(), AtNuCounter::kAll, and AtNuCounter::kMC.

00999 {
01000   return this->GetCount(AtNuCounter::kMC,AtNuCounter::kAll);
01001 }

Double_t AtNuEventCounter::GetExpectedCount ( AtNuCounter::SelectedEventType_t  selectedType  ) 

Definition at line 988 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kMC.

00989 {
00990   return this->GetCount(AtNuCounter::kMC,selectedType);
00991 }

Double_t AtNuEventCounter::GetExpectedCount ( AtNuCounter::AtmosEventType_t  atmosType  ) 

Definition at line 978 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kMC.

00979 {
00980   return this->GetCount(AtNuCounter::kMC,atmosType);
00981 }

Double_t AtNuEventCounter::GetExpectedCount ( AtNuCounter::AtmosNueCVType_t  cutType  ) 

Definition at line 968 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kMC.

00969 {
00970   return this->GetCount(AtNuCounter::kMC,cutType);
00971 }

Double_t AtNuEventCounter::GetExpectedCount ( AtNuCounter::AtmosNumuUPType_t  cutType  ) 

Definition at line 958 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kMC.

00959 {
00960   return this->GetCount(AtNuCounter::kMC,cutType);
00961 }

Double_t AtNuEventCounter::GetExpectedCount ( AtNuCounter::AtmosNumuCVType_t  cutType  ) 

Definition at line 948 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kMC.

00949 {
00950   return this->GetCount(AtNuCounter::kMC,cutType);
00951 }

Double_t AtNuEventCounter::GetObservedCount (  ) 

Definition at line 993 of file AtNuEventCounter.cxx.

References GetCount(), AtNuCounter::kAll, and AtNuCounter::kData.

00994 {
00995   return this->GetCount(AtNuCounter::kData,AtNuCounter::kAll);
00996 }

Double_t AtNuEventCounter::GetObservedCount ( AtNuCounter::SelectedEventType_t  selectedType  ) 

Definition at line 983 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kData.

00984 {
00985   return this->GetCount(AtNuCounter::kData,selectedType);
00986 }

Double_t AtNuEventCounter::GetObservedCount ( AtNuCounter::AtmosEventType_t  atmosType  ) 

Definition at line 973 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kData.

00974 {
00975   return this->GetCount(AtNuCounter::kData,atmosType);
00976 }

Double_t AtNuEventCounter::GetObservedCount ( AtNuCounter::AtmosNueCVType_t  cutType  ) 

Definition at line 963 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kData.

00964 {
00965   return this->GetCount(AtNuCounter::kData,cutType);
00966 }

Double_t AtNuEventCounter::GetObservedCount ( AtNuCounter::AtmosNumuUPType_t  cutType  ) 

Definition at line 953 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kData.

00954 {
00955   return this->GetCount(AtNuCounter::kData,cutType);
00956 }

Double_t AtNuEventCounter::GetObservedCount ( AtNuCounter::AtmosNumuCVType_t  cutType  ) 

Definition at line 943 of file AtNuEventCounter.cxx.

References GetCount(), and AtNuCounter::kData.

00944 {
00945   return this->GetCount(AtNuCounter::kData,cutType);
00946 }

void AtNuEventCounter::PrintCount (  ) 

Definition at line 793 of file AtNuEventCounter.cxx.

References fCtrAtmos, fCtrAtmosNueCV, fCtrAtmosNumuCV, fCtrAtmosNumuUP, fCtrSelected, fNumAtmosBins, fNumAtmosNueCVBins, fNumAtmosNumuCVBins, fNumAtmosNumuUPBins, fNumSelectedBins, and fNumTrueBins.

00794 {
00795   std::cout << " *** AtNuEventCounter::PrintCount() *** " << std::endl;
00796   
00797   std::cout << "  atmos cut flow [NumuCV]: " << std::endl;
00798   for( Int_t cutBin=0; cutBin<fNumAtmosNumuCVBins; cutBin++ ){
00799     for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00800       std::cout << fCtrAtmosNumuCV[trueBin*fNumAtmosNumuCVBins+cutBin] << "\t";
00801     }
00802     std::cout << std::endl;
00803   }
00804 
00805   std::cout << "  atmos cut flow: [NumuUP] " << std::endl;
00806   for( Int_t cutBin=0; cutBin<fNumAtmosNumuUPBins; cutBin++ ){
00807     for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00808       std::cout << fCtrAtmosNumuUP[trueBin*fNumAtmosNumuUPBins+cutBin] << "\t";
00809     }
00810     std::cout << std::endl;
00811   }
00812 
00813   std::cout << "  atmos cut flow [NueCV]: " << std::endl;
00814   for( Int_t cutBin=0; cutBin<fNumAtmosNueCVBins; cutBin++ ){
00815     for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00816       std::cout << fCtrAtmosNueCV[trueBin*fNumAtmosNueCVBins+cutBin] << "\t";
00817     }
00818     std::cout << std::endl;
00819   }
00820 
00821   std::cout << "  atmos event selection: " << std::endl;
00822   for( Int_t atmosBin=0; atmosBin<fNumAtmosBins; atmosBin++ ){
00823     for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00824       std::cout << fCtrAtmos[trueBin*fNumAtmosBins+atmosBin] << "\t";
00825     }
00826     std::cout << std::endl;
00827   }
00828 
00829   std::cout << "  up/down, nu/nubar selection: " << std::endl;
00830   for( Int_t selectedBin=0; selectedBin<fNumSelectedBins; selectedBin++ ){
00831     for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00832       std::cout << fCtrSelected[trueBin*fNumSelectedBins+selectedBin] << "\t";
00833     }
00834     std::cout << std::endl;
00835   }
00836 }

void AtNuEventCounter::ReDoFluxWeights ( Bool_t  doweights = 1  )  [inline]

Definition at line 112 of file AtNuEventCounter.h.

References fReDoFluxWeights.

00112                                             {
00113     fReDoFluxWeights = doweights;
00114   }

void AtNuEventCounter::ReDoProductionHeights ( Bool_t  doheights = 1  )  [inline]

Definition at line 96 of file AtNuEventCounter.h.

References fReDoProductionHeights.

00096                                                   {
00097     fReDoProductionHeights = doheights;
00098   }

void AtNuEventCounter::ReDoSolarCycleWeights ( Bool_t  doweights = 1  )  [inline]

Definition at line 104 of file AtNuEventCounter.h.

References fReDoSolarCycleWeights.

00104                                                   {
00105     fReDoSolarCycleWeights = doweights;
00106   }

void AtNuEventCounter::Reset (  ) 

Definition at line 93 of file AtNuEventCounter.cxx.

References fCtrAtmos, fCtrAtmosNueCV, fCtrAtmosNumuCV, fCtrAtmosNumuUP, fCtrSelected, fNumAtmosBins, fNumAtmosNueCVBins, fNumAtmosNumuCVBins, fNumAtmosNumuUPBins, fNumSelectedBins, fNumTrueBins, fTemplateData, fTemplateMC, AtNuOscFitTemplate::Reset(), and ResetChain().

00094 {
00095   std::cout << " *** AtNuEventCounter::Reset() *** " << std::endl;
00096 
00097   // reset arrays
00098   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00099     for( Int_t cutBin=0; cutBin<fNumAtmosNumuCVBins; cutBin++ ){
00100       fCtrAtmosNumuCV[trueBin*fNumAtmosNumuCVBins+cutBin] = 0.0;
00101     }
00102   }
00103 
00104   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00105     for( Int_t cutBin=0; cutBin<fNumAtmosNumuUPBins; cutBin++ ){
00106       fCtrAtmosNumuUP[trueBin*fNumAtmosNumuUPBins+cutBin] = 0.0;
00107     }
00108   }
00109 
00110   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00111     for( Int_t cutBin=0; cutBin<fNumAtmosNueCVBins; cutBin++ ){
00112       fCtrAtmosNueCV[trueBin*fNumAtmosNueCVBins+cutBin] = 0.0;
00113     }
00114   }
00115 
00116   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00117     for( Int_t atmosBin=0; atmosBin<fNumAtmosBins; atmosBin++ ){
00118       fCtrAtmos[trueBin*fNumAtmosBins+atmosBin] = 0.0;
00119     }
00120   }
00121 
00122   for( Int_t trueBin=0; trueBin<fNumTrueBins; trueBin++ ){
00123     for( Int_t selectedBin=0; selectedBin<fNumSelectedBins; selectedBin++ ){
00124       fCtrSelected[trueBin*fNumSelectedBins+selectedBin] = 0.0;
00125     }
00126   }
00127 
00128   // reset template
00129   if( fTemplateData ) fTemplateData->Reset();
00130   if( fTemplateMC )   fTemplateMC->Reset();
00131 
00132   // reset chain
00133   this->ResetChain();
00134 }

void AtNuEventCounter::ResetChain (  ) 

Definition at line 136 of file AtNuEventCounter.cxx.

References atmosnue, atmosnuecvcut1, atmosnuecvcut2, atmosnuecvcut3, atmosnuecvcut4, atmosnumu, atmosnumucv, atmosnumucvcut1, atmosnumucvcut2, atmosnumucvcut3, atmosnumucvcut4, atmosnumuup, atmosnumuupcut1, atmosnumuupcut2, atmosnumuupcut3, atmosnumuupcut4, ce, cv, enu, evtshwdiru, evtshwdirv, evtshwdirx, evtshwdiry, evtshwdirz, evtshwgevdwgt, evtshwgevlin, evtshwplanes, evtshwreco, evttrkdiru, evttrkdirv, evttrkdirx, evttrkdiry, evttrkdirz, evttrkemcharge, evttrkpcurve, evttrkplanes, evttrkprange, evttrkreco, evtvtxplane, evtvtxu, evtvtxv, evtvtxx, evtvtxy, evtvtxz, fc, fChainData, fDoFluxWeights, fDoSolarCycleWeights, fluxcvupratio, fluxelmuratio, fReDoFluxWeights, fReDoSolarCycleWeights, fUseFullNtuples, fUseThreeFlavours, goodcharge, gooddirection, goodenergy, goodevent, goodshield, goodshower, goodslice, goodtrack, hires1, hires2, hires3, hires4, idact, idnu, idres, index, lores, negativecharge, pc, pnux, pnuy, pnuz, positivecharge, recoemu, recoenu, recoeshwdwgt, recoeshwlin, recoeshwnue, recolength, simflag, solarweight, spill, trueemu, trueeshw, trueheight, truelength, unixtime, upmu, and veto.

Referenced by AddData(), and Reset().

00137 {
00138   std::cout << " *** AtNuEventCounter::ResetChain() *** " << std::endl;
00139 
00140   fChainData->Reset();
00141   fChainData->SetBranchAddress("unixtime",&unixtime);
00142   fChainData->SetBranchAddress("simflag",&simflag);
00143   fChainData->SetBranchAddress("simflag",&simflag);
00144   fChainData->SetBranchAddress("index",&index);
00145   fChainData->SetBranchAddress("mc.inu",&idnu);
00146   fChainData->SetBranchAddress("mc.iact",&idact);
00147   fChainData->SetBranchAddress("mc.ires",&idres);
00148   fChainData->SetBranchAddress("mc.enu",&enu);
00149   fChainData->SetBranchAddress("mc.pnux",&pnux);
00150   fChainData->SetBranchAddress("mc.pnuy",&pnuy);
00151   fChainData->SetBranchAddress("mc.pnuz",&pnuz);
00152   fChainData->SetBranchAddress("evt.goodslice",&goodslice);
00153   fChainData->SetBranchAddress("evt.goodevent",&goodevent);
00154   fChainData->SetBranchAddress("evt.goodtrack",&goodtrack);
00155   fChainData->SetBranchAddress("evt.goodshower",&goodshower);
00156   fChainData->SetBranchAddress("evt.cv",&cv);
00157   fChainData->SetBranchAddress("evt.ce",&ce);
00158   fChainData->SetBranchAddress("evt.fc",&fc);
00159   fChainData->SetBranchAddress("evt.pc",&pc);
00160   fChainData->SetBranchAddress("evt.upmu",&upmu);
00161   fChainData->SetBranchAddress("evt.veto",&veto);
00162   fChainData->SetBranchAddress("evt.spill",&spill);
00163   fChainData->SetBranchAddress("evt.goodshield",&goodshield);
00164   fChainData->SetBranchAddress("evt.gooddirection",&gooddirection);
00165   fChainData->SetBranchAddress("evt.goodenergy",&goodenergy);
00166   fChainData->SetBranchAddress("evt.goodcharge",&goodcharge);
00167   fChainData->SetBranchAddress("evt.positivecharge",&positivecharge);
00168   fChainData->SetBranchAddress("evt.negativecharge",&negativecharge);
00169   fChainData->SetBranchAddress("evt.atmosnumu",&atmosnumu);
00170   fChainData->SetBranchAddress("evt.atmosnumucv",&atmosnumucv);
00171   fChainData->SetBranchAddress("evt.atmosnumuup",&atmosnumuup);
00172   fChainData->SetBranchAddress("evt.atmosnue",&atmosnue);
00173   fChainData->SetBranchAddress("evt.trkreco",&evttrkreco);
00174   fChainData->SetBranchAddress("evt.trkemcharge",&evttrkemcharge);
00175   fChainData->SetBranchAddress("evt.trkprange",&evttrkprange);
00176   fChainData->SetBranchAddress("evt.trkpcurve",&evttrkpcurve);
00177   fChainData->SetBranchAddress("evt.trkdiru",&evttrkdiru);
00178   fChainData->SetBranchAddress("evt.trkdirv",&evttrkdirv);
00179   fChainData->SetBranchAddress("evt.trkdirx",&evttrkdirx);
00180   fChainData->SetBranchAddress("evt.trkdiry",&evttrkdiry);
00181   fChainData->SetBranchAddress("evt.trkdirz",&evttrkdirz);
00182   fChainData->SetBranchAddress("evt.shwreco",&evtshwreco);
00183   fChainData->SetBranchAddress("evt.shwdiru",&evtshwdiru);
00184   fChainData->SetBranchAddress("evt.shwdirv",&evtshwdirv);
00185   fChainData->SetBranchAddress("evt.shwdirx",&evtshwdirx);
00186   fChainData->SetBranchAddress("evt.shwdiry",&evtshwdiry);
00187   fChainData->SetBranchAddress("evt.shwdirz",&evtshwdirz);
00188   fChainData->SetBranchAddress("evt.shwgevlin",&evtshwgevlin);
00189   fChainData->SetBranchAddress("evt.shwgevdwgt",&evtshwgevdwgt);
00190   fChainData->SetBranchAddress("evt.vtxu",&evtvtxu);
00191   fChainData->SetBranchAddress("evt.vtxv",&evtvtxv);
00192   fChainData->SetBranchAddress("evt.vtxx",&evtvtxx);
00193   fChainData->SetBranchAddress("evt.vtxy",&evtvtxy);
00194   fChainData->SetBranchAddress("evt.vtxz",&evtvtxz);
00195   fChainData->SetBranchAddress("evt.vtxplane",&evtvtxplane);
00196   fChainData->SetBranchAddress("evt.trkplanes",&evttrkplanes);
00197   fChainData->SetBranchAddress("evt.shwplanes",&evtshwplanes);
00198   fChainData->SetBranchAddress("evt.truelength",&truelength);
00199   fChainData->SetBranchAddress("evt.trueheight",&trueheight);
00200   fChainData->SetBranchAddress("evt.trueemu",&trueemu);
00201   fChainData->SetBranchAddress("evt.trueeshw",&trueeshw);
00202   fChainData->SetBranchAddress("evt.recolength",&recolength);
00203   fChainData->SetBranchAddress("evt.recoenu",&recoenu);
00204   fChainData->SetBranchAddress("evt.recoemu",&recoemu);
00205   fChainData->SetBranchAddress("evt.recoeshwlin",&recoeshwlin);
00206   fChainData->SetBranchAddress("evt.recoeshwdwgt",&recoeshwdwgt);
00207   fChainData->SetBranchAddress("evt.recoeshwnue",&recoeshwnue);
00208   fChainData->SetBranchAddress("evt.lores",&lores);
00209   fChainData->SetBranchAddress("evt.hires1",&hires1);
00210   fChainData->SetBranchAddress("evt.hires2",&hires2);
00211   fChainData->SetBranchAddress("evt.hires3",&hires3);
00212   fChainData->SetBranchAddress("evt.hires4",&hires4);
00213 
00214   if( fUseFullNtuples ){
00215     fChainData->SetBranchAddress("evt.atmosnumucvcut1",&atmosnumucvcut1);
00216     fChainData->SetBranchAddress("evt.atmosnumucvcut2",&atmosnumucvcut2);
00217     fChainData->SetBranchAddress("evt.atmosnumucvcut3",&atmosnumucvcut3);
00218     fChainData->SetBranchAddress("evt.atmosnumucvcut4",&atmosnumucvcut4);
00219     fChainData->SetBranchAddress("evt.atmosnumuupcut1",&atmosnumuupcut1);
00220     fChainData->SetBranchAddress("evt.atmosnumuupcut2",&atmosnumuupcut2);
00221     fChainData->SetBranchAddress("evt.atmosnumuupcut3",&atmosnumuupcut3);
00222     fChainData->SetBranchAddress("evt.atmosnumuupcut4",&atmosnumuupcut4);
00223     fChainData->SetBranchAddress("evt.atmosnuecvcut1",&atmosnuecvcut1);
00224     fChainData->SetBranchAddress("evt.atmosnuecvcut2",&atmosnuecvcut2);
00225     fChainData->SetBranchAddress("evt.atmosnuecvcut3",&atmosnuecvcut3);
00226     fChainData->SetBranchAddress("evt.atmosnuecvcut4",&atmosnuecvcut4);
00227   }
00228 
00229   if( fDoSolarCycleWeights
00230    && !fReDoSolarCycleWeights ){
00231     fChainData->SetBranchAddress("solar.weight",&solarweight);
00232   }
00233 
00234   if( fDoFluxWeights
00235    && !fReDoFluxWeights ){
00236     fChainData->SetBranchAddress("flux.cvupratio",&fluxcvupratio);
00237   }
00238 
00239   if( fUseThreeFlavours ){
00240     fChainData->SetBranchAddress("flux.elmuratio",&fluxelmuratio);
00241   }
00242 
00243   return;
00244 }

void AtNuEventCounter::ReweightToBartol (  )  [inline]

Definition at line 116 of file AtNuEventCounter.h.

References fReweightToFluka, and fReweightToHonda.

Referenced by SetFluxType().

00116                          {
00117     fReweightToFluka = 0; fReweightToHonda = 0;
00118   }

void AtNuEventCounter::ReweightToFluka (  )  [inline]

Definition at line 120 of file AtNuEventCounter.h.

References fReweightToFluka, and fReweightToHonda.

Referenced by SetFluxType().

00120                         {
00121     fReweightToFluka = 1; fReweightToHonda = 0;
00122   }

void AtNuEventCounter::ReweightToHonda (  )  [inline]

Definition at line 124 of file AtNuEventCounter.h.

References fReweightToFluka, and fReweightToHonda.

Referenced by SetFluxType().

00124                         {
00125     fReweightToFluka = 0; fReweightToHonda = 1;
00126   }

void AtNuEventCounter::SetFluxType ( AtNuFlux::FluxType_t  fluxType  ) 

Definition at line 246 of file AtNuEventCounter.cxx.

References fDoFluxWeights, AtNuFlux::kBartol1D, AtNuFlux::kBartol3D, AtNuFlux::kFluka3D, AtNuFlux::kHonda3D, ReweightToBartol(), ReweightToFluka(), and ReweightToHonda().

00247 {
00248   if( fluxType==AtNuFlux::kBartol1D ){
00249     // not implemented
00250   }
00251 
00252   if( fluxType==AtNuFlux::kBartol3D ){
00253     fDoFluxWeights = 1;
00254     this->ReweightToBartol();
00255   }
00256 
00257   if( fluxType==AtNuFlux::kFluka3D ){
00258     fDoFluxWeights = 1;
00259     this->ReweightToFluka();
00260   }
00261 
00262   if( fluxType==AtNuFlux::kHonda3D ){
00263     fDoFluxWeights = 1;
00264     this->ReweightToHonda();
00265   }
00266 
00267   return;
00268 }

void AtNuEventCounter::SetKtYrs ( Double_t  ktyrs  )  [inline]

Definition at line 80 of file AtNuEventCounter.h.

References fKtYrsData.

00080                                  {
00081     fKtYrsData = ktyrs;
00082   }

void AtNuEventCounter::SetOscillations ( Double_t  dmsq,
Double_t  sinsq 
) [inline]

Definition at line 74 of file AtNuEventCounter.h.

References fDmsq, fHierarchy, fSinsq, fSinsq13, and fUseThreeFlavours.

00074                                                      {
00075     fDmsq = dmsq; fSinsq = sinsq;
00076     fSinsq13 = 0.0; fHierarchy = 0;
00077     fUseThreeFlavours = 0;
00078   }

void AtNuEventCounter::SetOscillations ( Double_t  dmsq,
Double_t  sinsq,
Double_t  sinsq13,
Int_t  hier 
) [inline]

Definition at line 67 of file AtNuEventCounter.h.

References fDmsq, fHierarchy, fSinsq, fSinsq13, and fUseThreeFlavours.

00068                                                     {
00069     fDmsq = dmsq; fSinsq = sinsq;
00070     fSinsq13 = sinsq13; fHierarchy = hier;
00071     fUseThreeFlavours = 1;
00072   }

void AtNuEventCounter::SetShieldBackgroundRate ( Double_t  rate  )  [inline]

Definition at line 88 of file AtNuEventCounter.h.

References fShieldBkgRate.

00088                                                {
00089     fShieldBkgRate = rate;
00090   }

void AtNuEventCounter::SetShieldSignalRate ( Double_t  rate  )  [inline]

Definition at line 84 of file AtNuEventCounter.h.

References fShieldSigRate.

00084                                            {
00085     fShieldSigRate = rate;
00086   }

void AtNuEventCounter::SetTimePeriod ( Int_t  mintime,
Int_t  maxtime 
)

Definition at line 270 of file AtNuEventCounter.cxx.

References SolarCycleRW::Instance(), and SolarCycleRW::TimePeriod().

00271 {
00272   SolarCycleRW::Instance()->TimePeriod(mintime,maxtime);
00273 }

void AtNuEventCounter::UseFullNtuples ( Bool_t  yesno = 1  )  [inline]

Definition at line 132 of file AtNuEventCounter.h.

References fUseFullNtuples.

00132                                          {
00133     fUseFullNtuples = yesno;
00134   }

void AtNuEventCounter::WriteTemplates ( const char *  filename  ) 

Definition at line 727 of file AtNuEventCounter.cxx.

References fTemplateData, fTemplateMC, and AtNuOscFitTemplate::WriteHistograms().

00728 { 
00729   // write data
00730   TString tagData = ".data";
00731   TString filenameData = filename;
00732 
00733   if( filenameData.EndsWith(".root") ){
00734     filenameData.Insert(filenameData.Length()-5,tagData);
00735   }
00736   else{
00737     filenameData.Append(tagData);
00738   }
00739 
00740   if( fTemplateData ) fTemplateData->WriteHistograms( filenameData.Data() );
00741 
00742   // write prediction
00743   TString tagMC = ".mc";
00744   TString filenameMC = filename;
00745 
00746   if( filenameMC.EndsWith(".root") ){
00747     filenameMC.Insert(filenameMC.Length()-5,tagMC);
00748   }
00749   else{
00750     filenameMC.Append(tagMC);
00751   }
00752 
00753   if( fTemplateMC ) fTemplateMC->WriteHistograms( filenameMC.Data() );
00754 }


Member Data Documentation

Int_t AtNuEventCounter::atmosnue [private]

Definition at line 179 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 188 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 189 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 190 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 191 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::atmosnumu [private]

Definition at line 176 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 177 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 180 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 181 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 182 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 183 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 178 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 184 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 185 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 186 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 187 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::ce [private]

Definition at line 164 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::cv [private]

Definition at line 163 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::enu [private]

Definition at line 155 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::evtshwdiru [private]

Definition at line 202 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwdirv [private]

Definition at line 203 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwdirx [private]

Definition at line 204 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwdiry [private]

Definition at line 205 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwdirz [private]

Definition at line 206 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwgevdwgt [private]

Definition at line 208 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtshwgevlin [private]

Definition at line 207 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 217 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 201 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkdiru [private]

Definition at line 196 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkdirv [private]

Definition at line 197 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkdirx [private]

Definition at line 198 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkdiry [private]

Definition at line 199 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::evttrkdirz [private]

Definition at line 200 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 193 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkpcurve [private]

Definition at line 195 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 216 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evttrkprange [private]

Definition at line 194 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 192 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 215 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtvtxtime [private]

Definition at line 209 of file AtNuEventCounter.h.

Double_t AtNuEventCounter::evtvtxu [private]

Definition at line 210 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtvtxv [private]

Definition at line 211 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtvtxx [private]

Definition at line 212 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtvtxy [private]

Definition at line 213 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::evtvtxz [private]

Definition at line 214 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::fc [private]

Definition at line 165 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

TChain* AtNuEventCounter::fChainData [private]

Definition at line 261 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t* AtNuEventCounter::fCtrAtmos [private]

Definition at line 275 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), Reset(), and ~AtNuEventCounter().

Double_t* AtNuEventCounter::fCtrAtmosNueCV [private]

Definition at line 273 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), Reset(), and ~AtNuEventCounter().

Double_t* AtNuEventCounter::fCtrAtmosNumuCV [private]

Definition at line 271 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), Reset(), and ~AtNuEventCounter().

Double_t* AtNuEventCounter::fCtrAtmosNumuUP [private]

Definition at line 272 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), Reset(), and ~AtNuEventCounter().

Double_t* AtNuEventCounter::fCtrSelected [private]

Definition at line 276 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), Reset(), and ~AtNuEventCounter().

Double_t AtNuEventCounter::fDmsq [private]

Definition at line 254 of file AtNuEventCounter.h.

Referenced by AddData(), and SetOscillations().

Definition at line 242 of file AtNuEventCounter.h.

Referenced by AddData(), DoFluxWeights(), ResetChain(), and SetFluxType().

Definition at line 238 of file AtNuEventCounter.h.

Referenced by AddData(), and DoProductionHeights().

Definition at line 240 of file AtNuEventCounter.h.

Referenced by AddData(), DoSolarCycleWeights(), and ResetChain().

Definition at line 258 of file AtNuEventCounter.h.

Referenced by AddData(), and SetOscillations().

Double_t AtNuEventCounter::fKtYrsData [private]

Definition at line 250 of file AtNuEventCounter.h.

Referenced by AddData(), and SetKtYrs().

Double_t AtNuEventCounter::fluxcvupratio [private]

Definition at line 235 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::fluxelmuratio [private]

Definition at line 236 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 268 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 265 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 263 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 264 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 269 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 267 of file AtNuEventCounter.h.

Referenced by Fill(), GetCount(), PrintCount(), and Reset().

Definition at line 278 of file AtNuEventCounter.h.

Referenced by AddData(), and ~AtNuEventCounter().

Definition at line 243 of file AtNuEventCounter.h.

Referenced by AddData(), ReDoFluxWeights(), and ResetChain().

Definition at line 239 of file AtNuEventCounter.h.

Referenced by AddData(), and ReDoProductionHeights().

Definition at line 241 of file AtNuEventCounter.h.

Referenced by AddData(), ReDoSolarCycleWeights(), and ResetChain().

Definition at line 245 of file AtNuEventCounter.h.

Referenced by AddData(), ReweightToBartol(), ReweightToFluka(), and ReweightToHonda().

Definition at line 246 of file AtNuEventCounter.h.

Referenced by AddData(), ReweightToBartol(), ReweightToFluka(), and ReweightToHonda().

Definition at line 251 of file AtNuEventCounter.h.

Referenced by AddData(), and SetShieldBackgroundRate().

Definition at line 252 of file AtNuEventCounter.h.

Referenced by AddData(), and SetShieldSignalRate().

Double_t AtNuEventCounter::fSinsq [private]

Definition at line 255 of file AtNuEventCounter.h.

Referenced by AddData(), and SetOscillations().

Double_t AtNuEventCounter::fSinsq13 [private]

Definition at line 256 of file AtNuEventCounter.h.

Referenced by AddData(), and SetOscillations().

Definition at line 280 of file AtNuEventCounter.h.

Referenced by FillTemplates(), Reset(), and WriteTemplates().

Definition at line 281 of file AtNuEventCounter.h.

Referenced by FillTemplates(), Reset(), and WriteTemplates().

Definition at line 248 of file AtNuEventCounter.h.

Referenced by ResetChain(), and UseFullNtuples().

Definition at line 259 of file AtNuEventCounter.h.

Referenced by AddData(), ResetChain(), and SetOscillations().

Definition at line 173 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 171 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 172 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::goodevent [private]

Definition at line 160 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 170 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 162 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::goodslice [private]

Definition at line 159 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::goodtrack [private]

Definition at line 161 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::hires1 [private]

Definition at line 229 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::hires2 [private]

Definition at line 230 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::hires3 [private]

Definition at line 231 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::hires4 [private]

Definition at line 232 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::idact [private]

Definition at line 153 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::idnu [private]

Definition at line 152 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::idres [private]

Definition at line 154 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::index [private]

Definition at line 151 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::lores [private]

Definition at line 228 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Definition at line 175 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::pc [private]

Definition at line 166 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::pnux [private]

Definition at line 156 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::pnuy [private]

Definition at line 157 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::pnuz [private]

Definition at line 158 of file AtNuEventCounter.h.

Referenced by ResetChain().

Definition at line 174 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::recoemu [private]

Definition at line 224 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::recoenu [private]

Definition at line 223 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::recoeshwdwgt [private]

Definition at line 226 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::recoeshwlin [private]

Definition at line 225 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::recoeshwnue [private]

Definition at line 227 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::recolength [private]

Definition at line 222 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::simflag [private]

Definition at line 150 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::solarweight [private]

Definition at line 234 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::spill [private]

Definition at line 169 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::trueemu [private]

Definition at line 220 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::trueeshw [private]

Definition at line 221 of file AtNuEventCounter.h.

Referenced by ResetChain().

Double_t AtNuEventCounter::trueheight [private]

Definition at line 218 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Double_t AtNuEventCounter::truelength [private]

Definition at line 219 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::unixtime [private]

Definition at line 149 of file AtNuEventCounter.h.

Referenced by ResetChain().

Int_t AtNuEventCounter::upmu [private]

Definition at line 167 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().

Int_t AtNuEventCounter::veto [private]

Definition at line 168 of file AtNuEventCounter.h.

Referenced by AddData(), and ResetChain().


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

Generated on 22 Nov 2017 for loon by  doxygen 1.6.1