AtNuCounter Namespace Reference

Typedefs

typedef enum
AtNuCounter::ETrueEventType 
TrueEventType_t
typedef enum
AtNuCounter::EAtmosNumuCVType 
AtmosNumuCVType_t
typedef enum
AtNuCounter::EAtmosNumuUPType 
AtmosNumuUPType_t
typedef enum
AtNuCounter::EAtmosNueCVType 
AtmosNueCVType_t
typedef enum
AtNuCounter::EAtmosEventType 
AtmosEventType_t
typedef enum
AtNuCounter::ESelectedEventType 
SelectedEventType_t

Enumerations

enum  ETrueEventType {
  kUnknown = 0x00, kCVCCNue = 0x01, kCVCCNumuNeg = 0x02, kCVCCNumuPos = 0x04,
  kCVCCNumu = kCVCCNumuNeg + kCVCCNumuPos, kCVCCNutau = 0x08, kCVNC = 0x10, kCVShw = kCVCCNue + kCVCCNutau + kCVNC,
  kCV = kCVCCNue + kCVCCNumu + kCVCCNutau + kCVNC, kUpMuNeg = 0x20, kUpMuPos = 0x40, kUpMu = kUpMuNeg + kUpMuPos,
  kAtmosCV = kCV, kAtmosUpMu = kUpMu, kAtmos = kCV + kUpMu, kCosmic = 0x80,
  kMC = kAtmos + kCosmic, kData = 0x100
}
enum  EAtmosNumuCVType {
  kAtmosNumuCVcut0 = 0x0, kAtmosNumuCVcut1 = 0x01, kAtmosNumuCVcut2 = 0x02, kAtmosNumuCVcut3 = 0x04,
  kAtmosNumuCVcut4 = 0x08, kAtmosNumuCVpass1 = kAtmosNumuCVcut4 + kAtmosNumuCVcut3 + kAtmosNumuCVcut2 + kAtmosNumuCVcut1, kAtmosNumuCVpass2 = kAtmosNumuCVcut4 + kAtmosNumuCVcut3 + kAtmosNumuCVcut2, kAtmosNumuCVpass3 = kAtmosNumuCVcut4 + kAtmosNumuCVcut3,
  kAtmosNumuCVpass4 = kAtmosNumuCVcut4
}
enum  EAtmosNumuUPType {
  kAtmosNumuUPcut0 = 0x0, kAtmosNumuUPcut1 = 0x01, kAtmosNumuUPcut2 = 0x02, kAtmosNumuUPcut3 = 0x04,
  kAtmosNumuUPcut4 = 0x08, kAtmosNumuUPpass1 = kAtmosNumuUPcut4 + kAtmosNumuUPcut3 + kAtmosNumuUPcut2 + kAtmosNumuUPcut1, kAtmosNumuUPpass2 = kAtmosNumuUPcut4 + kAtmosNumuUPcut3 + kAtmosNumuUPcut2, kAtmosNumuUPpass3 = kAtmosNumuUPcut4 + kAtmosNumuUPcut3,
  kAtmosNumuUPpass4 = kAtmosNumuUPcut4
}
enum  EAtmosNueCVType {
  kAtmosNueCVcut0 = 0x0, kAtmosNueCVcut1 = 0x01, kAtmosNueCVcut2 = 0x02, kAtmosNueCVcut3 = 0x04,
  kAtmosNueCVcut4 = 0x08, kAtmosNueCVpass1 = kAtmosNueCVcut4 + kAtmosNueCVcut3 + kAtmosNueCVcut2 + kAtmosNueCVcut1, kAtmosNueCVpass2 = kAtmosNueCVcut4 + kAtmosNueCVcut3 + kAtmosNueCVcut2, kAtmosNueCVpass3 = kAtmosNueCVcut4 + kAtmosNueCVcut3,
  kAtmosNueCVpass4 = kAtmosNueCVcut4
}
enum  EAtmosEventType {
  kBackground = 0x00, kAtmosNue = 0x01, kAtmosNumuCVOnly_FC = 0x10, kAtmosNumuCVUP_FC = 0x20,
  kAtmosNumuUPOnly_FC = 0x40, kAtmosNumuCVOnly_PC = 0x100, kAtmosNumuCVUP_PC = 0x200, kAtmosNumuUPOnly_PC = 0x400,
  kAtmosNumuCVOnly_RAF = 0x1000, kAtmosNumuCVUP_RAF = 0x2000, kAtmosNumuUPOnly_RAF = 0x4000, kAtmosNumuCVOnly = kAtmosNumuCVOnly_FC + kAtmosNumuCVOnly_PC + kAtmosNumuCVOnly_RAF,
  kAtmosNumuCVUP = kAtmosNumuCVUP_FC + kAtmosNumuCVUP_PC + kAtmosNumuCVUP_RAF, kAtmosNumuUPOnly = kAtmosNumuUPOnly_FC + kAtmosNumuUPOnly_PC + kAtmosNumuUPOnly_RAF, kAtmosNumuCV_FC = kAtmosNumuCVOnly_FC + kAtmosNumuCVUP_FC, kAtmosNumuCV_PC = kAtmosNumuCVOnly_PC + kAtmosNumuCVUP_PC,
  kAtmosNumuUP_FC = kAtmosNumuCVUP_FC + kAtmosNumuUPOnly_FC, kAtmosNumuUP_PC = kAtmosNumuCVUP_PC + kAtmosNumuUPOnly_PC, kAtmosNumuUP_RAF = kAtmosNumuCVUP_RAF + kAtmosNumuUPOnly_RAF, kAtmosNumuCV = kAtmosNumuCVOnly + kAtmosNumuCVUP,
  kAtmosNumuUP = kAtmosNumuCVUP + kAtmosNumuUPOnly, kAtmosNumu = kAtmosNumuCV + kAtmosNumuUP, kAtmosNu = kAtmosNue + kAtmosNumu
}
enum  ESelectedEventType {
  kNull = 0x00, kFCNue = 0x01, kFCLoRes = 0x02, kPCLoRes = 0x04,
  kFCUpNeg = 0x10, kFCUpPos = 0x20, kFCUpAmbig = 0x40, kFCDownNeg = 0x100,
  kFCDownPos = 0x200, kFCDownAmbig = 0x400, kPCUpNeg = 0x1000, kPCUpPos = 0x2000,
  kPCUpAmbig = 0x4000, kPCDownNeg = 0x10000, kPCDownPos = 0x20000, kPCDownAmbig = 0x40000,
  kFCPCNue = kFCNue, kFCPCLoRes = kFCLoRes + kPCLoRes, kFCPCUpNeg = kFCUpNeg + kPCUpNeg, kFCPCUpPos = kFCUpPos + kPCUpPos,
  kFCPCUpAmbig = kFCUpAmbig + kPCUpAmbig, kFCPCDownNeg = kFCDownNeg + kPCDownNeg, kFCPCDownPos = kFCDownPos + kPCDownPos, kFCPCDownAmbig = kFCDownAmbig + kPCDownAmbig,
  kFCPCUp = kFCPCUpNeg + kFCPCUpPos + kFCPCUpAmbig, kFCPCDown = kFCPCDownNeg + kFCPCDownPos + kFCPCDownAmbig, kFCPCNeg = kFCPCUpNeg + kFCPCDownNeg, kFCPCPos = kFCPCUpPos + kFCPCDownPos,
  kFCPCAmbig = kFCPCUpAmbig + kFCPCDownAmbig, kFCPCHiRes = kFCPCUp + kFCPCDown, kFCPCNumu = kFCPCLoRes + kFCPCHiRes, kFCPC = kFCPCNumu,
  kRAFNeg = 0x100000, kRAFPos = 0x200000, kRAFAmbig = 0x400000, kRAF = kRAFNeg + kRAFPos + kRAFAmbig,
  kNeg = kFCPCNeg + kRAFNeg, kPos = kFCPCPos + kRAFPos, kNue = kFCNue, kAll = kFCNue + kFCPC + kRAF
}

