#include <G4SPSPosDistribution.hh>

Data Structures
struct	thread_data_t

Public Member Functions
void	ConfineSourceToVolume (const G4String &)

	G4SPSPosDistribution ()

G4ThreeVector	GenerateOne ()

const G4ThreeVector &	GetCentreCoords () const

G4bool	GetConfined () const

const G4String &	GetConfineVolume () const

G4double	GetHalfX () const

G4double	GetHalfY () const

G4double	GetHalfZ () const

G4double	GetParAlpha () const

G4double	GetParPhi () const

G4double	GetParTheta () const

const G4ThreeVector &	GetParticlePos () const

const G4String &	GetPosDisShape () const

const G4String &	GetPosDisType () const

G4double	GetRadius () const

G4double	GetRadius0 () const

const G4ThreeVector &	GetRotx () const

const G4ThreeVector &	GetRoty () const

const G4ThreeVector &	GetRotz () const

const G4ThreeVector &	GetSideRefVec1 () const

const G4ThreeVector &	GetSideRefVec2 () const

const G4ThreeVector &	GetSideRefVec3 () const

const G4String &	GetSourcePosType () const

void	SetBeamSigmaInR (G4double)

void	SetBeamSigmaInX (G4double)

void	SetBeamSigmaInY (G4double)

void	SetBiasRndm (G4SPSRandomGenerator *a)

void	SetCentreCoords (const G4ThreeVector &)

void	SetHalfX (G4double)

void	SetHalfY (G4double)

void	SetHalfZ (G4double)

void	SetParAlpha (G4double)

void	SetParPhi (G4double)

void	SetParTheta (G4double)

void	SetPosDisShape (const G4String &)

void	SetPosDisType (const G4String &)

void	SetPosRot1 (const G4ThreeVector &)

void	SetPosRot2 (const G4ThreeVector &)

void	SetRadius (G4double)

void	SetRadius0 (G4double)

void	SetVerbosity (G4int a)

	~G4SPSPosDistribution ()

Private Member Functions
void	GeneratePointsInBeam (G4ThreeVector &outoutPos)

void	GeneratePointsInPlane (G4ThreeVector &outoutPos)

void	GeneratePointsInVolume (G4ThreeVector &outputPos)

void	GeneratePointsOnSurface (G4ThreeVector &outputPos)

void	GeneratePointSource (G4ThreeVector &outoutPos)

void	GenerateRotationMatrices ()

G4bool	IsSourceConfined (G4ThreeVector &outputPos)

Private Attributes
G4Mutex	a_mutex

G4ThreeVector	CentreCoords

G4bool	Confine = false

G4double	halfx

G4double	halfy

G4double	halfz

G4double	ParAlpha

G4double	ParPhi

G4double	ParTheta

G4SPSRandomGenerator *	PosRndm = nullptr

G4double	Radius

G4double	Radius0

G4ThreeVector	Rotx

G4ThreeVector	Roty

G4ThreeVector	Rotz

G4String	Shape

G4String	SourcePosType

G4double	SR

G4double	SX

G4double	SY

G4Cache< thread_data_t >	ThreadData

G4int	verbosityLevel

G4String	VolName

Detailed Description

Definition at line 59 of file G4SPSPosDistribution.hh.

Constructor & Destructor Documentation

◆ G4SPSPosDistribution()

G4SPSPosDistribution::G4SPSPosDistribution ( )

Definition at line 51 of file G4SPSPosDistribution.cc.

{
  SourcePosType = "Point";
  Shape = "NULL";
  CentreCoords = G4ThreeVector(0,0,0);
  Rotx = CLHEP::HepXHat;
  Roty = CLHEP::HepYHat;
  Rotz = CLHEP::HepZHat;
  halfx = 0.;
  halfy = 0.;
  halfz = 0.;
  Radius = 0.;
  Radius0 = 0.;
  SR = 0.;
  SX = 0.;
  SY = 0.;
  ParAlpha = 0.;
  ParTheta = 0.;
  ParPhi = 0.;
  VolName = "NULL";
  verbosityLevel = 0 ;
  G4MUTEXINIT(a_mutex);
}

References a_mutex, CentreCoords, G4MUTEXINIT, halfx, halfy, halfz, CLHEP::HepXHat, CLHEP::HepYHat, CLHEP::HepZHat, ParAlpha, ParPhi, ParTheta, Radius, Radius0, Rotx, Roty, Rotz, Shape, SourcePosType, SR, SX, SY, verbosityLevel, and VolName.

◆ ~G4SPSPosDistribution()

G4SPSPosDistribution::~G4SPSPosDistribution ( )

Definition at line 75 of file G4SPSPosDistribution.cc.

{
  G4MUTEXDESTROY(a_mutex);
}

References a_mutex, and G4MUTEXDESTROY.

Member Function Documentation

◆ ConfineSourceToVolume()

void G4SPSPosDistribution::ConfineSourceToVolume ( const G4String & Vname )

Definition at line 265 of file G4SPSPosDistribution.cc.

{
  VolName = Vname;
  if(verbosityLevel == 2) { G4cout << VolName << G4endl; }
 
  if(VolName=="NULL")
  {
    if(verbosityLevel >= 1)
    { G4cout << "Volume confinement is set off." << G4endl; }
    Confine = false;
    return;
  }
 
  G4VPhysicalVolume* tempPV = nullptr;
  G4PhysicalVolumeStore* PVStore = G4PhysicalVolumeStore::GetInstance();
  if(verbosityLevel == 2) { G4cout << PVStore->size() << G4endl; }
 
  tempPV = PVStore->GetVolume(VolName);
 
  // the volume exists else it doesn't
  //
  if (tempPV != nullptr)
  {
    if(verbosityLevel >= 1)
    {
      G4cout << "Volume " << VolName << " exists" << G4endl;
    }
    Confine = true;
  }
  else
  {
    G4cout << " **** Error: Volume <" << VolName
           << "> does not exist **** " << G4endl;
    G4cout << " Ignoring confine condition" << G4endl;
    Confine = false;
    VolName = "NULL";
  }
}

References Confine, G4cout, G4endl, G4PhysicalVolumeStore::GetInstance(), G4PhysicalVolumeStore::GetVolume(), verbosityLevel, and VolName.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ GenerateOne()

G4ThreeVector G4SPSPosDistribution::GenerateOne ( )

Definition at line 1246 of file G4SPSPosDistribution.cc.

