UtilMCFlag Namespace Reference

Enumerations

enum  ECut {
  kCUTGAM, kCUTELE, kCUTNEU, kCUTHAD,
  kCUTMUO, kBCUTE, kBCUTM, kDCUTE,
  kDCUTM, kPPCUTM, kTOFMAX, kUnknownCut
}
enum  EProcess {
  kANNI, kBREM, kCOMP, kDCAY,
  kDRAY, kHADR, kLOSS, kMULS,
  kMUNU, kPAIR, kPFIS, kPHOT,
  kUnknownProcess
}
enum  ETracking {
  kISVOL, kIFIELD, kFIELDM, kTMAXFD,
  kSTEMAX, kDEEMAX, kEPSIL, kSTMIN,
  kUnknownTracking
}

Functions

const char * AsString (ECut cut)
const char * AsString (EProcess process)
const char * AsString (ETracking tracking)
ECut GetCut (const char *cutname)
EProcess GetProcess (const char *processname)
ETracking GetTracking (const char *trackingname)

Variables

const Int_t kNCut = kUnknownCut
const Int_t kNProcess = kUnknownProcess

Enumeration Type Documentation

Enumerator:
kCUTGAM 
kCUTELE 
kCUTNEU 
kCUTHAD 
kCUTMUO 
kBCUTE 
kBCUTM 
kDCUTE 
kDCUTM 
kPPCUTM 
kTOFMAX 
kUnknownCut 

Definition at line 19 of file UtilMCFlag.h.

00019             {
00020     // Flags to specify threshold cuts.  Kinetic energy cuts in GeV.
00021     // Time of flight cut in seconds.  Specified in order that they
00022     // appear in Geant3 "CUTS" list.  
00023     kCUTGAM, // cut for gammas 
00024     kCUTELE, // cut for electrons 
00025     kCUTNEU, // cut for neutral hadrons 
00026     kCUTHAD, // cut for charged hadrons 
00027     kCUTMUO, // cut for muons
00028     kBCUTE,  // cut for electron bremsstrahlung
00029     kBCUTM,  // cut for muon and hadron bremsstrahlung
00030     kDCUTE,  // cut for delta rays by electrons
00031     kDCUTM,  // cut for delta rays by muons
00032     kPPCUTM, // total energy cut for direct pair production by muons
00033     kTOFMAX, // time of flight cut in seconds
00034     kUnknownCut  
00035   };

Enumerator:
kANNI 
kBREM 
kCOMP 
kDCAY 
kDRAY 
kHADR 
kLOSS 
kMULS 
kMUNU 
kPAIR 
kPFIS 
kPHOT 
kUnknownProcess 

Definition at line 38 of file UtilMCFlag.h.

00038                 {
00039     // Flags to control physics processes.  In general: 
00040     //   0 = process is disabled.
00041     //   1 = process enabled with production of secondaries
00042     //   2 = process enabled without production of secondaries
00043     // unless otherwise specified.
00044     // Process flags are listed in alphabetical order.
00045     kANNI,    // Positron annihilation
00046     kBREM,    // Bremsstrahlung
00047     kCOMP,    // Compton scattering 
00048     kDCAY,    // Decay in flight 
00049     kDRAY,    // Delta ray production 
00050     kHADR,    // Hadronic interactions. 
00051               // HADR 0=None 
00052               //  1,2,3=GHEISHA
00053               //      4=FLUKA 
00054               //      5=MICAP(low E)/FLUKA(high E)
00055               //      6=GCALOR
00056     kLOSS,    // Continuous energy loss
00057               // LOSS 0=None
00058               //      1=Continuous loss w/drays above DCUTE, fluctuations below
00059               //      2=Continuous loss w/o drays and full Landau fluctuations
00060               //      3=Same as 1
00061               //      4=Energy loss without fluctuation.  
00062     kMULS,    // Multiple scattering
00063               // MULS 0=None
00064               //      1=Multiple scattering according to Moliere theory
00065               //      2=Same as 1
00066               //      3=Pure Gaussian scattering according to the Rossi formula
00067     kMUNU,    // Muon nuclear interaction
00068     kPAIR,    // Pair production 
00069     kPFIS,    // Photofission (nuclear fission induced by photon)  
00070     kPHOT,    // Photoelectric effect 
00071     kUnknownProcess 
00072   };

