Geant4 Cross Reference

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


  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 // -------------------------------------------     28 // -------------------------------------------------------------------
 28 //                                                 29 //
 29 // GEANT4 Class file                               30 // GEANT4 Class file
 30 //                                                 31 //
 31 //                                                 32 //
 32 // File name:    G4ComponentSAIDTotalXS            33 // File name:    G4ComponentSAIDTotalXS
 33 //                                                 34 //
 34 // Authors:  G.Folger, V.Ivanchenko, D.Wright      35 // Authors:  G.Folger, V.Ivanchenko, D.Wright
 35 //                                                 36 //
 36 // Modifications:                                  37 // Modifications:
 37 //                                                 38 //
 38                                                    39 
 39 #include "G4ComponentSAIDTotalXS.hh"               40 #include "G4ComponentSAIDTotalXS.hh"
 40 #include "G4PhysicsVector.hh"                      41 #include "G4PhysicsVector.hh"
 41 #include "G4PhysicsFreeVector.hh"              <<  42 #include "G4LPhysicsFreeVector.hh"
                                                   >>  43 #include "G4HadronicException.hh"
 42                                                    44 
 43 const G4String G4ComponentSAIDTotalXS::fnames[ <<  45 G4String G4ComponentSAIDTotalXS::fnames[13] = {
 44   "","pp","np","pip","pim",                        46   "","pp","np","pip","pim",
 45   "pin","pie",                                     47   "pin","pie",
 46   "gp_pi0p","gp_pi+n","gn_pi-p","gn_pi0n","gp_     48   "gp_pi0p","gp_pi+n","gn_pi-p","gn_pi0n","gp_etap","gp_etapp"
 47 };                                                 49 };
 48                                                <<  50 G4PhysicsVector* G4ComponentSAIDTotalXS::elastdata[13] = {0};
 49 #ifdef G4MULTITHREADED                         <<  51 G4PhysicsVector* G4ComponentSAIDTotalXS::inelastdata[13] = {0};
 50   G4Mutex G4ComponentSAIDTotalXS::saidXSMutex  << 
 51 #endif                                         << 
 52                                                    52 
 53 G4ComponentSAIDTotalXS::G4ComponentSAIDTotalXS     53 G4ComponentSAIDTotalXS::G4ComponentSAIDTotalXS() 
 54   : G4VComponentCrossSection("xsSAID")         <<  54   : G4VComponentCrossSection("xsSAID"),numberOfSaidXS(13)
 55 {                                              <<  55 {}
 56   for(G4int i=0; i<numberOfSaidXS; ++i) {      << 
 57     elastdata[i] = nullptr;                    << 
 58     inelastdata[i] = nullptr;                  << 
 59   }                                            << 
 60 }                                              << 
 61                                                    56 
 62 G4ComponentSAIDTotalXS::~G4ComponentSAIDTotalX     57 G4ComponentSAIDTotalXS::~G4ComponentSAIDTotalXS()
 63 {                                                  58 {
 64   for(G4int i=0; i<numberOfSaidXS; ++i) {          59   for(G4int i=0; i<numberOfSaidXS; ++i) {
 65     if(elastdata[i]) {                             60     if(elastdata[i]) {
 66       delete elastdata[i];                         61       delete elastdata[i];
 67       elastdata[i] = nullptr;                  <<  62       elastdata[i] = 0;
 68     }                                              63     }
 69     if(inelastdata[i]) {                           64     if(inelastdata[i]) {
 70       delete inelastdata[i];                       65       delete inelastdata[i];
 71       inelastdata[i] = nullptr;                <<  66       inelastdata[i] = 0;
 72     }                                              67     }
 73   }                                                68   }
 74 }                                                  69 }
 75                                                    70 
 76 G4double                                           71 G4double 
 77 G4ComponentSAIDTotalXS::GetTotalElementCrossSe     72 G4ComponentSAIDTotalXS::GetTotalElementCrossSection(
 78       const G4ParticleDefinition* part,            73       const G4ParticleDefinition* part,
 79       G4double, G4int Z, G4double N)               74       G4double, G4int Z, G4double N)
 80 {                                                  75 {
 81   PrintWarning(part,0,Z,G4lrint(N),                76   PrintWarning(part,0,Z,G4lrint(N),
 82          "G4ComponentSAIDTotalXS::GetTotalElem     77          "G4ComponentSAIDTotalXS::GetTotalElementCrossSection",
 83          "Method is not implemented");             78          "Method is not implemented");
 84   return 0.0;                                      79   return 0.0; 
 85 }                                                  80 }
 86                                                    81 
 87 G4double                                           82 G4double 
 88 G4ComponentSAIDTotalXS::GetTotalIsotopeCrossSe     83 G4ComponentSAIDTotalXS::GetTotalIsotopeCrossSection(
 89       const G4ParticleDefinition* part,            84       const G4ParticleDefinition* part,
 90       G4double kinEnergy, G4int Z, G4int N)        85       G4double kinEnergy, G4int Z, G4int N)
 91 {                                                  86 {
 92   return GetInelasticIsotopeCrossSection(part,     87   return GetInelasticIsotopeCrossSection(part,kinEnergy,Z,N)
 93     + GetElasticIsotopeCrossSection(part,kinEn     88     + GetElasticIsotopeCrossSection(part,kinEnergy,Z,N);
 94 }                                                  89 }
 95                                                    90 
 96 G4double                                           91 G4double 
 97 G4ComponentSAIDTotalXS::GetInelasticElementCro     92 G4ComponentSAIDTotalXS::GetInelasticElementCrossSection(
 98       const G4ParticleDefinition* part,            93       const G4ParticleDefinition* part,
 99       G4double, G4int Z, G4double N)               94       G4double, G4int Z, G4double N)
100 {                                                  95 {
101   PrintWarning(part,0,Z,G4lrint(N),                96   PrintWarning(part,0,Z,G4lrint(N),
102          "G4ComponentSAIDTotalXS::GetTotalElem     97          "G4ComponentSAIDTotalXS::GetTotalElementCrossSection",
103          "Method is not implemented");             98          "Method is not implemented");
104   return 0.0;                                      99   return 0.0; 
105 }                                                 100 }
106                                                   101 
107 G4double                                          102 G4double 
108 G4ComponentSAIDTotalXS::GetInelasticIsotopeCro    103 G4ComponentSAIDTotalXS::GetInelasticIsotopeCrossSection(
109       const G4ParticleDefinition* part,           104       const G4ParticleDefinition* part,
110       G4double kinEnergy, G4int Z, G4int N)       105       G4double kinEnergy, G4int Z, G4int N)
111 {                                                 106 {
112   G4double cross = 0.0;                           107   G4double cross = 0.0;
113   G4SAIDCrossSectionType tp = GetType(part,0,Z    108   G4SAIDCrossSectionType tp = GetType(part,0,Z,N);
114   if(saidUnknown != tp) {                         109   if(saidUnknown != tp) {
115     G4int idx = G4int(tp);                        110     G4int idx = G4int(tp);
116     if(!inelastdata[idx]) { Initialise(tp); }     111     if(!inelastdata[idx]) { Initialise(tp); }
117     if(inelastdata[idx]) {                        112     if(inelastdata[idx]) { 
118       cross = (inelastdata[idx])->Value(kinEne    113       cross = (inelastdata[idx])->Value(kinEnergy);
119     }                                             114     }
120   }                                               115   }
121   return cross;                                   116   return cross;
122 }                                                 117 }
123                                                   118 
124 G4double                                          119 G4double 
125 G4ComponentSAIDTotalXS::GetElasticElementCross    120 G4ComponentSAIDTotalXS::GetElasticElementCrossSection(
126       const G4ParticleDefinition* part,           121       const G4ParticleDefinition* part,
127       G4double, G4int Z, G4double N)              122       G4double, G4int Z, G4double N)
128 {                                                 123 {
129   PrintWarning(part,0,Z,G4lrint(N),               124   PrintWarning(part,0,Z,G4lrint(N),
130          "G4ComponentSAIDTotalXS::GetTotalElem    125          "G4ComponentSAIDTotalXS::GetTotalElementCrossSection",
131          "Method is not implemented");            126          "Method is not implemented");
132   return 0.0;                                     127   return 0.0; 
133 }                                                 128 }
134                                                   129 
135 G4double                                          130 G4double 
136 G4ComponentSAIDTotalXS::GetElasticIsotopeCross    131 G4ComponentSAIDTotalXS::GetElasticIsotopeCrossSection(
137       const G4ParticleDefinition* part,           132       const G4ParticleDefinition* part,
138       G4double kinEnergy, G4int Z, G4int N)       133       G4double kinEnergy, G4int Z, G4int N)
139 {                                                 134 {
140   G4double cross = 0.0;                           135   G4double cross = 0.0;
141   G4SAIDCrossSectionType tp = GetType(part,0,Z    136   G4SAIDCrossSectionType tp = GetType(part,0,Z,N);
142   if(saidUnknown != tp) {                         137   if(saidUnknown != tp) {
143     G4int idx = G4int(tp);                        138     G4int idx = G4int(tp);
144     if(!elastdata[idx]) { Initialise(tp); }       139     if(!elastdata[idx]) { Initialise(tp); }
145     if(elastdata[idx]) {                          140     if(elastdata[idx]) { 
146       cross = (elastdata[idx])->Value(kinEnerg    141       cross = (elastdata[idx])->Value(kinEnergy); 
147     }                                             142     }
148   }                                               143   }
149   return cross;                                   144   return cross;
150 }                                                 145 }
151                                                   146 
152 G4double                                          147 G4double 
153 G4ComponentSAIDTotalXS::GetChargeExchangeCross    148 G4ComponentSAIDTotalXS::GetChargeExchangeCrossSection(
154      const G4ParticleDefinition* prim,            149      const G4ParticleDefinition* prim,
155      const G4ParticleDefinition* sec,             150      const G4ParticleDefinition* sec,
156      G4double kinEnergy, G4int Z, G4int N)        151      G4double kinEnergy, G4int Z, G4int N)
157 {                                                 152 {
158   G4double cross = 0.0;                           153   G4double cross = 0.0;
159   G4SAIDCrossSectionType tp = GetType(prim,sec    154   G4SAIDCrossSectionType tp = GetType(prim,sec,Z,N);
160   if(saidUnknown != tp) {                         155   if(saidUnknown != tp) {
161     G4int idx = G4int(tp);                        156     G4int idx = G4int(tp);
162     if(!inelastdata[idx]) { Initialise(tp); }     157     if(!inelastdata[idx]) { Initialise(tp); }
163     if(inelastdata[idx]) {                        158     if(inelastdata[idx]) { 
164       cross = (inelastdata[idx])->Value(kinEne    159       cross = (inelastdata[idx])->Value(kinEnergy); 
165     }                                             160     }
166   }                                               161   }
167   return cross;                                   162   return cross;
168 }                                                 163 }
169                                                   164 
170 void G4ComponentSAIDTotalXS::Description(std:: << 165 void 
                                                   >> 166 G4ComponentSAIDTotalXS::Description() const
171 {                                                 167 {
172 }                                                 168 }
173                                                   169 
174 G4SAIDCrossSectionType                            170 G4SAIDCrossSectionType 
175 G4ComponentSAIDTotalXS::GetType(const G4Partic    171 G4ComponentSAIDTotalXS::GetType(const G4ParticleDefinition* prim,
176         const G4ParticleDefinition* sec,          172         const G4ParticleDefinition* sec,
177         G4int Z, G4int N)                         173         G4int Z, G4int N)
178 {                                                 174 {
179   G4SAIDCrossSectionType type = saidUnknown;      175   G4SAIDCrossSectionType type = saidUnknown;
180   if(1 == N && prim) {                            176   if(1 == N && prim) {
181     G4int code = prim->GetPDGEncoding();          177     G4int code = prim->GetPDGEncoding();
182                                                   178 
183     // only gamma + N x-sections available        179     // only gamma + N x-sections available
184     if(0 == Z && sec && 22 == code) {             180     if(0 == Z && sec && 22 == code) {
185       G4int code1 = sec->GetPDGEncoding();        181       G4int code1 = sec->GetPDGEncoding();
186       if(-211 == code1)     { type = saidGN_PI    182       if(-211 == code1)     { type = saidGN_PINP; }
187       else if(111 == code1) { type = saidGN_PI    183       else if(111 == code1) { type = saidGN_PI0N; }
188                                                   184 
189       // x-sections off proton                    185       // x-sections off proton
190     } else if(1 == Z) {                           186     } else if(1 == Z) {
191       if(sec) {                                   187       if(sec) {
192   G4int code1 = sec->GetPDGEncoding();            188   G4int code1 = sec->GetPDGEncoding();
193         if(-211 == code) {                        189         if(-211 == code) {
194           if(111 == code1)      { type = saidP    190           if(111 == code1)      { type = saidPINP_PI0N; }
195           else if(221 == code1) { type = saidP    191           else if(221 == code1) { type = saidPINP_ETAN; }
196                                                   192 
197   } else if(22 == code) {                         193   } else if(22 == code) {
198           if(111 == code1)      { type = saidG    194           if(111 == code1)      { type = saidGP_PI0P; }
199           else if(211 == code1) { type = saidG    195           else if(211 == code1) { type = saidGP_PIPN; }
200           else if(221 == code1) { type = saidG    196           else if(221 == code1) { type = saidGP_ETAP; }
201           else if(331 == code1) { type = saidG    197           else if(331 == code1) { type = saidGP_ETAPP; }
202   }                                               198   }
203       } else {                                    199       } else {
204         if(2212 == code)        { type = saidP    200         if(2212 == code)        { type = saidPP; } 
205         else if(2112 == code)   { type = saidN    201         else if(2112 == code)   { type = saidNP; } 
206         else if(211 == code)    { type = saidP    202         else if(211 == code)    { type = saidPIPP; } 
207         else if(-211 == code)   { type = saidP    203         else if(-211 == code)   { type = saidPINP; } 
208       }                                           204       }
209     }                                             205     }
210   }                                               206   }
211   //G4cout << "G4ComponentSAIDTotalXS::Type= "    207   //G4cout << "G4ComponentSAIDTotalXS::Type= " << type << G4endl;
212   return type;                                    208   return type;
213 }                                                 209 }
214                                                   210 
215 void G4ComponentSAIDTotalXS::Initialise(G4SAID    211 void G4ComponentSAIDTotalXS::Initialise(G4SAIDCrossSectionType tp)
216 {                                                 212 {
217   G4int idx = G4int(tp);                          213   G4int idx = G4int(tp);
218 #ifdef G4MULTITHREADED                         << 214   // check environment variable 
219   G4MUTEXLOCK(&saidXSMutex);                   << 215   // Build the complete string identifying the file with the data set
220   if(!inelastdata[idx]) {                      << 216   char* path = getenv("G4SAIDXSDATA");
221 #endif                                         << 217   if (!path){
222     // check environment variable              << 218     throw G4HadronicException(__FILE__, __LINE__, 
223     // Build the complete string identifying t << 219                               "G4SAIDXSDATA environment variable not defined");
224     const char* path = G4FindDataDir("G4SAIDXS << 220     return;
225     if (!path){                                << 221   }
226       G4Exception("G4ComponentSAIDTotalXS::Ini << 222   if(idx <= 4) {
227       FatalException,                          << 223     elastdata[idx] = new G4LPhysicsFreeVector();
228       "Environment variable G4SAIDXSDATA is no << 224     inelastdata[idx] = new G4LPhysicsFreeVector();
229       return;                                  << 225     ReadData(idx,elastdata[idx],path,"_el.dat");
230     }                                          << 226     ReadData(idx,inelastdata[idx],path,"_in.dat");
231     if(idx <= 4) {                             << 227   } else {
232       elastdata[idx] = new G4PhysicsFreeVector << 228     inelastdata[idx] = new G4LPhysicsFreeVector();
233       inelastdata[idx] = new G4PhysicsFreeVect << 229     ReadData(idx,inelastdata[idx],path,".dat");
234       ReadData(idx,elastdata[idx],path,"_el.da << 
235       ReadData(idx,inelastdata[idx],path,"_in. << 
236     } else {                                   << 
237       inelastdata[idx] = new G4PhysicsFreeVect << 
238       ReadData(idx,inelastdata[idx],path,".dat << 
239     }                                          << 
240 #ifdef G4MULTITHREADED                         << 
241   }                                               230   }
242   G4MUTEXUNLOCK(&saidXSMutex);                 << 
243 #endif                                         << 
244 }                                                 231 }
245                                                   232 
246 void G4ComponentSAIDTotalXS::ReadData(G4int in    233 void G4ComponentSAIDTotalXS::ReadData(G4int index, 
247               G4PhysicsVector* v,                 234               G4PhysicsVector* v,
248               const G4String& ss1,                235               const G4String& ss1, 
249               const G4String& ss2)                236               const G4String& ss2)
250 {                                                 237 {
251   std::ostringstream ost;                         238   std::ostringstream ost;
252   ost << ss1 << "/" << fnames[index] << ss2;      239   ost << ss1 << "/" << fnames[index] << ss2;
253   std::ifstream filein(ost.str().c_str());        240   std::ifstream filein(ost.str().c_str());
254   if (!(filein)) {                                241   if (!(filein)) {
255     G4ExceptionDescription ed;                 << 242     G4cout << ost.str() << " is not opened by G4ComponentSAIDTotalXS" 
256     ed << "Data file <" << ost.str().c_str()   << 243      << G4endl;
257        << "> is not opened!";                  << 244     G4String sss(ost.str());
258     G4Exception("G4ComponentSAIDTotalXS::ReadD << 245     throw G4HadronicException(__FILE__, __LINE__,
259                 FatalException, ed, "Check G4S << 246             "Data file " + sss + 
                                                   >> 247             " is not opened," +
                                                   >> 248             "chech that G4SAIDXSDATA correctly set");
                                                   >> 249 
260   } else {                                        250   } else {
261     if(GetVerboseLevel() > 1) {                   251     if(GetVerboseLevel() > 1) {
262       G4cout << "File " << ost.str()              252       G4cout << "File " << ost.str() 
263              << " is opened by G4ComponentSAID    253              << " is opened by G4ComponentSAIDTotalXS" << G4endl;
264     }                                             254     }
265     // retrieve data from DB                      255     // retrieve data from DB
266     v->Retrieve(filein, true);                    256     v->Retrieve(filein, true);
267     v->ScaleVector(CLHEP::MeV,CLHEP::millibarn    257     v->ScaleVector(CLHEP::MeV,CLHEP::millibarn);
268     v->FillSecondDerivatives();                << 258     v->SetSpline(true);
269   }                                               259   } 
270 }                                                 260 }
271                                                   261 
272 void                                              262 void 
273 G4ComponentSAIDTotalXS::PrintWarning(const G4P    263 G4ComponentSAIDTotalXS::PrintWarning(const G4ParticleDefinition* prim,
274              const G4ParticleDefinition* sec,     264              const G4ParticleDefinition* sec,
275              G4int Z, G4int N,                    265              G4int Z, G4int N,
276              const G4String& ss1,                 266              const G4String& ss1,
277              const G4String& ss2)                 267              const G4String& ss2)
278 {                                                 268 {
279   G4cout << ss1 << ": " << ss2 << G4endl;         269   G4cout << ss1 << ": " << ss2 << G4endl;
280   G4cout << "For Z= " << Z << " N= " << N << "    270   G4cout << "For Z= " << Z << " N= " << N << " of ";
281   if(prim) { G4cout << prim->GetParticleName()    271   if(prim) { G4cout << prim->GetParticleName() << " "; }
282   if(sec) { G4cout << " x-section to " << sec-    272   if(sec) { G4cout << " x-section to " << sec->GetParticleName(); }
283   G4cout << G4endl;                               273   G4cout << G4endl;
284 }                                                 274 }
285                                                   275