RockMatrixRAF0720Ext Class Reference

#include <RockMatrixRAF0720Ext.h>

Inheritance diagram for RockMatrixRAF0720Ext:
RockMatrix NuMatrix

List of all members.

Public Member Functions

 RockMatrixRAF0720Ext (Double_t POT=0.0)
virtual void PrepareBins (RockEvent *nu) const
 Returns a copy of the current RockMatrix instance.
virtual void FillJess (const RockEvent &nu, const Double_t weight)
virtual void Fill (const RockEvent &nu, const Double_t weight, const bool display=false)
virtual void Fill (const NuEvent &nu, const Double_t weight, const bool display=false)
virtual void FillFromFileRockEvents (TString fname, TString brName="r")
virtual void FillFromFileNuEvents (TString fname, TString brName="s")
virtual void ResetPOT (Double_t new_POT)
 Sets the POT count directly, without scaling.
virtual Double_t StatsLikelihood (const NuMatrix *with) const
virtual Double_t StatsLikelihood (const RockMatrixRAF0720Ext *with) const
 Compares two NuMatrix objects and returns the LL difference.
virtual RockMatrixRAF0720ExtCopy (void) const
 Makes a 'deep copy' - every subclass should implement this.
virtual Bool_t Complete () const
 Tells the user if the class is completely configured.
virtual TH1 * Spectrum (void) const
 Returns a TH1 object representing the data the spectrum holds. Or zero.
virtual void Draw (Option_t *option="")
virtual Int_t Write (const TString &name) const
 Writes to the current file.
virtual Int_t Read (const TString &fname, const TString &name)
virtual void SetValue (Double_t val)
virtual void ScaleToPOT (Double_t new_POT)
 Changes the POT, by scaling the data.
virtual void Scale (Double_t value)
 Scales the Matrix, without changing the POT.
virtual void Divide (const NuMatrix &correction)
virtual void Divide (const TH1 &correction, const Option_t *option="")
virtual void Divide (const TGraph &correction)
virtual void Multiply (const NuMatrix &correction)
virtual void Multiply (const TH1 &correction, const Option_t *option="")
virtual void Multiply (const TGraph &correction)
virtual void Add (const NuMatrix &correction, Bool_t addpot=false)
virtual void Add (const RockMatrixRAF0720Ext &correction, Bool_t addpot=false)
 Functions for addition and subtraction.
virtual void Subtract (const NuMatrix &correction)
virtual void Subtract (const RockMatrixRAF0720Ext &correction)
virtual void RecoToTrue (const TH2D &correction)
virtual void TrueToReco (const TH2D &correction)
virtual void ExtrapolateNDToFD (const TH2D &beammatrix)
virtual void Oscillate (const Double_t dm2, const Double_t sn2)
virtual void DecayCC (double, double, double)
virtual void DecayNC (double, double)
virtual void DecayMuToTau (double, double, double)
virtual void Decohere (double, double, double)
NuMatrix1DFront (void)
NuMatrix1DGap (void)
NuMatrix1DGapEdge (void)
NuMatrix1DBack (void)
NuMatrix1DEdgeRock (void)
NuMatrix1DEdgeDet (void)
NuMatrix1DCoil (void)
NuMatrix1Ddispfront (void)
NuMatrix1Ddispgap (void)
NuMatrix1Ddispgapedge (void)
NuMatrix1Ddispback (void)
NuMatrix1Ddispedgerock (void)
NuMatrix1Ddispedgedet (void)
NuMatrix1Ddispcoil (void)
NuMatrix1Ddisprocklike (void)
NuMatrix1Ddispdetlike (void)
NuMatrix1Ddispall (void)
NuMatrix1Dadispfront (void)
NuMatrix1Dadispgap (void)
NuMatrix1Dadispgapedge (void)
NuMatrix1Dadispback (void)
NuMatrix1Dadispedgerock (void)
NuMatrix1Dadispedgedet (void)
NuMatrix1Dadispcoil (void)
NuMatrix1Dadisprocklike (void)
NuMatrix1Dadispdetlike (void)
NuMatrix1Dadispall (void)
NuMatrix1Dsdispfront (void)
NuMatrix1Dsdispgap (void)
NuMatrix1Dsdispgapedge (void)
NuMatrix1Dsdispback (void)
NuMatrix1Dsdispedgerock (void)
NuMatrix1Dsdispedgedet (void)
NuMatrix1Dsdispcoil (void)
NuMatrix2DJess_ccmu (void)
NuMatrix2DJess_cctau (void)
NuMatrix1DJess_no (void)
NuMatrix1DAllReco (void)
NuMatrix1DAllRecoNW (void)
NuMatrix1DAllTruth (void)
void GlobalBin2enang (Float_t &dang, Float_t &trkEn, int globalbin)
void GlobalBin2trkEn (Float_t &trkEn, int globalbin)

Static Public Member Functions

static int ear2GlobalBin (const Float_t dang, const Float_t trkEn, const Int_t regionTrkVtx, const Char_t edgemid)
static int Linearize2d (Float_t dang, Float_t trkEn, bool sparse=false)
static void Rectangularize1d (Float_t &dang, Float_t &trkEn, int onedbin, bool sparse=false)
static void GlobalBin2ear (Float_t &dang, Float_t &trkEn, Int_t &regionTrkVtx, Char_t &edgemid, int globalbin)

Protected Attributes

NuMatrix1D fFront
NuMatrix1D fGap
NuMatrix1D fGapEdge
NuMatrix1D fBack
NuMatrix1D fEdgeRock
NuMatrix1D fEdgeDet
NuMatrix1D fCoil
NuMatrix1D fAllReco
NuMatrix1D fAllRecoNW
NuMatrix1D fAllTruth
NuMatrix1D fdispfront
NuMatrix1D fdispgap
NuMatrix1D fdispedgerock
NuMatrix1D fdispedgedet
NuMatrix1D fdispback
NuMatrix1D fdispgapedge
NuMatrix1D fdispcoil
NuMatrix1D fdisprocklike
NuMatrix1D fdispdetlike
NuMatrix1D fdispall
NuMatrix1D fadispfront
NuMatrix1D fadispgap
NuMatrix1D fadispedgerock
NuMatrix1D fadispedgedet
NuMatrix1D fadispback
NuMatrix1D fadispgapedge
NuMatrix1D fadispcoil
NuMatrix1D fadisprocklike
NuMatrix1D fadispdetlike
NuMatrix1D fadispall
NuMatrix1D fsdispfront
NuMatrix1D fsdispgap
NuMatrix1D fsdispedgerock
NuMatrix1D fsdispedgedet
NuMatrix1D fsdispback
NuMatrix1D fsdispgapedge
NuMatrix1D fsdispcoil
NuMatrix1D fsdisprocklike
NuMatrix1D fsdispdetlike
NuMatrix1D fsdispall
NuMatrix2D fJess_ccmu
NuMatrix2D fJess_cctau
NuMatrix1D fJess_no

Detailed Description

Definition at line 20 of file RockMatrixRAF0720Ext.h.


Constructor & Destructor Documentation

RockMatrixRAF0720Ext::RockMatrixRAF0720Ext ( Double_t  POT = 0.0  ) 

Definition at line 106 of file RockMatrixRAF0720Ext.cxx.

References An(), dispa(), dispe(), EA(), En(), fadispall, fadispback, fadispcoil, fadispdetlike, fadispedgedet, fadispedgerock, fadispfront, fadispgap, fadispgapedge, fadisprocklike, fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fdispall, fdispback, fdispcoil, fdispdetlike, fdispedgedet, fdispedgerock, fdispfront, fdispgap, fdispgapedge, fdisprocklike, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fJess_ccmu, fJess_cctau, fJess_no, Plot::Format(), fsdispback, fsdispcoil, fsdispedgedet, fsdispedgerock, fsdispfront, fsdispgap, fsdispgapedge, NBINS1DA, NBINS1DE, NBINS2D, semidispcoarse(), semidispfine(), semidispnone(), NuMatrix1D::SetSpectrum(), and NuMatrix2D::SetSpectrum().

Referenced by Copy().

