G4SPSRandomGenerator Class Reference

#include <G4SPSRandomGenerator.hh>

Public Member Functions
	G4SPSRandomGenerator ()
	~G4SPSRandomGenerator ()
void	SetXBias (G4ThreeVector)
void	SetYBias (G4ThreeVector)
void	SetZBias (G4ThreeVector)
void	SetThetaBias (G4ThreeVector)
void	SetPhiBias (G4ThreeVector)
void	SetEnergyBias (G4ThreeVector)
void	SetPosThetaBias (G4ThreeVector)
void	SetPosPhiBias (G4ThreeVector)
G4double	GenRandX ()
G4double	GenRandY ()
G4double	GenRandZ ()
G4double	GenRandTheta ()
G4double	GenRandPhi ()
G4double	GenRandEnergy ()
G4double	GenRandPosTheta ()
G4double	GenRandPosPhi ()
void	SetIntensityWeight (G4double weight)
G4double	GetBiasWeight ()
void	ReSetHist (G4String)
void	SetVerbosity (G4int a)

---

Detailed Description

Definition at line 138 of file G4SPSRandomGenerator.hh.

---

Constructor & Destructor Documentation

G4SPSRandomGenerator::G4SPSRandomGenerator

(

)

Definition at line 65 of file G4SPSRandomGenerator.cc.

{
        // Initialise all variables

        // Bias variables
        XBias = false;
        IPDFXBias = false;
        YBias = false;
        IPDFYBias = false;
        ZBias = false;
        IPDFZBias = false;
        ThetaBias = false;
        IPDFThetaBias = false;
        PhiBias = false;
        IPDFPhiBias = false;
        EnergyBias = false;
        IPDFEnergyBias = false;
        PosThetaBias = false;
        IPDFPosThetaBias = false;
        PosPhiBias = false;
        IPDFPosPhiBias = false;
        bweights[0] = bweights[1] = bweights[2] = bweights[3] = bweights[4]
                        = bweights[5] = bweights[6] = bweights[7] = bweights[8] = 1.;
        verbosityLevel = 0;
}

G4SPSRandomGenerator::~G4SPSRandomGenerator

(

)

Definition at line 91 of file G4SPSRandomGenerator.cc.

                                            {
}

---

Member Function Documentation

G4double G4SPSRandomGenerator::GenRandEnergy

(

)

