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