Functions

int GetNumTrueBins ()
int GetTrueBin (AtNuCounter::TrueEventType_t trueType)
AtNuCounter::TrueEventType_t GetTrueType (int trueBin)
int GetNumAtmosNumuCVBins ()
int GetAtmosNumuCVBin (AtNuCounter::AtmosNumuCVType_t cutType)
AtNuCounter::AtmosNumuCVType_t GetAtmosNumuCVType (int cutBin)
int GetNumAtmosNumuUPBins ()
int GetAtmosNumuUPBin (AtNuCounter::AtmosNumuUPType_t cutType)
AtNuCounter::AtmosNumuUPType_t GetAtmosNumuUPType (int cutBin)
int GetNumAtmosNueCVBins ()
int GetAtmosNueCVBin (AtNuCounter::AtmosNueCVType_t cutType)
AtNuCounter::AtmosNueCVType_t GetAtmosNueCVType (int cutBin)
int GetNumAtmosBins ()
int GetAtmosBin (AtNuCounter::AtmosEventType_t atmosType)
AtNuCounter::AtmosEventType_t GetAtmosType (int atmosBin)
int GetNumSelectedBins ()
int GetSelectedBin (AtNuCounter::SelectedEventType_t selectedType)
AtNuCounter::SelectedEventType_t GetSelectedType (int selectedBin)

