lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 11.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-12-09 14:43:28 +01:00
parent c07cea1fe0
commit 9f34590941
3810 changed files with 200490 additions and 182326 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/event/History
+6
View File
@@ -6,6 +6,12 @@ be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2022-11-17 Gabriele Cosmo (event-V11-00-07)
- Fixed compilation warnings for implicit type conversions on macOS/XCode 14.1.
## 2022-09-05 Ben Morgan (event-V11-00-06)
- Remove unneeded dependency on G4magneticfield
## 2022-04-04 Ben Morgan (event-V11-00-05)
- Apply basic set of C++ modernization fixes suggested by clang-tidy
source/event/sources.cmake
-1
View File
@@ -96,5 +96,4 @@ geant4_module_link_libraries(G4event
G4graphics_reps
G4materials
G4heprandom
G4magneticfield
G4parameterisation)
source/event/src/G4Event.cc
+8 -8
View File
@@ -90,27 +90,27 @@ void G4Event::Draw() const
if(trajectoryContainer != nullptr)
{
G4int n_traj = trajectoryContainer->entries();
for(G4int i=0; i<n_traj; ++i)
std::size_t n_traj = trajectoryContainer->entries();
for(std::size_t i=0; i<n_traj; ++i)
{ (*trajectoryContainer)[i]->DrawTrajectory(); }
}
if(HC != nullptr)
{
G4int n_HC = HC->GetCapacity();
for(G4int j=0; j<n_HC; ++j)
std::size_t n_HC = HC->GetCapacity();
for(std::size_t j=0; j<n_HC; ++j)
{
G4VHitsCollection* VHC = HC->GetHC(j);
G4VHitsCollection* VHC = HC->GetHC((G4int)j);
if(VHC != nullptr) VHC->DrawAllHits();
}
}
if(DC != nullptr)
{
G4int n_DC = DC->GetCapacity();
for(G4int j=0; j<n_DC; ++j)
std::size_t n_DC = DC->GetCapacity();
for(std::size_t j=0; j<n_DC; ++j)
{
G4VDigiCollection* VDC = DC->GetDC(j);
G4VDigiCollection* VDC = DC->GetDC((G4int)j);
if(VDC != nullptr) VDC->DrawAllDigi();
}
}
source/event/src/G4GeneralParticleSource.cc
+2 -2
View File
@@ -202,7 +202,7 @@ void G4GeneralParticleSource::GeneratePrimaryVertex(G4Event* evt)
GPSData->Unlock();
}
G4double rndm = G4UniformRand();
std::size_t i = 0 ;
G4int i = 0 ;
if (! GPSData->GetFlatSampling() )
{
while ( rndm > GPSData->GetSourceProbability(i) ) ++i;
@@ -210,7 +210,7 @@ void G4GeneralParticleSource::GeneratePrimaryVertex(G4Event* evt)
}
else
{
i = std::size_t (GPSData->GetIntensityVectorSize()*rndm);
i = G4int (GPSData->GetIntensityVectorSize()*rndm);
currentSource = GPSData->GetCurrentSource(i);
}
}
source/event/src/G4GeneralParticleSourceData.cc
+3 -3
View File
@@ -95,11 +95,11 @@ void G4GeneralParticleSourceData::IntensityNormalise()
{
if (!flat_sampling)
{
GetCurrentSource(i)->GetBiasRndm()->SetIntensityWeight(1.);
GetCurrentSource((G4int)i)->GetBiasRndm()->SetIntensityWeight(1.);
}
else
{
GetCurrentSource(i)->GetBiasRndm()
GetCurrentSource((G4int)i)->GetBiasRndm()
->SetIntensityWeight(sourceNormalizedIntensity[i]*sourceIntensity.size());
}
}
@@ -117,7 +117,7 @@ void G4GeneralParticleSourceData::AddASource(G4double intensity)
currentSource = new G4SingleParticleSource();
sourceVector.push_back(currentSource);
sourceIntensity.push_back(intensity);
currentSourceIdx = sourceVector.size() - 1;
currentSourceIdx = G4int(sourceVector.size() - 1);
normalised = false;
}
source/event/src/G4SPSEneDistribution.cc
+50 -50
View File
@@ -582,13 +582,13 @@ void G4SPSEneDistribution::LinearInterpolation() // MT: Lock in caller
// Create a cumulative array which is then normalised Arb_Cum_Area
G4double Area_seg[1024]; // Stores area under each segment
G4double sum = 0., Arb_x[1024], Arb_y[1024], Arb_Cum_Area[1024];
G4int i, count;
G4int maxi = ArbEnergyH.GetVectorLength();
G4double sum = 0., Arb_x[1024]={0.}, Arb_y[1024]={0.}, Arb_Cum_Area[1024]={0.};
std::size_t i, count;
std::size_t maxi = ArbEnergyH.GetVectorLength();
for (i = 0; i < maxi; ++i)
{
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(std::size_t(i));
Arb_y[i] = ArbEnergyH(std::size_t(i));
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(i);
Arb_y[i] = ArbEnergyH(i);
}
// Points are now in x,y arrays. If the spectrum is integral it has to be
@@ -725,13 +725,13 @@ void G4SPSEneDistribution::LogInterpolation() // MT: Lock in caller
// Create normalised, cumulative array Arb_Cum_Area
G4double Area_seg[1024]; // Stores area under each segment
G4double sum = 0., Arb_x[1024], Arb_y[1024], Arb_Cum_Area[1024];
G4int i, count;
G4int maxi = ArbEnergyH.GetVectorLength();
G4double sum = 0., Arb_x[1024]={0.}, Arb_y[1024]={0.}, Arb_Cum_Area[1024]={0.};
std::size_t i, count;
std::size_t maxi = ArbEnergyH.GetVectorLength();
for (i = 0; i < maxi; ++i)
{
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(std::size_t(i));
Arb_y[i] = ArbEnergyH(std::size_t(i));
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(i);
Arb_y[i] = ArbEnergyH(i);
}
// Points are now in x,y arrays. If the spectrum is integral it has to be
@@ -880,13 +880,13 @@ void G4SPSEneDistribution::ExpInterpolation() // MT: Lock in caller
// Create normalised, cumulative array Arb_Cum_Area
G4double Area_seg[1024]; // Stores area under each segment
G4double sum = 0., Arb_x[1024], Arb_y[1024], Arb_Cum_Area[1024];
G4int i, count;
G4int maxi = ArbEnergyH.GetVectorLength();
G4double sum = 0., Arb_x[1024]={0.}, Arb_y[1024]={0.}, Arb_Cum_Area[1024]={0.};
std::size_t i, count;
std::size_t maxi = ArbEnergyH.GetVectorLength();
for (i = 0; i < maxi; ++i)
{
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(std::size_t(i));
Arb_y[i] = ArbEnergyH(std::size_t(i));
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(i);
Arb_y[i] = ArbEnergyH(i);
}
// Points are now in x,y arrays. If the spectrum is integral it has to be
@@ -1005,14 +1005,14 @@ void G4SPSEneDistribution::SplineInterpolation() // MT: Lock in caller
// Current method based on the above will not work in all cases.
// New method is implemented below.
G4double sum, Arb_x[1024], Arb_y[1024], Arb_Cum_Area[1024];
G4int i, count;
G4double sum, Arb_x[1024]={0.}, Arb_y[1024]={0.}, Arb_Cum_Area[1024]={0.};
std::size_t i, count;
std::size_t maxi = ArbEnergyH.GetVectorLength();
G4int maxi = ArbEnergyH.GetVectorLength();
for (i = 0; i < maxi; ++i)
{
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(std::size_t(i));
Arb_y[i] = ArbEnergyH(std::size_t(i));
Arb_x[i] = ArbEnergyH.GetLowEdgeEnergy(i);
Arb_y[i] = ArbEnergyH(i);
}
// Points are now in x,y arrays. If the spectrum is integral it has to be
@@ -1065,7 +1065,7 @@ void G4SPSEneDistribution::SplineInterpolation() // MT: Lock in caller
i = 1;
Arb_Cum_Area[0] = 0.;
sum = 0.;
Splinetemp = new G4DataInterpolation(Arb_x, Arb_y, maxi, 0., 0.);
Splinetemp = new G4DataInterpolation(Arb_x, Arb_y, (G4int)maxi, 0., 0.);
G4double ei[101], prob[101];
for (auto & it : SplineInt)
{
@@ -1584,8 +1584,8 @@ void G4SPSEneDistribution::GenUserHistEnergies()
if (!IPDFEnergyExist)
{
G4int ii;
G4int maxbin = G4int(UDefEnergyH.GetVectorLength());
std::size_t ii;
std::size_t maxbin = UDefEnergyH.GetVectorLength();
G4double bins[1024], vals[1024], sum;
for ( ii = 0 ; ii<1024 ; ++ii ) { bins[ii]=0; vals[ii]=0; }
sum = 0.;
@@ -1612,14 +1612,14 @@ void G4SPSEneDistribution::GenUserHistEnergies()
}
else
{
bins[0] = UDefEnergyH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = UDefEnergyH(std::size_t(0));
bins[0] = UDefEnergyH.GetLowEdgeEnergy(0);
vals[0] = UDefEnergyH(0);
sum = vals[0];
for (ii = 1; ii < maxbin; ++ii)
{
bins[ii] = UDefEnergyH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = UDefEnergyH(std::size_t(ii)) + vals[ii - 1];
sum = sum + UDefEnergyH(std::size_t(ii));
bins[ii] = UDefEnergyH.GetLowEdgeEnergy(ii);
vals[ii] = UDefEnergyH(ii) + vals[ii - 1];
sum = sum + UDefEnergyH(ii);
}
}
@@ -1717,18 +1717,18 @@ void G4SPSEneDistribution::GenArbPointEnergies()
// Find the Bin, have x, y, no of points, and cumulative area distribution
//
G4int nabove = IPDFArbEnergyH.GetVectorLength(), nbelow = 0, middle;
std::size_t nabove = IPDFArbEnergyH.GetVectorLength(), nbelow = 0, middle;
// Binary search to find bin that rndm is in
//
while (nabove - nbelow > 1)
{
middle = (nabove + nbelow) / 2;
if (rndm == IPDFArbEnergyH(std::size_t(middle)))
if (rndm == IPDFArbEnergyH(middle))
{
break;
}
if (rndm < IPDFArbEnergyH(std::size_t(middle)))
if (rndm < IPDFArbEnergyH(middle))
{
nabove = middle;
}
@@ -1742,30 +1742,30 @@ void G4SPSEneDistribution::GenArbPointEnergies()
{
// Update thread-local copy of parameters
//
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow + 1));
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow));
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow + 1);
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow);
params.grad = Arb_grad[nbelow + 1];
params.cept = Arb_cept[nbelow + 1];
GenerateLinearEnergies(true);
}
else if (IntType == "Log")
{
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow + 1));
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow));
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow + 1);
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow);
params.alpha = Arb_alpha[nbelow + 1];
GeneratePowEnergies(true);
}
else if (IntType == "Exp")
{
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow + 1));
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow));
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow + 1);
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow);
params.Ezero = Arb_ezero[nbelow + 1];
GenerateExpEnergies(true);
}
else if (IntType == "Spline")
{
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow + 1));
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(std::size_t(nbelow));
params.Emax = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow + 1);
params.Emin = IPDFArbEnergyH.GetLowEdgeEnergy(nbelow);
params.particle_energy = -1e100;
rndm = eneRndm->GenRandEnergy();
while (params.particle_energy < params.Emin
@@ -1804,16 +1804,16 @@ void G4SPSEneDistribution::GenEpnHistEnergies()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(UDefEnergyH.GetVectorLength());
bins[0] = UDefEnergyH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = UDefEnergyH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = UDefEnergyH.GetVectorLength();
bins[0] = UDefEnergyH.GetLowEdgeEnergy(0);
vals[0] = UDefEnergyH(0);
sum = vals[0];
for (ii = 1; ii < maxbin; ++ii)
{
bins[ii] = UDefEnergyH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = UDefEnergyH(std::size_t(ii)) + vals[ii - 1];
sum = sum + UDefEnergyH(std::size_t(ii));
bins[ii] = UDefEnergyH.GetLowEdgeEnergy(ii);
vals[ii] = UDefEnergyH(ii) + vals[ii - 1];
sum = sum + UDefEnergyH(ii);
}
l.lock();
@@ -1857,8 +1857,8 @@ void G4SPSEneDistribution::ConvertEPNToEnergy() // MT: lock in caller
// Change values in histogram, Read it out, delete it, re-create it
//
G4int count, maxcount;
maxcount = G4int(EpnEnergyH.GetVectorLength());
std::size_t count, maxcount;
maxcount = EpnEnergyH.GetVectorLength();
G4double ebins[1024], evals[1024];
if (maxcount > 1024)
{
@@ -1878,8 +1878,8 @@ void G4SPSEneDistribution::ConvertEPNToEnergy() // MT: lock in caller
for (count = 0; count < maxcount; ++count)
{
// Read out
ebins[count] = EpnEnergyH.GetLowEdgeEnergy(std::size_t(count));
evals[count] = EpnEnergyH(std::size_t(count));
ebins[count] = EpnEnergyH.GetLowEdgeEnergy(count);
evals[count] = EpnEnergyH(count);
}
// Multiply the channels by the nucleon number to give energies
source/event/src/G4SPSRandomGenerator.cc
+96 -96
View File
@@ -275,16 +275,16 @@ G4double G4SPSRandomGenerator::GenRandX()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(XBiasH.GetVectorLength());
bins[0] = XBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = XBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = XBiasH.GetVectorLength();
bins[0] = XBiasH.GetLowEdgeEnergy(0);
vals[0] = XBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = XBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = XBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + XBiasH(std::size_t(ii));
bins[ii] = XBiasH.GetLowEdgeEnergy(ii);
vals[ii] = XBiasH(ii) + vals[ii - 1];
sum = sum + XBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -306,9 +306,9 @@ G4double G4SPSRandomGenerator::GenRandX()
// difference in the biased probability (the area)
//
std::size_t numberOfBin = IPDFXBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFXBiasH(biasn2))
@@ -322,8 +322,8 @@ G4double G4SPSRandomGenerator::GenRandX()
//
bweights_t& w = bweights.Get();
w[0] = IPDFXBiasH(biasn2) - IPDFXBiasH(biasn2 - 1);
G4double xaxisl = IPDFXBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFXBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFXBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFXBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[0] = NatProb / w[0];
if (verbosityLevel >= 1)
@@ -356,16 +356,16 @@ G4double G4SPSRandomGenerator::GenRandY()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(YBiasH.GetVectorLength());
bins[0] = YBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = YBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = YBiasH.GetVectorLength();
bins[0] = YBiasH.GetLowEdgeEnergy(0);
vals[0] = YBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = YBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = YBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + YBiasH(std::size_t(ii));
bins[ii] = YBiasH.GetLowEdgeEnergy(ii);
vals[ii] = YBiasH(ii) + vals[ii - 1];
sum = sum + YBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -381,9 +381,9 @@ G4double G4SPSRandomGenerator::GenRandY()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFYBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFYBiasH(biasn2))
@@ -394,8 +394,8 @@ G4double G4SPSRandomGenerator::GenRandY()
}
bweights_t& w = bweights.Get();
w[1] = IPDFYBiasH(biasn2) - IPDFYBiasH(biasn2 - 1);
G4double xaxisl = IPDFYBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFYBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFYBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFYBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[1] = NatProb / w[1];
if (verbosityLevel >= 1)
@@ -428,16 +428,16 @@ G4double G4SPSRandomGenerator::GenRandZ()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(ZBiasH.GetVectorLength());
bins[0] = ZBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = ZBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = ZBiasH.GetVectorLength();
bins[0] = ZBiasH.GetLowEdgeEnergy(0);
vals[0] = ZBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = ZBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = ZBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + ZBiasH(std::size_t(ii));
bins[ii] = ZBiasH.GetLowEdgeEnergy(ii);
vals[ii] = ZBiasH(ii) + vals[ii - 1];
sum = sum + ZBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -453,9 +453,9 @@ G4double G4SPSRandomGenerator::GenRandZ()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFZBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFZBiasH(biasn2))
@@ -466,8 +466,8 @@ G4double G4SPSRandomGenerator::GenRandZ()
}
bweights_t& w = bweights.Get();
w[2] = IPDFZBiasH(biasn2) - IPDFZBiasH(biasn2 - 1);
G4double xaxisl = IPDFZBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFZBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFZBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFZBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[2] = NatProb / w[2];
if (verbosityLevel >= 1)
@@ -501,16 +501,16 @@ G4double G4SPSRandomGenerator::GenRandTheta()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(ThetaBiasH.GetVectorLength());
bins[0] = ThetaBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = ThetaBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = ThetaBiasH.GetVectorLength();
bins[0] = ThetaBiasH.GetLowEdgeEnergy(0);
vals[0] = ThetaBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = ThetaBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = ThetaBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + ThetaBiasH(std::size_t(ii));
bins[ii] = ThetaBiasH.GetLowEdgeEnergy(ii);
vals[ii] = ThetaBiasH(ii) + vals[ii - 1];
sum = sum + ThetaBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -526,9 +526,9 @@ G4double G4SPSRandomGenerator::GenRandTheta()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFThetaBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFThetaBiasH(biasn2))
@@ -539,8 +539,8 @@ G4double G4SPSRandomGenerator::GenRandTheta()
}
bweights_t& w = bweights.Get();
w[3] = IPDFThetaBiasH(biasn2) - IPDFThetaBiasH(biasn2 - 1);
G4double xaxisl = IPDFThetaBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFThetaBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFThetaBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFThetaBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[3] = NatProb / w[3];
if (verbosityLevel >= 1)
@@ -573,16 +573,16 @@ G4double G4SPSRandomGenerator::GenRandPhi()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(PhiBiasH.GetVectorLength());
bins[0] = PhiBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = PhiBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = PhiBiasH.GetVectorLength();
bins[0] = PhiBiasH.GetLowEdgeEnergy(0);
vals[0] = PhiBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = PhiBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = PhiBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + PhiBiasH(std::size_t(ii));
bins[ii] = PhiBiasH.GetLowEdgeEnergy(ii);
vals[ii] = PhiBiasH(ii) + vals[ii - 1];
sum = sum + PhiBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -598,9 +598,9 @@ G4double G4SPSRandomGenerator::GenRandPhi()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFPhiBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFPhiBiasH(biasn2))
@@ -611,8 +611,8 @@ G4double G4SPSRandomGenerator::GenRandPhi()
}
bweights_t& w = bweights.Get();
w[4] = IPDFPhiBiasH(biasn2) - IPDFPhiBiasH(biasn2 - 1);
G4double xaxisl = IPDFPhiBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFPhiBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFPhiBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFPhiBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[4] = NatProb / w[4];
if (verbosityLevel >= 1)
@@ -645,16 +645,16 @@ G4double G4SPSRandomGenerator::GenRandEnergy()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(EnergyBiasH.GetVectorLength());
bins[0] = EnergyBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = EnergyBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = EnergyBiasH.GetVectorLength();
bins[0] = EnergyBiasH.GetLowEdgeEnergy(0);
vals[0] = EnergyBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = EnergyBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = EnergyBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + EnergyBiasH(std::size_t(ii));
bins[ii] = EnergyBiasH.GetLowEdgeEnergy(ii);
vals[ii] = EnergyBiasH(ii) + vals[ii - 1];
sum = sum + EnergyBiasH(ii);
}
IPDFEnergyBiasH = ZeroPhysVector;
for (ii=0; ii<maxbin; ++ii)
@@ -670,9 +670,9 @@ G4double G4SPSRandomGenerator::GenRandEnergy()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFEnergyBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFEnergyBiasH(biasn2))
@@ -683,8 +683,8 @@ G4double G4SPSRandomGenerator::GenRandEnergy()
}
bweights_t& w = bweights.Get();
w[5] = IPDFEnergyBiasH(biasn2) - IPDFEnergyBiasH(biasn2 - 1);
G4double xaxisl = IPDFEnergyBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFEnergyBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFEnergyBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFEnergyBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[5] = NatProb / w[5];
if (verbosityLevel >= 1)
@@ -718,16 +718,16 @@ G4double G4SPSRandomGenerator::GenRandPosTheta()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(PosThetaBiasH.GetVectorLength());
bins[0] = PosThetaBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = PosThetaBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = PosThetaBiasH.GetVectorLength();
bins[0] = PosThetaBiasH.GetLowEdgeEnergy(0);
vals[0] = PosThetaBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = PosThetaBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = PosThetaBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + PosThetaBiasH(std::size_t(ii));
bins[ii] = PosThetaBiasH.GetLowEdgeEnergy(ii);
vals[ii] = PosThetaBiasH(ii) + vals[ii - 1];
sum = sum + PosThetaBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -743,9 +743,9 @@ G4double G4SPSRandomGenerator::GenRandPosTheta()
//
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFPosThetaBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFPosThetaBiasH(biasn2))
@@ -756,8 +756,8 @@ G4double G4SPSRandomGenerator::GenRandPosTheta()
}
bweights_t& w = bweights.Get();
w[6] = IPDFPosThetaBiasH(biasn2) - IPDFPosThetaBiasH(biasn2 - 1);
G4double xaxisl = IPDFPosThetaBiasH.GetLowEdgeEnergy(std::size_t(biasn2-1));
G4double xaxisu = IPDFPosThetaBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFPosThetaBiasH.GetLowEdgeEnergy(biasn2-1);
G4double xaxisu = IPDFPosThetaBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[6] = NatProb / w[6];
if (verbosityLevel >= 1)
@@ -790,16 +790,16 @@ G4double G4SPSRandomGenerator::GenRandPosPhi()
// IPDF has not been created, so create it
//
G4double bins[1024], vals[1024], sum;
G4int ii;
G4int maxbin = G4int(PosPhiBiasH.GetVectorLength());
bins[0] = PosPhiBiasH.GetLowEdgeEnergy(std::size_t(0));
vals[0] = PosPhiBiasH(std::size_t(0));
std::size_t ii;
std::size_t maxbin = PosPhiBiasH.GetVectorLength();
bins[0] = PosPhiBiasH.GetLowEdgeEnergy(0);
vals[0] = PosPhiBiasH(0);
sum = vals[0];
for (ii=1; ii<maxbin; ++ii)
{
bins[ii] = PosPhiBiasH.GetLowEdgeEnergy(std::size_t(ii));
vals[ii] = PosPhiBiasH(std::size_t(ii)) + vals[ii - 1];
sum = sum + PosPhiBiasH(std::size_t(ii));
bins[ii] = PosPhiBiasH.GetLowEdgeEnergy(ii);
vals[ii] = PosPhiBiasH(ii) + vals[ii - 1];
sum = sum + PosPhiBiasH(ii);
}
for (ii=0; ii<maxbin; ++ii)
@@ -815,9 +815,9 @@ G4double G4SPSRandomGenerator::GenRandPosPhi()
G4double rndm = G4UniformRand();
std::size_t numberOfBin = IPDFPosPhiBiasH.GetVectorLength();
G4int biasn1 = 0;
G4int biasn2 = numberOfBin / 2;
G4int biasn3 = numberOfBin - 1;
std::size_t biasn1 = 0;
std::size_t biasn2 = numberOfBin / 2;
std::size_t biasn3 = numberOfBin - 1;
while (biasn1 != biasn3 - 1)
{
if (rndm > IPDFPosPhiBiasH(biasn2))
@@ -828,8 +828,8 @@ G4double G4SPSRandomGenerator::GenRandPosPhi()
}
bweights_t& w = bweights.Get();
w[7] = IPDFPosPhiBiasH(biasn2) - IPDFPosPhiBiasH(biasn2 - 1);
G4double xaxisl = IPDFPosPhiBiasH.GetLowEdgeEnergy(std::size_t(biasn2 - 1));
G4double xaxisu = IPDFPosPhiBiasH.GetLowEdgeEnergy(std::size_t(biasn2));
G4double xaxisl = IPDFPosPhiBiasH.GetLowEdgeEnergy(biasn2 - 1);
G4double xaxisu = IPDFPosPhiBiasH.GetLowEdgeEnergy(biasn2);
G4double NatProb = xaxisu - xaxisl;
w[7] = NatProb / w[7];
if (verbosityLevel >= 1)
source/event/src/G4SmartTrackStack.cc
+2 -2
View File
@@ -123,8 +123,8 @@ void G4SmartTrackStack::PushToStack( const G4StackedTrack& aStackedTrack )
energies[iDest] += aStackedTrack.GetTrack()->GetDynamicParticle()->GetTotalEnergy();
++nTracks;
G4int dy1 = stacks[iDest]->GetNTrack() - stacks[iDest]->GetSafetyValue1();
G4int dy2 = stacks[fTurn]->GetNTrack() - stacks[fTurn]->GetSafetyValue2();
G4long dy1 = stacks[iDest]->GetNTrack() - stacks[iDest]->GetSafetyValue1();
G4long dy2 = stacks[fTurn]->GetNTrack() - stacks[fTurn]->GetSafetyValue2();
if (dy1 > 0 || dy1 > dy2 ||
(iDest == 2 &&
source/event/src/G4StackManager.cc
+8 -8
View File
@@ -581,31 +581,31 @@ void G4StackManager::ClearPostponeStack()
G4int G4StackManager::GetNTotalTrack() const
{
G4int n = urgentStack->GetNTrack()
+ waitingStack->GetNTrack()
+ postponeStack->GetNTrack();
std::size_t n = urgentStack->GetNTrack()
+ waitingStack->GetNTrack()
+ postponeStack->GetNTrack();
for(G4int i=1; i<=numberOfAdditionalWaitingStacks; ++i)
{
n += additionalWaitingStacks[i-1]->GetNTrack();
}
return n;
return G4int(n);
}
G4int G4StackManager::GetNUrgentTrack() const
{
return urgentStack->GetNTrack();
return (G4int)urgentStack->GetNTrack();
}
G4int G4StackManager::GetNWaitingTrack(int i) const
{
if(i==0)
{
return waitingStack->GetNTrack();
return (G4int)waitingStack->GetNTrack();
}
if(i<=numberOfAdditionalWaitingStacks)
{
return additionalWaitingStacks[i-1]->GetNTrack();
return (G4int)additionalWaitingStacks[i-1]->GetNTrack();
}
return 0;
@@ -613,7 +613,7 @@ G4int G4StackManager::GetNWaitingTrack(int i) const
G4int G4StackManager::GetNPostponedTrack() const
{
return postponeStack->GetNTrack();
return (G4int)postponeStack->GetNTrack();
}
void G4StackManager::SetVerboseLevel( G4int const value )