Enumerator:
kISVOL 
kIFIELD 
kFIELDM 
kTMAXFD 
kSTEMAX 
kDEEMAX 
kEPSIL 
kSTMIN 
kUnknownTracking 

Definition at line 75 of file UtilMCFlag.h.

00075                  {
00076     // Tracking parameters used in definition of medium.  Could put this in
00077     // Geo namespace, but it seems to group better with ECut and EProcess.
00078     kISVOL,   // sensitivity flag, <= 0 (not sensitive), > 0 (sensitive)
00079     kIFIELD,  // magnetic field swim method (see Geo::ESwimMethod)
00080     kFIELDM,  // maximum field (kGauss)
00081     kTMAXFD,  // maximum angle due to field permitted in one step (deg)
00082     kSTEMAX,  // maximum step permitted (cm)
00083     kDEEMAX,  // maximum fractional energy loss in one step (0 < DEEMAX <= 1)
00084     kEPSIL,   // boundary crossing precision (cm)
00085     kSTMIN,   // min step due to energy loss or multiple scat or b-field (cm)
00086     kUnknownTracking 
00087   };


Function Documentation

const char * UtilMCFlag::AsString ( ETracking  tracking  ) 

Definition at line 152 of file UtilMCFlag.cxx.

References kDEEMAX, kEPSIL, kFIELDM, kIFIELD, kISVOL, kSTEMAX, kSTMIN, kTMAXFD, kUnknownTracking, Msg::kWarning, and MSG.

00152                                                    {
00153   //  Purpose:  Convert enumerated tracking parameter to a tracking string.
00154   //  If unknown tracking parameter, return "UnknownTracking".
00155 
00156   switch ( tracking ) {
00157 
00158   case kISVOL:
00159     return "ISVOL";
00160   case kIFIELD:
00161     return "IFIELD";
00162   case kFIELDM:
00163     return "FIELDM";
00164   case kTMAXFD:
00165     return "TMAXFD";
00166   case kSTEMAX:
00167     return "STEMAX";
00168   case kDEEMAX:
00169     return "DEEMAX";
00170   case kEPSIL:
00171     return "EPSIL";
00172   case kSTMIN:
00173     return "STMIN";
00174   case kUnknownTracking:
00175     return "UnknownTracking";
00176   default:
00177     MSG("UtilMCFlag",Msg::kWarning) 
00178       << "UtilMCFlag::AsString called with unknown tracking parameter "  
00179       << (int)tracking << endl;
00180     return "UnknownTracking";
00181   } //end of switch
00182 
00183 }

const char * UtilMCFlag::AsString ( EProcess  process  ) 

Definition at line 86 of file UtilMCFlag.cxx.

References kANNI, kBREM, kCOMP, kDCAY, kDRAY, kHADR, kLOSS, kMULS, kMUNU, kPAIR, kPFIS, kPHOT, kUnknownProcess, Msg::kWarning, and MSG.

00086                                                  {
00087   //  Purpose:  Convert enumerated mc process to a process string.
00088   //  If unknown process, return "UnknownProcess".
00089 
00090   switch ( process ) {
00091 
00092   case kANNI:
00093     return "ANNI";
00094   case kBREM:
00095     return "BREM";
00096   case kCOMP:
00097     return "COMP";
00098   case kDCAY:
00099     return "DCAY";
00100   case kDRAY:
00101     return "DRAY";
00102   case kHADR:
00103     return "HADR";
00104   case kLOSS:
00105     return "LOSS";
00106   case kMULS:
00107     return "MULS";
00108   case kMUNU:
00109     return "MUNU";
00110   case kPAIR:
00111     return "PAIR";
00112   case kPFIS:
00113     return "PFIS";
00114   case kPHOT:
00115     return "PHOT";
00116   case kUnknownProcess:
00117     return "UnknownProcess";
00118   default:
00119     MSG("UtilMCFlag",Msg::kWarning) 
00120       << "UtilMCFlag::AsString called with unknown process "  << (int)process 
00121       << endl;
00122     return "UnknownProcess";
00123   } //end of switch
00124 
00125 }

