MICEPhysicsList Class Reference

#include <MICEPhysicsList.hh>

List of all members.

Public Member Functions

 MICEPhysicsList ()
virtual ~MICEPhysicsList ()
void ConstructProcessesForOneParticle (G4ParticleDefinition *particle)
G4MuIonisation * theMuMinusIonisationf ()
G4MuIonisation * theMuPlusIonisationf ()
G4MultipleScattering * theMuMinusMultScatf ()
G4MultipleScattering * theMuPlusMultScatf ()

Protected Member Functions

virtual void ConstructParticle ()
virtual void ConstructProcess ()
virtual void SetCuts ()
virtual void ConstructBosons ()
virtual void ConstructLeptons ()
virtual void ConstructMesons ()
virtual void ConstructBaryons ()
virtual void ConstructIons ()
virtual void ConstructAll ()

Private Attributes

G4PhotoElectricEffect * thePhotoElectricEffect
G4ComptonScattering * theComptonScattering
G4GammaConversion * theGammaConversion
G4MultipleScattering * theeminusMultipleScattering
G4eIonisation * theeminusIonisation
G4eBremsstrahlung * theeminusBremsstrahlung
G4MultipleScattering * theeplusMultipleScattering
G4eIonisation * theeplusIonisation
G4eBremsstrahlung * theeplusBremsstrahlung
G4eplusAnnihilation * theeplusAnnihilation
G4MuIonisation * theMuMinusIonisation
G4MuIonisation * theMuPlusIonisation
G4MultipleScattering * theMuMinusMultScat
G4MultipleScattering * theMuPlusMultScat
G4PionPlusInelasticProcess * thePionPlusInelastic
G4LEPionPlusInelastic * theLEPionPlusModel
G4MultipleScattering * thePionPlusMult
G4PionMinusInelasticProcess * thePionMinusInelastic
G4LEPionMinusInelastic * theLEPionMinusModel
G4MultipleScattering * thePionMinusMult
G4ProtonInelasticProcess * theProtonInelastic
G4LEProtonInelastic * theLEProtonModel
G4MultipleScattering * theProtonMult
G4AntiProtonInelasticProcess * theAntiProtonInelastic
G4LEAntiProtonInelastic * theLEAntiProtonModel
G4MultipleScattering * theAntiProtonMult
G4NeutronInelasticProcess * theNeutronInelastic
G4LENeutronInelastic * theLENeutronModel
G4HadronCaptureProcess * theNeutronCapture
G4LCapture * theNeutronCaptureModel


Constructor & Destructor Documentation

MICEPhysicsList::MICEPhysicsList (  ) 

References DataCards::fetchValueDouble().

00062                                 : G4VUserPhysicsList(),
00063   thePhotoElectricEffect(NULL),theComptonScattering(NULL),
00064   theGammaConversion(NULL),
00065   theeminusMultipleScattering(NULL),theeminusIonisation(NULL),
00066   theeminusBremsstrahlung(NULL),
00067   theeplusMultipleScattering(NULL),theeplusIonisation(NULL),
00068   theeplusBremsstrahlung(NULL),
00069   theeplusAnnihilation(NULL)
00070 {
00071 //   theCerenkovProcess           = 0;
00072 //   theScintillationProcess      = 0;
00073 //   theAbsorptionProcess         = 0;
00074 //   theRayleighScatteringProcess = 0;
00075 //   theBoundaryProcess           = 0;
00076   defaultCutValue = MyDataCards.fetchValueDouble("ProductionThreshold")*mm;
00077 //   SetVerboseLevel(1);
00078 }

MICEPhysicsList::~MICEPhysicsList (  )  [virtual]

00081 {
00082 }


Member Function Documentation

void MICEPhysicsList::ConstructProcessesForOneParticle ( G4ParticleDefinition *  particle  ) 

References DataCards::fetchValueDouble(), DataCards::fetchValueString(), theAntiProtonInelastic, theAntiProtonMult, theComptonScattering, theeminusBremsstrahlung, theeminusIonisation, theeminusMultipleScattering, theeplusAnnihilation, theeplusBremsstrahlung, theeplusIonisation, theeplusMultipleScattering, theGammaConversion, theLEAntiProtonModel, theLENeutronModel, theLEPionMinusModel, theLEPionPlusModel, theLEProtonModel, theMuMinusIonisation, theMuMinusMultScat, theMuPlusIonisation, theMuPlusMultScat, theNeutronCapture, theNeutronCaptureModel, theNeutronInelastic, thePhotoElectricEffect, thePionMinusInelastic, thePionMinusMult, thePionPlusInelastic, thePionPlusMult, theProtonInelastic, and theProtonMult.

