Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Data Structures | Public Member Functions
Run Class Reference

#include <Run.hh>

Inheritance diagram for Run:
G4Run G4Run G4Run G4Run G4Run

Public Member Functions

 Run (DetectorConstruction *)
 
 ~Run ()
 
void CountTraks0 (G4int nt)
 
void CountTraks1 (G4int nt)
 
void CountSteps0 (G4int ns)
 
void CountSteps1 (G4int ns)
 
void CountProcesses (G4String procName)
 
void AddEdep (G4double val)
 
void AddTrueRange (G4double l)
 
void AddProjRange (G4double x)
 
void AddTransvDev (G4double y)
 
void SetPrimary (G4ParticleDefinition *particle, G4double energy)
 
void PrintSummary () const
 
void ComputeStatistics ()
 
virtual void Merge (const G4Run *)
 
 Run (DetectorConstruction *detector)
 
 ~Run ()
 
void ComputeStatistics ()
 
void AddEdep (G4double e)
 
void AddTrackLength (G4double t)
 
void AddProjRange (G4double x)
 
void AddStepSize (G4int nb, G4double s)
 
void AddTrackStatus (G4int i)
 
void SetCsdaRange (G4int i, G4double value)
 
void SetXfrontNorm (G4int i, G4double value)
 
G4double GetCsdaRange (G4int i)
 
G4double GetXfrontNorm (G4int i)
 
virtual void Merge (const G4Run *)
 
 Run (DetectorConstruction *, PrimaryGeneratorAction *)
 
virtual ~Run ()
 
virtual void Merge (const G4Run *)
 
void InitializePerEvent ()
 
void FillPerEvent ()
 
void FillPerTrack (G4double, G4double)
 
void FillPerStep (G4double, G4int, G4int)
 
void AddStep (G4double q)
 
void ComputeStatistics (G4double edep, G4double rms, G4double &limit)
 
void SetVerbose (G4int val)
 
 Run (DetectorConstruction *)
 
 ~Run ()
 
void SetPrimary (G4ParticleDefinition *particle, G4double energy)
 
void AddEnergy (G4double edep)
 
void AddTrakLenCharg (G4double length)
 
void AddTrakLenNeutr (G4double length)
 
void AddMscProjTheta (G4double theta)
 
void CountStepsCharg (G4int nSteps)
 
void CountStepsNeutr (G4int nSteps)
 
void CountParticles (G4ParticleDefinition *part)
 
void CountTransmit (G4int flag)
 
void CountReflect (G4int flag)
 
void AddEnergyLeak (G4double eleak, G4int index)
 
G4double ComputeMscHighland ()
 
virtual void Merge (const G4Run *)
 
void PrintSummary ()
 
 Run (DetectorConstruction *)
 
 ~Run ()
 
void CountProcesses (const G4VProcess *process)
 
void ParticleCount (G4String, G4double)
 
void SumTrackLength (G4int, G4int, G4double, G4double, G4double, G4double)
 
void ComputeStatistics ()
 
virtual void Merge (const G4Run *)
 
- Public Member Functions inherited from G4Run
 G4Run ()
 
virtual ~G4Run ()
 
virtual void RecordEvent (const G4Event *)
 
G4int GetRunID () const
 
G4int GetNumberOfEvent () const
 
G4int GetNumberOfEventToBeProcessed () const
 
const G4HCtable * GetHCtable () const
 
const G4DCtable * GetDCtable () const
 
const G4String & GetRandomNumberStatus () const
 
void SetRunID (G4int id)
 
void SetNumberOfEventToBeProcessed (G4int n_ev)
 
void SetHCtable (G4HCtable *HCtbl)
 
void SetDCtable (G4DCtable *DCtbl)
 
void SetRandomNumberStatus (G4String &st)
 
void StoreEvent (G4Event *evt)
 
const std::vector< const
G4Event * > * 		GetEventVector () const
 

Additional Inherited Members

- Protected Attributes inherited from G4Run
G4int runID
 
G4int numberOfEvent
 
G4int numberOfEventToBeProcessed
 
G4HCtable * HCtable
 
G4DCtable * DCtable
 
G4String randomNumberStatus
 
std::vector< const G4Event * > * eventVector
 

Detailed Description

Definition at line 46 of file electromagnetic/TestEm1/include/Run.hh.

Constructor & Destructor Documentation

Run::Run ( DetectorConstruction *  det)

Definition at line 46 of file electromagnetic/TestEm1/src/Run.cc.

47 : G4Run(),
48  fDetector(det),
49  fParticle(0), fEkin(0.),
50  fNbOfTraks0(0), fNbOfTraks1(0),
51  fNbOfSteps0(0), fNbOfSteps1(0),
52  fEdep(0),
53  fTrueRange(0.), fTrueRange2(0.),
54  fProjRange(0.), fProjRange2(0.),
55  fTransvDev(0.), fTransvDev2(0.)
56 { }
G4Run::G4Run
G4Run()
Definition: G4Run.cc:34
Run::~Run ( )

Definition at line 60 of file electromagnetic/TestEm1/src/Run.cc.

61 { }
Run::Run ( DetectorConstruction *  detector)
Run::~Run ( )
Run::Run ( DetectorConstruction *  det,
PrimaryGeneratorAction *  kin 
)

Definition at line 53 of file electromagnetic/TestEm2/src/Run.cc.

54  :G4Run(),fDet(det),fKin(kin),
55  f_nLbin(MaxBin),f_nRbin(MaxBin)
56 {
57  Reset();
58 }
G4Run::G4Run
G4Run()
Definition: G4Run.cc:34
virtual Run::~Run ( )
virtual
Run::Run ( DetectorConstruction *  )
Run::~Run ( )
Run::Run ( DetectorConstruction *  )
Run::~Run ( )

Member Function Documentation

void Run::AddEdep ( G4double  e)
inline

Definition at line 55 of file electromagnetic/TestEm11/include/Run.hh.

55 { fEdeposit += e; fEdeposit2 += e*e;};
void Run::AddEdep ( G4double  val)
inline

Definition at line 59 of file electromagnetic/TestEm1/include/Run.hh.

59 { fEdep += val;}
void Run::AddEnergy ( G4double  edep)
inline

Definition at line 60 of file electromagnetic/TestEm5/include/Run.hh.

61  {fEnergyDeposit += edep; fEnergyDeposit2 += edep*edep;};
void Run::AddEnergyLeak ( G4double  eleak,
G4int  index 
)
inline

Definition at line 93 of file electromagnetic/TestEm5/include/Run.hh.

