PamG4/src/IonPhysics.cc


#include "IonPhysics.hh"

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


#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
//#include "G4LFission.hh"
//#include "G4LCapture.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
//#include "IonC12.hh"
#include "G4GenericIon.hh"

#include "G4ExcitationHandler.hh"
#include "G4Evaporation.hh"
#include "G4FermiBreakUp.hh"
#include "G4StatMF.hh"
#include "G4GeneratorPrecompoundInterface.hh"

#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4LETritonInelastic.hh"
#include "G4LEAlphaInelastic.hh"


IonPhysics::IonPhysics(const G4String& name)
                 :  G4VPhysicsConstructor(name)
{
}
IonPhysics::~IonPhysics()
{
}

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

// Nuclei
#include "G4IonConstructor.hh"

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


//#include "G4ProcessManager.hh"


void IonPhysics::ConstructProcess()
{

  G4ParticleDefinition* particle = 0;
  G4ProcessManager* pmanager = 0;
  G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
  theBC->SetMinEnergy(80*MeV);
  theBC->SetMaxEnergy(20*GeV);

  G4TripathiCrossSection * TripathiCrossSection= new G4TripathiCrossSection;
  G4IonsShenCrossSection * aShen = new G4IonsShenCrossSection;

  
  // Elastic Process
  theElasticModel = new G4LElastic();
  theElasticProcess.RegisterMe(theElasticModel);

  // Generic Ion
  //  pmanager = G4GenericIon::GenericIon()->GetProcessManager();
  // add process


  // GenericIon
  particle = G4GenericIon::GenericIon();
  pmanager = particle->GetProcessManager();
  G4HadronInelasticProcess* theIPGenericIon =
      new G4HadronInelasticProcess("IonInelastic",particle);
  theIPGenericIon->AddDataSet(TripathiCrossSection);
  theIPGenericIon->AddDataSet(aShen);
  G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
  theGenIonBC->SetMinEnergy(0*MeV);
  theGenIonBC->SetMaxEnergy(10*GeV);
  theIPGenericIon->RegisterMe(theGenIonBC);
  pmanager->AddDiscreteProcess(theIPGenericIon);
  //-------------------------------------------------
  pmanager->AddDiscreteProcess(&theElasticProcess);
  pmanager->AddProcess(&fIonIonisation, ordInActive, 2, 2);
  pmanager->AddProcess(&fIonMultipleScattering);
  pmanager->SetProcessOrdering(&fIonMultipleScattering, idxAlongStep,  1);
  pmanager->SetProcessOrdering(&fIonMultipleScattering, idxPostStep,  1);
  //------------------------------------------------------------------------

  // C12
  //  particle = IonC12::Ion();
  //  pmanager = particle->GetProcessManager();
  //  G4HadronInelasticProcess* theIPIonC12 =
  //      new G4HadronInelasticProcess("IonC12Inelastic",particle);
  //  theIPIonC12->AddDataSet(TripathiCrossSection);
  //  theIPIonC12->AddDataSet(aShen);
  //  theIPIonC12->RegisterMe(theGenIonBC);
  //  pmanager->AddDiscreteProcess(theIPIonC12);
  //------------------------------------------------------------------------
  // Deuteron 
  particle = G4Deuteron::Deuteron();
  pmanager = particle->GetProcessManager();
  G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
  theDIModel->SetMaxEnergy(100*MeV);
  theIPdeuteron.AddDataSet(TripathiCrossSection);
  theIPdeuteron.AddDataSet(aShen);
  theIPdeuteron.RegisterMe(theDIModel);
  theIPdeuteron.RegisterMe(theBC);
  pmanager->AddDiscreteProcess(&theIPdeuteron);
  //------------------------------------------------------
  //  pmanager = G4Deuteron::Deuteron()->GetProcessManager();
  // add process
  pmanager->AddDiscreteProcess(&theElasticProcess);

  //  fDeuteronModel = new G4LEDeuteronInelastic();
  //  fDeuteronProcess.RegisterMe(fDeuteronModel);
  //  pmanager->AddDiscreteProcess(&fDeuteronProcess);

  pmanager->AddProcess(&fDeuteronIonisation, ordInActive, 2, 2);

  pmanager->AddProcess(&fDeuteronMultipleScattering);
  pmanager->SetProcessOrdering(&fDeuteronMultipleScattering, idxAlongStep,  1);
  pmanager->SetProcessOrdering(&fDeuteronMultipleScattering, idxPostStep,  1);
  //------------------------------------------------------------------------------
  // Triton 
  //-----------------------------------------------------------------------------
  particle = G4Triton::Triton();
  pmanager = particle->GetProcessManager();
  G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
  theTIModel->SetMaxEnergy(100*MeV);
  theIPtriton.AddDataSet(TripathiCrossSection);
  theIPtriton.AddDataSet(aShen);
  theIPtriton.RegisterMe(theTIModel);
  theIPtriton.RegisterMe(theBC);
  pmanager->AddDiscreteProcess(&theIPtriton);
  pmanager = G4Triton::Triton()->GetProcessManager();
  // add process
  //----------------------------------------------
  pmanager->AddDiscreteProcess(&theElasticProcess);

  //  fTritonModel = new G4LETritonInelastic();
  // fTritonProcess.RegisterMe(fTritonModel);
  //pmanager->AddDiscreteProcess(&fTritonProcess);

  pmanager->AddProcess(&fTritonIonisation, ordInActive, 2, 2);

  pmanager->AddProcess(&fTritonMultipleScattering);
  pmanager->SetProcessOrdering(&fTritonMultipleScattering, idxAlongStep,  1);
  pmanager->SetProcessOrdering(&fTritonMultipleScattering, idxPostStep,  1);
 
  // Alpha 

 particle = G4Alpha::Alpha();
  pmanager = particle->GetProcessManager();
  G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
  theAIModel->SetMaxEnergy(100*MeV);
  theIPalpha.AddDataSet(TripathiCrossSection);
  theIPalpha.AddDataSet(aShen);
  theIPalpha.RegisterMe(theAIModel);
  theIPalpha.RegisterMe(theBC);
  pmanager->AddDiscreteProcess(&theIPalpha);
  //-------------------------------------------------------------------------
  //  pmanager = G4Alpha::Alpha()->GetProcessManager();
  // add process
  pmanager->AddDiscreteProcess(&theElasticProcess);

  //  fAlphaModel = new G4LEAlphaInelastic();
  //  fAlphaProcess.RegisterMe(fAlphaModel);
  //  pmanager->AddDiscreteProcess(&fAlphaProcess);

  pmanager->AddProcess(&fAlphaIonisation, ordInActive, 2, 2);

  pmanager->AddProcess(&fAlphaMultipleScattering);
  pmanager->SetProcessOrdering(&fAlphaMultipleScattering, idxAlongStep,  1);
  pmanager->SetProcessOrdering(&fAlphaMultipleScattering, idxPostStep,  1);
  //------------------------------------------------------------------------
  // He3
  particle = G4He3::He3();
  pmanager = particle->GetProcessManager();
  G4HadronInelasticProcess* theIPHe3 =
      new G4HadronInelasticProcess("He3Inelastic",particle);
  theIPHe3->AddDataSet(TripathiCrossSection);
  theIPHe3->AddDataSet(aShen);
  theIPHe3->RegisterMe(theGenIonBC);
  pmanager->AddDiscreteProcess(theIPHe3);
  //------------------------------------------------------------------------
  //  pmanager = G4He3::He3()->GetProcessManager();
  // add process
  pmanager->AddDiscreteProcess(&theElasticProcess);

  pmanager->AddProcess(&fHe3Ionisation, ordInActive, 2, 2);

  pmanager->AddProcess(&fHe3MultipleScattering);
  pmanager->SetProcessOrdering(&fHe3MultipleScattering, idxAlongStep,  1);
  pmanager->SetProcessOrdering(&fHe3MultipleScattering, idxPostStep,  1);
   
}


