BgsPhysicsList Class Reference

#include <BgsPhysicsList.hh>

Inheritance diagram for BgsPhysicsList:

Public Member Functions
	BgsPhysicsList ()
virtual	~BgsPhysicsList ()
void	SetCuts ()
void	SetStatusEmProcess ()
	BgsPhysicsList ()
virtual	~BgsPhysicsList ()
void	SetCuts ()
void	SetStatusEmProcess ()
	BgsPhysicsList ()
virtual	~BgsPhysicsList ()
void	SetCuts ()
void	SetStatusEmProcess ()

Protected Member Functions
void	ConstructParticle ()
void	ConstructProcess ()
void	ConstructBosons ()
void	ConstructLeptons ()
void	ConstructMesons ()
void	ConstructBaryons ()
void	ConstructIons ()
void	ConstructGeneral ()
void	ConstructEM ()
void	ConstructLeptHad ()
void	ConstructHad ()
void	ConstructNeutrinoGenocide ()
void	ConstructIonFix ()
void	ConstructNeutronFix ()
void	ConstructParticle ()
void	ConstructProcess ()
void	ConstructBosons ()
void	ConstructLeptons ()
void	ConstructMesons ()
void	ConstructBaryons ()
void	ConstructIons ()
void	ConstructGeneral ()
void	ConstructEM ()
void	ConstructLeptHad ()
void	ConstructHad ()
void	ConstructNeutrinoGenocide ()
void	ConstructIonFix ()
void	ConstructNeutronFix ()
void	ConstructParticle ()
void	ConstructProcess ()
void	ConstructBosons ()
void	ConstructLeptons ()
void	ConstructMesons ()
void	ConstructBaryons ()
void	ConstructIons ()
void	ConstructGeneral ()
void	ConstructEM ()
void	ConstructLeptHad ()
void	ConstructHad ()
void	ConstructNeutrinoGenocide ()
void	ConstructIonFix ()
void	ConstructNeutronFix ()

Detailed Description

Definition at line 54 of file InstallArea/x86_64-el9-gcc13-dbg/include/PhySim/BgsPhysicsList.hh.

Constructor & Destructor Documentation

BgsPhysicsList() [1/3]

BgsPhysicsList::BgsPhysicsList

(

)

Definition at line 131 of file BgsPhysicsList.cc.

    : G4VUserPhysicsList()
    , // bes
    //    control(theControl),
    //    first(true),
    first( false ) // bes
//    physicsRegistrar(pr),
//    theLooperDeath(0)         // looperdeath process
{
  SetVerboseLevel( 2 );
  bertini_model = new G4CascadeInterface;
}

~BgsPhysicsList() [1/3]

BgsPhysicsList::~BgsPhysicsList ( )

virtual

Definition at line 144 of file BgsPhysicsList.cc.

                                {
  //  delete theLooperDeath;
}

BgsPhysicsList() [2/3]

BgsPhysicsList::BgsPhysicsList

(

)

~BgsPhysicsList() [2/3]

virtual BgsPhysicsList::~BgsPhysicsList ( )

virtual

BgsPhysicsList() [3/3]

BgsPhysicsList::BgsPhysicsList

(

)

~BgsPhysicsList() [3/3]

virtual BgsPhysicsList::~BgsPhysicsList ( )

virtual

Member Function Documentation

ConstructBaryons() [1/3]

void BgsPhysicsList::ConstructBaryons ( )

protected

Definition at line 239 of file BgsPhysicsList.cc.

                                      {
  //  baryons
  G4Proton ::ProtonDefinition();
  G4AntiProton ::AntiProtonDefinition();
  G4Neutron ::NeutronDefinition();
  G4AntiNeutron ::AntiNeutronDefinition();
  G4Lambda ::LambdaDefinition();
  G4AntiLambda ::AntiLambdaDefinition();
  G4SigmaPlus ::SigmaPlusDefinition();
  G4SigmaZero ::SigmaZeroDefinition();
  G4SigmaMinus ::SigmaMinusDefinition();
  G4AntiSigmaPlus ::AntiSigmaPlusDefinition();
  G4AntiSigmaZero ::AntiSigmaZeroDefinition();
  G4AntiSigmaMinus::AntiSigmaMinusDefinition();
  G4XiZero ::XiZeroDefinition();
  G4XiMinus ::XiMinusDefinition();
  G4AntiXiZero ::AntiXiZeroDefinition();
  G4AntiXiMinus ::AntiXiMinusDefinition();
  G4OmegaMinus ::OmegaMinusDefinition();
  G4AntiOmegaMinus::AntiOmegaMinusDefinition();
  G4Deuteron ::DeuteronDefinition();
  G4Triton ::TritonDefinition();
  G4He3 ::He3Definition();
  G4Alpha ::AlphaDefinition();
}

