Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/cross_sections/src/G4NeutronElasticXS.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 /processes/hadronic/cross_sections/src/G4NeutronElasticXS.cc (Version 11.3.0) and /processes/hadronic/cross_sections/src/G4NeutronElasticXS.cc (Version 9.6)


  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$
                                                   >>  27 //
 26 // -------------------------------------------     28 // -------------------------------------------------------------------
 27 //                                                 29 //
 28 // GEANT4 Class file                               30 // GEANT4 Class file
 29 //                                                 31 //
 30 //                                                 32 //
 31 // File name:    G4NeutronElasticXS                33 // File name:    G4NeutronElasticXS
 32 //                                                 34 //
 33 // Author  Ivantchenko, Geant4, 3-Aug-09           35 // Author  Ivantchenko, Geant4, 3-Aug-09
 34 //                                                 36 //
 35 // Modifications:                                  37 // Modifications:
 36 //                                                 38 //
 37                                                    39 
                                                   >>  40 #include "G4HadronicException.hh"
 38 #include "G4NeutronElasticXS.hh"                   41 #include "G4NeutronElasticXS.hh"
 39 #include "G4Neutron.hh"                            42 #include "G4Neutron.hh"
 40 #include "G4DynamicParticle.hh"                    43 #include "G4DynamicParticle.hh"
 41 #include "G4ElementTable.hh"                   << 
 42 #include "G4Material.hh"                       << 
 43 #include "G4Element.hh"                            44 #include "G4Element.hh"
                                                   >>  45 #include "G4ElementTable.hh"
 44 #include "G4PhysicsLogVector.hh"                   46 #include "G4PhysicsLogVector.hh"
 45 #include "G4CrossSectionDataSetRegistry.hh"    <<  47 #include "G4PhysicsVector.hh"
 46 #include "G4ComponentGGHadronNucleusXsc.hh"    <<  48 #include "G4GlauberGribovCrossSection.hh"
 47 #include "G4HadronicParameters.hh"             <<  49 #include "G4HadronNucleonXsc.hh"
 48 #include "Randomize.hh"                        <<  50 #include "G4NistManager.hh"
 49 #include "G4SystemOfUnits.hh"                  <<  51 #include "G4Proton.hh"
 50 #include "G4IsotopeList.hh"                    << 
 51 #include "G4AutoLock.hh"                       << 
 52                                                    52 
                                                   >>  53 #include <iostream>
 53 #include <fstream>                                 54 #include <fstream>
 54 #include <sstream>                                 55 #include <sstream>
 55                                                    56 
 56 G4PhysicsVector* G4NeutronElasticXS::data[] =  <<  57 using namespace std;
 57 G4double G4NeutronElasticXS::coeff[] = {0.0};  << 
 58 G4String G4NeutronElasticXS::gDataDirectory =  << 
 59 G4bool G4NeutronElasticXS::fLock = true;       << 
 60                                                << 
 61 namespace                                      << 
 62 {                                              << 
 63   G4Mutex nElasticXSMutex = G4MUTEX_INITIALIZE << 
 64 }                                              << 
 65                                                    58 
 66 G4NeutronElasticXS::G4NeutronElasticXS()           59 G4NeutronElasticXS::G4NeutronElasticXS() 
 67  : G4VCrossSectionDataSet(Default_Name()),     <<  60  : G4VCrossSectionDataSet("G4NeutronElasticXS"),
 68    neutron(G4Neutron::Neutron())               <<  61    proton(G4Proton::Proton()), maxZ(92)
 69 {                                                  62 {
 70   //  verboseLevel = 0;                            63   //  verboseLevel = 0;
 71   if (verboseLevel > 0){                       <<  64   if(verboseLevel > 0){
 72     G4cout  << "G4NeutronElasticXS::G4NeutronE     65     G4cout  << "G4NeutronElasticXS::G4NeutronElasticXS Initialise for Z < " 
 73       << MAXZEL << G4endl;                     <<  66       << maxZ + 1 << G4endl;
 74   }                                                67   }
 75   ggXsection =                                 <<  68   data.resize(maxZ+1, 0);
 76     G4CrossSectionDataSetRegistry::Instance()- <<  69   coeff.resize(maxZ+1, 1.0);
 77   if (ggXsection == nullptr)                   <<  70   ggXsection = new G4GlauberGribovCrossSection();
 78     ggXsection = new G4ComponentGGHadronNucleu <<  71   fNucleon = new G4HadronNucleonXsc();
 79   SetForAllAtomsAndEnergies(true);             <<  72   isInitialized = false;
 80   FindDirectoryPath();                         << 
 81 }                                                  73 }
 82                                                    74 
 83 G4NeutronElasticXS::~G4NeutronElasticXS()          75 G4NeutronElasticXS::~G4NeutronElasticXS()
 84 {                                                  76 {
 85   if (isFirst) {                               <<  77   delete fNucleon;
 86     for(G4int i=0; i<MAXZEL; ++i) {            <<  78   for(G4int i=0; i<=maxZ; ++i) {
 87       delete data[i];                          <<  79     delete data[i];
 88       data[i] = nullptr;                       << 
 89     }                                          << 
 90   }                                                80   }
 91 }                                                  81 }
 92                                                    82 
 93 void G4NeutronElasticXS::CrossSectionDescripti     83 void G4NeutronElasticXS::CrossSectionDescription(std::ostream& outFile) const
 94 {                                                  84 {
 95   outFile << "G4NeutronElasticXS calculates th     85   outFile << "G4NeutronElasticXS calculates the neutron elastic scattering\n"
 96           << "cross section on nuclei using da     86           << "cross section on nuclei using data from the high precision\n"
 97           << "neutron database.  These data ar     87           << "neutron database.  These data are simplified and smoothed over\n"
 98           << "the resonance region in order to     88           << "the resonance region in order to reduce CPU time.\n"
 99           << "For high energies Glauber-Gribiv <<  89           << "G4NeutronElasticXS is valid for energies up to 20 MeV, for all\n"
                                                   >>  90           << "targets through U.\n";  
100 }                                                  91 }
101                                                    92 
102 G4bool                                             93 G4bool 
103 G4NeutronElasticXS::IsElementApplicable(const      94 G4NeutronElasticXS::IsElementApplicable(const G4DynamicParticle*, 
104           G4int, const G4Material*)                95           G4int, const G4Material*)
105 {                                                  96 {
106   return true;                                     97   return true;
107 }                                                  98 }
108                                                    99 
109 G4bool G4NeutronElasticXS::IsIsoApplicable(con << 
110                                            G4i << 
111                                            con << 
112 {                                              << 
113   return false;                                << 
114 }                                              << 
115                                                << 
116 G4double                                          100 G4double 
117 G4NeutronElasticXS::GetElementCrossSection(con    101 G4NeutronElasticXS::GetElementCrossSection(const G4DynamicParticle* aParticle,
118              G4int Z, const G4Material*)          102              G4int Z, const G4Material*)
119 {                                                 103 {
120   return ElementCrossSection(aParticle->GetKin << 104   G4double xs = 0.0;
121            aParticle->GetLogKineticEnergy(), Z << 105   G4double ekin = aParticle->GetKineticEnergy();
122 }                                              << 
123                                                << 
124 G4double                                       << 
125 G4NeutronElasticXS::ComputeCrossSectionPerElem << 
126               const G4ParticleDefinition*,     << 
127               const G4Element* elm,            << 
128               const G4Material*)               << 
129 {                                              << 
130   return ElementCrossSection(ekin, loge, elm-> << 
131 }                                              << 
132                                                   106 
133 G4double G4NeutronElasticXS::ElementCrossSecti << 107   if(Z < 1 || Z > maxZ) { return xs; }
134 {                                              << 
135   G4int Z = (ZZ >= MAXZEL) ? MAXZEL - 1 : ZZ;  << 
136   auto pv = GetPhysicsVector(Z);               << 
137                                                   108 
138   G4double xs = (ekin <= pv->GetMaxEnergy()) ? << 109   G4int Amean = G4int(G4NistManager::Instance()->GetAtomicMassAmu(Z)+0.5);
139     : coeff[Z]*ggXsection->GetElasticElementCr << 110   G4PhysicsVector* pv = data[Z];
140                                                << 111   //  G4cout  << "G4NeutronElasticXS::GetCrossSection e= " << ekin << " Z= " << Z << G4endl;
141                                                << 112 
142 #ifdef G4VERBOSE                               << 113   // element was not initialised
143   if(verboseLevel > 1) {                       << 114   if(!pv) {
144     G4cout  << "Z= " << Z << " Ekin(MeV)= " << << 115     Initialise(Z);
145       << ",  nElmXSel(b)= " << xs/CLHEP::barn  << 116     pv = data[Z];
146       << G4endl;                               << 117     if(!pv) { return xs; }
                                                   >> 118   }
                                                   >> 119 
                                                   >> 120   G4double e1 = pv->Energy(0);
                                                   >> 121   if(ekin <= e1) { return (*pv)[0]; }
                                                   >> 122 
                                                   >> 123   G4int n = pv->GetVectorLength() - 1;
                                                   >> 124   G4double e2 = pv->Energy(n);
                                                   >> 125 
                                                   >> 126   if(ekin <= e2) { 
                                                   >> 127     xs = pv->Value(ekin); 
                                                   >> 128   } else if(1 == Z) { 
                                                   >> 129     fNucleon->GetHadronNucleonXscPDG(aParticle, proton);
                                                   >> 130     xs = coeff[1]*fNucleon->GetElasticHadronNucleonXsc();
                                                   >> 131   } else {          
                                                   >> 132     ggXsection->GetIsoCrossSection(aParticle, Z, Amean);
                                                   >> 133     xs = coeff[Z]*ggXsection->GetElasticGlauberGribovXsc();
147   }                                               134   }
148 #endif                                         << 
149   return xs;                                   << 
150 }                                              << 
151                                                   135 
152 G4double                                       << 136   if(verboseLevel > 0){
153 G4NeutronElasticXS::ComputeIsoCrossSection(G4d << 137     G4cout  << "ekin= " << ekin << ",  XSinel= " << xs << G4endl;
154                    const G4ParticleDefinition* << 
155                    G4int Z, G4int A,           << 
156                    const G4Isotope*, const G4E << 
157                    const G4Material*)          << 
158 {                                              << 
159   return ElementCrossSection(ekin, loge, Z)*A/ << 
160 }                                              << 
161                                                << 
162 G4double                                       << 
163 G4NeutronElasticXS::GetIsoCrossSection(const G << 
164                G4int Z, G4int A,               << 
165                const G4Isotope*, const G4Eleme << 
166                const G4Material*)              << 
167 {                                              << 
168   return ElementCrossSection(aParticle->GetKin << 
169            aParticle->GetLogKineticEnergy(), Z << 
170                                                << 
171 }                                              << 
172                                                << 
173 const G4Isotope* G4NeutronElasticXS::SelectIso << 
174       const G4Element* anElement, G4double, G4 << 
175 {                                              << 
176   G4int nIso = (G4int)anElement->GetNumberOfIs << 
177   const G4Isotope* iso = anElement->GetIsotope << 
178                                                << 
179   //G4cout << "SelectIsotope NIso= " << nIso < << 
180   if(1 == nIso) { return iso; }                << 
181                                                << 
182   const G4double* abundVector = anElement->Get << 
183   G4double q = G4UniformRand();                << 
184   G4double sum = 0.0;                          << 
185                                                << 
186   // isotope wise cross section not used       << 
187   for (G4int j=0; j<nIso; ++j) {               << 
188     sum += abundVector[j];                     << 
189     if(q <= sum) {                             << 
190       iso = anElement->GetIsotope(j);          << 
191       break;                                   << 
192     }                                          << 
193   }                                               138   }
194   return iso;                                  << 139   return xs;
195 }                                                 140 }
196                                                   141 
197 void                                              142 void 
198 G4NeutronElasticXS::BuildPhysicsTable(const G4    143 G4NeutronElasticXS::BuildPhysicsTable(const G4ParticleDefinition& p)
199 {                                                 144 {
                                                   >> 145   if(isInitialized) { return; }
200   if(verboseLevel > 0){                           146   if(verboseLevel > 0){
201     G4cout << "G4NeutronElasticXS::BuildPhysic    147     G4cout << "G4NeutronElasticXS::BuildPhysicsTable for " 
202      << p.GetParticleName() << G4endl;            148      << p.GetParticleName() << G4endl;
203   }                                               149   }
204   if(p.GetParticleName() != "neutron") {          150   if(p.GetParticleName() != "neutron") { 
205     G4ExceptionDescription ed;                 << 151     throw G4HadronicException(__FILE__, __LINE__,"Wrong particle type");
206     ed << p.GetParticleName() << " is a wrong  << 
207        << " only neutron is allowed";          << 
208     G4Exception("G4NeutronElasticXS::BuildPhys << 
209     FatalException, ed, "");                   << 
210     return;                                       152     return; 
211   }                                               153   }
212   if (fLock || isFirst) {                      << 154   isInitialized = true;
213     G4AutoLock l(&nElasticXSMutex);            << 
214     if (fLock) {                               << 
215       isFirst = true;                          << 
216       fLock = false;                           << 
217       FindDirectoryPath();                     << 
218     }                                          << 
219                                                   155 
220     // Access to elements                      << 156   // check environment variable 
221     const G4ElementTable* table = G4Element::G << 157   // Build the complete string identifying the file with the data set
222     for ( auto & elm : *table ) {              << 158   char* path = getenv("G4NEUTRONXSDATA");
223       G4int Z = std::max( 1, std::min( elm->Ge << 159   if (!path){
224       if ( nullptr == data[Z] ) { Initialise(Z << 160     throw G4HadronicException(__FILE__, __LINE__, 
225     }                                          << 161             "G4NEUTRONXSDATA environment variable not defined");
226     l.unlock();                                << 162     return;
227   }                                               163   }
228 }                                              << 
229                                                   164 
230 const G4String& G4NeutronElasticXS::FindDirect << 165   G4DynamicParticle* dynParticle = 
231 {                                              << 166     new G4DynamicParticle(G4Neutron::Neutron(),G4ThreeVector(1,0,0),1);
232   // build the complete string identifying the << 167 
233   if (gDataDirectory.empty()) {                << 168   // Access to elements
234     std::ostringstream ost;                    << 169   const G4ElementTable* theElmTable = G4Element::GetElementTable();
235     ost << G4HadronicParameters::Instance()->G << 170   size_t numOfElm = G4Element::GetNumberOfElements();
236     gDataDirectory = ost.str();                << 171   if(numOfElm > 0) {
                                                   >> 172     for(size_t i=0; i<numOfElm; ++i) {
                                                   >> 173       G4int Z = G4int(((*theElmTable)[i])->GetZ());
                                                   >> 174       if(Z < 1)         { Z = 1; }
                                                   >> 175       else if(Z > maxZ) { Z = maxZ; }
                                                   >> 176       //G4cout << "Z= " << Z << G4endl;
                                                   >> 177       // Initialisation 
                                                   >> 178       if(!data[Z]) { Initialise(Z, dynParticle, path); }
                                                   >> 179     }
237   }                                               180   }
238   return gDataDirectory;                       << 181   delete dynParticle;
239 }                                                 182 }
240                                                   183 
241 void G4NeutronElasticXS::InitialiseOnFly(G4int << 184 void 
                                                   >> 185 G4NeutronElasticXS::Initialise(G4int Z, G4DynamicParticle* dp, 
                                                   >> 186              const char* p)
242 {                                                 187 {
243   G4AutoLock l(&nElasticXSMutex);              << 188   if(data[Z]) { return; }
244   Initialise(Z);                               << 189   const char* path = p;
245   l.unlock();                                  << 190   if(!p) {
246 }                                              << 191     // check environment variable 
                                                   >> 192     // Build the complete string identifying the file with the data set
                                                   >> 193     path = getenv("G4NEUTRONXSDATA");
                                                   >> 194     if (!path) {
                                                   >> 195       throw G4HadronicException(__FILE__, __LINE__, 
                                                   >> 196         "G4NEUTRONXSDATA environment variable not defined");
                                                   >> 197       return;
                                                   >> 198     }
                                                   >> 199   }
                                                   >> 200   G4DynamicParticle* dynParticle = dp;
                                                   >> 201   if(!dp) {
                                                   >> 202     dynParticle = 
                                                   >> 203       new G4DynamicParticle(G4Neutron::Neutron(),G4ThreeVector(1,0,0),1);
                                                   >> 204   }
247                                                   205 
248 void G4NeutronElasticXS::Initialise(G4int Z)   << 206   G4int Amean = G4int(G4NistManager::Instance()->GetAtomicMassAmu(Z)+0.5);
249 {                                              << 
250   if(data[Z] != nullptr) { return; }           << 
251                                                   207 
252   // upload data from file                        208   // upload data from file
253   data[Z] = new G4PhysicsLogVector();             209   data[Z] = new G4PhysicsLogVector();
254                                                   210 
255   std::ostringstream ost;                         211   std::ostringstream ost;
256   ost << FindDirectoryPath() << Z ;            << 212   ost << path << "/elast" << Z ;
257   std::ifstream filein(ost.str().c_str());        213   std::ifstream filein(ost.str().c_str());
258   if (!filein.is_open()) {                     << 214   if (!(filein)) {
259     G4ExceptionDescription ed;                 << 215     G4cout << ost.str() 
260     ed << "Data file <" << ost.str().c_str()   << 216      << "  is not opened by G4NeutronElasticXS" << G4endl;
261        << "> is not opened!";                  << 217     throw G4HadronicException(__FILE__, __LINE__,"NO data sets opened");
262     G4Exception("G4NeutronElasticXS::Initialis << 
263                 FatalException, ed, "Check G4P << 
264     return;                                       218     return;
265   }                                            << 219   }else{
266   if(verboseLevel > 1) {                       << 220     if(verboseLevel > 1) {
267     G4cout << "file " << ost.str()             << 221       G4cout << "file " << ost.str() 
268      << " is opened by G4NeutronElasticXS" <<  << 222        << " is opened by G4NeutronElasticXS" << G4endl;
269   }                                            << 223     }
270                                                   224     
271   // retrieve data from DB                     << 225     // retrieve data from DB
272   if(!data[Z]->Retrieve(filein, true)) {       << 226     data[Z]->Retrieve(filein, true);
273     G4ExceptionDescription ed;                 << 227     
274     ed << "Data file <" << ost.str().c_str()   << 228     // smooth transition 
275        << "> is not retrieved!";               << 229     size_t n      = data[Z]->GetVectorLength() - 1;
276     G4Exception("G4NeutronElasticXS::Initialis << 230     G4double emax = data[Z]->Energy(n);
277     FatalException, ed, "Check G4PARTICLEXSDAT << 231     G4double sig1 = (*data[Z])[n];
278     return;                                    << 232     dynParticle->SetKineticEnergy(emax);
279   }                                            << 233     G4double sig2 = 0.0;
280   // smooth transition                         << 234     if(1 == Z) {
281   G4double sig1  = (*(data[Z]))[data[Z]->GetVe << 235       fNucleon->GetHadronNucleonXscPDG(dynParticle, proton);
282   G4double ehigh = data[Z]->GetMaxEnergy();    << 236       sig2 = fNucleon->GetElasticHadronNucleonXsc();
283   G4double sig2  = ggXsection->GetElasticEleme << 237     } else {
284                                ehigh, Z, aeff[ << 238       ggXsection->GetIsoCrossSection(dynParticle, Z, Amean);
285   coeff[Z] = (sig2 > 0.) ? sig1/sig2 : 1.0;    << 239       sig2 = ggXsection->GetElasticGlauberGribovXsc();
                                                   >> 240     }
                                                   >> 241     if(sig2 > 0.) { coeff[Z] = sig1/sig2; } 
                                                   >> 242   } 
                                                   >> 243   if(!dp) { delete dynParticle; }
286 }                                                 244 }
287                                                   245