| 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 // $Id: $
26 // 27 //
27 // Author: D.H. Wright 28 // Author: D.H. Wright
28 // Date: 2 February 2011 29 // Date: 2 February 2011
29 // 30 //
30 // Description: model of muon nuclear interact 31 // Description: model of muon nuclear interaction in which a gamma from
31 // the virtual photon spectrum in 32 // the virtual photon spectrum interacts in the nucleus as
32 // a real gamma at low energies a 33 // a real gamma at low energies and as a pi0 at high energies.
33 // Kokoulin's muon cross section 34 // Kokoulin's muon cross section and equivalent gamma spectrum
34 // are used. 35 // are used.
35 // 36 //
36 37
37 #include "G4MuonVDNuclearModel.hh" 38 #include "G4MuonVDNuclearModel.hh"
38 39
39 #include "Randomize.hh" 40 #include "Randomize.hh"
40 #include "G4Log.hh" <<
41 #include "G4PhysicalConstants.hh" 41 #include "G4PhysicalConstants.hh"
42 #include "G4SystemOfUnits.hh" 42 #include "G4SystemOfUnits.hh"
43 #include "G4CascadeInterface.hh" 43 #include "G4CascadeInterface.hh"
44 #include "G4TheoFSGenerator.hh" 44 #include "G4TheoFSGenerator.hh"
45 #include "G4GeneratorPrecompoundInterface.hh" 45 #include "G4GeneratorPrecompoundInterface.hh"
>> 46 #include "G4ExcitationHandler.hh"
46 #include "G4PreCompoundModel.hh" 47 #include "G4PreCompoundModel.hh"
47 #include "G4LundStringFragmentation.hh" 48 #include "G4LundStringFragmentation.hh"
48 #include "G4ExcitedStringDecay.hh" 49 #include "G4ExcitedStringDecay.hh"
49 #include "G4FTFModel.hh" 50 #include "G4FTFModel.hh"
50 #include "G4HadronicInteractionRegistry.hh" 51 #include "G4HadronicInteractionRegistry.hh"
51 #include "G4KokoulinMuonNuclearXS.hh" <<
52 #include "G4CrossSectionDataSetRegistry.hh" <<
53 #include "G4ElementData.hh" <<
54 #include "G4Physics2DVector.hh" <<
55 #include "G4Pow.hh" <<
56 #include "G4PhysicsModelCatalog.hh" <<
57 <<
58 const G4int G4MuonVDNuclearModel::zdat[] = {1, <<
59 const G4double G4MuonVDNuclearModel::adat[] = <<
60 const G4double G4MuonVDNuclearModel::tdat[] = <<
61 1.e3,2.e3,3.e3,4.e3,5.e3,6.e3,7.e3,8.e3,9.e3 <<
62 1.e4,2.e4,3.e4,4.e4,5.e4,6.e4,7.e4,8.e4,9.e4 <<
63 1.e5,2.e5,3.e5,4.e5,5.e5,6.e5,7.e5,8.e5,9.e5 <<
64 1.e6,2.e6,3.e6,4.e6,5.e6,6.e6,7.e6,8.e6,9.e6 <<
65 1.e7,2.e7,3.e7,4.e7,5.e7,6.e7,7.e7,8.e7,9.e7 <<
66 1.e8,2.e8,3.e8,4.e8,5.e8,6.e8,7.e8,8.e8,9.e8 <<
67 1.e9,2.e9,3.e9,4.e9,5.e9,6.e9,7.e9,8.e9,9.e9 <<
68 1.e10,2.e10,3.e10,4.e10,5.e10,6.e10,7.e10,8. <<
69 <<
70 G4ElementData* G4MuonVDNuclearModel::fElementD <<
71 52
72 G4MuonVDNuclearModel::G4MuonVDNuclearModel() 53 G4MuonVDNuclearModel::G4MuonVDNuclearModel()
73 : G4HadronicInteraction("G4MuonVDNuclearMode << 54 : G4HadronicInteraction("G4MuonVDNuclearModel")
74 { 55 {
75 muNucXS = (G4KokoulinMuonNuclearXS*)G4CrossS <<
76 GetCrossSectionDataSet(G4KokoulinMuonNucle <<
77 <<
78 SetMinEnergy(0.0); 56 SetMinEnergy(0.0);
79 SetMaxEnergy(1*CLHEP::PeV); << 57 SetMaxEnergy(1*PeV);
80 CutFixed = 0.2*CLHEP::GeV; << 58 CutFixed = 0.2*GeV;
81 << 59 NBIN = 1000;
82 if (nullptr == fElementData) { << 60
83 fElementData = new G4ElementData(93); << 61 for (G4int k = 0; k < 5; k++) {
84 MakeSamplingTable(); << 62 for (G4int j = 0; j < 8; j++) {
>> 63 for (G4int i = 0; i < 1001; i++) {
>> 64 proba[k][j][i] = 0.0;
>> 65 ya[i] = 0.0;
>> 66 }
>> 67 }
85 } 68 }
86 << 69
>> 70 MakeSamplingTable();
>> 71
87 // reuse existing pre-compound model 72 // reuse existing pre-compound model
88 G4GeneratorPrecompoundInterface* precoInterf 73 G4GeneratorPrecompoundInterface* precoInterface
89 = new G4GeneratorPrecompoundInterface(); 74 = new G4GeneratorPrecompoundInterface();
90 G4HadronicInteraction* p = 75 G4HadronicInteraction* p =
91 G4HadronicInteractionRegistry::Instance()- 76 G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
92 G4VPreCompoundModel* pre = static_cast<G4VPr 77 G4VPreCompoundModel* pre = static_cast<G4VPreCompoundModel*>(p);
93 if(nullptr == pre) { pre = new G4PreCompound << 78 if(!pre) { pre = new G4PreCompoundModel(); }
94 precoInterface->SetDeExcitation(pre); 79 precoInterface->SetDeExcitation(pre);
95 80
96 // Build FTFP model 81 // Build FTFP model
97 ftfp = new G4TheoFSGenerator(); 82 ftfp = new G4TheoFSGenerator();
98 ftfp->SetTransport(precoInterface); 83 ftfp->SetTransport(precoInterface);
99 theFragmentation = new G4LundStringFragmenta 84 theFragmentation = new G4LundStringFragmentation();
100 theStringDecay = new G4ExcitedStringDecay(th 85 theStringDecay = new G4ExcitedStringDecay(theFragmentation);
101 G4FTFModel* theStringModel = new G4FTFModel; 86 G4FTFModel* theStringModel = new G4FTFModel;
102 theStringModel->SetFragmentationModel(theStr 87 theStringModel->SetFragmentationModel(theStringDecay);
103 ftfp->SetHighEnergyGenerator(theStringModel) 88 ftfp->SetHighEnergyGenerator(theStringModel);
104 89
105 // Build Bertini cascade 90 // Build Bertini cascade
106 bert = new G4CascadeInterface(); 91 bert = new G4CascadeInterface();
107 <<
108 // Creator model ID <<
109 secID = G4PhysicsModelCatalog::GetModelID( " <<
110 } 92 }
111 93
>> 94
112 G4MuonVDNuclearModel::~G4MuonVDNuclearModel() 95 G4MuonVDNuclearModel::~G4MuonVDNuclearModel()
113 { 96 {
114 delete theFragmentation; 97 delete theFragmentation;
115 delete theStringDecay; 98 delete theStringDecay;
116 } 99 }
>> 100
117 101
118 G4HadFinalState* 102 G4HadFinalState*
119 G4MuonVDNuclearModel::ApplyYourself(const G4Ha 103 G4MuonVDNuclearModel::ApplyYourself(const G4HadProjectile& aTrack,
120 G4Nucleus& 104 G4Nucleus& targetNucleus)
121 { 105 {
122 theParticleChange.Clear(); 106 theParticleChange.Clear();
123 107
124 // For very low energy, return initial track 108 // For very low energy, return initial track
125 G4double epmax = aTrack.GetTotalEnergy() - 0 109 G4double epmax = aTrack.GetTotalEnergy() - 0.5*proton_mass_c2;
126 if (epmax <= CutFixed) { 110 if (epmax <= CutFixed) {
127 theParticleChange.SetStatusChange(isAlive) 111 theParticleChange.SetStatusChange(isAlive);
128 theParticleChange.SetEnergyChange(aTrack.G 112 theParticleChange.SetEnergyChange(aTrack.GetKineticEnergy());
129 theParticleChange.SetMomentumChange(aTrack 113 theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
130 return &theParticleChange; 114 return &theParticleChange;
131 } 115 }
132 116
133 // Produce recoil muon and transferred photo 117 // Produce recoil muon and transferred photon
134 G4DynamicParticle* transferredPhoton = Calcu 118 G4DynamicParticle* transferredPhoton = CalculateEMVertex(aTrack, targetNucleus);
135 119
136 // Interact the gamma with the nucleus 120 // Interact the gamma with the nucleus
137 CalculateHadronicVertex(transferredPhoton, t 121 CalculateHadronicVertex(transferredPhoton, targetNucleus);
138 return &theParticleChange; 122 return &theParticleChange;
139 } 123 }
140 124
>> 125
141 G4DynamicParticle* 126 G4DynamicParticle*
142 G4MuonVDNuclearModel::CalculateEMVertex(const 127 G4MuonVDNuclearModel::CalculateEMVertex(const G4HadProjectile& aTrack,
143 G4Nucl 128 G4Nucleus& targetNucleus)
144 { 129 {
145 // Select sampling table 130 // Select sampling table
146 G4double KineticEnergy = aTrack.GetKineticEn 131 G4double KineticEnergy = aTrack.GetKineticEnergy();
147 G4double TotalEnergy = aTrack.GetTotalEnergy 132 G4double TotalEnergy = aTrack.GetTotalEnergy();
148 G4double Mass = G4MuonMinus::MuonMinus()->Ge 133 G4double Mass = G4MuonMinus::MuonMinus()->GetPDGMass();
149 G4Pow* g4calc = G4Pow::GetInstance(); << 134 G4double lnZ = std::log(G4double(targetNucleus.GetZ_asInt() ) );
150 G4double lnZ = g4calc->logZ(targetNucleus.Ge <<
151 135
152 G4double epmin = CutFixed; 136 G4double epmin = CutFixed;
153 G4double epmax = TotalEnergy - 0.5*proton_ma 137 G4double epmax = TotalEnergy - 0.5*proton_mass_c2;
154 G4double m0 = CutFixed; << 138 G4double m0 = 0.2*GeV;
155 139
156 G4double delmin = 1.e10; 140 G4double delmin = 1.e10;
157 G4double del; 141 G4double del;
158 G4int izz = 0; 142 G4int izz = 0;
159 G4int itt = 0; 143 G4int itt = 0;
>> 144 G4int NBINminus1 = NBIN - 1;
160 145
161 for (G4int iz = 0; iz < nzdat; ++iz) { << 146 G4int nzdat = 5;
162 del = std::abs(lnZ - g4calc->logZ(zdat[iz] << 147 G4double zdat[] = {1.,4.,13.,29.,92.};
>> 148 for (G4int iz = 0; iz < nzdat; iz++) {
>> 149 del = std::abs(lnZ-std::log(zdat[iz]));
163 if (del < delmin) { 150 if (del < delmin) {
164 delmin = del; 151 delmin = del;
165 izz = iz; 152 izz = iz;
166 } 153 }
167 } 154 }
168 155
>> 156 G4int ntdat = 8;
>> 157 G4double tdat[] = {1.e3,1.e4,1.e5,1.e6,1.e7,1.e8,1.e9,1.e10};
169 delmin = 1.e10; 158 delmin = 1.e10;
170 for (G4int it = 0; it < ntdat; ++it) { << 159 for (G4int it = 0; it < ntdat; it++) {
171 del = std::abs(G4Log(KineticEnergy)-G4Log( << 160 del = std::abs(std::log(KineticEnergy)-std::log(tdat[it]) );
172 if (del < delmin) { 161 if (del < delmin) {
173 delmin = del; 162 delmin = del;
174 itt = it; 163 itt = it;
175 } 164 }
176 } 165 }
177 166
178 // Sample the energy transfer according to t 167 // Sample the energy transfer according to the probability table
179 G4double r = G4UniformRand(); 168 G4double r = G4UniformRand();
180 169
181 G4int iy; << 170 G4int iy = -1;
182 << 171 do {
183 G4int Z = zdat[izz]; << 172 iy += 1 ;
184 << 173 } while (((proba[izz][itt][iy]) < r)&&(iy < NBINminus1)) ;
185 for(iy = 0; iy<NBIN; ++iy) { <<
186 <<
187 G4double pvv = fElementData->GetElement2DD <<
188 if(pvv >= r) { break; } <<
189 } <<
190 174
191 // Sampling is done uniformly in y in the bi 175 // Sampling is done uniformly in y in the bin
192 G4double pvx = fElementData->GetElement2DDat <<
193 G4double pvx1 = fElementData->GetElement2DDa <<
194 G4double y = pvx + G4UniformRand() * (pvx1 - <<
195 176
196 G4double x = G4Exp(y); << 177 G4double y;
197 G4double ep = epmin*G4Exp(x*G4Log(epmax/epmi << 178 if (iy < NBIN)
>> 179 y = ya[iy] + G4UniformRand() * (ya[iy+1] - ya[iy]);
>> 180 else
>> 181 y = ya[iy];
>> 182
>> 183 G4double x = std::exp(y);
>> 184 G4double ep = epmin*std::exp(x*std::log(epmax/epmin) );
198 185
199 // Sample scattering angle of mu, but first 186 // Sample scattering angle of mu, but first t should be sampled.
200 G4double yy = ep/TotalEnergy; 187 G4double yy = ep/TotalEnergy;
201 G4double tmin = Mass*Mass*yy*yy/(1.-yy); 188 G4double tmin = Mass*Mass*yy*yy/(1.-yy);
202 G4double tmax = 2.*proton_mass_c2*ep; 189 G4double tmax = 2.*proton_mass_c2*ep;
203 G4double t1; 190 G4double t1;
204 G4double t2; 191 G4double t2;
205 if (m0 < ep) { 192 if (m0 < ep) {
206 t1 = m0*m0; 193 t1 = m0*m0;
207 t2 = ep*ep; 194 t2 = ep*ep;
208 } else { 195 } else {
209 t1 = ep*ep; 196 t1 = ep*ep;
210 t2 = m0*m0; 197 t2 = m0*m0;
211 } 198 }
212 199
213 G4double w1 = tmax*t1; 200 G4double w1 = tmax*t1;
214 G4double w2 = tmax+t1; 201 G4double w2 = tmax+t1;
215 G4double w3 = tmax*(tmin+t1)/(tmin*w2); 202 G4double w3 = tmax*(tmin+t1)/(tmin*w2);
216 G4double y1 = 1.-yy; 203 G4double y1 = 1.-yy;
217 G4double y2 = 0.5*yy*yy; 204 G4double y2 = 0.5*yy*yy;
218 G4double y3 = y1+y2; 205 G4double y3 = y1+y2;
219 206
220 G4double t = 0.0; << 207 G4double t;
221 G4double rej = 0.0; << 208 G4double rej;
222 209
223 // Now sample t 210 // Now sample t
224 G4int ntry = 0; << 211 G4int ntry = 0;
225 do 212 do
226 { 213 {
227 ntry += 1; 214 ntry += 1;
228 if (ntry > 10000) { << 215 t = w1/(w2*std::exp(G4UniformRand()*std::log(w3))-tmax);
229 G4ExceptionDescription eda; <<
230 eda << " While count exceeded " << G4end <<
231 G4Exception("G4MuonVDNuclearModel::Calcu <<
232 break; <<
233 } <<
234 <<
235 t = w1/(w2*G4Exp(G4UniformRand()*G4Log(w3) <<
236 rej = (1.-t/tmax)*(y1*(1.-tmin/t)+y2)/(y3* 216 rej = (1.-t/tmax)*(y1*(1.-tmin/t)+y2)/(y3*(1.-t/t2));
237 } while (G4UniformRand() > rej) ; /* Loop << 217 } while (G4UniformRand() > rej) ;
238 218
239 // compute angle from t 219 // compute angle from t
240 G4double sinth2 = 220 G4double sinth2 =
241 0.5*(t-tmin)/(2.*(TotalEnergy*(To 221 0.5*(t-tmin)/(2.*(TotalEnergy*(TotalEnergy-ep)-Mass*Mass)-tmin);
242 G4double theta = std::acos(1. - 2.*sinth2); 222 G4double theta = std::acos(1. - 2.*sinth2);
243 223
244 G4double phi = twopi*G4UniformRand(); 224 G4double phi = twopi*G4UniformRand();
245 G4double sinth = std::sin(theta); 225 G4double sinth = std::sin(theta);
246 G4double dirx = sinth*std::cos(phi); 226 G4double dirx = sinth*std::cos(phi);
247 G4double diry = sinth*std::sin(phi); 227 G4double diry = sinth*std::sin(phi);
248 G4double dirz = std::cos(theta); 228 G4double dirz = std::cos(theta);
249 G4ThreeVector finalDirection(dirx,diry,dirz) 229 G4ThreeVector finalDirection(dirx,diry,dirz);
250 G4ThreeVector ParticleDirection(aTrack.Get4M 230 G4ThreeVector ParticleDirection(aTrack.Get4Momentum().vect().unit() );
251 finalDirection.rotateUz(ParticleDirection); 231 finalDirection.rotateUz(ParticleDirection);
252 232
253 G4double NewKinEnergy = KineticEnergy - ep; 233 G4double NewKinEnergy = KineticEnergy - ep;
254 G4double finalMomentum = std::sqrt(NewKinEne 234 G4double finalMomentum = std::sqrt(NewKinEnergy*(NewKinEnergy+2.*Mass) );
255 G4double Ef = NewKinEnergy + Mass; 235 G4double Ef = NewKinEnergy + Mass;
256 G4double initMomentum = std::sqrt(KineticEne 236 G4double initMomentum = std::sqrt(KineticEnergy*(TotalEnergy+Mass) );
257 237
258 // Set energy and direction of scattered pri 238 // Set energy and direction of scattered primary in theParticleChange
259 theParticleChange.SetStatusChange(isAlive); 239 theParticleChange.SetStatusChange(isAlive);
260 theParticleChange.SetEnergyChange(NewKinEner 240 theParticleChange.SetEnergyChange(NewKinEnergy);
261 theParticleChange.SetMomentumChange(finalDir 241 theParticleChange.SetMomentumChange(finalDirection);
262 242
263 // Now create the emitted gamma 243 // Now create the emitted gamma
264 G4LorentzVector primaryMomentum(initMomentum 244 G4LorentzVector primaryMomentum(initMomentum*ParticleDirection, TotalEnergy);
265 G4LorentzVector fsMomentum(finalMomentum*fin 245 G4LorentzVector fsMomentum(finalMomentum*finalDirection, Ef);
266 G4LorentzVector momentumTransfer = primaryMo 246 G4LorentzVector momentumTransfer = primaryMomentum - fsMomentum;
267 247
268 G4DynamicParticle* gamma = 248 G4DynamicParticle* gamma =
269 new G4DynamicParticle(G4Gamma::Gamm 249 new G4DynamicParticle(G4Gamma::Gamma(), momentumTransfer);
270 250
271 return gamma; 251 return gamma;
272 } 252 }
273 253
>> 254
274 void 255 void
275 G4MuonVDNuclearModel::CalculateHadronicVertex( 256 G4MuonVDNuclearModel::CalculateHadronicVertex(G4DynamicParticle* incident,
276 257 G4Nucleus& target)
277 { 258 {
278 G4HadFinalState* hfs = 0; 259 G4HadFinalState* hfs = 0;
279 G4double gammaE = incident->GetTotalEnergy() 260 G4double gammaE = incident->GetTotalEnergy();
280 261
281 if (gammaE < 10*GeV) { 262 if (gammaE < 10*GeV) {
282 G4HadProjectile projectile(*incident); 263 G4HadProjectile projectile(*incident);
283 hfs = bert->ApplyYourself(projectile, targ 264 hfs = bert->ApplyYourself(projectile, target);
284 } else { 265 } else {
285 // convert incident gamma to a pi0 266 // convert incident gamma to a pi0
286 G4double piMass = G4PionZero::PionZero()-> 267 G4double piMass = G4PionZero::PionZero()->GetPDGMass();
287 G4double piKE = incident->GetTotalEnergy() 268 G4double piKE = incident->GetTotalEnergy() - piMass;
288 G4double piMom = std::sqrt(piKE*(piKE + 2* 269 G4double piMom = std::sqrt(piKE*(piKE + 2*piMass) );
289 G4ThreeVector piMomentum(incident->GetMome 270 G4ThreeVector piMomentum(incident->GetMomentumDirection() );
290 piMomentum *= piMom; 271 piMomentum *= piMom;
291 G4DynamicParticle theHadron(G4PionZero::Pi 272 G4DynamicParticle theHadron(G4PionZero::PionZero(), piMomentum);
292 G4HadProjectile projectile(theHadron); 273 G4HadProjectile projectile(theHadron);
293 hfs = ftfp->ApplyYourself(projectile, targ 274 hfs = ftfp->ApplyYourself(projectile, target);
294 } 275 }
295 276
296 delete incident; 277 delete incident;
297 278
298 // Assign the creator model ID to the second <<
299 for ( size_t i = 0; i < hfs->GetNumberOfSeco <<
300 hfs->GetSecondary( i )->SetCreatorModelID( <<
301 } <<
302 <<
303 // Copy secondaries from sub-model to model 279 // Copy secondaries from sub-model to model
304 theParticleChange.AddSecondaries(hfs); 280 theParticleChange.AddSecondaries(hfs);
305 } 281 }
306 282
307 283
308 void G4MuonVDNuclearModel::MakeSamplingTable() 284 void G4MuonVDNuclearModel::MakeSamplingTable()
309 { 285 {
>> 286 G4double adat[] = {1.01,9.01,26.98,63.55,238.03};
>> 287 G4double zdat[] = {1.,4.,13.,29.,92.};
>> 288 G4int nzdat = 5;
>> 289
>> 290 G4double tdat[] = {1.e3,1.e4,1.e5,1.e6,1.e7,1.e8,1.e9,1.e10};
>> 291 G4int ntdat = 8;
>> 292
310 G4int nbin; 293 G4int nbin;
311 G4double KineticEnergy; 294 G4double KineticEnergy;
312 G4double TotalEnergy; 295 G4double TotalEnergy;
313 G4double Maxep; 296 G4double Maxep;
314 G4double CrossSection; 297 G4double CrossSection;
315 298
316 G4double c; 299 G4double c;
317 G4double y; 300 G4double y;
318 G4double ymin,ymax; 301 G4double ymin,ymax;
319 G4double dy,yy; 302 G4double dy,yy;
320 G4double dx,x; 303 G4double dx,x;
321 G4double ep; 304 G4double ep;
322 305
323 G4double AtomicNumber; 306 G4double AtomicNumber;
324 G4double AtomicWeight; 307 G4double AtomicWeight;
325 <<
326 G4double mumass = G4MuonMinus::MuonMinus()-> <<
327 308
328 for (G4int iz = 0; iz < nzdat; ++iz) { << 309 for (G4int iz = 0; iz < nzdat; iz++) {
329 AtomicNumber = zdat[iz]; 310 AtomicNumber = zdat[iz];
330 AtomicWeight = adat[iz]*(g/mole); << 311 AtomicWeight = adat[iz]*(g/mole);
331 312
332 G4Physics2DVector* pv = new G4Physics2DVec << 313 for (G4int it = 0; it < ntdat; it++) {
333 G4double pvv; <<
334 <<
335 for (G4int it = 0; it < ntdat; ++it) { <<
336 KineticEnergy = tdat[it]; 314 KineticEnergy = tdat[it];
337 TotalEnergy = KineticEnergy + mumass; << 315 TotalEnergy = KineticEnergy + G4MuonMinus::MuonMinus()->GetPDGMass();
338 Maxep = TotalEnergy - 0.5*proton_mass_c2 316 Maxep = TotalEnergy - 0.5*proton_mass_c2;
339 317
340 CrossSection = 0.0; 318 CrossSection = 0.0;
341 319
342 // Calculate the differential cross sect 320 // Calculate the differential cross section
343 // numerical integration in log ........ 321 // numerical integration in log .........
344 c = G4Log(Maxep/CutFixed); << 322 c = std::log(Maxep/CutFixed);
345 ymin = -5.0; 323 ymin = -5.0;
346 ymax = 0.0; 324 ymax = 0.0;
347 dy = (ymax-ymin)/NBIN; 325 dy = (ymax-ymin)/NBIN;
348 326
349 nbin=-1; 327 nbin=-1;
350 328
351 y = ymin - 0.5*dy; 329 y = ymin - 0.5*dy;
352 yy = ymin - dy; 330 yy = ymin - dy;
353 for (G4int i = 0; i < NBIN; ++i) { << 331 for (G4int i = 0; i < NBIN; i++) {
354 y += dy; 332 y += dy;
355 x = G4Exp(y); << 333 x = std::exp(y);
356 yy += dy; 334 yy += dy;
357 dx = G4Exp(yy+dy)-G4Exp(yy); << 335 dx = std::exp(yy+dy)-std::exp(yy);
358 336
359 ep = CutFixed*G4Exp(c*x); << 337 ep = CutFixed*std::exp(c*x);
360 338
361 CrossSection += 339 CrossSection +=
362 ep*dx*muNucXS->ComputeDDMicroscopic << 340 ep*dx*muNucXS.ComputeDDMicroscopicCrossSection(KineticEnergy,
363 AtomicNumber, << 341 AtomicNumber,
364 AtomicWeight, ep); << 342 AtomicWeight, ep);
365 if (nbin < NBIN) { 343 if (nbin < NBIN) {
366 ++nbin; << 344 nbin += 1;
367 pv->PutValue(nbin, it, CrossSection) << 345 ya[nbin] = y;
368 pv->PutX(nbin, y); << 346 proba[iz][it][nbin] = CrossSection;
369 } 347 }
370 } 348 }
371 pv->PutX(NBIN, 0.); << 349 ya[NBIN] = 0.;
372 350
373 if (CrossSection > 0.0) { 351 if (CrossSection > 0.0) {
374 for (G4int ib = 0; ib <= nbin; ++ib) { << 352 for (G4int ib = 0; ib <= nbin; ib++) proba[iz][it][ib] /= CrossSection;
375 pvv = pv->GetValue(ib, it); <<
376 pvv = pvv/CrossSection; <<
377 pv->PutValue(ib, it, pvv); <<
378 } <<
379 } 353 }
380 } // loop on it 354 } // loop on it
381 <<
382 fElementData->InitialiseForElement(zdat[iz <<
383 } // loop on iz 355 } // loop on iz
384 356
385 // G4cout << " Kokoulin XS = " 357 // G4cout << " Kokoulin XS = "
386 // << muNucXS->ComputeDDMicroscopicCro << 358 // << muNucXS.ComputeDDMicroscopicCrossSection(1*GeV, 20.0, 40.0*g/mole, 0.3*GeV)/millibarn
387 // 40.0*g/mole, 0.3*GeV)/millibarn <<
388 // << G4endl; 359 // << G4endl;
389 } <<
390 <<
391 void G4MuonVDNuclearModel::ModelDescription(st <<
392 { <<
393 outFile << "G4MuonVDNuclearModel handles the <<
394 << "of mu- and mu+ from nuclei using <<
395 << "approximation in which the incom <<
396 << "virtual photon at the electromag <<
397 << "virtual photon is converted to a <<
398 << "energies, the photon interacts d <<
399 << "using the Bertini cascade. At h <<
400 << "is converted to a pi0 which inte <<
401 << "model. The muon-nuclear cross s <<
402 << "are used to generate the virtual <<
403 } 360 }
404 361
405 362