Referenced by ConstructParticle().

ConstructBaryons() [2/3]

void BgsPhysicsList::ConstructBaryons ( )

protected

ConstructBaryons() [3/3]

void BgsPhysicsList::ConstructBaryons ( )

protected

ConstructBosons() [1/3]

void BgsPhysicsList::ConstructBosons ( )

protected

Definition at line 194 of file BgsPhysicsList.cc.

                                     {
  // pseudo-particles
  G4Geantino::GeantinoDefinition();
  G4ChargedGeantino::ChargedGeantinoDefinition();
 
  // gamma
  G4Gamma::GammaDefinition();
 
  // optical photon
  G4OpticalPhoton::OpticalPhotonDefinition();
}

Referenced by ConstructParticle().

ConstructBosons() [2/3]

void BgsPhysicsList::ConstructBosons ( )

protected

ConstructBosons() [3/3]

void BgsPhysicsList::ConstructBosons ( )

protected

ConstructEM() [1/3]

void BgsPhysicsList::ConstructEM ( )

protected

Definition at line 361 of file BgsPhysicsList.cc.

                                 {
  /* theParticleIterator->reset();
   while( (*theParticleIterator)() ){
     G4ParticleDefinition* particle = theParticleIterator->value();
     G4ProcessManager* pmanager = particle->GetProcessManager();
     G4String particleName = particle->GetParticleName();
 
     if (particleName == "gamma") {
       // gamma
       // Construct processes for gamma
 
       pmanager->AddDiscreteProcess( new G4PhotoElectricEffect());
       pmanager->AddDiscreteProcess( new G4ComptonScattering());
       pmanager->AddDiscreteProcess( new G4GammaConversion());
 
     } else if (particleName == "e-") {
       //electron
       // Construct processes for electron
       //change for geant4.9.0.p01
       //G4MultipleScattering* ms = new G4MultipleScattering();
       ms->MscStepLimitation(false,0.02);
       ms->SetRangeFactor(0.02);
 
       //      ms->SetLateralDisplasmentFlag(false);
 
       G4eIonisation *ionizationProcess = new G4eIonisation();
       //      ionizationProcess->SetLinearLossLimit(1.0);
 
       pmanager->AddProcess( ms,                      -1, 1,1);
       pmanager->AddProcess( ionizationProcess,       -1, 2,2);
       pmanager->AddProcess( new G4eBremsstrahlung(), -1,-1,3);
 
     } else if (particleName == "e+") {
       //positron
       // Construct processes for positron
 
       //change for geant4.9.p01
       G4MultipleScattering* ms = new G4MultipleScattering();
       //ms->MscStepLimitation(false,0.02);
       ms->SetRangeFactor(0.02);
 
       //      ms->SetLateralDisplasmentFlag(false);
 
       G4eIonisation *ionizationProcess = new G4eIonisation();
       //      ionizationProcess->SetLinearLossLimit(1.0);
 
       pmanager->AddProcess( ms,                        -1, 1,1);
       pmanager->AddProcess( ionizationProcess,         -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+
 
       //change for geant4.9.0.p01
       G4MultipleScattering* ms = new G4MultipleScattering();
       //ms->MscStepLimitation(false,0.02);
       ms->SetRangeFactor(0.02);
 
      //      ms->SetLateralDisplasmentFlag(false);
 
       G4MuIonisation *ionizationProcess = new G4MuIonisation();
       //      ionizationProcess->SetLinearLossLimit(1.0);
 
       pmanager->AddProcess( ms,                       -1, 1,1);
       pmanager->AddProcess( ionizationProcess,        -1, 2,2);
       pmanager->AddProcess( new G4MuBremsstrahlung(), -1,-1,3);
       pmanager->AddProcess( new G4MuPairProduction(), -1,-1,4);
 
     } else if ((!particle->IsShortLived()) &&
                (particle->GetPDGCharge() != 0.0) &&
                (particle->GetParticleName() != "chargedgeantino")) {
       // all others charged particles except geantino
       G4int AP=1;
       if (particle->GetParticleName() == "GenericIon") {
         //ostream& o = ErrMsg(warning);
               std::cerr
   <<"*********************************************************************" <<std::endl;
               std::cerr << "*** Disabling G4MultipleScattering process for particle "
   <<particle->GetParticleName() << std::endl; std::cerr
   <<"*********************************************************************" <<std::endl; }
   else {
   //change for Geant4.9.0.p01
         G4MultipleScattering* ms = new G4MultipleScattering();
   //ms->MscStepLimitation(false,0.02);
   ms->SetRangeFactor(0.02);
 
         //         ms->SetLateralDisplasmentFlag(false);
         pmanager->AddProcess( ms, -1,AP,AP);
         AP++;
       }
       G4hIonisation *ionizationProcess = new G4hIonisation();
       //      ionizationProcess->SetLinearLossLimit(1.0);
 
       pmanager->AddProcess( ionizationProcess, -1,AP,AP);
     }
   }*/
}