1	cafagna	1.1
2			#include "IonPhysics.hh"
3
4			#include "globals.hh"
5			#include "G4ios.hh"
6
7
8			#include "G4ParticleDefinition.hh"
9			#include "G4ProcessManager.hh"
10			//#include "G4LFission.hh"
11			//#include "G4LCapture.hh"
12			#include "G4Deuteron.hh"
13			#include "G4Triton.hh"
14			#include "G4He3.hh"
15			#include "G4Alpha.hh"
16			//#include "IonC12.hh"
17			#include "G4GenericIon.hh"
18
19			#include "G4ExcitationHandler.hh"
20			#include "G4Evaporation.hh"
21			#include "G4FermiBreakUp.hh"
22			#include "G4StatMF.hh"
23			#include "G4GeneratorPrecompoundInterface.hh"
24
25			#include "G4HadronInelasticProcess.hh"
26			#include "G4BinaryLightIonReaction.hh"
27			#include "G4TripathiCrossSection.hh"
28			#include "G4IonsShenCrossSection.hh"
29			#include "G4LEDeuteronInelastic.hh"
30			#include "G4LETritonInelastic.hh"
31			#include "G4LEAlphaInelastic.hh"
32
33
34			IonPhysics::IonPhysics(const G4String& name)
35			: G4VPhysicsConstructor(name)
36			{
37			}
38			IonPhysics::~IonPhysics()
39			{
40			}
41
42			//#include "G4ParticleDefinition.hh"
43			//#include "G4ParticleTable.hh"
44
45			// Nuclei
46			#include "G4IonConstructor.hh"
47
48			void IonPhysics::ConstructParticle()
49			{
50			// Construct light ions
51			G4IonConstructor pConstructor;
52			pConstructor.ConstructParticle();
53			}
54
55
56			//#include "G4ProcessManager.hh"
57
58
59			void IonPhysics::ConstructProcess()
60			{
61
62			G4ParticleDefinition* particle = 0;
63			G4ProcessManager* pmanager = 0;
64			G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
65			theBC->SetMinEnergy(80*MeV);
66			theBC->SetMaxEnergy(20*GeV);
67
68			G4TripathiCrossSection * TripathiCrossSection= new G4TripathiCrossSection;
69			G4IonsShenCrossSection * aShen = new G4IonsShenCrossSection;
70
71
72			// Elastic Process
73			theElasticModel = new G4LElastic();
74			theElasticProcess.RegisterMe(theElasticModel);
75
76			// Generic Ion
77			// pmanager = G4GenericIon::GenericIon()->GetProcessManager();
78			// add process
79
80
81
82			// GenericIon
83			particle = G4GenericIon::GenericIon();
84			pmanager = particle->GetProcessManager();
85			G4HadronInelasticProcess* theIPGenericIon =
86			new G4HadronInelasticProcess("IonInelastic",particle);
87			theIPGenericIon->AddDataSet(TripathiCrossSection);
88			theIPGenericIon->AddDataSet(aShen);
89			G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
90			theGenIonBC->SetMinEnergy(0*MeV);
91			theGenIonBC->SetMaxEnergy(10*GeV);
92			theIPGenericIon->RegisterMe(theGenIonBC);
93			pmanager->AddDiscreteProcess(theIPGenericIon);
94			//-------------------------------------------------
95			pmanager->AddDiscreteProcess(&theElasticProcess);
96			pmanager->AddProcess(&fIonIonisation, ordInActive, 2, 2);
97			pmanager->AddProcess(&fIonMultipleScattering);
98			pmanager->SetProcessOrdering(&fIonMultipleScattering, idxAlongStep, 1);
99			pmanager->SetProcessOrdering(&fIonMultipleScattering, idxPostStep, 1);
100			//------------------------------------------------------------------------
101
102			// C12
103			// particle = IonC12::Ion();
104			// pmanager = particle->GetProcessManager();
105			// G4HadronInelasticProcess* theIPIonC12 =
106			// new G4HadronInelasticProcess("IonC12Inelastic",particle);
107			// theIPIonC12->AddDataSet(TripathiCrossSection);
108			// theIPIonC12->AddDataSet(aShen);
109			// theIPIonC12->RegisterMe(theGenIonBC);
110			// pmanager->AddDiscreteProcess(theIPIonC12);
111			//------------------------------------------------------------------------
112			// Deuteron
113			particle = G4Deuteron::Deuteron();
114			pmanager = particle->GetProcessManager();
115			G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
116			theDIModel->SetMaxEnergy(100*MeV);
117			theIPdeuteron.AddDataSet(TripathiCrossSection);
118			theIPdeuteron.AddDataSet(aShen);
119			theIPdeuteron.RegisterMe(theDIModel);
120			theIPdeuteron.RegisterMe(theBC);
121			pmanager->AddDiscreteProcess(&theIPdeuteron);
122			//------------------------------------------------------
123			// pmanager = G4Deuteron::Deuteron()->GetProcessManager();
124			// add process
125			pmanager->AddDiscreteProcess(&theElasticProcess);
126
127			// fDeuteronModel = new G4LEDeuteronInelastic();
128			// fDeuteronProcess.RegisterMe(fDeuteronModel);
129			// pmanager->AddDiscreteProcess(&fDeuteronProcess);
130
131			pmanager->AddProcess(&fDeuteronIonisation, ordInActive, 2, 2);
132
133			pmanager->AddProcess(&fDeuteronMultipleScattering);
134			pmanager->SetProcessOrdering(&fDeuteronMultipleScattering, idxAlongStep, 1);
135			pmanager->SetProcessOrdering(&fDeuteronMultipleScattering, idxPostStep, 1);
136			//------------------------------------------------------------------------------
137			// Triton
138			//-----------------------------------------------------------------------------
139			particle = G4Triton::Triton();
140			pmanager = particle->GetProcessManager();
141			G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
142			theTIModel->SetMaxEnergy(100*MeV);
143			theIPtriton.AddDataSet(TripathiCrossSection);
144			theIPtriton.AddDataSet(aShen);
145			theIPtriton.RegisterMe(theTIModel);
146			theIPtriton.RegisterMe(theBC);
147			pmanager->AddDiscreteProcess(&theIPtriton);
148			pmanager = G4Triton::Triton()->GetProcessManager();
149			// add process
150			//----------------------------------------------
151			pmanager->AddDiscreteProcess(&theElasticProcess);
152
153			// fTritonModel = new G4LETritonInelastic();
154			// fTritonProcess.RegisterMe(fTritonModel);
155			//pmanager->AddDiscreteProcess(&fTritonProcess);
156
157			pmanager->AddProcess(&fTritonIonisation, ordInActive, 2, 2);
158
159			pmanager->AddProcess(&fTritonMultipleScattering);
160			pmanager->SetProcessOrdering(&fTritonMultipleScattering, idxAlongStep, 1);
161			pmanager->SetProcessOrdering(&fTritonMultipleScattering, idxPostStep, 1);
162
163			// Alpha
164
165			particle = G4Alpha::Alpha();
166			pmanager = particle->GetProcessManager();
167			G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
168			theAIModel->SetMaxEnergy(100*MeV);
169			theIPalpha.AddDataSet(TripathiCrossSection);
170			theIPalpha.AddDataSet(aShen);
171			theIPalpha.RegisterMe(theAIModel);
172			theIPalpha.RegisterMe(theBC);
173			pmanager->AddDiscreteProcess(&theIPalpha);
174			//-------------------------------------------------------------------------
175			// pmanager = G4Alpha::Alpha()->GetProcessManager();
176			// add process
177			pmanager->AddDiscreteProcess(&theElasticProcess);
178
179			// fAlphaModel = new G4LEAlphaInelastic();
180			// fAlphaProcess.RegisterMe(fAlphaModel);
181			// pmanager->AddDiscreteProcess(&fAlphaProcess);
182
183			pmanager->AddProcess(&fAlphaIonisation, ordInActive, 2, 2);
184
185			pmanager->AddProcess(&fAlphaMultipleScattering);
186			pmanager->SetProcessOrdering(&fAlphaMultipleScattering, idxAlongStep, 1);
187			pmanager->SetProcessOrdering(&fAlphaMultipleScattering, idxPostStep, 1);
188			//------------------------------------------------------------------------
189			// He3
190			particle = G4He3::He3();
191			pmanager = particle->GetProcessManager();
192			G4HadronInelasticProcess* theIPHe3 =
193			new G4HadronInelasticProcess("He3Inelastic",particle);
194			theIPHe3->AddDataSet(TripathiCrossSection);
195			theIPHe3->AddDataSet(aShen);
196			theIPHe3->RegisterMe(theGenIonBC);
197			pmanager->AddDiscreteProcess(theIPHe3);
198			//------------------------------------------------------------------------
199			// pmanager = G4He3::He3()->GetProcessManager();
200			// add process
201			pmanager->AddDiscreteProcess(&theElasticProcess);
202
203			pmanager->AddProcess(&fHe3Ionisation, ordInActive, 2, 2);
204
205			pmanager->AddProcess(&fHe3MultipleScattering);
206			pmanager->SetProcessOrdering(&fHe3MultipleScattering, idxAlongStep, 1);
207			pmanager->SetProcessOrdering(&fHe3MultipleScattering, idxPostStep, 1);
208
209			}
210
211
212