{
  G4ThreeVector localP;
  G4bool srcconf = false;
  G4int LoopCount = 0;
  while(srcconf == false)
  {
    if(SourcePosType == "Point")
      GeneratePointSource(localP);
    else if(SourcePosType == "Beam")
      GeneratePointsInBeam(localP);
    else if(SourcePosType == "Plane")
      GeneratePointsInPlane(localP);
    else if(SourcePosType == "Surface")
      GeneratePointsOnSurface(localP);
    else if(SourcePosType == "Volume")
      GeneratePointsInVolume(localP);
    else
    {
      G4ExceptionDescription msg;
      msg << "Error: SourcePosType undefined\n";
      msg << "Generating point source\n";
      G4Exception("G4SPSPosDistribution::GenerateOne()",
                  "G4GPS001", JustWarning, msg);
      GeneratePointSource(localP);
    }
    if(Confine == true)
    {
      srcconf = IsSourceConfined(localP);
      // if source in confined srcconf = true terminating the loop
      // if source isnt confined srcconf = false and loop continues
    }
    else if(Confine == false)
    {
      srcconf = true; // terminate loop
    }
    ++LoopCount;
    if(LoopCount == 100000)
    {
      G4ExceptionDescription msg;
      msg << "LoopCount = 100000\n";
      msg << "Either the source distribution >> confinement\n";
      msg << "or any confining volume may not overlap with\n";
      msg << "the source distribution or any confining volumes\n";
      msg << "may not exist\n"<< G4endl;
      msg << "If you have set confine then this will be ignored\n";
      msg << "for this event.\n" << G4endl;
      G4Exception("G4SPSPosDistribution::GenerateOne()",
                  "G4GPS001", JustWarning, msg);
      srcconf = true; // Avoids an infinite loop
    }
  }
  ThreadData.Get().CParticlePos = localP;
  return localP;
}

References Confine, G4endl, G4Exception(), GeneratePointsInBeam(), GeneratePointsInPlane(), GeneratePointsInVolume(), GeneratePointsOnSurface(), GeneratePointSource(), IsSourceConfined(), JustWarning, SourcePosType, and ThreadData.

Referenced by G4SingleParticleSource::GeneratePrimaryVertex().

◆ GeneratePointsInBeam()

void G4SPSPosDistribution::GeneratePointsInBeam ( G4ThreeVector & outoutPos )

private

Definition at line 321 of file G4SPSPosDistribution.cc.

{
  G4double x, y, z;
 
  G4ThreeVector RandPos;
  G4double tempx, tempy, tempz;
  z = 0.;
  
  // Private Method to create points in a plane
  //
  if(Shape == "Circle")
  {
    x = Radius + 100.;
    y = Radius + 100.;
    while(std::sqrt((x*x) + (y*y)) > Radius)
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
 
      x = (x*2.*Radius) - Radius;
      y = (y*2.*Radius) - Radius;
    }
    x += G4RandGauss::shoot(0.0,SX) ;
    y += G4RandGauss::shoot(0.0,SY) ;
  }  
  else
  {
    // All other cases default to Rectangle case
    //
    x = PosRndm->GenRandX();
    y = PosRndm->GenRandY();
    x = (x*2.*halfx) - halfx;
    y = (y*2.*halfy) - halfy;
    x += G4RandGauss::shoot(0.0,SX);
    y += G4RandGauss::shoot(0.0,SY);
  }
 
  // Apply Rotation Matrix
  // x * Rotx, y * Roty and z * Rotz
  //
  if(verbosityLevel >= 2)
  {
    G4cout << "Raw position " << x << "," << y << "," << z << G4endl;
  }
  tempx = (x * Rotx.x()) + (y * Roty.x()) + (z * Rotz.x());
  tempy = (x * Rotx.y()) + (y * Roty.y()) + (z * Rotz.y());
  tempz = (x * Rotx.z()) + (y * Roty.z()) + (z * Rotz.z());
  
  RandPos.setX(tempx);
  RandPos.setY(tempy);
  RandPos.setZ(tempz);
  
  // Translate
  //
  pos = CentreCoords + RandPos;
  if(verbosityLevel >= 1)
  {
    if(verbosityLevel >= 2)
    {
      G4cout << "Rotated Position " << RandPos << G4endl;
    }
    G4cout << "Rotated and Translated position " << pos << G4endl;
  }
}

References CentreCoords, G4cout, G4endl, G4SPSRandomGenerator::GenRandX(), G4SPSRandomGenerator::GenRandY(), halfx, halfy, pos, PosRndm, Radius, Rotx, Roty, Rotz, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), Shape, G4INCL::DeJongSpin::shoot(), SX, SY, verbosityLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GenerateOne().

◆ GeneratePointsInPlane()

void G4SPSPosDistribution::GeneratePointsInPlane ( G4ThreeVector & outoutPos )

private

Definition at line 386 of file G4SPSPosDistribution.cc.

{
  G4double x, y, z;
  G4double expression;
  G4ThreeVector RandPos;
  G4double tempx, tempy, tempz;
  x = y = z = 0.;
  thread_data_t& td = ThreadData.Get();
 
  if(SourcePosType != "Plane" && verbosityLevel >= 1)
  {
    G4cerr << "Error: SourcePosType is not Plane" << G4endl;
  }
 
  // Private Method to create points in a plane
  //
  if(Shape == "Circle")
  {
    x = Radius + 100.;
    y = Radius + 100.;
    while(std::sqrt((x*x) + (y*y)) > Radius)
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
 
      x = (x*2.*Radius) - Radius;
      y = (y*2.*Radius) - Radius;
    }
  }
  else if(Shape == "Annulus")
  {
    x = Radius + 100.;
    y = Radius + 100.;
    while(std::sqrt((x*x) + (y*y)) > Radius
       || std::sqrt((x*x) + (y*y)) < Radius0 )
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
 
      x = (x*2.*Radius) - Radius;
      y = (y*2.*Radius) - Radius;
    }
  }
  else if(Shape == "Ellipse")
  {
    expression = 20.;
    while(expression > 1.)
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
 
      x = (x*2.*halfx) - halfx;
      y = (y*2.*halfy) - halfy;
 
      expression = ((x*x)/(halfx*halfx)) + ((y*y)/(halfy*halfy));
    }
  }
  else if(Shape == "Square")
  {
    x = PosRndm->GenRandX();
    y = PosRndm->GenRandY();
    x = (x*2.*halfx) - halfx;
    y = (y*2.*halfy) - halfy;
  }
  else if(Shape == "Rectangle")
  {
    x = PosRndm->GenRandX();
    y = PosRndm->GenRandY();
    x = (x*2.*halfx) - halfx;
    y = (y*2.*halfy) - halfy;
  }
  else
  {
    G4cout << "Shape not one of the plane types" << G4endl;
  }
 
  // Apply Rotation Matrix
  // x * Rotx, y * Roty and z * Rotz
  //
  if(verbosityLevel == 2)
  {
    G4cout << "Raw position " << x << "," << y << "," << z << G4endl;
  }
  tempx = (x * Rotx.x()) + (y * Roty.x()) + (z * Rotz.x());
  tempy = (x * Rotx.y()) + (y * Roty.y()) + (z * Rotz.y());
  tempz = (x * Rotx.z()) + (y * Roty.z()) + (z * Rotz.z());
 
  RandPos.setX(tempx);
  RandPos.setY(tempy);
  RandPos.setZ(tempz);
 
  // Translate
  //
  pos = CentreCoords + RandPos;
  if(verbosityLevel >= 1)
  {
    if(verbosityLevel == 2)
    {
      G4cout << "Rotated Position " << RandPos << G4endl;
    }
    G4cout << "Rotated and Translated position " << pos << G4endl;
  }
 
  // For Cosine-Law make SideRefVecs = to Rotation matrix vectors
  // Note: these need to be thread-local, use G4Cache
  //
  td.CSideRefVec1 = Rotx;
  td.CSideRefVec2 = Roty;
  td.CSideRefVec3 = Rotz;
 
  // If rotation matrix z' point to origin then invert the matrix
  // So that SideRefVecs point away
  //
  if((CentreCoords.x() > 0. && Rotz.x() < 0.)
     || (CentreCoords.x() < 0. && Rotz.x() > 0.)
     || (CentreCoords.y() > 0. && Rotz.y() < 0.)
     || (CentreCoords.y() < 0. && Rotz.y() > 0.)
     || (CentreCoords.z() > 0. && Rotz.z() < 0.)
     || (CentreCoords.z() < 0. && Rotz.z() > 0.))
  {
    // Invert y and z
    //
    td.CSideRefVec2 = - td.CSideRefVec2;
    td.CSideRefVec3 = - td.CSideRefVec3;
  }
  if(verbosityLevel == 2)
  {
    G4cout << "Reference vectors for cosine-law "
           << td.CSideRefVec1<< " " << td.CSideRefVec2
           << " " << td.CSideRefVec3 << G4endl;
  }
}