ConstructEM() [2/3]

void BgsPhysicsList::ConstructEM ( )

protected

ConstructEM() [3/3]

void BgsPhysicsList::ConstructEM ( )

protected

ConstructGeneral() [1/3]

void BgsPhysicsList::ConstructGeneral ( )

protected

Definition at line 519 of file BgsPhysicsList.cc.

                                      {
  /*  // Add Decay Process
    G4Decay* theDecayProcess = new G4Decay();
    theParticleIterator->reset();
    while( (*theParticleIterator)() ){
      G4ParticleDefinition* particle = theParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      if (theDecayProcess->IsApplicable(*particle)) {
        pmanager ->AddProcess( theDecayProcess );
        // set ordering for PostStepDoIt and AtRestDoIt
        pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
        pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
  //      physicsRegistrar->
  //    Register( theDecayProcess, pmanager, "dcay", GVertex::decay );
      }
    }*/
  /*
    if (control->GetLooperCut()>0) {
 
      // Set special process to kill loopers
      theLooperDeath = new BgsLooperDeath( control->GetLooperCut()*MeV );
      theParticleIterator->reset();
      while( (*theParticleIterator)() ){
        G4ParticleDefinition* particle = theParticleIterator->value();
        if (theLooperDeath->IsApplicable(*particle)) {
          G4ProcessManager* pmanager = particle->GetProcessManager();
          pmanager->AddProcess(theLooperDeath, -1, -1, 5);
          physicsRegistrar->
            Register( theLooperDeath, pmanager, "loop", GVertex::looperDeath
  );
        }
      }
      ErrMsg(warning) << "Loopers with pt < " << control->GetLooperCut()
                      << " MeV will be killed" << endmsg;
    }
 
    if (control->GetMaxNumberOfSteps()>0) {
 
      //
      // Set special process to kill runaway particles
      // Only needed if dE/dx is turned off!
      //
      // Do not abuse!
      //
      theStepDeath = new BgsChargedStepDeath( control->GetMaxNumberOfSteps()
  );
 
      theParticleIterator->reset();
      while( (*theParticleIterator)() ){
        G4ParticleDefinition* particle = theParticleIterator->value();
        if (theStepDeath->IsApplicable(*particle)) {
          G4ProcessManager* pmanager = particle->GetProcessManager();
          pmanager->AddProcess(theStepDeath, -1, -1, 5);
          physicsRegistrar->
            Register( theStepDeath, pmanager, "maxStep", GVertex::runAway );
        }
      }
      ErrMsg(warning)
        << "\n  Charged particles will be killed if they take more than "
        << control->GetMaxNumberOfSteps() << " steps.\n"
        << "  If you do not understand this message, you should be very
  concerned.\n"
        << "  If this message appears in production, you should be very
  upset." << endmsg;
    }
   */
}

ConstructGeneral() [2/3]

void BgsPhysicsList::ConstructGeneral ( )

protected

ConstructGeneral() [3/3]

void BgsPhysicsList::ConstructGeneral ( )

protected

ConstructHad() [1/3]

void BgsPhysicsList::ConstructHad ( )

protected

