PamG4/src/HadronPhysics.cc


#include "HadronPhysics.hh"

#include "globals.hh"
#include "G4ios.hh"


HadronPhysics::HadronPhysics(const G4String& name)
                    :  G4VPhysicsConstructor(name)
{
}

HadronPhysics::~HadronPhysics()
{
}

#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"

// Nuclei
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4ShortLivedConstructor.hh"

void HadronPhysics::ConstructParticle()
{
  //  Construct all mesons
  G4MesonConstructor pMesonConstructor;
  pMesonConstructor.ConstructParticle();

  //  Construct all barions
  G4BaryonConstructor pBaryonConstructor;
  pBaryonConstructor.ConstructParticle();

  //  Construct  resonaces and quarks
  G4ShortLivedConstructor pShortLivedConstructor;
  pShortLivedConstructor.ConstructParticle();  

}


#include "G4ProcessManager.hh"


void HadronPhysics::ConstructProcess()
{
  G4ProcessManager * pManager = 0;
  
  // Elastic Process
  theElasticModel = new G4LElastic();
  theElasticProcess.RegisterMe(theElasticModel);

  // PionPlus
  pManager = G4PionPlus::PionPlus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEPionPlusModel = new G4LEPionPlusInelastic();
  theHEPionPlusModel = new G4HEPionPlusInelastic();
  thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
  thePionPlusInelastic.RegisterMe(theHEPionPlusModel);
  pManager->AddDiscreteProcess(&thePionPlusInelastic);

  pManager->AddProcess(&thePionPlusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&thePionPlusMult);
  pManager->SetProcessOrdering(&thePionPlusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&thePionPlusMult, idxPostStep, 1);

  // PionMinus
  pManager = G4PionMinus::PionMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEPionMinusModel = new G4LEPionMinusInelastic();
  theHEPionMinusModel = new G4HEPionMinusInelastic();
  thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
  thePionMinusInelastic.RegisterMe(theHEPionMinusModel);
  pManager->AddDiscreteProcess(&thePionMinusInelastic);

  pManager->AddProcess(&thePionMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&thePionMinusMult);
  pManager->SetProcessOrdering(&thePionMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&thePionMinusMult, idxPostStep, 1);

  pManager->AddRestProcess(&thePionMinusAbsorption, ordDefault);

  // KaonPlus
  pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEKaonPlusModel = new G4LEKaonPlusInelastic();
  theHEKaonPlusModel = new G4HEKaonPlusInelastic();
  theKaonPlusInelastic.RegisterMe(theLEKaonPlusModel);
  theKaonPlusInelastic.RegisterMe(theHEKaonPlusModel);
  pManager->AddDiscreteProcess(&theKaonPlusInelastic);

  pManager->AddProcess(&theKaonPlusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theKaonPlusMult);
  pManager->SetProcessOrdering(&theKaonPlusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theKaonPlusMult, idxPostStep, 1);

  // KaonMinus
  pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEKaonMinusModel = new G4LEKaonMinusInelastic();
  theHEKaonMinusModel = new G4HEKaonMinusInelastic();
  theKaonMinusInelastic.RegisterMe(theLEKaonMinusModel);
  theKaonMinusInelastic.RegisterMe(theHEKaonMinusModel);
  pManager->AddDiscreteProcess(&theKaonMinusInelastic);

  pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theKaonMinusMult);
  pManager->SetProcessOrdering(&theKaonMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theKaonMinusMult, idxPostStep, 1);

  pManager->AddRestProcess(&theKaonMinusAbsorption, ordDefault);

  // KaonZeroL
  pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
  theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
  theKaonZeroLInelastic.RegisterMe(theLEKaonZeroLModel);
  theKaonZeroLInelastic.RegisterMe(theHEKaonZeroLModel);
  pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
 
  // KaonZeroS
  pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
  theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
  theKaonZeroSInelastic.RegisterMe(theLEKaonZeroSModel);
  theKaonZeroSInelastic.RegisterMe(theHEKaonZeroSModel);
  pManager->AddDiscreteProcess(&theKaonZeroSInelastic);

  // Proton
  pManager = G4Proton::Proton()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEProtonModel = new G4LEProtonInelastic();
  theHEProtonModel = new G4HEProtonInelastic();
  theProtonInelastic.RegisterMe(theLEProtonModel);
  theProtonInelastic.RegisterMe(theHEProtonModel);
  pManager->AddDiscreteProcess(&theProtonInelastic);

  pManager->AddProcess(&theProtonIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theProtonMult);
  pManager->SetProcessOrdering(&theProtonMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theProtonMult, idxPostStep, 1);

  // anti-Proton
  pManager = G4AntiProton::AntiProton()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiProtonModel = new G4LEAntiProtonInelastic();
  theHEAntiProtonModel = new G4HEAntiProtonInelastic();
  theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
  theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
  pManager->AddDiscreteProcess(&theAntiProtonInelastic);

  pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theAntiProtonMult);
  pManager->SetProcessOrdering(&theAntiProtonMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theAntiProtonMult, idxPostStep, 1);

  pManager->AddRestProcess(&theAntiProtonAnnihilation);

  // Neutron
  pManager = G4Neutron::Neutron()->GetProcessManager();
  // add process

