10.00/html/_d_m_x_physics_list_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 //

 // --------------------------------------------------------------

 //   GEANT 4 - Underground Dark Matter Detector Advanced Example

 //

 //      For information related to this code contact: Alex Howard

 //      e-mail: alexander.howard@cern.ch

 // --------------------------------------------------------------

 // Comments

 //

 //                  Underground Advanced

 //               by A. Howard and H. Araujo

 //                    (27th November 2001)

 //

 // PhysicsList program

 //

 // Modified:

 //

 // 14-02-03 Fix bugs in msc and hIon instanciation + cut per region

 //

 // 05-02-05 AH - changes to G4Decay - added is not short lived protection

 //          and redefined particles to allow non-static creation

 //          i.e. changed construction to G4MesonConstructor, G4BaryonConstructor

 //

 // 23-10-09 LP - migrated EM physics from the LowEnergy processes (not supported) to

 //          the new G4Livermore model implementation. Results unchanged.

 //

 // --------------------------------------------------------------


 #include <iomanip>


 #include "DMXPhysicsList.hh"


 #include "globals.hh"

 #include "G4SystemOfUnits.hh"

 #include "G4ProcessManager.hh"

 #include "G4ProcessVector.hh"


 #include "G4ParticleDefinition.hh"

 #include "G4ParticleWithCuts.hh"

 #include "G4ParticleTypes.hh"

 #include "G4ParticleTable.hh"


 #include "G4ios.hh"

 #include "G4UserLimits.hh"


 // Constructor /////////////////////////////////////////////////////////////

 DMXPhysicsList::DMXPhysicsList() : G4VUserPhysicsList()

 {


   defaultCutValue     = 1.0*micrometer; //

   cutForGamma         = defaultCutValue;

   cutForElectron      = 1.0*nanometer;

   cutForPositron      = defaultCutValue;


   VerboseLevel = 1;

   OpVerbLevel = 0;


   SetVerboseLevel(VerboseLevel);

 }


 // Destructor //////////////////////////////////////////////////////////////

 DMXPhysicsList::~DMXPhysicsList()

 {;}


 // Construct Particles /////////////////////////////////////////////////////

 void DMXPhysicsList::ConstructParticle()

 {


   // 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.


   ConstructMyBosons();

   ConstructMyLeptons();

   ConstructMyHadrons();

   ConstructMyShortLiveds();


 }


 // construct Bosons://///////////////////////////////////////////////////

 void DMXPhysicsList::ConstructMyBosons()

 {

   // pseudo-particles

   G4Geantino::GeantinoDefinition();

   G4ChargedGeantino::ChargedGeantinoDefinition();


   // gamma

   G4Gamma::GammaDefinition();


   //OpticalPhotons

   G4OpticalPhoton::OpticalPhotonDefinition();


 }


 // construct Leptons://///////////////////////////////////////////////////

 void DMXPhysicsList::ConstructMyLeptons()

 {

   // leptons

   G4Electron::ElectronDefinition();

   G4Positron::PositronDefinition();

   G4MuonPlus::MuonPlusDefinition();

   G4MuonMinus::MuonMinusDefinition();


   G4NeutrinoE::NeutrinoEDefinition();

   G4AntiNeutrinoE::AntiNeutrinoEDefinition();

   G4NeutrinoMu::NeutrinoMuDefinition();

   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();

 }


 #include "G4MesonConstructor.hh"

 #include "G4BaryonConstructor.hh"

 #include "G4IonConstructor.hh"


 // construct Hadrons://///////////////////////////////////////////////////

 void DMXPhysicsList::ConstructMyHadrons()

 {

  //  mesons

   G4MesonConstructor mConstructor;

   mConstructor.ConstructParticle();


  //  baryons

   G4BaryonConstructor bConstructor;

   bConstructor.ConstructParticle();


  //  ions

   G4IonConstructor iConstructor;

   iConstructor.ConstructParticle();


 }


 // construct Shortliveds://///////////////////////////////////////////////////

 void DMXPhysicsList::ConstructMyShortLiveds()

 {

   // ShortLiveds

   ;

 }


 // Construct Processes //////////////////////////////////////////////////////

 void DMXPhysicsList::ConstructProcess()

 {


   AddTransportation();


   ConstructEM();


   ConstructOp();


   ConstructHad();


   ConstructGeneral();


 }


 // Transportation ///////////////////////////////////////////////////////////

 #include "DMXMaxTimeCuts.hh"

 #include "DMXMinEkineCuts.hh"

 #include "G4StepLimiter.hh"


 void DMXPhysicsList::AddTransportation() {


   G4VUserPhysicsList::AddTransportation();


   theParticleIterator->reset();

   while( (*theParticleIterator)() ){

     G4ParticleDefinition* particle = theParticleIterator->value();

     G4ProcessManager* pmanager = particle->GetProcessManager();

     G4String particleName = particle->GetParticleName();

     // time cuts for ONLY neutrons:

     if(particleName == "neutron")

       pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());

     // Energy cuts to kill charged (embedded in method) particles:

     pmanager->AddDiscreteProcess(new DMXMinEkineCuts());


     // Step limit applied to all particles:

     pmanager->AddProcess(new G4StepLimiter,       -1,-1,1);


   }

 }


 // Electromagnetic Processes ////////////////////////////////////////////////

 // all charged particles


 // gamma

 #include "G4PhotoElectricEffect.hh"

 #include "G4LivermorePhotoElectricModel.hh"


 #include "G4ComptonScattering.hh"

 #include "G4LivermoreComptonModel.hh"


 #include "G4GammaConversion.hh"

 #include "G4LivermoreGammaConversionModel.hh"


 #include "G4RayleighScattering.hh"

 #include "G4LivermoreRayleighModel.hh"


 // e-

 #include "G4eMultipleScattering.hh"


 #include "G4eIonisation.hh"

 #include "G4LivermoreIonisationModel.hh"


 #include "G4eBremsstrahlung.hh"

 #include "G4LivermoreBremsstrahlungModel.hh"


 // e+

 #include "G4eIonisation.hh"

 #include "G4eBremsstrahlung.hh"

 #include "G4eplusAnnihilation.hh"


 // alpha and GenericIon and deuterons, triton, He3:


 //muon:

 #include "G4MuIonisation.hh"

 #include "G4MuBremsstrahlung.hh"

 #include "G4MuPairProduction.hh"

 #include "G4MuonMinusCaptureAtRest.hh"


 //OTHERS:

 #include "G4hIonisation.hh"

 #include "G4hMultipleScattering.hh"

 #include "G4hBremsstrahlung.hh"

 #include "G4ionIonisation.hh"

 #include "G4IonParametrisedLossModel.hh"


 //em process options to allow msc step-limitation to be switched off

 #include "G4EmProcessOptions.hh"


 void DMXPhysicsList::ConstructEM() {


   //set a finer grid of the physic tables in order to improve precision

   //former LowEnergy models have 200 bins up to 100 GeV

   G4EmProcessOptions opt;

   opt.SetMaxEnergy(100*GeV);

   opt.SetDEDXBinning(200);

   opt.SetLambdaBinning(200);


   theParticleIterator->reset();

   while( (*theParticleIterator)() ){

     G4ParticleDefinition* particle = theParticleIterator->value();

     G4ProcessManager* pmanager = particle->GetProcessManager();

     G4String particleName = particle->GetParticleName();

     G4String particleType = particle->GetParticleType();

     G4double charge = particle->GetPDGCharge();


     if (particleName == "gamma")

       {

     //gamma

     G4RayleighScattering* theRayleigh = new G4RayleighScattering();

     theRayleigh->SetEmModel(new G4LivermoreRayleighModel());  //not strictly necessary

     pmanager->AddDiscreteProcess(theRayleigh);


     G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();

     thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());

     pmanager->AddDiscreteProcess(thePhotoElectricEffect);


     G4ComptonScattering* theComptonScattering = new G4ComptonScattering();

     theComptonScattering->SetEmModel(new G4LivermoreComptonModel());

     pmanager->AddDiscreteProcess(theComptonScattering);


     G4GammaConversion* theGammaConversion = new G4GammaConversion();

     theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());

     pmanager->AddDiscreteProcess(theGammaConversion);


       }

     else if (particleName == "e-")

       {

     //electron

     // process ordering: AddProcess(name, at rest, along step, post step)

     // Multiple scattering

     G4eMultipleScattering* msc = new G4eMultipleScattering();

     msc->SetStepLimitType(fUseDistanceToBoundary);

     pmanager->AddProcess(msc,-1, 1, 1);


     // Ionisation

     G4eIonisation* eIonisation = new G4eIonisation();

     eIonisation->SetEmModel(new G4LivermoreIonisationModel());

     eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking

     pmanager->AddProcess(eIonisation,-1, 2, 2);


     // Bremsstrahlung

     G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();

     eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());

     pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);

       }

     else if (particleName == "e+")

       {

     //positron

     G4eMultipleScattering* msc = new G4eMultipleScattering();

     msc->SetStepLimitType(fUseDistanceToBoundary);

     pmanager->AddProcess(msc,-1, 1, 1);


     // Ionisation

     G4eIonisation* eIonisation = new G4eIonisation();

     eIonisation->SetStepFunction(0.2, 100*um); //

     pmanager->AddProcess(eIonisation,                 -1, 2, 2);


     //Bremsstrahlung (use default, no low-energy available)

     pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);


     //Annihilation

     pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);

       }

     else if( particleName == "mu+" ||

          particleName == "mu-"    )

       {

     //muon

     pmanager->AddProcess(new G4eMultipleScattering,           -1, 1, 1);

     pmanager->AddProcess(new G4MuIonisation(),          -1, 2, 2);

     pmanager->AddProcess(new G4MuBremsstrahlung(),      -1,-1, 3);

     pmanager->AddProcess(new G4MuPairProduction(),      -1,-1, 4);

     if( particleName == "mu-" )

       pmanager->AddProcess(new G4MuonMinusCaptureAtRest(), 0,-1,-1);

       }

     else if (particleName == "proton" ||

          particleName == "pi+" ||

          particleName == "pi-")

       {

     //multiple scattering

     pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);


     //ionisation

     G4hIonisation* hIonisation = new G4hIonisation();

     hIonisation->SetStepFunction(0.2, 50*um);

     pmanager->AddProcess(hIonisation,                     -1, 2, 2);


     //bremmstrahlung

     pmanager->AddProcess(new G4hBremsstrahlung,     -1,-3, 3);

       }

     else if(particleName == "alpha"      ||

          particleName == "deuteron"   ||

          particleName == "triton"     ||

          particleName == "He3")

       {

     //multiple scattering

     pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);


     //ionisation

     G4ionIonisation* ionIoni = new G4ionIonisation();

     ionIoni->SetStepFunction(0.1, 20*um);

     pmanager->AddProcess(ionIoni,                   -1, 2, 2);

       }

     else if (particleName == "GenericIon")

       {

     // OBJECT may be dynamically created as either a GenericIon or nucleus

     // G4Nucleus exists and therefore has particle type nucleus

     // genericIon:


     //multiple scattering

     pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);


     //ionisation

     G4ionIonisation* ionIoni = new G4ionIonisation();

     ionIoni->SetEmModel(new G4IonParametrisedLossModel());

     ionIoni->SetStepFunction(0.1, 20*um);

     pmanager->AddProcess(ionIoni,                   -1, 2, 2);

       }


     else if ((!particle->IsShortLived()) &&

          (charge != 0.0) &&

          (particle->GetParticleName() != "chargedgeantino"))

       {

     //all others charged particles except geantino

         G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();

         G4hIonisation* ahadronIon = new G4hIonisation();


     //multiple scattering

     pmanager->AddProcess(aMultipleScattering,-1,1,1);


     //ionisation

     pmanager->AddProcess(ahadronIon,       -1,2,2);

       }


   }


   // turn off msc step-limitation - especially as electron cut 1nm

   opt.SetMscStepLimitation(fMinimal);


   // switch on fluorescence, PIXE and Auger:

   opt.SetFluo(true);

   opt.SetPIXE(true);

   opt.SetAuger(true);


 }


 // Optical Processes ////////////////////////////////////////////////////////

 #include "G4Scintillation.hh"

 #include "G4OpAbsorption.hh"

 //#include "G4OpRayleigh.hh"

 #include "G4OpBoundaryProcess.hh"


 void DMXPhysicsList::ConstructOp()

 {

   // default scintillation process

   G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");

   // theScintProcessDef->DumpPhysicsTable();

   theScintProcessDef->SetTrackSecondariesFirst(true);

   theScintProcessDef->SetScintillationYieldFactor(1.0); //

   theScintProcessDef->SetScintillationExcitationRatio(0.0); //

   theScintProcessDef->SetVerboseLevel(OpVerbLevel);


   // scintillation process for alpha:

   G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");

   // theScintProcessNuc->DumpPhysicsTable();

   theScintProcessAlpha->SetTrackSecondariesFirst(true);

   theScintProcessAlpha->SetScintillationYieldFactor(1.1);

   theScintProcessAlpha->SetScintillationExcitationRatio(1.0);

   theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);


   // scintillation process for heavy nuclei

   G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");

   // theScintProcessNuc->DumpPhysicsTable();

   theScintProcessNuc->SetTrackSecondariesFirst(true);

   theScintProcessNuc->SetScintillationYieldFactor(0.2);

   theScintProcessNuc->SetScintillationExcitationRatio(1.0);

   theScintProcessNuc->SetVerboseLevel(OpVerbLevel);


   // optical processes

   G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();

   //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();

   G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();

   //  theAbsorptionProcess->DumpPhysicsTable();

   //  theRayleighScatteringProcess->DumpPhysicsTable();

   theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);

   // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);

   theBoundaryProcess->SetVerboseLevel(OpVerbLevel);


   theParticleIterator->reset();

   while( (*theParticleIterator)() )

     {

       G4ParticleDefinition* particle = theParticleIterator->value();

       G4ProcessManager* pmanager = particle->GetProcessManager();

       G4String particleName = particle->GetParticleName();

       if (theScintProcessDef->IsApplicable(*particle)) {

     //      if(particle->GetPDGMass() > 5.0*GeV)

     if(particle->GetParticleName() == "GenericIon") {

       pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete

       pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);

       pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);

     }

     else if(particle->GetParticleName() == "alpha") {

       pmanager->AddProcess(theScintProcessAlpha);

       pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);

       pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);

     }

     else {

       pmanager->AddProcess(theScintProcessDef);

       pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);

       pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);

     }

       }


       if (particleName == "opticalphoton") {

     pmanager->AddDiscreteProcess(theAbsorptionProcess);

     //  pmanager->AddDiscreteProcess(theRayleighScatteringProcess);

     pmanager->AddDiscreteProcess(theBoundaryProcess);

       }

     }

 }


 // Hadronic processes ////////////////////////////////////////////////////////


 // Elastic processes:

 #include "G4HadronElasticProcess.hh"

 #include "G4ChipsElasticModel.hh"

 #include "G4ElasticHadrNucleusHE.hh"


 // Inelastic processes:

 #include "G4PionPlusInelasticProcess.hh"

 #include "G4PionMinusInelasticProcess.hh"

 #include "G4KaonPlusInelasticProcess.hh"

 #include "G4KaonZeroSInelasticProcess.hh"

 #include "G4KaonZeroLInelasticProcess.hh"

 #include "G4KaonMinusInelasticProcess.hh"

 #include "G4ProtonInelasticProcess.hh"

 #include "G4AntiProtonInelasticProcess.hh"

 #include "G4NeutronInelasticProcess.hh"

 #include "G4AntiNeutronInelasticProcess.hh"

 #include "G4DeuteronInelasticProcess.hh"

 #include "G4TritonInelasticProcess.hh"

 #include "G4AlphaInelasticProcess.hh"


 // High energy FTFP model and Bertini cascade

 #include "G4FTFModel.hh"

 #include "G4LundStringFragmentation.hh"

 #include "G4ExcitedStringDecay.hh"

 #include "G4PreCompoundModel.hh"

 #include "G4GeneratorPrecompoundInterface.hh"

 #include "G4TheoFSGenerator.hh"

 #include "G4CascadeInterface.hh"


 // Cross sections

 #include "G4VCrossSectionDataSet.hh"

 #include "G4CrossSectionDataSetRegistry.hh"


 #include "G4CrossSectionElastic.hh"

 #include "G4BGGPionElasticXS.hh"

 #include "G4AntiNuclElastic.hh"


 #include "G4CrossSectionInelastic.hh"

 #include "G4PiNuclearCrossSection.hh"

 #include "G4CrossSectionPairGG.hh"

 #include "G4BGGNucleonInelasticXS.hh"

 #include "G4ComponentAntiNuclNuclearXS.hh"

 #include "G4GGNuclNuclCrossSection.hh"


 #include "G4HadronElastic.hh"

 #include "G4HadronCaptureProcess.hh"


 // Neutron high-precision models: <20 MeV

 #include "G4NeutronHPElastic.hh"

 #include "G4NeutronHPElasticData.hh"

 #include "G4NeutronHPCapture.hh"

 #include "G4NeutronHPCaptureData.hh"

 #include "G4NeutronHPInelastic.hh"

 #include "G4NeutronHPInelasticData.hh"


 // Stopping processes

 #include "G4PiMinusAbsorptionBertini.hh"

 #include "G4KaonMinusAbsorptionBertini.hh"

 #include "G4AntiProtonAbsorptionFritiof.hh"


 void DMXPhysicsList::ConstructHad()

 {

   //Elastic models

   const G4double elastic_elimitPi = 1.0*GeV;


   G4HadronElastic* elastic_lhep0 = new G4HadronElastic();

   G4HadronElastic* elastic_lhep1 = new G4HadronElastic();

   elastic_lhep1->SetMaxEnergy( elastic_elimitPi );

   G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();

   G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE();

   elastic_he->SetMinEnergy( elastic_elimitPi );


   // Inelastic scattering

   const G4double theFTFMin0 =    0.0*GeV;

   const G4double theFTFMin1 =    4.0*GeV;

   const G4double theFTFMax =   100.0*TeV;

   const G4double theBERTMin0 =   0.0*GeV;

   const G4double theBERTMin1 =  19.0*MeV;

   const G4double theBERTMax =    5.0*GeV;

   const G4double theHPMin =      0.0*GeV;

   const G4double theHPMax =     20.0*MeV;


   G4FTFModel * theStringModel = new G4FTFModel;

   G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );

   theStringModel->SetFragmentationModel( theStringDecay );

   G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );

   G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );


   G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );

   theFTFModel0->SetHighEnergyGenerator( theStringModel );

   theFTFModel0->SetTransport( theCascade );

   theFTFModel0->SetMinEnergy( theFTFMin0 );

   theFTFModel0->SetMaxEnergy( theFTFMax );


   G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );

   theFTFModel1->SetHighEnergyGenerator( theStringModel );

   theFTFModel1->SetTransport( theCascade );

   theFTFModel1->SetMinEnergy( theFTFMin1 );

   theFTFModel1->SetMaxEnergy( theFTFMax );


   G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;

   theBERTModel0->SetMinEnergy( theBERTMin0 );

   theBERTModel0->SetMaxEnergy( theBERTMax );


   G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;

   theBERTModel1->SetMinEnergy( theBERTMin1 );

   theBERTModel1->SetMaxEnergy( theBERTMax );


   G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );

   G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );

   G4VCrossSectionDataSet * theGGNuclNuclData = G4CrossSectionDataSetRegistry::Instance()->

     GetCrossSectionDataSet(G4GGNuclNuclCrossSection::Default_Name());


   theParticleIterator->reset();

   while ((*theParticleIterator)())

     {

       G4ParticleDefinition* particle = theParticleIterator->value();

       G4ProcessManager* pmanager = particle->GetProcessManager();

       G4String particleName = particle->GetParticleName();


       if (particleName == "pi+")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );

           theElasticProcess->RegisterMe( elastic_lhep1 );

           theElasticProcess->RegisterMe( elastic_he );

       pmanager->AddDiscreteProcess( theElasticProcess );

       //Inelastic scattering

       G4PionPlusInelasticProcess* theInelasticProcess =

         new G4PionPlusInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( thePiData );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "pi-")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );

           theElasticProcess->RegisterMe( elastic_lhep1 );

           theElasticProcess->RegisterMe( elastic_he );

       pmanager->AddDiscreteProcess( theElasticProcess );

       //Inelastic scattering

       G4PionMinusInelasticProcess* theInelasticProcess =

         new G4PionMinusInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( thePiData );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

       //Absorption

       pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);

     }


       else if (particleName == "kaon+")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4KaonPlusInelasticProcess* theInelasticProcess =

         new G4KaonPlusInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->

                        GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "kaon0S")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4KaonZeroSInelasticProcess* theInelasticProcess =

         new G4KaonZeroSInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->

                        GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "kaon0L")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

       // Inelastic scattering

       G4KaonZeroLInelasticProcess* theInelasticProcess =

         new G4KaonZeroLInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->

                        GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "kaon-")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4KaonMinusInelasticProcess* theInelasticProcess =

         new G4KaonMinusInelasticProcess("inelastic");

           theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->

                        GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

       pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);

     }


       else if (particleName == "proton")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->

                     GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));

           theElasticProcess->RegisterMe( elastic_chip );

       pmanager->AddDiscreteProcess( theElasticProcess );

       // Inelastic scattering

       G4ProtonInelasticProcess* theInelasticProcess =

         new G4ProtonInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }

       else if (particleName == "anti_proton")

     {

       // Elastic scattering

           const G4double elastic_elimitAntiNuc = 100.0*CLHEP::MeV;

           G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();

           elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );

           G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );

           G4HadronElastic* elastic_lhep2 = new G4HadronElastic();

           elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->AddDataSet( elastic_anucxs );

           theElasticProcess->RegisterMe( elastic_lhep2 );

           theElasticProcess->RegisterMe( elastic_anuc );

       pmanager->AddDiscreteProcess( theElasticProcess );

       // Inelastic scattering

       G4AntiProtonInelasticProcess* theInelasticProcess =

         new G4AntiProtonInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( theAntiNucleonData );

       theInelasticProcess->RegisterMe( theFTFModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

       // Absorption

       pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);

     }


       else if (particleName == "neutron") {

     // elastic scattering

     G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

         theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));

         G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();

     elastic_neutronChipsModel->SetMinEnergy( 19.0*CLHEP::MeV );

         theElasticProcess->RegisterMe( elastic_neutronChipsModel );

     G4NeutronHPElastic * theElasticNeutronHP = new G4NeutronHPElastic;

         theElasticNeutronHP->SetMinEnergy( theHPMin );

         theElasticNeutronHP->SetMaxEnergy( theHPMax );

     theElasticProcess->RegisterMe( theElasticNeutronHP );

     theElasticProcess->AddDataSet( new G4NeutronHPElasticData );

     pmanager->AddDiscreteProcess( theElasticProcess );

     // inelastic scattering

     G4NeutronInelasticProcess* theInelasticProcess =

       new G4NeutronInelasticProcess("inelastic");

     theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );

     theInelasticProcess->RegisterMe( theFTFModel1 );

         theInelasticProcess->RegisterMe( theBERTModel1 );

     G4NeutronHPInelastic * theNeutronInelasticHPModel = new G4NeutronHPInelastic;

         theNeutronInelasticHPModel->SetMinEnergy( theHPMin );

         theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );

     theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );

     theInelasticProcess->AddDataSet( new G4NeutronHPInelasticData );

     pmanager->AddDiscreteProcess(theInelasticProcess);

     // capture

     G4HadronCaptureProcess* theCaptureProcess =

       new G4HadronCaptureProcess;

     G4NeutronHPCapture * theLENeutronCaptureModel = new G4NeutronHPCapture;

     theLENeutronCaptureModel->SetMinEnergy(theHPMin);

     theLENeutronCaptureModel->SetMaxEnergy(theHPMax);

     theCaptureProcess->RegisterMe(theLENeutronCaptureModel);

     theCaptureProcess->AddDataSet( new G4NeutronHPCaptureData);

     pmanager->AddDiscreteProcess(theCaptureProcess);


       }

       else if (particleName == "anti_neutron")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering (include annihilation on-fly)

       G4AntiNeutronInelasticProcess* theInelasticProcess =

         new G4AntiNeutronInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( theAntiNucleonData );

       theInelasticProcess->RegisterMe( theFTFModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "deuteron")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4DeuteronInelasticProcess* theInelasticProcess =

         new G4DeuteronInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( theGGNuclNuclData );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


       else if (particleName == "triton")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4TritonInelasticProcess* theInelasticProcess =

         new G4TritonInelasticProcess("inelastic");

       theInelasticProcess->AddDataSet( theGGNuclNuclData );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }

       else if (particleName == "alpha")

     {

       // Elastic scattering

           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;

           theElasticProcess->RegisterMe( elastic_lhep0 );

       pmanager->AddDiscreteProcess( theElasticProcess );

           // Inelastic scattering

       G4AlphaInelasticProcess* theInelasticProcess =

         new G4AlphaInelasticProcess("inelastic");

           theInelasticProcess->AddDataSet( theGGNuclNuclData );

       theInelasticProcess->RegisterMe( theFTFModel1 );

           theInelasticProcess->RegisterMe( theBERTModel0 );

       pmanager->AddDiscreteProcess( theInelasticProcess );

     }


     }

 }


 // Decays ///////////////////////////////////////////////////////////////////

 #include "G4Decay.hh"

 #include "G4RadioactiveDecay.hh"

 #include "G4IonTable.hh"

 #include "G4Ions.hh"


 void DMXPhysicsList::ConstructGeneral() {


   // Add Decay Process

   G4Decay* theDecayProcess = new G4Decay();

   theParticleIterator->reset();

   while( (*theParticleIterator)() )

     {

       G4ParticleDefinition* particle = theParticleIterator->value();

       G4ProcessManager* pmanager = particle->GetProcessManager();


       if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived())

     {

       pmanager ->AddProcess(theDecayProcess);

       // set ordering for PostStepDoIt and AtRestDoIt

       pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);

       pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);

     }

     }


   // Declare radioactive decay to the GenericIon in the IonTable.

   const G4IonTable *theIonTable =

     G4ParticleTable::GetParticleTable()->GetIonTable();

   G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();


   for (G4int i=0; i<theIonTable->Entries(); i++)

     {

       G4String particleName = theIonTable->GetParticle(i)->GetParticleName();

       G4String particleType = theIonTable->GetParticle(i)->GetParticleType();


       if (particleName == "GenericIon")

     {

       G4ProcessManager* pmanager =

         theIonTable->GetParticle(i)->GetProcessManager();

       pmanager->SetVerboseLevel(VerboseLevel);

       pmanager ->AddProcess(theRadioactiveDecay);

       pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);

       pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);

     }

     }

 }


 // Cuts /////////////////////////////////////////////////////////////////////

 void DMXPhysicsList::SetCuts()

 {


   if (verboseLevel >1)

     G4cout << "DMXPhysicsList::SetCuts:";


   if (verboseLevel>0){

     G4cout << "DMXPhysicsList::SetCuts:";

     G4cout << "CutLength : "

        << G4BestUnit(defaultCutValue,"Length") << G4endl;

   }


   //special for low energy physics

   G4double lowlimit=250*eV;

   G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV);


   // set cut values for gamma at first and for e- second and next for e+,

   // because some processes for e+/e- need cut values for gamma

   SetCutValue(cutForGamma, "gamma");

   SetCutValue(cutForElectron, "e-");

   SetCutValue(cutForPositron, "e+");


   if (verboseLevel>0) DumpCutValuesTable();

 }