const char * UtilMCFlag::AsString ( ECut  cut  ) 

Definition at line 25 of file UtilMCFlag.cxx.

References kBCUTE, kBCUTM, kCUTELE, kCUTGAM, kCUTHAD, kCUTMUO, kCUTNEU, kDCUTE, kDCUTM, kPPCUTM, kTOFMAX, kUnknownCut, Msg::kWarning, and MSG.

Referenced by UgliLoanPool::SetCut(), UgliLoanPool::SetProcess(), and UgliLoanPool::SetTracking().

00025                                          {
00026   //  Purpose:  Convert enumerated mc cut to a cut string.
00027   //  If unknown, return "UnknownCut".
00028 
00029   switch ( cut ) {
00030 
00031   case kCUTGAM:
00032     return "CUTGAM";
00033   case kCUTELE:
00034     return "CUTELE";
00035   case kCUTNEU:
00036     return "CUTNEU";
00037   case kCUTHAD:
00038     return "CUTHAD";
00039   case kCUTMUO:
00040     return "CUTMUO";
00041   case kBCUTE:
00042     return "BCUTE";
00043   case kBCUTM:
00044     return "BCUTM";
00045   case kDCUTE:
00046     return "DCUTE";
00047   case kDCUTM:
00048     return "DCUTM";
00049   case kPPCUTM:
00050     return "PPCUTM";
00051   case kTOFMAX:
00052     return "TOFMAX";
00053   case kUnknownCut:
00054     return "UnknownCut";
00055   default:
00056     MSG("UtilMCFlag",Msg::kWarning) 
00057       << "UtilMCFlag::AsString called with unknown cut " << (int)cut << endl;
00058     return "UnknownCut";
00059   }//end of switch
00060 
00061 }

UtilMCFlag::ECut UtilMCFlag::GetCut ( const char *  cutname  ) 

Definition at line 64 of file UtilMCFlag.cxx.

References kBCUTE, kBCUTM, kCUTELE, kCUTGAM, kCUTHAD, kCUTMUO, kCUTNEU, kDCUTE, kDCUTM, kPPCUTM, kTOFMAX, and kUnknownCut.

00064                                                  {
00065   // Purpose: Convert text string cut to an enumerated code.
00066   // Return kUnknownCut if unknown
00067 
00068   TString tmpstr(cut);
00069   tmpstr.ToLower();
00070   if ( strcmp(tmpstr.Data(),"cutgam") == 0 ) return UtilMCFlag::kCUTGAM;
00071   else if ( strcmp(tmpstr.Data(),"cutele") == 0 ) return UtilMCFlag::kCUTELE;
00072   else if ( strcmp(tmpstr.Data(),"cutneu") == 0 ) return UtilMCFlag::kCUTNEU;
00073   else if ( strcmp(tmpstr.Data(),"cuthad") == 0 ) return UtilMCFlag::kCUTHAD;
00074   else if ( strcmp(tmpstr.Data(),"cutmuo") == 0 ) return UtilMCFlag::kCUTMUO;
00075   else if ( strcmp(tmpstr.Data(),"bcute") == 0 ) return UtilMCFlag::kBCUTE;
00076   else if ( strcmp(tmpstr.Data(),"bcutm") == 0 ) return UtilMCFlag::kBCUTM;
00077   else if ( strcmp(tmpstr.Data(),"dcute") == 0 ) return UtilMCFlag::kDCUTE;
00078   else if ( strcmp(tmpstr.Data(),"dcutm") == 0 ) return UtilMCFlag::kDCUTM;
00079   else if ( strcmp(tmpstr.Data(),"ppcutm") == 0 ) return UtilMCFlag::kPPCUTM;
00080   else if ( strcmp(tmpstr.Data(),"tofmax") == 0 ) return UtilMCFlag::kTOFMAX;
00081   return kUnknownCut;
00082 
00083 }