References CentreCoords, G4SPSPosDistribution::thread_data_t::CSideRefVec1, G4SPSPosDistribution::thread_data_t::CSideRefVec2, G4SPSPosDistribution::thread_data_t::CSideRefVec3, G4cerr, G4cout, G4endl, G4SPSRandomGenerator::GenRandX(), G4SPSRandomGenerator::GenRandY(), halfx, halfy, pos, PosRndm, Radius, Radius0, Rotx, Roty, Rotz, CLHEP::Hep3Vector::setX(), CLHEP::Hep3Vector::setY(), CLHEP::Hep3Vector::setZ(), Shape, SourcePosType, ThreadData, verbosityLevel, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by GenerateOne().

◆ GeneratePointsInVolume()

void G4SPSPosDistribution::GeneratePointsInVolume ( G4ThreeVector & outputPos )

private

Definition at line 1070 of file G4SPSPosDistribution.cc.

{
  G4ThreeVector RandPos;
  G4double tempx, tempy, tempz;
  G4double x, y, z;
  G4double expression;
  x = y = z = 0.;
 
  if(SourcePosType != "Volume" && verbosityLevel >= 1)
  {
    G4cout << "Error SourcePosType not Volume" << G4endl;
  }
 
  // Private method to create points in a volume
  //
  if(Shape == "Sphere")
  {
    x = Radius*2.;
    y = Radius*2.;
    z = Radius*2.;
    while(((x*x)+(y*y)+(z*z)) > (Radius*Radius))
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
      z = PosRndm->GenRandZ();
 
      x = (x*2.*Radius) - Radius;
      y = (y*2.*Radius) - Radius;
      z = (z*2.*Radius) - Radius;
    }
  }
  else if(Shape == "Ellipsoid")
  {
    G4double temp;
    temp = 100.;
    while(temp > 1.)
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
      z = PosRndm->GenRandZ();
 
      x = (x*2.*halfx) - halfx;
      y = (y*2.*halfy) - halfy;
      z = (z*2.*halfz) - halfz;
          
      temp = ((x*x)/(halfx*halfx))+((y*y)/(halfy*halfy))+((z*z)/(halfz*halfz));
    }
  }
  else if(Shape == "Cylinder")
  {
    x = Radius*2.;
    y = Radius*2.;
    while(((x*x)+(y*y)) > (Radius*Radius))
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
      z = PosRndm->GenRandZ();
 
      x = (x*2.*Radius) - Radius;
      y = (y*2.*Radius) - Radius;
      z = (z*2.*halfz) - halfz;
    }
  }
  else if(Shape == "EllipticCylinder")
  {
    expression = 20.;
    while(expression > 1.)
    {
      x = PosRndm->GenRandX();
      y = PosRndm->GenRandY();
      z = PosRndm->GenRandZ();
 
      x = (x*2.*halfx) - halfx;
      y = (y*2.*halfy) - halfy;
      z = (z*2.*halfz) - halfz;
 
      expression = ((x*x)/(halfx*halfx)) + ((y*y)/(halfy*halfy));
    }
  }
  else if(Shape == "Para")
  {
    x = PosRndm->GenRandX();
    y = PosRndm->GenRandY();
    z = PosRndm->GenRandZ();
    x = (x*2.*halfx) - halfx;
    y = (y*2.*halfy) - halfy;
    z = (z*2.*halfz) - halfz;
    x = x + z*std::tan(ParTheta)*std::cos(ParPhi) + y*std::tan(ParAlpha);
    y = y + z*std::tan(ParTheta)*std::sin(ParPhi);
    // z = z;
  }
  else
  {
    G4cout << "Error: Volume Shape does not exist" << G4endl;
  }
 
  RandPos.setX(x);
  RandPos.setY(y);
  RandPos.setZ(z);
 
  // Apply Rotation Matrix
  // x * Rotx, y * Roty and z * Rotz
  //
  tempx = (x * Rotx.x()) + (y * Roty.x()) + (z * Rotz.x());
  tempy = (x * Rotx.y()) + (y * Roty.y()) + (z * Rotz.y());
  tempz = (x * Rotx.z()) + (y * Roty.z()) + (z * Rotz.z());
 
  RandPos.setX(tempx);
  RandPos.setY(tempy);
  RandPos.setZ(tempz);
 
  // Translate
  //
  pos = CentreCoords + RandPos;
 
  if(verbosityLevel == 2)
  {
    G4cout << "Raw position " << x << "," << y << "," << z << G4endl;
    G4cout << "Rotated position " << RandPos << G4endl;
  }
  if(verbosityLevel >= 1)
  {
    G4cout << "Rotated and translated position " << pos << G4endl;
  }
 
  // Cosine-law (not a good idea to use this here)
  //
  G4ThreeVector zdash(tempx,tempy,tempz);
  zdash = zdash.unit();
  G4ThreeVector xdash = Rotz.cross(zdash);
  G4ThreeVector ydash = xdash.cross(zdash);
  thread_data_t& td = ThreadData.Get();
  td.CSideRefVec1 = xdash.unit();
  td.CSideRefVec2 = ydash.unit();
  td.CSideRefVec3 = zdash.unit();
  if(verbosityLevel == 2)
  {
    G4cout << "Reference vectors for cosine-law " << td.CSideRefVec1
           << " " << td.CSideRefVec2 << " " << td.CSideRefVec3 << G4endl;
  } 
}