00106                                                        :
00107                                            NuMatrix(POT), RockMatrix(POT)
00108 {
00109   static unsigned int hin = 0; // Shut ROOT up about histogram names
00110   hin++;
00111 
00112   // Hey look!  It's one of those ROOT functions that modifies a global state!
00113   // I'll do all the extra work necessary to avoid this hurting other people.
00114   bool restore_sumw2 = TH1::GetDefaultSumw2();
00115   TH1::SetDefaultSumw2(); // yes, this sets it for TH1D, TH2D, etc.
00116 
00117   En.Sumw2();
00118   An.Sumw2();
00119   EA.Sumw2();
00120 
00121   semidispnone  .Sumw2();
00122   semidispcoarse.Sumw2();
00123   semidispfine  .Sumw2();
00124 
00125   fGapEdge .SetSpectrum(En);
00126   fCoil    .SetSpectrum(En);
00127   fBack    .SetSpectrum(An);
00128   fFront   .SetSpectrum(EA);
00129   fGap     .SetSpectrum(EA);
00130   fEdgeRock.SetSpectrum(EA);
00131   fEdgeDet .SetSpectrum(EA);
00132 
00133   const int NHISTOS = 7;  // These are the numbers used directly for analysis
00134   // normal bins plus under & overflow for each, even if those are always empty
00135   int totalbins = NBINS1DA + NBINS1DE*2 + 4*NBINS2D + NHISTOS*2;
00136 
00137 // ------------------------------------------------------------------------
00138 
00139   // These are for Jess and not used by the RAF analysis
00140   TH2D true2reco(TString::Format("trueenergy2recobin%d", hin),
00141                    "trueenergy2recobin", 800, 0, 200, totalbins, 0, totalbins);
00142 
00143   TH1D oned(TString::Format("oned%d", hin), "", totalbins, 0, totalbins);
00144 
00145   fJess_ccmu.SetSpectrum(true2reco); // CC nu mu (bar) events
00146   fJess_cctau.SetSpectrum(true2reco); // CC nu tau (bar) events
00147   fJess_no.SetSpectrum(oned); // All else, i.e. things that don't oscillate
00148 
00149 // ------------------------------------------------------------------------
00150 
00151   // This is for convenience of debugging
00152   TH1D reco(TString::Format("recobin%d", hin),
00153              "recobin", totalbins, 0, totalbins);
00154   fAllReco.SetSpectrum(reco);
00155   fAllRecoNW.SetSpectrum(reco);
00156 
00157   TH1D truth(TString::Format("truthbin%d", hin),
00158              "truthbin", 800, 0, 200);
00159   fAllTruth.SetSpectrum(truth);
00160 
00161 
00162 // ------------------------------------------------------------------------
00163 
00164   // These are for display (and debugging)
00165 
00166   fdispfront   .SetSpectrum(dispe);
00167   fdispgap     .SetSpectrum(dispe);
00168   fdispedgerock.SetSpectrum(dispe);
00169   fdispedgedet .SetSpectrum(dispe);
00170   fdispback    .SetSpectrum(dispe);
00171   fdispgapedge .SetSpectrum(dispe);
00172   fdispcoil    .SetSpectrum(dispe);
00173 
00174   fsdispfront   .SetSpectrum(semidispfine);
00175   fsdispedgerock.SetSpectrum(semidispfine);
00176   fsdispedgedet .SetSpectrum(semidispfine);
00177   fsdispgap     .SetSpectrum(semidispcoarse);
00178   fsdispgapedge .SetSpectrum(semidispcoarse);
00179   fsdispcoil    .SetSpectrum(semidispcoarse);
00180   fsdispback    .SetSpectrum(semidispnone);
00181 
00182   fdisprocklike.SetSpectrum(dispe);
00183   fdispdetlike .SetSpectrum(dispe);
00184   fdispall     .SetSpectrum(dispe);
00185 
00186   fadispfront   .SetSpectrum(dispa);
00187   fadispgap     .SetSpectrum(dispa);
00188   fadispedgerock.SetSpectrum(dispa);
00189   fadispedgedet .SetSpectrum(dispa);
00190   fadispback    .SetSpectrum(dispa);
00191   fadispgapedge .SetSpectrum(dispa);
00192   fadispcoil    .SetSpectrum(dispa);
00193 
00194   fadisprocklike.SetSpectrum(dispa);
00195   fadispdetlike .SetSpectrum(dispa);
00196   fadispall     .SetSpectrum(dispa);
00197 
00198   // Put the GLOBAL state back to where it was at the top
00199   TH1::SetDefaultSumw2(restore_sumw2);
00200 }


Member Function Documentation

void RockMatrixRAF0720Ext::Add ( const RockMatrixRAF0720Ext correction,
Bool_t  addpot = false 
) [virtual]

Functions for addition and subtraction.

Implements NuMatrix.

Definition at line 1204 of file RockMatrixRAF0720Ext.cxx.

References NuMatrix1D::Add(), fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, NuMatrix::GetPOT(), and ResetPOT().

01205 {
01206   // Base the addition on the 'essential' histograms listed in complete
01207   // Also, this probably won't be used so don't bother with validation/clever behaviour for now
01208   fFront.Add(correction.fFront);
01209   fGap.Add(correction.fGap);
01210   fGapEdge.Add(correction.fGapEdge);
01211   fBack.Add(correction.fBack);
01212   fEdgeRock.Add(correction.fEdgeRock);
01213   fEdgeDet.Add(correction.fEdgeDet);
01214   fCoil.Add(correction.fCoil);
01215   
01216   if (addpot) ResetPOT(GetPOT()+correction.GetPOT());
01217 }

void RockMatrixRAF0720Ext::Add ( const NuMatrix correction,
Bool_t  addpot = false 
) [virtual]

Definition at line 1192 of file RockMatrixRAF0720Ext.cxx.

References Msg::kWarning, and MSG.

01193 {
01194   // Convert the NuMatrix to a RockMatrixRAF0720Ext
01195   const RockMatrixRAF0720Ext *other = dynamic_cast<const RockMatrixRAF0720Ext*>(&with);
01196   if (other == 0) {
01197     MSG("RockMatrixRAF0720Ext",Msg::kWarning) << "Attempting to add a RockMatrixRAF0720Ext to something other than a RockMatrixRAF0720Eonly" << endl;
01198   }
01199 
01200   this->Add(*other, addpot);
01201 }

NuMatrix1D& RockMatrixRAF0720Ext::adispall ( void   )  [inline]

Definition at line 110 of file RockMatrixRAF0720Ext.h.

References fadispall.

00110 { return fadispall; }

NuMatrix1D& RockMatrixRAF0720Ext::adispback ( void   )  [inline]

Definition at line 103 of file RockMatrixRAF0720Ext.h.

References fadispback.

00103 { return fadispback; }

NuMatrix1D& RockMatrixRAF0720Ext::adispcoil ( void   )  [inline]

Definition at line 106 of file RockMatrixRAF0720Ext.h.

References fadispcoil.

00106 { return fadispcoil; }

NuMatrix1D& RockMatrixRAF0720Ext::adispdetlike ( void   )  [inline]

Definition at line 109 of file RockMatrixRAF0720Ext.h.

References fadispdetlike.

00109 { return fadispdetlike; }

NuMatrix1D& RockMatrixRAF0720Ext::adispedgedet ( void   )  [inline]

Definition at line 105 of file RockMatrixRAF0720Ext.h.

References fadispedgedet.

00105 { return fadispedgedet; }

NuMatrix1D& RockMatrixRAF0720Ext::adispedgerock ( void   )  [inline]

Definition at line 104 of file RockMatrixRAF0720Ext.h.

References fadispedgerock.

00104 { return fadispedgerock; }

NuMatrix1D& RockMatrixRAF0720Ext::adispfront ( void   )  [inline]

Definition at line 100 of file RockMatrixRAF0720Ext.h.

References fadispfront.

00100 { return fadispfront; }

NuMatrix1D& RockMatrixRAF0720Ext::adispgap ( void   )  [inline]

Definition at line 101 of file RockMatrixRAF0720Ext.h.

References fadispgap.

00101 { return fadispgap; }

NuMatrix1D& RockMatrixRAF0720Ext::adispgapedge ( void   )  [inline]

Definition at line 102 of file RockMatrixRAF0720Ext.h.

References fadispgapedge.

00102 { return fadispgapedge; }

NuMatrix1D& RockMatrixRAF0720Ext::adisprocklike ( void   )  [inline]

Definition at line 108 of file RockMatrixRAF0720Ext.h.

References fadisprocklike.

00108 { return fadisprocklike; }

NuMatrix1D& RockMatrixRAF0720Ext::AllReco ( void   )  [inline]

Definition at line 123 of file RockMatrixRAF0720Ext.h.

References fAllReco.

00123 { return fAllReco; }  

NuMatrix1D& RockMatrixRAF0720Ext::AllRecoNW ( void   )  [inline]

Definition at line 124 of file RockMatrixRAF0720Ext.h.

References fAllRecoNW.

00124 { return fAllRecoNW; }  

NuMatrix1D& RockMatrixRAF0720Ext::AllTruth ( void   )  [inline]

Definition at line 125 of file RockMatrixRAF0720Ext.h.

References fAllTruth.

00125 { return fAllTruth; }  

NuMatrix1D& RockMatrixRAF0720Ext::Back ( void   )  [inline]

Definition at line 83 of file RockMatrixRAF0720Ext.h.

References fBack.

00083 { return fBack; }

NuMatrix1D& RockMatrixRAF0720Ext::Coil ( void   )  [inline]

Definition at line 86 of file RockMatrixRAF0720Ext.h.

References fCoil.

00086 { return fCoil; }

Bool_t RockMatrixRAF0720Ext::Complete (  )  const [virtual]

Tells the user if the class is completely configured.

Implements NuMatrix.

Definition at line 1173 of file RockMatrixRAF0720Ext.cxx.

References NuMatrix1D::Complete(), fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, and fGapEdge.

01174 {
01175   return true; // I'm short circuiting this since the below always arrives here
01176 
01177   Bool_t complete = true;
01178 
01179   // This can't possibly return anything but true... what's the point?
01180   complete = complete || fFront.Complete();
01181   complete = complete || fGap.Complete();
01182   complete = complete || fGapEdge.Complete();
01183   complete = complete || fBack.Complete();
01184   complete = complete || fEdgeRock.Complete();
01185   complete = complete || fEdgeDet.Complete();
01186   complete = complete || fCoil.Complete();
01187 
01188   return complete;
01189 }

virtual RockMatrixRAF0720Ext* RockMatrixRAF0720Ext::Copy ( void   )  const [inline, virtual]

Makes a 'deep copy' - every subclass should implement this.

Implements NuMatrix.