Referenced by ConstructAll().

00163 {
00164     G4ProcessManager* pmanager = particle->GetProcessManager();
00165     G4String particleName = particle->GetParticleName();
00166     G4String particleType = particle->GetParticleType();
00167     //G4cout << particleType << G4endl;
00168 
00169       if (particleName == "gamma") {
00170         thePhotoElectricEffect = new G4PhotoElectricEffect();
00171         theComptonScattering = new G4ComptonScattering();
00172         theGammaConversion = new G4GammaConversion();
00173         pmanager->AddDiscreteProcess(thePhotoElectricEffect);
00174         pmanager->AddDiscreteProcess(theComptonScattering);
00175         pmanager->AddDiscreteProcess(theGammaConversion);
00176 
00177         if (MyDataCards.fetchValueString("BeamType") == "Electron") {
00178           G4LowEnergyCompton *alComp = new G4LowEnergyCompton();
00179           G4LowEnergyRayleigh *alRay = new G4LowEnergyRayleigh();
00180           G4LowEnergyGammaConversion *alGamConv =
00181                                       new G4LowEnergyGammaConversion();
00182           G4LowEnergyPhotoElectric *alPE = new G4LowEnergyPhotoElectric();
00183           pmanager->AddDiscreteProcess(alComp );
00184           pmanager->AddDiscreteProcess(alRay);
00185           pmanager->AddDiscreteProcess(alGamConv);
00186           pmanager->AddDiscreteProcess(alPE);
00187         }
00188       } else if (particleName == "e-") {
00189         theeminusMultipleScattering = new G4MultipleScattering();
00190         pmanager->AddProcess(theeminusMultipleScattering);
00191         theeminusIonisation = new G4eIonisation();
00192         theeminusBremsstrahlung = new G4eBremsstrahlung();
00193 
00194         pmanager->AddProcess(theeminusIonisation);
00195         pmanager->AddProcess(theeminusBremsstrahlung);
00196         if (MyDataCards.fetchValueString("BeamType") == "Electron"){
00197           G4LowEnergyBremsstrahlung *alEBrem = new  G4LowEnergyBremsstrahlung();
00198           G4LowEnergyIonisation *alEIon = new G4LowEnergyIonisation();
00199           pmanager->AddProcess(alEIon);
00200           pmanager->AddProcess( alEBrem);
00201         }
00202         pmanager->SetProcessOrdering(theeminusMultipleScattering, idxAlongStep,1);
00203         pmanager->SetProcessOrdering(theeminusBremsstrahlung, idxAlongStep, 2);
00204         pmanager->SetProcessOrdering(theeminusIonisation, idxAlongStep, 3);
00205         pmanager->SetProcessOrdering(theeminusMultipleScattering, idxPostStep, 1);
00206         pmanager->SetProcessOrdering(theeminusBremsstrahlung, idxPostStep, 2);
00207         pmanager->SetProcessOrdering(theeminusIonisation, idxPostStep, 3);
00208       } else if (particleName == "e+") {
00209         theeplusMultipleScattering = new G4MultipleScattering();
00210         theeplusIonisation = new G4eIonisation();
00211         theeplusBremsstrahlung = new G4eBremsstrahlung();
00212         theeplusAnnihilation = new G4eplusAnnihilation();
00213         pmanager->AddProcess(theeplusMultipleScattering);
00214         pmanager->AddProcess(theeplusIonisation);
00215         pmanager->AddProcess(theeplusBremsstrahlung);
00216         pmanager->AddProcess(theeplusAnnihilation);
00217         pmanager->SetProcessOrderingToFirst(theeplusAnnihilation, idxAtRest);
00218         pmanager->SetProcessOrdering(theeplusMultipleScattering, idxAlongStep,  1);
00219         pmanager->SetProcessOrdering(theeplusIonisation, idxAlongStep,  2);
00220         pmanager->SetProcessOrdering(theeplusMultipleScattering, idxPostStep, 1);
00221         pmanager->SetProcessOrdering(theeplusIonisation, idxPostStep, 2);
00222         pmanager->SetProcessOrdering(theeplusBremsstrahlung, idxPostStep, 3);
00223         pmanager->SetProcessOrdering(theeplusAnnihilation, idxPostStep, 4);
00224       } else if( particleName == "mu+" || particleName == "mu-" ) {
00225         G4VProcess* aMultipleScattering;
00226         G4VProcess* aBremsstrahlung = new G4MuBremsstrahlung();
00227         G4VProcess* aPairProduction = new G4MuPairProduction();
00228         G4VProcess* anIonisation;
00229         if ( particleName == "mu+") {
00230           this->theMuPlusIonisation = new G4MuIonisation();
00231           anIonisation = this->theMuPlusIonisation;
00232           this->theMuPlusMultScat  = new G4MultipleScattering();
00233           aMultipleScattering = this->theMuPlusMultScat;
00234           //Magic Patch to fix multiple scale..
00235           //this->theMuPlusMultScat->SetScatteringParameter(scatParam);
00236         } else {
00237           this->theMuMinusIonisation = new G4MuIonisation();
00238           anIonisation = this->theMuMinusIonisation;
00239           this->theMuMinusMultScat  = new G4MultipleScattering();
00240           aMultipleScattering = this->theMuMinusMultScat;
00241           //Magic Patch to fix multiple scale..
00242           //this->theMuMinusMultScat->SetScatteringParameter(scatParam);
00243         }
00244         pmanager->AddProcess(anIonisation);
00245         pmanager->AddProcess(aMultipleScattering);
00246         pmanager->AddProcess(aBremsstrahlung);
00247         pmanager->AddProcess(aPairProduction);
00248 
00249         pmanager->SetProcessOrdering(aMultipleScattering, idxAlongStep, 1);
00250         pmanager->SetProcessOrdering(anIonisation, idxAlongStep,  2);
00251 
00252         pmanager->SetProcessOrdering(aMultipleScattering, idxPostStep, 1);
00253         pmanager->SetProcessOrdering(anIonisation, idxPostStep, 2);
00254         pmanager->SetProcessOrdering(aBremsstrahlung, idxPostStep, 3);
00255         pmanager->SetProcessOrdering(aPairProduction, idxPostStep, 4);
00256 
00257         if (MyDataCards.fetchValueString("MuonDecay") == "True"){
00258           // Allows tweaking muon decay, if turned on.
00259           G4double muHalfTime = MyDataCards.fetchValueDouble("MuonHalfTime")*nanosecond;
00260           if (muHalfTime > 0) { // else use g4 default
00261             particle->SetPDGLifeTime(muHalfTime);
00262           }
00263           G4VProcess* aDecay = new G4Decay();
00264           pmanager->AddProcess(aDecay);
00265           pmanager->SetProcessOrdering(aDecay, idxPostStep, 5);
00266           pmanager->SetProcessOrdering(aDecay, idxAtRest);
00267         }
00268       } else if (particleType == "meson") {   // Rikards own hadronics:
00269         G4HadronElasticProcess* theElasticProcess =
00270                                     new G4HadronElasticProcess;
00271         G4LElastic* theElasticModel = new G4LElastic;
00272         theElasticProcess->RegisterMe(theElasticModel);
00273 
00274         // Add decay
00275         //
00276         // Only charged pions are interesting. All other mesons are only allowed
00277         // to decay and create children which may or may not be subject to
00278         // ionisation etc.
00279         if ((MyDataCards.fetchValueString("HadronDecayOption") == "Meson")
00280           |(MyDataCards.fetchValueString("HadronDecayOption") == "All")){
00281           G4VProcess* aDecay = new G4Decay();
00282           pmanager ->AddProcess(aDecay);
00283           pmanager ->SetProcessOrdering(aDecay, idxPostStep);
00284           pmanager ->SetProcessOrdering(aDecay, idxAtRest);
00285         }
00286 
00287         // Add ionisation
00288         //
00289         // If the particle is charged allow it to ionize gas if if flag is set.
00290         if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Meson")
00291             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00292           if (particle->GetPDGCharge()){ //charged particle?
00293             G4hIonisation* theIonisation = new G4hIonisation();
00294             pmanager->AddProcess(theIonisation, ordInActive,2, 2);
00295           }
00296         }
00297 
00298         if (particleName == "pi+"){
00299           // PionPlus
00300           if ((MyDataCards.fetchValueString("HadronScatteringOption") == "Meson")
00301           |(MyDataCards.fetchValueString("HadronScatteringOption") == "All")){
00302             theLEPionPlusModel = new G4LEPionPlusInelastic();
00303             thePionPlusInelastic = new G4PionPlusInelasticProcess();
00304             thePionPlusInelastic->RegisterMe(theLEPionPlusModel);
00305             thePionPlusMult = new G4MultipleScattering();
00306             pmanager->AddDiscreteProcess(theElasticProcess);
00307             pmanager->AddDiscreteProcess(thePionPlusInelastic);
00308             pmanager->AddProcess(thePionPlusMult);
00309             pmanager->SetProcessOrdering(thePionPlusMult, idxAlongStep, 1);
00310             pmanager->SetProcessOrdering(thePionPlusMult, idxPostStep, 1);
00311           }
00312 //           if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Meson")
00313 //             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00314 //             thePionPlusIonisation = new G4hIonisation();
00315 //             pmanager->AddProcess(thePionPlusIonisation, ordInActive,2, 2);
00316 //           }
00317         } else if (particleName == "pi-"){
00318           // PionMinus
00319           if ((MyDataCards.fetchValueString("HadronScatteringOption") == "Meson")
00320           |(MyDataCards.fetchValueString("HadronScatteringOption") == "All")){
00321             theLEPionMinusModel = new G4LEPionMinusInelastic();
00322             thePionMinusInelastic = new G4PionMinusInelasticProcess();
00323             thePionMinusInelastic->RegisterMe(theLEPionMinusModel);
00324             thePionMinusMult = new G4MultipleScattering();
00325             pmanager->AddDiscreteProcess(theElasticProcess);
00326             pmanager->AddDiscreteProcess(thePionMinusInelastic);
00327             pmanager->AddProcess(thePionMinusMult);
00328             pmanager->SetProcessOrdering(thePionMinusMult, idxAlongStep, 1);
00329             pmanager->SetProcessOrdering(thePionMinusMult, idxPostStep, 1);
00330           }
00331 //           if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Meson")
00332 //             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00333 //             thePionMinusIonisation = new G4hIonisation();
00334 //             pmanager->AddProcess(thePionMinusIonisation, ordInActive,2, 2);
00335 //           }
00336         }
00337 
00338       } else if (particleType == "baryon") {
00339         G4HadronElasticProcess* theElasticProcess =
00340                                     new G4HadronElasticProcess;
00341         G4LElastic* theElasticModel = new G4LElastic;
00342         theElasticProcess->RegisterMe(theElasticModel);
00343 
00344         // Add decay
00345         //
00346         // Only protons and neutrons are interesting. All other baryons are
00347         // only allowed to decay and create children which may or may not be
00348         // subject to ionisation etc (if they can decay according to PDG).
00349         // Antiprotons and antineutrons are too rare.
00350         if ((MyDataCards.fetchValueString("HadronDecayOption") == "Baryon")
00351           |(MyDataCards.fetchValueString("HadronDecayOption") == "All")){
00352           G4VProcess* aDecay = new G4Decay();
00353           if (particle->GetPDGStable() == false){
00354             pmanager ->AddProcess(aDecay);
00355             pmanager ->SetProcessOrdering(aDecay, idxPostStep);
00356             pmanager ->SetProcessOrdering(aDecay, idxAtRest);
00357           }
00358         }
00359 
00360         // Add ionisation
00361         //
00362         // If the particle is charged allow it to ionize gas if if flag is set.
00363         if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Baryon")
00364             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00365           if (particle->GetPDGCharge()){ //charged particle?
00366             G4hIonisation* theIonisation = new G4hIonisation();
00367             pmanager->AddProcess(theIonisation, ordInActive,2, 2);
00368           }
00369         }
00370 
00371         if (particleName == "proton"){
00372           // Proton
00373           if ((MyDataCards.fetchValueString("HadronScatteringOption") == "Baryon")
00374           |(MyDataCards.fetchValueString("HadronScatteringOption") == "All")){
00375             theLEProtonModel = new G4LEProtonInelastic();
00376             theProtonInelastic = new G4ProtonInelasticProcess();
00377             theProtonInelastic->RegisterMe(theLEProtonModel);
00378             theProtonMult = new G4MultipleScattering();
00379             pmanager->AddDiscreteProcess(theElasticProcess);
00380             pmanager->AddDiscreteProcess(theProtonInelastic);
00381             pmanager->AddProcess(theProtonMult); // this is defeated in competition
00382             //with the elastic and inelastic scattering.
00383             pmanager->SetProcessOrdering(theProtonMult, idxAlongStep, 1);
00384             pmanager->SetProcessOrdering(theProtonMult, idxPostStep, 1);
00385             pmanager->SetProcessOrdering(theElasticProcess, idxPostStep, 3);
00386             pmanager->SetProcessOrdering(theProtonInelastic, idxPostStep, 4);
00387           }
00388 //           if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Baryon")
00389 //             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00390 //             theProtonIonisation = new G4hIonisation();
00391 //             pmanager->AddProcess(theProtonIonisation);
00392 //             //pmanager->AddProcess(theProtonIonisation, ordInActive,2, 2);
00393 //             pmanager->SetProcessOrdering(theProtonIonisation, idxAlongStep, 2);
00394 //             pmanager->SetProcessOrdering(theProtonIonisation, idxPostStep, 2);
00395 //           }
00396         } else if (particleName == "anti_proton"){
00397           // Anti Proton
00398           if ((MyDataCards.fetchValueString("HadronScatteringOption") == "Baryon")
00399           |(MyDataCards.fetchValueString("HadronScatteringOption") == "All")){
00400             theLEAntiProtonModel = new G4LEAntiProtonInelastic();
00401             theAntiProtonInelastic = new G4AntiProtonInelasticProcess();
00402             theAntiProtonInelastic->RegisterMe(theLEAntiProtonModel);
00403             theAntiProtonMult = new G4MultipleScattering();
00404           //theAntiProtonAnnihilation =  new G4AntiProtonAnnihilationAtRest();
00405             pmanager->AddDiscreteProcess(theElasticProcess);
00406             pmanager->AddDiscreteProcess(theAntiProtonInelastic);
00407             pmanager->AddProcess(theAntiProtonMult);
00408             pmanager->SetProcessOrdering(theAntiProtonMult, idxAlongStep, 1);
00409             pmanager->SetProcessOrdering(theAntiProtonMult, idxPostStep, 1);
00410           //pmanager->AddRestProcess(theAntiProtonAnnihilation);
00411           }
00412 //           if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Baryon")
00413 //             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00414 //             theAntiProtonIonisation = new G4hIonisation();
00415 //             pmanager->AddProcess(theAntiProtonIonisation, ordInActive,2, 2);
00416 //           }
00417         } else if (particleName == "neutron"){
00418           if ((MyDataCards.fetchValueString("HadronScatteringOption") == "Baryon")
00419           |(MyDataCards.fetchValueString("HadronScatteringOption") == "All")){
00420             theLENeutronModel = new G4LENeutronInelastic();
00421             theNeutronInelastic = new G4NeutronInelasticProcess();
00422             theNeutronInelastic->RegisterMe(theLENeutronModel);
00423             pmanager->AddDiscreteProcess(theElasticProcess);
00424             pmanager->AddDiscreteProcess(theNeutronInelastic);
00425           }
00426           theNeutronCaptureModel = new G4LCapture();
00427           theNeutronCapture = new G4HadronCaptureProcess();
00428           theNeutronCapture->RegisterMe(theNeutronCaptureModel);
00429           pmanager->AddDiscreteProcess(theNeutronCapture);
00430         }
00431       }
00432 
00433       // Ions, also uncharged nucleus.
00434       if (particleType == "nucleus") {
00435         G4HadronElasticProcess* theElasticProcess =
00436                                     new G4HadronElasticProcess;
00437         G4LElastic* theElasticModel = new G4LElastic;
00438         theElasticProcess->RegisterMe(theElasticModel);
00439 
00440         // Add decay
00441         if ((MyDataCards.fetchValueString("HadronDecayOption") == "Ion")
00442           |(MyDataCards.fetchValueString("HadronDecayOption") == "All")){
00443           G4VProcess* aDecay = new G4Decay();
00444           if (particle->GetPDGStable() == false){
00445             pmanager ->AddProcess(aDecay);
00446             pmanager ->SetProcessOrdering(aDecay, idxPostStep);
00447             pmanager ->SetProcessOrdering(aDecay, idxAtRest);
00448           }
00449         }
00450 
00451         // Add ionisation
00452         //
00453         // If the nucleus is charged allow it to ionize gas if if flag is set.
00454         if ((MyDataCards.fetchValueString("HadronIonisationOption") == "Ion")
00455             |(MyDataCards.fetchValueString("HadronIonisationOption") == "All")){
00456           if (particle->GetPDGCharge()){ //charged particle?
00457             G4hIonisation* theIonisation = new G4hIonisation();
00458             pmanager->AddProcess(theIonisation, ordInActive,2, 2);
00459           }
00460         }
00461       }
00462 
00463 }// end of method