Referenced by GenerateOne().

◆ GeneratePointsOnSurface()

void G4SPSPosDistribution::GeneratePointsOnSurface ( G4ThreeVector & outputPos )

private

Definition at line 519 of file G4SPSPosDistribution.cc.

{
  // Private method to create points on a surface
  //
  G4double theta, phi;
  G4double x, y, z;
  x = y = z = 0.;
  G4double expression;
  G4ThreeVector RandPos;
 
  thread_data_t& td = ThreadData.Get();
  if(SourcePosType != "Surface" && verbosityLevel >= 1)
  {
    G4cout << "Error SourcePosType not Surface" << G4endl;
  }
 
  if(Shape == "Sphere")
  {
    theta = PosRndm->GenRandPosTheta();
    phi = PosRndm->GenRandPosPhi();
    theta = std::acos(1. - 2.*theta); // theta isotropic
    phi = phi * 2. * pi;
      
    x = Radius * std::sin(theta) * std::cos(phi);
    y = Radius * std::sin(theta) * std::sin(phi);
    z = Radius * std::cos(theta);
      
    RandPos.setX(x);
    RandPos.setY(y);
    RandPos.setZ(z);
 
    // Cosine-law (not a good idea to use this here)
    //
    G4ThreeVector zdash(x,y,z);
    zdash = zdash.unit();
    G4ThreeVector xdash = Rotz.cross(zdash);
    G4ThreeVector ydash = xdash.cross(zdash);
    td.CSideRefVec1 = xdash.unit();
    td.CSideRefVec2 = ydash.unit();
    td.CSideRefVec3 = zdash.unit();
  }
  else if(Shape == "Ellipsoid")
  {
    G4double minphi, maxphi, middlephi;
    G4double answer, constant;
 
    constant = pi/(halfx*halfx) + pi/(halfy*halfy) + twopi/(halfz*halfz);
      
    // Simplified approach
    //
    theta = PosRndm->GenRandPosTheta();
    phi = PosRndm->GenRandPosPhi();
      
    theta = std::acos(1. - 2.*theta);
    minphi = 0.;
    maxphi = twopi;
    while(maxphi-minphi > 0.)
    {
      middlephi = (maxphi+minphi)/2.;
      answer = (1./(halfx*halfx))*(middlephi/2. + std::sin(2*middlephi)/4.)
             + (1./(halfy*halfy))*(middlephi/2. - std::sin(2*middlephi)/4.)
             + middlephi/(halfz*halfz);
      answer = answer/constant;
      if(answer > phi) maxphi = middlephi;
      if(answer < phi) minphi = middlephi;
      if(std::fabs(answer-phi) <= 0.00001)
      {
        minphi = maxphi +1;
        phi = middlephi;
      }
    }
 
    // x,y and z form a unit vector. Put this onto the ellipse.
    //
    x = std::sin(theta)*std::cos(phi);
    y = std::sin(theta)*std::sin(phi);
    z = std::cos(theta);
 
    G4double lhs;
 
    // Solve for x
    //
    G4double numYinX = y/x;
    G4double numZinX = z/x;
    G4double tempxvar;          
    tempxvar = 1./(halfx*halfx)+(numYinX*numYinX)/(halfy*halfy)
             + (numZinX*numZinX)/(halfz*halfz);
    tempxvar = 1./tempxvar;
    G4double coordx = std::sqrt(tempxvar);
  
    // Solve for y
    //
    G4double numXinY = x/y;
    G4double numZinY = z/y;
    G4double tempyvar;
    tempyvar = (numXinY*numXinY)/(halfx*halfx)+1./(halfy*halfy)
             + (numZinY*numZinY)/(halfz*halfz);
    tempyvar = 1./tempyvar;
    G4double coordy = std::sqrt(tempyvar);
   
    // Solve for z
    //
    G4double numXinZ = x/z;
    G4double numYinZ = y/z;
    G4double tempzvar;
    tempzvar = (numXinZ*numXinZ)/(halfx*halfx)
             + (numYinZ*numYinZ)/(halfy*halfy)+1./(halfz*halfz);
    tempzvar = 1./tempzvar;
    G4double coordz = std::sqrt(tempzvar);
 
    lhs = std::sqrt((coordx*coordx)/(halfx*halfx) +
                    (coordy*coordy)/(halfy*halfy) +
                    (coordz*coordz)/(halfz*halfz));
      
    if(std::fabs(lhs-1.) > 0.001 && verbosityLevel >= 1)
    {
      G4cout << "Error: theta, phi not really on ellipsoid" << G4endl;
    }
 
    // coordx, coordy and coordz are all positive
    //
    G4double TestRandVar = G4UniformRand();
    if(TestRandVar > 0.5)
    {
      coordx = -coordx;
    }
    TestRandVar = G4UniformRand();
    if(TestRandVar > 0.5)
    {
      coordy = -coordy;
    }
    TestRandVar = G4UniformRand();
    if(TestRandVar > 0.5)
    {
      coordz = -coordz;
    }
 
    RandPos.setX(coordx);
    RandPos.setY(coordy);
    RandPos.setZ(coordz);
 
    // Cosine-law (not a good idea to use this here)
    //
    G4ThreeVector zdash(coordx,coordy,coordz);
    zdash = zdash.unit();
    G4ThreeVector xdash = Rotz.cross(zdash);
    G4ThreeVector ydash = xdash.cross(zdash);
    td.CSideRefVec1 = xdash.unit();
    td.CSideRefVec2 = ydash.unit();
    td.CSideRefVec3 = zdash.unit();
  }
  else if(Shape == "Cylinder")
  {
    G4double AreaTop, AreaBot, AreaLat;
    G4double AreaTotal, prob1, prob2, prob3;
    G4double testrand;
 
    // User giver Radius and z-half length
    // Calculate surface areas, maybe move this to 
    // a different method
 
    AreaTop = pi * Radius * Radius;
    AreaBot = AreaTop;
    AreaLat = 2. * pi * Radius * 2. * halfz;
    AreaTotal = AreaTop + AreaBot + AreaLat;
      
    prob1 = AreaTop / AreaTotal;
    prob2 = AreaBot / AreaTotal;
    prob3 = 1.00 - prob1 - prob2;
    if(std::fabs(prob3 - (AreaLat/AreaTotal)) >= 0.001)
    {
      if(verbosityLevel >= 1)
      {
        G4cout << AreaLat/AreaTotal << " " << prob3 << G4endl;
      }
      G4cout << "Error in prob3" << G4endl;
    }
 
    // Decide surface to calculate point on.
 
    testrand = G4UniformRand();
    if(testrand <= prob1)  // Point on Top surface
    {
      z = halfz;
      x = Radius + 100.;
      y = Radius + 100.;
      while(((x*x)+(y*y)) > (Radius*Radius))
      {
         x = PosRndm->GenRandX();
         y = PosRndm->GenRandY();
 
         x = x * 2. * Radius;
         y = y * 2. * Radius;
         x = x - Radius;
         y = y - Radius;
      }
      // Cosine law
      //
      td.CSideRefVec1 = Rotx;
      td.CSideRefVec2 = Roty;
      td.CSideRefVec3 = Rotz;
    }
    else if((testrand > prob1) && (testrand <= (prob1 + prob2)))
    {                          // Point on Bottom surface
      z = -halfz;
      x = Radius + 100.;
      y = Radius + 100.;
      while(((x*x)+(y*y)) > (Radius*Radius))
      {
        x = PosRndm->GenRandX();
        y = PosRndm->GenRandY();
 
        x = x * 2. * Radius;
        y = y * 2. * Radius;
        x = x - Radius;
        y = y - Radius;
      }
      // Cosine law
      //
      td.CSideRefVec1 = Rotx;
      td.CSideRefVec2 = -Roty;
      td.CSideRefVec3 = -Rotz;
    }
    else if(testrand > (prob1+prob2))  // Point on Lateral Surface
    {
      G4double rand;
 
      rand = PosRndm->GenRandPosPhi();
      rand = rand * 2. * pi;
 
      x = Radius * std::cos(rand);
      y = Radius * std::sin(rand);
 
      z = PosRndm->GenRandZ();
 
      z = z * 2. *halfz;
      z = z - halfz;
          
      // Cosine law
      //
      G4ThreeVector zdash(x,y,0.);
      zdash = zdash.unit();
      G4ThreeVector xdash = Rotz.cross(zdash);
      G4ThreeVector ydash = xdash.cross(zdash);
      td.CSideRefVec1 = xdash.unit();
      td.CSideRefVec2 = ydash.unit();
      td.CSideRefVec3 = zdash.unit();
    }
    else
    {
      G4cout << "Error: testrand " << testrand << G4endl;
    }
 
    RandPos.setX(x);
    RandPos.setY(y);
    RandPos.setZ(z);
  }
  else if(Shape == "EllipticCylinder")
  {
    G4double AreaTop, AreaBot, AreaLat, AreaTotal;
    G4double h;
    G4double prob1, prob2, prob3;
    G4double testrand;
 
    // User giver x, y and z-half length
    // Calculate surface areas, maybe move this to
    // a different method
 
    AreaTop = pi * halfx * halfy;
    AreaBot = AreaTop;
 
    // Using circumference approximation by Ramanujan (order h^3)
    // AreaLat = 2*halfz * pi*( 3*(halfx + halfy)
    //         - std::sqrt((3*halfx + halfy) * (halfx + 3*halfy)) );
    // Using circumference approximation by Ramanujan (order h^5)
    //
    h = ((halfx - halfy)*(halfx - halfy)) / ((halfx + halfy)*(halfx + halfy));
    AreaLat = 2*halfz * pi*(halfx + halfy)
            * (1 + (3*h)/(10 + std::sqrt(4 - 3*h)));
    AreaTotal = AreaTop + AreaBot + AreaLat;
 
    prob1 = AreaTop / AreaTotal;
    prob2 = AreaBot / AreaTotal;
    prob3 = 1.00 - prob1 - prob2;
    if(std::fabs(prob3 - (AreaLat/AreaTotal)) >= 0.001)
    {
      if(verbosityLevel >= 1)
      {
        G4cout << AreaLat/AreaTotal << " " << prob3 << G4endl;
      }
      G4cout << "Error in prob3" << G4endl;
    }
 
    // Decide surface to calculate point on
 
    testrand = G4UniformRand();
    if(testrand <= prob1)  // Point on Top surface
    {
      z = halfz;
      expression = 20.;
      while(expression > 1.)
      {
        x = PosRndm->GenRandX();
        y = PosRndm->GenRandY();
 
        x = (x * 2. * halfx) - halfx;
        y = (y * 2. * halfy) - halfy;
 
        expression = ((x*x)/(halfx*halfx)) + ((y*y)/(halfy*halfy));
      }
    }
    else if((testrand > prob1) && (testrand <= (prob1 + prob2)))
    {                          // Point on Bottom surface
      z = -halfz;
      expression = 20.;
      while(expression > 1.)
      {
        x = PosRndm->GenRandX();
        y = PosRndm->GenRandY();
 
        x = (x * 2. * halfx) - halfx;
        y = (y * 2. * halfy) - halfy;
 
        expression = ((x*x)/(halfx*halfx)) + ((y*y)/(halfy*halfy));
      }
    }
    else if(testrand > (prob1+prob2))  // Point on Lateral Surface
    {
      G4double rand;
 
      rand = PosRndm->GenRandPosPhi();
      rand = rand * 2. * pi;
 
      x = halfx * std::cos(rand);
      y = halfy * std::sin(rand);
 
      z = PosRndm->GenRandZ();
 
      z = (z * 2. * halfz) - halfz;
    }
    else
    {
      G4cout << "Error: testrand " << testrand << G4endl;
    }
 
    RandPos.setX(x);
    RandPos.setY(y);
    RandPos.setZ(z);
 
    // Cosine law
    //
    G4ThreeVector zdash(x,y,z);
    zdash = zdash.unit();
    G4ThreeVector xdash = Rotz.cross(zdash);
    G4ThreeVector ydash = xdash.cross(zdash);
    td.CSideRefVec1 = xdash.unit();
    td.CSideRefVec2 = ydash.unit();
    td.CSideRefVec3 = zdash.unit();
  }
  else if(Shape == "Para")
  {
    // Right Parallelepiped.
    // User gives x,y,z half lengths and ParAlpha
    // ParTheta and ParPhi
    // +x = <1, -x >1 & <2, +y >2 & <3, -y >3 &<4
    // +z >4 & < 5, -z >5 &<6
 
    G4double testrand = G4UniformRand();
    G4double AreaX = halfy * halfz * 4.;
    G4double AreaY = halfx * halfz * 4.;
    G4double AreaZ = halfx * halfy * 4.;
    G4double AreaTotal = 2*(AreaX + AreaY + AreaZ);
    G4double Probs[6];
    Probs[0] = AreaX/AreaTotal;
    Probs[1] = Probs[0] + AreaX/AreaTotal;
    Probs[2] = Probs[1] + AreaY/AreaTotal;
    Probs[3] = Probs[2] + AreaY/AreaTotal;
    Probs[4] = Probs[3] + AreaZ/AreaTotal;
    Probs[5] = Probs[4] + AreaZ/AreaTotal;
      
    x = PosRndm->GenRandX();
    y = PosRndm->GenRandY();
    z = PosRndm->GenRandZ();
      
    x = x * halfx * 2.;
    x = x - halfx;
    y = y * halfy * 2.;
    y = y - halfy;
    z = z * halfz * 2.;
    z = z - halfz;
 
    // Pick a side first
    //
    if(testrand < Probs[0])
    {
      // side is +x
 
      x = halfx + z*std::tan(ParTheta)*std::cos(ParPhi) + y*std::tan(ParAlpha);
      y = y + z*std::tan(ParTheta)*std::sin(ParPhi);
      // z = z;
 
      // Cosine-law
      //
      G4ThreeVector xdash(halfz*std::tan(ParTheta)*std::cos(ParPhi),
                          halfz*std::tan(ParTheta)*std::sin(ParPhi),
                          halfz/std::cos(ParPhi));
      G4ThreeVector ydash(halfy*std::tan(ParAlpha), -halfy, 0.0);
      xdash = xdash.unit();
      ydash = ydash.unit();
      G4ThreeVector zdash = xdash.cross(ydash);
      td.CSideRefVec1 = xdash.unit();
      td.CSideRefVec2 = ydash.unit();
      td.CSideRefVec3 = zdash.unit();
    }
    else if(testrand >= Probs[0] && testrand < Probs[1])
    {
      // side is -x
 
      x = -halfx + z*std::tan(ParTheta)*std::cos(ParPhi) + y*std::tan(ParAlpha);
      y = y + z*std::tan(ParTheta)*std::sin(ParPhi);
      // z = z;
 
      // Cosine-law
      //
      G4ThreeVector xdash(halfz*std::tan(ParTheta)*std::cos(ParPhi),
                          halfz*std::tan(ParTheta)*std::sin(ParPhi),
                          halfz/std::cos(ParPhi));
      G4ThreeVector ydash(halfy*std::tan(ParAlpha), halfy, 0.0);
      xdash = xdash.unit();
      ydash = ydash.unit();
      G4ThreeVector zdash = xdash.cross(ydash);
      td.CSideRefVec1 = xdash.unit();
      td.CSideRefVec2 = ydash.unit();
      td.CSideRefVec3 = zdash.unit();
    }
    else if(testrand >= Probs[1] && testrand < Probs[2])
    {
      // side is +y
 
      x = x + z*std::tan(ParTheta)*std::cos(ParPhi) + halfy*std::tan(ParAlpha);
      y = halfy + z*std::tan(ParTheta)*std::sin(ParPhi);
      // z = z;
 
      // Cosine-law
      //
      G4ThreeVector ydash(halfz*std::tan(ParTheta)*std::cos(ParPhi),
                          halfz*std::tan(ParTheta)*std::sin(ParPhi),
                          halfz/std::cos(ParPhi));
      ydash = ydash.unit();
      G4ThreeVector xdash = Roty.cross(ydash);
      G4ThreeVector zdash = xdash.cross(ydash);
      td.CSideRefVec1 = xdash.unit();
      td.CSideRefVec2 = -ydash.unit();
      td.CSideRefVec3 = -zdash.unit();
    }
    else if(testrand >= Probs[2] && testrand < Probs[3])
    {
      // side is -y
 
      x = x + z*std::tan(ParTheta)*std::cos(ParPhi) - halfy*std::tan(ParAlpha);
      y = -halfy + z*std::tan(ParTheta)*std::sin(ParPhi);
      // z = z;
 
      // Cosine-law
      //
      G4ThreeVector ydash(halfz*std::tan(ParTheta)*std::cos(ParPhi),
                          halfz*std::tan(ParTheta)*std::sin(ParPhi),
                          halfz/std::cos(ParPhi));
      ydash = ydash.unit();
      G4ThreeVector xdash = Roty.cross(ydash);
      G4ThreeVector zdash = xdash.cross(ydash);
      td.CSideRefVec1 = xdash.unit();
      td.CSideRefVec2 = ydash.unit();
      td.CSideRefVec3 = zdash.unit();
    }
    else if(testrand >= Probs[3] && testrand < Probs[4])
    {
      // side is +z
 
      z = halfz;
      y = y + halfz*std::sin(ParPhi)*std::tan(ParTheta);
      x = x + halfz*std::cos(ParPhi)*std::tan(ParTheta) + y*std::tan(ParAlpha);
 
      // Cosine-law
      //
      td.CSideRefVec1 = Rotx;
      td.CSideRefVec2 = Roty;
      td.CSideRefVec3 = Rotz;
    }
    else if(testrand >= Probs[4] && testrand < Probs[5])
    {
      // side is -z
 
      z = -halfz;
      y = y - halfz*std::sin(ParPhi)*std::tan(ParTheta);
      x = x - halfz*std::cos(ParPhi)*std::tan(ParTheta) + y*std::tan(ParAlpha);
 
      // Cosine-law
      //
      td.CSideRefVec1 = Rotx;
      td.CSideRefVec2 = -Roty;
      td.CSideRefVec3 = -Rotz;
    }
    else
    {
      G4cout << "Error: testrand out of range" << G4endl;
      if(verbosityLevel >= 1)
      {
        G4cout << "testrand=" << testrand << " Probs[5]=" << Probs[5] <<G4endl;
      }
    }
 
    RandPos.setX(x);
    RandPos.setY(y);
    RandPos.setZ(z);
  }
 
  // Apply Rotation Matrix
  // x * Rotx, y * Roty and z * Rotz
  //
  if(verbosityLevel == 2)
  {
    G4cout << "Raw position " << RandPos << G4endl;
  }
  x=(RandPos.x()*Rotx.x())+(RandPos.y()*Roty.x())+(RandPos.z()*Rotz.x());
  y=(RandPos.x()*Rotx.y())+(RandPos.y()*Roty.y())+(RandPos.z()*Rotz.y());
  z=(RandPos.x()*Rotx.z())+(RandPos.y()*Roty.z())+(RandPos.z()*Rotz.z());
  
  RandPos.setX(x);
  RandPos.setY(y);
  RandPos.setZ(z);
 
  // Translate
  //
  pos = CentreCoords + RandPos;
 
  if(verbosityLevel >= 1)
  {
    if(verbosityLevel == 2)
    {
      G4cout << "Rotated position " << RandPos << G4endl;
    }
    G4cout << "Rotated and translated position " << pos << G4endl;
  }
  if(verbosityLevel == 2)
  {
    G4cout << "Reference vectors for cosine-law " << td.CSideRefVec1
           << " " << td.CSideRefVec2 << " " << td.CSideRefVec3 << G4endl;
  }
}