Typedef Documentation


Enumeration Type Documentation

Enumerator:
kBackground 
kAtmosNue 
kAtmosNumuCVOnly_FC 
kAtmosNumuCVUP_FC 
kAtmosNumuUPOnly_FC 
kAtmosNumuCVOnly_PC 
kAtmosNumuCVUP_PC 
kAtmosNumuUPOnly_PC 
kAtmosNumuCVOnly_RAF 
kAtmosNumuCVUP_RAF 
kAtmosNumuUPOnly_RAF 
kAtmosNumuCVOnly 
kAtmosNumuCVUP 
kAtmosNumuUPOnly 
kAtmosNumuCV_FC 
kAtmosNumuCV_PC 
kAtmosNumuUP_FC 
kAtmosNumuUP_PC 
kAtmosNumuUP_RAF 
kAtmosNumuCV 
kAtmosNumuUP 
kAtmosNumu 
kAtmosNu 

Definition at line 63 of file AtNuCountedEventType.h.

00063                                {
00064     kBackground          = 0x00,
00065     kAtmosNue            = 0x01,
00066     kAtmosNumuCVOnly_FC  = 0x10,
00067     kAtmosNumuCVUP_FC    = 0x20,
00068     kAtmosNumuUPOnly_FC  = 0x40,
00069     kAtmosNumuCVOnly_PC  = 0x100,
00070     kAtmosNumuCVUP_PC    = 0x200,
00071     kAtmosNumuUPOnly_PC  = 0x400,
00072     kAtmosNumuCVOnly_RAF = 0x1000,
00073     kAtmosNumuCVUP_RAF   = 0x2000,
00074     kAtmosNumuUPOnly_RAF = 0x4000,
00075     kAtmosNumuCVOnly = kAtmosNumuCVOnly_FC + kAtmosNumuCVOnly_PC + kAtmosNumuCVOnly_RAF,
00076     kAtmosNumuCVUP   = kAtmosNumuCVUP_FC   + kAtmosNumuCVUP_PC   + kAtmosNumuCVUP_RAF,
00077     kAtmosNumuUPOnly = kAtmosNumuUPOnly_FC + kAtmosNumuUPOnly_PC + kAtmosNumuUPOnly_RAF,
00078     kAtmosNumuCV_FC  = kAtmosNumuCVOnly_FC + kAtmosNumuCVUP_FC,
00079     kAtmosNumuCV_PC  = kAtmosNumuCVOnly_PC + kAtmosNumuCVUP_PC,
00080     kAtmosNumuUP_FC  = kAtmosNumuCVUP_FC   + kAtmosNumuUPOnly_FC,
00081     kAtmosNumuUP_PC  = kAtmosNumuCVUP_PC   + kAtmosNumuUPOnly_PC,
00082     kAtmosNumuUP_RAF = kAtmosNumuCVUP_RAF  + kAtmosNumuUPOnly_RAF,
00083     kAtmosNumuCV     = kAtmosNumuCVOnly    + kAtmosNumuCVUP,
00084     kAtmosNumuUP     = kAtmosNumuCVUP      + kAtmosNumuUPOnly,
00085     kAtmosNumu       = kAtmosNumuCV        + kAtmosNumuUP,
00086     kAtmosNu         = kAtmosNue           + kAtmosNumu
00087   } AtmosEventType_t;

Enumerator:
kAtmosNueCVcut0 
kAtmosNueCVcut1 
kAtmosNueCVcut2 
kAtmosNueCVcut3 
kAtmosNueCVcut4 
kAtmosNueCVpass1 
kAtmosNueCVpass2 
kAtmosNueCVpass3 
kAtmosNueCVpass4 

Definition at line 51 of file AtNuCountedEventType.h.

Enumerator:
kAtmosNumuCVcut0 
kAtmosNumuCVcut1 
kAtmosNumuCVcut2 
kAtmosNumuCVcut3 
kAtmosNumuCVcut4 
kAtmosNumuCVpass1 
kAtmosNumuCVpass2 
kAtmosNumuCVpass3 
kAtmosNumuCVpass4 

Definition at line 27 of file AtNuCountedEventType.h.