Definition at line 488 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                             {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandEnergy" << G4endl;
        if (EnergyBias == false) {
                // Energy is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // ENERGY is biased
                if (IPDFEnergyBias == false) {
                        // 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(size_t(0));
                        vals[0] = EnergyBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = EnergyBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = EnergyBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + EnergyBiasH(size_t(ii));
                        }
                        IPDFEnergyBiasH = ZeroPhysVector;
                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFEnergyBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFEnergyBias = true
                        IPDFEnergyBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //  size_t weight_bin_no = IPDFEnergyBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFEnergyBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFEnergyBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[5] = IPDFEnergyBiasH(biasn2) - IPDFEnergyBiasH(biasn2 - 1);
                G4double xaxisl = IPDFEnergyBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFEnergyBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[5] = NatProb / bweights[5];
                if (verbosityLevel >= 1)
                        G4cout << "Energy bin weight " << bweights[5] << " " << rndm
                                        << G4endl;
                return (IPDFEnergyBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandPhi

(

)

Definition at line 433 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                          {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandPhi" << G4endl;
        if (PhiBias == false) {
                // Phi is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // Phi is biased
                if (IPDFPhiBias == false) {
                        // 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(size_t(0));
                        vals[0] = PhiBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = PhiBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = PhiBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + PhiBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFPhiBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFPhiBias = true
                        IPDFPhiBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //      size_t weight_bin_no = IPDFPhiBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFPhiBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFPhiBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[4] = IPDFPhiBiasH(biasn2) - IPDFPhiBiasH(biasn2 - 1);
                G4double xaxisl = IPDFPhiBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFPhiBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[4] = NatProb / bweights[4];
                if (verbosityLevel >= 1)
                        G4cout << "Phi bin weight " << bweights[4] << " " << rndm << G4endl;
                return (IPDFPhiBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandPosPhi

(

)

Definition at line 603 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                             {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandPosPhi" << G4endl;
        if (PosPhiBias == false) {
                // PosPhi is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // PosPhi is biased
                if (IPDFPosPhiBias == false) {
                        // 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(size_t(0));
                        vals[0] = PosPhiBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = PosPhiBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = PosPhiBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + PosPhiBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFPosPhiBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFPosPhiBias = true
                        IPDFPosPhiBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //      size_t weight_bin_no = IPDFPosPhiBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFPosPhiBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFPosPhiBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[7] = IPDFPosPhiBiasH(biasn2) - IPDFPosPhiBiasH(biasn2 - 1);
                G4double xaxisl = IPDFPosPhiBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFPosPhiBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[7] = NatProb / bweights[7];
                if (verbosityLevel >= 1)
                        G4cout << "PosPhi bin weight " << bweights[7] << " " << rndm
                                        << G4endl;
                return (IPDFPosPhiBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandPosTheta

(

)

Definition at line 544 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                               {
        if (verbosityLevel >= 1) {
                G4cout << "In GenRandPosTheta" << G4endl;
                G4cout << "Verbosity " << verbosityLevel << G4endl;
        }
        if (PosThetaBias == false) {
                // Theta is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // Theta is biased
                if (IPDFPosThetaBias == false) {
                        // 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(size_t(0));
                        vals[0] = PosThetaBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = PosThetaBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = PosThetaBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + PosThetaBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFPosThetaBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFThetaBias = true
                        IPDFPosThetaBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //      size_t weight_bin_no = IPDFThetaBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFPosThetaBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFPosThetaBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[6] = IPDFPosThetaBiasH(biasn2) - IPDFPosThetaBiasH(biasn2 - 1);
                G4double xaxisl =
                                IPDFPosThetaBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFPosThetaBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[6] = NatProb / bweights[6];
                if (verbosityLevel >= 1)
                        G4cout << "PosTheta bin weight " << bweights[6] << " " << rndm
                                        << G4endl;
                return (IPDFPosThetaBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandTheta

(

)

Definition at line 375 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                            {
        if (verbosityLevel >= 1) {
                G4cout << "In GenRandTheta" << G4endl;
                G4cout << "Verbosity " << verbosityLevel << G4endl;
        }
        if (ThetaBias == false) {
                // Theta is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // Theta is biased
                if (IPDFThetaBias == false) {
                        // 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(size_t(0));
                        vals[0] = ThetaBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = ThetaBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = ThetaBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + ThetaBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFThetaBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFThetaBias = true
                        IPDFThetaBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //      size_t weight_bin_no = IPDFThetaBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFThetaBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFThetaBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[3] = IPDFThetaBiasH(biasn2) - IPDFThetaBiasH(biasn2 - 1);
                G4double xaxisl = IPDFThetaBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFThetaBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[3] = NatProb / bweights[3];
                if (verbosityLevel >= 1)
                        G4cout << "Theta bin weight " << bweights[3] << " " << rndm
                                        << G4endl;
                return (IPDFThetaBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandX

(

)

Definition at line 204 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                        {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandX" << G4endl;
        if (XBias == false) {
                // X is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // X is biased
                if (IPDFXBias == false) {
                        // 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(size_t(0));
                        vals[0] = XBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = XBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = XBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + XBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFXBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFXBias = true
                        IPDFXBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();

                // Calculate the weighting: Find the bin that the determined
                // rndm is in and the weigthing will be the difference in the
                // natural probability (from the x-axis) divided by the
                // difference in the biased probability (the area).
                size_t numberOfBin = IPDFXBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFXBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                // retrieve the areas and then the x-axis values
                bweights[0] = IPDFXBiasH(biasn2) - IPDFXBiasH(biasn2 - 1);
                G4double xaxisl = IPDFXBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFXBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                //G4cout << "X Bin weight " << bweights[0] << " " << rndm << G4endl;
                //G4cout << "lower and upper xaxis vals "<<xaxisl<<" "<<xaxisu<<G4endl;
                bweights[0] = NatProb / bweights[0];
                if (verbosityLevel >= 1)
                        G4cout << "X bin weight " << bweights[0] << " " << rndm << G4endl;
                return (IPDFXBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandY

(

)

Definition at line 266 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                        {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandY" << G4endl;
        if (YBias == false) {
                // Y is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // Y is biased
                if (IPDFYBias == false) {
                        // 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(size_t(0));
                        vals[0] = YBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = YBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = YBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + YBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFYBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFYBias = true
                        IPDFYBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                size_t numberOfBin = IPDFYBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFYBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[1] = IPDFYBiasH(biasn2) - IPDFYBiasH(biasn2 - 1);
                G4double xaxisl = IPDFYBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFYBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[1] = NatProb / bweights[1];
                if (verbosityLevel >= 1)
                        G4cout << "Y bin weight " << bweights[1] << " " << rndm << G4endl;
                return (IPDFYBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GenRandZ

(

)

Definition at line 320 of file G4SPSRandomGenerator.cc.

References G4cout, G4endl, G4UniformRand, G4PhysicsOrderedFreeVector::GetEnergy(), G4PhysicsOrderedFreeVector::GetLowEdgeEnergy(), G4PhysicsVector::GetVectorLength(), and G4PhysicsOrderedFreeVector::InsertValues().

                                        {
        if (verbosityLevel >= 1)
                G4cout << "In GenRandZ" << G4endl;
        if (ZBias == false) {
                // Z is not biased
                G4double rndm = G4UniformRand();
                return (rndm);
        } else {
                // Z is biased
                if (IPDFZBias == false) {
                        // 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(size_t(0));
                        vals[0] = ZBiasH(size_t(0));
                        sum = vals[0];
                        for (ii = 1; ii < maxbin; ii++) {
                                bins[ii] = ZBiasH.GetLowEdgeEnergy(size_t(ii));
                                vals[ii] = ZBiasH(size_t(ii)) + vals[ii - 1];
                                sum = sum + ZBiasH(size_t(ii));
                        }

                        for (ii = 0; ii < maxbin; ii++) {
                                vals[ii] = vals[ii] / sum;
                                IPDFZBiasH.InsertValues(bins[ii], vals[ii]);
                        }
                        // Make IPDFZBias = true
                        IPDFZBias = true;
                }
                // IPDF has been create so carry on
                G4double rndm = G4UniformRand();
                //      size_t weight_bin_no = IPDFZBiasH.FindValueBinLocation(rndm);
                size_t numberOfBin = IPDFZBiasH.GetVectorLength();
                G4int biasn1 = 0;
                G4int biasn2 = numberOfBin / 2;
                G4int biasn3 = numberOfBin - 1;
                while (biasn1 != biasn3 - 1) {
                        if (rndm > IPDFZBiasH(biasn2))
                                biasn1 = biasn2;
                        else
                                biasn3 = biasn2;
                        biasn2 = biasn1 + (biasn3 - biasn1 + 1) / 2;
                }
                bweights[2] = IPDFZBiasH(biasn2) - IPDFZBiasH(biasn2 - 1);
                G4double xaxisl = IPDFZBiasH.GetLowEdgeEnergy(size_t(biasn2 - 1));
                G4double xaxisu = IPDFZBiasH.GetLowEdgeEnergy(size_t(biasn2));
                G4double NatProb = xaxisu - xaxisl;
                bweights[2] = NatProb / bweights[2];
                if (verbosityLevel >= 1)
                        G4cout << "Z bin weight " << bweights[2] << " " << rndm << G4endl;
                return (IPDFZBiasH.GetEnergy(rndm));
        }
}

G4double G4SPSRandomGenerator::GetBiasWeight

(

)

[inline]

Definition at line 168 of file G4SPSRandomGenerator.hh.

Referenced by G4SingleParticleSource::GeneratePrimaryVertex().

                                        {
                return bweights[0] * bweights[1] * bweights[2] * bweights[3]
                                * bweights[4] * bweights[5] * bweights[6] * bweights[7]
                                * bweights[8];
        }

void G4SPSRandomGenerator::ReSetHist

(

G4String

)

Definition at line 166 of file G4SPSRandomGenerator.cc.

References G4cout, and G4endl.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                   {
        if (atype == "biasx") {
                XBias = false;
                IPDFXBias = false;
                XBiasH = IPDFXBiasH = ZeroPhysVector;
        } else if (atype == "biasy") {
                YBias = false;
                IPDFYBias = false;
                YBiasH = IPDFYBiasH = ZeroPhysVector;
        } else if (atype == "biasz") {
                ZBias = false;
                IPDFZBias = false;
                ZBiasH = IPDFZBiasH = ZeroPhysVector;
        } else if (atype == "biast") {
                ThetaBias = false;
                IPDFThetaBias = false;
                ThetaBiasH = IPDFThetaBiasH = ZeroPhysVector;
        } else if (atype == "biasp") {
                PhiBias = false;
                IPDFPhiBias = false;
                PhiBiasH = IPDFPhiBiasH = ZeroPhysVector;
        } else if (atype == "biase") {
                EnergyBias = false;
                IPDFEnergyBias = false;
                EnergyBiasH = IPDFEnergyBiasH = ZeroPhysVector;
        } else if (atype == "biaspt") {
                PosThetaBias = false;
                IPDFPosThetaBias = false;
                PosThetaBiasH = IPDFPosThetaBiasH = ZeroPhysVector;
        } else if (atype == "biaspp") {
                PosPhiBias = false;
                IPDFPosPhiBias = false;
                PosPhiBiasH = IPDFPosPhiBiasH = ZeroPhysVector;
        } else {
                G4cout << "Error, histtype not accepted " << G4endl;
        }
}

void G4SPSRandomGenerator::SetEnergyBias

(

G4ThreeVector

)

Definition at line 142 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                            {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        EnergyBiasH.InsertValues(ehi, val);
        EnergyBias = true;
}

void G4SPSRandomGenerator::SetIntensityWeight

(

G4double

weight

)

[inline]

Definition at line 163 of file G4SPSRandomGenerator.hh.

                                                        {
                bweights[8] = weight;
        }

void G4SPSRandomGenerator::SetPhiBias

(

G4ThreeVector

)

Definition at line 134 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                         {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        PhiBiasH.InsertValues(ehi, val);
        PhiBias = true;
}

void G4SPSRandomGenerator::SetPosPhiBias

(

G4ThreeVector

)

Definition at line 158 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                            {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        PosPhiBiasH.InsertValues(ehi, val);
        PosPhiBias = true;
}

void G4SPSRandomGenerator::SetPosThetaBias

(

G4ThreeVector

)

Definition at line 150 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                              {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        PosThetaBiasH.InsertValues(ehi, val);
        PosThetaBias = true;
}

void G4SPSRandomGenerator::SetThetaBias

(

G4ThreeVector

)

Definition at line 126 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                           {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        ThetaBiasH.InsertValues(ehi, val);
        ThetaBias = true;
}

void G4SPSRandomGenerator::SetVerbosity

(

G4int

a

)

[inline]

Definition at line 179 of file G4SPSRandomGenerator.hh.

                                   {
                verbosityLevel = a;
        }

void G4SPSRandomGenerator::SetXBias

(

G4ThreeVector

)

Definition at line 102 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                       {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        XBiasH.InsertValues(ehi, val);
        XBias = true;
}

void G4SPSRandomGenerator::SetYBias

(

G4ThreeVector

)

Definition at line 110 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                       {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        YBiasH.InsertValues(ehi, val);
        YBias = true;
}

void G4SPSRandomGenerator::SetZBias

(

G4ThreeVector

)

Definition at line 118 of file G4SPSRandomGenerator.cc.

References G4PhysicsOrderedFreeVector::InsertValues().

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

                                                       {
        G4double ehi, val;
        ehi = input.x();
        val = input.y();
        ZBiasH.InsertValues(ehi, val);
        ZBias = true;
}

---

The documentation for this class was generated from the following files:

• G4SPSRandomGenerator.hh
• G4SPSRandomGenerator.cc

---