// elastic scattering
                 theNeutronElasticProcess = new G4HadronElasticProcess;
            theElasticModel1 = new G4LElastic;
            theElasticNeutron = new G4NeutronHPElastic;
            theNeutronElasticProcess->RegisterMe(theElasticModel1);
            theElasticModel1->SetMinEnergy(19.9*MeV);
            theNeutronElasticProcess->RegisterMe(theElasticNeutron);
            theNeutronData = new G4NeutronHPElasticData;
            theNeutronElasticProcess->AddDataSet(theNeutronData);
            pManager->AddDiscreteProcess(theNeutronElasticProcess);

    // inelastic scattering
            theInelasticProcess =new G4NeutronInelasticProcess("inelastic");
            theInelasticModel = new G4LENeutronInelastic;
            theHEInelasticModel = new G4HENeutronInelastic();
            theInelasticModel->SetMinEnergy(19.9*MeV);
            theInelasticModel->SetMaxEnergy(55*GeV);
            theHEInelasticModel->SetMinEnergy(25*GeV);
            theInelasticProcess->RegisterMe(theInelasticModel);
            theLENeutronInelasticModel =new G4NeutronHPInelastic;
            theInelasticProcess->RegisterMe(theLENeutronInelasticModel);
            theInelasticProcess->RegisterMe(theHEInelasticModel); 
            theNeutronData1 =   new G4NeutronHPInelasticData;
            theInelasticProcess->AddDataSet(theNeutronData1);
            pManager->AddDiscreteProcess(theInelasticProcess);


            //    aProductionModel = new G4NeutronIsotopeProduction;
            //  theInelasticProcess->RegisterIsotopeProductionModel(aProductionModel);
            //  G4HadronicProcess::EnableIsotopeProductionGlobally();
      //fission


               theFissionProcess = new G4HadronFissionProcess;
                theFissionModel = new G4LFission;
                theFissionModel->SetMinEnergy(19.9*MeV);
               theFissionProcess->RegisterMe(theFissionModel);
               theLENeutronFissionModel = new G4NeutronHPFission;
              theFissionProcess->RegisterMe(theLENeutronFissionModel);
              theNeutronData2 = new G4NeutronHPFissionData;
              theFissionProcess->AddDataSet(theNeutronData2);
                pManager->AddDiscreteProcess(theFissionProcess);