Definition at line 686 of file BgsPhysicsList.cc.

                                  {
  // One process handles hadronic elastic processes for all hadrons.
  // However hadronic inelastic processes are unique to each hadron.
 
  // For pi+ and pi- only, substitute pi-Nuclear cross sections
  /*  G4PiNuclearCrossSection* piNucCS = new G4PiNuclearCrossSection();
 
    theParticleIterator->reset();
    while( (*theParticleIterator)() ){
      G4ParticleDefinition* particle = theParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      G4String particleName = particle->GetParticleName();
      // *******
      // * pi+ *
      // *******
      if (particleName == "pi+") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4PionPlusInelasticProcess *inel_process = new
  G4PionPlusInelasticProcess();
        inel_process->AddDataSet(piNucCS);
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * pi- *
      // *******
      } else if (particleName == "pi-") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4PionMinusInelasticProcess *inel_process = new
  G4PionMinusInelasticProcess();
        inel_process->AddDataSet(piNucCS);
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * K+  *
      // *******
      } else if (particleName == "kaon+") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4KaonPlusInelasticProcess* inel_process = new
  G4KaonPlusInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * K-  *
      // *******
      } else if (particleName == "kaon-") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4KaonMinusInelasticProcess* inel_process = new
  G4KaonMinusInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * K0L *
      // *******
      } else if (particleName == "kaon0L") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4KaonZeroLInelasticProcess* inel_process = new
  G4KaonZeroLInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * K0S *
      // *******
      } else if (particleName == "kaon0S") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4KaonZeroSInelasticProcess* inel_process =
        new G4KaonZeroSInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * p   *
      // *******
      } else if (particleName == "proton") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4ProtonInelasticProcess *inel_process = new
  G4ProtonInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *********
      // * p-bar *
      // *********
      } else if (particleName == "anti_proton") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4AntiProtonInelasticProcess *inel_process =
           new G4AntiProtonInelasticProcess();
        G4LEAntiProtonInelastic *inel_model = new G4LEAntiProtonInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // *******
      // * n   *
      // *******
      } else if (particleName == "neutron") {
 
        //if (control->UseHPNeutrons()) {
        if(1){
          G4cout << "High precision neutron models chosen" << G4endl;
 
          putenv("G4NEUTRONHPDATA=/afs/ihep.ac.cn/bes3/offline/sw/packages/geant4/4.9.0/slc4_ia32_gcc346/geant4.9.0.p01/data/G4NDL3.11/");
 
          // Elastic process
          G4HadronElasticProcess* el_process = new G4HadronElasticProcess();
 
          // High precision model and data below 20 MeV
          G4NeutronHPElastic* hpel_model = new G4NeutronHPElastic();
          G4NeutronHPElasticData* el_data = new G4NeutronHPElasticData();
          el_process->AddDataSet(el_data);
          el_process->RegisterMe(hpel_model);
 
          // LEP model above 20 MeV
          G4LElastic* el_model = new G4LElastic();
          el_model->SetMinEnergy(19.9*MeV);
          el_process->RegisterMe(el_model);
 
          pmanager->AddDiscreteProcess(el_process);
          //physicsRegistrar->Register(el_process,pmanager,"hade",
          //                         GVertex::hadronElastic);
 
          // Inelastic process
          G4NeutronInelasticProcess* inel_process =
                                         new G4NeutronInelasticProcess();
 
          // High precision model and data below 20 MeV
          G4NeutronHPInelastic* hpinel_model = new G4NeutronHPInelastic();
          G4NeutronHPInelasticData* hpinel_data = new
  G4NeutronHPInelasticData();
          inel_process->AddDataSet(hpinel_data);
          inel_process->RegisterMe(hpinel_model);
 
          // Bertini model above 20 MeV
          G4CascadeInterface* neutron_bertini = new G4CascadeInterface;
          neutron_bertini->SetMinEnergy(19.9*MeV);
          inel_process->RegisterMe(neutron_bertini);
 
          pmanager->AddDiscreteProcess(inel_process);
          //physicsRegistrar->Register(inel_process,pmanager,"hadi",
          //                         GVertex::hadronInelastic);
 
          // Capture process
          G4HadronCaptureProcess* cap_process = new G4HadronCaptureProcess();
 
          // High precision model and data below 20 MeV
          G4NeutronHPCapture* hpcap_model = new G4NeutronHPCapture();
          G4NeutronHPCaptureData* hpcap_data = new G4NeutronHPCaptureData();
          cap_process->AddDataSet(hpcap_data);
          cap_process->RegisterMe(hpcap_model);
 
          // LEP model above 20 MeV - default cross sections are used here
          // hence no need to explicitly invoke AddDataSet method
          G4LCapture* cap_model = new G4LCapture();
          cap_model->SetMinEnergy(19.9*MeV);
          cap_process->RegisterMe(cap_model);
 
          pmanager->AddDiscreteProcess(cap_process);
          // Note: need to update GVertex to include hadronCapture
  //       physicsRegistrar->Register(cap_process,pmanager,"hadi",
  //                                 GVertex::hadronInelastic);
 
          // Fission process
          G4HadronFissionProcess* fis_process = new G4HadronFissionProcess();
 
          // High precision model and data below 20 MeV
          G4NeutronHPFission* hpfis_model = new G4NeutronHPFission();
          G4NeutronHPFissionData* hpfis_data = new G4NeutronHPFissionData();
          fis_process->AddDataSet(hpfis_data);
          fis_process->RegisterMe(hpfis_model);
 
          // LEP model above 20 MeV - default cross sections are used here
          // hence no need to explicitly invoke AddDataSet method
          G4LFission* fis_model = new G4LFission();
          fis_model->SetMinEnergy(19.9*MeV);
          fis_process->RegisterMe(fis_model);
 
          pmanager->AddDiscreteProcess(fis_process);
          // Note: need to update GVertex to include hadronFission
  //        physicsRegistrar->Register(fis_process,pmanager,"hadi",
  //                                 GVertex::hadronInelastic);
 
        } else {
 
          // Elastic process
          G4HadronElasticProcess *process = new G4HadronElasticProcess();
          G4LElastic *model =  new G4LElastic();
          process->RegisterMe(model);
          pmanager->AddDiscreteProcess(process);
 
          // Inelastic process
          G4NeutronInelasticProcess *inel_process =
                                       new G4NeutronInelasticProcess();
          inel_process->RegisterMe(bertini_model);
          pmanager->AddDiscreteProcess(inel_process);
  //        physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                                 GVertex::hadronInelastic);
        }
      // *********
      // * n-bar *
      // *********
      } else if (particleName == "anti_neutron") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4AntiNeutronInelasticProcess *inel_process =
           new G4AntiNeutronInelasticProcess();
        G4LEAntiNeutronInelastic *inel_model = new G4LEAntiNeutronInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // **********
      // * lambda *
      // **********
      } else if (particleName == "lambda") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4LambdaInelasticProcess* inel_process = new
  G4LambdaInelasticProcess();
        inel_process->RegisterMe(bertini_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // **************
      // * lambda-bar *
      // **************
      } else if (particleName == "anti_lambda") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4AntiLambdaInelasticProcess *inel_process =
           new G4AntiLambdaInelasticProcess();
        G4LEAntiLambdaInelastic *inel_model = new G4LEAntiLambdaInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // **************
      // * deuteron   *
      // **************
      } else if (particleName == "deuteron") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4DeuteronInelasticProcess *inel_process =
           new G4DeuteronInelasticProcess();
        G4LEDeuteronInelastic *inel_model = new G4LEDeuteronInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // **************
      // * triton     *
      // **************
      } else if (particleName == "triton") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4TritonInelasticProcess *inel_process =
           new G4TritonInelasticProcess();
        G4LETritonInelastic *inel_model = new G4LETritonInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      // **************
      // * alpha      *
      // **************
      } else if (particleName == "alpha") {
 
        // Elastic process
        G4HadronElasticProcess *process = new G4HadronElasticProcess();
        G4LElastic *model =  new G4LElastic();
        process->RegisterMe(model);
        pmanager->AddDiscreteProcess(process);
 
        // Inelastic process
 
        G4AlphaInelasticProcess *inel_process = new G4AlphaInelasticProcess();
        G4LEAlphaInelastic *inel_model = new G4LEAlphaInelastic();
        inel_process->RegisterMe(inel_model);
        pmanager->AddDiscreteProcess(inel_process);
  //      physicsRegistrar->Register(inel_process,pmanager,"hadi",
  //                               GVertex::hadronInelastic);
      }
    }  // while */
}

