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/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