PTSim Namespace Reference

Enumerations

enum  EStdHepSelectMode { kUnknown = 0x00, kMomentum = 0x01, kHit = 0x02 }
enum  ECut {
  kCUTGAM, kCUTELE, kCUTNEU, kCUTHAD,
  kCUTMUO, kBCUTE, kBCUTM, kDCUTE,
  kDCUTM, kPPCUTM, kTOFMAX, kNCut
}
enum  EProcess {
  kANNI, kBREM, kCOMP, kDCAY,
  kDRAY, kHADR, kLOSS, kMULS,
  kMUNU, kPAIR, kPFIS, kPHOT,
  kNProcess
}

Functions

const char * AsString (ECut cut)
const char * AsString (EProcess process)
const char * AsString (EStdHepSelectMode mode)
int GetCut (const char *cutname)
int GetProcess (const char *processname)
int GetStdHepSelectMode (const char *mode)

Enumeration Type Documentation

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

Definition at line 28 of file PTSim.h.

00028             {
00029     // Flags to specify threshold cuts.  Kinetic energy cuts in GeV.
00030     // Time of flight cut in seconds.  Specified in order that they
00031     // appear in Geant3 "CUTS" flag.  
00032     kCUTGAM, // cut for gammas 
00033     kCUTELE, // cut for electrons 
00034     kCUTNEU, // cut for neutral hadrons 
00035     kCUTHAD, // cut for charged hadrons 
00036     kCUTMUO, // cut for muons
00037     kBCUTE,  // cut for electron bremsstrahlung
00038     kBCUTM,  // cut for muon and hadron bremsstrahlung
00039     kDCUTE,  // cut for delta rays by electrons
00040     kDCUTM,  // cut for delta rays by muons
00041     kPPCUTM, // total energy cut for direct pair production by muons
00042     kTOFMAX, // time of flight cut in seconds
00043     kNCut    // Number of cuts in enumerated list
00044   };

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

Definition at line 46 of file PTSim.h.

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

Enumerator:
kUnknown 
kMomentum 
kHit 

Definition at line 19 of file PTSim.h.

00019                          {
00020     // Flags to specify selection mode applied to secondaries produced
00021     // during particle transport to determine which particles to
00022     // store in output stdhep array.
00023     kUnknown  = 0x00,
00024     kMomentum = 0x01,  // particle must exceed configurable momentum threshold 
00025     kHit= 0x02 // particle must generate energy deposition hit exceeding thresh
00026   };


Function Documentation

const char * PTSim::AsString ( EStdHepSelectMode  mode  ) 

Definition at line 22 of file PTSim.cxx.

References kHit, kMomentum, kUnknown, Msg::kWarning, and MSG.

00022                                                   {
00023   //  Purpose:  Convert enumerated stdhep select mode to a string.
00024   //
00025   //  Return:  mode string. If unknown, returns "Unknown".
00026   //
00027 
00028   switch ( mode ) {
00029 
00030     case kUnknown:
00031       return "Unknown";
00032     case kMomentum:
00033       return "Momentum";
00034     case kHit:
00035       return "Hit";
00036     default:
00037       MSG("PTSim",Msg::kWarning) 
00038       << "PTSim::AsString called with unknown EStdHepSelectMode" 
00039       << (int)mode << endl;
00040       return "Unknown";
00041 
00042   }//end of switch
00043 
00044 }

const char * PTSim::AsString ( EProcess  process  ) 

Definition at line 136 of file PTSim.cxx.

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

00136                                             {
00137   //  Purpose:  Convert enumerated mc process to a process string.
00138   //
00139   //  Argument: process: enumerated EProcess described in PTSim.h.
00140   //
00141   //  Return:  process string. If unknown, returns "Unknown".
00142   //
00143   //  Contact:   S. Kasahara
00144   //
00145 
00146   switch ( process ) {
00147     case kANNI:
00148       return "ANNI";
00149     case kBREM:
00150       return "BREM";
00151     case kCOMP:
00152       return "COMP";
00153     case kDCAY:
00154       return "DCAY";
00155     case kDRAY:
00156       return "DRAY";
00157     case kHADR:
00158       return "HADR";
00159     case kLOSS:
00160       return "LOSS";
00161     case kMULS:
00162       return "MULS";
00163     case kMUNU:
00164       return "MUNU";
00165     case kPAIR:
00166       return "PAIR";
00167     case kPFIS:
00168       return "PFIS";
00169     case kPHOT:
00170       return "PHOT";
00171 
00172     default:
00173       MSG("PTSim",Msg::kWarning) 
00174       << "PTSim::AsString called with unknown process" << (int)process << endl;
00175       return "Unknown";
00176   }//end of switch
00177 
00178 }

const char * PTSim::AsString ( ECut  cut  ) 

Definition at line 63 of file PTSim.cxx.

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