Definition at line 42 of file RockMatrixRAF0720Ext.h.

References RockMatrixRAF0720Ext().

00042                                                  {
00043     return new RockMatrixRAF0720Ext(*this);
00044   }

virtual void RockMatrixRAF0720Ext::DecayCC ( double  ,
double  ,
double   
) [inline, virtual]

Definition at line 74 of file RockMatrixRAF0720Ext.h.

00074 {assert(0 && "Not implemented");}

virtual void RockMatrixRAF0720Ext::DecayMuToTau ( double  ,
double  ,
double   
) [inline, virtual]

Definition at line 76 of file RockMatrixRAF0720Ext.h.

00076 {assert(0 && "Not implemented");}

virtual void RockMatrixRAF0720Ext::DecayNC ( double  ,
double   
) [inline, virtual]

Definition at line 75 of file RockMatrixRAF0720Ext.h.

00075 {assert(0 && "Not implemented");}

virtual void RockMatrixRAF0720Ext::Decohere ( double  ,
double  ,
double   
) [inline, virtual]

Definition at line 77 of file RockMatrixRAF0720Ext.h.

00077 {assert(0 && "Not implemented");}

NuMatrix1D& RockMatrixRAF0720Ext::dispall ( void   )  [inline]

Definition at line 98 of file RockMatrixRAF0720Ext.h.

References fdispall.

00098 { return fdispall; }

NuMatrix1D& RockMatrixRAF0720Ext::dispback ( void   )  [inline]

Definition at line 91 of file RockMatrixRAF0720Ext.h.

References fdispback.

00091 { return fdispback; }

NuMatrix1D& RockMatrixRAF0720Ext::dispcoil ( void   )  [inline]

Definition at line 94 of file RockMatrixRAF0720Ext.h.

References fdispcoil.

00094 { return fdispcoil; }

NuMatrix1D& RockMatrixRAF0720Ext::dispdetlike ( void   )  [inline]

Definition at line 97 of file RockMatrixRAF0720Ext.h.

References fdispdetlike.

00097 { return fdispdetlike; }

NuMatrix1D& RockMatrixRAF0720Ext::dispedgedet ( void   )  [inline]

Definition at line 93 of file RockMatrixRAF0720Ext.h.

References fdispedgedet.

00093 { return fdispedgedet; }

NuMatrix1D& RockMatrixRAF0720Ext::dispedgerock ( void   )  [inline]

Definition at line 92 of file RockMatrixRAF0720Ext.h.

References fdispedgerock.

00092 { return fdispedgerock; }

NuMatrix1D& RockMatrixRAF0720Ext::dispfront ( void   )  [inline]

Definition at line 88 of file RockMatrixRAF0720Ext.h.

References fdispfront.

00088 { return fdispfront; }

NuMatrix1D& RockMatrixRAF0720Ext::dispgap ( void   )  [inline]

Definition at line 89 of file RockMatrixRAF0720Ext.h.

References fdispgap.

00089 { return fdispgap; }

NuMatrix1D& RockMatrixRAF0720Ext::dispgapedge ( void   )  [inline]

Definition at line 90 of file RockMatrixRAF0720Ext.h.

References fdispgapedge.

00090 { return fdispgapedge; }

NuMatrix1D& RockMatrixRAF0720Ext::disprocklike ( void   )  [inline]

Definition at line 96 of file RockMatrixRAF0720Ext.h.

References fdisprocklike.

00096 { return fdisprocklike; }

void RockMatrixRAF0720Ext::Divide ( const TGraph &  correction  )  [virtual]

Implements NuMatrix.

Definition at line 1122 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01123 {
01124   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Divide not implemented"<<endl;
01125 }

void RockMatrixRAF0720Ext::Divide ( const TH1 &  correction,
const Option_t *  option = "" 
) [virtual]

Implements NuMatrix.

Definition at line 1116 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01117 {
01118   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Divide not implemented"<<endl;
01119 }

void RockMatrixRAF0720Ext::Divide ( const NuMatrix correction  )  [virtual]

Definition at line 1110 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01111 {
01112   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Divide not implemented"<<endl;
01113 }

void RockMatrixRAF0720Ext::Draw ( Option_t *  option = ""  )  [virtual]

Implements NuMatrix.

Definition at line 957 of file RockMatrixRAF0720Ext.cxx.

00958 {
00959 
00960 }

int RockMatrixRAF0720Ext::ear2GlobalBin ( const Float_t  dang,
const Float_t  trkEn,
const Int_t  regionTrkVtx,
const Char_t  edgemid 
) [static]

Definition at line 205 of file RockMatrixRAF0720Ext.cxx.

References An(), En(), Msg::kError, Linearize2d(), MAXMSG, NBINS1DA, NBINS1DE, and NBINS2D.

Referenced by GlobalBin2ear(), and PrepareBins().

00207 {
00208   // This awkwardly duplicates Fill, and must be kept in sync with it
00209   // Whee good programming practices!
00210 
00211   const int UNDERANDOVERFLOW = 2;
00212 
00213   if(regionTrkVtx==4 || regionTrkVtx==5 || regionTrkVtx==6){ // Front and front+edge and front+coil
00214     return Linearize2d(dang, trkEn) + 1;
00215   }
00216 
00217   else if(regionTrkVtx==8 || regionTrkVtx==12 || 
00218           regionTrkVtx==10 || regionTrkVtx==14){ // N & S side of gap, gap+coil
00219     return Linearize2d(dang, trkEn, true) + 1 // SPARSE
00220       + NBINS2D
00221       + UNDERANDOVERFLOW;
00222     // The tree in the hole in the ground
00223   }
00224 
00225   else if(regionTrkVtx==9 || regionTrkVtx==13){ //N & S side of gap+edge
00226     return En.FindBin(trkEn)
00227       + NBINS2D
00228       + NBINS2D
00229       + 2*UNDERANDOVERFLOW;
00230       // The branch on the tree in the hole in the ground
00231   }
00232 
00233   else if(regionTrkVtx==16 || regionTrkVtx==17 || regionTrkVtx==18){ // Back and back+edge/coil
00234     return An.FindBin(dang)
00235       + NBINS2D
00236       + NBINS2D
00237       + NBINS1DE
00238       + 3*UNDERANDOVERFLOW;
00239      // The twig on the branch on the tree in the hole in the ground
00240   }
00241 
00242   else if(regionTrkVtx==1 && edgemid == 0){ // Edge rock-like
00243     return
00244       Linearize2d(dang, trkEn) + 1
00245       + NBINS2D
00246       + NBINS2D
00247       + NBINS1DE
00248       + NBINS1DA
00249       + 4*UNDERANDOVERFLOW;
00250      // The bug on the twig on the branch on the tree in the hole in the ground
00251   }
00252 
00253   else if(regionTrkVtx==1 && edgemid == 1){ // Edge detector-like
00254     return
00255       Linearize2d(dang, trkEn) + 1
00256       + NBINS2D
00257       + NBINS2D
00258       + NBINS1DE
00259       + NBINS1DA
00260       + NBINS2D
00261       + 5*UNDERANDOVERFLOW;
00262      // The hair on the bug on the twig on the branch on the tree in the hole
00263      // in the ground
00264   }
00265 
00266   else if(regionTrkVtx==2){ // Coil
00267     return En.FindBin(trkEn)
00268       + NBINS2D
00269       + NBINS2D
00270       + NBINS1DE
00271       + NBINS1DA
00272       + NBINS2D
00273       + NBINS2D
00274       + 6*UNDERANDOVERFLOW;
00275      // The protein in the hair on the bug on the twig on the branch on the 
00276      // tree in the hole in the ground & ||: the green grass grows all round :||
00277   }
00278 
00279   else{
00280     MAXMSG("RockMatrixRAF0720Ext", Msg::kError, 100) <<
00281      "No events should reach this point in RockMatrixRAF0720Ext::"
00282      "ear2GlobalBin!\nregionTrkVtx = " << int(regionTrkVtx) << endl <<
00283      "edgemid = "      << int(edgemid) << endl;
00284     return -1;
00285   }
00286 }

NuMatrix1D& RockMatrixRAF0720Ext::EdgeDet ( void   )  [inline]

Definition at line 85 of file RockMatrixRAF0720Ext.h.

References fEdgeDet.

00085 { return fEdgeDet; }

NuMatrix1D& RockMatrixRAF0720Ext::EdgeRock ( void   )  [inline]

Definition at line 84 of file RockMatrixRAF0720Ext.h.

References fEdgeRock.

00084 { return fEdgeRock; }

void RockMatrixRAF0720Ext::ExtrapolateNDToFD ( const TH2D &  beammatrix  )  [virtual]

Implements NuMatrix.

Definition at line 1159 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01160 {
01161   MSG("RockMatrixRAF0720Ext",Msg::kError)
01162     << "ExtrapolateNDToFD not implemented" << endl;
01163 }

virtual void RockMatrixRAF0720Ext::Fill ( const NuEvent nu,
const Double_t  weight,
const bool  display = false 
) [inline, virtual]

Implements RockMatrix.

Definition at line 29 of file RockMatrixRAF0720Ext.h.

References Fill().

00029                                                                                           {
00030     this->Fill(RockEvent(nu), weight, display);
00031   }

void RockMatrixRAF0720Ext::Fill ( const RockEvent nu,
const Double_t  weight,
const bool  display = false 
) [virtual]

Implements RockMatrix.