94  {fEnergyLeak[index] += eleak; fEnergyLeak2[index] += eleak*eleak;};
void Run::AddMscProjTheta ( G4double  theta)
inline

Definition at line 69 of file electromagnetic/TestEm5/include/Run.hh.

70  {if (std::abs(theta) <= fMscThetaCentral) { fMscEntryCentral++;
71  fMscProjecTheta += theta; fMscProjecTheta2 += theta*theta;}
72  };
void Run::AddProjRange ( G4double  x)
inline

Definition at line 57 of file electromagnetic/TestEm11/include/Run.hh.

References test::x.

57 { fProjRange += x; fProjRange2 += x*x;};
void Run::AddProjRange ( G4double  x)
inline

Definition at line 61 of file electromagnetic/TestEm1/include/Run.hh.

References test::x.

61 { fProjRange += x; fProjRange2 += x*x;}
void Run::AddStep ( G4double  q)
inline

Definition at line 129 of file electromagnetic/TestEm2/include/Run.hh.

130 {
131  if (q == 0.0) { fNeutralStep += 1.0; }
132  else { fChargedStep += 1.0; }
133 }
void Run::AddStepSize ( G4int  nb,
G4double  s 
)
inline

Definition at line 58 of file electromagnetic/TestEm11/include/Run.hh.

59  { fNbOfSteps += nb; fNbOfSteps2 += nb*nb;
60  fStepSize += s ; fStepSize2 += s*s; };
s
const XML_Char * s
Definition: include/expat.h:262
void Run::AddTrackLength ( G4double  t)
inline

Definition at line 56 of file electromagnetic/TestEm11/include/Run.hh.

56 { fTrackLen += t; fTrackLen2 += t*t;};
void Run::AddTrackStatus ( G4int  i)
inline

Definition at line 61 of file electromagnetic/TestEm11/include/Run.hh.

61 { fStatus[i]++ ;};
void Run::AddTrakLenCharg ( G4double  length)
inline

Definition at line 63 of file electromagnetic/TestEm5/include/Run.hh.

64  {fTrakLenCharged += length; fTrakLenCharged2 += length*length;};
void Run::AddTrakLenNeutr ( G4double  length)
inline

Definition at line 66 of file electromagnetic/TestEm5/include/Run.hh.

67  {fTrakLenNeutral += length; fTrakLenNeutral2 += length*length;};
void Run::AddTransvDev ( G4double  y)
inline

Definition at line 62 of file electromagnetic/TestEm1/include/Run.hh.

62 { fTransvDev += y; fTransvDev2 += y*y;}
void Run::AddTrueRange ( G4double  l)
inline

Definition at line 60 of file electromagnetic/TestEm1/include/Run.hh.

60 { fTrueRange += l; fTrueRange2 += l*l;}
G4double Run::ComputeMscHighland ( )

Definition at line 310 of file electromagnetic/TestEm5/src/Run.cc.

