Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Em10RunAction.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 /// \file electromagnetic/TestEm10/src/Em10RunAction.cc
27 /// \brief Implementation of the Em10RunAction class
28 //
29 //
30 // $Id: Em10RunAction.cc 67268 2013-02-13 11:38:40Z ihrivnac $
31 //
32 //
33 
34 
35 #include "Em10RunAction.hh"
36 #include "Em10RunMessenger.hh"
37 
38 #include "G4Run.hh"
39 #include "G4UImanager.hh"
40 #include "G4VVisManager.hh"
41 #include "G4ios.hh"
42 #include <iomanip>
43 
44 #include "G4PhysicalConstants.hh"
45 #include "G4SystemOfUnits.hh"
46 #include "Randomize.hh"
47 
48 //////////////////////////////////////////////////////////////////////////////
49 
50 Em10RunAction::Em10RunAction()
51  :G4UserRunAction(),
52  histName("histfile"),nbinStep(0),nbinEn(0),nbinTt(0),nbinTb(0),
53  nbinTsec(0),nbinTh(0),nbinThback(0),nbinR(0),nbinGamma(0),
54  nbinvertexz(0)
55 {
56  runMessenger = new Em10RunMessenger(this);
57  saveRndm = 1;
58 
59  EnergySumAbs = EnergySquareSumAbs = tlSumAbs = tlsquareSumAbs =
60  nStepSumCharged = nStepSum2Charged= nStepSumNeutral = nStepSum2Neutral=
61  TotNbofEvents = SumCharged= SumNeutral=Sum2Charged=Sum2Neutral=Selectron=
62  Spositron=Transmitted=Reflected =dStep=entryStep=underStep=overStep=
63  dEn = entryEn= underEn=overEn=dTt = entryTt=underTt=overTt=Ttmean=
64  Tt2mean=dTb = entryTb=underTb=overTb=Tbmean=Tb2mean=dTsec =entryTsec=
65  underTsec=overTsec=dTh = entryTh=underTh=overTh=dThback =entryThback=
66  underThback=overThback=dR =entryR =underR =overR =Rmean=R2mean=dEGamma=
67  entryGamma = underGamma=overGamma=dz=entryvertexz=undervertexz=
68  oververtexz=0.;
69 }
70 
71 ////////////////////////////////////////////////////////////////////////////
72 
73 Em10RunAction::~Em10RunAction()
74 {
75  delete runMessenger;
76 }
77 
78 ////////////////////////////////////////////////////////////////////////////////
79 
80 void Em10RunAction::bookHisto()
81 {
82 }
83 
84 /////////////////////////////////////////////////////////////////////////////
85 
86 void Em10RunAction::BeginOfRunAction(const G4Run* aRun)
87 {
88  G4cout << "### Run " << aRun->GetRunID() << " start." << G4endl;
89 
90  // save Rndm status
91  if (saveRndm > 0)
92  {
93  CLHEP::HepRandom::showEngineStatus();
94  CLHEP::HepRandom::saveEngineStatus("beginOfRun.rndm");
95  }
96  G4UImanager* UI = G4UImanager::GetUIpointer();
97 
98  G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
99 
100  if(pVVisManager) UI->ApplyCommand("/vis/scene/notifyHandlers");
101 
102 
103  EnergySumAbs = 0. ;
104  EnergySquareSumAbs = 0.;
105  tlSumAbs = 0. ;
106  tlsquareSumAbs = 0. ;
107  nStepSumCharged = 0. ;
108  nStepSum2Charged= 0. ;
109  nStepSumNeutral = 0. ;
110  nStepSum2Neutral= 0. ;
111  TotNbofEvents = 0. ;
112  SumCharged=0.;
113  SumNeutral=0.;
114  Sum2Charged=0.;
115  Sum2Neutral=0.;
116  Selectron=0.;
117  Spositron=0.;
118 
119  Transmitted=0.;
120  Reflected =0.;
121 
122  // plot definitions
123 
124  if(nbinStep>0)
125  {
126  dStep=(Stephigh-Steplow)/nbinStep;
127  entryStep=0.;
128  underStep=0.;
129  overStep=0.;
130  for(G4int ist=0; ist<200; ist++)
131  {
132  distStep[ist]=0.;
133  }
134  }
135  if(nbinEn>0)
136  {
137  dEn = (Enhigh-Enlow)/nbinEn ;
138  entryEn=0.;
139  underEn=0.;
140  overEn=0.;
141 
142  for (G4int ien=0; ien<200; ien++) distEn[ien]=0.;
143  }
144  if(nbinTt>0)
145  {
146  dTt = (Tthigh-Ttlow)/nbinTt ;
147  entryTt=0.;
148  underTt=0.;
149  overTt=0.;
150 
151  for (G4int itt=0; itt<200; itt++) distTt[itt]=0.;
152 
153  Ttmean=0.;
154  Tt2mean=0.;
155  }
156  if(nbinTb>0)
157  {
158  dTb = (Tbhigh-Tblow)/nbinTb ;
159  entryTb=0.;
160  underTb=0.;
161  overTb=0.;
162  for (G4int itt=0; itt<200; itt++)
163  {
164  distTb[itt]=0.;
165  }
166  Tbmean=0.;
167  Tb2mean=0.;
168  }
169  if(nbinTsec>0)
170  {
171  dTsec = (Tsechigh-Tseclow)/nbinTsec ;
172  entryTsec=0.;
173  underTsec=0.;
174  overTsec=0.;
175  for (G4int its=0; its<200; its++)
176  {
177  distTsec[its]=0.;
178  }
179  }
180  if(nbinTh>0)
181  {
182  dTh = (Thhigh-Thlow)/nbinTh ;
183  entryTh=0.;
184  underTh=0.;
185  overTh=0.;
186  for (G4int ith=0; ith<200; ith++)
187  {
188  distTh[ith]=0.;
189  }
190  }
191 
192  if(nbinThback>0)
193  {
194  dThback = (Thhighback-Thlowback)/nbinThback ;
195  entryThback=0.;
196  underThback=0.;
197  overThback=0.;
198  for (G4int ithback=0; ithback<200; ithback++)
199  {
200  distThback[ithback]=0.;
201  }
202  }
203 
204 
205  if(nbinR >0)
206  {
207  dR = (Rhigh-Rlow)/nbinR ;
208  entryR =0.;
209  underR =0.;
210  overR =0.;
211  for (G4int ir =0; ir<200; ir++)
212  {
213  distR[ir]=0.;
214  }
215  Rmean=0.;
216  R2mean=0.;
217  }
218 
219  if(nbinGamma>0)
220  {
221  dEGamma = std::log(EhighGamma/ElowGamma)/nbinGamma ;
222  entryGamma = 0.;
223  underGamma=0.;
224  overGamma=0.;
225  for (G4int ig=0; ig<200; ig++)
226  {
227  distGamma[ig]=0.;
228  }
229  }
230  if(nbinvertexz>0)
231  {
232  dz=(zhigh-zlow)/nbinvertexz;
233  entryvertexz=0.;
234  undervertexz=0.;
235  oververtexz=0.;
236  for(G4int iz=0; iz<200; iz++)
237  {
238  distvertexz[iz]=0.;
239  }
240  }
241 
242  bookHisto();
243 }
244 
245 /////////////////////////////////////////////////////////////////////////////
246 
247 void Em10RunAction::EndOfRunAction(const G4Run*)
248 {
249  G4double sAbs,sigAbs,sigstep,sigcharged,signeutral;
250  if(0.0 >= TotNbofEvents) { return; }
251 
252  tlSumAbs /= TotNbofEvents ;
253  sAbs = tlsquareSumAbs/TotNbofEvents-tlSumAbs*tlSumAbs ;
254  if(sAbs>0.)
255  sAbs = std::sqrt(sAbs/TotNbofEvents) ;
256  else
257  sAbs = 0. ;
258 
259  EnergySumAbs /= TotNbofEvents ;
260  sigAbs = EnergySquareSumAbs/TotNbofEvents-EnergySumAbs*EnergySumAbs;
261  if(sigAbs>0.)
262  sigAbs = std::sqrt(sigAbs/TotNbofEvents);
263  else
264  sigAbs = 0.;
265 
266  nStepSumCharged /= TotNbofEvents ;
267  sigstep = nStepSum2Charged/TotNbofEvents-nStepSumCharged*nStepSumCharged;
268  if(sigstep>0.)
269  sigstep = std::sqrt(sigstep/TotNbofEvents);
270  else
271  sigstep = 0.;
272  G4double sigch=sigstep ;
273 
274  nStepSumNeutral /= TotNbofEvents ;
275  sigstep = nStepSum2Neutral/TotNbofEvents-nStepSumNeutral*nStepSumNeutral;
276  if(sigstep>0.)
277  sigstep = std::sqrt(sigstep/TotNbofEvents);
278  else
279  sigstep = 0.;
280  G4double signe=sigstep ;
281 
282  SumCharged /= TotNbofEvents;
283  sigcharged = Sum2Charged/TotNbofEvents-SumCharged*SumCharged;
284  if(sigcharged>0.)
285  sigcharged = std::sqrt(sigcharged/TotNbofEvents);
286  else
287  sigcharged = 0. ;
288 
289  SumNeutral /= TotNbofEvents;
290  signeutral = Sum2Neutral/TotNbofEvents-SumNeutral*SumNeutral;
291  if(signeutral>0.)
292  signeutral = std::sqrt(signeutral/TotNbofEvents);
293  else
294  signeutral = 0. ;
295 
296  Selectron /= TotNbofEvents ;
297  Spositron /= TotNbofEvents ;
298 
299  Transmitted /=TotNbofEvents ;
300  Reflected /=TotNbofEvents ;
301  G4cout << " ================== run summary =====================" << G4endl;
302  G4int prec = G4cout.precision(6);
303  G4cout << " end of Run TotNbofEvents = " <<
304  TotNbofEvents << G4endl ;
305  G4cout << " mean charged track length in absorber=" <<
306  tlSumAbs/mm << " +- " << sAbs/mm <<
307  " mm " << G4endl;
308  G4cout << G4endl;
309  G4cout << " mean energy deposit in absorber=" <<
310  EnergySumAbs/MeV << " +- " << sigAbs/MeV <<
311  " MeV " << G4endl ;
312  G4cout << G4endl ;
313  G4cout << " mean number of steps in absorber (charged) =" <<
314  nStepSumCharged << " +- " << sigch <<
315  " " << G4endl ;
316  G4cout << " mean number of steps in absorber (neutral) =" <<
317  nStepSumNeutral << " +- " << signe <<
318  " " << G4endl ;
319  G4cout << G4endl ;
320  G4cout << " mean number of charged secondaries = " <<
321  SumCharged << " +- " << sigcharged << G4endl;
322  G4cout << G4endl ;
323  G4cout << " mean number of neutral secondaries = " <<
324  SumNeutral << " +- " << signeutral << G4endl;
325  G4cout << G4endl ;
326 
327  G4cout << " mean number of e-s =" << Selectron <<
328  " and e+s =" << Spositron << G4endl;
329  G4cout << G4endl;
330 
331  G4cout << "(number) transmission coeff=" << Transmitted <<
332  " reflection coeff=" << Reflected << G4endl;
333  G4cout << G4endl;
334 
335  if(nbinStep>0)
336  {G4double E , dnorm, norm ;
337  G4cout << " step number/event distribution " << G4endl ;
338  G4cout << "#entries=" << entryStep << " #underflows=" << underStep <<
339  " #overflows=" << overStep << G4endl ;
340  if( entryStep>0.)
341  {
342  E = Steplow - dStep ;
343  norm = TotNbofEvents ;
344  G4cout << " bin nb nsteplow entries normalized " << G4endl ;
345  for(G4int iss=0; iss<nbinStep; iss++)
346  {
347  E += dStep ;
348  dnorm = distStep[iss]/norm;
349  G4cout << std::setw(5) << iss << std::setw(10) << E <<
350  std::setw(12) << distStep[iss] <<
351  std::setw(12) << dnorm << G4endl ;
352  }
353  G4cout << G4endl;
354  }
355  }
356  if(nbinEn > 0)
357  {
358  std::ofstream fileOut("distribution.out", std::ios::out ) ;
359  fileOut.setf( std::ios::scientific, std::ios::floatfield );
360 
361  std::ofstream normOut("normDist.out", std::ios::out ) ;
362  normOut.setf( std::ios::scientific, std::ios::floatfield );
363 
364  G4double E , dnorm, norm,fmax,Emp ;
365  Emp=-999.999 ;
366  G4cout << " energy deposit distribution " << G4endl ;
367  G4cout << "#entries=" << entryEn << " #underflows=" << underEn <<
368  " #overflows=" << overEn << G4endl ;
369  if( entryEn>0.)
370  {
371  E = Enlow - dEn ;
372  norm = TotNbofEvents*1.0 ; // *dEn ;
373  G4cout << " bin nb Elow entries normalized " << G4endl ;
374  fmax = 0. ;
375 
376  for(G4int ien=0; ien<nbinEn; ien++)
377  {
378  E += dEn ;
379 
380  if(distEn[ien]>fmax)
381  {
382  fmax = distEn[ien] ;
383  Emp = E ; // most probable roughly
384  }
385  dnorm = distEn[ien]/norm;
386 
387  G4cout << std::setw(5) << ien << std::setw(10) << E/keV <<
388  std::setw(12) << distEn[ien] <<
389  std::setw(12) << dnorm << G4endl ;
390 
391  fileOut << E/keV << "\t"<< distEn[ien] << G4endl ;
392  normOut << E/keV << "\t"<< dnorm << G4endl ;
393  }
394  G4cout << G4endl;
395  G4int ii ;
396  G4double E1,E2 ;
397  E1=-1.e6 ;
398  E2=+1.e6 ;
399  E = Enlow -dEn ;
400  ii = -1;
401 
402  for(G4int i1=0; i1<nbinEn; i1++)
403  {
404  E += dEn ;
405  if(ii<0)
406  {
407  if(distEn[i1] >= 0.5*fmax)
408  {
409  E1=E ;
410  ii=i1 ;
411  }
412  }
413  }
414  E = Enlow -dEn ;
415 
416  for(G4int i2=0; i2<nbinEn; i2++)
417  {
418  E += dEn ;
419 
420  if(distEn[i2] >= 0.5*fmax) E2=E ;
421  }
422  G4cout << " Emp = " << std::setw(15) << Emp/MeV << " width="
423  << std::setw(15) << (E2-E1)/MeV << " MeV " << G4endl;
424  G4cout << G4endl ;
425  }
426  }
427  if(nbinTt>0)
428  {
429  G4double E , dnorm, norm ,sig;
430  G4cout << " transmitted energy distribution " << G4endl ;
431  G4cout << "#entries=" << entryTt << " #underflows=" << underTt <<
432  " #overflows=" << overTt << G4endl ;
433  if( entryTt>0.)
434  {
435  Ttmean /= entryTt;
436  sig=Tt2mean/entryTt-Ttmean*Ttmean ;
437  if(sig<=0.)
438  sig=0.;
439  else
440  sig=std::sqrt(sig/entryTt) ;
441  G4cout << " mean energy of transmitted particles=" << Ttmean/keV <<
442  " +- " << sig/keV << " keV." << G4endl;
443  E = Ttlow - dTt ;
444  norm = TotNbofEvents*dTt ;
445  G4cout << " bin nb Elow entries normalized " << G4endl ;
446  for(G4int itt=0; itt<nbinTt; itt++)
447  {
448  E += dTt ;
449  dnorm = distTt[itt]/norm;
450  G4cout << std::setw(5) << itt << std::setw(10) << E <<
451  std::setw(12) << distTt[itt] <<
452  std::setw(12) << dnorm << G4endl ;
453  }
454  G4cout << G4endl;
455  }
456  }
457  if(nbinTb>0)
458  {
459  G4double E , dnorm, norm ,sig;
460  G4cout << " backscattered energy distribution " << G4endl ;
461  G4cout << "#entries=" << entryTb << " #underflows=" << underTb <<
462  " #overflows=" << overTb << G4endl ;
463  if( entryTb>0.)
464  {
465  Tbmean /= entryTb;
466  sig=Tb2mean/entryTb-Tbmean*Tbmean ;
467  if(sig<=0.)
468  sig=0.;
469  else
470  sig=std::sqrt(sig/entryTb) ;
471  G4cout << " mean energy of backscattered particles=" << Tbmean/keV <<
472  " +- " << sig/keV << " keV." << G4endl;
473  E = Tblow - dTb ;
474  norm = TotNbofEvents*dTb ;
475  G4cout << " bin nb Elow entries normalized " << G4endl ;
476  for(G4int itt=0; itt<nbinTb; itt++)
477  {
478  E += dTb ;
479  dnorm = distTb[itt]/norm;
480  G4cout << std::setw(5) << itt << std::setw(10) << E <<
481  std::setw(12) << distTb[itt] <<
482  std::setw(12) << dnorm << G4endl ;
483  }
484  G4cout << G4endl;
485  }
486  }
487  if(nbinTsec>0)
488  {G4double E , dnorm, norm ;
489  G4cout << " energy distribution of charged secondaries " << G4endl ;
490  G4cout << "#entries=" << entryTsec << " #underflows=" << underTsec <<
491  " #overflows=" << overTsec << G4endl ;
492  if( entryTsec>0.)
493  {
494  E = Tseclow - dTsec ;
495  norm = TotNbofEvents*dTsec ;
496  G4cout << " bin nb Elow entries normalized " << G4endl ;
497  for(G4int itt=0; itt<nbinTsec; itt++)
498  {
499  E += dTsec ;
500  dnorm = distTsec[itt]/norm;
501  G4cout << std::setw(5) << itt << std::setw(10) << E <<
502  std::setw(12) << distTsec[itt] <<
503  std::setw(12) << dnorm << G4endl ;
504  }
505  G4cout << G4endl;
506  }
507  }
508 
509  if(nbinR >0)
510  {G4double R , dnorm, norm,sig ;
511  G4cout << " R distribution " << G4endl ;
512  G4cout << "#entries=" << entryR << " #underflows=" << underR <<
513  " #overflows=" << overR << G4endl ;
514  if( entryR >0.)
515  {
516  Rmean /= entryR;
517  sig = R2mean/entryR - Rmean*Rmean;
518  if(sig<=0.) sig=0. ;
519  else sig = std::sqrt(sig/entryR) ;
520  G4cout << " mean lateral displacement at exit=" << Rmean/mm << " +- "
521  << sig/mm << " mm." << G4endl ;
522  R = Rlow - dR ;
523  norm = TotNbofEvents*dR ;
524  G4cout << " bin nb Rlow entries normalized " << G4endl ;
525  for(G4int ier=0; ier<nbinR ; ier++)
526  {
527  R+= dR ;
528  dnorm = distR[ier]/norm;
529  G4cout << std::setw(5) << ier << std::setw(10) << R <<
530  std::setw(12) << distR[ier] <<
531  std::setw(12) << dnorm << G4endl ;
532  }
533  G4cout << G4endl;
534  }
535  }
536 
537  if(nbinTh>0)
538  {G4double Th,Thdeg, dnorm, norm,fac0,fnorm,pere,Thpere,Thmean,sum;
539  G4cout << " angle distribution " << G4endl ;
540  G4cout << "#entries=" << entryTh << " #underflows=" << underTh <<
541  " #overflows=" << overTh << G4endl ;
542  if( entryTh>0.)
543  {
544  Th= Thlow - dTh ;
545  norm = TotNbofEvents ;
546  if(distTh[0] == 0.)
547  fac0 = 1. ;
548  else
549  fac0 = 1./distTh[0] ;
550  pere = 1./std::exp(1.) ;
551 
552  G4cout << " bin nb Thlowdeg Thlowrad " <<
553  " entries normalized " << G4endl ;
554  Thpere = 0. ;
555  sum = 0. ;
556  Thmean = 0. ;
557  for(G4int ien=0; ien<nbinTh; ien++)
558  {
559  Th+= dTh ;
560  Thdeg = Th*180./pi ;
561  sum += distTh[ien] ;
562  Thmean += distTh[ien]*(Th+0.5*dTh) ;
563  dnorm = distTh[ien]/norm;
564  fnorm = fac0*distTh[ien] ;
565  if( fnorm > pere)
566  Thpere = Th ;
567  G4cout << std::setw(5) << ien << std::setw(10) << Thdeg << " " <<
568  std::setw(10) << Th << " " <<
569  std::setw(12) << distTh[ien] << " " <<
570  std::setw(12) << dnorm << " " << std::setw(12) << fnorm <<G4endl ;
571  }
572  Thmean /= sum ;
573  G4cout << G4endl;
574  G4cout << " mean = " << Thmean << " rad or " << 180.*Thmean/pi <<
575  " deg." << G4endl;
576  G4cout << " theta(1/e)=" << Thpere << " - " << Thpere+dTh << " rad "
577  << " or " << 180.*Thpere/pi << " - " << 180.*(Thpere+dTh)/pi
578  << " deg." << G4endl;
579  G4cout << G4endl;
580  }
581  }
582 
583  if(nbinThback>0)
584  {G4double Thb,Thdegb, dnormb, normb,fac0b,fnormb,pereb,Thpereb,Thmeanb,sumb;
585  G4cout << " backscattering angle distribution " << G4endl ;
586  G4cout << "#entries=" << entryThback << " #underflows=" << underThback <<
587  " #overflows=" << overThback << G4endl ;
588  if( entryThback>0.)
589  {
590  Thb= Thlowback - dThback ;
591  normb = TotNbofEvents ;
592  if(distThback[0] == 0.)
593  fac0b = 1. ;
594  else
595  fac0b = 1./distThback[0] ;
596  pereb = 1./std::exp(1.) ;
597 
598  G4cout << " bin nb Thlowdeg Thlowrad " <<
599  " entries normalized " << G4endl ;
600  Thpereb = 0. ;
601  sumb = 0. ;
602  Thmeanb = 0. ;
603  for(G4int ien=0; ien<nbinThback; ien++)
604  {
605  Thb+= dThback ;
606  Thdegb = Thb*180./pi ;
607  sumb += distThback[ien] ;
608  Thmeanb += distThback[ien]*(Thb+0.5*dThback) ;
609  dnormb = distThback[ien]/normb;
610  fnormb = fac0b*distThback[ien] ;
611  if( fnormb > pereb)
612  Thpereb = Thb ;
613  G4cout << std::setw(5) << ien << std::setw(10) << Thdegb << " " <<
614  std::setw(10) << Thb << " " <<
615  std::setw(12) << distThback[ien] << " " <<
616  std::setw(12) << dnormb << " " << std::setw(12) << fnormb <<G4endl ;
617  }
618  Thmeanb /= sumb ;
619  G4cout << G4endl;
620  G4cout << " mean = " << Thmeanb << " rad or " << 180.*Thmeanb/pi <<
621  " deg." << G4endl;
622  G4cout << " theta(1/e)=" << Thpereb << " - " << Thpereb+dThback << " rad "
623  << " or " << 180.*Thpereb/pi << " - " << 180.*(Thpereb+dThback)/pi
624  << " deg." << G4endl;
625  G4cout << G4endl;
626  }
627  }
628 
629  if(nbinGamma>0)
630  {G4double E , fact,dnorm, norm ;
631  G4cout << " gamma energy distribution " << G4endl ;
632  G4cout << "#entries=" << entryGamma << " #underflows=" << underGamma <<
633  " #overflows=" << overGamma << G4endl ;
634  if( entryGamma>0.)
635  {
636  fact=std::exp(dEGamma) ;
637  E = ElowGamma/fact ;
638  norm = TotNbofEvents*dEGamma;
639  G4cout << " bin nb Elow entries normalized " << G4endl ;
640  for(G4int itt=0; itt<nbinGamma; itt++)
641  {
642  E *= fact ;
643  dnorm = distGamma[itt]/norm;
644  G4cout << std::setw(5) << itt << std::setw(13) << E <<
645  std::setw(12) << distGamma[itt] <<
646  std::setw(15) << dnorm << G4endl ;
647  }
648  G4cout << G4endl;
649  }
650  }
651 
652  if(nbinvertexz >0)
653  {G4double z , dnorm, norm ;
654  G4cout << " vertex Z distribution " << G4endl ;
655  G4cout << "#entries=" << entryvertexz << " #underflows=" << undervertexz <<
656  " #overflows=" << oververtexz << G4endl ;
657  if( entryvertexz >0.)
658  {
659  z =zlow - dz ;
660  norm = TotNbofEvents*dz ;
661  G4cout << " bin nb zlow entries normalized " << G4endl ;
662  for(G4int iez=0; iez<nbinvertexz ; iez++)
663  {
664  z+= dz ;
665  if(std::fabs(z)<1.e-12) z=0.;
666  dnorm = distvertexz[iez]/norm;
667  G4cout << std::setw(5) << iez << std::setw(10) << z <<
668  std::setw(12) << distvertexz[iez] <<
669  std::setw(12) << dnorm << G4endl ;
670  }
671  G4cout << G4endl;
672  }
673  }
674 
675  G4cout.precision(prec);
676 
677  if (G4VVisManager::GetConcreteInstance())
678  {
679  G4UImanager::GetUIpointer()->ApplyCommand("/vis/viewer/update");
680  }
681 
682  // save Rndm status
683 
684  if (saveRndm == 1)
685  {
686  CLHEP::HepRandom::showEngineStatus();
687  CLHEP::HepRandom::saveEngineStatus("endOfRun.rndm");
688  }
689 }
690 
691 ///////////////////////////////////////////////////////////////////////////
692 
693 void Em10RunAction::CountEvent()
694 {
695  TotNbofEvents += 1. ;
696 }
697 
698 /////////////////////////////////////////////////////////////////////////
699 
700 void Em10RunAction::AddnStepsCharged(G4double nstp)
701 {
702  nStepSumCharged += nstp;
703  nStepSum2Charged += nstp*nstp;
704 }
705 
706 ////////////////////////////////////////////////////////////////////////
707 
708 void Em10RunAction::AddnStepsNeutral(G4double nstp)
709 {
710  nStepSumNeutral += nstp;
711  nStepSum2Neutral += nstp*nstp;
712 }
713 
714 ////////////////////////////////////////////////////////////////////////////
715 
716 void Em10RunAction::AddEdeps(G4double Eabs)
717 {
718  EnergySumAbs += Eabs;
719  EnergySquareSumAbs += Eabs*Eabs;
720 }
721 
722 /////////////////////////////////////////////////////////////////////////////
723 
724 void Em10RunAction::AddTrackLength(G4double tlabs)
725 {
726  tlSumAbs += tlabs;
727  tlsquareSumAbs += tlabs*tlabs ;
728 }
729 
730 /////////////////////////////////////////////////////////////////////////////
731 
732 void Em10RunAction::AddTrRef(G4double tr,G4double ref)
733 {
734  Transmitted += tr ;
735  Reflected += ref;
736 }
737 
738 /////////////////////////////////////////////////////////////////////////////
739 
740 void Em10RunAction::FillNbOfSteps(G4double)// ns)
741 {
742 }
743 
744 //////////////////////////////////////////////////////////////////////////////
745 
746 void Em10RunAction::FillEn(G4double En)
747 {
748  G4double bin ;
749  G4int ibin;
750 
751  entryEn += 1. ;
752  if(Enlow < Enhigh) {
753 
754  if(En < Enlow) underEn += 1. ;
755  else if( En >= Enhigh) overEn += 1. ;
756  else
757  {
758  bin = (En-Enlow)/dEn;
759  ibin= (G4int)bin;
760  if(ibin < 0) { ibin = 0; }
761  if(ibin > 199) { ibin = 199; }
762  distEn[ibin] += 1.;
763  }
764  }
765 }
766 
767 ////////////////////////////////////////////////////////////////////////////
768 
769 void Em10RunAction::FillTt(G4double) // En)
770 {
771 }
772 
773 //////////////////////////////////////////////////////////////////////////////
774 
775 void Em10RunAction::FillTb(G4double) // En)
776 {
777 }
778 
779 ///////////////////////////////////////////////////////////////////////////////
780 
781 void Em10RunAction::FillTsec(G4double) // En)
782 {
783 }
784 
785 /////////////////////////////////////////////////////////////////////////////
786 
787 void Em10RunAction::FillGammaSpectrum(G4double) // En)
788 {
789 }
790 
791 ////////////////////////////////////////////////////////////////////////////////
792 
793 void Em10RunAction::FillTh(G4double) // Th)
794 {
795 }
796 
797 //////////////////////////////////////////////////////////////////////////
798 
799 void Em10RunAction::FillThBack(G4double) // Th)
800 {
801 }
802 
803 //////////////////////////////////////////////////////////////////////////
804 
805 void Em10RunAction::FillR(G4double) // R )
806 {
807 }
808 
809 /////////////////////////////////////////////////////////////////////////////
810 
811 void Em10RunAction::Fillvertexz(G4double) // z )
812 {
813 }
814 
815 //////////////////////////////////////////////////////////////////////////////
816 
817 void Em10RunAction::SethistName(G4String name)
818 {
819  histName = name ;
820  G4cout << " hist file = " << histName << G4endl;
821 }
822 
823 void Em10RunAction::SetnbinStep(G4int nbin)
824 {
825  if(nbin> 0 && nbin<= 200) {
826  nbinStep = nbin;
827  G4cout << " Nb of bins in #step plot = " << nbinStep << G4endl ;
828  }
829 }
830 
831 void Em10RunAction::SetSteplow(G4double low)
832 {
833  if(low >= 0.0){
834  Steplow = low ;
835  G4cout << " low in the #step plot = " << Steplow << G4endl ;
836  }
837 }
838 void Em10RunAction::SetStephigh(G4double high)
839 {
840  if(high > 0.0) {
841  Stephigh = high;
842  G4cout << " high in the #step plot = " << Stephigh << G4endl ;
843  }
844 }
845 
846 ////////////////////////////////////////////////////////////////////////
847 
848 void Em10RunAction::SetnbinEn(G4int nbin)
849 {
850  if(nbin > 0 && nbin <= 200) {
851  nbinEn = nbin;
852  G4cout << " Nb of bins in Edep plot = " << nbinEn << G4endl ;
853  }
854 }
855 
856 void Em10RunAction::SetEnlow(G4double Elow)
857 {
858  if(Elow >= 0.0) {
859  Enlow = Elow ;
860  G4cout << " Elow in the Edep plot = " << Enlow << G4endl ;
861  }
862 }
863 
864 void Em10RunAction::SetEnhigh(G4double Ehigh)
865 {
866  if(Ehigh > 0.0) {
867  Enhigh = Ehigh ;
868  G4cout << " Ehigh in the Edep plot = " << Enhigh << G4endl ;
869  }
870 }
871 
872 /////////////////////////////////////////////////////////////////////////
873 
874 void Em10RunAction::SetnbinGamma(G4int nbin)
875 {
876  if(nbin > 0 && nbin <= 200) {
877  nbinGamma = nbin;
878  G4cout << " Nb of bins in gamma spectrum plot = " << nbinGamma << G4endl ;
879  }
880 }
881 
882 void Em10RunAction::SetElowGamma(G4double Elow)
883 {
884  if(Elow >= 0.0) {
885  ElowGamma = Elow;
886  G4cout << " Elow in the gamma spectrum plot = " << ElowGamma << G4endl ;
887  }
888 }
889 
890 void Em10RunAction::SetEhighGamma(G4double Ehigh)
891 {
892  if(Ehigh > 0.0) {
893  EhighGamma = Ehigh;
894  G4cout << " Ehigh in the gamma spectrum plot = " << EhighGamma << G4endl ;
895  }
896 }
897 
898 void Em10RunAction::SetnbinTt(G4int nbin)
899 {
900  if(nbin > 0 && nbin <= 200) {
901  nbinTt = nbin;
902  G4cout << " Nb of bins in Etransmisssion plot = " << nbinTt << G4endl ;
903  }
904 }
905 
906 void Em10RunAction::SetTtlow(G4double Elow)
907 {
908  if(Elow >= 0.0) {
909  Ttlow = Elow;
910  G4cout << " Elow in the Etransmission plot = " << Ttlow << G4endl ;
911  }
912 }
913 
914 void Em10RunAction::SetTthigh(G4double Ehigh)
915 {
916  if(Ehigh > 0.0) {
917  Tthigh = Ehigh;
918  G4cout << " Ehigh in the Etransmission plot = " << Tthigh << G4endl ;
919  }
920 }
921 
922 void Em10RunAction::SetnbinTb(G4int nbin)
923 {
924  if(nbin > 0 && nbin <= 200) {
925  nbinTb = nbin;
926  G4cout << " Nb of bins in Ebackscattered plot = " << nbinTb << G4endl ;
927  }
928 }
929 
930 void Em10RunAction::SetTblow(G4double Elow)
931 {
932 
933  Tblow = Elow ;
934  G4cout << " Elow in the Ebackscattered plot = " << Tblow << G4endl ;
935 }
936 
937 void Em10RunAction::SetTbhigh(G4double Ehigh)
938 {
939  Tbhigh = Ehigh ;
940  G4cout << " Ehigh in the Ebackscattered plot = " << Tbhigh << G4endl ;
941 }
942 
943 void Em10RunAction::SetnbinTsec(G4int nbin)
944 {
945  if(nbin > 0 && nbin <= 200) {
946  nbinTsec = nbin;
947  G4cout << " Nb of bins in Tsecondary plot = " << nbinTsec << G4endl ;
948  }
949 }
950 
951 void Em10RunAction::SetTseclow(G4double Elow)
952 {
953  Tseclow = Elow ;
954  G4cout << " Elow in the Tsecondary plot = " << Tseclow << G4endl ;
955 }
956 
957 void Em10RunAction::SetTsechigh(G4double Ehigh)
958 {
959  Tsechigh = Ehigh ;
960  G4cout << " Ehigh in the Tsecondary plot = " << Tsechigh << G4endl ;
961 }
962 
963 void Em10RunAction::SetnbinR(G4int nbin)
964 {
965  if(nbin > 0 && nbin <= 200) {
966  nbinR = nbin;
967  G4cout << " Nb of bins in R plot = " << nbinR << G4endl ;
968  }
969 }
970 
971 void Em10RunAction::SetRlow(G4double rlow)
972 {
973  Rlow = rlow ;
974  G4cout << " Rlow in the R plot = " << Rlow << G4endl ;
975 }
976 
977 void Em10RunAction::SetRhigh(G4double rhigh)
978 {
979  Rhigh = rhigh ;
980  G4cout << " Rhigh in the R plot = " << Rhigh << G4endl ;
981 }
982 
983 void Em10RunAction::Setnbinzvertex(G4int nbin)
984 {
985  if(nbin > 0 && nbin <= 200) {
986  nbinvertexz = nbin;
987  G4cout << " Nb of bins in Z plot = " << nbinvertexz << G4endl ;
988  }
989 }
990 
991 void Em10RunAction::Setzlow(G4double z)
992 {
993  zlow = z ;
994  G4cout << " zlow in the Z plot = " << zlow << G4endl ;
995 }
996 
997 void Em10RunAction::Setzhigh(G4double z)
998 {
999  zhigh = z ;
1000  G4cout << " zhigh in the Z plot = " << zhigh << G4endl ;
1001 }
1002 
1003 void Em10RunAction::SetnbinTh(G4int nbin)
1004 {
1005  if(nbin > 0 && nbin <= 200) {
1006  nbinTh = nbin;
1007  G4cout << " Nb of bins in Theta plot = " << nbinTh << G4endl ;
1008  }
1009 }
1010 
1011 void Em10RunAction::SetThlow(G4double Tlow)
1012 {
1013  Thlow = Tlow ;
1014  G4cout << " Tlow in the Theta plot = " << Thlow << G4endl ;
1015 }
1016 
1017 void Em10RunAction::SetThhigh(G4double Thigh)
1018 {
1019  Thhigh = Thigh ;
1020  G4cout << " Thigh in the Theta plot = " << Thhigh << G4endl ;
1021 }
1022 
1023 void Em10RunAction::SetnbinThBack(G4int nbin)
1024 {
1025  if(nbin > 0 && nbin <= 200) {
1026  nbinThback = nbin;
1027  G4cout << " Nb of bins in Theta plot = " << nbinThback << G4endl ;
1028  }
1029 }
1030 
1031 void Em10RunAction::SetThlowBack(G4double Tlow)
1032 {
1033  Thlowback = Tlow ;
1034  G4cout << " Tlow in the Theta plot = " << Thlowback << G4endl ;
1035 }
1036 
1037 void Em10RunAction::SetThhighBack(G4double Thigh)
1038 {
1039  Thhighback = Thigh ;
1040  G4cout << " Thigh in the Theta plot = " << Thhighback << G4endl ;
1041 }
1042 
1043 void Em10RunAction::CountParticles(G4double nch,G4double nne)
1044 {
1045  SumCharged += nch ;
1046  SumNeutral += nne ;
1047  Sum2Charged += nch*nch ;
1048  Sum2Neutral += nne*nne ;
1049 }
1050 
1051 void Em10RunAction::AddEP(G4double nele,G4double npos)
1052 {
1053  Selectron += nele;
1054  Spositron += npos;
1055 }
1056 
1057 //
1058 //
1059 ////////////////////////////////////////////////////////////////////////
Em10RunAction::Fillvertexz
void Fillvertexz(G4double z)
Definition: Em10RunAction.cc:811
Em10RunAction::SetThhigh
void SetThhigh(G4double Thhigh)
Definition: Em10RunAction.cc:1017
Em10RunAction::SetEnhigh
void SetEnhigh(G4double Enhigh)
Definition: Em10RunAction.cc:864
Em10RunAction::SethistName
void SethistName(G4String name)
Definition: Em10RunAction.cc:817
Em10RunAction::SetnbinR
void SetnbinR(G4int nbin)
Definition: Em10RunAction.cc:963
plottest35.bin
tuple bin
Definition: plottest35.py:22
Em10RunAction::SetTblow
void SetTblow(G4double Tblow)
Definition: Em10RunAction.cc:930
Em10RunAction.hh
Definition of the Em10RunAction class.
Em10RunAction::SetnbinTh
void SetnbinTh(G4int nbin)
Definition: Em10RunAction.cc:1003
Em10RunAction::SetEhighGamma
void SetEhighGamma(G4double Ehigh)
Definition: Em10RunAction.cc:890
G4VVisManager::GetConcreteInstance
static G4VVisManager * GetConcreteInstance()
Definition: G4VVisManager.cc:39
z
G4double z
Definition: TRTMaterials.hh:39
Em10RunAction::SetnbinGamma
void SetnbinGamma(G4int nbin)
Definition: Em10RunAction.cc:874
Em10RunAction::Setzlow
void Setzlow(G4double z)
Definition: Em10RunAction.cc:991
Em10RunAction::FillTh
void FillTh(G4double Th)
Definition: Em10RunAction.cc:793
name
const XML_Char * name
Definition: include/expat.h:151
Em10RunAction::SetnbinTt
void SetnbinTt(G4int nbin)
Definition: Em10RunAction.cc:898
Em10RunAction::FillNbOfSteps
void FillNbOfSteps(G4double nstep)
Definition: Em10RunAction.cc:740
Em10RunAction::FillThBack
void FillThBack(G4double Th)
Definition: Em10RunAction.cc:799
G4int
int G4int
Definition: G4Types.hh:78
Em10RunAction::CountParticles
void CountParticles(G4double, G4double)
Definition: Em10RunAction.cc:1043
Em10RunAction::SetTtlow
void SetTtlow(G4double Ttlow)
Definition: Em10RunAction.cc:906
G4UImanager::GetUIpointer
static G4UImanager * GetUIpointer()
Definition: G4UImanager.cc:58
Em10RunAction::FillEn
void FillEn(G4double En)
Definition: Em10RunAction.cc:746
Em10RunAction::FillR
void FillR(G4double R)
Definition: Em10RunAction.cc:805
G4VVisManager.hh
Em10RunAction::Setzhigh
void Setzhigh(G4double z)
Definition: Em10RunAction.cc:997
G4cout
G4GLOB_DLL std::ostream G4cout
Em10RunAction::SetRlow
void SetRlow(G4double Rlow)
Definition: Em10RunAction.cc:971
Em10RunAction::SetnbinTsec
void SetnbinTsec(G4int nbin)
Definition: Em10RunAction.cc:943
Em10RunMessenger.hh
Definition of the Em10RunMessenger class.
Em10RunAction::SetTbhigh
void SetTbhigh(G4double Tbhigh)
Definition: Em10RunAction.cc:937
Em10RunAction::SetnbinEn
void SetnbinEn(G4int nbin)
Definition: Em10RunAction.cc:848
Em10RunAction::BeginOfRunAction
void BeginOfRunAction(const G4Run *)
Definition: Em10RunAction.cc:86
Em10RunAction::SetnbinTb
void SetnbinTb(G4int nbin)
Definition: Em10RunAction.cc:922
iz
G4double iz
Definition: TRTMaterials.hh:39
Em10RunAction::EndOfRunAction
void EndOfRunAction(const G4Run *)
Definition: Em10RunAction.cc:247
G4Run::GetRunID
G4int GetRunID() const
Definition: G4Run.hh:76
Em10RunAction::SetSteplow
void SetSteplow(G4double Slow)
Definition: Em10RunAction.cc:831
Em10RunAction::SetnbinStep
void SetnbinStep(G4int nbin)
Definition: Em10RunAction.cc:823
G4Run
Definition: G4Run.hh:46
G4UImanager.hh
Randomize.hh
Em10RunAction::AddEdeps
void AddEdeps(G4double Eabs)
Definition: Em10RunAction.cc:716
Em10RunAction::FillTt
void FillTt(G4double Tt)
Definition: Em10RunAction.cc:769
CLHEP::HepRandom::showEngineStatus
static void showEngineStatus()
Definition: Random.cc:203
G4PhysicalConstants.hh
Em10RunAction::SetnbinThBack
void SetnbinThBack(G4int nbin)
Definition: Em10RunAction.cc:1023
Em10RunAction::SetEnlow
void SetEnlow(G4double Elow)
Definition: Em10RunAction.cc:856
Em10RunAction::SetTthigh
void SetTthigh(G4double Tthigh)
Definition: Em10RunAction.cc:914
G4Run.hh
Em10RunAction::SetTseclow
void SetTseclow(G4double Tlow)
Definition: Em10RunAction.cc:951
CLHEP::HepRandom::saveEngineStatus
static void saveEngineStatus(const char filename[]="Config.conf")
Definition: Random.cc:175
G4ios.hh
Em10RunAction::SetTsechigh
void SetTsechigh(G4double Thigh)
Definition: Em10RunAction.cc:957
Em10RunAction::AddTrRef
void AddTrRef(G4double tr, G4double ref)
Definition: Em10RunAction.cc:732
Em10RunAction::FillTsec
void FillTsec(G4double T)
Definition: Em10RunAction.cc:781
Em10RunAction::FillGammaSpectrum
void FillGammaSpectrum(G4double E)
Definition: Em10RunAction.cc:787
G4endl
#define G4endl
Definition: G4ios.hh:61
Em10RunAction::SetStephigh
void SetStephigh(G4double Shigh)
Definition: Em10RunAction.cc:838
Em10RunAction::AddnStepsNeutral
void AddnStepsNeutral(G4double ns)
Definition: Em10RunAction.cc:708
Em10RunAction::Setnbinzvertex
void Setnbinzvertex(G4int nbin)
Definition: Em10RunAction.cc:983
G4double
double G4double
Definition: G4Types.hh:76
G4SystemOfUnits.hh
Em10RunAction::SetElowGamma
void SetElowGamma(G4double Elow)
Definition: Em10RunAction.cc:882
Em10RunAction::SetThlowBack
void SetThlowBack(G4double Thlow)
Definition: Em10RunAction.cc:1031
Em10RunAction::AddnStepsCharged
void AddnStepsCharged(G4double ns)
Definition: Em10RunAction.cc:700
Em10RunAction::AddTrackLength
void AddTrackLength(G4double tlabs)
Definition: Em10RunAction.cc:724
Em10RunAction::AddEP
void AddEP(G4double, G4double)
Definition: Em10RunAction.cc:1051
Em10RunAction::FillTb
void FillTb(G4double Tt)
Definition: Em10RunAction.cc:775
Em10RunAction::SetRhigh
void SetRhigh(G4double Rhigh)
Definition: Em10RunAction.cc:977
G4UImanager::ApplyCommand
G4int ApplyCommand(const char *aCommand)
Definition: G4UImanager.cc:419
Em10RunAction::SetThhighBack
void SetThhighBack(G4double Thhigh)
Definition: Em10RunAction.cc:1037
Em10RunAction::SetThlow
void SetThlow(G4double Thlow)
Definition: Em10RunAction.cc:1011
Generated on Wed Apr 30 2014 15:54:33 for Geant4.10 by   doxygen 1.8.7