Definition at line 751 of file RockMatrixRAF0720Ext.cxx.

References RockEvent::binNumber, clampcoarse(), clampfine(), clampnone(), RockEvent::dang, RockEvent::edgemid, fadispall, fadispback, fadispcoil, fadispdetlike, fadispedgedet, fadispedgerock, fadispfront, fadispgap, fadispgapedge, fadisprocklike, fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fdispall, fdispback, fdispcoil, fdispdetlike, fdispedgedet, fdispedgerock, fdispfront, fdispgap, fdispgapedge, fdisprocklike, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fsdispback, fsdispcoil, fsdispedgedet, fsdispedgerock, fsdispfront, fsdispgap, fsdispgapedge, Msg::kError, Linearize2d(), MAXMSG, RockEvent::neuEnMC, RockEvent::regionTrkVtx, NuMatrix1D::Spectrum(), spoonlawn(), and RockEvent::trkEn.

Referenced by Fill(), FillFromFileNuEvents(), and FillFromFileRockEvents().

00752 {
00753   const bool userocklike = true, usedetlike = true;
00754 
00755   // Don't fill jesstograms here since oscillation has already occured,
00756   // or if it hasn't, the taus have, in any case, been zeroed.
00757   // these are the same as adding together the three jesstograms and then
00758   // collapsing them to 1D.  It is pure convenience to explicitly construct
00759   // them here.
00760   if(display){
00761     fAllReco  .Spectrum()->Fill(nu.binNumber, weight);
00762     fAllRecoNW.Spectrum()->Fill(nu.binNumber);
00763     fAllTruth .Spectrum()->Fill(nu.neuEnMC, weight);
00764     fdispall  .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00765     fadispall .Spectrum()->Fill(nu.dang, weight);
00766   }
00767 
00768   // Decide where to fill based on region
00769   if(nu.regionTrkVtx==4 || nu.regionTrkVtx==5 || nu.regionTrkVtx==6){ // Front and front+edge/coil
00770     if(userocklike) fFront.Spectrum()->Fill(Linearize2d(nu.dang, nu.trkEn), weight);
00771     if(display){
00772       fdispfront    .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00773       fsdispfront   .Spectrum()->Fill(clampfine(nu.trkEn), weight);
00774       fdisprocklike .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00775       fadispfront   .Spectrum()->Fill(nu.dang, weight);
00776       fadisprocklike.Spectrum()->Fill(nu.dang, weight);
00777     }
00778   }
00779 
00780   else if(nu.regionTrkVtx==8  || nu.regionTrkVtx==12 ||
00781           nu.regionTrkVtx==10 || nu.regionTrkVtx==14){ // N & S side of gap(+coil)
00782     // gap is sparse, see Linearize2d
00783     if(usedetlike) fGap.Spectrum()->Fill(Linearize2d(nu.dang, nu.trkEn, true), weight);
00784     if(display){
00785       fdispgap     .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00786       fsdispgap    .Spectrum()->Fill(clampcoarse(nu.trkEn), weight);
00787       fadispgap    .Spectrum()->Fill(nu.dang, weight);
00788       fdispdetlike .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00789       fadispdetlike.Spectrum()->Fill(nu.dang, weight);
00790     }
00791   }
00792 
00793   else if(nu.regionTrkVtx==9 || nu.regionTrkVtx==13){ // N & S side of gap+edge
00794     if(userocklike) fGapEdge.Spectrum()->Fill(nu.trkEn, weight);
00795     if(display){
00796       fdispgapedge  .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00797       fsdispgapedge .Spectrum()->Fill(clampcoarse(nu.trkEn), weight);
00798       fadispgapedge .Spectrum()->Fill(nu.dang, weight);
00799       fdisprocklike .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00800       fadisprocklike.Spectrum()->Fill(nu.dang, weight);
00801     }
00802   }
00803 
00804   else if(nu.regionTrkVtx==16 || nu.regionTrkVtx==17 || nu.regionTrkVtx==18){ // Back and back+edge/coil
00805     if(usedetlike) fBack.Spectrum()->Fill(nu.dang, weight);
00806     if(display){
00807       fdispback    .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00808       fsdispback   .Spectrum()->Fill(clampnone(nu.trkEn), weight);
00809       fadispback   .Spectrum()->Fill(nu.dang, weight);
00810       fdispdetlike .Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00811       fadispdetlike.Spectrum()->Fill(nu.dang, weight);
00812     }
00813   }
00814 
00815   else if(nu.regionTrkVtx==1 && nu.edgemid == 0){ // Edge rock-like
00816     if(userocklike) fEdgeRock.Spectrum()->Fill(Linearize2d(nu.dang, nu.trkEn), weight);
00817     if(display){
00818       fdispedgerock.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00819       fsdispedgerock.Spectrum()->Fill(clampfine(nu.trkEn), weight);
00820       fadispedgerock.Spectrum()->Fill(nu.dang, weight);
00821       fdisprocklike.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00822       fadisprocklike.Spectrum()->Fill(nu.dang, weight);
00823     }
00824   }
00825 
00826   else if(nu.regionTrkVtx==1 && nu.edgemid == 1){ // Edge detector-like
00827     if(usedetlike) fEdgeDet.Spectrum()->Fill(Linearize2d(nu.dang, nu.trkEn), weight);
00828     if(display){
00829       fdispedgedet.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00830       fsdispedgedet.Spectrum()->Fill(clampfine(nu.trkEn), weight);
00831       fadispedgedet.Spectrum()->Fill(nu.dang, weight);
00832       fdispdetlike.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00833       fadispdetlike.Spectrum()->Fill(nu.dang, weight);
00834     }
00835   }
00836 
00837   else if(nu.regionTrkVtx==2){ // Coil
00838     if(usedetlike) fCoil.Spectrum()->Fill(nu.trkEn, weight);
00839     if(display){
00840       fdispcoil.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00841       fsdispcoil.Spectrum()->Fill(clampcoarse(nu.trkEn), weight);
00842       fadispcoil.Spectrum()->Fill(nu.dang, weight);
00843       fdispdetlike.Spectrum()->Fill(spoonlawn(nu.trkEn), weight);
00844       fadispdetlike.Spectrum()->Fill(nu.dang, weight);
00845     }
00846   }
00847 
00848   else{
00849     MAXMSG("RockMatrixRAF0720Ext", Msg::kError, 100)
00850       << "No events should reach this point in RockMatrixRAF0720Ext::Fill!\n"
00851             "regionTrkVtx = " << int(nu.regionTrkVtx) << endl <<
00852             "edgemid = "      << int(nu.edgemid) << endl;
00853   }
00854 }

void RockMatrixRAF0720Ext::FillFromFileNuEvents ( TString  fname,
TString  brName = "s" 
) [virtual]

Definition at line 877 of file RockMatrixRAF0720Ext.cxx.

References Fill(), Msg::kError, MSG, PrepareBins(), and RockEvent::rw.

00878 {
00879   TChain ch(brName);
00880   ch.Add(fname);
00881   if(ch.GetEntries() == 0){
00882     MSG("RockMatrixRAF0720Ext", Msg::kError)
00883       << "Empty or nonexistent file " << fname << endl;
00884     return;
00885   }
00886 
00887   NuEvent* ev = 0;
00888   ch.SetBranchAddress(brName, &ev);
00889   for(int i = 0; i < ch.GetEntries(); ++i){
00890     ch.GetEntry(i);
00891     RockEvent evr(*ev);
00892     PrepareBins(&evr);
00893     Fill(evr, evr.rw, true);
00894   }
00895 }

void RockMatrixRAF0720Ext::FillFromFileRockEvents ( TString  fname,
TString  brName = "r" 
) [virtual]

Definition at line 857 of file RockMatrixRAF0720Ext.cxx.

References Fill(), Msg::kError, MSG, PrepareBins(), and RockEvent::rw.

00858 {
00859   TChain ch(brName);
00860   ch.Add(fname);
00861   if(ch.GetEntries() == 0){
00862     MSG("RockMatrixRAF0720Ext", Msg::kError)
00863       << "Empty or nonexistent file " << fname << endl;
00864     return;
00865   }
00866 
00867   RockEvent* ev = 0;
00868   ch.SetBranchAddress(brName, &ev);
00869   for(int i = 0; i < ch.GetEntries(); ++i){
00870     ch.GetEntry(i);
00871     PrepareBins(ev);
00872     Fill(*ev, ev->rw, true);
00873   }
00874 }

void RockMatrixRAF0720Ext::FillJess ( const RockEvent nu,
const Double_t  weight 
) [virtual]

Reimplemented from RockMatrix.

Definition at line 729 of file RockMatrixRAF0720Ext.cxx.

References RockEvent::binNumber, fJess_ccmu, fJess_cctau, fJess_no, RockEvent::iaction, RockEvent::inu, RockEvent::neuEnMC, NuMatrix1D::Spectrum(), and NuMatrix2D::Spectrum().

00730 {
00731   // Fill these true-to-reco histograms for Jess.
00732 
00733   // Numu(bar) charged current
00734   if(nu.iaction == 1 && abs(nu.inu) == 14)
00735     fJess_ccmu.Spectrum()->Fill(nu.neuEnMC, nu.binNumber, weight);
00736 
00737   // Nutau(bar) charged current
00738   if(nu.iaction == 1 && abs(nu.inu) == 16)
00739     fJess_cctau.Spectrum()->Fill(nu.neuEnMC, nu.binNumber, weight);
00740 
00741   // Neutral current, nue(bar) and (accidentally) most real data
00742   // Don't include taus here because we'd double-count them (the taus are
00743   // unoscillated at this point)
00744   if((nu.iaction == 0 && abs(nu.inu) != 16) || abs(nu.inu) == 12)
00745     fJess_no.Spectrum()->Fill(nu.binNumber, weight);
00746 }