ConstructHad() [2/3]

void BgsPhysicsList::ConstructHad ( )

protected

ConstructHad() [3/3]

void BgsPhysicsList::ConstructHad ( )

protected

ConstructIonFix() [1/3]

void BgsPhysicsList::ConstructIonFix ( )

protected

Definition at line 1114 of file BgsPhysicsList.cc.

                                     { /*
                                          BgsGenocide *genocide = new
                                        //BgsGentleGenocide(control->GetIonEnergyCut()*MeV,
                                        //                                              60);
                                          BgsGentleGenocide(0.01*MeV,
                                                                                      60);
 
                                          theParticleIterator->reset();
                                          while( (*theParticleIterator)() ){
                                            G4ParticleDefinition* particle =
                                        theParticleIterator->value(); G4ProcessManager*
                                        pmanager = particle->GetProcessManager(); G4String
                                        particleName = particle->GetParticleName();
 
                                            if ( particleName == "triton" ||
                                                 particleName == "alpha"  ||
                                                 particleName == "proton" ||
                                                 particleName == "deuteron"  ) {
 
                                                pmanager->AddProcess(genocide, -1, -1, 5);
                                        //        physicsRegistrar->Register( genocide,
                                        pmanager, "ionFix",
                                        // GVertex::minimumEnergy );
                                            }
                                          }*/
}

ConstructIonFix() [2/3]

void BgsPhysicsList::ConstructIonFix ( )

protected

ConstructIonFix() [3/3]

void BgsPhysicsList::ConstructIonFix ( )

protected

ConstructIons() [1/3]

void BgsPhysicsList::ConstructIons ( )

protected

Definition at line 265 of file BgsPhysicsList.cc.

{ G4GenericIon::GenericIonDefinition(); }

Referenced by ConstructParticle().