void MICEPhysicsList::ConstructParticle (  )  [protected, virtual]

References ConstructBaryons(), ConstructBosons(), ConstructIons(), ConstructLeptons(), and ConstructMesons().

00085 {
00086   // In this method, static member functions should be called
00087   // for all particles which you want to use.
00088   // This ensures that objects of these particle types will be
00089   // created in the program.
00090 
00091   ConstructBosons();
00092   ConstructLeptons();
00093   ConstructMesons();
00094   ConstructBaryons();
00095   ConstructIons();
00096 }

void MICEPhysicsList::ConstructProcess (  )  [protected, virtual]

References ConstructAll().

00147 {
00148   AddTransportation();
00149   ConstructAll();
00150   //ConstructOp();
00151 }

void MICEPhysicsList::SetCuts (  )  [protected, virtual]

References DataCards::fetchValueString().

00506 {
00507   if (verboseLevel >1){
00508     G4cout << "MICEPhysicsList::SetCuts:";
00509   }
00510   //  " G4VUserPhysicsList::SetCutsWithDefault" method sets
00511   //   the default cut value for all particle types
00512   SetCutsWithDefault();
00513 
00514 
00515   // SetCutValue sets a cut value for a particle type for a region
00516   // Geant4 presently only supports gamma, e+ & e-.
00517   //SetCutValue(0.5*mm, "e-", const G4String& rname);
00518   typedef std::vector<G4Region*>::iterator regionIterator;
00519   G4RegionStore* regionStore = G4RegionStore::GetInstance();
00520   G4cout << "\nList of defined G4Regions: " << G4endl;
00521   for(regionIterator rItr=regionStore->begin();rItr!=regionStore->end();rItr++)
00522   {
00523     G4Region* aR = *rItr;
00524     G4cout << "- " << aR->GetName() << G4endl;
00525   }
00526 
00527   if (MyDataCards.fetchValueString("TrackerOption") == "TPG") {
00528     // This is the sensitive gas region of the TPG and the volumes inside it.
00529     G4Region* regA = G4RegionStore::GetInstance()->GetRegion("lGasVolumeTPGUp");
00530     G4Region* regB = G4RegionStore::GetInstance()->GetRegion("lGasVolumeTPGDown");
00531     G4ProductionCuts* cuts = new G4ProductionCuts;
00532     cuts->SetProductionCut(0.5*mm);
00533     regA->SetProductionCuts(cuts);
00534     regB->SetProductionCuts(cuts);
00535   }
00536   //SetCutValue(0.5*mm, "e-");
00537 
00538 
00539 
00540   DumpCutValuesTable();
00541 }