G4FTFModel
Definition: G4FTFModel.hh:63

G4hMultipleScattering.hh

G4IonTable
Definition: G4IonTable.hh:67

G4Geantino::GeantinoDefinition
static G4Geantino * GeantinoDefinition()
Definition: G4Geantino.cc:82

G4OpAbsorption
Definition: G4OpAbsorption.hh:74

G4Electron::ElectronDefinition
static G4Electron * ElectronDefinition()
Definition: G4Electron.cc:89

G4LivermoreBremsstrahlungModel
Definition: G4LivermoreBremsstrahlungModel.hh:61

G4eIonisation.hh

G4AntiProtonAbsorptionFritiof.hh

G4MesonConstructor.hh

G4ExcitedStringDecay
Definition: G4ExcitedStringDecay.hh:38

G4Scintillation
Definition: G4Scintillation.hh:88

G4MuonPlus::MuonPlusDefinition
static G4MuonPlus * MuonPlusDefinition()
Definition: G4MuonPlus.cc:94

python.hepunit.GeV
GeV
Definition: hepunit.py:120

G4NeutronHPInelastic.hh

G4IonParametrisedLossModel.hh

G4VUserPhysicsList::verboseLevel
G4int verboseLevel
Definition: G4VUserPhysicsList.hh:357