// capture
            theCaptureProcess =  new G4HadronCaptureProcess;
            theCaptureModel = new G4LCapture;
            theCaptureModel->SetMinEnergy(19.9*MeV);
            theCaptureProcess->RegisterMe(theCaptureModel);
            theLENeutronCaptureModel = new G4NeutronHPCapture;
            theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
            theNeutronData3 = new G4NeutronHPCaptureData;
            theCaptureProcess->AddDataSet(theNeutronData3);
            pManager->AddDiscreteProcess(theCaptureProcess);
     
  // AntiNeutron
  pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
  theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
  theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
  theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
  pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
    
  pManager->AddRestProcess(&theAntiNeutronAnnihilation);

  // Lambda
  pManager = G4Lambda::Lambda()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLELambdaModel = new G4LELambdaInelastic();
  theHELambdaModel = new G4HELambdaInelastic();
  theLambdaInelastic.RegisterMe(theLELambdaModel);
  theLambdaInelastic.RegisterMe(theHELambdaModel);
  pManager->AddDiscreteProcess(&theLambdaInelastic);
  
  // AntiLambda
  pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
  theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
  theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
  theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
  pManager->AddDiscreteProcess(&theAntiLambdaInelastic);
    
  // SigmaMinus
  pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLESigmaMinusModel = new G4LESigmaMinusInelastic();
  theHESigmaMinusModel = new G4HESigmaMinusInelastic();
  theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
  theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
  pManager->AddDiscreteProcess(&theSigmaMinusInelastic);

  pManager->AddProcess(&theSigmaMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theSigmaMinusMult);
  pManager->SetProcessOrdering(&theSigmaMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theSigmaMinusMult, idxPostStep, 1);

  // anti-SigmaMinus
  pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
  theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
  theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
  theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
  pManager->AddDiscreteProcess(&theAntiSigmaMinusInelastic);

  pManager->AddProcess(&theAntiSigmaMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theAntiSigmaMinusMult);
  pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxPostStep, 1);

  // SigmaPlus
  pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLESigmaPlusModel = new G4LESigmaPlusInelastic();
  theHESigmaPlusModel = new G4HESigmaPlusInelastic();
  theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
  theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
  pManager->AddDiscreteProcess(&theSigmaPlusInelastic);

  pManager->AddProcess(&theSigmaPlusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theSigmaPlusMult);
  pManager->SetProcessOrdering(&theSigmaPlusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theSigmaPlusMult, idxPostStep, 1);

  // anti-SigmaPlus
  pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
  theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
  theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
  theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
  pManager->AddDiscreteProcess(&theAntiSigmaPlusInelastic);

  pManager->AddProcess(&theAntiSigmaPlusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theAntiSigmaPlusMult);
  pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxPostStep, 1);

  // XiMinus
  pManager = G4XiMinus::XiMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEXiMinusModel = new G4LEXiMinusInelastic();
  theHEXiMinusModel = new G4HEXiMinusInelastic();
  theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
  theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
  pManager->AddDiscreteProcess(&theXiMinusInelastic);

  pManager->AddProcess(&theXiMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theXiMinusMult);
  pManager->SetProcessOrdering(&theXiMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theXiMinusMult, idxPostStep, 1);

  // anti-XiMinus
  pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
  theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
  theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
  theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
  pManager->AddDiscreteProcess(&theAntiXiMinusInelastic);

  pManager->AddProcess(&theAntiXiMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theAntiXiMinusMult);
  pManager->SetProcessOrdering(&theAntiXiMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theAntiXiMinusMult, idxPostStep, 1);

  // XiZero
  pManager = G4XiZero::XiZero()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEXiZeroModel = new G4LEXiZeroInelastic();
  theHEXiZeroModel = new G4HEXiZeroInelastic();
  theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
  theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
  pManager->AddDiscreteProcess(&theXiZeroInelastic);

  // anti-XiZero
  pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
  theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
  theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
  theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
  pManager->AddDiscreteProcess(&theAntiXiZeroInelastic);

  // OmegaMinus
  pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
  theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
  theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
  theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
  pManager->AddDiscreteProcess(&theOmegaMinusInelastic);

  pManager->AddProcess(&theOmegaMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theOmegaMinusMult);
  pManager->SetProcessOrdering(&theOmegaMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theOmegaMinusMult, idxPostStep, 1);

  // anti-OmegaMinus
  pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
  // add process
  pManager->AddDiscreteProcess(&theElasticProcess);

  theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
  theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
  theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
  theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
  pManager->AddDiscreteProcess(&theAntiOmegaMinusInelastic);

  pManager->AddProcess(&theAntiOmegaMinusIonisation, ordInActive,2, 2);

  pManager->AddProcess(&theAntiOmegaMinusMult);
  pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxAlongStep, 1);
  pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxPostStep, 1);

}


