| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id: G4ChargeExchangeProcess.cc 66892 2013-01-17 10:57:59Z gunter $
27 // 28 //
28 // 29 //
29 // Geant4 Hadron Charge Exchange Process -- so 30 // Geant4 Hadron Charge Exchange Process -- source file
30 // 31 //
31 // Created 21 April 2006 V.Ivanchenko 32 // Created 21 April 2006 V.Ivanchenko
32 // 33 //
33 // Modified: 34 // Modified:
34 // 24-Apr-06 V.Ivanchenko add neutron scatteri 35 // 24-Apr-06 V.Ivanchenko add neutron scattering on hydrogen from CHIPS
35 // 07-Jun-06 V.Ivanchenko fix problem of rotat 36 // 07-Jun-06 V.Ivanchenko fix problem of rotation of final state
36 // 25-Jul-06 V.Ivanchenko add 19 MeV low energ 37 // 25-Jul-06 V.Ivanchenko add 19 MeV low energy for CHIPS
37 // 23-Jan-07 V.Ivanchenko add cross section in 38 // 23-Jan-07 V.Ivanchenko add cross section interfaces with Z and A
38 // and do not use CHIPS 39 // and do not use CHIPS for cross sections
39 // 14-Sep-12 M.Kelsey -- Pass subType code to 40 // 14-Sep-12 M.Kelsey -- Pass subType code to base ctor
40 // 06-Aug-15 A.Ribon migrating to G4Pow <<
41 41
42 #include "G4ChargeExchangeProcess.hh" 42 #include "G4ChargeExchangeProcess.hh"
43 #include "globals.hh" 43 #include "globals.hh"
44 #include "G4SystemOfUnits.hh" 44 #include "G4SystemOfUnits.hh"
45 #include "G4CrossSectionDataStore.hh" 45 #include "G4CrossSectionDataStore.hh"
46 #include "G4CrossSectionElastic.hh" << 46 #include "G4HadronElasticDataSet.hh"
47 #include "G4ComponentGGHadronNucleusXsc.hh" <<
48 #include "G4Element.hh" 47 #include "G4Element.hh"
49 #include "G4ElementVector.hh" 48 #include "G4ElementVector.hh"
50 #include "G4IsotopeVector.hh" 49 #include "G4IsotopeVector.hh"
51 #include "G4Neutron.hh" 50 #include "G4Neutron.hh"
52 #include "G4Proton.hh" 51 #include "G4Proton.hh"
53 #include "G4PhysicsLinearVector.hh" 52 #include "G4PhysicsLinearVector.hh"
54 53
55 #include "G4Pow.hh" <<
56 <<
57 <<
58 G4ChargeExchangeProcess::G4ChargeExchangeProce 54 G4ChargeExchangeProcess::G4ChargeExchangeProcess(const G4String& procName)
59 : G4HadronicProcess(procName,fChargeExchange 55 : G4HadronicProcess(procName,fChargeExchange), first(true)
60 { 56 {
61 G4cout << "###=== The class G4ChargeExchange <<
62 G4cout << "###=== It will be removed at the <<
63 thEnergy = 20.*MeV; 57 thEnergy = 20.*MeV;
64 pPDG = 0; 58 pPDG = 0;
65 verboseLevel= 1; 59 verboseLevel= 1;
66 AddDataSet( new G4CrossSectionElastic( new G << 60 AddDataSet(new G4HadronElasticDataSet);
67 theProton = G4Proton::Proton(); 61 theProton = G4Proton::Proton();
68 theNeutron = G4Neutron::Neutron(); 62 theNeutron = G4Neutron::Neutron();
69 theAProton = G4AntiProton::AntiProton(); 63 theAProton = G4AntiProton::AntiProton();
70 theANeutron = G4AntiNeutron::AntiNeutron(); 64 theANeutron = G4AntiNeutron::AntiNeutron();
71 thePiPlus = G4PionPlus::PionPlus(); 65 thePiPlus = G4PionPlus::PionPlus();
72 thePiMinus = G4PionMinus::PionMinus(); 66 thePiMinus = G4PionMinus::PionMinus();
73 thePiZero = G4PionZero::PionZero(); 67 thePiZero = G4PionZero::PionZero();
74 theKPlus = G4KaonPlus::KaonPlus(); 68 theKPlus = G4KaonPlus::KaonPlus();
75 theKMinus = G4KaonMinus::KaonMinus(); 69 theKMinus = G4KaonMinus::KaonMinus();
76 theK0S = G4KaonZeroShort::KaonZeroShort 70 theK0S = G4KaonZeroShort::KaonZeroShort();
77 theK0L = G4KaonZeroLong::KaonZeroLong() 71 theK0L = G4KaonZeroLong::KaonZeroLong();
78 theL = G4Lambda::Lambda(); 72 theL = G4Lambda::Lambda();
79 theAntiL = G4AntiLambda::AntiLambda(); 73 theAntiL = G4AntiLambda::AntiLambda();
80 theSPlus = G4SigmaPlus::SigmaPlus(); 74 theSPlus = G4SigmaPlus::SigmaPlus();
81 theASPlus = G4AntiSigmaPlus::AntiSigmaPlus 75 theASPlus = G4AntiSigmaPlus::AntiSigmaPlus();
82 theSMinus = G4SigmaMinus::SigmaMinus(); 76 theSMinus = G4SigmaMinus::SigmaMinus();
83 theASMinus = G4AntiSigmaMinus::AntiSigmaMin 77 theASMinus = G4AntiSigmaMinus::AntiSigmaMinus();
84 theS0 = G4SigmaZero::SigmaZero(); 78 theS0 = G4SigmaZero::SigmaZero();
85 theAS0 = G4AntiSigmaZero::AntiSigmaZero 79 theAS0 = G4AntiSigmaZero::AntiSigmaZero();
86 theXiMinus = G4XiMinus::XiMinus(); 80 theXiMinus = G4XiMinus::XiMinus();
87 theXi0 = G4XiZero::XiZero(); 81 theXi0 = G4XiZero::XiZero();
88 theAXiMinus = G4AntiXiMinus::AntiXiMinus(); 82 theAXiMinus = G4AntiXiMinus::AntiXiMinus();
89 theAXi0 = G4AntiXiZero::AntiXiZero(); 83 theAXi0 = G4AntiXiZero::AntiXiZero();
90 theOmega = G4OmegaMinus::OmegaMinus(); 84 theOmega = G4OmegaMinus::OmegaMinus();
91 theAOmega = G4AntiOmegaMinus::AntiOmegaMin 85 theAOmega = G4AntiOmegaMinus::AntiOmegaMinus();
92 theD = G4Deuteron::Deuteron(); 86 theD = G4Deuteron::Deuteron();
93 theT = G4Triton::Triton(); 87 theT = G4Triton::Triton();
94 theA = G4Alpha::Alpha(); 88 theA = G4Alpha::Alpha();
95 theHe3 = G4He3::He3(); 89 theHe3 = G4He3::He3();
96 } 90 }
97 91
98 G4ChargeExchangeProcess::~G4ChargeExchangeProc 92 G4ChargeExchangeProcess::~G4ChargeExchangeProcess()
99 { 93 {
100 if (factors) delete factors; << 94 delete factors;
101 } 95 }
102 96
103 void G4ChargeExchangeProcess:: 97 void G4ChargeExchangeProcess::
104 BuildPhysicsTable(const G4ParticleDefinition& 98 BuildPhysicsTable(const G4ParticleDefinition& aParticleType)
105 { 99 {
106 if(first) { 100 if(first) {
107 first = false; 101 first = false;
108 theParticle = &aParticleType; 102 theParticle = &aParticleType;
109 pPDG = theParticle->GetPDGEncoding(); 103 pPDG = theParticle->GetPDGEncoding();
110 104
111 store = G4HadronicProcess::GetCrossSection 105 store = G4HadronicProcess::GetCrossSectionDataStore();
112 106
113 const size_t n = 10; 107 const size_t n = 10;
114 if(theParticle == thePiPlus || theParticle 108 if(theParticle == thePiPlus || theParticle == thePiMinus ||
115 theParticle == theKPlus || theParticle 109 theParticle == theKPlus || theParticle == theKMinus ||
116 theParticle == theK0S || theParticle 110 theParticle == theK0S || theParticle == theK0L) {
117 111
118 G4double F[n] = {0.33,0.27,0.29,0.31,0.2 112 G4double F[n] = {0.33,0.27,0.29,0.31,0.27,0.18,0.13,0.1,0.09,0.07};
119 factors = new G4PhysicsLinearVector(0.0, 113 factors = new G4PhysicsLinearVector(0.0,2.0*GeV,n);
120 for(size_t i=0; i<n; i++) {factors->PutV 114 for(size_t i=0; i<n; i++) {factors->PutValue(i,F[i]);}
121 115
122 } else { 116 } else {
123 117
124 G4double F[n] = {0.50,0.45,0.40,0.35,0.3 118 G4double F[n] = {0.50,0.45,0.40,0.35,0.30,0.25,0.06,0.04,0.005,0.0};
125 factors = new G4PhysicsLinearVector(0.0, 119 factors = new G4PhysicsLinearVector(0.0,4.0*GeV,n);
126 for(size_t i=0; i<n; i++) {factors->PutV 120 for(size_t i=0; i<n; i++) {factors->PutValue(i,F[i]);}
127 } 121 }
>> 122 //factors->SetSpline(true);
128 123
129 if(verboseLevel>1) 124 if(verboseLevel>1)
130 G4cout << "G4ChargeExchangeProcess for " 125 G4cout << "G4ChargeExchangeProcess for "
131 << theParticle->GetParticleName() 126 << theParticle->GetParticleName()
132 << G4endl; 127 << G4endl;
133 } 128 }
134 G4HadronicProcess::BuildPhysicsTable(aPartic 129 G4HadronicProcess::BuildPhysicsTable(aParticleType);
135 } 130 }
136 131
137 G4double G4ChargeExchangeProcess::GetElementCr 132 G4double G4ChargeExchangeProcess::GetElementCrossSection(
138 const G4Dyna 133 const G4DynamicParticle* dp,
139 const G4Element* elm, 134 const G4Element* elm,
140 const G4Material* mat) 135 const G4Material* mat)
141 { 136 {
142 // gives the microscopic cross section in GE 137 // gives the microscopic cross section in GEANT4 internal units
143 G4double Z = elm->GetZ(); 138 G4double Z = elm->GetZ();
144 G4int iz = G4int(Z); 139 G4int iz = G4int(Z);
145 G4double x = 0.0; 140 G4double x = 0.0;
146 141
147 // The process is effective only above the t 142 // The process is effective only above the threshold
148 if(iz == 1 || dp->GetKineticEnergy() < thEne 143 if(iz == 1 || dp->GetKineticEnergy() < thEnergy) return x;
149 144
150 if(verboseLevel>1) 145 if(verboseLevel>1)
151 G4cout << "G4ChargeExchangeProcess compute 146 G4cout << "G4ChargeExchangeProcess compute GHAD CS for element "
152 << elm->GetName() 147 << elm->GetName()
153 << G4endl; 148 << G4endl;
154 x = store->GetCrossSection(dp, elm, mat); 149 x = store->GetCrossSection(dp, elm, mat);
155 150
156 if(verboseLevel>1) 151 if(verboseLevel>1)
157 G4cout << "G4ChargeExchangeProcess cross(m 152 G4cout << "G4ChargeExchangeProcess cross(mb)= " << x/millibarn
158 << " E(MeV)= " << dp->GetKineticEn 153 << " E(MeV)= " << dp->GetKineticEnergy()
159 << " " << theParticle->GetParticleName() 154 << " " << theParticle->GetParticleName()
160 << " in Z= " << iz 155 << " in Z= " << iz
161 << G4endl; 156 << G4endl;
162 G4bool b; 157 G4bool b;
163 G4double A = elm->GetN(); 158 G4double A = elm->GetN();
164 G4double ptot = dp->GetTotalMomentum(); 159 G4double ptot = dp->GetTotalMomentum();
165 x *= factors->GetValue(ptot, b)/G4Pow::GetIn << 160 x *= factors->GetValue(ptot, b)/std::pow(A, 0.42);
166 if(theParticle == thePiPlus || theParticle = 161 if(theParticle == thePiPlus || theParticle == theProton ||
167 theParticle == theKPlus || theParticle = 162 theParticle == theKPlus || theParticle == theANeutron)
168 { x *= (1.0 - Z/A); } 163 { x *= (1.0 - Z/A); }
169 164
170 else if(theParticle == thePiMinus || thePart 165 else if(theParticle == thePiMinus || theParticle == theNeutron ||
171 theParticle == theKMinus || thePart 166 theParticle == theKMinus || theParticle == theAProton)
172 { x *= Z/A; } 167 { x *= Z/A; }
173 168
174 if(theParticle->GetPDGMass() < GeV) { 169 if(theParticle->GetPDGMass() < GeV) {
175 if(ptot > 2.*GeV) x *= 4.0*GeV*GeV/(ptot*p 170 if(ptot > 2.*GeV) x *= 4.0*GeV*GeV/(ptot*ptot);
176 } 171 }
177 172
178 if(verboseLevel>1) 173 if(verboseLevel>1)
179 G4cout << "Corrected cross(mb)= " << x/mil 174 G4cout << "Corrected cross(mb)= " << x/millibarn << G4endl;
180 175
181 return x; 176 return x;
182 } 177 }
183 178
184 G4bool G4ChargeExchangeProcess:: 179 G4bool G4ChargeExchangeProcess::
185 IsApplicable(const G4ParticleDefinition& aPart 180 IsApplicable(const G4ParticleDefinition& aParticleType)
186 { 181 {
187 const G4ParticleDefinition* p = &aParticleTy 182 const G4ParticleDefinition* p = &aParticleType;
188 return (p == thePiPlus || p == thePiMinus || 183 return (p == thePiPlus || p == thePiMinus ||
189 p == theProton || p == theNeutron || 184 p == theProton || p == theNeutron ||
190 p == theAProton|| p == theANeutron|| 185 p == theAProton|| p == theANeutron||
191 p == theKPlus || p == theKMinus || 186 p == theKPlus || p == theKMinus ||
192 p == theK0S || p == theK0L || 187 p == theK0S || p == theK0L ||
193 p == theL); 188 p == theL);
194 } 189 }
195 190
196 void G4ChargeExchangeProcess:: 191 void G4ChargeExchangeProcess::
197 DumpPhysicsTable(const G4ParticleDefinition& a 192 DumpPhysicsTable(const G4ParticleDefinition& aParticleType)
198 { 193 {
199 store->DumpPhysicsTable(aParticleType); 194 store->DumpPhysicsTable(aParticleType);
200 } 195 }
201 196