References DBL_MIN, python.hepunit::eplus, DetectorConstruction::GetAbsorberMaterial(), DetectorConstruction::GetAbsorberThickness(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4Material::GetRadlen(), python.hepunit::MeV, and z.

Referenced by PrintSummary().

311 {
312  //compute the width of the Gaussian central part of the MultipleScattering
313  //projected angular distribution.
314  //Eur. Phys. Jour. C15 (2000) page 166, formule 23.9
315 
316  G4double t = (fDetector->GetAbsorberThickness())
317  /(fDetector->GetAbsorberMaterial()->GetRadlen());
318  if (t < DBL_MIN) return 0.;
319 
320  G4double T = fEkin;
321  G4double M = fParticle->GetPDGMass();
322  G4double z = std::abs(fParticle->GetPDGCharge()/eplus);
323 
324  G4double bpc = T*(T+2*M)/(T+M);
325  G4double teta0 = 13.6*MeV*z*std::sqrt(t)*(1.+0.038*std::log(t))/bpc;
326  return teta0;
327 }
z
G4double z
Definition: TRTMaterials.hh:39
G4Material::GetRadlen
G4double GetRadlen() const
Definition: G4Material.hh:218
G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:161
DBL_MIN
#define DBL_MIN
Definition: templates.hh:75
G4double
double G4double
Definition: G4Types.hh:76
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
void Run::ComputeStatistics ( )
void Run::ComputeStatistics ( )
void Run::ComputeStatistics ( )

Definition at line 97 of file electromagnetic/TestEm1/src/Run.cc.

References density, G4BestUnit, G4cout, G4endl, G4EmCalculator::GetCSDARange(), G4Material::GetDensity(), DetectorConstruction::GetMaterial(), G4ParticleDefinition::GetPDGCharge(), eplot::material, and G4Run::numberOfEvent.

98 {
99  G4int prec = 5, wid = prec + 2;
100  G4int dfprec = G4cout.precision(prec);
101 
102  G4double dNbOfEvents = double(numberOfEvent);
103  G4cout << "\n total energy deposit: "
104  << G4BestUnit(fEdep/dNbOfEvents, "Energy") << G4endl;
105 
106  //nb of tracks and steps per event
107  //
108  G4cout << "\n nb tracks/event"
109  << " neutral: " << std::setw(wid) << fNbOfTraks0/dNbOfEvents
110  << " charged: " << std::setw(wid) << fNbOfTraks1/dNbOfEvents
111  << "\n nb steps/event"
112  << " neutral: " << std::setw(wid) << fNbOfSteps0/dNbOfEvents
113  << " charged: " << std::setw(wid) << fNbOfSteps1/dNbOfEvents
114  << G4endl;
115 
116  //frequency of processes call
117  std::map<G4String,G4int>::iterator it;
118  G4cout << "\n nb of process calls per event: \n ";
119  for (it = fProcCounter.begin(); it != fProcCounter.end(); it++)
120  G4cout << std::setw(12) << it->first;
121 
122  G4cout << "\n ";
123  for (it = fProcCounter.begin(); it != fProcCounter.end(); it++)
124  G4cout << std::setw(12) << (it->second)/dNbOfEvents;
125  G4cout << G4endl;
126 
127  //compute true and projected ranges, and transverse dispersion
128  //
129  fTrueRange /= numberOfEvent; fTrueRange2 /= numberOfEvent;
130  G4double trueRms = fTrueRange2 - fTrueRange*fTrueRange;
131  if (trueRms>0.) trueRms = std::sqrt(trueRms); else trueRms = 0.;
132 
133  fProjRange /= numberOfEvent; fProjRange2 /= numberOfEvent;
134  G4double projRms = fProjRange2 - fProjRange*fProjRange;
135  if (projRms>0.) projRms = std::sqrt(projRms); else projRms = 0.;
136 
137  fTransvDev /= 2*numberOfEvent; fTransvDev2 /= 2*numberOfEvent;
138  G4double trvsRms = fTransvDev2 - fTransvDev*fTransvDev;
139  if (trvsRms>0.) trvsRms = std::sqrt(trvsRms); else trvsRms = 0.;
140 
141  //compare true range with csda range from PhysicsTables
142  //
143  G4Material* material = fDetector->GetMaterial();
144  G4double density = material->GetDensity();
145  //
146  G4EmCalculator emCalculator;
147  G4double rangeTable = 0.;
148  if (fParticle->GetPDGCharge() != 0.)
149  rangeTable = emCalculator.GetCSDARange(fEkin,fParticle,material);
150 
151  G4cout << "\n---------------------------------------------------------\n";
152  G4cout << " Primary particle : " ;
153  G4cout << "\n true Range = " << G4BestUnit(fTrueRange,"Length")
154  << " rms = " << G4BestUnit(trueRms, "Length");
155 
156  G4cout << "\n proj Range = " << G4BestUnit(fProjRange,"Length")
157  << " rms = " << G4BestUnit(projRms, "Length");
158 
159  G4cout << "\n proj/true = " << fProjRange/fTrueRange;
160 
161  G4cout << "\n transverse dispersion at end = "
162  << G4BestUnit(trvsRms,"Length");
163 
164  G4cout << "\n mass true Range from simulation = "
165  << G4BestUnit(fTrueRange*density, "Mass/Surface")
166  << "\n from PhysicsTable (csda range) = "
167  << G4BestUnit(rangeTable*density, "Mass/Surface");
168  G4cout << "\n---------------------------------------------------------\n";
169  G4cout << G4endl;
170 
171  //restore default format
172  G4cout.precision(dfprec);
173 
174  // remove all contents in fProcCounter
175  fProcCounter.clear();
176 }
G4Run::numberOfEvent
G4int numberOfEvent
Definition: G4Run.hh:59
G4Material::GetDensity
G4double GetDensity() const
Definition: G4Material.hh:178
G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53
G4int
int G4int
Definition: G4Types.hh:78
eplot.material
string material
Definition: eplot.py:19
G4EmCalculator::GetCSDARange
G4double GetCSDARange(G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
Definition: G4EmCalculator.cc:204
density
G4double density
Definition: TRTMaterials.hh:39
G4cout
G4GLOB_DLL std::ostream G4cout
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
void Run::ComputeStatistics ( G4double  edep,
G4double  rms,
G4double &  limit 
)

Definition at line 193 of file electromagnetic/TestEm2/src/Run.cc.

References assert, EmAcceptance::BeginOfAcceptance(), plottest35::bin, DBL_MAX, EmAcceptance::EmAcceptanceGauss(), EmAcceptance::EndOfAcceptance(), G4BestUnit, G4cout, G4endl, DetectorConstruction::GetdLradl(), DetectorConstruction::GetdRlength(), DetectorConstruction::GetdRradl(), DetectorConstruction::GetMaterial(), DetectorConstruction::GetnLtot(), G4Run::GetNumberOfEvent(), G4ParticleGun::GetParticleDefinition(), G4ParticleGun::GetParticleEnergy(), PrimaryGeneratorAction::GetParticleGun(), G4ParticleDefinition::GetPDGMass(), and G4Material::GetRadlen().

194 {
195  G4int NbOfEvents = GetNumberOfEvent();
196 
197  G4double kinEnergy = fKin->GetParticleGun()->GetParticleEnergy();
198  assert(NbOfEvents*kinEnergy > 0);
199 
200  fChargedStep /= G4double(NbOfEvents);
201  fNeutralStep /= G4double(NbOfEvents);
202 
203  G4double mass=fKin->GetParticleGun()->GetParticleDefinition()->GetPDGMass();
204  G4double norme = 100./(NbOfEvents*(kinEnergy+mass));
205 
206  //longitudinal
207  //
208  G4double dLradl = fDet->GetdLradl();
209 
210  MyVector MeanELongit(f_nLbin), rmsELongit(f_nLbin);
211  MyVector MeanELongitCumul(f_nLbin), rmsELongitCumul(f_nLbin);
212 
213  G4AnalysisManager* analysisManager = G4AnalysisManager::Instance();
214 
215  G4int i;
216  for (i=0; i<f_nLbin; i++) {
217  MeanELongit[i] = norme*fSumELongit[i];
218  rmsELongit[i] =
219  norme*std::sqrt(std::abs(NbOfEvents*fSumE2Longit[i]
220  - fSumELongit[i]*fSumELongit[i]));
221 
222  MeanELongitCumul[i] = norme*fSumELongitCumul[i];
223  rmsELongitCumul[i] = norme*std::sqrt(std::abs(NbOfEvents*
224  fSumE2LongitCumul[i] - fSumELongitCumul[i]*fSumELongitCumul[i]));
225  G4double bin = (i+0.5)*dLradl;
226  analysisManager->FillH1(4, bin,MeanELongit[i]/dLradl);
227  analysisManager->FillH1(5, bin, rmsELongit[i]/dLradl);
228  bin = (i+1)*dLradl;
229  analysisManager->FillH1(6, bin,MeanELongitCumul[i]);
230  analysisManager->FillH1(7, bin, rmsELongitCumul[i]);
231  }
232 
233  //radial
234  //
235  G4double dRradl = fDet->GetdRradl();
236 
237  MyVector MeanERadial(f_nRbin), rmsERadial(f_nRbin);
238  MyVector MeanERadialCumul(f_nRbin), rmsERadialCumul(f_nRbin);
239 
240  for (i=0; i<f_nRbin; i++) {
241  MeanERadial[i] = norme*fSumERadial[i];
242  rmsERadial[i] = norme*std::sqrt(std::abs(NbOfEvents*fSumE2Radial[i]
243  - fSumERadial[i]*fSumERadial[i]));
244 
245  MeanERadialCumul[i] = norme*fSumERadialCumul[i];
246  rmsERadialCumul[i] =
247  norme*std::sqrt(std::abs(NbOfEvents*fSumE2RadialCumul[i]
248  - fSumERadialCumul[i]*fSumERadialCumul[i]));
249 
250  G4double bin = (i+0.5)*dRradl;
251  analysisManager->FillH1(8, bin,MeanERadial[i]/dRradl);
252  analysisManager->FillH1(9, bin, rmsERadial[i]/dRradl);
253  bin = (i+1)*dRradl;
254  analysisManager->FillH1(10, bin,MeanERadialCumul[i]);
255  analysisManager->FillH1(11, bin, rmsERadialCumul[i]);
256  }
257 
258  //find Moliere confinement
259  //
260  const G4double EMoliere = 90.;
261  G4double iMoliere = 0.;
262  if ((MeanERadialCumul[0] <= EMoliere) &&
263  (MeanERadialCumul[f_nRbin-1] >= EMoliere)) {
264  G4int imin = 0;
265  while( (imin < f_nRbin-1) && (MeanERadialCumul[imin] < EMoliere) )
266  { ++imin; }
267  G4double ratio = (EMoliere - MeanERadialCumul[imin]) /
268  (MeanERadialCumul[imin+1] - MeanERadialCumul[imin]);
269  iMoliere = 1. + imin + ratio;
270  }
271 
272  //track length
273  //
274  norme = 1./(NbOfEvents*(fDet->GetMaterial()->GetRadlen()));
275  G4double MeanChargTrLength = norme*fSumChargTrLength;
276  G4double rmsChargTrLength =
277  norme*std::sqrt(std::fabs(NbOfEvents*fSum2ChargTrLength
278  - fSumChargTrLength*fSumChargTrLength));
279 
280  G4double MeanNeutrTrLength = norme*fSumNeutrTrLength;
281  G4double rmsNeutrTrLength =
282  norme*std::sqrt(std::fabs(NbOfEvents*fSum2NeutrTrLength
283  - fSumNeutrTrLength*fSumNeutrTrLength));
284 
285  //print
286  std::ios::fmtflags mode = G4cout.flags();
287  G4cout.setf(std::ios::fixed,std::ios::floatfield);
288  G4int prec = G4cout.precision(2);
289 
290  if (fVerbose) {
291 
292  G4cout << " LOGITUDINAL PROFILE "
293  << " CUMULATIVE LOGITUDINAL PROFILE" << G4endl << G4endl;
294 
295  G4cout << " bin " << " Mean rms "
296  << " bin " << " Mean rms \n" << G4endl;
297 
298  for (i=0; i<f_nLbin; i++) {
299  G4double inf=i*dLradl, sup=inf+dLradl;
300 
301  G4cout << std::setw(8) << inf << "->"
302  << std::setw(5) << sup << " radl: "
303  << std::setw(7) << MeanELongit[i] << "% "
304  << std::setw(9) << rmsELongit[i] << "% "
305  << " 0->" << std::setw(5) << sup << " radl: "
306  << std::setw(7) << MeanELongitCumul[i] << "% "
307  << std::setw(7) << rmsELongitCumul[i] << "% "
308  <<G4endl;
309  }
310 
311  G4cout << G4endl << G4endl << G4endl;
312 
313  G4cout << " RADIAL PROFILE "
314  << " CUMULATIVE RADIAL PROFILE" << G4endl << G4endl;
315 
316  G4cout << " bin " << " Mean rms "
317  << " bin " << " Mean rms \n" << G4endl;
318 
319  for (i=0; i<f_nRbin; i++) {
320  G4double inf=i*dRradl, sup=inf+dRradl;
321 
322  G4cout << std::setw(8) << inf << "->"
323  << std::setw(5) << sup << " radl: "
324  << std::setw(7) << MeanERadial[i] << "% "
325  << std::setw(9) << rmsERadial[i] << "% "
326  << " 0->" << std::setw(5) << sup << " radl: "
327  << std::setw(7) << MeanERadialCumul[i] << "% "
328  << std::setw(7) << rmsERadialCumul[i] << "% "
329  <<G4endl;
330  }
331  }
332 
333  G4cout << "\n ===== SUMMARY ===== \n" << G4endl;
334 
335  G4cout << " Total number pf events: " << NbOfEvents << "\n"
336  << " Mean number of charged steps: " << fChargedStep << G4endl;
337  G4cout << " Mean number of neutral steps: " << fNeutralStep
338  << "\n" << G4endl;
339 
340  G4cout << " energy deposit : "
341  << std::setw(7) << MeanELongitCumul[f_nLbin-1] << " % E0 +- "
342  << std::setw(7) << rmsELongitCumul[f_nLbin-1] << " % E0" << G4endl;
343  G4cout << " charged traklen: "
344  << std::setw(7) << MeanChargTrLength << " radl +- "
345  << std::setw(7) << rmsChargTrLength << " radl" << G4endl;
346  G4cout << " neutral traklen: "
347  << std::setw(7) << MeanNeutrTrLength << " radl +- "
348  << std::setw(7) << rmsNeutrTrLength << " radl" << G4endl;
349 
350  if (iMoliere > 0. ) {
351  G4double RMoliere1 = iMoliere*fDet->GetdRradl();
352  G4double RMoliere2 = iMoliere*fDet->GetdRlength();
353  G4cout << "\n " << EMoliere << " % confinement: radius = "
354  << RMoliere1 << " radl ("
355  << G4BestUnit( RMoliere2, "Length") << ")" << "\n" << G4endl;
356  }
357 
358  G4cout.setf(mode,std::ios::floatfield);
359  G4cout.precision(prec);
360 
361  // Acceptance
362 
363  G4int nLbin = fDet->GetnLtot();
364  if (limit < DBL_MAX) {
365  EmAcceptance acc;
366  acc.BeginOfAcceptance("Total Energy in Absorber",NbOfEvents);
367  G4double e = MeanELongitCumul[nLbin-1]/100.;
368  G4double r = rmsELongitCumul[nLbin-1]/100.;
369  acc.EmAcceptanceGauss("Edep",NbOfEvents,e,edep,rms,limit);
370  acc.EmAcceptanceGauss("Erms",NbOfEvents,r,rms,rms,2.0*limit);
371  acc.EndOfAcceptance();
372  }
373  limit = DBL_MAX;
374 }
plottest35.bin
tuple bin
Definition: plottest35.py:22
EmAcceptance::EmAcceptanceGauss
void EmAcceptanceGauss(const G4String &title, G4int stat, G4double avr, G4double avr0, G4double rms, G4double limit)
Definition: TestEm2/src/EmAcceptance.cc:68
assert
#define assert(x)
Definition: mymalloc.cc:1309
EmAcceptance::BeginOfAcceptance
void BeginOfAcceptance(const G4String &title, G4int stat)
Definition: TestEm2/src/EmAcceptance.cc:49
G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53
G4int
int G4int
Definition: G4Types.hh:78
MyVector
std::vector< G4double > MyVector
Definition: electromagnetic/TestEm2/include/Run.hh:46
G4cout
G4GLOB_DLL std::ostream G4cout
G4Run::GetNumberOfEvent
G4int GetNumberOfEvent() const
Definition: G4Run.hh:79
G4Hbook::G4AnalysisManager
ExG4HbookAnalysisManager G4AnalysisManager
Definition: g4hbook_defs.hh:46
G4Material::GetRadlen
G4double GetRadlen() const
Definition: G4Material.hh:218
G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:161
G4ParticleGun::GetParticleDefinition
G4ParticleDefinition * GetParticleDefinition() const
Definition: G4ParticleGun.hh:106
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
G4ParticleGun::GetParticleEnergy
G4double GetParticleEnergy() const
Definition: G4ParticleGun.hh:110
void Run::CountParticles ( G4ParticleDefinition *  part)
inline

Definition at line 80 of file electromagnetic/TestEm5/include/Run.hh.

References G4Electron::Electron(), G4Gamma::Gamma(), and G4Positron::Positron().

81  { if (part == G4Gamma::Gamma()) fNbGamma++ ;
82  else if (part == G4Electron::Electron()) fNbElect++ ;
83  else if (part == G4Positron::Positron()) fNbPosit++ ; };
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:94
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94
void Run::CountProcesses ( const G4VProcess *  process)

Definition at line 56 of file hadronic/Hadr04/src/Run.cc.

57 {
58  std::map<const G4VProcess*,G4int>::iterator it = fProcCounter.find(process);
59  if ( it == fProcCounter.end()) {
60  fProcCounter[process] = 1;
61  }
62  else {
63  fProcCounter[process]++;
64  }
65 }
void Run::CountProcesses ( G4String  procName)
inline

Definition at line 57 of file electromagnetic/TestEm1/include/Run.hh.

57 { fProcCounter[procName]++;}
void Run::CountReflect ( G4int  flag)
inline

Definition at line 89 of file electromagnetic/TestEm5/include/Run.hh.

90  { if (flag == 1) fReflect[0]++;
91  else if (flag == 2) {fReflect[0]++; fReflect[1]++; }};
void Run::CountSteps0 ( G4int  ns)
inline

Definition at line 55 of file electromagnetic/TestEm1/include/Run.hh.

References ns.

55 { fNbOfSteps0 += ns;}
ns
#define ns
Definition: xmlparse.cc:597
void Run::CountSteps1 ( G4int  ns)
inline

Definition at line 56 of file electromagnetic/TestEm1/include/Run.hh.

References ns.

56 { fNbOfSteps1 += ns;}
ns
#define ns
Definition: xmlparse.cc:597
void Run::CountStepsCharg ( G4int  nSteps)
inline

Definition at line 74 of file electromagnetic/TestEm5/include/Run.hh.

75  {fNbStepsCharged += nSteps; fNbStepsCharged2 += nSteps*nSteps;};
void Run::CountStepsNeutr ( G4int  nSteps)
inline

Definition at line 77 of file electromagnetic/TestEm5/include/Run.hh.

78  {fNbStepsNeutral += nSteps; fNbStepsNeutral2 += nSteps*nSteps;};
void Run::CountTraks0 ( G4int  nt)
inline

Definition at line 53 of file electromagnetic/TestEm1/include/Run.hh.

53 { fNbOfTraks0 += nt;}
void Run::CountTraks1 ( G4int  nt)
inline

Definition at line 54 of file electromagnetic/TestEm1/include/Run.hh.

54 { fNbOfTraks1 += nt;}
void Run::CountTransmit ( G4int  flag)
inline

Definition at line 85 of file electromagnetic/TestEm5/include/Run.hh.

86  { if (flag == 1) fTransmit[0]++;
87  else if (flag == 2) {fTransmit[0]++; fTransmit[1]++; }};
void Run::FillPerEvent ( )

Definition at line 118 of file electromagnetic/TestEm2/src/Run.cc.

References DetectorConstruction::GetMaterial(), G4ParticleGun::GetParticleDefinition(), G4ParticleGun::GetParticleEnergy(), PrimaryGeneratorAction::GetParticleGun(), G4ParticleDefinition::GetPDGMass(), and G4Material::GetRadlen().

119 {
120  //accumulate statistic
121  //
122  G4double dLCumul = 0.;
123  for (G4int i=0; i<f_nLbin; i++)
124  {
125  fSumELongit[i] += f_dEdL[i];
126  fSumE2Longit[i] += f_dEdL[i]*f_dEdL[i];
127  dLCumul += f_dEdL[i];
128  fSumELongitCumul[i] += dLCumul;
129  fSumE2LongitCumul[i] += dLCumul*dLCumul;
130  }
131 
132  G4double dRCumul = 0.;
133  for (G4int j=0; j<f_nRbin; j++)
134  {
135  fSumERadial[j] += f_dEdR[j];
136  fSumE2Radial[j] += f_dEdR[j]*f_dEdR[j];
137  dRCumul += f_dEdR[j];
138  fSumERadialCumul[j] += dRCumul;
139  fSumE2RadialCumul[j] += dRCumul*dRCumul;
140  }
141 
142  fSumChargTrLength += fChargTrLength;
143  fSum2ChargTrLength += fChargTrLength*fChargTrLength;
144  fSumNeutrTrLength += fNeutrTrLength;
145  fSum2NeutrTrLength += fNeutrTrLength*fNeutrTrLength;
146 
147  //fill histograms
148  //
149 
150  G4double Ekin=fKin->GetParticleGun()->GetParticleEnergy();
151  G4double mass=fKin->GetParticleGun()->GetParticleDefinition()->GetPDGMass();
152  G4double radl=fDet->GetMaterial()->GetRadlen();
153 
154  G4AnalysisManager* analysisManager = G4AnalysisManager::Instance();
155  analysisManager->FillH1(1, 100.*dLCumul/(Ekin+mass));
156  analysisManager->FillH1(2, fChargTrLength/radl);
157  analysisManager->FillH1(3, fNeutrTrLength/radl);
158 }
G4int
int G4int
Definition: G4Types.hh:78
G4Hbook::G4AnalysisManager
ExG4HbookAnalysisManager G4AnalysisManager
Definition: g4hbook_defs.hh:46
G4Material::GetRadlen
G4double GetRadlen() const
Definition: G4Material.hh:218
G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:161
G4ParticleGun::GetParticleDefinition
G4ParticleDefinition * GetParticleDefinition() const
Definition: G4ParticleGun.hh:106
G4double
double G4double
Definition: G4Types.hh:76
G4ParticleGun::GetParticleEnergy
G4double GetParticleEnergy() const
Definition: G4ParticleGun.hh:110
void Run::FillPerStep ( G4double  dEstep,
G4int  Lbin,
G4int  Rbin 
)
inline

Definition at line 122 of file electromagnetic/TestEm2/include/Run.hh.

123 {
124  f_dEdL[Lbin] += dEstep; f_dEdR[Rbin] += dEstep;
125 }
void Run::FillPerTrack ( G4double  charge,
G4double  trkLength 
)
inline

Definition at line 113 of file electromagnetic/TestEm2/include/Run.hh.

114 {
115  if (charge != 0.) fChargTrLength += trkLength;
116  else fNeutrTrLength += trkLength;
117 }
G4double Run::GetCsdaRange ( G4int  i)
inline

Definition at line 66 of file electromagnetic/TestEm11/include/Run.hh.

66 {return fCsdaRange[i];};
G4double Run::GetXfrontNorm ( G4int  i)
inline

Definition at line 67 of file electromagnetic/TestEm11/include/Run.hh.

67 {return fXfrontNorm[i];};
void Run::InitializePerEvent ( )

Definition at line 103 of file electromagnetic/TestEm2/src/Run.cc.

104 {
105  //initialize arrays of energy deposit per bin
106  for (G4int i=0; i<f_nLbin; i++)
107  { f_dEdL[i] = 0.; }
108 
109  for (G4int j=0; j<f_nRbin; j++)
110  { f_dEdR[j] = 0.; }
111 
112  //initialize tracklength
113  fChargTrLength = fNeutrTrLength = 0.;
114 }
G4int
int G4int
Definition: G4Types.hh:78
virtual void Run::Merge ( const G4Run *  )
virtual

Reimplemented from G4Run.

virtual void Run::Merge ( const G4Run *  )
virtual

Reimplemented from G4Run.

void Run::Merge ( const G4Run *  run)
virtual

Reimplemented from G4Run.

Definition at line 180 of file electromagnetic/TestEm1/src/Run.cc.

References G4Run::Merge().

181 {
182  const Run* localRun = static_cast<const Run*>(run);
183 
184  // pass information about primary particle
185  fParticle = localRun->fParticle;
186  fEkin = localRun->fEkin;
187 
188  // accumulate sums
189  //
190  fNbOfTraks0 += localRun->fNbOfTraks0;
191  fNbOfTraks1 += localRun->fNbOfTraks1;
192  fNbOfSteps0 += localRun->fNbOfSteps0;
193  fNbOfSteps1 += localRun->fNbOfSteps1;
194  fEdep += localRun->fEdep;
195  fTrueRange += localRun->fTrueRange;
196  fTrueRange2 += localRun->fTrueRange2;
197  fProjRange += localRun->fProjRange;
198  fProjRange2 += localRun->fProjRange2;
199  fTransvDev += localRun->fTransvDev;
200  fTransvDev2 += localRun->fTransvDev2;
201 
202  //map
203  std::map<G4String,G4int>::const_iterator it;
204  for (it = localRun->fProcCounter.begin();
205  it !=localRun->fProcCounter.end(); ++it) {
206  fProcCounter[it->first] += it->second;
207  }
208 
209  G4Run::Merge(run);
210 }
G4Run::Merge
virtual void Merge(const G4Run *)
Definition: G4Run.cc:54
virtual void Run::Merge ( const G4Run *  )
virtual

Reimplemented from G4Run.

virtual void Run::Merge ( const G4Run *  )
virtual

Reimplemented from G4Run.

void Run::ParticleCount ( G4String  name,
G4double  Ekin 
)

Definition at line 69 of file hadronic/Hadr04/src/Run.cc.

70 {
71  std::map<G4String, ParticleData>::iterator it = fParticleDataMap.find(name);
72  if ( it == fParticleDataMap.end()) {
73  fParticleDataMap[name] = ParticleData(1, Ekin, Ekin, Ekin);
74  }
75  else {
76  ParticleData& data = it->second;
77  data.fCount++;
78  data.fEmean += Ekin;
79  //update min max
80  G4double emin = data.fEmin;
81  if (Ekin < emin) data.fEmin = Ekin;
82  G4double emax = data.fEmax;
83  if (Ekin > emax) data.fEmax = Ekin;
84  }
85 }
name
const XML_Char * name
Definition: include/expat.h:151
G4double
double G4double
Definition: G4Types.hh:76
data
const XML_Char const XML_Char * data
Definition: include/expat.h:268
void Run::PrintSummary ( ) const

Definition at line 73 of file electromagnetic/TestEm1/src/Run.cc.

References density, G4BestUnit, G4cout, G4endl, G4Material::GetDensity(), DetectorConstruction::GetMaterial(), G4Material::GetName(), G4Run::GetNumberOfEvent(), G4ParticleDefinition::GetParticleName(), DetectorConstruction::GetSize(), and eplot::material.

74 {
75  G4int prec = G4cout.precision(5);
76 
77  G4int nbOfEvents = GetNumberOfEvent();
78  G4String partName = fParticle->GetParticleName();
79  G4double length = fDetector->GetSize();
80  G4Material* material = fDetector->GetMaterial();
81  G4double density = material->GetDensity();
82 
83  G4cout << "\n ======================== run summary ======================\n";
84  G4cout << "\n The run was: " << nbOfEvents << " " << partName << " of "
85  << G4BestUnit(fEkin,"Energy") << " through "
86  << G4BestUnit(length,"Length") << " of "
87  << material->GetName() << " (density: "
88  << G4BestUnit(density,"Volumic Mass") << ")" << G4endl;
89  G4cout << "\n ============================================================\n";
90 
91  // reset default precision
92  G4cout.precision(prec);
93 }
G4Material::GetName
const G4String & GetName() const
Definition: G4Material.hh:176
G4Material::GetDensity
G4double GetDensity() const
Definition: G4Material.hh:178
G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53
G4int
int G4int
Definition: G4Types.hh:78
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:159
eplot.material
string material
Definition: eplot.py:19
density
G4double density
Definition: TRTMaterials.hh:39
G4cout
G4GLOB_DLL std::ostream G4cout
G4Run::GetNumberOfEvent
G4int GetNumberOfEvent() const
Definition: G4Run.hh:79
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
void Run::PrintSummary ( )

Definition at line 130 of file electromagnetic/TestEm5/src/Run.cc.

References python.hepunit::cm, python.hepunit::cm2, ComputeMscHighland(), G4EmCalculator::ComputeTotalDEDX(), density, g(), G4BestUnit, G4cout, G4endl, DetectorConstruction::GetAbsorberMaterial(), DetectorConstruction::GetAbsorberThickness(), G4EmCalculator::GetDEDX(), G4Material::GetDensity(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), eplot::material, python.hepunit::MeV, python.hepunit::mrad, and G4Run::numberOfEvent.

131 {
132  // compute mean and rms
133  //
134  G4int TotNbofEvents = numberOfEvent;
135  if (TotNbofEvents == 0) return;
136 
137  G4double EnergyBalance = fEnergyDeposit + fEnergyLeak[0] + fEnergyLeak[1];
138  EnergyBalance /= TotNbofEvents;
139 
140  fEnergyDeposit /= TotNbofEvents; fEnergyDeposit2 /= TotNbofEvents;
141  G4double rmsEdep = fEnergyDeposit2 - fEnergyDeposit*fEnergyDeposit;
142  if (rmsEdep>0.) rmsEdep = std::sqrt(rmsEdep/TotNbofEvents);
143  else rmsEdep = 0.;
144 
145  fTrakLenCharged /= TotNbofEvents; fTrakLenCharged2 /= TotNbofEvents;
146  G4double rmsTLCh = fTrakLenCharged2 - fTrakLenCharged*fTrakLenCharged;
147  if (rmsTLCh>0.) rmsTLCh = std::sqrt(rmsTLCh/TotNbofEvents);
148  else rmsTLCh = 0.;
149 
150  fTrakLenNeutral /= TotNbofEvents; fTrakLenNeutral2 /= TotNbofEvents;
151  G4double rmsTLNe = fTrakLenNeutral2 - fTrakLenNeutral*fTrakLenNeutral;
152  if (rmsTLNe>0.) rmsTLNe = std::sqrt(rmsTLNe/TotNbofEvents);
153  else rmsTLNe = 0.;
154 
155  fNbStepsCharged /= TotNbofEvents; fNbStepsCharged2 /= TotNbofEvents;
156  G4double rmsStCh = fNbStepsCharged2 - fNbStepsCharged*fNbStepsCharged;
157  if (rmsStCh>0.) rmsStCh = std::sqrt(rmsTLCh/TotNbofEvents);
158  else rmsStCh = 0.;
159 
160  fNbStepsNeutral /= TotNbofEvents; fNbStepsNeutral2 /= TotNbofEvents;
161  G4double rmsStNe = fNbStepsNeutral2 - fNbStepsNeutral*fNbStepsNeutral;
162  if (rmsStNe>0.) rmsStNe = std::sqrt(rmsTLCh/TotNbofEvents);
163  else rmsStNe = 0.;
164 
165  G4double Gamma = (G4double)fNbGamma/TotNbofEvents;
166  G4double Elect = (G4double)fNbElect/TotNbofEvents;
167  G4double Posit = (G4double)fNbPosit/TotNbofEvents;
168 
169  G4double transmit[2];
170  transmit[0] = 100.*fTransmit[0]/TotNbofEvents;
171  transmit[1] = 100.*fTransmit[1]/TotNbofEvents;
172 
173  G4double reflect[2];
174  reflect[0] = 100.*fReflect[0]/TotNbofEvents;
175  reflect[1] = 100.*fReflect[1]/TotNbofEvents;
176 
177  G4double rmsMsc = 0., tailMsc = 0.;
178  if (fMscEntryCentral > 0) {
179  fMscProjecTheta /= fMscEntryCentral; fMscProjecTheta2 /= fMscEntryCentral;
180  rmsMsc = fMscProjecTheta2 - fMscProjecTheta*fMscProjecTheta;
181  if (rmsMsc > 0.) { rmsMsc = std::sqrt(rmsMsc); }
182  if(fTransmit[1] > 0.0) {
183  tailMsc = 100.- (100.*fMscEntryCentral)/(2*fTransmit[1]);
184  }
185  }
186 
187  fEnergyLeak[0] /= TotNbofEvents; fEnergyLeak2[0] /= TotNbofEvents;
188  G4double rmsEl0 = fEnergyLeak2[0] - fEnergyLeak[0]*fEnergyLeak[0];
189  if (rmsEl0>0.) rmsEl0 = std::sqrt(rmsEl0/TotNbofEvents);
190  else rmsEl0 = 0.;
191 
192  fEnergyLeak[1] /= TotNbofEvents; fEnergyLeak2[1] /= TotNbofEvents;
193  G4double rmsEl1 = fEnergyLeak2[1] - fEnergyLeak[1]*fEnergyLeak[1];
194  if (rmsEl1>0.) rmsEl1 = std::sqrt(rmsEl1/TotNbofEvents);
195  else rmsEl1 = 0.;
196 
197 
198  //Stopping Power from input Table.
199  //
200  G4Material* material = fDetector->GetAbsorberMaterial();
201  G4double length = fDetector->GetAbsorberThickness();
202  G4double density = material->GetDensity();
203  G4String partName = fParticle->GetParticleName();
204 
205  G4EmCalculator emCalculator;
206  G4double dEdxTable = 0., dEdxFull = 0.;
207  if (fParticle->GetPDGCharge()!= 0.) {
208  dEdxTable = emCalculator.GetDEDX(fEkin,fParticle,material);
209  dEdxFull = emCalculator.ComputeTotalDEDX(fEkin,fParticle,material);
210  }
211  G4double stopTable = dEdxTable/density;
212  G4double stopFull = dEdxFull /density;
213 
214  //Stopping Power from simulation.
215  //
216  G4double meandEdx = fEnergyDeposit/length;
217  G4double stopPower = meandEdx/density;
218 
219  G4cout << "\n ======================== run summary ======================\n";
220 
221  G4int prec = G4cout.precision(3);
222 
223  G4cout << "\n The run was " << TotNbofEvents << " " << partName << " of "
224  << G4BestUnit(fEkin,"Energy") << " through "
225  << G4BestUnit(length,"Length") << " of "
226  << material->GetName() << " (density: "
227  << G4BestUnit(density,"Volumic Mass") << ")" << G4endl;
228 
229  G4cout.precision(4);
230 
231  G4cout << "\n Total energy deposit in absorber per event = "
232  << G4BestUnit(fEnergyDeposit,"Energy") << " +- "
233  << G4BestUnit(rmsEdep, "Energy")
234  << G4endl;
235 
236  G4cout << "\n -----> Mean dE/dx = " << meandEdx/(MeV/cm) << " MeV/cm"
237  << "\t(" << stopPower/(MeV*cm2/g) << " MeV*cm2/g)"
238  << G4endl;
239 
240  G4cout << "\n From formulas :" << G4endl;
241  G4cout << " restricted dEdx = " << dEdxTable/(MeV/cm) << " MeV/cm"
242  << "\t(" << stopTable/(MeV*cm2/g) << " MeV*cm2/g)"
243  << G4endl;
244 
245  G4cout << " full dEdx = " << dEdxFull/(MeV/cm) << " MeV/cm"
246  << "\t(" << stopFull/(MeV*cm2/g) << " MeV*cm2/g)"
247  << G4endl;
248 
249  G4cout << "\n Leakage : primary = "
250  << G4BestUnit(fEnergyLeak[0],"Energy") << " +- "
251  << G4BestUnit(rmsEl0, "Energy")
252  << " secondaries = "
253  << G4BestUnit(fEnergyLeak[1],"Energy") << " +- "
254  << G4BestUnit(rmsEl1, "Energy")
255  << G4endl;
256 
257  G4cout << " Energy balance : edep + eleak = "
258  << G4BestUnit(EnergyBalance,"Energy")
259  << G4endl;
260 
261  G4cout << "\n Total track length (charged) in absorber per event = "
262  << G4BestUnit(fTrakLenCharged,"Length") << " +- "
263  << G4BestUnit(rmsTLCh, "Length") << G4endl;
264 
265  G4cout << " Total track length (neutral) in absorber per event = "
266  << G4BestUnit(fTrakLenNeutral,"Length") << " +- "
267  << G4BestUnit(rmsTLNe, "Length") << G4endl;
268 
269  G4cout << "\n Number of steps (charged) in absorber per event = "
270  << fNbStepsCharged << " +- " << rmsStCh << G4endl;
271 
272  G4cout << " Number of steps (neutral) in absorber per event = "
273  << fNbStepsNeutral << " +- " << rmsStNe << G4endl;
274 
275  G4cout << "\n Number of secondaries per event : Gammas = " << Gamma
276  << "; electrons = " << Elect
277  << "; positrons = " << Posit << G4endl;
278 
279  G4cout << "\n Number of events with the primary particle transmitted = "
280  << transmit[1] << " %" << G4endl;
281 
282  G4cout << " Number of events with at least 1 particle transmitted "
283  << "(same charge as primary) = " << transmit[0] << " %" << G4endl;
284 
285  G4cout << "\n Number of events with the primary particle reflected = "
286  << reflect[1] << " %" << G4endl;
287 
288  G4cout << " Number of events with at least 1 particle reflected "
289  << "(same charge as primary) = " << reflect[0] << " %" << G4endl;
290 
291  // compute width of the Gaussian central part of the MultipleScattering
292  //
293  G4cout << "\n MultipleScattering:"
294  << "\n rms proj angle of transmit primary particle = "
295  << rmsMsc/mrad << " mrad (central part only)" << G4endl;
296 
297  G4cout << " computed theta0 (Highland formula) = "
298  << ComputeMscHighland()/mrad << " mrad" << G4endl;
299 
300  G4cout << " central part defined as +- "
301  << fMscThetaCentral/mrad << " mrad; "
302  << " Tail ratio = " << tailMsc << " %" << G4endl;
303 
304  // reset default precision
305  G4cout.precision(prec);
306 }
G4Run::numberOfEvent
G4int numberOfEvent
Definition: G4Run.hh:59
Run::ComputeMscHighland
G4double ComputeMscHighland()
Definition: electromagnetic/TestEm5/src/Run.cc:310
G4Material::GetName
const G4String & GetName() const
Definition: G4Material.hh:176
G4Material::GetDensity
G4double GetDensity() const
Definition: G4Material.hh:178
G4EmCalculator::ComputeTotalDEDX
G4double ComputeTotalDEDX(G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, G4double cut=DBL_MAX)
Definition: G4EmCalculator.cc:593
G4BestUnit
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
Definition: G4SteppingVerbose.cc:53
G4int
int G4int
Definition: G4Types.hh:78
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:159
G4EmCalculator::GetDEDX
G4double GetDEDX(G4double kinEnergy, const G4ParticleDefinition *, const G4Material *, const G4Region *r=0)
Definition: G4EmCalculator.cc:132
eplot.material
string material
Definition: eplot.py:19
density
G4double density
Definition: TRTMaterials.hh:39
g
function g(Y1, Y2, PT2)
Definition: hijing1.383.f:5205
G4cout
G4GLOB_DLL std::ostream G4cout
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
void Run::SetCsdaRange ( G4int  i,
G4double  value 
)
inline

Definition at line 63 of file electromagnetic/TestEm11/include/Run.hh.

63 { fCsdaRange[i] = value; }
value
const XML_Char int const XML_Char * value
Definition: include/expat.h:331
void Run::SetPrimary ( G4ParticleDefinition *  particle,
G4double  energy 
)
void Run::SetPrimary ( G4ParticleDefinition *  particle,
G4double  energy 
)

Definition at line 65 of file electromagnetic/TestEm1/src/Run.cc.

References energy().

66 {
67  fParticle = particle;
68  fEkin = energy;
69 }
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
void Run::SetVerbose ( G4int  val)
inline

Definition at line 74 of file electromagnetic/TestEm2/include/Run.hh.

Referenced by RunAction::SetVerbose().

74 {fVerbose = val;};
void Run::SetXfrontNorm ( G4int  i,
G4double  value 
)
inline

Definition at line 64 of file electromagnetic/TestEm11/include/Run.hh.

64 { fXfrontNorm[i] = value; }
value
const XML_Char int const XML_Char * value
Definition: include/expat.h:331
void Run::SumTrackLength ( G4int  nstep1,
G4int  nstep2,
G4double  trackl1,
G4double  trackl2,
G4double  time1,
G4double  time2 
)

Definition at line 89 of file hadronic/Hadr04/src/Run.cc.

92 {
93  fNbStep1 += nstep1; fNbStep2 += nstep2;
94  fTrackLen1 += trackl1; fTrackLen2 += trackl2;
95  fTime1 += time1; fTime2 += time2;
96 }
The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:57:30 for Geant4.10 by   doxygen 1.8.7