G4KaonZeroLInelasticProcess.hh

G4EmProcessOptions::SetPIXE
void SetPIXE(G4bool val)
Definition: G4EmProcessOptions.cc:280

G4IonTable::Entries
G4int Entries() const
Definition: G4IonTable.cc:1584

G4Scintillation.hh

G4PiNuclearCrossSection.hh

G4BGGPionElasticXS
Definition: G4BGGPionElasticXS.hh:64

G4VUserPhysicsList::SetCutValue
void SetCutValue(G4double aCut, const G4String &pname)
Definition: G4VUserPhysicsList.cc:419

G4PhotoElectricEffect
Definition: G4PhotoElectricEffect.hh:79

G4NeutronHPCaptureData
Definition: G4NeutronHPCaptureData.hh:49

G4BaryonConstructor.hh

G4ProductionCutsTable::SetEnergyRange
void SetEnergyRange(G4double lowedge, G4double highedge)
Definition: G4ProductionCutsTable.cc:329

G4BaryonConstructor
Definition: G4BaryonConstructor.hh:39

G4ElasticHadrNucleusHE
Definition: G4ElasticHadrNucleusHE.hh:108

G4HadronElasticProcess
Definition: G4HadronElasticProcess.hh:49

G4OpBoundaryProcess.hh