Enumerator:
kAtmosNumuUPcut0 
kAtmosNumuUPcut1 
kAtmosNumuUPcut2 
kAtmosNumuUPcut3 
kAtmosNumuUPcut4 
kAtmosNumuUPpass1 
kAtmosNumuUPpass2 
kAtmosNumuUPpass3 
kAtmosNumuUPpass4 

Definition at line 39 of file AtNuCountedEventType.h.

Enumerator:
kNull 
kFCNue 
kFCLoRes 
kPCLoRes 
kFCUpNeg 
kFCUpPos 
kFCUpAmbig 
kFCDownNeg 
kFCDownPos 
kFCDownAmbig 
kPCUpNeg 
kPCUpPos 
kPCUpAmbig 
kPCDownNeg 
kPCDownPos 
kPCDownAmbig 
kFCPCNue 
kFCPCLoRes 
kFCPCUpNeg 
kFCPCUpPos 
kFCPCUpAmbig 
kFCPCDownNeg 
kFCPCDownPos 
kFCPCDownAmbig 
kFCPCUp 
kFCPCDown 
kFCPCNeg 
kFCPCPos 
kFCPCAmbig 
kFCPCHiRes 
kFCPCNumu 
kFCPC 
kRAFNeg 
kRAFPos 
kRAFAmbig 
kRAF 
kNeg 
kPos 
kNue 
kAll 

Definition at line 89 of file AtNuCountedEventType.h.

00089                                   {
00090     kNull          = 0x00,
00091     kFCNue         = 0x01,
00092     kFCLoRes       = 0x02,
00093     kPCLoRes       = 0x04,
00094     kFCUpNeg       = 0x10,
00095     kFCUpPos       = 0x20,
00096     kFCUpAmbig     = 0x40,
00097     kFCDownNeg     = 0x100,
00098     kFCDownPos     = 0x200,
00099     kFCDownAmbig   = 0x400,
00100     kPCUpNeg       = 0x1000,
00101     kPCUpPos       = 0x2000,
00102     kPCUpAmbig     = 0x4000,
00103     kPCDownNeg     = 0x10000,
00104     kPCDownPos     = 0x20000,
00105     kPCDownAmbig   = 0x40000,
00106     kFCPCNue       = kFCNue,
00107     kFCPCLoRes     = kFCLoRes     + kPCLoRes,
00108     kFCPCUpNeg     = kFCUpNeg     + kPCUpNeg,
00109     kFCPCUpPos     = kFCUpPos     + kPCUpPos,
00110     kFCPCUpAmbig   = kFCUpAmbig   + kPCUpAmbig,
00111     kFCPCDownNeg   = kFCDownNeg   + kPCDownNeg,
00112     kFCPCDownPos   = kFCDownPos   + kPCDownPos,
00113     kFCPCDownAmbig = kFCDownAmbig + kPCDownAmbig,
00114     kFCPCUp        = kFCPCUpNeg   + kFCPCUpPos    + kFCPCUpAmbig,
00115     kFCPCDown      = kFCPCDownNeg + kFCPCDownPos  + kFCPCDownAmbig,
00116     kFCPCNeg       = kFCPCUpNeg   + kFCPCDownNeg,
00117     kFCPCPos       = kFCPCUpPos   + kFCPCDownPos,
00118     kFCPCAmbig     = kFCPCUpAmbig + kFCPCDownAmbig,
00119     kFCPCHiRes     = kFCPCUp      + kFCPCDown,
00120     kFCPCNumu      = kFCPCLoRes   + kFCPCHiRes,
00121     kFCPC          = kFCPCNumu,
00122     kRAFNeg        = 0x100000,
00123     kRAFPos        = 0x200000,
00124     kRAFAmbig      = 0x400000,
00125     kRAF           = kRAFNeg  + kRAFPos + kRAFAmbig,
00126     kNeg           = kFCPCNeg + kRAFNeg,
00127     kPos           = kFCPCPos + kRAFPos,
00128     kNue           = kFCNue,
00129     kAll           = kFCNue + kFCPC + kRAF
00130   } SelectedEventType_t;

Enumerator:
kUnknown 
kCVCCNue 
kCVCCNumuNeg 
kCVCCNumuPos 
kCVCCNumu 
kCVCCNutau 
kCVNC 
kCVShw 
kCV 
kUpMuNeg 
kUpMuPos 
kUpMu 
kAtmosCV 
kAtmosUpMu 
kAtmos 
kCosmic 
kMC 
kData 

Definition at line 6 of file AtNuCountedEventType.h.

