B03PhysicsList Class Reference

#include <B03PhysicsList.hh>

Inheritance diagram for B03PhysicsList:

Collaboration diagram for B03PhysicsList:

Public Member Functions
	B03PhysicsList ()
virtual	~B03PhysicsList ()
void	AddParallelWorldName (G4String &pname)
void	AddBiasing (G4GeometrySampler *mgs, G4String &pname)
Public Member Functions inherited from G4VUserPhysicsList
	G4VUserPhysicsList ()
virtual	~G4VUserPhysicsList ()
	G4VUserPhysicsList (const G4VUserPhysicsList &)
G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)
void	Construct ()
void	UseCoupledTransportation (G4bool vl=true)
void	SetDefaultCutValue (G4double newCutValue)
G4double	GetDefaultCutValue () const
void	BuildPhysicsTable ()
void	PreparePhysicsTable (G4ParticleDefinition *)
void	BuildPhysicsTable (G4ParticleDefinition *)
G4bool	StorePhysicsTable (const G4String &directory=".")
G4bool	IsPhysicsTableRetrieved () const
G4bool	IsStoredInAscii () const
const G4String &	GetPhysicsTableDirectory () const
void	SetPhysicsTableRetrieved (const G4String &directory="")
void	SetStoredInAscii ()
void	ResetPhysicsTableRetrieved ()
void	ResetStoredInAscii ()
void	DumpList () const
void	DumpCutValuesTable (G4int flag=1)
void	DumpCutValuesTableIfRequested ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
void	SetCutsWithDefault ()
void	SetCutValue (G4double aCut, const G4String &pname)
G4double	GetCutValue (const G4String &pname) const
void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)
void	SetParticleCuts (G4double cut, G4ParticleDefinition *particle, G4Region *region=0)
void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=0)
void	SetCutsForRegion (G4double aCut, const G4String &rname)
void	ResetCuts ()
	obsolete methods More...
void	SetApplyCuts (G4bool value, const G4String &name)
G4bool	GetApplyCuts (const G4String &name) const
void	RemoveProcessManager ()
void	AddProcessManager (G4ParticleDefinition *newParticle, G4ProcessManager *newManager=0)
void	CheckParticleList ()
void	DisableCheckParticleList ()
G4int	GetInstanceID () const
void	InitializeWorker ()

Protected Member Functions
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
virtual void	SetCuts ()
virtual void	ConstructGeneral ()
virtual void	ConstructEM ()
virtual void	ConstructHad ()
virtual void	ConstructLeptHad ()
void	AddScoringProcess ()
void	AddBiasingProcess ()
void	ConstructAllBosons ()
void	ConstructAllLeptons ()
void	ConstructAllMesons ()
void	ConstructAllBaryons ()
void	ConstructAllIons ()
void	ConstructAllShortLiveds ()
Protected Member Functions inherited from G4VUserPhysicsList
void	AddTransportation ()
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
void	BuildIntegralPhysicsTable (G4VProcess *, G4ParticleDefinition *)
virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)
void	InitializeProcessManager ()
G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Additional Inherited Members
Static Public Member Functions inherited from G4VUserPhysicsList
static const G4VUPLManager &	GetSubInstanceManager ()
Protected Attributes inherited from G4VUserPhysicsList
G4ParticleTable *	theParticleTable
G4int	verboseLevel
G4double	defaultCutValue
G4bool	isSetDefaultCutValue
G4ProductionCutsTable *	fCutsTable
G4bool	fRetrievePhysicsTable
G4bool	fStoredInAscii
G4bool	fIsCheckedForRetrievePhysicsTable
G4bool	fIsRestoredCutValues
G4String	directoryPhysicsTable
G4bool	fDisableCheckParticleList
G4int	g4vuplInstanceID
Static Protected Attributes inherited from G4VUserPhysicsList
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 41 of file B03PhysicsList.hh.

Constructor & Destructor Documentation

B03PhysicsList::B03PhysicsList

(

)

Definition at line 56 of file B03PhysicsList.cc.

                              :  G4VUserPhysicsList()
{
  fParaWorldName.clear();
  SetVerboseLevel(1);  
}

Here is the call graph for this function:

B03PhysicsList::~B03PhysicsList ( )

virtual

