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

Import Geant4 11.3.1 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2025-03-24 16:45:22 +01:00
parent 32390e802b
commit df176550b3
388 changed files with 29491 additions and 29435 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/solids/CSG/History
+8
View File
@@ -6,6 +6,14 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2025-03-04 Ben Morgan (geom-csg-V11-02-04)
- Hide all ENorm/ESide enums in anonymous namespaces to prevent ODR warnings.
- Identified in ATLAS Athena code built against v11.3.0.
## 2025-02-03 Gabriele Cosmo
- Removed fake default constructor from G4U* wrappers, clearing compilation
warnings on gcc-14.
## 2024-05-29 Evgueni Tcherniaev (geom-csg-V11-02-03)
- Added new methods GetNumOfConstituents() and IsFaceted().
source/geometry/solids/CSG/include/G4Cons.hh
-9
View File
@@ -189,15 +189,6 @@ class G4Cons : public G4CSGSolid
// specification for points not on the surface
private:
// Used by distanceToOut
//
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi,kPZ,kMZ};
// used by normal
//
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi,kNZ};
G4double kRadTolerance, kAngTolerance;
//
// Radial and angular tolerances
source/geometry/solids/CSG/include/G4Sphere.hh
-9
View File
@@ -201,15 +201,6 @@ class G4Sphere : public G4CSGSolid
// specification for points not on the surface
private:
// Used by distanceToOut
//
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi,kSTheta,kETheta};
// used by normal
//
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi,kNSTheta,kNETheta};
G4double fRminTolerance, fRmaxTolerance, kAngTolerance,
kRadTolerance, fEpsilon = 2.e-11;
//
source/geometry/solids/CSG/include/G4Torus.hh
-4
View File
@@ -183,11 +183,7 @@ class G4Torus : public G4CSGSolid
G4double fRmin,fRmax,fRtor,fSPhi,fDPhi;
// Used by distanceToOut
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi};
// used by normal
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi};
G4double fRminTolerance, fRmaxTolerance, kRadTolerance, kAngTolerance;
// Radial and angular tolerances
source/geometry/solids/CSG/include/G4Tubs.hh
-8
View File
@@ -190,14 +190,6 @@ class G4Tubs : public G4CSGSolid
protected:
// Used by distanceToOut
//
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi,kPZ,kMZ};
// Used by normal
//
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi,kNZ};
G4double kRadTolerance, kAngTolerance;
//
// Radial and angular tolerances
source/geometry/solids/CSG/include/G4UBox.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Box to make use of VecGeom Box.
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UBOX_HH
#define G4UBOX_HH
@@ -47,7 +47,7 @@ class G4UBox : public G4UAdapter<vecgeom::UnplacedBox>
using Shape_t = vecgeom::UnplacedBox;
using Base_t = G4UAdapter<vecgeom::UnplacedBox>;
public: // with description
public:
G4UBox(const G4String& pName, G4double pX, G4double pY, G4double pZ);
// Constructs a box with name, and half lengths pX,pY,pZ
@@ -81,13 +81,6 @@ class G4UBox : public G4UAdapter<vecgeom::UnplacedBox>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UBox(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UBox(const G4UBox& rhs);
G4UBox& operator=(const G4UBox& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UCons.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Cons to make use of VecGeom Cone.
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UCONS_HH
#define G4UCONS_HH
@@ -47,7 +47,7 @@ class G4UCons : public G4UAdapter<vecgeom::GenericUnplacedCone>
using Shape_t = vecgeom::GenericUnplacedCone;
using Base_t = G4UAdapter<vecgeom::GenericUnplacedCone>;
public: // with description
public:
G4UCons(const G4String& pName,
G4double pRmin1, G4double pRmax1,
@@ -95,13 +95,6 @@ class G4UCons : public G4UAdapter<vecgeom::GenericUnplacedCone>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UCons(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UCons(const G4UCons& rhs);
G4UCons& operator=(const G4UCons& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UCutTubs.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4CutTubs to make use of VecGeom CutTube.
// 07.07.17 G.Cosmo, CERN/PH
// 07.07.17 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UCUTTUBS_HH
#define G4UCUTTUBS_HH
@@ -47,7 +47,7 @@ class G4UCutTubs : public G4UAdapter<vecgeom::UnplacedCutTube>
using Shape_t = vecgeom::UnplacedCutTube;
using Base_t = G4UAdapter<vecgeom::UnplacedCutTube>;
public: // with description
public:
G4UCutTubs( const G4String& pName,
G4double pRMin,
@@ -92,13 +92,6 @@ class G4UCutTubs : public G4UAdapter<vecgeom::UnplacedCutTube>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UCutTubs(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UCutTubs(const G4UCutTubs& rhs);
G4UCutTubs& operator=(const G4UCutTubs& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UOrb.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Orb to make use of VecGeom Orb.
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UORB_HH
#define G4UORB_HH
@@ -47,7 +47,7 @@ class G4UOrb : public G4UAdapter<vecgeom::UnplacedOrb>
using Shape_t = vecgeom::UnplacedOrb;
using Base_t = G4UAdapter<vecgeom::UnplacedOrb>;
public: // with description
public:
G4UOrb(const G4String& pName, G4double pRmax);
@@ -74,13 +74,6 @@ class G4UOrb : public G4UAdapter<vecgeom::UnplacedOrb>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UOrb(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UOrb(const G4UOrb& rhs);
G4UOrb& operator=(const G4UOrb& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UPara.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Para to make use of VecGeom Parallelepiped.
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UPARA_HH
#define G4UPARA_HH
@@ -47,7 +47,7 @@ class G4UPara : public G4UAdapter<vecgeom::UnplacedParallelepiped>
using Shape_t = vecgeom::UnplacedParallelepiped;
using Base_t = G4UAdapter<vecgeom::UnplacedParallelepiped>;
public: // with description
public:
G4UPara(const G4String& pName,
G4double pDx, G4double pDy, G4double pDz,
@@ -102,13 +102,6 @@ class G4UPara : public G4UAdapter<vecgeom::UnplacedParallelepiped>
G4Polyhedron* CreatePolyhedron () const override;
public: // without description
G4UPara(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects
G4UPara(const G4UPara& rhs);
G4UPara& operator=(const G4UPara& rhs);
// Copy constructor and assignment operator
source/geometry/solids/CSG/include/G4USphere.hh
+2 -10
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Sphere to make use of VecGeom Sphere.
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4USPHERE_HH
#define G4USPHERE_HH
@@ -47,7 +47,7 @@ class G4USphere : public G4UAdapter<vecgeom::UnplacedSphere>
using Shape_t = vecgeom::UnplacedSphere;
using Base_t = G4UAdapter<vecgeom::UnplacedSphere>;
public: // with description
public:
G4USphere(const G4String& pName,
G4double pRmin, G4double pRmax,
@@ -97,14 +97,6 @@ class G4USphere : public G4UAdapter<vecgeom::UnplacedSphere>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4USphere(__void__&);
//
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4USphere(const G4USphere& rhs);
G4USphere& operator=(const G4USphere& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UTorus.hh
+1 -8
View File
@@ -47,7 +47,7 @@ class G4UTorus : public G4UAdapter<vecgeom::UnplacedTorus2>
using Shape_t = vecgeom::UnplacedTorus2;
using Base_t = G4UAdapter<vecgeom::UnplacedTorus2>;
public: // with description
public:
G4UTorus(const G4String& pName,
G4double rmin, G4double rmax, G4double rtor,
@@ -92,13 +92,6 @@ class G4UTorus : public G4UAdapter<vecgeom::UnplacedTorus2>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UTorus(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTorus(const G4UTorus& rhs);
G4UTorus& operator=(const G4UTorus& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UTrap.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Trap to make use of VecGeom Trapezoid.
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UTRAP_HH
#define G4UTRAP_HH
@@ -47,7 +47,7 @@ class G4UTrap : public G4UAdapter<vecgeom::UnplacedTrapezoid>
using Shape_t = vecgeom::UnplacedTrapezoid;
using Base_t = G4UAdapter<vecgeom::UnplacedTrapezoid>;
public: // with description
public:
G4UTrap( const G4String& pName,
G4double pDz,
@@ -143,13 +143,6 @@ class G4UTrap : public G4UAdapter<vecgeom::UnplacedTrapezoid>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UTrap(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTrap(const G4UTrap& rhs);
G4UTrap& operator=(const G4UTrap& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UTrd.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Trd to make use of VecGeom Trd.
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UTRD_HH
#define G4UTRD_HH
@@ -47,7 +47,7 @@ class G4UTrd : public G4UAdapter<vecgeom::GenericUnplacedTrd>
using Shape_t = vecgeom::GenericUnplacedTrd;
using Base_t = G4UAdapter<vecgeom::GenericUnplacedTrd>;
public: // with description
public:
G4UTrd(const G4String& pName,
G4double pdx1, G4double pdx2,
@@ -91,13 +91,6 @@ class G4UTrd : public G4UAdapter<vecgeom::GenericUnplacedTrd>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UTrd(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTrd(const G4UTrd& rhs);
G4UTrd& operator=(const G4UTrd& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/include/G4UTubs.hh
+2 -9
View File
@@ -29,7 +29,7 @@
//
// Wrapper class for G4Tubs to make use of VecGeom Tube.
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#ifndef G4UTUBS_HH
#define G4UTUBS_HH
@@ -47,7 +47,7 @@ class G4UTubs : public G4UAdapter<vecgeom::GenericUnplacedTube>
using Shape_t = vecgeom::GenericUnplacedTube;
using Base_t = G4UAdapter<vecgeom::GenericUnplacedTube>;
public: // with description
public:
G4UTubs( const G4String& pName,
G4double pRMin,
@@ -92,13 +92,6 @@ class G4UTubs : public G4UAdapter<vecgeom::GenericUnplacedTube>
G4Polyhedron* CreatePolyhedron() const override;
public: // without description
G4UTubs(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTubs(const G4UTubs& rhs);
G4UTubs& operator=(const G4UTubs& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/CSG/src/G4Sphere.cc
+4 -4
View File
@@ -56,14 +56,14 @@
using namespace CLHEP;
// Private enum: Not for external use - used by distanceToOut
// Private enums: Not for external use
namespace {
// used by distanceToOut
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi,kSTheta,kETheta};
// used by normal
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi,kNSTheta,kNETheta};
}
////////////////////////////////////////////////////////////////////////
//
// constructor - check parameters, convert angles so 0<sphi+dpshi<=2_PI
source/geometry/solids/CSG/src/G4Torus.cc
+78 -69
View File
@@ -57,6 +57,15 @@
using namespace CLHEP;
// Private enums: Not for external use
namespace {
// Used by distanceToOut
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi};
// used by normal
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi};
}
///////////////////////////////////////////////////////////////
//
// Constructor - check parameters, convert angles so 0<sphi+dpshi<=2_PI
@@ -147,7 +156,7 @@ G4Torus::SetAllParameters( G4double pRmin,
"GeomSolids0002", FatalException, message);
}
}
// Ensure psphi in 0-2PI or -2PI-0 range if shape crosses 0
//
fSPhi = pSPhi;
@@ -184,7 +193,7 @@ G4Torus::G4Torus(const G4Torus&) = default;
//
// Assignment operator
G4Torus& G4Torus::operator = (const G4Torus& rhs)
G4Torus& G4Torus::operator = (const G4Torus& rhs)
{
// Check assignment to self
//
@@ -222,7 +231,7 @@ void G4Torus::ComputeDimensions( G4VPVParameterisation* p,
////////////////////////////////////////////////////////////////////////////////
//
// Calculate the real roots to torus surface.
// Calculate the real roots to torus surface.
// Returns negative solutions as well.
void G4Torus::TorusRootsJT( const G4ThreeVector& p,
@@ -249,11 +258,11 @@ void G4Torus::TorusRootsJT( const G4ThreeVector& p,
G4JTPolynomialSolver torusEq;
num = torusEq.FindRoots( c, 4, srd, si );
for ( i = 0; i < num; ++i )
for ( i = 0; i < num; ++i )
{
if( si[i] == 0. ) { roots.push_back(srd[i]) ; } // store real roots
}
}
std::sort(roots.begin() , roots.end() ) ; // sorting with <
}
@@ -261,7 +270,7 @@ void G4Torus::TorusRootsJT( const G4ThreeVector& p,
//////////////////////////////////////////////////////////////////////////////
//
// Interface for DistanceToIn and DistanceToOut.
// Calls TorusRootsJT and returns the smalles possible distance to
// Calls TorusRootsJT and returns the smalles possible distance to
// the surface.
// Attention: Difference in DistanceToIn/Out for points p on the surface.
@@ -304,18 +313,18 @@ G4double G4Torus::SolveNumericJT( const G4ThreeVector& p,
ptmp = p + t*v ; // calculate the position of the proposed intersection
G4double theta = std::atan2(ptmp.y(),ptmp.x());
if ( fSPhi >= 0 )
{
if ( theta < - halfAngTolerance ) { theta += twopi; }
if ( (std::fabs(theta) < halfAngTolerance)
&& (std::fabs(fSPhi + fDPhi - twopi) < halfAngTolerance) )
{
{
theta += twopi ; // 0 <= theta < 2pi
}
}
if ((fSPhi <= -pi )&&(theta>halfAngTolerance)) { theta = theta-twopi; }
// We have to verify if this root is inside the region between
// fSPhi and fSPhi + fDPhi
//
@@ -350,7 +359,7 @@ G4double G4Torus::SolveNumericJT( const G4ThreeVector& p,
{
if (std::fabs(t) < halfCarTolerance )
{
// compute scalar product at position p : v.n
// compute scalar product at position p : v.n
//
scal = v* G4ThreeVector( p.x()*(1-fRtor/std::hypot(p.x(),p.y())),
p.y()*(1-fRtor/std::hypot(p.x(),p.y())),
@@ -578,7 +587,7 @@ EInside G4Torus::Inside( const G4ThreeVector& p ) const
else tolRMin = 0 ;
tolRMax = fRmax - fRmaxTolerance;
if (pt2 >= tolRMin*tolRMin && pt2 <= tolRMax*tolRMax )
{
if ( fDPhi == twopi || pt2 == 0 ) // on torus swept axis
@@ -597,7 +606,7 @@ EInside G4Torus::Inside( const G4ThreeVector& p ) const
{
if ( (std::fabs(pPhi) < halfAngTolerance)
&& (std::fabs(fSPhi + fDPhi - twopi) < halfAngTolerance) )
{
{
pPhi += twopi ; // 0 <= pPhi < 2pi
}
if ( (pPhi >= fSPhi + halfAngTolerance)
@@ -644,7 +653,7 @@ EInside G4Torus::Inside( const G4ThreeVector& p ) const
{
if ( (std::fabs(pPhi) < halfAngTolerance)
&& (std::fabs(fSPhi + fDPhi - twopi) < halfAngTolerance) )
{
{
pPhi += twopi ; // 0 <= pPhi < 2pi
}
if ( (pPhi >= fSPhi - halfAngTolerance)
@@ -676,7 +685,7 @@ EInside G4Torus::Inside( const G4ThreeVector& p ) const
G4ThreeVector G4Torus::SurfaceNormal( const G4ThreeVector& p ) const
{
G4int noSurfaces = 0;
G4int noSurfaces = 0;
G4double rho, pt, pPhi;
G4double distRMin = kInfinity;
G4double distSPhi = kInfinity, distEPhi = kInfinity;
@@ -719,7 +728,7 @@ G4ThreeVector G4Torus::SurfaceNormal( const G4ThreeVector& p ) const
}
nPs = G4ThreeVector(std::sin(fSPhi),-std::cos(fSPhi),0);
nPe = G4ThreeVector(-std::sin(fSPhi+fDPhi),std::cos(fSPhi+fDPhi),0);
}
}
if( distRMax <= delta )
{
++noSurfaces;
@@ -741,7 +750,7 @@ G4ThreeVector G4Torus::SurfaceNormal( const G4ThreeVector& p ) const
++noSurfaces;
sumnorm += nPs;
}
if (distEPhi <= dAngle)
if (distEPhi <= dAngle)
{
++noSurfaces;
sumnorm += nPe;
@@ -754,7 +763,7 @@ G4ThreeVector G4Torus::SurfaceNormal( const G4ThreeVector& p ) const
ed.precision(16);
EInside inIt= Inside( p );
if( inIt != kSurface )
{
ed << " ERROR> Surface Normal was called for Torus,"
@@ -818,7 +827,7 @@ G4ThreeVector G4Torus::ApproxSurfaceNormal( const G4ThreeVector& p ) const
G4cout << " G4Torus::ApproximateSurfaceNormal called for point " << p
<< G4endl;
#endif
distRMax = std::fabs(pt - fRmax) ;
if(fRmin != 0.0) // First minimum radius
@@ -840,7 +849,7 @@ G4ThreeVector G4Torus::ApproxSurfaceNormal( const G4ThreeVector& p ) const
{
distMin = distRMax ;
side = kNRMax ;
}
}
if ( (fDPhi < twopi) && (rho != 0.0) )
{
phi = std::atan2(p.y(),p.x()) ; // Protected against (0,0,z) (above rho!=0)
@@ -860,7 +869,7 @@ G4ThreeVector G4Torus::ApproxSurfaceNormal( const G4ThreeVector& p ) const
{
if (distEPhi < distMin) { side = kNEPhi ; }
}
}
}
switch (side)
{
case kNRMin: // Inner radius
@@ -885,7 +894,7 @@ G4ThreeVector G4Torus::ApproxSurfaceNormal( const G4ThreeVector& p ) const
"GeomSolids1002", JustWarning,
"Undefined side for valid surface normal to solid.");
break ;
}
}
return norm ;
}
@@ -894,7 +903,7 @@ G4ThreeVector G4Torus::ApproxSurfaceNormal( const G4ThreeVector& p ) const
// Calculate distance to shape from outside, along normalised vector
// - return kInfinity if no intersection, or intersection distance <= tolerance
//
// - Compute the intersection with the z planes
// - Compute the intersection with the z planes
// - if at valid r, phi, return
//
// -> If point is outer outer radius, compute intersection with rmax
@@ -934,7 +943,7 @@ G4double G4Torus::DistanceToIn( const G4ThreeVector& p,
// Calculate safety distance to bounding box
// If point is too far, move it closer and calculate distance
//
G4double Dmax = 32*boxMax;
G4double Dmax = 32*boxMax;
G4double safe = std::max(std::max(distX,distY),distZ);
if (safe > Dmax)
{
@@ -1047,7 +1056,7 @@ G4double G4Torus::DistanceToIn( const G4ThreeVector& p,
sinEPhi=std::sin(ePhi);
cosEPhi=std::cos(ePhi);
Comp=-(v.x()*sinEPhi-v.y()*cosEPhi);
if ( Comp < 0 ) // Component in outwards normal dirn
{
Dist = -(p.y()*cosEPhi - p.x()*sinEPhi) ;
@@ -1059,7 +1068,7 @@ G4double G4Torus::DistanceToIn( const G4ThreeVector& p,
if (sphi < snxt )
{
if (sphi < 0 ) { sphi = 0 ; }
xi = p.x() + sphi*v.x() ;
yi = p.y() + sphi*v.y() ;
zi = p.z() + sphi*v.z() ;
@@ -1072,7 +1081,7 @@ G4double G4Torus::DistanceToIn( const G4ThreeVector& p,
// with correct half-plane
//
if ((yi*cosCPhi-xi*sinCPhi)>=0) { snxt=sphi; }
}
}
}
}
}
@@ -1094,7 +1103,7 @@ G4double G4Torus::DistanceToIn( const G4ThreeVector& p ) const
G4double safe=0.0, safe1, safe2 ;
G4double phiC, cosPhiC, sinPhiC, safePhi, ePhi, cosPsi ;
G4double rho, pt ;
rho = std::hypot(p.x(),p.y());
pt = std::hypot(p.z(),rho-fRtor);
safe1 = fRmin - pt ;
@@ -1155,18 +1164,18 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
#if 1
// This is the version with the calculation of CalcNorm = true
// This is the version with the calculation of CalcNorm = true
// To be done: Check the precision of this calculation.
// If you want return always validNorm = false, then take the version below
G4double rho = std::hypot(p.x(),p.y());
G4double pt = hypot(p.z(),rho-fRtor);
G4double pDotV = p.x()*v.x() + p.y()*v.y() + p.z()*v.z() ;
G4double tolRMax = fRmax - fRmaxTolerance ;
G4double vDotNmax = pDotV - fRtor*(v.x()*p.x() + v.y()*p.y())/rho ;
G4double pDotxyNmax = (1 - fRtor/rho) ;
@@ -1175,19 +1184,19 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
// On tolerant boundary & heading outwards (or perpendicular to) outer
// radial surface -> leaving immediately with *n for really convex part
// only
if ( calcNorm && (pDotxyNmax >= -2.*fRmaxTolerance) )
if ( calcNorm && (pDotxyNmax >= -2.*fRmaxTolerance) )
{
*n = G4ThreeVector( p.x()*(1 - fRtor/rho)/pt,
p.y()*(1 - fRtor/rho)/pt,
p.z()/pt ) ;
*validNorm = true ;
}
return snxt = 0 ; // Leaving by Rmax immediately
}
snxt = SolveNumericJT(p,v,fRmax,false);
snxt = SolveNumericJT(p,v,fRmax,false);
side = kRMax ;
// rmin
@@ -1201,7 +1210,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
if (calcNorm) { *validNorm = false ; } // Concave surface of the torus
return snxt = 0 ; // Leaving by Rmin immediately
}
sd[0] = SolveNumericJT(p,v,fRmin,false);
if ( sd[0] < snxt )
{
@@ -1215,7 +1224,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
// this is the "conservative" version which return always validnorm = false
// NOTE: using this version the unit test testG4Torus will break
snxt = SolveNumericJT(p,v,fRmax,false);
snxt = SolveNumericJT(p,v,fRmax,false);
side = kRMax ;
if ( fRmin )
@@ -1235,7 +1244,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
}
#endif
if (fDPhi < twopi) // Phi Intersections
{
sinSPhi = std::sin(fSPhi) ;
@@ -1246,12 +1255,12 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
cPhi = fSPhi + fDPhi*0.5 ;
sinCPhi = std::sin(cPhi) ;
cosCPhi = std::cos(cPhi) ;
// angle calculation with correction
// angle calculation with correction
// of difference in domain of atan2 and Sphi
//
vphi = std::atan2(v.y(),v.x()) ;
if ( vphi < fSPhi - halfAngTolerance ) { vphi += twopi; }
else if ( vphi > ePhi + halfAngTolerance ) { vphi -= twopi; }
@@ -1265,7 +1274,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
compS = -sinSPhi*v.x() + cosSPhi*v.y() ;
compE = sinEPhi*v.x() - cosEPhi*v.y() ;
sidephi = kNull ;
if( ( (fDPhi <= pi) && ( (pDistS <= halfCarTolerance)
&& (pDistE <= halfCarTolerance) ) )
|| ( (fDPhi > pi) && ((pDistS <= halfCarTolerance)
@@ -1276,12 +1285,12 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
if ( compS < 0 )
{
sphi = pDistS/compS ;
if (sphi >= -halfCarTolerance)
{
xi = p.x() + sphi*v.x() ;
yi = p.y() + sphi*v.y() ;
// Check intersecting with correct half-plane
// (if not -> no intersect)
//
@@ -1302,7 +1311,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
else
{
sidephi = kSPhi ;
}
}
}
else
{
@@ -1317,14 +1326,14 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
if ( compE < 0 )
{
sphi2 = pDistE/compE ;
// Only check further if < starting phi intersection
//
if ( (sphi2 > -kCarTolerance) && (sphi2 < sphi) )
{
xi = p.x() + sphi2*v.x() ;
yi = p.y() + sphi2*v.y() ;
if ( (std::fabs(xi)<=kCarTolerance)
&& (std::fabs(yi)<=kCarTolerance) )
{
@@ -1336,8 +1345,8 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
sidephi = kEPhi ;
sphi = sphi2;
}
}
else // Check intersecting with correct half-plane
}
else // Check intersecting with correct half-plane
{
if ( (yi*cosCPhi-xi*sinCPhi) >= 0)
{
@@ -1345,7 +1354,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
//
sidephi = kEPhi ;
sphi = sphi2;
}
}
}
@@ -1355,22 +1364,22 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
{
sphi = kInfinity ;
}
}
}
else
{
// On z axis + travel not || to z axis -> if phi of vector direction
// within phi of shape, Step limited by rmax, else Step =0
vphi = std::atan2(v.y(),v.x());
if ( ( fSPhi-halfAngTolerance <= vphi ) &&
if ( ( fSPhi-halfAngTolerance <= vphi ) &&
( vphi <= ( ePhi+halfAngTolerance ) ) )
{
sphi = kInfinity;
}
else
{
sidephi = kSPhi ; // arbitrary
sidephi = kSPhi ; // arbitrary
sphi=0;
}
}
@@ -1381,7 +1390,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
{
snxt=sphi;
side=sidephi;
}
}
}
G4double rhoi,it,iDotxyNmax ;
@@ -1392,7 +1401,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
{
switch(side)
{
case kRMax: // n is unit vector
case kRMax: // n is unit vector
xi = p.x() + snxt*v.x() ;
yi = p.y() + snxt*v.y() ;
zi = p.z() + snxt*v.z() ;
@@ -1401,7 +1410,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p,
iDotxyNmax = (1-fRtor/rhoi) ;
if(iDotxyNmax >= -2.*fRmaxTolerance) // really convex part of Rmax
{
{
*n = G4ThreeVector( xi*(1-fRtor/rhoi)/it,
yi*(1-fRtor/rhoi)/it,
zi/it ) ;
@@ -1481,10 +1490,10 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p ) const
G4double safe=0.0,safeR1,safeR2;
G4double rho,pt ;
G4double safePhi,phiC,cosPhiC,sinPhiC,ePhi;
rho = std::hypot(p.x(),p.y());
pt = std::hypot(p.z(),rho-fRtor);
#ifdef G4CSGDEBUG
if( Inside(p) == kOutside )
{
@@ -1512,7 +1521,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p ) const
else
{
safe = fRmax - pt ;
}
}
// Check if phi divided, Calc distances closest phi plane
//
@@ -1534,7 +1543,7 @@ G4double G4Torus::DistanceToOut( const G4ThreeVector& p ) const
if (safePhi < safe) { safe = safePhi ; }
}
if (safe < 0) { safe = 0 ; }
return safe ;
return safe ;
}
//////////////////////////////////////////////////////////////////////////
@@ -1585,10 +1594,10 @@ std::ostream& G4Torus::StreamInfo( std::ostream& os ) const
G4ThreeVector G4Torus::GetPointOnSurface() const
{
G4double cosu, sinu,cosv, sinv, aOut, aIn, aSide, chose, phi, theta, rRand;
phi = G4RandFlat::shoot(fSPhi,fSPhi+fDPhi);
theta = G4RandFlat::shoot(0.,twopi);
cosu = std::cos(phi); sinu = std::sin(phi);
cosv = std::cos(theta); sinv = std::sin(theta);
@@ -1597,7 +1606,7 @@ G4ThreeVector G4Torus::GetPointOnSurface() const
aOut = (fDPhi)*twopi*fRtor*fRmax;
aIn = (fDPhi)*twopi*fRtor*fRmin;
aSide = pi*(fRmax*fRmax-fRmin*fRmin);
if ((fSPhi == 0) && (fDPhi == twopi)){ aSide = 0; }
chose = G4RandFlat::shoot(0.,aOut + aIn + 2.*aSide);
@@ -1620,19 +1629,19 @@ G4ThreeVector G4Torus::GetPointOnSurface() const
rRand = GetRadiusInRing(fRmin,fRmax);
return { (fRtor+rRand*cosv)*std::cos(fSPhi+fDPhi),
(fRtor+rRand*cosv)*std::sin(fSPhi+fDPhi), rRand*sinv };
}
}
}
///////////////////////////////////////////////////////////////////////
//
// Visualisation Functions
void G4Torus::DescribeYourselfTo ( G4VGraphicsScene& scene ) const
void G4Torus::DescribeYourselfTo ( G4VGraphicsScene& scene ) const
{
scene.AddSolid (*this);
}
G4Polyhedron* G4Torus::CreatePolyhedron () const
G4Polyhedron* G4Torus::CreatePolyhedron () const
{
return new G4PolyhedronTorus (fRmin, fRmax, fRtor, fSPhi, fDPhi);
}
source/geometry/solids/CSG/src/G4Tubs.cc
+9
View File
@@ -50,6 +50,15 @@
using namespace CLHEP;
// Private enums: Not for external use
namespace {
// Used by distanceToOut
enum ESide {kNull,kRMin,kRMax,kSPhi,kEPhi,kPZ,kMZ};
// Used by normal
enum ENorm {kNRMin,kNRMax,kNSPhi,kNEPhi,kNZ};
}
/////////////////////////////////////////////////////////////////////////
//
// Constructor - check parameters, convert angles so 0<sphi+dpshi<=2_PI
source/geometry/solids/CSG/src/G4UBox.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UBox wrapper class
//
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Box.hh"
@@ -52,16 +52,6 @@ G4UBox::G4UBox(const G4String& pName,
{
}
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UBox::G4UBox( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UCons.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UCons wrapper class
//
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Cons.hh"
@@ -54,16 +54,6 @@ G4UCons::G4UCons( const G4String& pName,
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UCons::G4UCons( __void__& a )
: Base_t(a)
{
}
///////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UCutTubs.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UCutTubs wrapper class
//
// 07.07.17 G.Cosmo, CERN/PH
// 07.07.17 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4CutTubs.hh"
@@ -57,16 +57,6 @@ G4UCutTubs::G4UCutTubs( const G4String& pName,
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UCutTubs::G4UCutTubs( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UOrb.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UOrb wrapper class
//
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Orb.hh"
@@ -53,16 +53,6 @@ G4UOrb::G4UOrb( const G4String& pName, G4double pRmax )
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UOrb::G4UOrb( __void__& a )
: Base_t(a)
{
}
/////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UPara.cc
+1 -13
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UPara wrapper class
//
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Para.hh"
@@ -119,18 +119,6 @@ G4UPara::G4UPara( const G4String& pName,
}
}
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency
G4UPara::G4UPara( __void__& a )
: Base_t(a)
{
SetAllParameters(1., 1., 1., 0., 0., 0.);
fRebuildPolyhedron = false;
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4USphere.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4USphere wrapper class
//
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Sphere.hh"
@@ -53,16 +53,6 @@ G4USphere::G4USphere( const G4String& pName,
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4USphere::G4USphere( __void__& a )
: Base_t(a)
{
}
/////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UTorus.cc
-9
View File
@@ -53,15 +53,6 @@ G4UTorus::G4UTorus(const G4String& pName,
: Base_t(pName, rmin, rmax, rtor, sphi, dphi)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UTorus::G4UTorus( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UTrap.cc
-10
View File
@@ -134,16 +134,6 @@ G4UTrap::G4UTrap( const G4String& pName )
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UTrap::G4UTrap( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UTrd.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UTrd wrapper class
//
// 13.09.13 G.Cosmo, CERN/PH
// 13.09.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Trd.hh"
@@ -51,16 +51,6 @@ G4UTrd::G4UTrd(const G4String& pName,
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UTrd::G4UTrd( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/CSG/src/G4UTubs.cc
+1 -11
View File
@@ -25,7 +25,7 @@
//
// Implementation for G4UTubs wrapper class
//
// 30.10.13 G.Cosmo, CERN/PH
// 30.10.13 G.Cosmo, CERN
// --------------------------------------------------------------------
#include "G4Tubs.hh"
@@ -53,16 +53,6 @@ G4UTubs::G4UTubs( const G4String& pName,
{
}
///////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UTubs::G4UTubs( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/History
+9 -1
View File
@@ -6,8 +6,16 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2025-03-07 Soon Yung Jun (geom-specific-V11-02-09)
- G4Polyhedra, G4UPolyhedra: Verify the validity of the delta phi to restore
visualization of HepPolyhedronPgon
## 2025-02-03 Gabriele Cosmo
- Removed fake default constructor from G4U* wrappers, clearing compilation
warnings on gcc-14.
## 2024-10-01 Evgueni Tcherniaev (geom-specific-V11-02-08)
- G4GenericTrap: Fixed minor defect reported by Coverity
- G4GenericTrap: Fixed minor defect reported by Coverity.
## 2024-07-18 Alvaro Tolosa-Delgado (geom-specific-V11-02-07)
- Remove internal state of G4TwistedTubs and G4VTwistedFaceted.
source/geometry/solids/specific/include/G4UEllipsoid.hh
-5
View File
@@ -69,11 +69,6 @@ class G4UEllipsoid : public G4UAdapter<vecgeom::UnplacedEllipsoid>
inline G4GeometryType GetEntityType() const override;
G4UEllipsoid(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UEllipsoid( const G4UEllipsoid &source );
G4UEllipsoid &operator=( const G4UEllipsoid &source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UEllipticalCone.hh
-5
View File
@@ -68,11 +68,6 @@ class G4UEllipticalCone : public G4UAdapter<vecgeom::UnplacedEllipticalCone>
inline G4GeometryType GetEntityType() const override;
G4UEllipticalCone(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UEllipticalCone( const G4UEllipticalCone& source );
G4UEllipticalCone& operator=( const G4UEllipticalCone& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UEllipticalTube.hh
-5
View File
@@ -66,11 +66,6 @@ class G4UEllipticalTube : public G4UAdapter<vecgeom::UnplacedEllipticalTube>
inline G4GeometryType GetEntityType() const override;
G4UEllipticalTube(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UEllipticalTube( const G4UEllipticalTube& source );
G4UEllipticalTube &operator=( const G4UEllipticalTube& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UExtrudedSolid.hh
-5
View File
@@ -88,11 +88,6 @@ class G4UExtrudedSolid : public G4UAdapter<vecgeom::UnplacedExtruded>
inline G4bool IsFaceted() const override;
G4UExtrudedSolid(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UExtrudedSolid( const G4UExtrudedSolid& source );
G4UExtrudedSolid &operator=(const G4UExtrudedSolid& source);
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UGenericPolycone.hh
-5
View File
@@ -73,11 +73,6 @@ class G4UGenericPolycone : public G4UAdapter<vecgeom::UnplacedGenericPolycone>
G4VSolid* Clone() const override;
G4UGenericPolycone(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UGenericPolycone( const G4UGenericPolycone& source );
G4UGenericPolycone& operator=(const G4UGenericPolycone& source);
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UGenericTrap.hh
-5
View File
@@ -70,11 +70,6 @@ class G4UGenericTrap : public G4UAdapter<vecgeom::UnplacedGenTrap>
inline G4bool IsFaceted() const override;
G4UGenericTrap(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UGenericTrap( const G4UGenericTrap& source );
G4UGenericTrap& operator=(const G4UGenericTrap& source);
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UHype.hh
-5
View File
@@ -77,11 +77,6 @@ class G4UHype : public G4UAdapter<vecgeom::GenericUnplacedHype>
inline G4GeometryType GetEntityType() const override;
G4UHype(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UHype( const G4UHype& source );
G4UHype& operator=( const G4UHype& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UParaboloid.hh
-5
View File
@@ -66,11 +66,6 @@ class G4UParaboloid : public G4UAdapter<vecgeom::UnplacedParaboloid>
inline G4GeometryType GetEntityType() const override;
G4UParaboloid(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UParaboloid( const G4UParaboloid& source );
G4UParaboloid& operator=( const G4UParaboloid& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UPolycone.hh
-5
View File
@@ -92,11 +92,6 @@ class G4UPolycone : public G4UAdapter<vecgeom::GenericUnplacedPolycone>
inline G4GeometryType GetEntityType() const override;
G4UPolycone(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UPolycone( const G4UPolycone& source );
G4UPolycone& operator=( const G4UPolycone& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UPolyhedra.hh
-5
View File
@@ -100,11 +100,6 @@ class G4UPolyhedra : public G4UAdapter<vecgeom::UnplacedPolyhedron>
inline G4bool IsFaceted() const override;
G4UPolyhedra(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UPolyhedra( const G4UPolyhedra& source );
G4UPolyhedra& operator=( const G4UPolyhedra& source );
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UTessellatedSolid.hh
-5
View File
@@ -78,11 +78,6 @@ class G4UTessellatedSolid : public G4UAdapter<vecgeom::UnplacedTessellated>
G4int AllocatedMemory();
void DisplayAllocatedMemory();
G4UTessellatedSolid(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTessellatedSolid( const G4UTessellatedSolid& source );
G4UTessellatedSolid& operator=(const G4UTessellatedSolid& source);
// Copy constructor and assignment operator.
source/geometry/solids/specific/include/G4UTet.hh
-5
View File
@@ -69,11 +69,6 @@ class G4UTet : public G4UAdapter<vecgeom::UnplacedTet>
inline G4bool IsFaceted() const override;
G4UTet(__void__&);
// Fake default constructor for usage restricted to direct object
// persistency for clients requiring preallocation of memory for
// persistifiable objects.
G4UTet(const G4UTet& rhs);
G4UTet& operator=(const G4UTet& rhs);
// Copy constructor and assignment operator.
source/geometry/solids/specific/src/G4Polyhedra.cc
+8 -1
View File
@@ -1038,7 +1038,14 @@ G4Polyhedron* G4Polyhedra::CreatePolyhedron() const
std::vector<G4TwoVector> rz(numCorner);
for (G4int i = 0; i < numCorner; ++i)
rz[i].set(corners[i].r, corners[i].z);
return new G4PolyhedronPgon(startPhi, endPhi - startPhi, numSide, rz);
// Check the validity of the delta phi
G4double wrDelta = endPhi - startPhi;
if (wrDelta <= 0. || wrDelta >= twopi*(1-DBL_EPSILON))
{
wrDelta = twopi;
}
return new G4PolyhedronPgon(startPhi, wrDelta, numSide, rz);
}
// SetOriginalParameters
source/geometry/solids/specific/src/G4UEllipsoid.cc
-9
View File
@@ -53,15 +53,6 @@ G4UEllipsoid::G4UEllipsoid(const G4String& pName,
: Base_t(pName, dx, dy, dz, bcut, tcut)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UEllipsoid::G4UEllipsoid( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UEllipticalCone.cc
-9
View File
@@ -52,15 +52,6 @@ G4UEllipticalCone::G4UEllipticalCone(const G4String& pName,
: Base_t(pName, a, b, h, cut)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UEllipticalCone::G4UEllipticalCone( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UEllipticalTube.cc
-9
View File
@@ -51,15 +51,6 @@ G4UEllipticalTube::G4UEllipticalTube(const G4String& pName,
: Base_t(pName, dx, dy, dz)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UEllipticalTube::G4UEllipticalTube( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UExtrudedSolid.cc
-11
View File
@@ -97,17 +97,6 @@ G4UExtrudedSolid::G4UExtrudedSolid(const G4String& name,
delete[] sections;
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UExtrudedSolid::G4UExtrudedSolid(__void__& a)
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UGenericPolycone.cc
-11
View File
@@ -71,17 +71,6 @@ G4UGenericPolycone::G4UGenericPolycone(const G4String& name,
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UGenericPolycone::G4UGenericPolycone(__void__& a)
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UGenericTrap.cc
-11
View File
@@ -54,17 +54,6 @@ G4UGenericTrap::G4UGenericTrap(const G4String& name, G4double halfZ,
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UGenericTrap::G4UGenericTrap(__void__& a)
: Base_t(a), fVisSubdivisions(0)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UHype.cc
-9
View File
@@ -53,15 +53,6 @@ G4UHype::G4UHype(const G4String& pName,
newInnerStereo, newOuterStereo, newHalfLenZ)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UHype::G4UHype( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UParaboloid.cc
-9
View File
@@ -51,15 +51,6 @@ G4UParaboloid::G4UParaboloid(const G4String& pName,
: Base_t(pName, rlo, rhi, dz)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
G4UParaboloid::G4UParaboloid( __void__& a )
: Base_t(a)
{ }
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UPolycone.cc
-11
View File
@@ -115,17 +115,6 @@ G4UPolycone::G4UPolycone(const G4String& name,
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UPolycone::G4UPolycone( __void__& a )
: Base_t(a)
{
}
////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UPolyhedra.cc
+7 -12
View File
@@ -126,17 +126,6 @@ G4UPolyhedra::G4UPolyhedra(const G4String& name,
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UPolyhedra::G4UPolyhedra( __void__& a )
: Base_t(a)
{
}
////////////////////////////////////////////////////////////////////////
//
// Destructor
@@ -593,7 +582,13 @@ G4UPolyhedra::CalculateExtent(const EAxis pAxis,
//
G4Polyhedron* G4UPolyhedra::CreatePolyhedron() const
{
return new G4PolyhedronPgon(wrStart, wrDelta, wrNumSide, rzcorners);
// Check the validity of the delta phi
G4double deltaPhi = wrDelta;
if (deltaPhi <= 0. || deltaPhi >= twopi*(1-DBL_EPSILON))
{
deltaPhi = twopi;
}
return new G4PolyhedronPgon(wrStart, deltaPhi, wrNumSide, rzcorners);
}
#endif // G4GEOM_USE_USOLIDS
source/geometry/solids/specific/src/G4UTessellatedSolid.cc
-10
View File
@@ -54,16 +54,6 @@ G4UTessellatedSolid::G4UTessellatedSolid(const G4String& name)
{
}
////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UTessellatedSolid::G4UTessellatedSolid(__void__& a)
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor
source/geometry/solids/specific/src/G4UTet.cc
-10
View File
@@ -75,16 +75,6 @@ G4UTet::G4UTet(const G4String& pName,
}
}
//////////////////////////////////////////////////////////////////////////
//
// Fake default constructor - sets only member data and allocates memory
// for usage restricted to object persistency.
//
G4UTet::G4UTet( __void__& a )
: Base_t(a)
{
}
//////////////////////////////////////////////////////////////////////////
//
// Destructor