Referenced by GenerateOne().

◆ GeneratePointSource()

void G4SPSPosDistribution::GeneratePointSource ( G4ThreeVector & outoutPos )

private

Definition at line 304 of file G4SPSPosDistribution.cc.

{
  // Generates Points given the point source
 
  if(SourcePosType == "Point")
  {
    pos = CentreCoords;
  }
  else
  {
    if(verbosityLevel >= 1)
    {
      G4cerr << "Error SourcePosType is not set to Point" << G4endl;
    }
  }
}

References CentreCoords, G4cerr, G4endl, pos, SourcePosType, and verbosityLevel.

Referenced by GenerateOne().

◆ GenerateRotationMatrices()

void G4SPSPosDistribution::GenerateRotationMatrices ( )

private

Definition at line 246 of file G4SPSPosDistribution.cc.

{
  // This takes in 2 vectors, x' and one in the plane x'-y',
  // and from these takes a cross product to calculate z'.
  // Then a cross product is taken between x' and z' to give y'
 
  Rotx = Rotx.unit(); // x'
  Roty = Roty.unit(); // vector in x'y' plane
  Rotz = Rotx.cross(Roty); // z'
  Rotz = Rotz.unit();
  Roty =Rotz.cross(Rotx); // y'
  Roty =Roty.unit();
  if(verbosityLevel == 2)
  {
    G4cout << "The new axes, x', y', z' "
           << Rotx << " " << Roty << " " << Rotz << G4endl;
  }
}

