Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/particles/management/src/G4DecayProducts.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /particles/management/src/G4DecayProducts.cc (Version 11.3.0) and /particles/management/src/G4DecayProducts.cc (Version 6.2.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4DecayProducts class implementation        << 
 27 //                                                 23 //
 28 // Author: H.Kurashige, 12 July 1996           <<  24 // $Id: G4DecayProducts.cc,v 1.12 2004/06/11 14:25:27 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-06-02 $
                                                   >>  26 //
                                                   >>  27 // 
                                                   >>  28 // ------------------------------------------------------------
                                                   >>  29 //      GEANT 4 class implementation file
                                                   >>  30 //
                                                   >>  31 //      History: first implementation, based on object model of
                                                   >>  32 //      10 July 1996 H.Kurashige
                                                   >>  33 //      21 Oct  1996 H.Kurashige
                                                   >>  34 //      12 Dec 1997 H.Kurashige
 29 // -------------------------------------------     35 // ------------------------------------------------------------
 30                                                    36 
                                                   >>  37 #include "G4ios.hh"
                                                   >>  38 #include "globals.hh"
 31 #include "G4DecayProducts.hh"                      39 #include "G4DecayProducts.hh"
 32                                                    40 
 33 #include "G4LorentzRotation.hh"                << 
 34 #include "G4LorentzVector.hh"                      41 #include "G4LorentzVector.hh"
 35 #include "G4PhysicalConstants.hh"              <<  42 #include "G4LorentzRotation.hh"
 36 #include "G4SystemOfUnits.hh"                  <<  43 
 37 #include "G4ios.hh"                            <<  44 G4Allocator<G4DecayProducts> aDecayProductsAllocator;
 38 #include "globals.hh"                          <<  45 
 39                                                    46 
 40 G4DecayProducts::G4DecayProducts()                 47 G4DecayProducts::G4DecayProducts()
 41 {                                              <<  48                 :numberOfProducts(0),theParentParticle(0)
 42   theProductVector = new G4DecayProductVector( <<  49 { 
                                                   >>  50 
 43 }                                                  51 }
 44                                                    52 
 45 G4DecayProducts::G4DecayProducts(const G4Dynam <<  53 G4DecayProducts::G4DecayProducts(const G4DynamicParticle &aParticle)
                                                   >>  54                 :numberOfProducts(0),theParentParticle(0)
 46 {                                                  55 {
 47   theParentParticle = new G4DynamicParticle(aP     56   theParentParticle = new G4DynamicParticle(aParticle);
 48   theProductVector = new G4DecayProductVector( << 
 49 }                                                  57 }
 50                                                    58 
 51 G4DecayProducts::G4DecayProducts(const G4Decay <<  59 G4DecayProducts::G4DecayProducts(const G4DecayProducts &right) 
                                                   >>  60                 :numberOfProducts(0)
 52 {                                                  61 {
 53   theProductVector = new G4DecayProductVector( << 
 54                                                << 
 55   // copy parent (Deep Copy)                       62   // copy parent (Deep Copy)
 56   theParentParticle = new G4DynamicParticle(*r     63   theParentParticle = new G4DynamicParticle(*right.theParentParticle);
 57                                                    64 
 58   // copy daughters (Deep Copy)                <<  65   //copy daughters (Deep Copy)
 59   for (G4int index = 0; index < right.numberOf <<  66   for (G4int index=0; index < right.numberOfProducts; index++)
 60     G4DynamicParticle* daughter = right.thePro <<  67   {
 61     auto pDaughter = new G4DynamicParticle(*da <<  68     G4DynamicParticle* daughter = right.theProductVector[index];
 62                                                <<  69     const G4DecayProducts* pPreAssigned = daughter->GetPreAssignedDecayProducts();
 63     G4double properTime = daughter->GetPreAssi     70     G4double properTime = daughter->GetPreAssignedDecayProperTime();
 64     if (properTime > 0.0) pDaughter->SetPreAss <<  71     G4DynamicParticle* pDaughter =  new G4DynamicParticle(*daughter);
 65                                                    72 
 66     const G4DecayProducts* pPreAssigned = daug <<  73     if (pPreAssigned) {
 67     if (pPreAssigned != nullptr) {             <<  74       G4DecayProducts* pPA = new G4DecayProducts(*pPreAssigned);
 68       auto pPA = new G4DecayProducts(*pPreAssi << 
 69       pDaughter->SetPreAssignedDecayProducts(p     75       pDaughter->SetPreAssignedDecayProducts(pPA);
                                                   >>  76       if(properTime>0.0)
                                                   >>  77       { pDaughter->SetPreAssignedDecayProperTime(properTime); }
 70     }                                              78     }
 71     theProductVector->push_back(pDaughter);    <<  79 
                                                   >>  80     PushProducts( pDaughter );
 72   }                                                81   }
 73   numberOfProducts = right.numberOfProducts;   << 
 74 }                                                  82 }
 75                                                    83 
 76 G4DecayProducts& G4DecayProducts::operator=(co <<  84 G4DecayProducts & G4DecayProducts::operator=(const G4DecayProducts &right)
 77 {                                                  85 {
 78   G4int index;                                     86   G4int index;
 79                                                    87 
 80   if (this != &right) {                        <<  88   if (this != &right)
                                                   >>  89   { 
 81     // recreate parent                             90     // recreate parent
 82     delete theParentParticle;                  <<  91     if (theParentParticle != 0) delete theParentParticle;
 83     theParentParticle = new G4DynamicParticle(     92     theParentParticle = new G4DynamicParticle(*right.theParentParticle);
 84                                                    93 
 85     // delete G4DynamicParticle objects            94     // delete G4DynamicParticle objects
 86     for (index = 0; index < numberOfProducts;  <<  95     for (index=0; index < numberOfProducts; index++)
 87       delete theProductVector->at(index);      <<  96     {
                                                   >>  97       delete theProductVector[index];
 88     }                                              98     }
 89     theProductVector->clear();                 << 
 90                                                    99 
 91     // copy daughters (Deep Copy)              << 100     //copy daughters (Deep Copy)
 92     for (index = 0; index < right.numberOfProd << 101     for (index=0; index < right.numberOfProducts; index++) {
 93       G4DynamicParticle* daughter = right.theP << 102       PushProducts( new G4DynamicParticle(*right.theProductVector[index]) );
 94       auto pDaughter = new G4DynamicParticle(* << 103     } 
 95                                                << 
 96       G4double properTime = daughter->GetPreAs << 
 97       if (properTime > 0.0) pDaughter->SetPreA << 
 98                                                << 
 99       const G4DecayProducts* pPreAssigned = da << 
100       if (pPreAssigned != nullptr) {           << 
101         auto pPA = new G4DecayProducts(*pPreAs << 
102         pDaughter->SetPreAssignedDecayProducts << 
103       }                                        << 
104       theProductVector->push_back(pDaughter);  << 
105     }                                          << 
106     numberOfProducts = right.numberOfProducts;    104     numberOfProducts = right.numberOfProducts;
                                                   >> 105     
107   }                                               106   }
108   return *this;                                   107   return *this;
109 }                                                 108 }
110                                                   109 
111 G4DecayProducts::~G4DecayProducts()               110 G4DecayProducts::~G4DecayProducts()
112 {                                                 111 {
113   // delete parent                             << 112   //delete parent
114   delete theParentParticle;                    << 113   if (theParentParticle != 0) delete theParentParticle;
115   theParentParticle = nullptr;                 << 114   
116                                                << 
117   // delete G4DynamicParticle object              115   // delete G4DynamicParticle object
118   for (G4int index = 0; index < numberOfProduc << 116   for (G4int index=0; index < numberOfProducts; index++)
119     delete theProductVector->at(index);        << 117   {
                                                   >> 118       delete theProductVector[index];
120   }                                               119   }
121   theProductVector->clear();                   << 120   numberOfProducts = 0;    
122   numberOfProducts = 0;                        << 
123   delete theProductVector;                     << 
124   theProductVector = nullptr;                  << 
125 }                                                 121 }
126                                                   122 
127 G4DynamicParticle* G4DecayProducts::PopProduct    123 G4DynamicParticle* G4DecayProducts::PopProducts()
128 {                                                 124 {
129   if (numberOfProducts > 0) {                  << 125    if ( numberOfProducts >0 ) {
130     numberOfProducts -= 1;                     << 126      numberOfProducts -= 1;   
131     G4DynamicParticle* part = theProductVector << 127      return  theProductVector[numberOfProducts];
132     theProductVector->pop_back();              << 128    } else {
133     return part;                               << 129      return 0;
134   }                                            << 130    }
135                                                << 
136   return nullptr;                              << 
137 }                                                 131 }
138                                                   132 
139 G4int G4DecayProducts::PushProducts(G4DynamicP << 133 G4int G4DecayProducts::PushProducts(G4DynamicParticle *aParticle)
140 {                                              << 134 {
141   theProductVector->push_back(aParticle);      << 135    if ( numberOfProducts < MaxNumberOfProducts) {
142   numberOfProducts += 1;                       << 136      theProductVector[numberOfProducts]= aParticle;
143   return numberOfProducts;                     << 137      numberOfProducts += 1; 
                                                   >> 138    } else {
                                                   >> 139 #ifdef G4VERBOSE
                                                   >> 140      G4cout << "G4DecayProducts::PushProducts ";
                                                   >> 141      G4cout << " exceeds MaxNumberOfProducts(="
                                                   >> 142             << G4int(MaxNumberOfProducts) << ")";
                                                   >> 143      G4cout << G4endl;
                                                   >> 144 #endif
                                                   >> 145    }
                                                   >> 146    return numberOfProducts;
144 }                                                 147 }
145                                                   148 
146 G4DynamicParticle* G4DecayProducts::operator[]    149 G4DynamicParticle* G4DecayProducts::operator[](G4int anIndex) const
147 {                                                 150 {
148   if ((numberOfProducts > anIndex) && (anIndex << 151    if ((numberOfProducts > anIndex) && (anIndex >=0) ) {
149     return theProductVector->at(anIndex);      << 152      return  theProductVector[anIndex];
150   }                                            << 153    } else {
151                                                << 154      return 0;
152   return nullptr;                              << 155    }
153 }                                                 156 }
154                                                   157 
155 void G4DecayProducts::SetParentParticle(const  << 158 void  G4DecayProducts::SetParentParticle(const G4DynamicParticle &aParticle)
156 {                                                 159 {
157   delete theParentParticle;                    << 160   if (theParentParticle != 0) delete theParentParticle;
158   theParentParticle = new G4DynamicParticle(aP    161   theParentParticle = new G4DynamicParticle(aParticle);
159 }                                                 162 }
160                                                   163 
161 void G4DecayProducts::Boost(G4double totalEner << 164 
                                                   >> 165 void G4DecayProducts::Boost(G4double totalEnergy, const G4ThreeVector &momentumDirection)
162 {                                                 166 {
163   // calculate new beta                        << 167   // calcurate new beta
164   G4double mass = theParentParticle->GetMass() << 168   G4double   mass = theParentParticle->GetMass();
165   G4double totalMomentum(0);                   << 169   G4double   totalMomentum  = sqrt( (totalEnergy - mass)*(totalEnergy + mass) );
166   if (totalEnergy > mass) {                    << 170   G4double   betax = momentumDirection.x()*totalMomentum/totalEnergy;  
167     totalMomentum = std::sqrt((totalEnergy - m << 171   G4double   betay = momentumDirection.y()*totalMomentum/totalEnergy;  
168   }                                            << 172   G4double   betaz = momentumDirection.z()*totalMomentum/totalEnergy;  
169   G4double betax = momentumDirection.x() * tot << 173   this->Boost(betax, betay, betaz);
170   G4double betay = momentumDirection.y() * tot << 
171   G4double betaz = momentumDirection.z() * tot << 
172   Boost(betax, betay, betaz);                  << 
173 }                                                 174 }
174                                                   175 
175 void G4DecayProducts::Boost(G4double newbetax,    176 void G4DecayProducts::Boost(G4double newbetax, G4double newbetay, G4double newbetaz)
176 {                                              << 177 { 
177   G4double mass = theParentParticle->GetMass() << 178   G4double   mass = theParentParticle->GetMass();
178   G4double energy = theParentParticle->GetTota << 179   G4double   energy  = theParentParticle->GetTotalEnergy();
179   G4double momentum = 0.0;                     << 180   G4double   momentum  = 0.0;
180                                                   181 
181   G4ThreeVector direction(0.0, 0.0, 1.0);      << 182   G4ThreeVector direction(0.0,0.0,1.0);    
182   G4LorentzVector p4;                             183   G4LorentzVector p4;
183                                                   184 
184   if (energy - mass > DBL_MIN) {                  185   if (energy - mass > DBL_MIN) {
185     // calcurate  beta of initial state           186     // calcurate  beta of initial state
186     momentum = theParentParticle->GetTotalMome << 187     momentum  = theParentParticle->GetTotalMomentum();
187     direction = theParentParticle->GetMomentum    188     direction = theParentParticle->GetMomentumDirection();
188     G4double betax = -1.0 * direction.x() * mo << 189     G4double betax = -1.0*direction.x()*momentum/energy;  
189     G4double betay = -1.0 * direction.y() * mo << 190     G4double betay = -1.0*direction.y()*momentum/energy;  
190     G4double betaz = -1.0 * direction.z() * mo << 191     G4double betaz = -1.0*direction.z()*momentum/energy;  
191                                                << 192     
192     for (G4int index = 0; index < numberOfProd << 193     for (G4int index=0; index < numberOfProducts; index++) {
193       // make G4LorentzVector for secondaries  << 194        // make G4LorentzVector for secondaries
194       p4 = (theProductVector->at(index))->Get4 << 195        p4 = theProductVector[index]->Get4Momentum();
195                                                << 196 
196       // boost secondaries to theParentParticl << 197        // boost secondaries to theParentParticle's rest frame 
197       p4.boost(betax, betay, betaz);           << 198        p4.boost(betax, betay, betaz);
                                                   >> 199 
                                                   >> 200        // boost secondaries to  new frame 
                                                   >> 201        p4.boost(newbetax, newbetay, newbetaz);
                                                   >> 202 
                                                   >> 203        // change energy/momentum
                                                   >> 204        theProductVector[index]->Set4Momentum(p4);
                                                   >> 205      }
                                                   >> 206    } else {
                                                   >> 207      for (G4int index=0; index < numberOfProducts; index++) {
                                                   >> 208        // make G4LorentzVector for secondaries
                                                   >> 209        p4 = theProductVector[index]->Get4Momentum();
198                                                   210 
199       // boost secondaries to  new frame       << 211        // boost secondaries to  new frame 
200       p4.boost(newbetax, newbetay, newbetaz);  << 212        p4.boost(newbetax, newbetay, newbetaz);
201                                                << 
202       // change energy/momentum                << 
203       (theProductVector->at(index))->Set4Momen << 
204     }                                          << 
205   }                                            << 
206   else {                                       << 
207     for (G4int index = 0; index < numberOfProd << 
208       // make G4LorentzVector for secondaries  << 
209       p4 = (theProductVector->at(index))->Get4 << 
210                                                   213 
211       // boost secondaries to  new frame       << 214        // change energy/momentum
212       p4.boost(newbetax, newbetay, newbetaz);  << 215        theProductVector[index]->Set4Momentum(p4);
213                                                << 216       }
214       // change energy/momentum                << 217    }
215       (theProductVector->at(index))->Set4Momen << 218    // make G4LorentzVector for parent in its rest frame
216     }                                          << 219    mass = theParentParticle->GetMass();
217   }                                            << 220    G4LorentzVector parent4( 0.0, 0.0, 0.0, mass);
218                                                << 
219   // make G4LorentzVector for parent in its re << 
220   mass = theParentParticle->GetMass();         << 
221   G4LorentzVector parent4(0.0, 0.0, 0.0, mass) << 
222                                                   221 
223   // boost parent to new frame                 << 222    // boost parent to new frame 
224   parent4.boost(newbetax, newbetay, newbetaz); << 223    parent4.boost(newbetax, newbetay, newbetaz);
225                                                   224 
226   // change energy/momentum                    << 225    // change energy/momentum
227   theParentParticle->Set4Momentum(parent4);    << 226    theParentParticle->Set4Momentum(parent4);
228 }                                                 227 }
229                                                   228 
230 G4bool G4DecayProducts::IsChecked() const         229 G4bool G4DecayProducts::IsChecked() const
231 {                                                 230 {
232   G4bool returnValue = true;                      231   G4bool returnValue = true;
233                                                << 232   // check parent 
234   // check parent                              << 233   //   energy/momentum
235   // energy/momentum                           << 234   G4double   parent_energy  = theParentParticle->GetTotalEnergy();
236   G4double parent_energy = theParentParticle-> << 
237   G4ThreeVector direction = theParentParticle-    235   G4ThreeVector direction = theParentParticle->GetMomentumDirection();
238   G4ThreeVector parent_momentum = direction *  << 236   G4ThreeVector parent_momentum = direction*(theParentParticle->GetTotalMomentum());
239                                                << 237   // check momentum dirction is a unit vector
240   // check momentum direction is a unit vector << 238   if ( (parent_momentum.mag() >0.0) && (abs(direction.mag()-1.0) >1.0e-6 ) ) {
241   if ((parent_momentum.mag() > 0.0) && (std::f << 
242 #ifdef G4VERBOSE                                  239 #ifdef G4VERBOSE
243     G4cout << "G4DecayProducts::IsChecked()::  << 240     G4cout << " Momentum Direction Vector of Parent is not normalized ";
244            << " Momentum Direction Vector of P << 241     G4cout << "  (=" << direction.mag() << ")" << G4endl;
245            << "  (=" << direction.mag() << ")" << 
246 #endif                                            242 #endif
247     returnValue = false;                          243     returnValue = false;
248     parent_momentum = parent_momentum * (1. /  << 244     parent_momentum = parent_momentum * (1./direction.mag());
249   }                                               245   }
250                                                   246 
251   // daughters                                 << 247   //daughters
252   G4double mass, energy;                       << 248   G4double   mass, energy;
253   G4ThreeVector momentum;                         249   G4ThreeVector momentum;
254   G4double total_energy = parent_energy;       << 250   G4double   total_energy = parent_energy;
255   G4ThreeVector total_momentum = parent_moment << 251   G4ThreeVector total_momentum =  parent_momentum;
256                                                << 252   for (G4int index=0; index < numberOfProducts; index++) 
257   for (G4int index = 0; index < numberOfProduc << 253   {
258     G4DynamicParticle* part = theProductVector << 254     mass = theProductVector[index]->GetMass();
259     mass = part->GetMass();                    << 255     energy  = theProductVector[index]->GetTotalEnergy();
260     energy = part->GetTotalEnergy();           << 256     direction = theProductVector[index]->GetMomentumDirection();
261     direction = part->GetMomentumDirection();  << 257     momentum = direction*(theProductVector[index]->GetTotalMomentum());
262     momentum = direction * (part->GetTotalMome << 258     // check momentum dirction is a unit vector
263                                                << 259     if ( (momentum.mag()>0.0) && (abs(direction.mag()-1.0) > 1.0e-6)) {
264     // check momentum direction is a unit vect << 
265     if ((momentum.mag() > 0.0) && (std::fabs(d << 
266 #ifdef G4VERBOSE                                  260 #ifdef G4VERBOSE
267       G4cout << "G4DecayProducts::IsChecked(): << 261       G4cout << " Momentum Direction Vector of Daughter [" << index;
268              << " Momentum Direction Vector of << 262       G4cout << "]  is not normalized (=" << direction.mag() << ")" << G4endl;
269              << "]  is not normalized (=" << d << 
270 #endif                                            263 #endif
271       returnValue = false;                        264       returnValue = false;
272       momentum = momentum * (1. / direction.ma << 265       momentum = momentum * (1./direction.mag());
273     }                                             266     }
274     // whether daughter stops or not              267     // whether daughter stops or not
275     if (energy - mass < DBL_MIN) {             << 268     if (energy - mass < DBL_MIN ) {
276 #ifdef G4VERBOSE                                  269 #ifdef G4VERBOSE
277       G4cout << "G4DecayProducts::IsChecked(): << 270       G4cout << "Daughter [" << index << "] has no kinetic energy "<< G4endl;
278              << "  Daughter [" << index << "]  << 
279 #endif                                            271 #endif
280       returnValue = false;                        272       returnValue = false;
281     }                                             273     }
282     total_energy -= energy;                    << 274     total_energy -= energy; 
283     total_momentum -= momentum;                   275     total_momentum -= momentum;
284   }                                               276   }
285   // check energy/momentum conservation           277   // check energy/momentum conservation
286   if ((std::fabs(total_energy) > 1.0e-9 * MeV) << 278   if ( (abs(total_energy) >1.0e-6) || (total_momentum.mag() >1.0e-6 ) ){ 
287 #ifdef G4VERBOSE                                  279 #ifdef G4VERBOSE
288     G4cout << "G4DecayProducts::IsChecked()::  << 280     G4cout << " Energy/Momentum is not conserved   ";
289            << " Energy/Momentum is not conserv << 281     G4cout << total_energy << "  " << total_momentum << G4endl;
290     G4cout << " difference between parent ener << 
291            << "[MeV]  " << G4endl;             << 
292     G4cout << " difference between parent mome << 
293            << " x:" << total_momentum.getX() / << 
294            << " z:" << total_momentum.getZ() / << 
295 #endif                                            282 #endif
296     returnValue = false;                          283     returnValue = false;
297   }                                               284   }
298   return returnValue;                             285   return returnValue;
299 }                                                 286 }
300                                                   287 
301 void G4DecayProducts::DumpInfo() const            288 void G4DecayProducts::DumpInfo() const
302 {                                                 289 {
303   G4cout << " ----- List of DecayProducts  --- << 290    G4cout << " ----- List of DecayProducts  -----" << G4endl;
304   G4cout << " ------ Parent Particle --------- << 291    G4cout << " ------ Parent Particle ----------" << G4endl;
305   if (theParentParticle != nullptr) theParentP << 292    if (theParentParticle != 0) theParentParticle->DumpInfo();
306   G4cout << " ------ Daughter Particles  ----- << 293    G4cout << " ------ Daughter Particles  ------" << G4endl;  
307   for (G4int index = 0; index < numberOfProduc << 294    for (G4int index=0; index < numberOfProducts; index++) 
308     G4cout << " ----------" << index + 1 << "  << 295    {
309     (theProductVector->at(index))->DumpInfo(); << 296       G4cout << " ----------" << index+1 << " -------------" << G4endl;  
310   }                                            << 297       theProductVector[index]-> DumpInfo();
311   G4cout << " ----- End List of DecayProducts  << 298    }
312   G4cout << G4endl;                            << 299    G4cout << " ----- End List of DecayProducts  -----" << G4endl;
313 }                                              << 300    G4cout << G4endl;
                                                   >> 301 } 
314                                                   302