void MICEPhysicsList::ConstructBosons (  )  [protected, virtual]

Referenced by ConstructParticle().

00099 {
00100   // gamma
00101   G4Gamma::GammaDefinition();
00102   // optical photon
00103   // G4OpticalPhoton::OpticalPhotonDefinition();
00104 
00105   // pseudo-particles
00106   G4Geantino::GeantinoDefinition();
00107   // G4ChargedGeantino::ChargedGeantinoDefinition();
00108 }

void MICEPhysicsList::ConstructLeptons (  )  [protected, virtual]

Referenced by ConstructParticle().

00111 {
00112   // leptons
00113   //  e+/-
00114   G4Electron::ElectronDefinition();
00115   G4Positron::PositronDefinition();
00116   // mu+/-
00117   G4MuonPlus::MuonPlusDefinition();
00118   G4MuonMinus::MuonMinusDefinition();
00119   // Neutrinos, needed for pion and mu decay.
00120   G4NeutrinoMu::NeutrinoMuDefinition();
00121   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
00122   G4NeutrinoE::NeutrinoEDefinition();
00123   G4AntiNeutrinoE::AntiNeutrinoEDefinition();
00124 
00125 }

void MICEPhysicsList::ConstructMesons (  )  [protected, virtual]

Referenced by ConstructParticle().