00006                               {
00007     kUnknown     = 0x00,
00008     kCVCCNue     = 0x01,
00009     kCVCCNumuNeg = 0x02,
00010     kCVCCNumuPos = 0x04,
00011     kCVCCNumu    = kCVCCNumuNeg + kCVCCNumuPos,
00012     kCVCCNutau   = 0x08,
00013     kCVNC        = 0x10,
00014     kCVShw       = kCVCCNue + kCVCCNutau + kCVNC,
00015     kCV          = kCVCCNue + kCVCCNumu  + kCVCCNutau + kCVNC,
00016     kUpMuNeg     = 0x20,
00017     kUpMuPos     = 0x40,
00018     kUpMu        = kUpMuNeg + kUpMuPos,
00019     kAtmosCV     = kCV,
00020     kAtmosUpMu   = kUpMu,
00021     kAtmos       = kCV + kUpMu,
00022     kCosmic      = 0x80,
00023     kMC          = kAtmos + kCosmic,
00024     kData        = 0x100
00025   } TrueEventType_t;


Function Documentation

int AtNuCounter::GetAtmosBin ( AtNuCounter::AtmosEventType_t  atmosType  ) 

Definition at line 157 of file AtNuCountedEventType.cxx.

References kAtmosNue, kAtmosNumuCVOnly_FC, kAtmosNumuCVOnly_PC, kAtmosNumuCVOnly_RAF, kAtmosNumuCVUP_FC, kAtmosNumuCVUP_PC, kAtmosNumuCVUP_RAF, kAtmosNumuUPOnly_FC, kAtmosNumuUPOnly_PC, and kAtmosNumuUPOnly_RAF.

Referenced by AtNuEventCounter::Fill().

00158 {  
00159   int bin = -1;
00160 
00161   switch( atmosType ){
00162     case AtNuCounter::kAtmosNue:            bin = 0; break;
00163     case AtNuCounter::kAtmosNumuCVOnly_FC:  bin = 1; break;
00164     case AtNuCounter::kAtmosNumuCVUP_FC:    bin = 2; break;
00165     case AtNuCounter::kAtmosNumuUPOnly_FC:  bin = 3; break;
00166     case AtNuCounter::kAtmosNumuCVOnly_PC:  bin = 4; break;
00167     case AtNuCounter::kAtmosNumuCVUP_PC:    bin = 5; break;
00168     case AtNuCounter::kAtmosNumuUPOnly_PC:  bin = 6; break;
00169     case AtNuCounter::kAtmosNumuCVOnly_RAF: bin = 7; break;
00170     case AtNuCounter::kAtmosNumuCVUP_RAF:   bin = 8; break;
00171     case AtNuCounter::kAtmosNumuUPOnly_RAF: bin = 9; break;
00172     default: break;
00173   }
00174 
00175   return bin;
00176 }

int AtNuCounter::GetAtmosNueCVBin ( AtNuCounter::AtmosNueCVType_t  cutType  ) 

Definition at line 122 of file AtNuCountedEventType.cxx.

References kAtmosNueCVcut1, kAtmosNueCVcut2, kAtmosNueCVcut3, and kAtmosNueCVcut4.

Referenced by AtNuEventCounter::Fill().

00123 {
00124   int bin = -1;
00125 
00126   switch( cutType ){
00127     case kAtmosNueCVcut1:  bin = 0; break;
00128     case kAtmosNueCVcut2:  bin = 1; break;
00129     case kAtmosNueCVcut3:  bin = 2; break;
00130     case kAtmosNueCVcut4:  bin = 3; break;
00131     default: break;
00132   }
00133 
00134   return bin;
00135 }

AtNuCounter::AtmosNueCVType_t AtNuCounter::GetAtmosNueCVType ( int  cutBin  ) 

Definition at line 137 of file AtNuCountedEventType.cxx.

References kAtmosNueCVcut0, kAtmosNueCVcut1, kAtmosNueCVcut2, kAtmosNueCVcut3, and kAtmosNueCVcut4.

Referenced by AtNuEventCounter::GetCount().

00138 {
00139   AtNuCounter::AtmosNueCVType_t cutType = AtNuCounter::kAtmosNueCVcut0;
00140 
00141   switch( cutBin ){
00142     case 0: cutType = kAtmosNueCVcut1;  break;
00143     case 1: cutType = kAtmosNueCVcut2;  break;
00144     case 2: cutType = kAtmosNueCVcut3;  break;
00145     case 3: cutType = kAtmosNueCVcut4;  break;
00146     default: break;
00147   }
00148 
00149   return cutType;
00150 }