Definition at line 64 of file B03PhysicsList.cc.

{
  fParaWorldName.clear();
}

Member Function Documentation

void B03PhysicsList::AddBiasing ( G4GeometrySampler *  mgs, G4String &  pname  )

inline

Definition at line 51 of file B03PhysicsList.hh.

         {fGeomSampler = mgs; fBiasWorldName = pname;}

void B03PhysicsList::AddBiasingProcess ( )

protected

Definition at line 662 of file B03PhysicsList.cc.

                                      {

  
  G4cout << " Preparing Importance Sampling with GhostWorld " 
         << fBiasWorldName << G4endl;
  fGeomSampler->SetParallel(true); // parallelworld
  G4IStore* iStore = G4IStore::GetInstance(fBiasWorldName);
  fGeomSampler->SetWorld(iStore->GetParallelWorldVolumePointer());
  //  fGeomSampler->PrepareImportanceSampling(G4IStore::
  //                              GetInstance(fBiasWorldName), 0);
  static G4bool first = true;
  if(first) {
    fGeomSampler->PrepareImportanceSampling(iStore, 0);

    fGeomSampler->Configure();
    G4cout << " GeomSampler Configured!!! " << G4endl;
    first = false;
  }

#ifdef G4MULTITHREADED 
    fGeomSampler->AddProcess();
#else
  G4cout << " Running in singlethreaded mode!!! " << G4endl;
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::AddParallelWorldName ( G4String &  pname )

inline

Definition at line 48 of file B03PhysicsList.hh.

         {fParaWorldName.push_back(pname);}

Here is the caller graph for this function:

void B03PhysicsList::AddScoringProcess ( )

protected

Definition at line 634 of file B03PhysicsList.cc.

                                      {

  G4int npw = fParaWorldName.size();
  for ( G4int i = 0; i < npw; i++){
   G4String procName = "ParaWorldProc_"+fParaWorldName[i];
   G4ParallelWorldProcess* theParallelWorldProcess
     = new G4ParallelWorldProcess(procName);
   theParallelWorldProcess->SetParallelWorld(fParaWorldName[i]);

   auto particleIterator=GetParticleIterator();
   particleIterator->reset();
   while( (*particleIterator)() ){
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    pmanager->AddProcess(theParallelWorldProcess);
    if(theParallelWorldProcess->IsAtRestRequired(particle))
    {pmanager->SetProcessOrdering(theParallelWorldProcess, idxAtRest, 9900);}
    pmanager->SetProcessOrderingToSecond(theParallelWorldProcess, idxAlongStep);
    pmanager->SetProcessOrdering(theParallelWorldProcess, idxPostStep, 9900);
   }
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllBaryons ( )

protected

Definition at line 115 of file B03PhysicsList.cc.

{
  //  Construct all barions
  G4BaryonConstructor pConstructor;
  pConstructor.ConstructParticle();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllBosons ( )

protected

Definition at line 88 of file B03PhysicsList.cc.

{
  // Construct all bosons
  G4BosonConstructor pConstructor;
  pConstructor.ConstructParticle();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllIons ( )

protected

Definition at line 124 of file B03PhysicsList.cc.

{
  //  Construct light ions
  G4IonConstructor pConstructor;
  pConstructor.ConstructParticle();  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllLeptons ( )

protected

Definition at line 97 of file B03PhysicsList.cc.

{
  // Construct all leptons
  G4LeptonConstructor pConstructor;
  pConstructor.ConstructParticle();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllMesons ( )

protected

Definition at line 106 of file B03PhysicsList.cc.

{
  //  Construct all mesons
  G4MesonConstructor pConstructor;
  pConstructor.ConstructParticle();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructAllShortLiveds ( )

protected

Definition at line 133 of file B03PhysicsList.cc.

{
  //  Construct  resonaces and quarks
  G4ShortLivedConstructor pConstructor;
  pConstructor.ConstructParticle();  
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructEM ( )

protectedvirtual

Definition at line 173 of file B03PhysicsList.cc.

{
  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  while( (*particleIterator)() ){
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    G4String particleName = particle->GetParticleName();
     
    if (particleName == "gamma") {
    // gamma
      // Construct processes for gamma
      pmanager->AddDiscreteProcess(new G4GammaConversion());
      pmanager->AddDiscreteProcess(new G4ComptonScattering());      
      pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());

    } else if (particleName == "e-") {
    //electron
      // Construct processes for electron
      pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
      pmanager->AddProcess(new G4eIonisation(),-1,2,2);
      pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
  
    } else if (particleName == "e+") {
    //positron
      // Construct processes for positron
     pmanager->AddProcess(new G4eMultipleScattering(),-1,1,1);
     
     pmanager->AddProcess(new G4eIonisation(),-1,2,2);
     pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);      
     pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
  
    } else if( particleName == "mu+" || 
               particleName == "mu-"    ) {
    //muon  
     // Construct processes for muon+
     pmanager->AddProcess(new G4MuMultipleScattering(),-1,1,1);
     pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
     pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
     pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);       
     
    } else if( particleName == "GenericIon" ) {
      pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
      pmanager->AddProcess(new G4hIonisation(),-1,2,2); 
    } else { 
      if ((particle->GetPDGCharge() != 0.0) && 
          (particle->GetParticleName() != "chargedgeantino")&&
          (!particle->IsShortLived()) ) {
     // all others charged particles except geantino
       pmanager->AddProcess(new G4hMultipleScattering(),-1,1,1);
       pmanager->AddProcess(new G4hIonisation(),-1,2,2);       
     }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructGeneral ( )

protectedvirtual

Definition at line 601 of file B03PhysicsList.cc.

{
  G4Decay* theDecayProcess = new G4Decay();
  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  while( (*particleIterator)() ){
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    if (theDecayProcess->IsApplicable(*particle)) { 
      pmanager ->AddProcess(theDecayProcess);
      pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
      pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructHad ( )

protectedvirtual

Definition at line 298 of file B03PhysicsList.cc.

{
  // this will be the model class for high energies
  G4TheoFSGenerator* theTheoModel = new G4TheoFSGenerator;
  G4TheoFSGenerator* antiBHighEnergyModel = new G4TheoFSGenerator;
       
  // Evaporation logic
  G4ExcitationHandler* theHandler = new G4ExcitationHandler;
  theHandler->SetMinEForMultiFrag(3*MeV);
        
  // Pre equilibrium stage 
  G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(theHandler);

  // a no-cascade generator-precompound interaface
  G4GeneratorPrecompoundInterface* theCascade =
                                    new G4GeneratorPrecompoundInterface;
  theCascade->SetDeExcitation(thePreEquilib);  

  // Bertini cascade
  G4CascadeInterface* bertini = new G4CascadeInterface;
  bertini->SetMaxEnergy(22*MeV);

  // here come the high energy parts
  G4VPartonStringModel* theStringModel;
  theStringModel = new G4FTFModel;
  theTheoModel->SetTransport(theCascade);
  theTheoModel->SetHighEnergyGenerator(theStringModel);
  theTheoModel->SetMinEnergy(19*GeV);
  theTheoModel->SetMaxEnergy(100*TeV);

  G4VLongitudinalStringDecay* theFragmentation = new G4QGSMFragmentation;
  G4ExcitedStringDecay* theStringDecay = 
                         new G4ExcitedStringDecay(theFragmentation);
  theStringModel->SetFragmentationModel(theStringDecay);

  // high energy model for anti-baryons
  antiBHighEnergyModel = new G4TheoFSGenerator("ANTI-FTFP");
  G4FTFModel* antiBStringModel = new G4FTFModel;
  G4ExcitedStringDecay* stringDecay = 
                    new G4ExcitedStringDecay(new G4LundStringFragmentation);
  antiBStringModel->SetFragmentationModel(stringDecay);

  G4GeneratorPrecompoundInterface* antiBCascade = 
                               new G4GeneratorPrecompoundInterface;
  G4PreCompoundModel* preEquilib = 
                  new G4PreCompoundModel(new G4ExcitationHandler);
  antiBCascade->SetDeExcitation(preEquilib);

  antiBHighEnergyModel->SetTransport(antiBCascade);
  antiBHighEnergyModel->SetHighEnergyGenerator(antiBStringModel);
  antiBHighEnergyModel->SetMinEnergy(0.0);
  antiBHighEnergyModel->SetMaxEnergy(20*TeV);

  // Light ion models
  G4BinaryLightIonReaction* binaryCascade = new G4BinaryLightIonReaction;
  binaryCascade->SetMinEnergy(0.0);
  binaryCascade->SetMaxEnergy(110*MeV);

  G4QMDReaction* qmd = new G4QMDReaction;
  qmd->SetMinEnergy(100*MeV);
  qmd->SetMaxEnergy(10*GeV);

  G4IonsShenCrossSection* shenXS = new G4IonsShenCrossSection;
  G4TripathiCrossSection* tripXS = new G4TripathiCrossSection;
  G4TripathiLightCrossSection* tripLightXS = new G4TripathiLightCrossSection;

  // Elastic process
  G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
  G4HadronElastic* theElasticModel = new G4HadronElastic;
  theElasticProcess->RegisterMe(theElasticModel);

  auto particleIterator=GetParticleIterator();
  particleIterator->reset();
  while ((*particleIterator)()) {
    G4ParticleDefinition* particle = particleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    G4String particleName = particle->GetParticleName();
     
    if (particleName == "pi+") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4PionPlusInelasticProcess* theInelasticProcess = 
                                new G4PionPlusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
    } else if (particleName == "pi-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4PionMinusInelasticProcess* theInelasticProcess = 
                                new G4PionMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
    } else if (particleName == "kaon+") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4KaonPlusInelasticProcess* theInelasticProcess = 
                                  new G4KaonPlusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "kaon0S") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4KaonZeroSInelasticProcess* theInelasticProcess = 
                             new G4KaonZeroSInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "kaon0L") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4KaonZeroLInelasticProcess* theInelasticProcess = 
                             new G4KaonZeroLInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "kaon-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4KaonMinusInelasticProcess* theInelasticProcess = 
                                 new G4KaonMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "proton") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4ProtonInelasticProcess* theInelasticProcess = 
                                    new G4ProtonInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_proton") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiProtonInelasticProcess* theInelasticProcess = 
                                new G4AntiProtonInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);

    } else if (particleName == "neutron") {         
      // elastic scattering
      pmanager->AddDiscreteProcess(theElasticProcess);

      // inelastic scattering
      G4NeutronInelasticProcess* theInelasticProcess = 
                                    new G4NeutronInelasticProcess("inelastic");
      theInelasticProcess->RegisterMe(bertini);
      theInelasticProcess->RegisterMe(theTheoModel);
      pmanager->AddDiscreteProcess(theInelasticProcess);

      // fission
      G4HadronFissionProcess* theFissionProcess = new G4HadronFissionProcess;
      G4LFission* theFissionModel = new G4LFission;
      theFissionProcess->RegisterMe(theFissionModel);
      pmanager->AddDiscreteProcess(theFissionProcess);

      // capture
      G4HadronCaptureProcess* theCaptureProcess = new G4HadronCaptureProcess;
      G4NeutronRadCapture* theCaptureModel = new G4NeutronRadCapture;
      theCaptureProcess->RegisterMe(theCaptureModel);
      pmanager->AddDiscreteProcess(theCaptureProcess);

    } else if (particleName == "anti_neutron") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiNeutronInelasticProcess* theInelasticProcess = 
                               new G4AntiNeutronInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);

    } else if (particleName == "lambda") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4LambdaInelasticProcess* theInelasticProcess = 
                                    new G4LambdaInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_lambda") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiLambdaInelasticProcess* theInelasticProcess = 
                                new G4AntiLambdaInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "sigma+") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4SigmaPlusInelasticProcess* theInelasticProcess = 
                                 new G4SigmaPlusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "sigma-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4SigmaMinusInelasticProcess* theInelasticProcess = 
                                 new G4SigmaMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_sigma+") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiSigmaPlusInelasticProcess* theInelasticProcess = 
                             new G4AntiSigmaPlusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_sigma-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiSigmaMinusInelasticProcess* theInelasticProcess = 
                            new G4AntiSigmaMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "xi0") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4XiZeroInelasticProcess* theInelasticProcess = 
                            new G4XiZeroInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "xi-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4XiMinusInelasticProcess* theInelasticProcess = 
                            new G4XiMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(bertini);
         theInelasticProcess->RegisterMe(theTheoModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_xi0") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiXiZeroInelasticProcess* theInelasticProcess = 
                            new G4AntiXiZeroInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "anti_xi-") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AntiXiMinusInelasticProcess* theInelasticProcess = 
                            new G4AntiXiMinusInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(antiBHighEnergyModel);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "deuteron") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4DeuteronInelasticProcess* theInelasticProcess = 
                            new G4DeuteronInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(binaryCascade);
         theInelasticProcess->RegisterMe(qmd);
         theInelasticProcess->AddDataSet(shenXS);
         theInelasticProcess->AddDataSet(tripXS);
         theInelasticProcess->AddDataSet(tripLightXS);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "triton") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4TritonInelasticProcess* theInelasticProcess = 
                            new G4TritonInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(binaryCascade);
         theInelasticProcess->RegisterMe(qmd);
         theInelasticProcess->AddDataSet(shenXS);
         theInelasticProcess->AddDataSet(tripXS);
         theInelasticProcess->AddDataSet(tripLightXS);
         pmanager->AddDiscreteProcess(theInelasticProcess);
      }
      else if (particleName == "alpha") {
         pmanager->AddDiscreteProcess(theElasticProcess);
         G4AlphaInelasticProcess* theInelasticProcess = 
                            new G4AlphaInelasticProcess("inelastic");
         theInelasticProcess->RegisterMe(binaryCascade);
         theInelasticProcess->RegisterMe(qmd);
         theInelasticProcess->AddDataSet(shenXS);
         theInelasticProcess->AddDataSet(tripXS);
         theInelasticProcess->AddDataSet(tripLightXS);
         pmanager->AddDiscreteProcess(theInelasticProcess);

    } else if (particleName == "omega-") {
      pmanager->AddDiscreteProcess(theElasticProcess);
      G4OmegaMinusInelasticProcess* theInelasticProcess = 
                            new G4OmegaMinusInelasticProcess("inelastic");
      theInelasticProcess->RegisterMe(bertini);
      theInelasticProcess->RegisterMe(theTheoModel);
      pmanager->AddDiscreteProcess(theInelasticProcess);

    } else if (particleName == "anti_omega-") {
      pmanager->AddDiscreteProcess(theElasticProcess);
      G4AntiOmegaMinusInelasticProcess* theInelasticProcess = 
                            new G4AntiOmegaMinusInelasticProcess("inelastic");
      theInelasticProcess->RegisterMe(antiBHighEnergyModel);
      pmanager->AddDiscreteProcess(theInelasticProcess);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void B03PhysicsList::ConstructLeptHad ( )

protectedvirtual

Definition at line 595 of file B03PhysicsList.cc.

{;}

Here is the caller graph for this function:

void B03PhysicsList::ConstructParticle ( void  )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 71 of file B03PhysicsList.cc.

{
  // In this method, static member functions should be called
  // for all particles which you want to use.
  // This ensures that objects of these particle types will be
  // created in the program. 

  ConstructAllBosons();
  ConstructAllLeptons();
  ConstructAllMesons();
  ConstructAllBaryons();
  ConstructAllIons();
  ConstructAllShortLiveds();
}

Here is the call graph for this function:

void B03PhysicsList::ConstructProcess ( void  )

protectedvirtual

Implements G4VUserPhysicsList.

Definition at line 142 of file B03PhysicsList.cc.

{
  AddTransportation();
  AddScoringProcess();
  AddBiasingProcess();
  ConstructEM();
  ConstructLeptHad();
  ConstructHad();
  ConstructGeneral();
}

Here is the call graph for this function:

void B03PhysicsList::SetCuts ( )

protectedvirtual

Reimplemented from G4VUserPhysicsList.

Definition at line 619 of file B03PhysicsList.cc.

{
  if (verboseLevel >0)
  {
    G4cout << "B03PhysicsList::SetCuts:";
    G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
  }  
  //   "G4VUserPhysicsList::SetCutsWithDefault" method sets 
  //   the default cut value for all particle types 
  SetCutsWithDefault();   
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p02/examples/extended/biasing/B03/include/B03PhysicsList.hh
• source/geant4.10.03.p02/examples/extended/biasing/B03/src/B03PhysicsList.cc