UtilMCFlag::EProcess UtilMCFlag::GetProcess ( const char *  processname  ) 

Definition at line 128 of file UtilMCFlag.cxx.

References kANNI, kBREM, kCOMP, kDCAY, kDRAY, kHADR, kLOSS, kMULS, kMUNU, kPAIR, kPFIS, kPHOT, and kUnknownProcess.

00128                                                              {
00129   // Purpose: Convert text string process to an enumerated code.
00130   // If no match, return kUnknownProcess.
00131 
00132   TString tmpstr(process);
00133   tmpstr.ToLower();
00134   if ( strcmp(tmpstr.Data(),"anni") == 0 ) return UtilMCFlag::kANNI;
00135   else if ( strcmp(tmpstr.Data(),"brem") == 0 ) return UtilMCFlag::kBREM;
00136   else if ( strcmp(tmpstr.Data(),"comp") == 0 ) return UtilMCFlag::kCOMP;
00137   else if ( strcmp(tmpstr.Data(),"dcay") == 0 ) return UtilMCFlag::kDCAY;
00138   else if ( strcmp(tmpstr.Data(),"dray") == 0 ) return UtilMCFlag::kDRAY;
00139   else if ( strcmp(tmpstr.Data(),"hadr") == 0 ) return UtilMCFlag::kHADR;
00140   else if ( strcmp(tmpstr.Data(),"loss") == 0 ) return UtilMCFlag::kLOSS;
00141   else if ( strcmp(tmpstr.Data(),"muls") == 0 ) return UtilMCFlag::kMULS;
00142   else if ( strcmp(tmpstr.Data(),"munu") == 0 ) return UtilMCFlag::kMUNU;
00143   else if ( strcmp(tmpstr.Data(),"pair") == 0 ) return UtilMCFlag::kPAIR;
00144   else if ( strcmp(tmpstr.Data(),"pfis") == 0 ) return UtilMCFlag::kPFIS;
00145   else if ( strcmp(tmpstr.Data(),"phot") == 0 ) return UtilMCFlag::kPHOT;
00146 
00147   return kUnknownProcess;
00148 
00149 }

UtilMCFlag::ETracking UtilMCFlag::GetTracking ( const char *  trackingname  ) 

Definition at line 186 of file UtilMCFlag.cxx.

References kDEEMAX, kEPSIL, kFIELDM, kIFIELD, kISVOL, kSTEMAX, kSTMIN, kTMAXFD, and kUnknownTracking.

Referenced by GeoMediumMap::ConfigureMedium().

00186                                                                 {
00187   // Purpose: Convert text string tracking parameter to an enumerated code.
00188   // If no match, return kUnknownTracking.
00189 
00190   TString tmpstr(tracking);
00191   tmpstr.ToLower();
00192   if ( strcmp(tmpstr.Data(),"isvol") == 0 ) return kISVOL;
00193   else if ( strcmp(tmpstr.Data(),"ifield") == 0 ) return kIFIELD;
00194   else if ( strcmp(tmpstr.Data(),"fieldm" ) == 0 ) return kFIELDM;
00195   else if ( strcmp(tmpstr.Data(),"tmaxfd" ) == 0 ) return kTMAXFD;
00196   else if ( strcmp(tmpstr.Data(),"stemax" ) == 0 ) return kSTEMAX;
00197   else if ( strcmp(tmpstr.Data(),"deemax" ) == 0 ) return kDEEMAX;
00198   else if ( strcmp(tmpstr.Data(),"epsil" ) == 0 ) return kEPSIL;
00199   else if ( strcmp(tmpstr.Data(),"stmin" ) == 0 ) return kSTMIN;
00200   return kUnknownTracking;
00201 
00202 }


Variable Documentation

const Int_t UtilMCFlag::kNCut = kUnknownCut

Definition at line 36 of file UtilMCFlag.h.

const Int_t UtilMCFlag::kNProcess = kUnknownProcess

Definition at line 73 of file UtilMCFlag.h.


Generated on 3 Oct 2018 for loon by  doxygen 1.6.1