00128 {
00129   G4PionPlus::PionPlusDefinition();
00130   G4PionMinus::PionMinusDefinition();
00131   G4PionZero::PionZeroDefinition();
00132 }

void MICEPhysicsList::ConstructBaryons (  )  [protected, virtual]

Referenced by ConstructParticle().

00135 {
00136   G4Proton::ProtonDefinition();
00137   G4AntiProton::AntiProtonDefinition();
00138   G4Neutron::NeutronDefinition();
00139 }

void MICEPhysicsList::ConstructIons (  )  [protected, virtual]

Referenced by ConstructParticle().

00142 {
00143   G4GenericIon::GenericIonDefinition();
00144 }

void MICEPhysicsList::ConstructAll (  )  [protected, virtual]

References ConstructProcessesForOneParticle().

Referenced by ConstructProcess().

00154 {
00155   theParticleIterator->reset();
00156   while( (*theParticleIterator)() ){
00157     G4ParticleDefinition* particle = theParticleIterator->value();
00158     ConstructProcessesForOneParticle(particle);
00159   }
00160 }

G4MuIonisation* MICEPhysicsList::theMuMinusIonisationf (  )  [inline]

References theMuMinusIonisation.

00186                          {return theMuMinusIonisation; }

G4MuIonisation* MICEPhysicsList::theMuPlusIonisationf (  )  [inline]