NuMatrix1D& RockMatrixRAF0720Ext::Front ( void   )  [inline]

Definition at line 80 of file RockMatrixRAF0720Ext.h.

References fFront.

00080 { return fFront; }

NuMatrix1D& RockMatrixRAF0720Ext::Gap ( void   )  [inline]

Definition at line 81 of file RockMatrixRAF0720Ext.h.

References fGap.

00081 { return fGap; }

NuMatrix1D& RockMatrixRAF0720Ext::GapEdge ( void   )  [inline]

Definition at line 82 of file RockMatrixRAF0720Ext.h.

References fGapEdge.

00082 { return fGapEdge; }

void RockMatrixRAF0720Ext::GlobalBin2ear ( Float_t &  dang,
Float_t &  trkEn,
Int_t &  regionTrkVtx,
Char_t &  edgemid,
int  globalbin 
) [static]

Definition at line 329 of file RockMatrixRAF0720Ext.cxx.

References An(), ear2GlobalBin(), En(), issueobobwarning(), Msg::kError, MSG, NBINS1DA, NBINS1DE, NBINS2D, and Rectangularize1d().

Referenced by GlobalBin2enang(), and GlobalBin2trkEn().

00331 {
00332   // See PrepareBins for how the global bin number is found.  This 
00333   // function reverses the procedure.  This is obviously somewhat fragile
00334   // and quite possibly will need to be edited if PrepareBins is edited!
00335 
00336   dang = trkEn = -1; // junk default values for errors
00337   edgemid = regionTrkVtx = -1;
00338 
00339   // 2s are for overflow and underflow bins.  -1 is an artifact of how the 
00340   // global bin number is calculated.  See below.
00341   int lastbin_front   =       -1         + NBINS2D  + 2,
00342       lastbin_gap     = lastbin_front    + NBINS2D  + 2,
00343       lastbin_gapedge = lastbin_gap      + NBINS1DE + 2,
00344       lastbin_back    = lastbin_gapedge  + NBINS1DA + 2,
00345       lastbin_edgerock= lastbin_back     + NBINS2D  + 2,
00346       lastbin_edgedet = lastbin_edgerock + NBINS2D  + 2,
00347       lastbin_coil    = lastbin_edgedet  + NBINS1DE + 2;
00348 
00349   if(globalbin < 1){
00350      MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00351      "below 1 (" << globalbin << "). Underflow should not be possible.\n";
00352      return;
00353   }
00354   else if(globalbin >= lastbin_coil+1){
00355      MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00356      << globalbin << " greater than the number of bins in fAllReco (" 
00357      << lastbin_coil << ").\n";
00358      issueobobwarning();
00359      return;
00360   }
00361 
00362   if(globalbin <= lastbin_front){
00363     // So what's going on here?  The lowest bin that can actually get filled
00364     // is created as follows: An event on the front face with trkEn < 0.5 and 
00365     // dang < 30 is passed into Linearize2d, which returns 0. PrepareBins gets
00366     // the value zero and wants to fill fFront with it.  fFront is a 1D 
00367     // histogram with 133 bins and range 0 to 133 (so that 133 itself goes into
00368     // the overflow bin).  So the value 0 gets put into bin number 1.  
00369     // the global bin number is then set to just that.
00370     // 
00371     // Now, Rectangularize1d is the straight-up inverse of Linearize2d, so it
00372     // knows nothing about the off-by-one shift we caused above.  So:
00373 
00374     Rectangularize1d(dang, trkEn, globalbin-1);
00375     regionTrkVtx = 4; // semi-fiducial front
00376     edgemid = 1; // not very meaningful
00377   }
00378   else if(globalbin == lastbin_front+1){
00379     MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00380     << globalbin << " would be an underflow in fGap.  That can't happen.\n";
00381      issueobobwarning();
00382     return;
00383   }
00384   else if(globalbin <= lastbin_gap){
00385     // Now the next histogram, fGap. The lowest bin of this does the following:
00386     // Linearize2d returns 0.  PrepareBins determines that this goes in bin 1 of
00387     // fGap, and calculates the global bin number as:
00388     // 1 + fFront.GetNbinsX() [133] + UNDERANDOVERFLOW [2] = 136
00389     // We want this go to back into Retangularize1d as 0.
00390     // The last bin (including overflow) of fFront is global bin number 134. So:
00391 
00392     Rectangularize1d(dang, trkEn, globalbin - lastbin_front - 2, true);//SPARSE
00393     regionTrkVtx = 12; // north side of semi-fiducial gap
00394     edgemid = 1; // not very meaningful
00395   }
00396   else if(globalbin <= lastbin_gapedge){
00397     // Now the next histogram, fGapEdge.  This is 1D in trkEn.  The lowest 
00398     // non-underflow bin of this (bin number 1) has global bin number 271, so 
00399     // to retrieve the bin number in fGapEdge, we have to subtract 270
00400     // The pattern now starts to be clear: 
00401     // --> global - lastbin - 2 (1) for linearized (normal) histograms <--
00402 
00403     dang = 45; // no information on angle
00404 
00405     // What does this return for the overflow bin, you might wonder.
00406     // Turns out it figures that ROOT pretends that the overflow bin has the
00407     // average width of the non-overflow bins in this case.
00408     trkEn = En.GetBinCenter(globalbin - lastbin_gap - 1);
00409 
00410     regionTrkVtx = 13; // north side of gap+edge
00411     edgemid = 0; // not very meaningful
00412   }
00413   else if(globalbin <= lastbin_back){
00414     // Now the back histogram, which has no energy information
00415 
00416     trkEn = 1.111; //Hey! This might be annoying! But so might 0, -1 or 10000...
00417     dang = An.GetBinCenter(globalbin - lastbin_gapedge - 1);
00418 
00419     regionTrkVtx = 16; // semi-fiducial back
00420     edgemid = 0; // not very meaningful
00421   }
00422   else if(globalbin == lastbin_back+1){
00423     MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00424     << globalbin<< " would be an underflow in fEdgeRock.  That can't happen.\n";
00425     issueobobwarning();
00426     return;
00427   }
00428   else if(globalbin <= lastbin_edgerock){
00429     Rectangularize1d(dang, trkEn, globalbin - lastbin_back - 2);
00430     regionTrkVtx = 1; // semi-fiducial edge
00431     edgemid = 0; // detector-like edge
00432   }
00433   else if(globalbin == lastbin_edgerock+1){
00434     MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00435     << globalbin <<" would be an underflow in fEdgeRock.  That can't happen.\n";
00436     issueobobwarning();
00437     return;
00438   }
00439   else if(globalbin <= lastbin_edgedet){
00440     Rectangularize1d(dang, trkEn, globalbin - lastbin_edgerock - 2);
00441     regionTrkVtx = 1; // semi-fiducial edge
00442     edgemid = 1; // rock-like edge
00443   }
00444   else if(globalbin == lastbin_edgedet+1){
00445     MSG("RockMatrixRAF0720Std", Msg::kError) << "Unexpected global bin number "
00446     << globalbin <<" would be an underflow in fCoil.  That can't happen.\n";
00447     issueobobwarning();
00448     return;
00449   }
00450   else if(globalbin <= lastbin_coil){
00451     dang = 45; // no information on angle
00452     trkEn = En.GetBinCenter(globalbin - lastbin_edgedet - 1);
00453     regionTrkVtx = 2;
00454     edgemid = 1; // not very meaningful
00455   }
00456 
00457   // check answer
00458   if(ear2GlobalBin(dang, trkEn, regionTrkVtx, edgemid) != globalbin)
00459     cerr<<"OH NO: inconsistent GlobalBin2ear result for " << globalbin << endl
00460     << dang << " " << trkEn << " " << regionTrkVtx << " " << edgemid << endl;
00461 }

void RockMatrixRAF0720Ext::GlobalBin2enang ( Float_t &  dang,
Float_t &  trkEn,
int  globalbin 
)

Definition at line 308 of file RockMatrixRAF0720Ext.cxx.

References GlobalBin2ear().

00310 {
00311   Int_t regionTrkVtx = 0;
00312   Char_t edgemid = 0;
00313   GlobalBin2ear(dang, trkEn, regionTrkVtx, edgemid, globalbin);
00314 }

void RockMatrixRAF0720Ext::GlobalBin2trkEn ( Float_t &  trkEn,
int  globalbin 
)

Definition at line 298 of file RockMatrixRAF0720Ext.cxx.

References GlobalBin2ear().

00299 {
00300   Int_t regionTrkVtx = 0;
00301   Char_t edgemid = 0;
00302   Float_t dang = 0;
00303   GlobalBin2ear(dang, trkEn, regionTrkVtx, edgemid, globalbin);
00304 }

NuMatrix2D& RockMatrixRAF0720Ext::Jess_ccmu ( void   )  [inline]

Definition at line 120 of file RockMatrixRAF0720Ext.h.

References fJess_ccmu.

00120 { return fJess_ccmu; }

NuMatrix2D& RockMatrixRAF0720Ext::Jess_cctau ( void   )  [inline]