int AtNuCounter::GetAtmosNumuCVBin ( AtNuCounter::AtmosNumuCVType_t  cutType  ) 

Definition at line 52 of file AtNuCountedEventType.cxx.

References kAtmosNumuCVcut1, kAtmosNumuCVcut2, kAtmosNumuCVcut3, and kAtmosNumuCVcut4.

Referenced by AtNuEventCounter::Fill().

00053 {
00054   int bin = -1;
00055 
00056   switch( cutType ){
00057     case kAtmosNumuCVcut1: bin = 0; break; 
00058     case kAtmosNumuCVcut2: bin = 1; break;
00059     case kAtmosNumuCVcut3: bin = 2; break;
00060     case kAtmosNumuCVcut4: bin = 3; break;
00061     default: break;
00062   }
00063 
00064   return bin;
00065 }

AtNuCounter::AtmosNumuCVType_t AtNuCounter::GetAtmosNumuCVType ( int  cutBin  ) 

Definition at line 67 of file AtNuCountedEventType.cxx.

References kAtmosNumuCVcut0, kAtmosNumuCVcut1, kAtmosNumuCVcut2, kAtmosNumuCVcut3, and kAtmosNumuCVcut4.

Referenced by AtNuEventCounter::GetCount().

00068 {
00069   AtNuCounter::AtmosNumuCVType_t cutType = AtNuCounter::kAtmosNumuCVcut0;
00070 
00071   switch( cutBin ){
00072     case 0: cutType = kAtmosNumuCVcut1; break; 
00073     case 1: cutType = kAtmosNumuCVcut2; break;
00074     case 2: cutType = kAtmosNumuCVcut3; break;
00075     case 3: cutType = kAtmosNumuCVcut4; break;
00076     default: break;
00077   }
00078 
00079   return cutType;
00080 }

int AtNuCounter::GetAtmosNumuUPBin ( AtNuCounter::AtmosNumuUPType_t  cutType  ) 

Definition at line 87 of file AtNuCountedEventType.cxx.

References kAtmosNumuUPcut1, kAtmosNumuUPcut2, kAtmosNumuUPcut3, and kAtmosNumuUPcut4.

Referenced by AtNuEventCounter::Fill().

00088 {
00089   int bin = -1;
00090   
00091   switch( cutType ){
00092     case kAtmosNumuUPcut1: bin = 0; break;
00093     case kAtmosNumuUPcut2: bin = 1; break;
00094     case kAtmosNumuUPcut3: bin = 2; break;
00095     case kAtmosNumuUPcut4: bin = 3; break;
00096     default: break;
00097   }
00098 
00099   return bin;
00100 }

AtNuCounter::AtmosNumuUPType_t AtNuCounter::GetAtmosNumuUPType ( int  cutBin  ) 

Definition at line 102 of file AtNuCountedEventType.cxx.

References kAtmosNumuUPcut0, kAtmosNumuUPcut1, kAtmosNumuUPcut2, kAtmosNumuUPcut3, and kAtmosNumuUPcut4.

Referenced by AtNuEventCounter::GetCount().

00103 {
00104   AtNuCounter::AtmosNumuUPType_t cutType = AtNuCounter::kAtmosNumuUPcut0;
00105 
00106   switch( cutBin ){
00107     case 0: cutType = kAtmosNumuUPcut1; break;
00108     case 1: cutType = kAtmosNumuUPcut2; break;
00109     case 2: cutType = kAtmosNumuUPcut3; break;
00110     case 3: cutType = kAtmosNumuUPcut4; break;
00111     default: break;
00112   }
00113 
00114   return cutType;
00115 }

AtNuCounter::AtmosEventType_t AtNuCounter::GetAtmosType ( int  atmosBin  ) 

Definition at line 178 of file AtNuCountedEventType.cxx.

References kAtmosNue, kAtmosNumuCVOnly_FC, kAtmosNumuCVOnly_PC, kAtmosNumuCVOnly_RAF, kAtmosNumuCVUP_FC, kAtmosNumuCVUP_PC, kAtmosNumuCVUP_RAF, kAtmosNumuUPOnly_FC, kAtmosNumuUPOnly_PC, kAtmosNumuUPOnly_RAF, and kBackground.

Referenced by AtNuEventCounter::GetCount().