References theMuPlusIonisation.

00188                          {return theMuPlusIonisation; }

G4MultipleScattering* MICEPhysicsList::theMuMinusMultScatf (  )  [inline]

References theMuMinusMultScat.

00191                          {return theMuMinusMultScat; }

G4MultipleScattering* MICEPhysicsList::theMuPlusMultScatf (  )  [inline]

References theMuPlusMultScat.

00193                          {return theMuPlusMultScat; }


Member Data Documentation

G4PhotoElectricEffect* MICEPhysicsList::thePhotoElectricEffect [private]

G4ComptonScattering* MICEPhysicsList::theComptonScattering [private]

G4GammaConversion* MICEPhysicsList::theGammaConversion [private]

G4MultipleScattering* MICEPhysicsList::theeminusMultipleScattering [private]

G4eIonisation* MICEPhysicsList::theeminusIonisation [private]

G4eBremsstrahlung* MICEPhysicsList::theeminusBremsstrahlung [private]

G4MultipleScattering* MICEPhysicsList::theeplusMultipleScattering [private]

G4eIonisation* MICEPhysicsList::theeplusIonisation [private]

G4eBremsstrahlung* MICEPhysicsList::theeplusBremsstrahlung [private]

G4eplusAnnihilation* MICEPhysicsList::theeplusAnnihilation [private]