Definition at line 121 of file RockMatrixRAF0720Ext.h.

References fJess_cctau.

00121 { return fJess_cctau; }

NuMatrix1D& RockMatrixRAF0720Ext::Jess_no ( void   )  [inline]

Definition at line 122 of file RockMatrixRAF0720Ext.h.

References fJess_no.

00122 { return fJess_no; }

int RockMatrixRAF0720Ext::Linearize2d ( Float_t  dang,
Float_t  trkEn,
bool  sparse = false 
) [static]

Definition at line 582 of file RockMatrixRAF0720Ext.cxx.

Referenced by ear2GlobalBin(), Fill(), and Rectangularize1d().

00583 {
00584   // Notes:
00585   // * Non-use of "else" in this function is deliberate
00586   // * This could be written more compactly in a variety of ways.
00587   //   All of the ones I can think of make it essentially unreadable.
00588   if(trkEn < 0.5){
00589     if(dang < 30) return 0;
00590                   return 1;
00591   }
00592 
00593   if(trkEn < 1.0){
00594     if(dang < 10) return 2;
00595     if(dang < 15) return 3;
00596     if(dang < 20) return 4;
00597     if(dang < 25) return 5;
00598     if(dang < 30) return 6;
00599     if(dang < 35) return 7;
00600     if(dang < 40) return 8;
00601     if(dang < 45) return 9;
00602     if(dang < 50) return 10;
00603     if(dang < 55) return 11;
00604                   return 12;
00605   }
00606 
00607   if(trkEn < 1.5){
00608     if(dang < 10) return 13;
00609     if(dang < 15) return 14;
00610     if(dang < 20) return 15;
00611     if(dang < 25) return 16;
00612     if(dang < 30) return 17;
00613     if(dang < 35) return 18;
00614     if(dang < 40) return 19;
00615     if(dang < 45) return 20;
00616     if(dang < 50) return 21;
00617                   return 22;
00618   }
00619 
00620   if(trkEn < 2.0){
00621     if(dang < 10) return 23;
00622     if(dang < 15) return 24;
00623     if(dang < 20) return 25;
00624     if(dang < 25) return 26;
00625     if(dang < 30) return 27;
00626     if(dang < 35) return 28;
00627                   return 29;
00628   }
00629 
00630   if(trkEn < 2.5){
00631     if(dang < 10) return 30;
00632     if(dang < 15) return 31;
00633     if(dang < 20) return 32;
00634     if(dang < 25) return 33;
00635     if(dang < 30) return 34;
00636                   return 35;
00637   }
00638 
00639   if(trkEn < 3.0){
00640     if(dang < 5)  return 36;
00641     if(dang < 10) return 37;
00642     if(dang < 15) return 38;
00643     if(dang < 20) return 39;
00644                   return 40;
00645   }
00646 
00647   if(trkEn < 3.5){
00648     if(dang < 5)  return 41;
00649     if(dang < 10) return 42;
00650     if(dang < 15) return 43;
00651     if(dang < 20) return 44;
00652                   return 45;
00653   }
00654 
00655   if(trkEn < 4.0){
00656     if(dang < 10) return 46;
00657                   return 47;
00658   }
00659 
00660   if(trkEn < 4.5){
00661     if(dang < 10) return 48;
00662                   return 49;
00663   }
00664 
00665   if(trkEn < 5.0){
00666     if(dang < 10) return 50;
00667                   return 51;
00668   }
00669 
00670   if(!sparse){
00671     // If not sparse, match the fiducial binning
00672     // It only matches for ease of explanation, not for any technical reason
00673 
00674     if(trkEn <  20.0) return  52 + int( (trkEn -  5.0)*4 ); // max 111
00675     if(trkEn <  30.0) return 112 + int(  trkEn - 20.0    ); // max 121
00676     if(trkEn <  50.0) return 122 + int( (trkEn - 30.0)/2 ); // max 131
00677     if(trkEn < 200.0) return 132;
00678 
00679 
00680     return 133; // intended to go into the overflow bin
00681                 // Really no events should be over 200 GeV (but some are)
00682   }
00683   else{
00684     // 1/2 GeV for 5-10
00685     // 5 GeV for 10-30
00686     // 1 bin for 30-200
00687 
00688     if(trkEn < 10)  return 52 + int( (trkEn -  5.0)*2 ); // max 61
00689     if(trkEn < 30)  return 62 + int( (trkEn - 10.0)/5 ); // max 65
00690     if(trkEn < 200) return 66;
00691 
00692     return 133; // overflow: use same number as above to make sure it goes into 
00693                 // the overflow bin
00694   }
00695 }

void RockMatrixRAF0720Ext::Multiply ( const TGraph &  correction  )  [virtual]

Implements NuMatrix.

Definition at line 1140 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01141 {
01142   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Multiply not implemented"<<endl;
01143 }

void RockMatrixRAF0720Ext::Multiply ( const TH1 &  correction,
const Option_t *  option = "" 
) [virtual]

Implements NuMatrix.

Definition at line 1134 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01135 {
01136   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Multiply not implemented"<<endl;
01137 }

void RockMatrixRAF0720Ext::Multiply ( const NuMatrix correction  )  [virtual]

Definition at line 1128 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01129 {
01130   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Multiply not implemented"<<endl;
01131 }

void RockMatrixRAF0720Ext::Oscillate ( const Double_t  dm2,
const Double_t  sn2 
) [virtual]

Implements NuMatrix.

Definition at line 1166 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01167 {
01168   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"Oscillate not implemented"<<endl;
01169 }

void RockMatrixRAF0720Ext::PrepareBins ( RockEvent nu  )  const [virtual]

Returns a copy of the current RockMatrix instance.

Precalculates a RockEvents bins for the RockMatrix histograms

Implements RockMatrix.

Definition at line 290 of file RockMatrixRAF0720Ext.cxx.

References RockEvent::binNumber, RockEvent::dang, ear2GlobalBin(), RockEvent::edgemid, RockEvent::regionTrkVtx, and RockEvent::trkEn.

Referenced by FillFromFileNuEvents(), and FillFromFileRockEvents().

00291 {
00292   nu->binNumber = ear2GlobalBin(nu->dang, nu->trkEn, nu->regionTrkVtx,
00293                                 nu->edgemid);
00294 }

Int_t RockMatrixRAF0720Ext::Read ( const TString &  fname,
const TString &  name 
) [virtual]

Definition at line 1021 of file RockMatrixRAF0720Ext.cxx.

References exit(), fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fJess_ccmu, fJess_cctau, fJess_no, NuMatrix::fPot, Msg::kError, MSG, NuMatrix1D::Read(), and NuMatrix2D::Read().

01022 {
01023   TDirectory* dir_backup = gDirectory;
01024 
01025   TFile* f = new TFile(fname);
01026 
01027   if(!f || !f->IsOpen() || f->IsZombie()){
01028     MSG("RockMatrixRAF0720Ext",Msg::kError) << "Read() could not open "
01029       << fname << " Bailing out\n";
01030     exit(1);
01031   }
01032 
01033   fFront   .Read(f, name + "_front"   );
01034   fGap     .Read(f, name + "_gap"     );
01035   fGapEdge .Read(f, name + "_gapedge" );
01036   fBack    .Read(f, name + "_back"    );
01037   fEdgeRock.Read(f, name + "_edgerock");
01038   fEdgeDet .Read(f, name + "_edgedet" );
01039   fCoil    .Read(f, name + "_coil" );
01040 
01041   fAllReco .Read(f, name + "_allreco" );
01042   fAllRecoNW.Read(f, name + "_allreconw" );
01043   fAllTruth.Read(f, name + "_alltruth" );
01044 
01045   fJess_ccmu.Read(f, name + "_jess_ccmu");
01046   fJess_cctau.Read(f, name + "_jess_cctau");
01047   fJess_no.Read(f, name + "_jess_no");
01048 
01049   fPot = ((TH1*)f->Get(name + "_pot"))->GetBinContent(1);
01050 
01051   f->Close();
01052   dir_backup->cd();
01053 
01054   return 1;
01055 }

void RockMatrixRAF0720Ext::RecoToTrue ( const TH2D &  correction  )  [virtual]

Implements NuMatrix.

Definition at line 1147 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01148 {
01149   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"RecoToTrue not implemented"<<endl;
01150 }

void RockMatrixRAF0720Ext::Rectangularize1d ( Float_t &  dang,
Float_t &  trkEn,
int  onedbin,
bool  sparse = false 
) [static]

Definition at line 469 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, Linearize2d(), and MSG.

Referenced by GlobalBin2ear().

