Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/extended/hadronic/Hadr04/src/Run.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 /examples/extended/hadronic/Hadr04/src/Run.cc (Version 11.3.0) and /examples/extended/hadronic/Hadr04/src/Run.cc (Version 11.2.2)


  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 /// \file Run.cc                                   26 /// \file Run.cc
 27 /// \brief Implementation of the Run class         27 /// \brief Implementation of the Run class
 28 //                                                 28 //
 29 //                                             <<  29 // 
 30 //....oooOO0OOooo........oooOO0OOooo........oo     30 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 31 //....oooOO0OOooo........oooOO0OOooo........oo     31 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 32                                                    32 
 33 #include "Run.hh"                                  33 #include "Run.hh"
 34                                                << 
 35 #include "DetectorConstruction.hh"                 34 #include "DetectorConstruction.hh"
 36 #include "HistoManager.hh"                     << 
 37 #include "PrimaryGeneratorAction.hh"               35 #include "PrimaryGeneratorAction.hh"
                                                   >>  36 #include "HistoManager.hh"
 38                                                    37 
 39 #include "G4SystemOfUnits.hh"                  << 
 40 #include "G4UnitsTable.hh"                         38 #include "G4UnitsTable.hh"
                                                   >>  39 #include "G4SystemOfUnits.hh"
 41                                                    40 
 42 //....oooOO0OOooo........oooOO0OOooo........oo     41 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 43                                                    42 
 44 Run::Run(DetectorConstruction* det) : fDetecto <<  43 Run::Run(DetectorConstruction* det)
                                                   >>  44 : fDetector(det)
                                                   >>  45 { }
 45                                                    46 
 46 //....oooOO0OOooo........oooOO0OOooo........oo     47 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 47                                                    48 
 48 void Run::SetPrimary(G4ParticleDefinition* par     49 void Run::SetPrimary(G4ParticleDefinition* particle, G4double energy)
 49 {                                              <<  50 { 
 50   fParticle = particle;                            51   fParticle = particle;
 51   fEkin = energy;                                  52   fEkin = energy;
 52 }                                              <<  53 } 
 53                                                    54 
 54 //....oooOO0OOooo........oooOO0OOooo........oo     55 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 55                                                    56 
 56 void Run::CountProcesses(const G4VProcess* pro <<  57 void Run::CountProcesses(const G4VProcess* process) 
 57 {                                                  58 {
 58   if (process == nullptr) return;                  59   if (process == nullptr) return;
 59   G4String procName = process->GetProcessName(     60   G4String procName = process->GetProcessName();
 60   std::map<G4String, G4int>::iterator it = fPr <<  61   std::map<G4String,G4int>::iterator it = fProcCounter.find(procName);
 61   if (it == fProcCounter.end()) {              <<  62   if ( it == fProcCounter.end()) {
 62     fProcCounter[procName] = 1;                    63     fProcCounter[procName] = 1;
 63   }                                                64   }
 64   else {                                           65   else {
 65     fProcCounter[procName]++;                  <<  66     fProcCounter[procName]++; 
 66   }                                                67   }
 67 }                                              <<  68 }                 
 68                                                <<  69                   
 69 //....oooOO0OOooo........oooOO0OOooo........oo     70 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 70                                                    71 
 71 void Run::ParticleCount(G4String name, G4doubl     72 void Run::ParticleCount(G4String name, G4double Ekin)
 72 {                                                  73 {
 73   std::map<G4String, ParticleData>::iterator i     74   std::map<G4String, ParticleData>::iterator it = fParticleDataMap.find(name);
 74   if (it == fParticleDataMap.end()) {          <<  75   if ( it == fParticleDataMap.end()) {
 75     fParticleDataMap[name] = ParticleData(1, E     76     fParticleDataMap[name] = ParticleData(1, Ekin, Ekin, Ekin);
 76   }                                                77   }
 77   else {                                           78   else {
 78     ParticleData& data = it->second;               79     ParticleData& data = it->second;
 79     data.fCount++;                                 80     data.fCount++;
 80     data.fEmean += Ekin;                           81     data.fEmean += Ekin;
 81     // update min max                          <<  82     //update min max
 82     G4double emin = data.fEmin;                    83     G4double emin = data.fEmin;
 83     if (Ekin < emin) data.fEmin = Ekin;            84     if (Ekin < emin) data.fEmin = Ekin;
 84     G4double emax = data.fEmax;                    85     G4double emax = data.fEmax;
 85     if (Ekin > emax) data.fEmax = Ekin;        <<  86     if (Ekin > emax) data.fEmax = Ekin; 
 86   }                                            <<  87   }   
 87 }                                                  88 }
 88                                                    89 
 89 //....oooOO0OOooo........oooOO0OOooo........oo     90 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 90                                                    91 
 91 void Run::SumTrackLength(G4int nstep1, G4int n <<  92 void Run::SumTrackLength(G4int nstep1, G4int nstep2, 
                                                   >>  93                          G4double trackl1, G4double trackl2,
 92                          G4double time1, G4dou     94                          G4double time1, G4double time2)
 93 {                                                  95 {
 94   fNbStep1 += nstep1;                          <<  96   fNbStep1   += nstep1;  fNbStep2   += nstep2;
 95   fNbStep2 += nstep2;                          <<  97   fTrackLen1 += trackl1; fTrackLen2 += trackl2;
 96   fTrackLen1 += trackl1;                       <<  98   fTime1 += time1; fTime2 += time2;  
 97   fTrackLen2 += trackl2;                       << 
 98   fTime1 += time1;                             << 
 99   fTime2 += time2;                             << 
100 }                                                  99 }
101                                                   100 
102 //....oooOO0OOooo........oooOO0OOooo........oo    101 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
103                                                   102 
104 void Run::Merge(const G4Run* run)                 103 void Run::Merge(const G4Run* run)
105 {                                                 104 {
106   const Run* localRun = static_cast<const Run*    105   const Run* localRun = static_cast<const Run*>(run);
107                                                << 106   
108   // primary particle info                     << 107   //primary particle info
109   //                                              108   //
110   fParticle = localRun->fParticle;                109   fParticle = localRun->fParticle;
111   fEkin = localRun->fEkin;                     << 110   fEkin     = localRun->fEkin;
112                                                << 111   
113   // accumulate sums                              112   // accumulate sums
114   //                                              113   //
115   fNbStep1 += localRun->fNbStep1;              << 114   fNbStep1   += localRun->fNbStep1;
116   fNbStep2 += localRun->fNbStep2;              << 115   fNbStep2   += localRun->fNbStep2;   
117   fTrackLen1 += localRun->fTrackLen1;          << 116   fTrackLen1 += localRun->fTrackLen1;  
118   fTrackLen2 += localRun->fTrackLen2;             117   fTrackLen2 += localRun->fTrackLen2;
119   fTime1 += localRun->fTime1;                  << 118   fTime1     += localRun->fTime1;  
120   fTime2 += localRun->fTime2;                  << 119   fTime2     += localRun->fTime2;
                                                   >> 120   
                                                   >> 121   //map: processes count
                                                   >> 122   std::map<G4String,G4int>::const_iterator itp;
                                                   >> 123   for ( itp = localRun->fProcCounter.begin();
                                                   >> 124         itp != localRun->fProcCounter.end(); ++itp ) {
121                                                   125 
122   // map: processes count                      << 
123   std::map<G4String, G4int>::const_iterator it << 
124   for (itp = localRun->fProcCounter.begin(); i << 
125     G4String procName = itp->first;               126     G4String procName = itp->first;
126     G4int localCount = itp->second;               127     G4int localCount = itp->second;
127     if (fProcCounter.find(procName) == fProcCo << 128     if ( fProcCounter.find(procName) == fProcCounter.end()) {
128       fProcCounter[procName] = localCount;        129       fProcCounter[procName] = localCount;
129     }                                             130     }
130     else {                                        131     else {
131       fProcCounter[procName] += localCount;       132       fProcCounter[procName] += localCount;
132     }                                          << 133     }  
133   }                                               134   }
134                                                << 135    
135   // map: created particles count              << 136   //map: created particles count         
136   std::map<G4String, ParticleData>::const_iter << 137   std::map<G4String,ParticleData>::const_iterator itn;
137   for (itn = localRun->fParticleDataMap.begin( << 138   for (itn = localRun->fParticleDataMap.begin(); 
                                                   >> 139        itn != localRun->fParticleDataMap.end(); ++itn) {
                                                   >> 140     
138     G4String name = itn->first;                   141     G4String name = itn->first;
139     const ParticleData& localData = itn->secon << 142     const ParticleData& localData = itn->second;   
140     if (fParticleDataMap.find(name) == fPartic << 143     if ( fParticleDataMap.find(name) == fParticleDataMap.end()) {
141       fParticleDataMap[name] =                 << 144       fParticleDataMap[name]
142         ParticleData(localData.fCount, localDa << 145        = ParticleData(localData.fCount, 
                                                   >> 146                       localData.fEmean, 
                                                   >> 147                       localData.fEmin, 
                                                   >> 148                       localData.fEmax);
143     }                                             149     }
144     else {                                        150     else {
145       ParticleData& data = fParticleDataMap[na << 151       ParticleData& data = fParticleDataMap[name];   
146       data.fCount += localData.fCount;            152       data.fCount += localData.fCount;
147       data.fEmean += localData.fEmean;            153       data.fEmean += localData.fEmean;
148       G4double emin = localData.fEmin;            154       G4double emin = localData.fEmin;
149       if (emin < data.fEmin) data.fEmin = emin    155       if (emin < data.fEmin) data.fEmin = emin;
150       G4double emax = localData.fEmax;            156       G4double emax = localData.fEmax;
151       if (emax > data.fEmax) data.fEmax = emax << 157       if (emax > data.fEmax) data.fEmax = emax; 
152     }                                          << 158     }   
153   }                                               159   }
154                                                   160 
155   G4Run::Merge(run);                           << 161   G4Run::Merge(run); 
156 }                                              << 162 } 
157                                                   163 
158 //....oooOO0OOooo........oooOO0OOooo........oo    164 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
159                                                   165 
160 void Run::EndOfRun()                           << 166 void Run::EndOfRun() 
161 {                                                 167 {
162   G4int prec = 5, wid = prec + 2;              << 168   G4int prec = 5, wid = prec + 2;  
163   G4int dfprec = G4cout.precision(prec);          169   G4int dfprec = G4cout.precision(prec);
164                                                << 170   
165   // run condition                             << 171   //run condition
166   //                                              172   //
167   G4Material* material = fDetector->GetMateria    173   G4Material* material = fDetector->GetMaterial();
168   G4double density = material->GetDensity();      174   G4double density = material->GetDensity();
169                                                << 175    
170   G4String Particle = fParticle->GetParticleNa << 176   G4String Particle = fParticle->GetParticleName();    
171   G4cout << "\n The run is " << numberOfEvent  << 177   G4cout << "\n The run is " << numberOfEvent << " "<< Particle << " of "
172          << G4BestUnit(fEkin, "Energy") << " t << 178          << G4BestUnit(fEkin,"Energy") << " through " 
173          << G4BestUnit(0.5 * (fDetector->GetSi << 179          << G4BestUnit(0.5*(fDetector->GetSize()),"Length") << " of "
174          << " (density: " << G4BestUnit(densit << 180          << material->GetName() << " (density: " 
175                                                << 181          << G4BestUnit(density,"Volumic Mass") << ")" << G4endl;
176   if (numberOfEvent == 0) {                    << 182 
177     G4cout.precision(dfprec);                  << 183   if (numberOfEvent == 0) { G4cout.precision(dfprec);   return;}
178     return;                                    << 184              
179   }                                            << 185   //frequency of processes
180                                                << 
181   // frequency of processes                    << 
182   //                                              186   //
183   G4cout << "\n Process calls frequency :" <<  << 187   G4cout << "\n Process calls frequency :" << G4endl;  
184   G4int survive = 0;                              188   G4int survive = 0;
185   std::map<G4String, G4int>::iterator it;      << 189   std::map<G4String,G4int>::iterator it;    
186   for (it = fProcCounter.begin(); it != fProcC    190   for (it = fProcCounter.begin(); it != fProcCounter.end(); it++) {
187     G4String procName = it->first;             << 191      G4String procName = it->first;
188     G4int count = it->second;                  << 192      G4int    count    = it->second;
189     G4cout << "\t" << procName << "= " << coun << 193      G4cout << "\t" << procName << "= " << count;
190     if (procName == "Transportation") survive  << 194      if (procName == "Transportation") survive = count;
191   }                                               195   }
192   G4cout << G4endl;                               196   G4cout << G4endl;
193                                                << 197       
194   if (survive > 0) {                              198   if (survive > 0) {
195     G4cout << "\n Nb of incident particles sur    199     G4cout << "\n Nb of incident particles surviving after "
196            << G4BestUnit(0.5 * (fDetector->Get << 200            << G4BestUnit(0.5*(fDetector->GetSize()),"Length") << " of "
197            << fDetector->GetMaterial()->GetNam    201            << fDetector->GetMaterial()->GetName() << " : " << survive << G4endl;
198   }                                               202   }
199                                                   203 
200   // total track length of incident neutron    << 204  // total track length of incident neutron
201   //                                           << 205  //
202   G4cout << "\n Parcours of incident neutron:" << 206  G4cout << "\n Parcours of incident neutron:";
203                                                << 207   
204   G4double meanCollision1 = (G4double)fNbStep1 << 208  G4double meanCollision1  = (G4double)fNbStep1/numberOfEvent;
205   G4double meanCollision2 = (G4double)fNbStep2 << 209  G4double meanCollision2  = (G4double)fNbStep2/numberOfEvent;
206   G4double meanCollisTota = meanCollision1 + m << 210  G4double meanCollisTota  = meanCollision1 + meanCollision2;
207                                                << 211 
208   G4cout << "\n   nb of collisions    E>1*eV=  << 212  G4cout << "\n   nb of collisions    E>1*eV= " << meanCollision1
209          << "      E<1*eV= " << meanCollision2 << 213         << "      E<1*eV= " << meanCollision2
210                                                << 214         << "       total= " << meanCollisTota;        
211   G4double meanTrackLen1 = fTrackLen1 / number << 215         
212   G4double meanTrackLen2 = fTrackLen2 / number << 216  G4double meanTrackLen1  = fTrackLen1/numberOfEvent;
213   G4double meanTrackLtot = meanTrackLen1 + mea << 217  G4double meanTrackLen2  = fTrackLen2/numberOfEvent;
214                                                << 218  G4double meanTrackLtot  =  meanTrackLen1 + meanTrackLen2;  
215   G4cout << "\n   track length        E>1*eV=  << 219 
216          << "  E<1*eV= " << G4BestUnit(meanTra << 220  G4cout 
217          << "   total= " << G4BestUnit(meanTra << 221    << "\n   track length        E>1*eV= " << G4BestUnit(meanTrackLen1,"Length")
218                                                << 222    << "  E<1*eV= " << G4BestUnit(meanTrackLen2, "Length")
219   G4double meanTime1 = fTime1 / numberOfEvent; << 223    << "   total= " << G4BestUnit(meanTrackLtot, "Length");   
220   G4double meanTime2 = fTime2 / numberOfEvent; << 224    
221   G4double meanTimeTo = meanTime1 + meanTime2; << 225  G4double meanTime1  = fTime1/numberOfEvent;
222                                                << 226  G4double meanTime2  = fTime2/numberOfEvent;
223   G4cout << "\n   time of flight      E>1*eV=  << 227  G4double meanTimeTo = meanTime1 + meanTime2;  
224          << "  E<1*eV= " << G4BestUnit(meanTim << 228 
225          << "   total= " << G4BestUnit(meanTim << 229  G4cout 
226                                                << 230    << "\n   time of flight      E>1*eV= " << G4BestUnit(meanTime1,"Time")
227   // particles count                           << 231    << "  E<1*eV= " << G4BestUnit(meanTime2, "Time")
228   //                                           << 232    << "   total= " << G4BestUnit(meanTimeTo, "Time") << G4endl;   
229   G4cout << "\n List of generated particles:"  << 233              
230                                                << 234  //particles count
231   std::map<G4String, ParticleData>::iterator i << 235  //
232   for (itn = fParticleDataMap.begin(); itn !=  << 236  G4cout << "\n List of generated particles:" << G4endl;
                                                   >> 237      
                                                   >> 238  std::map<G4String,ParticleData>::iterator itn;               
                                                   >> 239  for (itn = fParticleDataMap.begin(); itn != fParticleDataMap.end(); itn++) { 
233     G4String name = itn->first;                   240     G4String name = itn->first;
234     ParticleData data = itn->second;              241     ParticleData data = itn->second;
235     G4int count = data.fCount;                    242     G4int count = data.fCount;
236     G4double eMean = data.fEmean / count;      << 243     G4double eMean = data.fEmean/count;
237     G4double eMin = data.fEmin;                   244     G4double eMin = data.fEmin;
238     G4double eMax = data.fEmax;                << 245     G4double eMax = data.fEmax;    
239                                                << 246          
240     G4cout << "  " << std::setw(13) << name <<    247     G4cout << "  " << std::setw(13) << name << ": " << std::setw(7) << count
241            << "  Emean = " << std::setw(wid) < << 248            << "  Emean = " << std::setw(wid) << G4BestUnit(eMean, "Energy")
242            << G4BestUnit(eMin, "Energy") << "  << 249            << "\t( "  << G4BestUnit(eMin, "Energy")
243   }                                            << 250            << " --> " << G4BestUnit(eMax, "Energy") 
244                                                << 251            << ")" << G4endl;           
245   // normalize histograms                      << 252  }
                                                   >> 253  
                                                   >> 254   //normalize histograms      
246   ////G4AnalysisManager* analysisManager = G4A    255   ////G4AnalysisManager* analysisManager = G4AnalysisManager::Instance();
247   ////G4double factor = 1./numberOfEvent;         256   ////G4double factor = 1./numberOfEvent;
248   ////analysisManager->ScaleH1(3,factor);         257   ////analysisManager->ScaleH1(3,factor);
249                                                << 258            
250   // remove all contents in fProcCounter, fCou << 259   //remove all contents in fProcCounter, fCount 
251   fProcCounter.clear();                           260   fProcCounter.clear();
252   fParticleDataMap.clear();                       261   fParticleDataMap.clear();
253                                                << 262                           
254   // restore default format                    << 263   //restore default format         
255   G4cout.precision(dfprec);                    << 264   G4cout.precision(dfprec);   
256 }                                                 265 }
257                                                   266 
258 //....oooOO0OOooo........oooOO0OOooo........oo    267 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
259                                                   268