G4EmProcessOptions
Definition: G4EmProcessOptions.hh:63

G4ComptonScattering.hh

DMXPhysicsList::ConstructGeneral
virtual void ConstructGeneral()
Definition: DMXPhysicsList.cc:873

G4Decay::IsApplicable
virtual G4bool IsApplicable(const G4ParticleDefinition &)
Definition: G4Decay.cc:89

G4VPartonStringModel::SetFragmentationModel
void SetFragmentationModel(G4VStringFragmentation *aModel)
Definition: G4VPartonStringModel.hh:86

G4CrossSectionPairGG.hh

G4HadronElastic.hh

G4Scintillation::SetScintillationExcitationRatio
void SetScintillationExcitationRatio(const G4double excitationratio)
Definition: G4Scintillation.hh:307

G4hBremsstrahlung.hh

G4hIonisation.hh

G4MesonConstructor
Definition: G4MesonConstructor.hh:39

G4PiMinusAbsorptionBertini
Definition: G4PiMinusAbsorptionBertini.hh:39

python.hepunit.MeV
MeV
Definition: hepunit.py:117

G4TritonInelasticProcess
Definition: G4TritonInelasticProcess.hh:41

G4LivermoreIonisationModel.hh

G4MuonMinusCaptureAtRest
Definition: G4MuonMinusCaptureAtRest.hh:64