1	cafagna	1.1
2			#include "HadronPhysics.hh"
3
4			#include "globals.hh"
5			#include "G4ios.hh"
6
7
8			HadronPhysics::HadronPhysics(const G4String& name)
9			: G4VPhysicsConstructor(name)
10			{
11			}
12
13			HadronPhysics::~HadronPhysics()
14			{
15			}
16
17			#include "G4ParticleDefinition.hh"
18			#include "G4ParticleTable.hh"
19
20			// Nuclei
21			#include "G4MesonConstructor.hh"
22			#include "G4BaryonConstructor.hh"
23			#include "G4ShortLivedConstructor.hh"
24
25			void HadronPhysics::ConstructParticle()
26			{
27			// Construct all mesons
28			G4MesonConstructor pMesonConstructor;
29			pMesonConstructor.ConstructParticle();
30
31			// Construct all barions
32			G4BaryonConstructor pBaryonConstructor;
33			pBaryonConstructor.ConstructParticle();
34
35			// Construct resonaces and quarks
36			G4ShortLivedConstructor pShortLivedConstructor;
37			pShortLivedConstructor.ConstructParticle();
38
39			}
40
41
42			#include "G4ProcessManager.hh"
43
44
45			void HadronPhysics::ConstructProcess()
46			{
47			G4ProcessManager * pManager = 0;
48
49			// Elastic Process
50			theElasticModel = new G4LElastic();
51			theElasticProcess.RegisterMe(theElasticModel);
52
53			// PionPlus
54			pManager = G4PionPlus::PionPlus()->GetProcessManager();
55			// add process
56			pManager->AddDiscreteProcess(&theElasticProcess);
57
58			theLEPionPlusModel = new G4LEPionPlusInelastic();
59			theHEPionPlusModel = new G4HEPionPlusInelastic();
60			thePionPlusInelastic.RegisterMe(theLEPionPlusModel);
61			thePionPlusInelastic.RegisterMe(theHEPionPlusModel);
62			pManager->AddDiscreteProcess(&thePionPlusInelastic);
63
64			pManager->AddProcess(&thePionPlusIonisation, ordInActive,2, 2);
65
66			pManager->AddProcess(&thePionPlusMult);
67			pManager->SetProcessOrdering(&thePionPlusMult, idxAlongStep, 1);
68			pManager->SetProcessOrdering(&thePionPlusMult, idxPostStep, 1);
69
70			// PionMinus
71			pManager = G4PionMinus::PionMinus()->GetProcessManager();
72			// add process
73			pManager->AddDiscreteProcess(&theElasticProcess);
74
75			theLEPionMinusModel = new G4LEPionMinusInelastic();
76			theHEPionMinusModel = new G4HEPionMinusInelastic();
77			thePionMinusInelastic.RegisterMe(theLEPionMinusModel);
78			thePionMinusInelastic.RegisterMe(theHEPionMinusModel);
79			pManager->AddDiscreteProcess(&thePionMinusInelastic);
80
81			pManager->AddProcess(&thePionMinusIonisation, ordInActive,2, 2);
82
83			pManager->AddProcess(&thePionMinusMult);
84			pManager->SetProcessOrdering(&thePionMinusMult, idxAlongStep, 1);
85			pManager->SetProcessOrdering(&thePionMinusMult, idxPostStep, 1);
86
87			pManager->AddRestProcess(&thePionMinusAbsorption, ordDefault);
88
89			// KaonPlus
90			pManager = G4KaonPlus::KaonPlus()->GetProcessManager();
91			// add process
92			pManager->AddDiscreteProcess(&theElasticProcess);
93
94			theLEKaonPlusModel = new G4LEKaonPlusInelastic();
95			theHEKaonPlusModel = new G4HEKaonPlusInelastic();
96			theKaonPlusInelastic.RegisterMe(theLEKaonPlusModel);
97			theKaonPlusInelastic.RegisterMe(theHEKaonPlusModel);
98			pManager->AddDiscreteProcess(&theKaonPlusInelastic);
99
100			pManager->AddProcess(&theKaonPlusIonisation, ordInActive,2, 2);
101
102			pManager->AddProcess(&theKaonPlusMult);
103			pManager->SetProcessOrdering(&theKaonPlusMult, idxAlongStep, 1);
104			pManager->SetProcessOrdering(&theKaonPlusMult, idxPostStep, 1);
105
106			// KaonMinus
107			pManager = G4KaonMinus::KaonMinus()->GetProcessManager();
108			// add process
109			pManager->AddDiscreteProcess(&theElasticProcess);
110
111			theLEKaonMinusModel = new G4LEKaonMinusInelastic();
112			theHEKaonMinusModel = new G4HEKaonMinusInelastic();
113			theKaonMinusInelastic.RegisterMe(theLEKaonMinusModel);
114			theKaonMinusInelastic.RegisterMe(theHEKaonMinusModel);
115			pManager->AddDiscreteProcess(&theKaonMinusInelastic);
116
117			pManager->AddProcess(&theKaonMinusIonisation, ordInActive,2, 2);
118
119			pManager->AddProcess(&theKaonMinusMult);
120			pManager->SetProcessOrdering(&theKaonMinusMult, idxAlongStep, 1);
121			pManager->SetProcessOrdering(&theKaonMinusMult, idxPostStep, 1);
122
123			pManager->AddRestProcess(&theKaonMinusAbsorption, ordDefault);
124
125			// KaonZeroL
126			pManager = G4KaonZeroLong::KaonZeroLong()->GetProcessManager();
127			// add process
128			pManager->AddDiscreteProcess(&theElasticProcess);
129
130			theLEKaonZeroLModel = new G4LEKaonZeroLInelastic();
131			theHEKaonZeroLModel = new G4HEKaonZeroInelastic();
132			theKaonZeroLInelastic.RegisterMe(theLEKaonZeroLModel);
133			theKaonZeroLInelastic.RegisterMe(theHEKaonZeroLModel);
134			pManager->AddDiscreteProcess(&theKaonZeroLInelastic);
135
136			// KaonZeroS
137			pManager = G4KaonZeroShort::KaonZeroShort()->GetProcessManager();
138			// add process
139			pManager->AddDiscreteProcess(&theElasticProcess);
140
141			theLEKaonZeroSModel = new G4LEKaonZeroSInelastic();
142			theHEKaonZeroSModel = new G4HEKaonZeroInelastic();
143			theKaonZeroSInelastic.RegisterMe(theLEKaonZeroSModel);
144			theKaonZeroSInelastic.RegisterMe(theHEKaonZeroSModel);
145			pManager->AddDiscreteProcess(&theKaonZeroSInelastic);
146
147			// Proton
148			pManager = G4Proton::Proton()->GetProcessManager();
149			// add process
150			pManager->AddDiscreteProcess(&theElasticProcess);
151
152			theLEProtonModel = new G4LEProtonInelastic();
153			theHEProtonModel = new G4HEProtonInelastic();
154			theProtonInelastic.RegisterMe(theLEProtonModel);
155			theProtonInelastic.RegisterMe(theHEProtonModel);
156			pManager->AddDiscreteProcess(&theProtonInelastic);
157
158			pManager->AddProcess(&theProtonIonisation, ordInActive,2, 2);
159
160			pManager->AddProcess(&theProtonMult);
161			pManager->SetProcessOrdering(&theProtonMult, idxAlongStep, 1);
162			pManager->SetProcessOrdering(&theProtonMult, idxPostStep, 1);
163
164			// anti-Proton
165			pManager = G4AntiProton::AntiProton()->GetProcessManager();
166			// add process
167			pManager->AddDiscreteProcess(&theElasticProcess);
168
169			theLEAntiProtonModel = new G4LEAntiProtonInelastic();
170			theHEAntiProtonModel = new G4HEAntiProtonInelastic();
171			theAntiProtonInelastic.RegisterMe(theLEAntiProtonModel);
172			theAntiProtonInelastic.RegisterMe(theHEAntiProtonModel);
173			pManager->AddDiscreteProcess(&theAntiProtonInelastic);
174
175			pManager->AddProcess(&theAntiProtonIonisation, ordInActive,2, 2);
176
177			pManager->AddProcess(&theAntiProtonMult);
178			pManager->SetProcessOrdering(&theAntiProtonMult, idxAlongStep, 1);
179			pManager->SetProcessOrdering(&theAntiProtonMult, idxPostStep, 1);
180
181			pManager->AddRestProcess(&theAntiProtonAnnihilation);
182
183			// Neutron
184			pManager = G4Neutron::Neutron()->GetProcessManager();
185			// add process
186
187			// elastic scattering
188			theNeutronElasticProcess = new G4HadronElasticProcess;
189			theElasticModel1 = new G4LElastic;
190			theElasticNeutron = new G4NeutronHPElastic;
191			theNeutronElasticProcess->RegisterMe(theElasticModel1);
192			theElasticModel1->SetMinEnergy(19.9*MeV);
193			theNeutronElasticProcess->RegisterMe(theElasticNeutron);
194			theNeutronData = new G4NeutronHPElasticData;
195			theNeutronElasticProcess->AddDataSet(theNeutronData);
196			pManager->AddDiscreteProcess(theNeutronElasticProcess);
197
198			// inelastic scattering
199			theInelasticProcess =new G4NeutronInelasticProcess("inelastic");
200			theInelasticModel = new G4LENeutronInelastic;
201			theHEInelasticModel = new G4HENeutronInelastic();
202			theInelasticModel->SetMinEnergy(19.9*MeV);
203			theInelasticModel->SetMaxEnergy(55*GeV);
204			theHEInelasticModel->SetMinEnergy(25*GeV);
205			theInelasticProcess->RegisterMe(theInelasticModel);
206			theLENeutronInelasticModel =new G4NeutronHPInelastic;
207			theInelasticProcess->RegisterMe(theLENeutronInelasticModel);
208			theInelasticProcess->RegisterMe(theHEInelasticModel);
209			theNeutronData1 = new G4NeutronHPInelasticData;
210			theInelasticProcess->AddDataSet(theNeutronData1);
211			pManager->AddDiscreteProcess(theInelasticProcess);
212
213
214			// aProductionModel = new G4NeutronIsotopeProduction;
215			// theInelasticProcess->RegisterIsotopeProductionModel(aProductionModel);
216			// G4HadronicProcess::EnableIsotopeProductionGlobally();
217			//fission
218
219
220			theFissionProcess = new G4HadronFissionProcess;
221			theFissionModel = new G4LFission;
222			theFissionModel->SetMinEnergy(19.9*MeV);
223			theFissionProcess->RegisterMe(theFissionModel);
224			theLENeutronFissionModel = new G4NeutronHPFission;
225			theFissionProcess->RegisterMe(theLENeutronFissionModel);
226			theNeutronData2 = new G4NeutronHPFissionData;
227			theFissionProcess->AddDataSet(theNeutronData2);
228			pManager->AddDiscreteProcess(theFissionProcess);
229
230			// capture
231			theCaptureProcess = new G4HadronCaptureProcess;
232			theCaptureModel = new G4LCapture;
233			theCaptureModel->SetMinEnergy(19.9*MeV);
234			theCaptureProcess->RegisterMe(theCaptureModel);
235			theLENeutronCaptureModel = new G4NeutronHPCapture;
236			theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
237			theNeutronData3 = new G4NeutronHPCaptureData;
238			theCaptureProcess->AddDataSet(theNeutronData3);
239			pManager->AddDiscreteProcess(theCaptureProcess);
240
241			// AntiNeutron
242			pManager = G4AntiNeutron::AntiNeutron()->GetProcessManager();
243			// add process
244			pManager->AddDiscreteProcess(&theElasticProcess);
245
246			theLEAntiNeutronModel = new G4LEAntiNeutronInelastic();
247			theHEAntiNeutronModel = new G4HEAntiNeutronInelastic();
248			theAntiNeutronInelastic.RegisterMe(theLEAntiNeutronModel);
249			theAntiNeutronInelastic.RegisterMe(theHEAntiNeutronModel);
250			pManager->AddDiscreteProcess(&theAntiNeutronInelastic);
251
252			pManager->AddRestProcess(&theAntiNeutronAnnihilation);
253
254			// Lambda
255			pManager = G4Lambda::Lambda()->GetProcessManager();
256			// add process
257			pManager->AddDiscreteProcess(&theElasticProcess);
258
259			theLELambdaModel = new G4LELambdaInelastic();
260			theHELambdaModel = new G4HELambdaInelastic();
261			theLambdaInelastic.RegisterMe(theLELambdaModel);
262			theLambdaInelastic.RegisterMe(theHELambdaModel);
263			pManager->AddDiscreteProcess(&theLambdaInelastic);
264
265			// AntiLambda
266			pManager = G4AntiLambda::AntiLambda()->GetProcessManager();
267			// add process
268			pManager->AddDiscreteProcess(&theElasticProcess);
269
270			theLEAntiLambdaModel = new G4LEAntiLambdaInelastic();
271			theHEAntiLambdaModel = new G4HEAntiLambdaInelastic();
272			theAntiLambdaInelastic.RegisterMe(theLEAntiLambdaModel);
273			theAntiLambdaInelastic.RegisterMe(theHEAntiLambdaModel);
274			pManager->AddDiscreteProcess(&theAntiLambdaInelastic);
275
276			// SigmaMinus
277			pManager = G4SigmaMinus::SigmaMinus()->GetProcessManager();
278			// add process
279			pManager->AddDiscreteProcess(&theElasticProcess);
280
281			theLESigmaMinusModel = new G4LESigmaMinusInelastic();
282			theHESigmaMinusModel = new G4HESigmaMinusInelastic();
283			theSigmaMinusInelastic.RegisterMe(theLESigmaMinusModel);
284			theSigmaMinusInelastic.RegisterMe(theHESigmaMinusModel);
285			pManager->AddDiscreteProcess(&theSigmaMinusInelastic);
286
287			pManager->AddProcess(&theSigmaMinusIonisation, ordInActive,2, 2);
288
289			pManager->AddProcess(&theSigmaMinusMult);
290			pManager->SetProcessOrdering(&theSigmaMinusMult, idxAlongStep, 1);
291			pManager->SetProcessOrdering(&theSigmaMinusMult, idxPostStep, 1);
292
293			// anti-SigmaMinus
294			pManager = G4AntiSigmaMinus::AntiSigmaMinus()->GetProcessManager();
295			// add process
296			pManager->AddDiscreteProcess(&theElasticProcess);
297
298			theLEAntiSigmaMinusModel = new G4LEAntiSigmaMinusInelastic();
299			theHEAntiSigmaMinusModel = new G4HEAntiSigmaMinusInelastic();
300			theAntiSigmaMinusInelastic.RegisterMe(theLEAntiSigmaMinusModel);
301			theAntiSigmaMinusInelastic.RegisterMe(theHEAntiSigmaMinusModel);
302			pManager->AddDiscreteProcess(&theAntiSigmaMinusInelastic);
303
304			pManager->AddProcess(&theAntiSigmaMinusIonisation, ordInActive,2, 2);
305
306			pManager->AddProcess(&theAntiSigmaMinusMult);
307			pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxAlongStep, 1);
308			pManager->SetProcessOrdering(&theAntiSigmaMinusMult, idxPostStep, 1);
309
310			// SigmaPlus
311			pManager = G4SigmaPlus::SigmaPlus()->GetProcessManager();
312			// add process
313			pManager->AddDiscreteProcess(&theElasticProcess);
314
315			theLESigmaPlusModel = new G4LESigmaPlusInelastic();
316			theHESigmaPlusModel = new G4HESigmaPlusInelastic();
317			theSigmaPlusInelastic.RegisterMe(theLESigmaPlusModel);
318			theSigmaPlusInelastic.RegisterMe(theHESigmaPlusModel);
319			pManager->AddDiscreteProcess(&theSigmaPlusInelastic);
320
321			pManager->AddProcess(&theSigmaPlusIonisation, ordInActive,2, 2);
322
323			pManager->AddProcess(&theSigmaPlusMult);
324			pManager->SetProcessOrdering(&theSigmaPlusMult, idxAlongStep, 1);
325			pManager->SetProcessOrdering(&theSigmaPlusMult, idxPostStep, 1);
326
327			// anti-SigmaPlus
328			pManager = G4AntiSigmaPlus::AntiSigmaPlus()->GetProcessManager();
329			// add process
330			pManager->AddDiscreteProcess(&theElasticProcess);
331
332			theLEAntiSigmaPlusModel = new G4LEAntiSigmaPlusInelastic();
333			theHEAntiSigmaPlusModel = new G4HEAntiSigmaPlusInelastic();
334			theAntiSigmaPlusInelastic.RegisterMe(theLEAntiSigmaPlusModel);
335			theAntiSigmaPlusInelastic.RegisterMe(theHEAntiSigmaPlusModel);
336			pManager->AddDiscreteProcess(&theAntiSigmaPlusInelastic);
337
338			pManager->AddProcess(&theAntiSigmaPlusIonisation, ordInActive,2, 2);
339
340			pManager->AddProcess(&theAntiSigmaPlusMult);
341			pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxAlongStep, 1);
342			pManager->SetProcessOrdering(&theAntiSigmaPlusMult, idxPostStep, 1);
343
344			// XiMinus
345			pManager = G4XiMinus::XiMinus()->GetProcessManager();
346			// add process
347			pManager->AddDiscreteProcess(&theElasticProcess);
348
349			theLEXiMinusModel = new G4LEXiMinusInelastic();
350			theHEXiMinusModel = new G4HEXiMinusInelastic();
351			theXiMinusInelastic.RegisterMe(theLEXiMinusModel);
352			theXiMinusInelastic.RegisterMe(theHEXiMinusModel);
353			pManager->AddDiscreteProcess(&theXiMinusInelastic);
354
355			pManager->AddProcess(&theXiMinusIonisation, ordInActive,2, 2);
356
357			pManager->AddProcess(&theXiMinusMult);
358			pManager->SetProcessOrdering(&theXiMinusMult, idxAlongStep, 1);
359			pManager->SetProcessOrdering(&theXiMinusMult, idxPostStep, 1);
360
361			// anti-XiMinus
362			pManager = G4AntiXiMinus::AntiXiMinus()->GetProcessManager();
363			// add process
364			pManager->AddDiscreteProcess(&theElasticProcess);
365
366			theLEAntiXiMinusModel = new G4LEAntiXiMinusInelastic();
367			theHEAntiXiMinusModel = new G4HEAntiXiMinusInelastic();
368			theAntiXiMinusInelastic.RegisterMe(theLEAntiXiMinusModel);
369			theAntiXiMinusInelastic.RegisterMe(theHEAntiXiMinusModel);
370			pManager->AddDiscreteProcess(&theAntiXiMinusInelastic);
371
372			pManager->AddProcess(&theAntiXiMinusIonisation, ordInActive,2, 2);
373
374			pManager->AddProcess(&theAntiXiMinusMult);
375			pManager->SetProcessOrdering(&theAntiXiMinusMult, idxAlongStep, 1);
376			pManager->SetProcessOrdering(&theAntiXiMinusMult, idxPostStep, 1);
377
378			// XiZero
379			pManager = G4XiZero::XiZero()->GetProcessManager();
380			// add process
381			pManager->AddDiscreteProcess(&theElasticProcess);
382
383			theLEXiZeroModel = new G4LEXiZeroInelastic();
384			theHEXiZeroModel = new G4HEXiZeroInelastic();
385			theXiZeroInelastic.RegisterMe(theLEXiZeroModel);
386			theXiZeroInelastic.RegisterMe(theHEXiZeroModel);
387			pManager->AddDiscreteProcess(&theXiZeroInelastic);
388
389			// anti-XiZero
390			pManager = G4AntiXiZero::AntiXiZero()->GetProcessManager();
391			// add process
392			pManager->AddDiscreteProcess(&theElasticProcess);
393
394			theLEAntiXiZeroModel = new G4LEAntiXiZeroInelastic();
395			theHEAntiXiZeroModel = new G4HEAntiXiZeroInelastic();
396			theAntiXiZeroInelastic.RegisterMe(theLEAntiXiZeroModel);
397			theAntiXiZeroInelastic.RegisterMe(theHEAntiXiZeroModel);
398			pManager->AddDiscreteProcess(&theAntiXiZeroInelastic);
399
400			// OmegaMinus
401			pManager = G4OmegaMinus::OmegaMinus()->GetProcessManager();
402			// add process
403			pManager->AddDiscreteProcess(&theElasticProcess);
404
405			theLEOmegaMinusModel = new G4LEOmegaMinusInelastic();
406			theHEOmegaMinusModel = new G4HEOmegaMinusInelastic();
407			theOmegaMinusInelastic.RegisterMe(theLEOmegaMinusModel);
408			theOmegaMinusInelastic.RegisterMe(theHEOmegaMinusModel);
409			pManager->AddDiscreteProcess(&theOmegaMinusInelastic);
410
411			pManager->AddProcess(&theOmegaMinusIonisation, ordInActive,2, 2);
412
413			pManager->AddProcess(&theOmegaMinusMult);
414			pManager->SetProcessOrdering(&theOmegaMinusMult, idxAlongStep, 1);
415			pManager->SetProcessOrdering(&theOmegaMinusMult, idxPostStep, 1);
416
417			// anti-OmegaMinus
418			pManager = G4AntiOmegaMinus::AntiOmegaMinus()->GetProcessManager();
419			// add process
420			pManager->AddDiscreteProcess(&theElasticProcess);
421
422			theLEAntiOmegaMinusModel = new G4LEAntiOmegaMinusInelastic();
423			theHEAntiOmegaMinusModel = new G4HEAntiOmegaMinusInelastic();
424			theAntiOmegaMinusInelastic.RegisterMe(theLEAntiOmegaMinusModel);
425			theAntiOmegaMinusInelastic.RegisterMe(theHEAntiOmegaMinusModel);
426			pManager->AddDiscreteProcess(&theAntiOmegaMinusInelastic);
427
428			pManager->AddProcess(&theAntiOmegaMinusIonisation, ordInActive,2, 2);
429
430			pManager->AddProcess(&theAntiOmegaMinusMult);
431			pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxAlongStep, 1);
432			pManager->SetProcessOrdering(&theAntiOmegaMinusMult, idxPostStep, 1);
433
434			}
435
436
437
438
439