00063                                     {
00064   //  Purpose:  Convert enumerated mc cut to a cut string.
00065   //
00066   //  Argument: cut: enumerated ECut described in PTSim.h.
00067   //
00068   //  Return:  cut string. If unknown, returns "Unknown".
00069   //
00070   //  Contact:   S. Kasahara
00071   //
00072 
00073   switch ( cut ) {
00074     case kCUTGAM:
00075       return "CUTGAM";
00076     case kCUTELE:
00077       return "CUTELE";
00078     case kCUTNEU:
00079       return "CUTNEU";
00080     case kCUTHAD:
00081       return "CUTHAD";
00082     case kCUTMUO:
00083       return "CUTMUO";
00084     case kBCUTE:
00085       return "BCUTE";
00086     case kBCUTM:
00087       return "BCUTM";
00088     case kDCUTE:
00089       return "DCUTE";
00090     case kDCUTM:
00091       return "DCUTM";
00092     case kPPCUTM:
00093       return "PPCUTM";
00094     case kTOFMAX:
00095       return "TOFMAX";
00096 
00097     default:
00098       MSG("PTSim",Msg::kWarning) 
00099       << "PTSim::AsString called with unknown cut" 
00100       << (int)cut << endl;
00101       return "Unknown";
00102   }//end of switch
00103 
00104 }

int PTSim::GetCut ( const char *  cutname  ) 

Definition at line 107 of file PTSim.cxx.

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

Referenced by GeoMediumMap::ConfigureMedium().

00107                                  {
00108   // Purpose: Convert text string cut to an enumerated code.
00109   // 
00110   // Argument: cut string
00111   //
00112   // Return: returns -1 if no match
00113   //
00114   // Contact: S. Kasahara
00115   //
00116 
00117   TString tmpstr(cut);
00118   tmpstr.ToLower();
00119   if ( strcmp(tmpstr.Data(),"cutgam") == 0 ) return PTSim::kCUTGAM;
00120   else if ( strcmp(tmpstr.Data(),"cutele") == 0 ) return PTSim::kCUTELE;
00121   else if ( strcmp(tmpstr.Data(),"cutneu") == 0 ) return PTSim::kCUTNEU;
00122   else if ( strcmp(tmpstr.Data(),"cuthad") == 0 ) return PTSim::kCUTHAD;
00123   else if ( strcmp(tmpstr.Data(),"cutmuo") == 0 ) return PTSim::kCUTMUO;
00124   else if ( strcmp(tmpstr.Data(),"bcute") == 0 ) return PTSim::kBCUTE;
00125   else if ( strcmp(tmpstr.Data(),"bcutm") == 0 ) return PTSim::kBCUTM;
00126   else if ( strcmp(tmpstr.Data(),"dcute") == 0 ) return PTSim::kDCUTE;
00127   else if ( strcmp(tmpstr.Data(),"dcutm") == 0 ) return PTSim::kDCUTM;
00128   else if ( strcmp(tmpstr.Data(),"ppcutm") == 0 ) return PTSim::kPPCUTM;
00129   else if ( strcmp(tmpstr.Data(),"tofmax") == 0 ) return PTSim::kTOFMAX;
00130 
00131   return -1;
00132 
00133 }

int PTSim::GetProcess ( const char *  processname  ) 

Definition at line 181 of file PTSim.cxx.

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

Referenced by GeoMediumMap::ConfigureMedium(), PTSimStack::FillStdHepArray(), PTSimStack::ParticleIsSelected(), and PTSimApplication::PreTrack().

00181                                          {
00182   // Purpose: Convert text string process to an enumerated code.
00183   // 
00184   // Argument: process string
00185   //
00186   // Return: returns -1 if no match
00187   //
00188   // Contact: S. Kasahara
00189   //
00190 
00191   TString tmpstr(process);
00192   tmpstr.ToLower();
00193   if ( strcmp(tmpstr.Data(),"anni") == 0 ) return PTSim::kANNI;
00194   else if ( strcmp(tmpstr.Data(),"brem") == 0 ) return PTSim::kBREM;
00195   else if ( strcmp(tmpstr.Data(),"comp") == 0 ) return PTSim::kCOMP;
00196   else if ( strcmp(tmpstr.Data(),"dcay") == 0 ) return PTSim::kDCAY;
00197   else if ( strcmp(tmpstr.Data(),"dray") == 0 ) return PTSim::kDRAY;
00198   else if ( strcmp(tmpstr.Data(),"hadr") == 0 ) return PTSim::kHADR;
00199   else if ( strcmp(tmpstr.Data(),"loss") == 0 ) return PTSim::kLOSS;
00200   else if ( strcmp(tmpstr.Data(),"muls") == 0 ) return PTSim::kMULS;
00201   else if ( strcmp(tmpstr.Data(),"munu") == 0 ) return PTSim::kMUNU;
00202   else if ( strcmp(tmpstr.Data(),"pair") == 0 ) return PTSim::kPAIR;
00203   else if ( strcmp(tmpstr.Data(),"pfis") == 0 ) return PTSim::kPFIS;
00204   else if ( strcmp(tmpstr.Data(),"phot") == 0 ) return PTSim::kPHOT;
00205 
00206   return -1;
00207 
00208 }

int PTSim::GetStdHepSelectMode ( const char *  mode  ) 

Definition at line 47 of file PTSim.cxx.

References kHit, and kMomentum.

00047                                                {
00048   // Purpose: Convert text string cut to an enumerated mode.
00049   //
00050   // Return: returns -1 if no match, else EStdHepSelectMode
00051   //
00052 
00053   TString tmpstr(mode);
00054   tmpstr.ToLower();
00055   if ( strcmp(tmpstr.Data(),"momentum") == 0 ) return PTSim::kMomentum;
00056   else if ( strcmp(tmpstr.Data(),"hit") == 0 ) return PTSim::kHit;
00057 
00058   return -1;
00059 
00060 }


Generated on 3 Dec 2018 for loon by  doxygen 1.6.1