G4ProtonInelasticProcess.hh

G4VUserPhysicsList::defaultCutValue
G4double defaultCutValue
Definition: G4VUserPhysicsList.hh:361

G4MuPairProduction.hh

G4VEnergyLossProcess::SetStepFunction
void SetStepFunction(G4double v1, G4double v2)
Definition: G4VEnergyLossProcess.hh:995

G4ProcessManager::AddDiscreteProcess
G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord=ordDefault)

G4RadioactiveDecay
Definition: G4RadioactiveDecay.hh:82

G4eMultipleScattering.hh

DMXMinEkineCuts
Definition: DMXMinEkineCuts.hh:45

G4NeutronHPInelasticData
Definition: G4NeutronHPInelasticData.hh:49

G4KaonMinusAbsorptionBertini.hh

G4CascadeInterface
Definition: G4CascadeInterface.hh:86

G4ComptonScattering
Definition: G4ComptonScattering.hh:71

G4ProcessManager::SetVerboseLevel
void SetVerboseLevel(G4int value)

G4CrossSectionDataSetRegistry.hh

G4BGGNucleonInelasticXS
Definition: G4BGGNucleonInelasticXS.hh:64

G4Scintillation::IsApplicable
G4bool IsApplicable(const G4ParticleDefinition &aParticleType)
Definition: G4Scintillation.hh:262