00179 {
00180   AtNuCounter::AtmosEventType_t atmosType = AtNuCounter::kBackground;
00181 
00182   switch( atmosBin ){
00183     case 0: atmosType = AtNuCounter::kAtmosNue;            break;
00184     case 1: atmosType = AtNuCounter::kAtmosNumuCVOnly_FC;  break;
00185     case 2: atmosType = AtNuCounter::kAtmosNumuCVUP_FC;    break;
00186     case 3: atmosType = AtNuCounter::kAtmosNumuUPOnly_FC;  break;
00187     case 4: atmosType = AtNuCounter::kAtmosNumuCVOnly_PC;  break;
00188     case 5: atmosType = AtNuCounter::kAtmosNumuCVUP_PC;    break;
00189     case 6: atmosType = AtNuCounter::kAtmosNumuUPOnly_PC;  break;
00190     case 7: atmosType = AtNuCounter::kAtmosNumuCVOnly_RAF; break;
00191     case 8: atmosType = AtNuCounter::kAtmosNumuCVUP_RAF;   break;
00192     case 9: atmosType = AtNuCounter::kAtmosNumuUPOnly_RAF; break;
00193     default: break;
00194   }
00195 
00196   return atmosType;
00197 }

int AtNuCounter::GetNumAtmosBins (  ) 

Definition at line 152 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00153 {
00154   return 10;
00155 }

int AtNuCounter::GetNumAtmosNueCVBins (  ) 

Definition at line 117 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00118 {
00119   return 4;
00120 }

int AtNuCounter::GetNumAtmosNumuCVBins (  ) 

Definition at line 47 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00048 {
00049   return 4;
00050 }

int AtNuCounter::GetNumAtmosNumuUPBins (  ) 

Definition at line 82 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00083 {
00084   return 4;
00085 }

int AtNuCounter::GetNumSelectedBins (  ) 

Definition at line 199 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00200 {
00201   return 18;
00202 }

int AtNuCounter::GetNumTrueBins (  ) 

Definition at line 3 of file AtNuCountedEventType.cxx.

Referenced by AtNuEventCounter::AtNuEventCounter().

00004 {
00005   return 9;
00006 }

int AtNuCounter::GetSelectedBin ( AtNuCounter::SelectedEventType_t  selectedType  ) 

Definition at line 204 of file AtNuCountedEventType.cxx.

References kFCDownAmbig, kFCDownNeg, kFCDownPos, kFCLoRes, kFCNue, kFCUpAmbig, kFCUpNeg, kFCUpPos, kPCDownAmbig, kPCDownNeg, kPCDownPos, kPCLoRes, kPCUpAmbig, kPCUpNeg, kPCUpPos, kRAFAmbig, kRAFNeg, and kRAFPos.

Referenced by AtNuEventCounter::Fill().

00205 {  
00206   int bin = -1;
00207   
00208   switch( selectedType ){
00209     case AtNuCounter::kFCNue:         bin = 0;   break;
00210     case AtNuCounter::kFCLoRes:       bin = 1;   break;
00211     case AtNuCounter::kFCUpNeg:       bin = 2;   break;
00212     case AtNuCounter::kFCUpPos:       bin = 3;   break;
00213     case AtNuCounter::kFCUpAmbig:     bin = 4;   break;
00214     case AtNuCounter::kFCDownNeg:     bin = 5;   break;
00215     case AtNuCounter::kFCDownPos:     bin = 6;   break;
00216     case AtNuCounter::kFCDownAmbig:   bin = 7;   break;
00217     case AtNuCounter::kPCLoRes:       bin = 8;   break;
00218     case AtNuCounter::kPCUpNeg:       bin = 9;   break;
00219     case AtNuCounter::kPCUpPos:       bin = 10;  break;
00220     case AtNuCounter::kPCUpAmbig:     bin = 11;  break;
00221     case AtNuCounter::kPCDownNeg:     bin = 12;  break;
00222     case AtNuCounter::kPCDownPos:     bin = 13;  break;
00223     case AtNuCounter::kPCDownAmbig:   bin = 14;  break;
00224     case AtNuCounter::kRAFNeg:        bin = 15;  break;
00225     case AtNuCounter::kRAFPos:        bin = 16;  break;
00226     case AtNuCounter::kRAFAmbig:      bin = 17;  break;
00227     default: break;
00228   }
00229 
00230   return bin;
00231 }

AtNuCounter::SelectedEventType_t AtNuCounter::GetSelectedType ( int  selectedBin  ) 

Definition at line 233 of file AtNuCountedEventType.cxx.

References kFCDownAmbig, kFCDownNeg, kFCDownPos, kFCLoRes, kFCNue, kFCUpAmbig, kFCUpNeg, kFCUpPos, kNull, kPCDownAmbig, kPCDownNeg, kPCDownPos, kPCLoRes, kPCUpAmbig, kPCUpNeg, kPCUpPos, kRAFAmbig, kRAFNeg, and kRAFPos.