References CLHEP::Hep3Vector::cross(), G4cout, G4endl, Rotx, Roty, Rotz, CLHEP::Hep3Vector::unit(), and verbosityLevel.

Referenced by SetPosRot1(), and SetPosRot2().

◆ GetCentreCoords()

const G4ThreeVector & G4SPSPosDistribution::GetCentreCoords ( ) const

Definition at line 185 of file G4SPSPosDistribution.cc.

{
  return CentreCoords;
}

References CentreCoords.

Referenced by G4GPSModel::DescribeYourselfTo(), and G4GeneralParticleSource::ListSource().

◆ GetConfined()

G4bool G4SPSPosDistribution::GetConfined ( ) const

inline

Definition at line 151 of file G4SPSPosDistribution.hh.

151{ return Confine; }

References Confine.

◆ GetConfineVolume()

const G4String & G4SPSPosDistribution::GetConfineVolume ( ) const

inline

Definition at line 152 of file G4SPSPosDistribution.hh.

152{ return VolName; }

References VolName.

◆ GetHalfX()

G4double G4SPSPosDistribution::GetHalfX ( ) const

Definition at line 190 of file G4SPSPosDistribution.cc.

{
  return halfx;
}

References halfx.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetHalfY()

G4double G4SPSPosDistribution::GetHalfY ( ) const