ConstructIons() [2/3]

void BgsPhysicsList::ConstructIons ( )

protected

ConstructIons() [3/3]

void BgsPhysicsList::ConstructIons ( )

protected

ConstructLeptHad() [1/3]

void BgsPhysicsList::ConstructLeptHad ( )

protected

Definition at line 589 of file BgsPhysicsList.cc.

                                      {
  //
  // Gamma-nuclear process
  //
 
  // low energy part
  /* G4GammaNuclearReaction* lowEGammaModel = new G4GammaNuclearReaction();
   lowEGammaModel->SetMaxEnergy(3.5*GeV);
   G4PhotoNuclearProcess* thePhotoNuclearProcess = new
 G4PhotoNuclearProcess();
   thePhotoNuclearProcess->RegisterMe(lowEGammaModel);
   */
  // bias the cross section
  //
  /*  double thePhotoNuclearBias = control->GetPhotoNuclearBias();
    if (thePhotoNuclearBias != 1.) {
      thePhotoNuclearProcess->BiasCrossSectionByFactor(thePhotoNuclearBias);
 
    // print out a warning if biasing
    //
      ErrMsg(warning) << "*** Biasing the photo-nuclear process by factor "
                      << thePhotoNuclearBias << endmsg;
    }
  */
  // high energy part
  /*G4TheoFSGenerator* highEGammaModel = new G4TheoFSGenerator();
  G4GeneratorPrecompoundInterface* preComModel =
                         new G4GeneratorPrecompoundInterface();
  highEGammaModel->SetTransport(preComModel);
 
  G4QGSModel<G4GammaParticipants>* theStringModel =
                         new G4QGSModel<G4GammaParticipants>;
  G4QGSMFragmentation* fragModel = new G4QGSMFragmentation();
  G4ExcitedStringDecay* stringDecay =
                            new G4ExcitedStringDecay(fragModel);
  theStringModel->SetFragmentationModel(stringDecay);
 
  highEGammaModel->SetHighEnergyGenerator(theStringModel);
  highEGammaModel->SetMinEnergy(3.*GeV);
  highEGammaModel->SetMaxEnergy(20.*GeV);
 
  thePhotoNuclearProcess->RegisterMe(highEGammaModel);
 
  G4ProcessManager* gamMan = G4Gamma::Gamma()->GetProcessManager();
 
  gamMan->AddDiscreteProcess(thePhotoNuclearProcess);
  //
  // Electron-nuclear process
  //
  G4ElectroNuclearReaction* theElectronReaction =
                                   new G4ElectroNuclearReaction();
  G4ElectronNuclearProcess* theElectronNuclearProcess =
                                   new G4ElectronNuclearProcess();
  theElectronNuclearProcess->RegisterMe(theElectronReaction);
 
  G4ProcessManager* electronMan =
G4Electron::Electron()->GetProcessManager();
 
  electronMan->AddProcess(theElectronNuclearProcess, -1, -1, 4);
*/
  // bias the cross section
  //
  /*
    G4double theElectroNuclearBias = control->GetElectroNuclearBias();
    if (theElectroNuclearBias != 1.) {
 
  theElectronNuclearProcess->BiasCrossSectionByFactor(theElectroNuclearBias);
 
    // print out a warning if biasing
    //
      ErrMsg(warning) << "*** Biasing the electron-nuclear process by factor "
                      << theElectroNuclearBias << endmsg;
    }
  */
  //
  // Positron-nuclear process
  //
  /*G4PositronNuclearProcess* thePositronNuclearProcess =
                                   new G4PositronNuclearProcess();
  thePositronNuclearProcess->RegisterMe(theElectronReaction);
 
  G4ProcessManager* positronMan =
G4Positron::Positron()->GetProcessManager();
  positronMan->AddProcess(thePositronNuclearProcess, -1, -1, 5);
*/
  // bias the cross section
  //
  /*
    if (theElectroNuclearBias != 1.) {
 
  thePositronNuclearProcess->BiasCrossSectionByFactor(theElectroNuclearBias);
      ErrMsg(warning) << "*** Biasing the positron-nuclear process by factor "
                      << theElectroNuclearBias << endmsg;
    }
    */
}

ConstructLeptHad() [2/3]

void BgsPhysicsList::ConstructLeptHad ( )

protected

ConstructLeptHad() [3/3]

void BgsPhysicsList::ConstructLeptHad ( )

protected

ConstructLeptons() [1/3]

void BgsPhysicsList::ConstructLeptons ( )

protected