00471 {
00472   switch (onedbin) {
00473     case 0:  dang = 15; trkEn = 0.25; break;
00474     case 1:  dang = 60; trkEn = 0.25; break;
00475 
00476     case 2:  dang = 5;     trkEn = 0.75;  break;
00477     case 3:  dang = 12.5;  trkEn = 0.75;  break;
00478     case 4:  dang = 17.5;  trkEn = 0.75;  break;
00479     case 5:  dang = 22.5;  trkEn = 0.75;  break;
00480     case 6:  dang = 27.5;  trkEn = 0.75;  break;
00481     case 7:  dang = 32.5;  trkEn = 0.75;  break;
00482     case 8:  dang = 37.5;  trkEn = 0.75;  break;
00483     case 9:  dang = 42.5;  trkEn = 0.75;  break;
00484     case 10: dang = 47.5;  trkEn = 0.75;  break;
00485     case 11: dang = 52.5;  trkEn = 0.75;  break;
00486     case 12: dang = 72.5;  trkEn = 0.75;  break;
00487 
00488     case 13: dang = 5;    trkEn = 1.25; break;
00489     case 14: dang = 12.5; trkEn = 1.25; break;
00490     case 15: dang = 17.5; trkEn = 1.25; break;
00491     case 16: dang = 22.5; trkEn = 1.25; break;
00492     case 17: dang = 27.5; trkEn = 1.25; break;
00493     case 18: dang = 32.5; trkEn = 1.25; break;
00494     case 19: dang = 37.5; trkEn = 1.25; break;
00495     case 20: dang = 42.5; trkEn = 1.25; break;
00496     case 21: dang = 47.5; trkEn = 1.25; break;
00497     case 22: dang = 75;   trkEn = 1.25; break;
00498 
00499     case 23: dang = 5;    trkEn = 1.75; break;
00500     case 24: dang = 12.5; trkEn = 1.75; break;
00501     case 25: dang = 17.5; trkEn = 1.75; break;
00502     case 26: dang = 22.5; trkEn = 1.75; break;
00503     case 27: dang = 27.5; trkEn = 1.75; break;
00504     case 28: dang = 32.5; trkEn = 1.75; break;
00505     case 29: dang = 62.5; trkEn = 1.75; break;
00506 
00507     case 30: dang = 5;    trkEn = 2.25; break;
00508     case 31: dang = 12.5; trkEn = 2.25; break;
00509     case 32: dang = 17.5; trkEn = 2.25; break;
00510     case 33: dang = 22.5; trkEn = 2.25; break;
00511     case 34: dang = 27.5; trkEn = 2.25; break;
00512     case 35: dang = 60;   trkEn = 2.25; break;
00513 
00514     case 36: dang = 2.5;  trkEn = 2.75; break;
00515     case 37: dang = 7.5;  trkEn = 2.75; break;
00516     case 38: dang = 12.5; trkEn = 2.75; break;
00517     case 39: dang = 17.5; trkEn = 2.75; break;
00518     case 40: dang = 55.5; trkEn = 2.75; break;
00519 
00520     case 41: dang = 2.5;  trkEn = 3.25; break;
00521     case 42: dang = 7.5;  trkEn = 3.25; break;
00522     case 43: dang = 12.5; trkEn = 3.25; break;
00523     case 44: dang = 17.5; trkEn = 3.25; break;
00524     case 45: dang = 55.5; trkEn = 3.25; break;
00525 
00526     case 46: dang = 5;  trkEn = 3.75; break;
00527     case 47: dang = 50; trkEn = 3.75; break;
00528 
00529     case 48: dang = 5;  trkEn = 4.25; break;
00530     case 49: dang = 50; trkEn = 4.25; break;
00531 
00532     case 50: dang = 5;  trkEn = 4.75; break;
00533     case 51: dang = 50; trkEn = 4.75; break;
00534 
00535     default:
00536       dang = 45;
00537 
00538       if(onedbin < 0){
00539         MSG("RockMatrixRAF0720Std",Msg::kError) << "Rectangularize1d given "
00540           "bad input (valid range 0-133): " << onedbin << endl;
00541         trkEn = -1;
00542       }
00543 
00544       else if(onedbin <= 132){
00545         if(!sparse){ // see Linearize2d
00546           if(     onedbin <= 111) trkEn = float(onedbin -  52)/4 + 5.125;
00547           else if(onedbin <= 121) trkEn = float(onedbin - 112)   + 20.5;
00548           else if(onedbin <= 131) trkEn = float(onedbin - 122)*2 + 31;
00549           else if(onedbin == 132) trkEn = 125;
00550         }
00551         else{
00552           if(     onedbin <= 61) trkEn = float(onedbin - 52)/2 + 5.25;
00553           else if(onedbin <= 65) trkEn = float(onedbin - 62)*5 + 12.5;
00554           else if(onedbin == 66) trkEn = 115;
00555           else{
00556             MSG("RockMatrixRAF0720Std",Msg::kError) << "Rectangularize1d given "
00557             "bad input (valid range when sparse 0-66,133): " << onedbin << endl;
00558             trkEn = -1;
00559           }
00560         }
00561       }
00562 
00563       // not a bin center since this is an overflow
00564       else if(onedbin == 133) trkEn = 1000;
00565       else{
00566         MSG("RockMatrixRAF0720Std",Msg::kError) << "Rectangularize1d given "
00567           "bad input (valid range 0-133): " << onedbin << endl;
00568         trkEn = -1;
00569       }
00570   }
00571 
00572   if(RockMatrixRAF0720Ext::Linearize2d(dang, trkEn, sparse) != onedbin)
00573     cerr << "OH NO: inconsistent Linearize2d result for " << onedbin << endl;
00574 }

void RockMatrixRAF0720Ext::ResetPOT ( Double_t  new_POT  )  [virtual]

Sets the POT count directly, without scaling.

Reimplemented from NuMatrix.

Definition at line 899 of file RockMatrixRAF0720Ext.cxx.

References fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fJess_ccmu, fJess_cctau, fJess_no, NuMatrix::fPot, and NuMatrix::ResetPOT().

Referenced by Add(), and ScaleToPOT().

00900 {
00901   fFront   .ResetPOT(new_POT);
00902   fGap     .ResetPOT(new_POT);
00903   fGapEdge .ResetPOT(new_POT);
00904   fBack    .ResetPOT(new_POT);
00905   fEdgeRock.ResetPOT(new_POT);
00906   fEdgeDet .ResetPOT(new_POT);
00907   fCoil    .ResetPOT(new_POT);
00908 
00909   fAllReco .ResetPOT(new_POT);
00910   fAllRecoNW.ResetPOT(new_POT);
00911   fAllTruth.ResetPOT(new_POT);
00912 
00913   fJess_ccmu.ResetPOT(new_POT);
00914   fJess_cctau.ResetPOT(new_POT);
00915   fJess_no.ResetPOT(new_POT);
00916 
00917   fPot = new_POT;
00918 }

void RockMatrixRAF0720Ext::Scale ( Double_t  value  )  [virtual]

Scales the Matrix, without changing the POT.

Implements NuMatrix.

Definition at line 1090 of file RockMatrixRAF0720Ext.cxx.

References fAllReco, fAllTruth, fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fJess_ccmu, fJess_cctau, fJess_no, NuMatrix2D::Scale(), and NuMatrix1D::Scale().

Referenced by ScaleToPOT().

01091 {
01092   fFront   .Scale(value);
01093   fGap     .Scale(value);
01094   fGapEdge .Scale(value);
01095   fBack    .Scale(value);
01096   fEdgeRock.Scale(value);
01097   fEdgeDet .Scale(value);
01098   fCoil    .Scale(value);
01099 
01100   fJess_ccmu .Scale(value);
01101   fJess_cctau.Scale(value);
01102   fJess_no   .Scale(value);
01103 
01104   fAllReco .Scale(value);
01105   /* Don't scale fAllRecoNW since it is supposed to represent actual MC count */
01106   fAllTruth.Scale(value);
01107 }

void RockMatrixRAF0720Ext::ScaleToPOT ( Double_t  new_POT  )  [virtual]

Changes the POT, by scaling the data.

Implements NuMatrix.

Definition at line 1078 of file RockMatrixRAF0720Ext.cxx.

References NuMatrix::GetPOT(), ResetPOT(), and Scale().

01079 {
01080   if (GetPOT() != 0.0) {
01081     // The spectrum must exist - calculate the scale factor
01082     Double_t scale_factor = new_POT / GetPOT();
01083     Scale(scale_factor);
01084   }
01085 
01086   ResetPOT(new_POT);
01087 }

NuMatrix1D& RockMatrixRAF0720Ext::sdispback ( void   )  [inline]

Definition at line 115 of file RockMatrixRAF0720Ext.h.

References fsdispback.