Definition at line 195 of file G4SPSPosDistribution.cc.

{
  return halfy;
}

References halfy.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetHalfZ()

G4double G4SPSPosDistribution::GetHalfZ ( ) const

Definition at line 200 of file G4SPSPosDistribution.cc.

{
  return halfz;
}

References halfz.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetParAlpha()

G4double G4SPSPosDistribution::GetParAlpha ( ) const

inline

Definition at line 145 of file G4SPSPosDistribution.hh.

145{ return ParAlpha; }

References ParAlpha.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetParPhi()

G4double G4SPSPosDistribution::GetParPhi ( ) const

inline

Definition at line 147 of file G4SPSPosDistribution.hh.

147{ return ParPhi; }

References ParPhi.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetParTheta()

G4double G4SPSPosDistribution::GetParTheta ( ) const

inline

Definition at line 146 of file G4SPSPosDistribution.hh.

146{ return ParTheta; }

References ParTheta.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetParticlePos()

const G4ThreeVector & G4SPSPosDistribution::GetParticlePos ( ) const

Definition at line 226 of file G4SPSPosDistribution.cc.

{
  return ThreadData.Get().CParticlePos;
}

References ThreadData.

Referenced by G4SPSAngDistribution::GenerateFocusedFlux().

◆ GetPosDisShape()

const G4String & G4SPSPosDistribution::GetPosDisShape ( ) const

Definition at line 180 of file G4SPSPosDistribution.cc.

{
  return Shape;
}

References Shape.

Referenced by G4GPSModel::DescribeYourselfTo(), and G4GeneralParticleSource::ListSource().

◆ GetPosDisType()

const G4String & G4SPSPosDistribution::GetPosDisType ( ) const

Definition at line 175 of file G4SPSPosDistribution.cc.

{
  return SourcePosType;
}

References SourcePosType.

Referenced by G4GPSModel::DescribeYourselfTo(), and G4GeneralParticleSource::ListSource().

◆ GetRadius()

G4double G4SPSPosDistribution::GetRadius ( ) const

Definition at line 205 of file G4SPSPosDistribution.cc.

{
  return Radius;
}

References Radius.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetRadius0()

G4double G4SPSPosDistribution::GetRadius0 ( ) const

inline

Definition at line 144 of file G4SPSPosDistribution.hh.

144{ return Radius0; }

References Radius0.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetRotx()

const G4ThreeVector & G4SPSPosDistribution::GetRotx ( ) const

inline

Definition at line 148 of file G4SPSPosDistribution.hh.

148{ return Rotx; }

References Rotx.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetRoty()

const G4ThreeVector & G4SPSPosDistribution::GetRoty ( ) const

inline

Definition at line 149 of file G4SPSPosDistribution.hh.

149{ return Roty; }

References Roty.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetRotz()

const G4ThreeVector & G4SPSPosDistribution::GetRotz ( ) const

inline

Definition at line 150 of file G4SPSPosDistribution.hh.

150{ return Rotz; }

References Rotz.

Referenced by G4GPSModel::DescribeYourselfTo().

◆ GetSideRefVec1()

const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec1 ( ) const

Definition at line 231 of file G4SPSPosDistribution.cc.

{
  return ThreadData.Get().CSideRefVec1;
}

References ThreadData.

Referenced by G4SPSAngDistribution::GenerateCosineLawFlux(), G4SPSAngDistribution::GenerateIsotropicFlux(), and G4SPSAngDistribution::GenerateUserDefFlux().

◆ GetSideRefVec2()

const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec2 ( ) const

Definition at line 236 of file G4SPSPosDistribution.cc.

{
  return ThreadData.Get().CSideRefVec2;
}

References ThreadData.

Referenced by G4SPSAngDistribution::GenerateCosineLawFlux(), G4SPSAngDistribution::GenerateIsotropicFlux(), and G4SPSAngDistribution::GenerateUserDefFlux().

◆ GetSideRefVec3()

const G4ThreeVector & G4SPSPosDistribution::GetSideRefVec3 ( ) const

Definition at line 241 of file G4SPSPosDistribution.cc.

{
  return ThreadData.Get().CSideRefVec3;
}

References ThreadData.