Definition at line 206 of file BgsPhysicsList.cc.

                                      {
  // leptons
  G4Electron::ElectronDefinition();
  G4Positron::PositronDefinition();
  G4MuonPlus::MuonPlusDefinition();
  G4MuonMinus::MuonMinusDefinition();
  G4TauPlus::TauPlusDefinition();
  G4TauMinus::TauMinusDefinition();
 
  G4NeutrinoE::NeutrinoEDefinition();
  G4AntiNeutrinoE::AntiNeutrinoEDefinition();
  G4NeutrinoMu::NeutrinoMuDefinition();
  G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
  G4NeutrinoTau::NeutrinoTauDefinition();
  G4AntiNeutrinoTau::AntiNeutrinoTauDefinition();
}

Referenced by ConstructParticle().

ConstructLeptons() [2/3]

void BgsPhysicsList::ConstructLeptons ( )

protected

ConstructLeptons() [3/3]

void BgsPhysicsList::ConstructLeptons ( )

protected

ConstructMesons() [1/3]

void BgsPhysicsList::ConstructMesons ( )

protected

Definition at line 223 of file BgsPhysicsList.cc.

                                     {
  //  mesons
  G4PionPlus ::PionPlusDefinition();
  G4PionMinus ::PionMinusDefinition();
  G4PionZero ::PionZeroDefinition();
  G4Eta ::EtaDefinition();
  G4EtaPrime ::EtaPrimeDefinition();
  //  G4RhoZero      ::RhoZeroDefinition();
  G4KaonPlus ::KaonPlusDefinition();
  G4KaonMinus ::KaonMinusDefinition();
  G4KaonZero ::KaonZeroDefinition();
  G4AntiKaonZero ::AntiKaonZeroDefinition();
  G4KaonZeroLong ::KaonZeroLongDefinition();
  G4KaonZeroShort::KaonZeroShortDefinition();
}

Referenced by ConstructParticle().

ConstructMesons() [2/3]

void BgsPhysicsList::ConstructMesons ( )

protected

ConstructMesons() [3/3]

void BgsPhysicsList::ConstructMesons ( )

protected

ConstructNeutrinoGenocide() [1/3]

void BgsPhysicsList::ConstructNeutrinoGenocide ( )

protected

Definition at line 1083 of file BgsPhysicsList.cc.

                                               {
  /*  BgsGenocide *genocide = new BgsGenocide();
 
    theParticleIterator->reset();
    while( (*theParticleIterator)() ){
      G4ParticleDefinition* particle = theParticleIterator->value();
      G4ProcessManager* pmanager = particle->GetProcessManager();
      G4String particleName = particle->GetParticleName();
 
      if (particleName == "nu_e"   ||
          particleName == "nu_mu"  ||
          particleName == "nu_tau" ||
          particleName == "anti_nu_e"   ||
          particleName == "anti_nu_mu"  ||
          particleName == "anti_nu_tau" ||
 
          // temporary fix for K0, K0bar until CHIPS photonuclear model isfixed
 
          particleName == "kaon0"  ||
          particleName == "anti_kaon0"    ) {
 
          pmanager->AddProcess(genocide, -1, -1, 5);
  //        physicsRegistrar->Register( genocide, pmanager, "neutrinoDeath",
  //                                  GVertex::neutrino );
      }
    }*/
}

ConstructNeutrinoGenocide() [2/3]

void BgsPhysicsList::ConstructNeutrinoGenocide ( )

protected

ConstructNeutrinoGenocide() [3/3]

void BgsPhysicsList::ConstructNeutrinoGenocide ( )

protected

ConstructNeutronFix() [1/3]

void BgsPhysicsList::ConstructNeutronFix ( )

protected

Definition at line 1144 of file BgsPhysicsList.cc.

                                         { /*
                                              BgsGenocide *genocide = new
                                            BgsGentleGenocide(0.01*MeV,0);
 
                                              theParticleIterator->reset();
                                              while( (*theParticleIterator)() ){
                                                G4ParticleDefinition* particle =
                                            theParticleIterator->value(); G4ProcessManager*
                                            pmanager = particle->GetProcessManager(); G4String
                                            particleName = particle->GetParticleName();
 
                                                if ( particleName == "neutron"  ) {
 
                                                    pmanager->AddProcess(genocide, -1, -1, 1);
                                            //        physicsRegistrar->Register( genocide,
                                            pmanager, "neutronFix",
                                            // GVertex::minimumEnergy );
                                                }
                                              }*/
}

ConstructNeutronFix() [2/3]

void BgsPhysicsList::ConstructNeutronFix ( )

protected

ConstructNeutronFix() [3/3]

void BgsPhysicsList::ConstructNeutronFix ( )

protected

ConstructParticle() [1/3]

void BgsPhysicsList::ConstructParticle ( )

protected