G4MuonMinusCaptureAtRest.hh

G4PiNuclearCrossSection
Definition: G4PiNuclearCrossSection.hh:37

G4AlphaInelasticProcess.hh

fUseDistanceToBoundary
Definition: G4MscStepLimitType.hh:51

G4NeutronHPCaptureData.hh

G4Ions.hh

G4NeutronInelasticProcess.hh

G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53

G4BaryonConstructor::ConstructParticle
static void ConstructParticle()
Definition: G4BaryonConstructor.cc:102

G4IonConstructor.hh

G4MuIonisation.hh

G4ParticleDefinition
Definition: G4ParticleDefinition.hh:111

DMXMaxTimeCuts.hh

G4ChipsKaonPlusInelasticXS::Default_Name
static const char * Default_Name()
Definition: G4ChipsKaonPlusInelasticXS.hh:56

G4MuBremsstrahlung.hh

G4DeuteronInelasticProcess.hh

G4VCrossSectionDataSet
Definition: G4VCrossSectionDataSet.hh:70

G4LivermoreComptonModel.hh

G4MesonConstructor::ConstructParticle
static void ConstructParticle()
Definition: G4MesonConstructor.cc:80

G4GGNuclNuclCrossSection::Default_Name
static const char * Default_Name()
Definition: G4GGNuclNuclCrossSection.hh:57

G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const

G4int
int G4int
Definition: G4Types.hh:78

G4AntiNuclElastic::GetComponentCrossSection
G4ComponentAntiNuclNuclearXS * GetComponentCrossSection()
Definition: G4AntiNuclElastic.hh:125

G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:159

G4BGGNucleonInelasticXS.hh

G4KaonMinusAbsorptionBertini
Definition: G4KaonMinusAbsorptionBertini.hh:39

G4EmProcessOptions::SetFluo
void SetFluo(G4bool val)
Definition: G4EmProcessOptions.cc:264

G4IonTable.hh

G4HadronCaptureProcess
Definition: G4HadronCaptureProcess.hh:52

DMXPhysicsList::ConstructProcess
virtual void ConstructProcess()
Definition: DMXPhysicsList.cc:174

G4TheoFSGenerator::SetHighEnergyGenerator
void SetHighEnergyGenerator(G4VHighEnergyGenerator *const value)
Definition: G4TheoFSGenerator.hh:103

fMinimal
Definition: G4MscStepLimitType.hh:49

G4IonConstructor::ConstructParticle
static void ConstructParticle()
Definition: G4IonConstructor.cc:59

G4EmProcessOptions::SetAuger
void SetAuger(G4bool val)
Definition: G4EmProcessOptions.cc:272

G4TheoFSGenerator
Definition: G4TheoFSGenerator.hh:53

G4HadronicProcess::RegisterMe
void RegisterMe(G4HadronicInteraction *a)
Definition: G4HadronicProcess.cc:142

python.hepunit.nanometer
int nanometer
Definition: hepunit.py:35

G4LivermoreRayleighModel
Definition: G4LivermoreRayleighModel.hh:39

G4ionIonisation.hh

G4EmProcessOptions::SetDEDXBinning
void SetDEDXBinning(G4int val)
Definition: G4EmProcessOptions.cc:137

DMXPhysicsList::AddTransportation
virtual void AddTransportation()
Definition: DMXPhysicsList.cc:195

G4VCrossSectionDataSet.hh

G4Scintillation::SetScintillationYieldFactor
void SetScintillationYieldFactor(const G4double yieldfactor)
Definition: G4Scintillation.hh:295

G4ChipsKaonZeroInelasticXS::Default_Name
static const char * Default_Name()
Definition: G4ChipsKaonZeroInelasticXS.hh:59

G4HadronicInteraction::SetMinEnergy
void SetMinEnergy(G4double anEnergy)
Definition: G4HadronicInteraction.hh:90

G4ParticleTypes.hh

G4NeutronHPElasticData
Definition: G4NeutronHPElasticData.hh:49

G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEmProcess.cc:198

G4HadronicProcess::AddDataSet
void AddDataSet(G4VCrossSectionDataSet *aDataSet)
Definition: G4HadronicProcess.hh:117

G4PionPlusInelasticProcess
Definition: G4PionPlusInelasticProcess.hh:41

G4PreCompoundModel.hh

G4ParticleTable::GetIonTable
G4IonTable * GetIonTable() const
Definition: G4ParticleTable.cc:712

G4VUserPhysicsList::DumpCutValuesTable
void DumpCutValuesTable(G4int flag=1)
Definition: G4VUserPhysicsList.cc:805

G4TheoFSGenerator.hh

G4CrossSectionElastic.hh

G4NeutronHPElastic.hh

G4GGNuclNuclCrossSection.hh

G4cout
G4GLOB_DLL std::ostream G4cout