Referenced by G4SPSAngDistribution::GenerateCosineLawFlux(), G4SPSAngDistribution::GenerateIsotropicFlux(), and G4SPSAngDistribution::GenerateUserDefFlux().

◆ GetSourcePosType()

const G4String & G4SPSPosDistribution::GetSourcePosType ( ) const

Definition at line 221 of file G4SPSPosDistribution.cc.

{
  return SourcePosType;
}

References SourcePosType.

Referenced by G4SPSAngDistribution::GenerateCosineLawFlux(), and G4SPSAngDistribution::GenerateIsotropicFlux().

◆ IsSourceConfined()

G4bool G4SPSPosDistribution::IsSourceConfined ( G4ThreeVector & outputPos )

private

Definition at line 1212 of file G4SPSPosDistribution.cc.

{
  // Method to check point is within the volume specified
 
  if(Confine == false)
  {
    G4cout << "Error: Confine is false" << G4endl;
  }
  G4ThreeVector null(0.,0.,0.);
  G4ThreeVector* ptr = &null;
 
  // Check position is within VolName, if so true, else false
  //
  G4VPhysicalVolume* theVolume;
  G4Navigator* gNavigator = G4TransportationManager::GetTransportationManager()
                          ->GetNavigatorForTracking();
  theVolume = gNavigator->LocateGlobalPointAndSetup(pos,ptr,true);
  if(theVolume == nullptr) { return false; }
  G4String theVolName = theVolume->GetName();
 
  if(theVolName == VolName)
  {
    if(verbosityLevel >= 1)
    {
      G4cout << "Particle is in volume " << VolName << G4endl;
    }
    return true;
  }
  else
  {
    return false;
  }
}

References Confine, G4cout, G4endl, G4VPhysicalVolume::GetName(), G4TransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetTransportationManager(), G4Navigator::LocateGlobalPointAndSetup(), pos, verbosityLevel, and VolName.

Referenced by GenerateOne().

◆ SetBeamSigmaInR()

void G4SPSPosDistribution::SetBeamSigmaInR ( G4double r )

Definition at line 144 of file G4SPSPosDistribution.cc.

{
  SX = SY = r;
  SR = r;
}

References SR, SX, and SY.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetBeamSigmaInX()

void G4SPSPosDistribution::SetBeamSigmaInX ( G4double r )

Definition at line 150 of file G4SPSPosDistribution.cc.

{
  SX = r;
}

References SX.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetBeamSigmaInY()

void G4SPSPosDistribution::SetBeamSigmaInY ( G4double r )

Definition at line 155 of file G4SPSPosDistribution.cc.

{
  SY = r;
}

References SY.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetBiasRndm()

void G4SPSPosDistribution::SetBiasRndm ( G4SPSRandomGenerator * a )

Definition at line 210 of file G4SPSPosDistribution.cc.

{
  G4AutoLock l(&a_mutex);
  PosRndm = a;
}

References a_mutex, and PosRndm.

Referenced by G4SingleParticleSource::G4SingleParticleSource().

◆ SetCentreCoords()

void G4SPSPosDistribution::SetCentreCoords ( const G4ThreeVector & coordsOfCentre )

Definition at line 90 of file G4SPSPosDistribution.cc.

{
  CentreCoords = coordsOfCentre;
}

References CentreCoords.

Referenced by G4AdjointPrimaryGenerator::GenerateAdjointPrimaryVertex(), G4AdjointPrimaryGenerator::GenerateFwdPrimaryVertex(), G4GeneralParticleSourceMessenger::SetNewValue(), and G4AdjointPrimaryGenerator::SetSphericalAdjointPrimarySource().

◆ SetHalfX()

void G4SPSPosDistribution::SetHalfX ( G4double xhalf )

Definition at line 119 of file G4SPSPosDistribution.cc.

{
  halfx = xhalf;
}

References halfx.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetHalfY()

void G4SPSPosDistribution::SetHalfY ( G4double yhalf )

Definition at line 124 of file G4SPSPosDistribution.cc.

{
  halfy = yhalf;
}

References halfy.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetHalfZ()

void G4SPSPosDistribution::SetHalfZ ( G4double zhalf )

Definition at line 129 of file G4SPSPosDistribution.cc.

{
  halfz = zhalf;
}

References halfz.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetParAlpha()

void G4SPSPosDistribution::SetParAlpha ( G4double paralp )

Definition at line 160 of file G4SPSPosDistribution.cc.

{
  ParAlpha = paralp;
}

References ParAlpha.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetParPhi()

void G4SPSPosDistribution::SetParPhi ( G4double parphi )

Definition at line 170 of file G4SPSPosDistribution.cc.

{
  ParPhi = parphi;
}

References ParPhi.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetParTheta()

void G4SPSPosDistribution::SetParTheta ( G4double parthe )

Definition at line 165 of file G4SPSPosDistribution.cc.

{
  ParTheta = parthe;
}

References ParTheta.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetPosDisShape()

void G4SPSPosDistribution::SetPosDisShape ( const G4String & shapeType )

Definition at line 85 of file G4SPSPosDistribution.cc.

{
  Shape = shapeType;
}

References Shape.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue(), and G4AdjointPrimaryGenerator::SetSphericalAdjointPrimarySource().

◆ SetPosDisType()

void G4SPSPosDistribution::SetPosDisType ( const G4String & PosType )

Definition at line 80 of file G4SPSPosDistribution.cc.

{
  SourcePosType = PosType;
}

References SourcePosType.

Referenced by G4AdjointPrimaryGenerator::G4AdjointPrimaryGenerator(), G4AdjointPrimaryGenerator::SetAdjointPrimarySourceOnAnExtSurfaceOfAVolume(), G4GeneralParticleSourceMessenger::SetNewValue(), and G4AdjointPrimaryGenerator::SetSphericalAdjointPrimarySource().

◆ SetPosRot1()

void G4SPSPosDistribution::SetPosRot1 ( const G4ThreeVector & posrot1 )

Definition at line 95 of file G4SPSPosDistribution.cc.

{
  // This should be x'
 
  Rotx = posrot1;
  if(verbosityLevel == 2)
  {
    G4cout << "Vector x' " << Rotx << G4endl;
  }
  GenerateRotationMatrices();
}

References G4cout, G4endl, GenerateRotationMatrices(), Rotx, and verbosityLevel.

Referenced by G4GeneralParticleSourceMessenger::SetNewValue().

◆ SetPosRot2()

void G4SPSPosDistribution::SetPosRot2 ( const G4ThreeVector & posrot2 )

Definition at line 107 of file G4SPSPosDistribution.cc.

{
  // This is a vector in the plane x'y' but need not be y'
 
  Roty = posrot2;
  if(verbosityLevel == 2)
  {
    G4cout << "The vector in the x'-y' plane " << Roty << G4endl;
  }
  GenerateRotationMatrices();
}