Referenced by AtNuEventCounter::GetCount().

00234 {
00235   AtNuCounter::SelectedEventType_t selectedType = AtNuCounter::kNull;
00236 
00237   switch( selectedBin ){
00238     case 0:  selectedType = AtNuCounter::kFCNue;       break;
00239     case 1:  selectedType = AtNuCounter::kFCLoRes;     break;
00240     case 2:  selectedType = AtNuCounter::kFCUpNeg;     break;
00241     case 3:  selectedType = AtNuCounter::kFCUpPos;     break;
00242     case 4:  selectedType = AtNuCounter::kFCUpAmbig;   break;
00243     case 5:  selectedType = AtNuCounter::kFCDownNeg;   break;
00244     case 6:  selectedType = AtNuCounter::kFCDownPos;   break;
00245     case 7:  selectedType = AtNuCounter::kFCDownAmbig; break;
00246     case 8:  selectedType = AtNuCounter::kPCLoRes;     break;
00247     case 9:  selectedType = AtNuCounter::kPCUpNeg;     break;
00248     case 10: selectedType = AtNuCounter::kPCUpPos;     break;
00249     case 11: selectedType = AtNuCounter::kPCUpAmbig;   break;
00250     case 12: selectedType = AtNuCounter::kPCDownNeg;   break;
00251     case 13: selectedType = AtNuCounter::kPCDownPos;   break;
00252     case 14: selectedType = AtNuCounter::kPCDownAmbig; break;
00253     case 15: selectedType = AtNuCounter::kRAFNeg;      break;
00254     case 16: selectedType = AtNuCounter::kRAFPos;      break;
00255     case 17: selectedType = AtNuCounter::kRAFAmbig;    break;
00256     default: break;
00257   }
00258 
00259   return selectedType;
00260 }

int AtNuCounter::GetTrueBin ( AtNuCounter::TrueEventType_t  trueType  ) 

Definition at line 8 of file AtNuCountedEventType.cxx.

References kCosmic, kCVCCNue, kCVCCNumuNeg, kCVCCNumuPos, kCVCCNutau, kCVNC, kData, kUpMuNeg, and kUpMuPos.

Referenced by AtNuEventCounter::Fill().

00009 {  
00010   int bin = -1;
00011 
00012   switch( trueType ){
00013     case AtNuCounter::kCVCCNue:     bin = 0; break;
00014     case AtNuCounter::kCVCCNumuNeg: bin = 1; break;
00015     case AtNuCounter::kCVCCNumuPos: bin = 2; break;
00016     case AtNuCounter::kCVCCNutau:   bin = 3; break;
00017     case AtNuCounter::kCVNC:        bin = 4; break;
00018     case AtNuCounter::kUpMuNeg:     bin = 5; break;
00019     case AtNuCounter::kUpMuPos:     bin = 6; break;
00020     case AtNuCounter::kCosmic:      bin = 7; break;
00021     case AtNuCounter::kData:        bin = 8; break;
00022     default: break;
00023   }
00024 
00025   return bin;
00026 }

AtNuCounter::TrueEventType_t AtNuCounter::GetTrueType ( int  trueBin  ) 

Definition at line 28 of file AtNuCountedEventType.cxx.

References kCosmic, kCVCCNue, kCVCCNumuNeg, kCVCCNumuPos, kCVCCNutau, kCVNC, kData, kUnknown, kUpMuNeg, and kUpMuPos.

Referenced by AtNuEventCounter::GetCount().

00029 {
00030   AtNuCounter::TrueEventType_t trueType = AtNuCounter::kUnknown;
00031 
00032   switch( trueBin ){
00033     case 0: trueType = AtNuCounter::kCVCCNue;     break;
00034     case 1: trueType = AtNuCounter::kCVCCNumuNeg; break;
00035     case 2: trueType = AtNuCounter::kCVCCNumuPos; break;
00036     case 3: trueType = AtNuCounter::kCVCCNutau;   break;
00037     case 4: trueType = AtNuCounter::kCVNC;        break;
00038     case 5: trueType = AtNuCounter::kUpMuNeg;     break;
00039     case 6: trueType = AtNuCounter::kUpMuPos;     break;
00040     case 7: trueType = AtNuCounter::kCosmic;      break;
00041     case 8: trueType = AtNuCounter::kData;        break;
00042   }
00043 
00044   return trueType;
00045 }


Generated on 13 Dec 2018 for loon by  doxygen 1.6.1