Definition at line 148 of file BgsPhysicsList.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.
 
  ConstructBosons();
  ConstructLeptons();
  ConstructMesons();
  ConstructBaryons();
  ConstructIons();
  /*
    if (first) {
      first = false;
 
      //
      // Check to make sure our particles have valid PDG encodings
      //
      BgsPDGEncode encode(false);
 
      G4ParticleTable *table = G4ParticleTable::GetParticleTable();
 
      G4int nProb = 0;
      G4int n = table->entries();
      while(n--) {
        G4ParticleDefinition *part = table->GetParticle(n);
        if (encode.pdt(part) == 0) {
          nProb++;
          std::cerr << "The Geant4 particle \""
                        << part->GetParticleName()
                        << "\" is not recognized by BgsPDGEncode" << std::endl;
        }
      }
 
      if(nProb > 0) std::cerr << "One or more PDG encoding errors" <<
  std::endl;
    }
  */
  // Add short lived particles for high energy models,
  // but don't check PDG codes - they are not propagated in Bogus anyway
 
  G4ShortLivedConstructor shortLived;
  shortLived.ConstructParticle();
}

ConstructParticle() [2/3]

void BgsPhysicsList::ConstructParticle ( )

protected

ConstructParticle() [3/3]

void BgsPhysicsList::ConstructParticle ( )

protected

ConstructProcess() [1/3]

void BgsPhysicsList::ConstructProcess ( )

protected

Definition at line 267 of file BgsPhysicsList.cc.

                                      {
  // if (control->UseBgsTran()) {
  /*  if(0) {
      AddBgsTransportation(control->GetMaxTrackingStepSize(),
                           control->GetMaxVacStepSize(),
                           control->GetVacName());
      std::cout << "+^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^+ " <<
              std::endl;
      std::cout << "+v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v+ " <<
              std::endl;
      std::cout << " +---                                                  ---+ " <<
              std::endl;
      std::cout << " +---                 BgsTransportation                ---+ " <<
        std::endl;
      std::cout << " +---                      USED !!                     ---+ " <<
        std::endl;
      std::cout << " +---                                                  ---+ " <<
        std::endl;
      std::cout << "+^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^+ " <<
        std::endl;
      std::cout << "+v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v+ " <<
        std::endl;
 
    }
    else {
    */
  /*
  AddTransportation();
   std::cout << "+^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^+ " <<
     std::endl;
   std::cout << "+v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v+ " <<
     std::endl;
   std::cout << " +---                                                  ---+ " <<
     std::endl;
   std::cout << " +---                 G4Transportation                 ---+ " <<
     std::endl;
   std::cout << " +---                      USED !!                     ---+ " <<
     std::endl;
   std::cout << " +---                                                  ---+ " <<
     std::endl;
   std::cout << "+^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^+ " <<
     std::endl;
   std::cout << "+v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v^v+ " <<
     std::endl;
//  }
 //  AddParameterisation();
 ConstructEM();
 ConstructLeptHad();
 ConstructHad();
 ConstructGeneral();
 ConstructNeutrinoGenocide();
 ConstructIonFix();
 ConstructNeutronFix();*/
}

ConstructProcess() [2/3]

void BgsPhysicsList::ConstructProcess ( )

protected

ConstructProcess() [3/3]

void BgsPhysicsList::ConstructProcess ( )

protected

SetCuts() [1/3]

void BgsPhysicsList::SetCuts

(

)

Definition at line 1167 of file BgsPhysicsList.cc.

                             { /*
                                  // Set default cuts, all volumes
 
                                  SetDefaultCutValue(0.7*mm);
                                  SetCutsWithDefault();
                                */
  // Enable print out of cuts after tables are built
  // This is now done in BgsRunAction
  //
  //    if (verboseLevel > 1) DumpCutValuesTable();
}

SetCuts() [2/3]

void BgsPhysicsList::SetCuts

(

)

SetCuts() [3/3]

void BgsPhysicsList::SetCuts

(

)

SetStatusEmProcess() [1/3]

void BgsPhysicsList::SetStatusEmProcess

(

)

Definition at line 500 of file BgsPhysicsList.cc.

{}

SetStatusEmProcess() [2/3]

void BgsPhysicsList::SetStatusEmProcess

(

)

SetStatusEmProcess() [3/3]

void BgsPhysicsList::SetStatusEmProcess

(

)

---

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

• InstallArea/x86_64-el9-gcc13-dbg/include/PhySim/BgsPhysicsList.hh
• InstallArea/x86_64-el9-gcc13-opt/include/PhySim/BgsPhysicsList.hh
• Simulation/BOOST/PhySim/include/PhySim/BgsPhysicsList.hh
• BgsPhysicsList.cc