G4EmProcessOptions::SetLambdaBinning
void SetLambdaBinning(G4int val)
Definition: G4EmProcessOptions.cc:151

G4LivermoreIonisationModel
Definition: G4LivermoreIonisationModel.hh:58

G4DeuteronInelasticProcess
Definition: G4DeuteronInelasticProcess.hh:41

G4FTFModel.hh

G4GammaConversion
Definition: G4GammaConversion.hh:75

G4ParticleTable.hh

G4BGGPionElasticXS.hh

DMXPhysicsList::DMXPhysicsList
DMXPhysicsList()
Definition: DMXPhysicsList.cc:72

G4hBremsstrahlung
Definition: G4hBremsstrahlung.hh:61

G4GammaConversion.hh

G4PreCompoundModel
Definition: G4PreCompoundModel.hh:64

G4LundStringFragmentation
Definition: G4LundStringFragmentation.hh:42

idxPostStep
Definition: G4ProcessManager.hh:94

G4AntiNeutronInelasticProcess.hh

DMXMinEkineCuts.hh

G4VUserPhysicsList::SetVerboseLevel
void SetVerboseLevel(G4int value)
Definition: G4VUserPhysicsList.cc:966

G4ProcessManager::AddProcess
G4int AddProcess(G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)
Definition: G4ProcessManager.cc:410

G4NeutrinoE::NeutrinoEDefinition
static G4NeutrinoE * NeutrinoEDefinition()
Definition: G4NeutrinoE.cc:80

G4Decay
Definition: G4Decay.hh:63

G4ExcitationHandler
Definition: G4ExcitationHandler.hh:63

G4Decay.hh

G4CrossSectionInelastic
Definition: G4CrossSectionInelastic.hh:61

G4NeutronHPCapture
Definition: G4NeutronHPCapture.hh:47

G4ChipsNeutronElasticXS::Default_Name
static const char * Default_Name()
Definition: G4ChipsNeutronElasticXS.hh:55

G4IonParametrisedLossModel
Definition: G4IonParametrisedLossModel.hh:93

G4AntiNeutrinoMu::AntiNeutrinoMuDefinition
static G4AntiNeutrinoMu * AntiNeutrinoMuDefinition()
Definition: G4AntiNeutrinoMu.cc:80

G4CrossSectionDataSetRegistry::Instance
static G4CrossSectionDataSetRegistry * Instance()
Definition: G4CrossSectionDataSetRegistry.cc:77

G4LivermoreBremsstrahlungModel.hh

G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93

python.hepunit.eV
eV
Definition: hepunit.py:118

G4ParticleDefinition::GetParticleType
const G4String & GetParticleType() const
Definition: G4ParticleDefinition.hh:180

G4ExcitedStringDecay.hh

G4ProcessManager.hh

G4ParticleDefinition.hh

G4LivermoreComptonModel
Definition: G4LivermoreComptonModel.hh:48

G4AntiProtonInelasticProcess
Definition: G4AntiProtonInelasticProcess.hh:41

G4StepLimiter.hh

G4IonConstructor
Definition: G4IonConstructor.hh:39

G4Neutron::Neutron
static G4Neutron * Neutron()
Definition: G4Neutron.cc:104

G4StepLimiter
Definition: G4StepLimiter.hh:45

G4ProcessManager::SetProcessOrdering
void SetProcessOrdering(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt, G4int ordDoIt=ordDefault)
Definition: G4ProcessManager.cc:607

G4LundStringFragmentation.hh

G4PhotoElectricEffect.hh

DMXMaxTimeCuts
Definition: DMXMaxTimeCuts.hh:50

G4ionIonisation
Definition: G4ionIonisation.hh:78

G4MuBremsstrahlung
Definition: G4MuBremsstrahlung.hh:78

G4ProcessVector.hh

G4OpBoundaryProcess
Definition: G4OpBoundaryProcess.hh:131

globals.hh

G4LivermoreGammaConversionModel.hh

G4AntiNuclElastic
Definition: G4AntiNuclElastic.hh:49

G4AntiNuclElastic.hh

G4EmProcessOptions::SetMaxEnergy
void SetMaxEnergy(G4double val)
Definition: G4EmProcessOptions.cc:116

DMXPhysicsList::ConstructHad
virtual void ConstructHad()
Definition: DMXPhysicsList.cc:566

G4ParticleWithCuts.hh

G4ChipsKaonMinusInelasticXS::Default_Name
static const char * Default_Name()
Definition: G4ChipsKaonMinusInelasticXS.hh:55

G4MuIonisation
Definition: G4MuIonisation.hh:85

G4VUserPhysicsList
Definition: G4VUserPhysicsList.hh:159

G4AntiProtonInelasticProcess.hh

G4Positron::PositronDefinition
static G4Positron * PositronDefinition()
Definition: G4Positron.cc:89

G4LivermoreRayleighModel.hh

ordDefault
Definition: G4ProcessManager.hh:102

G4ParticleDefinition::IsShortLived
G4bool IsShortLived() const
Definition: G4ParticleDefinition.hh:196

G4ProductionCutsTable::GetProductionCutsTable
static G4ProductionCutsTable * GetProductionCutsTable()
Definition: G4ProductionCutsTable.cc:63

G4RayleighScattering.hh

DMXPhysicsList.hh

G4eBremsstrahlung
Definition: G4eBremsstrahlung.hh:81

G4PionMinusInelasticProcess.hh

G4PiMinusAbsorptionBertini.hh

DMXPhysicsList::SetCuts
virtual void SetCuts()
Definition: DMXPhysicsList.cc:915

G4ParticleTable::GetParticleTable
static G4ParticleTable * GetParticleTable()
Definition: G4ParticleTable.cc:95

G4eIonisation
Definition: G4eIonisation.hh:80

G4Scintillation::SetTrackSecondariesFirst
void SetTrackSecondariesFirst(const G4bool state)
Definition: G4Scintillation.hh:271

G4HadronElastic
Definition: G4HadronElastic.hh:50

G4KaonZeroSInelasticProcess
Definition: G4KaonZeroSInelasticProcess.hh:41

