Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4PhaseSpaceDecayChannel.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id$
28//
29//
30// ------------------------------------------------------------
31// GEANT 4 class header file
32//
33// History: first implementation, based on object model of
34// 27 July 1996 H.Kurashige
35// 20 Oct 1996 H.Kurashige
36// 30 May 1997 H.Kurashige
37// ------------------------------------------------------------
38
39#include "G4ParticleDefinition.hh"
40#include "G4PhysicalConstants.hh"
41#include "G4SystemOfUnits.hh"
42#include "G4DecayProducts.hh"
43#include "G4VDecayChannel.hh"
44#include "G4PhaseSpaceDecayChannel.hh"
45#include "Randomize.hh"
46#include "G4LorentzVector.hh"
47#include "G4LorentzRotation.hh"
48
49
50G4PhaseSpaceDecayChannel::G4PhaseSpaceDecayChannel(G4int Verbose)
51 :G4VDecayChannel("Phase Space", Verbose)
52{
53
54}
55
56G4PhaseSpaceDecayChannel::G4PhaseSpaceDecayChannel(
57 const G4String& theParentName,
58 G4double theBR,
59 G4int theNumberOfDaughters,
60 const G4String& theDaughterName1,
61 const G4String& theDaughterName2,
62 const G4String& theDaughterName3,
63 const G4String& theDaughterName4 )
64 :G4VDecayChannel("Phase Space",
65 theParentName,theBR,
66 theNumberOfDaughters,
67 theDaughterName1,
68 theDaughterName2,
69 theDaughterName3,
70 theDaughterName4),
71 current_parent_mass(0.0)
72{
73
74}
75
76G4PhaseSpaceDecayChannel::~G4PhaseSpaceDecayChannel()
77{
78}
79
80G4DecayProducts *G4PhaseSpaceDecayChannel::DecayIt(G4double parentMass)
81{
82#ifdef G4VERBOSE
83 if (GetVerboseLevel()>1) G4cout << "G4PhaseSpaceDecayChannel::DecayIt ";
84#endif
85
86 G4DecayProducts * products = 0;
87
88 if (parent == 0) FillParent();
89 if (daughters == 0) FillDaughters();
90
91 if (parentMass >0.0) current_parent_mass = parentMass;
92 else current_parent_mass = parent_mass;
93
94 switch (numberOfDaughters){
95 case 0:
96#ifdef G4VERBOSE
97 if (GetVerboseLevel()>0) {
98 G4cout << "G4PhaseSpaceDecayChannel::DecayIt ";
99 G4cout << " daughters not defined " <<G4endl;
100 }
101#endif
102 break;
103 case 1:
104 products = OneBodyDecayIt();
105 break;
106 case 2:
107 products = TwoBodyDecayIt();
108 break;
109 case 3:
110 products = ThreeBodyDecayIt();
111 break;
112 default:
113 products = ManyBodyDecayIt();
114 break;
115 }
116#ifdef G4VERBOSE
117 if ((products == 0) && (GetVerboseLevel()>0)) {
118 G4cout << "G4PhaseSpaceDecayChannel::DecayIt ";
119 G4cout << *parent_name << " can not decay " << G4endl;
120 DumpInfo();
121 }
122#endif
123 return products;
124}
125
126G4DecayProducts *G4PhaseSpaceDecayChannel::OneBodyDecayIt()
127{
128#ifdef G4VERBOSE
129 if (GetVerboseLevel()>1) G4cout << "G4PhaseSpaceDecayChannel::OneBodyDecayIt()"<<G4endl;
130#endif
131
132 //create parent G4DynamicParticle at rest
133 G4ThreeVector dummy;
134 G4DynamicParticle * parentparticle = new G4DynamicParticle( parent, dummy, 0.0);
135 //create G4Decayproducts
136 G4DecayProducts *products = new G4DecayProducts(*parentparticle);
137 delete parentparticle;
138
139 //create daughter G4DynamicParticle at rest
140 G4DynamicParticle * daughterparticle = new G4DynamicParticle( daughters[0], dummy, 0.0);
141 products->PushProducts(daughterparticle);
142
143#ifdef G4VERBOSE
144 if (GetVerboseLevel()>1) {
145 G4cout << "G4PhaseSpaceDecayChannel::OneBodyDecayIt ";
146 G4cout << " create decay products in rest frame " <<G4endl;
147 products->DumpInfo();
148 }
149#endif
150 return products;
151}
152
153G4DecayProducts *G4PhaseSpaceDecayChannel::TwoBodyDecayIt()
154{
155#ifdef G4VERBOSE
156 if (GetVerboseLevel()>1) G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt()"<<G4endl;
157#endif
158 // parent mass
159 G4double parentmass = current_parent_mass;
160
161 //daughters'mass
162 G4double daughtermass[2];
163 G4double daughtermomentum;
164 daughtermass[0] = daughters_mass[0];
165 daughtermass[1] = daughters_mass[1];
166
167 //create parent G4DynamicParticle at rest
168 G4ThreeVector dummy;
169 G4DynamicParticle * parentparticle = new G4DynamicParticle( parent, dummy, 0.0);
170 //create G4Decayproducts
171 G4DecayProducts *products = new G4DecayProducts(*parentparticle);
172 delete parentparticle;
173
174 //calculate daughter momentum
175 daughtermomentum = Pmx(parentmass,daughtermass[0],daughtermass[1]);
176 if (daughtermomentum <0.0) {
177#ifdef G4VERBOSE
178 if (GetVerboseLevel()>0) {
179 G4cerr << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt "
180 << "sum of daughter mass is larger than parent mass" << G4endl;
181 G4cerr << "parent :" << parent->GetParticleName() << " " << current_parent_mass/GeV << G4endl;
182 G4cerr << "daughter 1 :" << daughters[0]->GetParticleName() << " " << daughtermass[0]/GeV << G4endl;
183 G4cerr << "daughter 2:" << daughters[1]->GetParticleName() << " " << daughtermass[1]/GeV << G4endl;
184 }
185#endif
186 G4Exception("G4PhaseSpaceDecayChannel::TwoBodyDecayIt",
187 "PART112", JustWarning,
188 "Can not create decay products: sum of daughter mass is larger than parent mass");
189 return products;
190 }
191
192 G4double costheta = 2.*G4UniformRand()-1.0;
193 G4double sintheta = std::sqrt((1.0 - costheta)*(1.0 + costheta));
194 G4double phi = twopi*G4UniformRand()*rad;
195 G4ThreeVector direction(sintheta*std::cos(phi),sintheta*std::sin(phi),costheta);
196
197 //create daughter G4DynamicParticle
198 G4DynamicParticle * daughterparticle = new G4DynamicParticle( daughters[0], direction*daughtermomentum);
199 products->PushProducts(daughterparticle);
200 daughterparticle = new G4DynamicParticle( daughters[1], direction*(-1.0*daughtermomentum));
201 products->PushProducts(daughterparticle);
202
203#ifdef G4VERBOSE
204 if (GetVerboseLevel()>1) {
205 G4cout << "G4PhaseSpaceDecayChannel::TwoBodyDecayIt ";
206 G4cout << " create decay products in rest frame " <<G4endl;
207 products->DumpInfo();
208 }
209#endif
210 return products;
211}
212
213G4DecayProducts *G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()
214// algorism of this code is originally written in GDECA3 of GEANT3
215{
216#ifdef G4VERBOSE
217 if (GetVerboseLevel()>1) G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt()"<<G4endl;
218#endif
219 // parent mass
220 G4double parentmass = current_parent_mass;
221 //daughters'mass
222 G4double daughtermass[3];
223 G4double sumofdaughtermass = 0.0;
224 for (G4int index=0; index<3; index++){
225 daughtermass[index] = daughters_mass[index];
226 sumofdaughtermass += daughtermass[index];
227 }
228
229 //create parent G4DynamicParticle at rest
230 G4ThreeVector dummy;
231 G4DynamicParticle * parentparticle = new G4DynamicParticle( parent, dummy, 0.0);
232
233
234 //create G4Decayproducts
235 G4DecayProducts *products = new G4DecayProducts(*parentparticle);
236 delete parentparticle;
237
238 if (sumofdaughtermass >parentmass) {
239#ifdef G4VERBOSE
240 if (GetVerboseLevel()>0) {
241 G4cerr << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt "
242 << "sum of daughter mass is larger than parent mass" << G4endl;
243 G4cerr << "parent :" << parent->GetParticleName() << " " << current_parent_mass/GeV << G4endl;
244 G4cerr << "daughter 1 :" << daughters[0]->GetParticleName() << " " << daughtermass[0]/GeV << G4endl;
245 G4cerr << "daughter 2:" << daughters[1]->GetParticleName() << " " << daughtermass[1]/GeV << G4endl;
246 G4cerr << "daughter 3:" << daughters[2]->GetParticleName() << " " << daughtermass[2]/GeV << G4endl;
247 }
248#endif
249 G4Exception("G4PhaseSpaceDecayChannel::ThreeBodyDecayIt",
250 "PART112", JustWarning,
251 "Can not create decay products: sum of daughter mass is larger than parent mass");
252 return products;
253 }
254
255
256
257 //calculate daughter momentum
258 // Generate two
259 G4double rd1, rd2, rd;
260 G4double daughtermomentum[3];
261 G4double momentummax=0.0, momentumsum = 0.0;
262 G4double energy;
263
264 do {
265 rd1 = G4UniformRand();
266 rd2 = G4UniformRand();
267 if (rd2 > rd1) {
268 rd = rd1;
269 rd1 = rd2;
270 rd2 = rd;
271 }
272 momentummax = 0.0;
273 momentumsum = 0.0;
274 // daughter 0
275 energy = rd2*(parentmass - sumofdaughtermass);
276 daughtermomentum[0] = std::sqrt(energy*energy + 2.0*energy* daughtermass[0]);
277 if ( daughtermomentum[0] >momentummax )momentummax = daughtermomentum[0];
278 momentumsum += daughtermomentum[0];
279 // daughter 1
280 energy = (1.-rd1)*(parentmass - sumofdaughtermass);
281 daughtermomentum[1] = std::sqrt(energy*energy + 2.0*energy* daughtermass[1]);
282 if ( daughtermomentum[1] >momentummax )momentummax = daughtermomentum[1];
283 momentumsum += daughtermomentum[1];
284 // daughter 2
285 energy = (rd1-rd2)*(parentmass - sumofdaughtermass);
286 daughtermomentum[2] = std::sqrt(energy*energy + 2.0*energy* daughtermass[2]);
287 if ( daughtermomentum[2] >momentummax )momentummax = daughtermomentum[2];
288 momentumsum += daughtermomentum[2];
289 } while (momentummax > momentumsum - momentummax );
290 // output message
291#ifdef G4VERBOSE
292 if (GetVerboseLevel()>1) {
293 G4cout << " daughter 0:" << daughtermomentum[0]/GeV << "[GeV/c]" <<G4endl;
294 G4cout << " daughter 1:" << daughtermomentum[1]/GeV << "[GeV/c]" <<G4endl;
295 G4cout << " daughter 2:" << daughtermomentum[2]/GeV << "[GeV/c]" <<G4endl;
296 G4cout << " momentum sum:" << momentumsum/GeV << "[GeV/c]" <<G4endl;
297 }
298#endif
299
300 //create daughter G4DynamicParticle
301 G4double costheta, sintheta, phi, sinphi, cosphi;
302 G4double costhetan, sinthetan, phin, sinphin, cosphin;
303 costheta = 2.*G4UniformRand()-1.0;
304 sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
305 phi = twopi*G4UniformRand()*rad;
306 sinphi = std::sin(phi);
307 cosphi = std::cos(phi);
308 G4ThreeVector direction0(sintheta*cosphi,sintheta*sinphi,costheta);
309 G4DynamicParticle * daughterparticle
310 = new G4DynamicParticle( daughters[0], direction0*daughtermomentum[0]);
311 products->PushProducts(daughterparticle);
312
313 costhetan = (daughtermomentum[1]*daughtermomentum[1]-daughtermomentum[2]*daughtermomentum[2]-daughtermomentum[0]*daughtermomentum[0])/(2.0*daughtermomentum[2]*daughtermomentum[0]);
314 sinthetan = std::sqrt((1.0-costhetan)*(1.0+costhetan));
315 phin = twopi*G4UniformRand()*rad;
316 sinphin = std::sin(phin);
317 cosphin = std::cos(phin);
318 G4ThreeVector direction2;
319 direction2.setX( sinthetan*cosphin*costheta*cosphi - sinthetan*sinphin*sinphi + costhetan*sintheta*cosphi);
320 direction2.setY( sinthetan*cosphin*costheta*sinphi + sinthetan*sinphin*cosphi + costhetan*sintheta*sinphi);
321 direction2.setZ( -sinthetan*cosphin*sintheta + costhetan*costheta);
322 daughterparticle = new G4DynamicParticle( daughters[2], direction2*(daughtermomentum[2]/direction2.mag()));
323 products->PushProducts(daughterparticle);
324
325 daughterparticle =
326 new G4DynamicParticle(
327 daughters[1],
328 (direction0*daughtermomentum[0] + direction2*(daughtermomentum[2]/direction2.mag()))*(-1.0)
329 );
330 products->PushProducts(daughterparticle);
331
332#ifdef G4VERBOSE
333 if (GetVerboseLevel()>1) {
334 G4cout << "G4PhaseSpaceDecayChannel::ThreeBodyDecayIt ";
335 G4cout << " create decay products in rest frame " <<G4endl;
336 products->DumpInfo();
337 }
338#endif
339 return products;
340}
341
342G4DecayProducts *G4PhaseSpaceDecayChannel::ManyBodyDecayIt()
343// algorithm of this code is originally written in FORTRAN by M.Asai
344//******************************************************************
345// NBODY
346// N-body phase space Monte-Carlo generator
347// Makoto Asai
348// Hiroshima Institute of Technology
349// ([email protected])
350// Revised release : 19/Apr/1995
351//
352{
353 G4int index, index2;
354
355 //return value
356 G4DecayProducts *products;
357
358#ifdef G4VERBOSE
359 if (GetVerboseLevel()>1) G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt()"<<G4endl;
360#endif
361 // parent mass
362 G4double parentmass = current_parent_mass;
363 //daughters'mass
364 G4double *daughtermass = new G4double[numberOfDaughters];
365 G4double sumofdaughtermass = 0.0;
366 for (index=0; index<numberOfDaughters; index++){
367 daughtermass[index] = daughters_mass[index];
368 sumofdaughtermass += daughtermass[index];
369 }
370
371 //Calculate daughter momentum
372 G4double *daughtermomentum = new G4double[numberOfDaughters];
373 G4ThreeVector direction;
374 G4DynamicParticle **daughterparticle;
375 G4double *sm = new G4double[numberOfDaughters];
376 G4double tmas;
377 G4double weight = 1.0;
378 G4int numberOfTry = 0;
379
380 do {
381 //Generate rundom number in descending order
382 G4double temp;
383 G4double *rd = new G4double[numberOfDaughters];
384 rd[0] = 1.0;
385 for(index =1; index < numberOfDaughters -1; index++) rd[index] = G4UniformRand();
386 rd[ numberOfDaughters -1] = 0.0;
387 for(index =1; index < numberOfDaughters -1; index++) {
388 for(index2 = index+1; index2 < numberOfDaughters; index2++) {
389 if (rd[index] < rd[index2]){
390 temp = rd[index];
391 rd[index] = rd[index2];
392 rd[index2] = temp;
393 }
394 }
395 }
396
397 //calcurate virtual mass
398 tmas = parentmass - sumofdaughtermass;
399 temp = sumofdaughtermass;
400 for(index =0; index < numberOfDaughters; index++) {
401 sm[index] = rd[index]*tmas + temp;
402 temp -= daughtermass[index];
403 if (GetVerboseLevel()>1) {
404 G4cout << index << " rundom number:" << rd[index];
405 G4cout << " virtual mass:" << sm[index]/GeV << "[GeV/c/c]" <<G4endl;
406 }
407 }
408 delete [] rd;
409
410 //Calculate daughter momentum
411 weight = 1.0;
412 index =numberOfDaughters-1;
413 daughtermomentum[index]= Pmx( sm[index-1],daughtermass[index-1], sm[index]);
414#ifdef G4VERBOSE
415 if (GetVerboseLevel()>1) {
416 G4cout << " daughter " << index << ":" << *daughters_name[index];
417 G4cout << " momentum:" << daughtermomentum[index]/GeV << "[GeV/c]" <<G4endl;
418 }
419#endif
420 for(index =numberOfDaughters-2; index>=0; index--) {
421 // calculate
422 daughtermomentum[index]= Pmx( sm[index],daughtermass[index], sm[index +1]);
423 if(daughtermomentum[index] < 0.0) {
424 // !!! illegal momentum !!!
425#ifdef G4VERBOSE
426 if (GetVerboseLevel()>0) {
427 G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt ";
428 G4cout << " can not calculate daughter momentum " <<G4endl;
429 G4cout << " parent:" << *parent_name;
430 G4cout << " mass:" << parentmass/GeV << "[GeV/c/c]" <<G4endl;
431 G4cout << " daughter " << index << ":" << *daughters_name[index];
432 G4cout << " mass:" << daughtermass[index]/GeV << "[GeV/c/c]" ;
433 G4cout << " mass:" << daughtermomentum[index]/GeV << "[GeV/c]" <<G4endl;
434 }
435#endif
436 delete [] sm;
437 delete [] daughtermass;
438 delete [] daughtermomentum;
439
440 G4Exception("G4PhaseSpaceDecayChannel::ManyBodyDecayIt",
441 "PART112", JustWarning,
442 "Can not create decay products: sum of daughter mass is larger than parent mass");
443
444 return 0; // Error detection
445
446 } else {
447 // calculate weight of this events
448 weight *= daughtermomentum[index]/sm[index];
449#ifdef G4VERBOSE
450 if (GetVerboseLevel()>1) {
451 G4cout << " daughter " << index << ":" << *daughters_name[index];
452 G4cout << " momentum:" << daughtermomentum[index]/GeV << "[GeV/c]" <<G4endl;
453 }
454#endif
455 }
456 }
457
458#ifdef G4VERBOSE
459 if (GetVerboseLevel()>1) {
460 G4cout << " weight: " << weight <<G4endl;
461 }
462#endif
463
464 // exit if number of Try exceeds 100
465 if (numberOfTry++ >100) {
466#ifdef G4VERBOSE
467 if (GetVerboseLevel()>0) {
468 G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt: ";
469 G4cout << " can not determine Decay Kinematics " << G4endl;
470 G4cout << "parent : " << *parent_name << G4endl;
471 G4cout << "daughters : ";
472 for(index=0; index<numberOfDaughters; index++) {
473 G4cout << *daughters_name[index] << " , ";
474 }
475 G4cout << G4endl;
476 }
477#endif
478 G4Exception("G4PhaseSpaceDecayChannel::ManyBodyDecayIt: ",
479 "PART113", JustWarning,
480 " Cannot decay : Decay Kinematics cannot be calculated ");
481
482 delete [] sm;
483 delete [] daughtermass;
484 delete [] daughtermomentum;
485 return 0; // Error detection
486 }
487 } while ( weight > G4UniformRand());
488
489#ifdef G4VERBOSE
490 if (GetVerboseLevel()>1) {
491 G4cout << "Start calulation of daughters momentum vector "<<G4endl;
492 }
493#endif
494
495 G4double costheta, sintheta, phi;
496 G4double beta;
497 daughterparticle = new G4DynamicParticle*[numberOfDaughters];
498
499 index = numberOfDaughters -2;
500 costheta = 2.*G4UniformRand()-1.0;
501 sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
502 phi = twopi*G4UniformRand()*rad;
503 direction.setZ(costheta);
504 direction.setY(sintheta*std::sin(phi));
505 direction.setX(sintheta*std::cos(phi));
506 daughterparticle[index] = new G4DynamicParticle( daughters[index], direction*daughtermomentum[index] );
507 daughterparticle[index+1] = new G4DynamicParticle( daughters[index+1], direction*(-1.0*daughtermomentum[index]) );
508
509 for (index = numberOfDaughters -3; index >= 0; index--) {
510 //calculate momentum direction
511 costheta = 2.*G4UniformRand()-1.0;
512 sintheta = std::sqrt((1.0-costheta)*(1.0+costheta));
513 phi = twopi*G4UniformRand()*rad;
514 direction.setZ(costheta);
515 direction.setY(sintheta*std::sin(phi));
516 direction.setX(sintheta*std::cos(phi));
517
518 // boost already created particles
519 beta = daughtermomentum[index];
520 beta /= std::sqrt( daughtermomentum[index]*daughtermomentum[index] + sm[index+1]*sm[index+1] );
521 for (index2 = index+1; index2<numberOfDaughters; index2++) {
522 G4LorentzVector p4;
523 // make G4LorentzVector for secondaries
524 p4 = daughterparticle[index2]->Get4Momentum();
525
526 // boost secondaries to new frame
527 p4.boost( direction.x()*beta, direction.y()*beta, direction.z()*beta);
528
529 // change energy/momentum
530 daughterparticle[index2]->Set4Momentum(p4);
531 }
532 //create daughter G4DynamicParticle
533 daughterparticle[index]= new G4DynamicParticle( daughters[index], direction*(-1.0*daughtermomentum[index]));
534 }
535
536 //create G4Decayproducts
537 G4DynamicParticle *parentparticle;
538 direction.setX(1.0); direction.setY(0.0); direction.setZ(0.0);
539 parentparticle = new G4DynamicParticle( parent, direction, 0.0);
540 products = new G4DecayProducts(*parentparticle);
541 delete parentparticle;
542 for (index = 0; index<numberOfDaughters; index++) {
543 products->PushProducts(daughterparticle[index]);
544 }
545
546#ifdef G4VERBOSE
547 if (GetVerboseLevel()>1) {
548 G4cout << "G4PhaseSpaceDecayChannel::ManyBodyDecayIt ";
549 G4cout << " create decay products in rest frame " << G4endl;
550 products->DumpInfo();
551 }
552#endif
553
554 delete [] daughterparticle;
555 delete [] daughtermomentum;
556 delete [] daughtermass;
557 delete [] sm;
558
559 return products;
560}
561
562
563G4double G4PhaseSpaceDecayChannel::Pmx(G4double e, G4double p1, G4double p2)
564{
565 // calcurate momentum of daughter particles in two-body decay
566 G4double ppp = (e+p1+p2)*(e+p1-p2)*(e-p1+p2)*(e-p1-p2)/(4.0*e*e);
567 if (ppp>0) return std::sqrt(ppp);
568 else return -1.;
569}
570
571
572
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:64
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4cout
G4DLLIMPORT std::ostream G4cout
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:53
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::setY
void setY(double)
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::setZ
void setZ(double)
CLHEP::Hep3Vector::mag
double mag() const
CLHEP::Hep3Vector::setX
void setX(double)
CLHEP::HepLorentzVector::boost
HepLorentzVector & boost(double, double, double)
Definition: LorentzVector.cc:59
G4DecayProducts::DumpInfo
void DumpInfo() const
Definition: G4DecayProducts.cc:311
G4DecayProducts::PushProducts
G4int PushProducts(G4DynamicParticle *aParticle)
Definition: G4DecayProducts.cc:153
G4DynamicParticle::Get4Momentum
G4LorentzVector Get4Momentum() const
G4DynamicParticle::Set4Momentum
void Set4Momentum(const G4LorentzVector &momentum)
Definition: G4DynamicParticle.cc:351
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:115
G4PhaseSpaceDecayChannel::Pmx
static G4double Pmx(G4double e, G4double p1, G4double p2)
Definition: G4PhaseSpaceDecayChannel.cc:563
G4PhaseSpaceDecayChannel::DecayIt
virtual G4DecayProducts * DecayIt(G4double)
Definition: G4PhaseSpaceDecayChannel.cc:80
G4VDecayChannel::parent_name
G4String * parent_name
Definition: G4VDecayChannel.hh:133
G4VDecayChannel::daughters_name
G4String ** daughters_name
Definition: G4VDecayChannel.hh:135
G4VDecayChannel::GetVerboseLevel
G4int GetVerboseLevel() const
Definition: G4VDecayChannel.hh:276
G4VDecayChannel::daughters_mass
G4double * daughters_mass
Definition: G4VDecayChannel.hh:151
G4VDecayChannel::parent
G4ParticleDefinition * parent
Definition: G4VDecayChannel.hh:146
G4VDecayChannel::daughters
G4ParticleDefinition ** daughters
Definition: G4VDecayChannel.hh:147
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41