00115 { return fsdispback; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispcoil ( void   )  [inline]

Definition at line 118 of file RockMatrixRAF0720Ext.h.

References fsdispcoil.

00118 { return fsdispcoil; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispedgedet ( void   )  [inline]

Definition at line 117 of file RockMatrixRAF0720Ext.h.

References fsdispedgedet.

00117 { return fsdispedgedet; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispedgerock ( void   )  [inline]

Definition at line 116 of file RockMatrixRAF0720Ext.h.

References fsdispedgerock.

00116 { return fsdispedgerock; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispfront ( void   )  [inline]

Definition at line 112 of file RockMatrixRAF0720Ext.h.

References fsdispfront.

00112 { return fsdispfront; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispgap ( void   )  [inline]

Definition at line 113 of file RockMatrixRAF0720Ext.h.

References fsdispgap.

00113 { return fsdispgap; }

NuMatrix1D& RockMatrixRAF0720Ext::sdispgapedge ( void   )  [inline]

Definition at line 114 of file RockMatrixRAF0720Ext.h.

References fsdispgapedge.

00114 { return fsdispgapedge; }

void RockMatrixRAF0720Ext::SetValue ( Double_t  val  )  [virtual]

Implements NuMatrix.

Definition at line 1060 of file RockMatrixRAF0720Ext.cxx.

References fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, and NuMatrix1D::SetValue().

01061 {
01062   cerr << "RockMatrixRAF0720Ext::SetValue might not do what you think.\n";
01063 
01064   fFront   .SetValue(val);
01065   fGap     .SetValue(val);
01066   fGapEdge .SetValue(val);
01067   fBack    .SetValue(val);
01068   fEdgeRock.SetValue(val);
01069   fEdgeDet .SetValue(val);
01070   fCoil    .SetValue(val);
01071 
01072   fAllReco.SetValue(val);
01073   fAllRecoNW.SetValue(val);
01074   fAllTruth.SetValue(val);
01075 }

virtual TH1* RockMatrixRAF0720Ext::Spectrum ( void   )  const [inline, virtual]

Returns a TH1 object representing the data the spectrum holds. Or zero.

Implements NuMatrix.

Definition at line 46 of file RockMatrixRAF0720Ext.h.

00046 { /* never call this, I guess! */ return 0; }

Double_t RockMatrixRAF0720Ext::StatsLikelihood ( const RockMatrixRAF0720Ext with  )  const [virtual]

Compares two NuMatrix objects and returns the LL difference.

Implements NuMatrix.

Definition at line 937 of file RockMatrixRAF0720Ext.cxx.

References fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, and NuMatrix1D::StatsLikelihood().

00938 {
00939   Double_t like = 0.0;
00940 
00941   like += fFront   .StatsLikelihood(&with->fFront   );
00942   like += fGap     .StatsLikelihood(&with->fGap     );
00943   like += fGapEdge .StatsLikelihood(&with->fGapEdge );
00944   like += fBack    .StatsLikelihood(&with->fBack    );
00945   like += fEdgeRock.StatsLikelihood(&with->fEdgeRock);
00946   like += fEdgeDet .StatsLikelihood(&with->fEdgeDet );
00947   like += fCoil    .StatsLikelihood(&with->fCoil    );
00948 
00949   // This SHOULD be nearly identical to all of the above, except that it will
00950   // include underflow and overflow bins in the fit. Test this sometime.
00951   // Do NOT use both the above and this; that's double counting
00952   //like += fAllReco.StatsLikelihood(&with->fAllReco );
00953 
00954   return like;
00955 }

Double_t RockMatrixRAF0720Ext::StatsLikelihood ( const NuMatrix with  )  const [virtual]

Definition at line 920 of file RockMatrixRAF0720Ext.cxx.

References Msg::kWarning, and MSG.

00921 {
00922   // Convert the NuMatrix to a RockMatrixRAF0720Ext
00923   const RockMatrixRAF0720Ext *other
00924     = dynamic_cast<const RockMatrixRAF0720Ext*>(with);
00925   if (other == 0) {
00926     MSG("RockMatrixRAF0720Ext",Msg::kWarning)
00927       << "Attempting to compare a RockMatrixRAF0720Ext to "
00928          "something other than a RockMatrixRAF0720Ext" << endl;
00929     return -1;
00930   }
00931 
00932   return this->StatsLikelihood(other);
00933 }

void RockMatrixRAF0720Ext::Subtract ( const RockMatrixRAF0720Ext correction  )  [virtual]

Implements NuMatrix.

Definition at line 1233 of file RockMatrixRAF0720Ext.cxx.

References NuMatrix1D::Add(), fBack, fCoil, fEdgeDet, fEdgeRock, fFront, fGap, and fGapEdge.

01234 {
01235   // Base the addition on the 'essential' histograms listed in complete
01236   // Also, this probably won't be used so don't bother with validation/clever behaviour for now
01237   fFront.Add(correction.fFront, -1.0);
01238   fGap.Add(correction.fGap, -1.0);
01239   fGapEdge.Add(correction.fGapEdge, -1.0);
01240   fBack.Add(correction.fBack, -1.0);
01241   fEdgeRock.Add(correction.fEdgeRock, -1.0);
01242   fEdgeDet.Add(correction.fEdgeDet, -1.0);
01243   fCoil.Add(correction.fCoil, -1.0);
01244 }

void RockMatrixRAF0720Ext::Subtract ( const NuMatrix correction  )  [virtual]

Definition at line 1220 of file RockMatrixRAF0720Ext.cxx.

References Msg::kWarning, and MSG.

01221 {
01222   // Convert the NuMatrix to a RockMatrixRAF0720Eonly
01223   const RockMatrixRAF0720Ext *other = dynamic_cast<const RockMatrixRAF0720Ext*>(&with);
01224   if (other == 0) {
01225     MSG("RockMatrixRAF0720Ext",Msg::kWarning) << "Attempting to subtract a RockMatrixRAF0720Ext from something other than a RockMatrixRAF0720Eonly" << endl;
01226   }
01227 
01228   this->Subtract(*other);
01229   
01230 }

void RockMatrixRAF0720Ext::TrueToReco ( const TH2D &  correction  )  [virtual]

Implements NuMatrix.

Definition at line 1153 of file RockMatrixRAF0720Ext.cxx.

References Msg::kError, and MSG.

01154 {
01155   MSG("RockMatrixRAF0720Ext",Msg::kError)<<"TrueToReco not implemented"<<endl;
01156 }

Int_t RockMatrixRAF0720Ext::Write ( const TString &  name  )  const [virtual]

Writes to the current file.

Implements NuMatrix.

Definition at line 963 of file RockMatrixRAF0720Ext.cxx.

References fadispall, fadispback, fadispcoil, fadispdetlike, fadispedgedet, fadispedgerock, fadispfront, fadispgap, fadispgapedge, fadisprocklike, fAllReco, fAllRecoNW, fAllTruth, fBack, fCoil, fdispall, fdispback, fdispcoil, fdispdetlike, fdispedgedet, fdispedgerock, fdispfront, fdispgap, fdispgapedge, fdisprocklike, fEdgeDet, fEdgeRock, fFront, fGap, fGapEdge, fJess_ccmu, fJess_cctau, fJess_no, NuMatrix::fPot, fsdispback, fsdispcoil, fsdispedgedet, fsdispedgerock, fsdispfront, fsdispgap, fsdispgapedge, NuMatrix1D::Write(), and NuMatrix2D::Write().

00964 {
00965   fFront   .Write(name + "_front"   );
00966   fGap     .Write(name + "_gap"     );
00967   fGapEdge .Write(name + "_gapedge" );
00968   fBack    .Write(name + "_back"    );
00969   fEdgeRock.Write(name + "_edgerock");
00970   fEdgeDet .Write(name + "_edgedet" );
00971   fCoil    .Write(name + "_coil" );
00972 
00973   fAllReco.Write(name + "_allreco");
00974   fAllRecoNW.Write(name + "_allreconw");
00975   fAllTruth.Write(name + "_alltruth");
00976 
00977   fJess_ccmu.Write(name + "_jess_ccmu"   );
00978   fJess_cctau.Write(name + "_jess_cctau"   );
00979   fJess_no.Write(name + "_jess_no"   );
00980 
00981   fdispfront   .Write(name + "_dispfront");
00982   fdispgap     .Write(name + "_dispgap");
00983   fdispedgerock.Write(name + "_dispedgerock");
00984   fdispedgedet .Write(name + "_dispedgedet");
00985   fdispback    .Write(name + "_dispback");
00986   fdispgapedge .Write(name + "_dispgapedge");
00987   fdispcoil    .Write(name + "_dispcoil");
00988 
00989   fdisprocklike.Write(name + "_disprocklike");
00990   fdispdetlike .Write(name + "_dispdetlike");
00991   fdispall     .Write(name + "_dispall");
00992 
00993   fadispfront   .Write(name + "_adispfront");
00994   fadispgap     .Write(name + "_adispgap");
00995   fadispedgerock.Write(name + "_adispedgerock");
00996   fadispedgedet .Write(name + "_adispedgedet");
00997   fadispback    .Write(name + "_adispback");
00998   fadispgapedge .Write(name + "_adispgapedge");
00999   fadispcoil    .Write(name + "_adispcoil");
01000 
01001   fadisprocklike.Write(name + "_adisprocklike");
01002   fadispdetlike .Write(name + "_adispdetlike");
01003   fadispall     .Write(name + "_adispall");
01004 
01005   fsdispfront   .Write(name + "_sdispfront");
01006   fsdispgap     .Write(name + "_sdispgap");
01007   fsdispedgerock.Write(name + "_sdispedgerock");
01008   fsdispedgedet .Write(name + "_sdispedgedet");
01009   fsdispback    .Write(name + "_sdispback");
01010   fsdispgapedge .Write(name + "_sdispgapedge");
01011   fsdispcoil    .Write(name + "_sdispcoil");
01012 
01013   TH1* pot = new TH1D("", "", 1, 0, 1);
01014   pot->SetBinContent(1, fPot);
01015   pot->Write(name + "_pot");
01016 
01017   return 1;
01018 }


Member Data Documentation

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispall(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispback(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispcoil(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispdetlike(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispedgedet(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispedgerock(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispfront(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispgap(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adispgapedge(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by adisprocklike(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispall(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispback(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispcoil(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispdetlike(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispedgedet(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispedgerock(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispfront(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispgap(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by dispgapedge(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by disprocklike(), Fill(), RockMatrixRAF0720Ext(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispback(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispcoil(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispedgedet(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispedgerock(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispfront(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispgap(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.

Referenced by Fill(), RockMatrixRAF0720Ext(), sdispgapedge(), and Write().

Definition at line 142 of file RockMatrixRAF0720Ext.h.


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

Generated on 22 Nov 2017 for loon by  doxygen 1.6.1