G4ProcessManager::SetProcessOrderingToLast
void SetProcessOrderingToLast(G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
Definition: G4ProcessManager.cc:849

G4eplusAnnihilation.hh

G4LivermorePhotoElectricModel
Definition: G4LivermorePhotoElectricModel.hh:50

G4PionPlusInelasticProcess.hh

G4NeutronHPElasticData.hh

G4VUserPhysicsList::AddTransportation
void AddTransportation()
Definition: G4VUserPhysicsList.cc:947

G4ios.hh

DMXPhysicsList::~DMXPhysicsList
~DMXPhysicsList()
Definition: DMXPhysicsList.cc:88

G4KaonZeroLInelasticProcess
Definition: G4KaonZeroLInelasticProcess.hh:41

G4KaonMinusInelasticProcess.hh

G4VEnergyLossProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEnergyLossProcess.cc:362

G4MuPairProduction
Definition: G4MuPairProduction.hh:74

G4NeutronInelasticProcess
Definition: G4NeutronInelasticProcess.hh:44

G4MuonMinus::MuonMinusDefinition
static G4MuonMinus * MuonMinusDefinition()
Definition: G4MuonMinus.cc:95

G4ChipsElasticModel
Definition: G4ChipsElasticModel.hh:53

DMXPhysicsList::ConstructOp
virtual void ConstructOp()
Definition: DMXPhysicsList.cc:432

G4GeneratorPrecompoundInterface.hh

G4KaonZeroSInelasticProcess.hh

G4CrossSectionPairGG
Definition: G4CrossSectionPairGG.hh:51

G4HadronicInteraction::SetMaxEnergy
void SetMaxEnergy(const G4double anEnergy)
Definition: G4HadronicInteraction.hh:103

G4AlphaInelasticProcess
Definition: G4AlphaInelasticProcess.hh:41

G4CrossSectionElastic
Definition: G4CrossSectionElastic.hh:61

G4ChargedGeantino::ChargedGeantinoDefinition
static G4ChargedGeantino * ChargedGeantinoDefinition()
Definition: G4ChargedGeantino.cc:82

G4ChipsProtonElasticXS::Default_Name
static const char * Default_Name()
Definition: G4ChipsProtonElasticXS.hh:53

G4TritonInelasticProcess.hh

G4eBremsstrahlung.hh

G4endl
#define G4endl
Definition: G4ios.hh:61

G4TheoFSGenerator::SetTransport
void SetTransport(G4VIntraNuclearTransportModel *const value)
Definition: G4TheoFSGenerator.hh:93

G4ProcessManager
Definition: G4ProcessManager.hh:106

G4eplusAnnihilation
Definition: G4eplusAnnihilation.hh:65

G4eMultipleScattering
Definition: G4eMultipleScattering.hh:60

G4RayleighScattering
Definition: G4RayleighScattering.hh:51

G4hMultipleScattering
Definition: G4hMultipleScattering.hh:62

G4KaonPlusInelasticProcess
Definition: G4KaonPlusInelasticProcess.hh:41

G4NeutronHPInelastic
Definition: G4NeutronHPInelastic.hh:86

G4ProtonInelasticProcess
Definition: G4ProtonInelasticProcess.hh:41

G4EmProcessOptions::SetMscStepLimitation
void SetMscStepLimitation(G4MscStepLimitType val)
Definition: G4EmProcessOptions.cc:305

G4OpAbsorption.hh

G4KaonPlusInelasticProcess.hh

G4ProcessManager::AddRestProcess
G4int AddRestProcess(G4VProcess *aProcess, G4int ord=ordDefault)

G4NeutronHPCapture.hh

G4AntiNeutrinoE::AntiNeutrinoEDefinition
static G4AntiNeutrinoE * AntiNeutrinoEDefinition()
Definition: G4AntiNeutrinoE.cc:80

G4AntiNeutronInelasticProcess
Definition: G4AntiNeutronInelasticProcess.hh:42

G4LivermoreGammaConversionModel
Definition: G4LivermoreGammaConversionModel.hh:41

G4OpticalPhoton::OpticalPhotonDefinition
static G4OpticalPhoton * OpticalPhotonDefinition()
Definition: G4OpticalPhoton.cc:82

G4ComponentAntiNuclNuclearXS.hh

G4AntiProtonAbsorptionFritiof
Definition: G4AntiProtonAbsorptionFritiof.hh:50

G4GeneratorPrecompoundInterface
Definition: G4GeneratorPrecompoundInterface.hh:60

G4double
double G4double
Definition: G4Types.hh:76

G4SystemOfUnits.hh

G4CrossSectionInelastic.hh

G4NeutronHPInelasticData.hh

G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163

G4NeutrinoMu::NeutrinoMuDefinition
static G4NeutrinoMu * NeutrinoMuDefinition()
Definition: G4NeutrinoMu.cc:80

G4NeutronHPElastic
Definition: G4NeutronHPElastic.hh:47

G4CascadeInterface.hh

python.hepunit.micrometer
int micrometer
Definition: hepunit.py:34

G4HadronElasticProcess.hh

G4UserLimits.hh

G4EmProcessOptions.hh

G4HadronCaptureProcess.hh

G4hIonisation
Definition: G4hIonisation.hh:85

theParticleIterator
#define theParticleIterator
Definition: G4VUserPhysicsList.hh:153

G4ComponentAntiNuclNuclearXS
Definition: G4ComponentAntiNuclNuclearXS.hh:57

DMXPhysicsList::ConstructParticle
virtual void ConstructParticle()
Definition: DMXPhysicsList.cc:93

G4ChipsElasticModel.hh

G4ElasticHadrNucleusHE.hh

G4VProcess::SetVerboseLevel
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:437

DMXPhysicsList::ConstructEM
virtual void ConstructEM()
Definition: DMXPhysicsList.cc:268

python.hepunit.TeV
TeV
Definition: hepunit.py:121

idxAtRest
Definition: G4ProcessManager.hh:92

G4VMultipleScattering::SetStepLimitType
void SetStepLimitType(G4MscStepLimitType val)
Definition: G4VMultipleScattering.hh:391

G4LivermorePhotoElectricModel.hh

G4RadioactiveDecay.hh

G4Gamma::GammaDefinition
static G4Gamma * GammaDefinition()
Definition: G4Gamma.cc:81

G4PionMinusInelasticProcess
Definition: G4PionMinusInelasticProcess.hh:41

G4String
Definition: G4String.hh:45

G4IonTable::GetParticle
G4ParticleDefinition * GetParticle(G4int index) const
Definition: G4IonTable.cc:1538

G4KaonMinusInelasticProcess
Definition: G4KaonMinusInelasticProcess.hh:41