G4MuIonisation* MICEPhysicsList::theMuMinusIonisation [private]

G4MuIonisation* MICEPhysicsList::theMuPlusIonisation [private]

G4MultipleScattering* MICEPhysicsList::theMuMinusMultScat [private]

G4MultipleScattering* MICEPhysicsList::theMuPlusMultScat [private]

G4PionPlusInelasticProcess* MICEPhysicsList::thePionPlusInelastic [private]

G4LEPionPlusInelastic* MICEPhysicsList::theLEPionPlusModel [private]

G4MultipleScattering* MICEPhysicsList::thePionPlusMult [private]

G4PionMinusInelasticProcess* MICEPhysicsList::thePionMinusInelastic [private]

G4LEPionMinusInelastic* MICEPhysicsList::theLEPionMinusModel [private]

G4MultipleScattering* MICEPhysicsList::thePionMinusMult [private]

G4ProtonInelasticProcess* MICEPhysicsList::theProtonInelastic [private]

G4LEProtonInelastic* MICEPhysicsList::theLEProtonModel [private]

G4MultipleScattering* MICEPhysicsList::theProtonMult [private]

G4AntiProtonInelasticProcess* MICEPhysicsList::theAntiProtonInelastic [private]

G4LEAntiProtonInelastic* MICEPhysicsList::theLEAntiProtonModel [private]

G4MultipleScattering* MICEPhysicsList::theAntiProtonMult [private]

G4NeutronInelasticProcess* MICEPhysicsList::theNeutronInelastic [private]

G4LENeutronInelastic* MICEPhysicsList::theLENeutronModel [private]

G4HadronCaptureProcess* MICEPhysicsList::theNeutronCapture [private]


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