File indexing completed on 2025-04-04 08:05:20
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034 #include "Run.hh"
0035
0036 #include "G4Run.hh"
0037 #include "G4RunManager.hh"
0038 #include "G4SystemOfUnits.hh"
0039
0040
0041
0042 Run::Run()
0043 : G4Run(),
0044 fNumEvents(0),
0045 fPrimaryParticleId(0),
0046 fPrimaryParticleInitialKineticEnergy(0.0),
0047 fPrimaryParticleInitialTotalEnergy(0.0),
0048 fPrimaryParticleInitialMomentum(0.0),
0049 fPrimaryParticleInitialBeta(0.0),
0050 fPrimaryParticleInitialGamma(0.0),
0051 fPrimaryParticleInitial3Momentum(G4ThreeVector()),
0052 fPrimaryParticleInitialPosition(G4ThreeVector()),
0053 fToleranceEPviolations(0.0),
0054 fToleranceDeltaDecayRadius(0.0),
0055 fIsPreassignedDecayEnabled(true),
0056 fIsBoostToLabEnabled(true),
0057 fNumDecays(0),
0058 fNumBadDecays(0),
0059 fNumUnexpectedDecays(0),
0060 fNumEviolations(0),
0061 fNumPviolations(0),
0062 fNum_mc_truth_rPos_deltaMax_above(0),
0063 fNum_underestimated_mc_truth_rPos_delta_above(0),
0064 fNum_overestimated_mc_truth_rPos_delta_above(0),
0065 fNumLargeUnderestimates(0),
0066 fNumLargeOverestimates(0),
0067 fDecayT(0.0),
0068 fSumDecayT(0.0),
0069 fMinDecayT(999999.9),
0070 fMaxDecayT(-999999.9),
0071 fDecayR_mc_truth(0.0),
0072 fDecayR(0.0),
0073 fSumDecayR(0.0),
0074 fMinDecayR(999999.9),
0075 fMaxDecayR(-999999.9),
0076 fDecayX(0.0),
0077 fSumDecayX(0.0),
0078 fMinDecayX(999999.9),
0079 fMaxDecayX(-999999.9),
0080 fDecayY(0.0),
0081 fSumDecayY(0.0),
0082 fMinDecayY(999999.9),
0083 fMaxDecayY(-999999.9),
0084 fDecayZ(0.0),
0085 fSumDecayZ(0.0),
0086 fMinDecayZ(999999.9),
0087 fMaxDecayZ(-999999.9),
0088 fDeltaDecayR(0.0),
0089 fSumDeltaDecayR(0.0),
0090 fMinDeltaDecayR(999999.9),
0091 fMaxDeltaDecayR(-999999.9),
0092 fDeflectionAngle(0.0),
0093 fSumDeflectionAngle(0.0),
0094 fMinDeflectionAngle(999999.9),
0095 fMaxDeflectionAngle(-999999.9),
0096 fDeltaEkin(0.0),
0097 fSumDeltaEkin(0.0),
0098 fMinDeltaEkin(999999.9),
0099 fMaxDeltaEkin(-999999.9),
0100 fDecayEkin(0.0),
0101 fSumDecayEkin(0.0),
0102 fMinDecayEkin(999999.9),
0103 fMaxDecayEkin(-999999.9),
0104 fDecayPx(0.0),
0105 fSumDecayPx(0.0),
0106 fMinDecayPx(999999.9),
0107 fMaxDecayPx(-999999.9),
0108 fDecayPy(0.0),
0109 fSumDecayPy(0.0),
0110 fMinDecayPy(999999.9),
0111 fMaxDecayPy(-999999.9),
0112 fDecayPz(0.0),
0113 fSumDecayPz(0.0),
0114 fMinDecayPz(999999.9),
0115 fMaxDecayPz(-999999.9),
0116 fDecayEtotViolation(0.0),
0117 fSumDecayEtotViolation(0.0),
0118 fMinDecayEtotViolation(999999.9),
0119 fMaxDecayEtotViolation(-999999.9),
0120 fDecayPxViolation(0.0),
0121 fSumDecayPxViolation(0.0),
0122 fMinDecayPxViolation(999999.9),
0123 fMaxDecayPxViolation(-999999.9),
0124 fDecayPyViolation(0.0),
0125 fSumDecayPyViolation(0.0),
0126 fMinDecayPyViolation(999999.9),
0127 fMaxDecayPyViolation(-999999.9),
0128 fDecayPzViolation(0.0),
0129 fSumDecayPzViolation(0.0),
0130 fMinDecayPzViolation(999999.9),
0131 fMaxDecayPzViolation(-999999.9),
0132 fMaxEkin_deltaMax(0.0),
0133 fMaxEtot_deltaMax(0.0),
0134 fMaxP_deltaMax(0.0),
0135 fMaxPdir_deltaMax(0.0),
0136 fMaxMass_deltaMax1(0.0),
0137 fMaxMass_deltaMax2(0.0),
0138 fSumMass_deltaMax3(0.0),
0139 fMaxMass_deltaMax3(0.0),
0140 fMaxBeta_deltaMax1(0.0),
0141 fMaxBeta_deltaMax2(0.0),
0142 fMaxGamma_deltaMax1(0.0),
0143 fMaxGamma_deltaMax2(0.0),
0144 fMaxGamma_deltaMax3(0.0),
0145 fMaxT_proper_deltaMax(0.0),
0146 fMaxT_lab_deltaMax(0.0),
0147 fSumMc_truth_rPos_deltaMax(0.0),
0148 fMaxMc_truth_rPos_deltaMax(0.0),
0149 fSumUnderestimated_mc_truth_rPos_delta(0.0),
0150 fMinUnderestimated_mc_truth_rPos_delta(999999.9),
0151 fSumOverestimated_mc_truth_rPos_delta(0.0),
0152 fMaxOverestimated_mc_truth_rPos_delta(-999999.9),
0153 fSumUnderestimated_rDeltaPos(0.0),
0154 fMinUnderestimated_rDeltaPos(999999.9),
0155 fSumOverestimated_rDeltaPos(0.0),
0156 fMaxOverestimated_rDeltaPos(-999999.9),
0157 fMaxFloat_rDeltaPos_deltaMax(-999999.9)
0158 {}
0159
0160
0161
0162 Run::~Run() {}
0163
0164
0165
0166 void Run::RecordEvent(const G4Event* anEvent)
0167 {
0168
0169
0170
0171 G4int nEvt = anEvent->GetEventID();
0172 if (nEvt % 1000 == 0) {
0173 G4cout << std::setprecision(6) << " Event#=" << nEvt << " ; t[ns]=" << fDecayT
0174 << " ; r[mm]=" << fDecayR
0175 << " ; deltaR[mum]=" << (fDecayR_mc_truth - fDecayR) / CLHEP::micrometer
0176 << " ; deltaEkin[MeV]=" << fDeltaEkin << " ; deltaAngle(deg)=" << fDeflectionAngle
0177 << G4endl;
0178 }
0179 G4Run::RecordEvent(anEvent);
0180 }
0181
0182
0183
0184 void Run::Merge(const G4Run* aRun)
0185 {
0186
0187
0188 const Run* localRun = static_cast<const Run*>(aRun);
0189 fNumEvents += localRun->GetNumberOfEvent();
0190
0191 fPrimaryParticleId = localRun->GetPrimaryParticleId();
0192 fPrimaryParticleInitialKineticEnergy = localRun->GetPrimaryParticleInitialKineticEnergy();
0193 fPrimaryParticleInitialTotalEnergy = localRun->GetPrimaryParticleInitialTotalEnergy();
0194 fPrimaryParticleInitialMomentum = localRun->GetPrimaryParticleInitialMomentum();
0195 fPrimaryParticleInitialBeta = localRun->GetPrimaryParticleInitialBeta();
0196 fPrimaryParticleInitialGamma = localRun->GetPrimaryParticleInitialGamma();
0197 fPrimaryParticleInitial3Momentum = localRun->GetPrimaryParticleInitial3Momentum();
0198 fPrimaryParticleInitialPosition = localRun->GetPrimaryParticleInitialPosition();
0199 fToleranceEPviolations = localRun->GetToleranceEPviolations();
0200 fToleranceDeltaDecayRadius = localRun->GetToleranceDeltaDecayRadius();
0201 fIsPreassignedDecayEnabled = localRun->GetIsPreassignedDecayEnabled();
0202 fIsBoostToLabEnabled = localRun->GetIsBoostToLabEnabled();
0203
0204 fNumDecays += localRun->GetNumberDecays();
0205 fNumBadDecays += localRun->GetNumberBadDecays();
0206 fNumUnexpectedDecays += localRun->GetNumberUnexpectedDecays();
0207 fNumEviolations += localRun->GetNumberEviolations();
0208 fNumPviolations += localRun->GetNumberPviolations();
0209 fNum_mc_truth_rPos_deltaMax_above += localRun->GetNumber_mc_truth_rPos_deltaMax_above();
0210 fNum_underestimated_mc_truth_rPos_delta_above +=
0211 localRun->GetNumberUnderestimated_mc_truth_rPos_delta_above();
0212 fNum_overestimated_mc_truth_rPos_delta_above +=
0213 localRun->GetNumberOverestimated_mc_truth_rPos_delta_above();
0214 fNumLargeUnderestimates += localRun->GetNumberLargeUnderestimates();
0215 fNumLargeOverestimates += localRun->GetNumberLargeOverestimates();
0216
0217 fSumDecayT += localRun->GetSumDecayT();
0218 fMinDecayT = std::min(fMinDecayT, localRun->GetMinDecayT());
0219 fMaxDecayT = std::max(fMaxDecayT, localRun->GetMaxDecayT());
0220 fSumDecayR += localRun->GetSumDecayR();
0221 fMinDecayR = std::min(fMinDecayR, localRun->GetMinDecayR());
0222 fMaxDecayR = std::max(fMaxDecayR, localRun->GetMaxDecayR());
0223 fSumDecayX += localRun->GetSumDecayX();
0224 fMinDecayX = std::min(fMinDecayX, localRun->GetMinDecayX());
0225 fMaxDecayX = std::max(fMaxDecayX, localRun->GetMaxDecayX());
0226 fSumDecayY += localRun->GetSumDecayY();
0227 fMinDecayY = std::min(fMinDecayY, localRun->GetMinDecayY());
0228 fMaxDecayY = std::max(fMaxDecayY, localRun->GetMaxDecayY());
0229 fSumDecayZ += localRun->GetSumDecayZ();
0230 fMinDecayZ = std::min(fMinDecayZ, localRun->GetMinDecayZ());
0231 fMaxDecayZ = std::max(fMaxDecayZ, localRun->GetMaxDecayZ());
0232 fSumDeltaDecayR += localRun->GetSumDeltaDecayR();
0233 fMinDeltaDecayR = std::min(fMinDeltaDecayR, localRun->GetMinDeltaDecayR());
0234 fMaxDeltaDecayR = std::max(fMaxDeltaDecayR, localRun->GetMaxDeltaDecayR());
0235 fSumDeflectionAngle += localRun->GetSumDeflectionAngle();
0236 fMinDeflectionAngle = std::min(fMinDeflectionAngle, localRun->GetMinDeflectionAngle());
0237 fMaxDeflectionAngle = std::max(fMaxDeflectionAngle, localRun->GetMaxDeflectionAngle());
0238 fSumDeltaEkin += localRun->GetSumDeltaEkin();
0239 fMinDeltaEkin = std::min(fMinDeltaEkin, localRun->GetMinDeltaEkin());
0240 fMaxDeltaEkin = std::max(fMaxDeltaEkin, localRun->GetMaxDeltaEkin());
0241 fSumDecayEkin += localRun->GetSumDecayEkin();
0242 fMinDecayEkin = std::min(fMinDecayEkin, localRun->GetMinDecayEkin());
0243 fMaxDecayEkin = std::max(fMaxDecayEkin, localRun->GetMaxDecayEkin());
0244 fSumDecayPx += localRun->GetSumDecayPx();
0245 fMinDecayPx = std::min(fMinDecayPx, localRun->GetMinDecayPx());
0246 fMaxDecayPx = std::max(fMaxDecayPx, localRun->GetMaxDecayPx());
0247 fSumDecayPy += localRun->GetSumDecayPy();
0248 fMinDecayPy = std::min(fMinDecayPy, localRun->GetMinDecayPy());
0249 fMaxDecayPy = std::max(fMaxDecayPy, localRun->GetMaxDecayPy());
0250 fSumDecayPz += localRun->GetSumDecayPz();
0251 fMinDecayPz = std::min(fMinDecayPz, localRun->GetMinDecayPz());
0252 fMaxDecayPz = std::max(fMaxDecayPz, localRun->GetMaxDecayPz());
0253 fSumDecayEtotViolation += localRun->GetSumDecayEtotViolation();
0254 fMinDecayEtotViolation = std::min(fMinDecayEtotViolation, localRun->GetMinDecayEtotViolation());
0255 fMaxDecayEtotViolation = std::max(fMaxDecayEtotViolation, localRun->GetMaxDecayEtotViolation());
0256 fSumDecayPxViolation += localRun->GetSumDecayPxViolation();
0257 fMinDecayPxViolation = std::min(fMinDecayPxViolation, localRun->GetMinDecayPxViolation());
0258 fMaxDecayPxViolation = std::max(fMaxDecayPxViolation, localRun->GetMaxDecayPxViolation());
0259 fSumDecayPyViolation += localRun->GetSumDecayPyViolation();
0260 fMinDecayPyViolation = std::min(fMinDecayPyViolation, localRun->GetMinDecayPyViolation());
0261 fMaxDecayPyViolation = std::max(fMaxDecayPyViolation, localRun->GetMaxDecayPyViolation());
0262 fSumDecayPzViolation += localRun->GetSumDecayPzViolation();
0263 fMinDecayPzViolation = std::min(fMinDecayPzViolation, localRun->GetMinDecayPzViolation());
0264 fMaxDecayPzViolation = std::max(fMaxDecayPzViolation, localRun->GetMaxDecayPzViolation());
0265
0266 fMaxEkin_deltaMax = std::max(fMaxEkin_deltaMax, localRun->GetMaxEkin_deltaMax());
0267 fMaxEtot_deltaMax = std::max(fMaxEtot_deltaMax, localRun->GetMaxEtot_deltaMax());
0268 fMaxP_deltaMax = std::max(fMaxP_deltaMax, localRun->GetMaxP_deltaMax());
0269 fMaxPdir_deltaMax = std::max(fMaxPdir_deltaMax, localRun->GetMaxPdir_deltaMax());
0270 fMaxMass_deltaMax1 = std::max(fMaxMass_deltaMax1, localRun->GetMaxMass_deltaMax1());
0271 fMaxMass_deltaMax2 = std::max(fMaxMass_deltaMax2, localRun->GetMaxMass_deltaMax2());
0272 fMaxMass_deltaMax3 = std::max(fMaxMass_deltaMax3, localRun->GetMaxMass_deltaMax3());
0273 fSumMass_deltaMax3 += localRun->GetSumMass_deltaMax3();
0274 fMaxBeta_deltaMax1 = std::max(fMaxBeta_deltaMax1, localRun->GetMaxBeta_deltaMax1());
0275 fMaxBeta_deltaMax2 = std::max(fMaxBeta_deltaMax2, localRun->GetMaxBeta_deltaMax2());
0276 fMaxGamma_deltaMax1 = std::max(fMaxGamma_deltaMax1, localRun->GetMaxGamma_deltaMax1());
0277 fMaxGamma_deltaMax2 = std::max(fMaxGamma_deltaMax2, localRun->GetMaxGamma_deltaMax2());
0278 fMaxGamma_deltaMax3 = std::max(fMaxGamma_deltaMax3, localRun->GetMaxGamma_deltaMax3());
0279 fMaxT_proper_deltaMax = std::max(fMaxT_proper_deltaMax, localRun->GetMaxT_proper_deltaMax());
0280 fMaxT_lab_deltaMax = std::max(fMaxT_lab_deltaMax, localRun->GetMaxT_lab_deltaMax());
0281 fMaxMc_truth_rPos_deltaMax =
0282 std::max(fMaxMc_truth_rPos_deltaMax, localRun->GetMaxMc_truth_rPos_deltaMax());
0283 fSumMc_truth_rPos_deltaMax += localRun->GetSumMc_truth_rPos_deltaMax();
0284
0285 fMinUnderestimated_mc_truth_rPos_delta = std::min(
0286 fMinUnderestimated_mc_truth_rPos_delta, localRun->GetMinUnderestimated_mc_truth_rPos_delta());
0287 fSumUnderestimated_mc_truth_rPos_delta += localRun->GetSumUnderestimated_mc_truth_rPos_delta();
0288 fMaxOverestimated_mc_truth_rPos_delta = std::max(
0289 fMaxOverestimated_mc_truth_rPos_delta, localRun->GetMaxOverestimated_mc_truth_rPos_delta());
0290 fSumOverestimated_mc_truth_rPos_delta += localRun->GetSumOverestimated_mc_truth_rPos_delta();
0291 fMinUnderestimated_rDeltaPos =
0292 std::min(fMinUnderestimated_rDeltaPos, localRun->GetMinUnderestimated_rDeltaPos());
0293 fSumUnderestimated_rDeltaPos += localRun->GetSumUnderestimated_rDeltaPos();
0294 fMaxOverestimated_rDeltaPos =
0295 std::max(fMaxOverestimated_rDeltaPos, localRun->GetMaxOverestimated_rDeltaPos());
0296 fSumOverestimated_rDeltaPos += localRun->GetSumOverestimated_rDeltaPos();
0297
0298 fMaxFloat_rDeltaPos_deltaMax =
0299 std::max(fMaxFloat_rDeltaPos_deltaMax, localRun->GetMaxFloat_rDeltaPos_deltaMax());
0300
0301 G4Run::Merge(aRun);
0302 }
0303
0304
0305
0306 void Run::PrintInfo() const
0307 {
0308
0309
0310 const G4double femtosecond = 0.001 * CLHEP::picosecond;
0311 const G4double NN = (fNumDecays > 0 ? G4double(fNumDecays) : 1.0);
0312 G4cout
0313 << std::setprecision(6) << G4endl << G4endl
0314 << " ============ Run::printInfo() =============== \t RunID = " << GetRunID() << G4endl
0315 << " primary PDG code = " << fPrimaryParticleId << G4endl
0316 << " primary initial kinetic energy [GeV] = "
0317 << fPrimaryParticleInitialKineticEnergy / CLHEP::GeV << G4endl
0318 << " primary initial total energy [GeV] = " << fPrimaryParticleInitialTotalEnergy / CLHEP::GeV
0319 << G4endl
0320 << " primary initial momentum [GeV] = " << fPrimaryParticleInitialMomentum / CLHEP::GeV
0321 << G4endl << " primary initial Lorentz beta = " << fPrimaryParticleInitialBeta << G4endl
0322 << " primary initial Lorentz gamma = " << fPrimaryParticleInitialGamma << G4endl
0323 << " primary initial 3 momentum [GeV] = " << fPrimaryParticleInitial3Momentum / CLHEP::GeV
0324 << G4endl << " primary initial position [mm] = " << fPrimaryParticleInitialPosition
0325 << G4endl << " toleranceEPviolations [eV] = " << fToleranceEPviolations / CLHEP::eV
0326 << G4endl
0327 << " toleranceDeltaDecayRadius [mum] = " << fToleranceDeltaDecayRadius / CLHEP::micrometer
0328 << G4endl << " isPreassignedDecayEnabled = " << fIsPreassignedDecayEnabled << G4endl
0329 << " isBoostToLabEnabled = " << fIsBoostToLabEnabled << G4endl
0330 << " # Events = " << (fNumEvents > 0 ? fNumEvents : GetNumberOfEvent()) << G4endl
0331 << " # Decays = " << fNumDecays << G4endl
0332 << " (# Bad decays = " << fNumBadDecays << " )" << G4endl
0333 << " (# Unexpected decays = " << fNumUnexpectedDecays << " )" << G4endl
0334 << " # E violations = " << fNumEviolations << G4endl
0335 << " # P violations = " << fNumPviolations << G4endl
0336 << " decay T [ns] : min=" << fMinDecayT << "\t mean=" << fSumDecayT / NN
0337 << "\t max=" << fMaxDecayT << G4endl << " decay R [mm] : min=" << fMinDecayR
0338 << "\t mean=" << fSumDecayR / NN << "\t max=" << fMaxDecayR << G4endl
0339 << " decay X [mm] : min=" << fMinDecayX << "\t mean=" << fSumDecayX / NN
0340 << "\t max=" << fMaxDecayX << G4endl << " decay Y [mm] : min=" << fMinDecayY
0341 << "\t mean=" << fSumDecayY / NN << "\t max=" << fMaxDecayY << G4endl
0342 << " decay Z [mm] : min=" << fMinDecayZ << "\t mean=" << fSumDecayZ / NN
0343 << "\t max=" << fMaxDecayZ << G4endl << " Delta decay R [mm] : min=" << fMinDeltaDecayR
0344 << "\t mean=" << fSumDeltaDecayR / NN << "\t max=" << fMaxDeltaDecayR << G4endl
0345 << " deflection angle [deg] : min=" << fMinDeflectionAngle
0346 << "\t mean=" << fSumDeflectionAngle / NN << "\t max=" << fMaxDeflectionAngle << G4endl
0347 << " Delta Ekin [MeV] : min=" << fMinDeltaEkin << "\t mean=" << fSumDeltaEkin / NN
0348 << "\t max=" << fMaxDeltaEkin << G4endl
0349 << " decay Ekin [GeV] : min=" << fMinDecayEkin / CLHEP::GeV
0350 << "\t mean=" << fSumDecayEkin / NN / CLHEP::GeV << "\t max=" << fMaxDecayEkin / CLHEP::GeV
0351 << G4endl << " decay Px [GeV] : min=" << fMinDecayPx / CLHEP::GeV
0352 << "\t mean=" << fSumDecayPx / NN / CLHEP::GeV << "\t max=" << fMaxDecayPx / CLHEP::GeV
0353 << G4endl << " decay Py [GeV] : min=" << fMinDecayPy / CLHEP::GeV
0354 << "\t mean=" << fSumDecayPy / NN / CLHEP::GeV << "\t max=" << fMaxDecayPy / CLHEP::GeV
0355 << G4endl << " decay Pz [GeV] : min=" << fMinDecayPz / CLHEP::GeV
0356 << "\t mean=" << fSumDecayPz / NN / CLHEP::GeV << "\t max=" << fMaxDecayPz / CLHEP::GeV
0357 << G4endl << " decay Etot violation [MeV] : min=" << fMinDecayEtotViolation
0358 << "\t mean=" << fSumDecayEtotViolation / NN << "\t max=" << fMaxDecayEtotViolation << G4endl
0359 << " decay Px violation [MeV] : min=" << fMinDecayPxViolation
0360 << "\t mean=" << fSumDecayPxViolation / NN << "\t max=" << fMaxDecayPxViolation << G4endl
0361 << " decay Py violation [MeV] : min=" << fMinDecayPyViolation
0362 << "\t mean=" << fSumDecayPyViolation / NN << "\t max=" << fMaxDecayPyViolation << G4endl
0363 << " decay Pz violation [MeV] : min=" << fMinDecayPzViolation
0364 << "\t mean=" << fSumDecayPzViolation / NN << "\t max=" << fMaxDecayPzViolation << G4endl
0365 << " --- Consistency checks --- " << G4endl
0366 << " maxEkin_deltaMax [eV] = " << fMaxEkin_deltaMax / CLHEP::eV << G4endl
0367 << " maxEtot_deltaMax [eV] = " << fMaxEtot_deltaMax / CLHEP::eV << G4endl
0368 << " maxP_deltaMax [eV] = " << fMaxP_deltaMax / CLHEP::eV << G4endl
0369 << " maxPdir_deltaMax = " << fMaxPdir_deltaMax << G4endl
0370 << " maxMass_deltaMax{1,2,3} [eV] = " << fMaxMass_deltaMax1 / CLHEP::eV << " , "
0371 << fMaxMass_deltaMax2 / CLHEP::eV << " , " << fMaxMass_deltaMax3 / CLHEP::eV
0372 << " (mean=" << fSumMass_deltaMax3 / NN / CLHEP::eV << ")" << G4endl
0373 << " maxBeta_deltaMax{1,2} = " << fMaxBeta_deltaMax1 << " , " << fMaxBeta_deltaMax2
0374 << G4endl << " maxGamma_deltaMax{1,2,3} = " << fMaxGamma_deltaMax1 << " , "
0375 << fMaxGamma_deltaMax2 << " , " << fMaxGamma_deltaMax3 << G4endl
0376 << " maxT_proper_deltaMax [fs] = " << fMaxT_proper_deltaMax / femtosecond << G4endl
0377 << " maxT_lab_deltaMax [fs] = " << fMaxT_lab_deltaMax / femtosecond << G4endl
0378 << " maxMc_truth_rPos_deltaMax [mum] = " << fMaxMc_truth_rPos_deltaMax / CLHEP::micrometer
0379 << " (mean=" << fSumMc_truth_rPos_deltaMax / NN / CLHEP::micrometer
0380 << ")\t (# above threshold = " << fNum_mc_truth_rPos_deltaMax_above << ")" << G4endl
0381 << " --- Extra checks --- " << G4endl << " minUnderestimated_mc_truth_rPos_delta [mum] = "
0382 << fMinUnderestimated_mc_truth_rPos_delta / CLHEP::micrometer
0383 << " (mean=" << fSumUnderestimated_mc_truth_rPos_delta / NN / CLHEP::micrometer
0384 << ")\t (#above threshold = " << fNum_underestimated_mc_truth_rPos_delta_above << ")" << G4endl
0385 << " maxOverestimated_mc_truth_rPos_delta [mum] = "
0386 << fMaxOverestimated_mc_truth_rPos_delta / CLHEP::micrometer
0387 << " (mean=" << fSumOverestimated_mc_truth_rPos_delta / NN / CLHEP::micrometer
0388 << ")\t (#above threshold = " << fNum_overestimated_mc_truth_rPos_delta_above << ")" << G4endl
0389 << " minUnderestimated_rDeltaPos [mum] = "
0390 << fMinUnderestimated_rDeltaPos / CLHEP::micrometer
0391 << " (mean=" << fSumUnderestimated_rDeltaPos / NN / CLHEP::micrometer
0392 << ")\t (#above threshold = " << fNumLargeUnderestimates << ")" << G4endl
0393 << " maxOverestimated_rDeltaPos [mum] = "
0394 << fMaxOverestimated_rDeltaPos / CLHEP::micrometer
0395 << " (mean=" << fSumOverestimated_rDeltaPos / NN / CLHEP::micrometer
0396 << ")\t (#above threshold = " << fNumLargeOverestimates << ")" << G4endl
0397 << " --- float instead of double --- " << G4endl
0398 << " fMaxFloat_rDeltaPos_deltaMax [mum] = " << fMaxFloat_rDeltaPos_deltaMax / CLHEP::micrometer
0399 << G4endl << " ============================================= " << G4endl << G4endl;
0400 }
0401
0402
0403
0404 void Run::SetDecayT(const G4double inputValue)
0405 {
0406 fDecayT = inputValue;
0407 fSumDecayT += inputValue;
0408 fMinDecayT = std::min(fMinDecayT, inputValue);
0409 fMaxDecayT = std::max(fMaxDecayT, inputValue);
0410 }
0411
0412
0413
0414 void Run::SetDecayR_mc_truth(const G4double inputValue)
0415 {
0416 fDecayR_mc_truth = inputValue;
0417 }
0418
0419
0420
0421 void Run::SetDecayR(const G4double inputValue)
0422 {
0423 fDecayR = inputValue;
0424 fSumDecayR += inputValue;
0425 fMinDecayR = std::min(fMinDecayR, inputValue);
0426 fMaxDecayR = std::max(fMaxDecayR, inputValue);
0427 }
0428
0429
0430
0431 void Run::SetDecayX(const G4double inputValue)
0432 {
0433 fDecayX = inputValue;
0434 fSumDecayX += inputValue;
0435 fMinDecayX = std::min(fMinDecayX, inputValue);
0436 fMaxDecayX = std::max(fMaxDecayX, inputValue);
0437 }
0438
0439
0440
0441 void Run::SetDecayY(const G4double inputValue)
0442 {
0443 fDecayY = inputValue;
0444 fSumDecayY += inputValue;
0445 fMinDecayY = std::min(fMinDecayY, inputValue);
0446 fMaxDecayY = std::max(fMaxDecayY, inputValue);
0447 }
0448
0449
0450
0451 void Run::SetDecayZ(const G4double inputValue)
0452 {
0453 fDecayZ = inputValue;
0454 fSumDecayZ += inputValue;
0455 fMinDecayZ = std::min(fMinDecayZ, inputValue);
0456 fMaxDecayZ = std::max(fMaxDecayZ, inputValue);
0457 }
0458
0459
0460
0461 void Run::SetDeltaDecayR(const G4double inputValue)
0462 {
0463 fDeltaDecayR = inputValue;
0464 fSumDeltaDecayR += inputValue;
0465 fMinDeltaDecayR = std::min(fMinDeltaDecayR, inputValue);
0466 fMaxDeltaDecayR = std::max(fMaxDeltaDecayR, inputValue);
0467 }
0468
0469
0470
0471 void Run::SetDeflectionAngle(const G4double inputValue)
0472 {
0473 fDeflectionAngle = inputValue;
0474 fSumDeflectionAngle += inputValue;
0475 fMinDeflectionAngle = std::min(fMinDeflectionAngle, inputValue);
0476 fMaxDeflectionAngle = std::max(fMaxDeflectionAngle, inputValue);
0477 }
0478
0479
0480
0481 void Run::SetDeltaEkin(const G4double inputValue)
0482 {
0483 fDeltaEkin = inputValue;
0484 fSumDeltaEkin += inputValue;
0485 fMinDeltaEkin = std::min(fMinDeltaEkin, inputValue);
0486 fMaxDeltaEkin = std::max(fMaxDeltaEkin, inputValue);
0487 }
0488
0489
0490
0491 void Run::SetDecayEkin(const G4double inputValue)
0492 {
0493 fDecayEkin = inputValue;
0494 fSumDecayEkin += inputValue;
0495 fMinDecayEkin = std::min(fMinDecayEkin, inputValue);
0496 fMaxDecayEkin = std::max(fMaxDecayEkin, inputValue);
0497 }
0498
0499
0500
0501 void Run::SetDecayPx(const G4double inputValue)
0502 {
0503 fDecayPx = inputValue;
0504 fSumDecayPx += inputValue;
0505 fMinDecayPx = std::min(fMinDecayPx, inputValue);
0506 fMaxDecayPx = std::max(fMaxDecayPx, inputValue);
0507 }
0508
0509
0510
0511 void Run::SetDecayPy(const G4double inputValue)
0512 {
0513 fDecayPy = inputValue;
0514 fSumDecayPy += inputValue;
0515 fMinDecayPy = std::min(fMinDecayPy, inputValue);
0516 fMaxDecayPy = std::max(fMaxDecayPy, inputValue);
0517 }
0518
0519
0520
0521 void Run::SetDecayPz(const G4double inputValue)
0522 {
0523 fDecayPz = inputValue;
0524 fSumDecayPz += inputValue;
0525 fMinDecayPz = std::min(fMinDecayPz, inputValue);
0526 fMaxDecayPz = std::max(fMaxDecayPz, inputValue);
0527 }
0528
0529
0530
0531 void Run::SetDecayEtotViolation(const G4double inputValue)
0532 {
0533 fDecayEtotViolation = inputValue;
0534 fSumDecayEtotViolation += inputValue;
0535 fMinDecayEtotViolation = std::min(fMinDecayEtotViolation, inputValue);
0536 fMaxDecayEtotViolation = std::max(fMaxDecayEtotViolation, inputValue);
0537 }
0538
0539
0540
0541 void Run::SetDecayPxViolation(const G4double inputValue)
0542 {
0543 fDecayPxViolation = inputValue;
0544 fSumDecayPxViolation += inputValue;
0545 fMinDecayPxViolation = std::min(fMinDecayPxViolation, inputValue);
0546 fMaxDecayPxViolation = std::max(fMaxDecayPxViolation, inputValue);
0547 }
0548
0549
0550
0551 void Run::SetDecayPyViolation(const G4double inputValue)
0552 {
0553 fDecayPyViolation = inputValue;
0554 fSumDecayPyViolation += inputValue;
0555 fMinDecayPyViolation = std::min(fMinDecayPyViolation, inputValue);
0556 fMaxDecayPyViolation = std::max(fMaxDecayPyViolation, inputValue);
0557 }
0558
0559
0560
0561 void Run::SetDecayPzViolation(const G4double inputValue)
0562 {
0563 fDecayPzViolation = inputValue;
0564 fSumDecayPzViolation += inputValue;
0565 fMinDecayPzViolation = std::min(fMinDecayPzViolation, inputValue);
0566 fMaxDecayPzViolation = std::max(fMaxDecayPzViolation, inputValue);
0567 }
0568
0569
0570
0571 void Run::SetMaxEkin_deltaMax(const G4double inputValue)
0572 {
0573 fMaxEkin_deltaMax = std::max(fMaxEkin_deltaMax, inputValue);
0574 }
0575
0576
0577
0578 void Run::SetMaxEtot_deltaMax(const G4double inputValue)
0579 {
0580 fMaxEtot_deltaMax = std::max(fMaxEtot_deltaMax, inputValue);
0581 }
0582
0583
0584
0585 void Run::SetMaxP_deltaMax(const G4double inputValue)
0586 {
0587 fMaxP_deltaMax = std::max(fMaxP_deltaMax, inputValue);
0588 }
0589
0590
0591
0592 void Run::SetMaxPdir_deltaMax(const G4double inputValue)
0593 {
0594 fMaxPdir_deltaMax = std::max(fMaxPdir_deltaMax, inputValue);
0595 }
0596
0597
0598
0599 void Run::SetMaxMass_deltaMax1(const G4double inputValue)
0600 {
0601 fMaxMass_deltaMax1 = std::max(fMaxMass_deltaMax1, inputValue);
0602 }
0603
0604
0605
0606 void Run::SetMaxMass_deltaMax2(const G4double inputValue)
0607 {
0608 fMaxMass_deltaMax2 = std::max(fMaxMass_deltaMax2, inputValue);
0609 }
0610
0611
0612
0613 void Run::SetMaxMass_deltaMax3(const G4double inputValue)
0614 {
0615 fSumMass_deltaMax3 += inputValue;
0616 fMaxMass_deltaMax3 = std::max(fMaxMass_deltaMax3, inputValue);
0617 }
0618
0619
0620
0621 void Run::SetMaxBeta_deltaMax1(const G4double inputValue)
0622 {
0623 fMaxBeta_deltaMax1 = std::max(fMaxBeta_deltaMax1, inputValue);
0624 }
0625
0626
0627
0628 void Run::SetMaxBeta_deltaMax2(const G4double inputValue)
0629 {
0630 fMaxBeta_deltaMax2 = std::max(fMaxBeta_deltaMax2, inputValue);
0631 }
0632
0633
0634
0635 void Run::SetMaxGamma_deltaMax1(const G4double inputValue)
0636 {
0637 fMaxGamma_deltaMax1 = std::max(fMaxGamma_deltaMax1, inputValue);
0638 }
0639
0640
0641
0642 void Run::SetMaxGamma_deltaMax2(const G4double inputValue)
0643 {
0644 fMaxGamma_deltaMax2 = std::max(fMaxGamma_deltaMax2, inputValue);
0645 }
0646
0647
0648
0649 void Run::SetMaxGamma_deltaMax3(const G4double inputValue)
0650 {
0651 fMaxGamma_deltaMax3 = std::max(fMaxGamma_deltaMax3, inputValue);
0652 }
0653
0654
0655
0656 void Run::SetMaxT_proper_deltaMax(const G4double inputValue)
0657 {
0658 fMaxT_proper_deltaMax = std::max(fMaxT_proper_deltaMax, inputValue);
0659 }
0660
0661
0662
0663 void Run::SetMaxT_lab_deltaMax(const G4double inputValue)
0664 {
0665 fMaxT_lab_deltaMax = std::max(fMaxT_lab_deltaMax, inputValue);
0666 }
0667
0668
0669
0670 void Run::SetMaxMc_truth_rPos_deltaMax(const G4double inputValue)
0671 {
0672 fSumMc_truth_rPos_deltaMax += inputValue;
0673 fMaxMc_truth_rPos_deltaMax = std::max(fMaxMc_truth_rPos_deltaMax, inputValue);
0674 }
0675
0676
0677
0678 void Run::SetMinUnderestimated_mc_truth_rPos_delta(const G4double inputValue)
0679 {
0680 fSumUnderestimated_mc_truth_rPos_delta += inputValue;
0681 fMinUnderestimated_mc_truth_rPos_delta =
0682 std::min(fMinUnderestimated_mc_truth_rPos_delta, inputValue);
0683 }
0684
0685
0686
0687 void Run::SetMaxOverestimated_mc_truth_rPos_delta(const G4double inputValue)
0688 {
0689 fSumOverestimated_mc_truth_rPos_delta += inputValue;
0690 fMaxOverestimated_mc_truth_rPos_delta =
0691 std::max(fMaxOverestimated_mc_truth_rPos_delta, inputValue);
0692 }
0693
0694
0695
0696 void Run::SetMinUnderestimated_rDeltaPos(const G4double inputValue)
0697 {
0698 fSumUnderestimated_rDeltaPos += inputValue;
0699 fMinUnderestimated_rDeltaPos = std::min(fMinUnderestimated_rDeltaPos, inputValue);
0700 }
0701
0702
0703
0704 void Run::SetMaxOverestimated_rDeltaPos(const G4double inputValue)
0705 {
0706 fSumOverestimated_rDeltaPos += inputValue;
0707 fMaxOverestimated_rDeltaPos = std::max(fMaxOverestimated_rDeltaPos, inputValue);
0708 }
0709
0710
0711
0712 void Run::SetMaxFloat_rDeltaPos_deltaMax(const G4double inputValue)
0713 {
0714 fMaxFloat_rDeltaPos_deltaMax = std::max(fMaxFloat_rDeltaPos_deltaMax, inputValue);
0715 }
0716
0717
