Gabriele Cosmo
415 lines
13 KiB
C++
415 lines
13 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// Implementation of G4UTessellatedSolid wrapper class
|
|
// --------------------------------------------------------------------
|
|
|
|
#include "G4TessellatedSolid.hh"
|
|
#include "G4UTessellatedSolid.hh"
|
|
|
|
#if ( defined(G4GEOM_USE_USOLIDS) || defined(G4GEOM_USE_PARTIAL_USOLIDS) )
|
|
|
|
#include "G4TriangularFacet.hh"
|
|
#include "G4QuadrangularFacet.hh"
|
|
|
|
#include "G4GeomTools.hh"
|
|
#include "G4AffineTransform.hh"
|
|
#include "G4BoundingEnvelope.hh"
|
|
|
|
#include "G4PolyhedronArbitrary.hh"
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Constructors
|
|
//
|
|
G4UTessellatedSolid::G4UTessellatedSolid()
|
|
: Base_t("")
|
|
{
|
|
}
|
|
|
|
|
|
G4UTessellatedSolid::G4UTessellatedSolid(const G4String& name)
|
|
: Base_t(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
|
|
//
|
|
G4UTessellatedSolid::~G4UTessellatedSolid()
|
|
{
|
|
G4int size = fFacets.size();
|
|
for (G4int i = 0; i < size; ++i) { delete fFacets[i]; }
|
|
fFacets.clear();
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copy constructor
|
|
//
|
|
G4UTessellatedSolid::G4UTessellatedSolid(const G4UTessellatedSolid& source)
|
|
: Base_t(source)
|
|
{
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Assignment operator
|
|
//
|
|
G4UTessellatedSolid&
|
|
G4UTessellatedSolid::operator=(const G4UTessellatedSolid& source)
|
|
{
|
|
if (this == &source) return *this;
|
|
|
|
Base_t::operator=( source );
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Accessors
|
|
|
|
G4bool G4UTessellatedSolid::AddFacet(G4VFacet* aFacet)
|
|
{
|
|
// Add a facet to the structure, checking validity.
|
|
//
|
|
if (GetSolidClosed())
|
|
{
|
|
G4Exception("G4UTessellatedSolid::AddFacet()", "GeomSolids1002",
|
|
JustWarning, "Attempt to add facets when solid is closed.");
|
|
return false;
|
|
}
|
|
if (!aFacet->IsDefined())
|
|
{
|
|
G4Exception("G4UTessellatedSolid::AddFacet()", "GeomSolids1002",
|
|
JustWarning, "Attempt to add facet not properly defined.");
|
|
aFacet->StreamInfo(G4cout);
|
|
return false;
|
|
}
|
|
if (aFacet->GetNumberOfVertices() == 3)
|
|
{
|
|
G4TriangularFacet* a3Facet = dynamic_cast<G4TriangularFacet*>(aFacet);
|
|
return Base_t::AddTriangularFacet(U3Vector(a3Facet->GetVertex(0).x(),
|
|
a3Facet->GetVertex(0).y(),
|
|
a3Facet->GetVertex(0).z()),
|
|
U3Vector(a3Facet->GetVertex(1).x(),
|
|
a3Facet->GetVertex(1).y(),
|
|
a3Facet->GetVertex(1).z()),
|
|
U3Vector(a3Facet->GetVertex(2).x(),
|
|
a3Facet->GetVertex(2).y(),
|
|
a3Facet->GetVertex(2).z()),
|
|
true);
|
|
}
|
|
else if (aFacet->GetNumberOfVertices() == 4)
|
|
{
|
|
G4QuadrangularFacet* a4Facet = dynamic_cast<G4QuadrangularFacet*>(aFacet);
|
|
return Base_t::AddQuadrilateralFacet(U3Vector(a4Facet->GetVertex(0).x(),
|
|
a4Facet->GetVertex(0).y(),
|
|
a4Facet->GetVertex(0).z()),
|
|
U3Vector(a4Facet->GetVertex(1).x(),
|
|
a4Facet->GetVertex(1).y(),
|
|
a4Facet->GetVertex(1).z()),
|
|
U3Vector(a4Facet->GetVertex(2).x(),
|
|
a4Facet->GetVertex(2).y(),
|
|
a4Facet->GetVertex(2).z()),
|
|
U3Vector(a4Facet->GetVertex(3).x(),
|
|
a4Facet->GetVertex(3).y(),
|
|
a4Facet->GetVertex(3).z()),
|
|
true);
|
|
}
|
|
else
|
|
{
|
|
G4Exception("G4UTessellatedSolid::AddFacet()", "GeomSolids1002",
|
|
JustWarning, "Attempt to add facet not properly defined.");
|
|
aFacet->StreamInfo(G4cout);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
G4VFacet* G4UTessellatedSolid::GetFacet(G4int i) const
|
|
{
|
|
return fFacets[i];
|
|
}
|
|
|
|
G4int G4UTessellatedSolid::GetNumberOfFacets() const
|
|
{
|
|
return GetNFacets();
|
|
}
|
|
|
|
void G4UTessellatedSolid::SetSolidClosed(const G4bool t)
|
|
{
|
|
if (t && !Base_t::IsClosed())
|
|
{
|
|
Base_t::Close();
|
|
G4int nVertices = fTessellated.fVertices.size();
|
|
G4int nFacets = fTessellated.fFacets.size();
|
|
for (G4int j = 0; j < nVertices; ++j)
|
|
{
|
|
U3Vector vt = fTessellated.fVertices[j];
|
|
fVertexList.push_back(G4ThreeVector(vt.x(), vt.y(), vt.z()));
|
|
}
|
|
for (G4int i = 0; i < nFacets; ++i)
|
|
{
|
|
vecgeom::TriangleFacet<G4double>* afacet = Base_t::GetFacet(i);
|
|
std::vector<G4ThreeVector> v;
|
|
for (G4int k=0; k<3; ++k)
|
|
{
|
|
v.push_back(G4ThreeVector(afacet->fVertices[k].x(),
|
|
afacet->fVertices[k].y(),
|
|
afacet->fVertices[k].z()));
|
|
}
|
|
G4VFacet* facet = new G4TriangularFacet(v[0], v[1], v[2],
|
|
G4FacetVertexType::ABSOLUTE);
|
|
facet->SetVertices(&fVertexList);
|
|
for (G4int k=0; k<3; ++k)
|
|
{
|
|
facet->SetVertexIndex(k, afacet->fIndices[k]);
|
|
}
|
|
fFacets.push_back(facet);
|
|
}
|
|
}
|
|
}
|
|
|
|
G4bool G4UTessellatedSolid::GetSolidClosed() const
|
|
{
|
|
return Base_t::IsClosed();
|
|
}
|
|
|
|
void G4UTessellatedSolid::SetMaxVoxels(G4int)
|
|
{
|
|
// Not yet implemented !
|
|
}
|
|
|
|
G4double G4UTessellatedSolid::GetMinXExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMin.x();
|
|
}
|
|
G4double G4UTessellatedSolid::GetMaxXExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMax.x();
|
|
}
|
|
G4double G4UTessellatedSolid::GetMinYExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMin.y();
|
|
}
|
|
G4double G4UTessellatedSolid::GetMaxYExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMax.y();
|
|
}
|
|
G4double G4UTessellatedSolid::GetMinZExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMin.z();
|
|
}
|
|
G4double G4UTessellatedSolid::GetMaxZExtent() const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
return aMax.z();
|
|
}
|
|
|
|
G4int G4UTessellatedSolid::AllocatedMemoryWithoutVoxels()
|
|
{
|
|
G4int base = sizeof(*this);
|
|
base += fVertexList.capacity() * sizeof(G4ThreeVector);
|
|
|
|
G4int limit = fFacets.size();
|
|
for (G4int i = 0; i < limit; i++)
|
|
{
|
|
G4VFacet &facet = *fFacets[i];
|
|
base += facet.AllocatedMemory();
|
|
}
|
|
return base;
|
|
}
|
|
G4int G4UTessellatedSolid::AllocatedMemory()
|
|
{
|
|
return AllocatedMemoryWithoutVoxels();
|
|
}
|
|
void G4UTessellatedSolid::DisplayAllocatedMemory()
|
|
{
|
|
G4int without = AllocatedMemoryWithoutVoxels();
|
|
// G4int with = AllocatedMemory();
|
|
// G4double ratio = (G4double) with / without;
|
|
// G4cout << "G4TessellatedSolid - Allocated memory without voxel overhead "
|
|
// << without << "; with " << with << "; ratio: " << ratio << G4endl;
|
|
G4cout << "G4TessellatedSolid - Allocated memory without voxel overhead "
|
|
<< without << G4endl;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Get bounding box
|
|
|
|
void G4UTessellatedSolid::BoundingLimits(G4ThreeVector& pMin,
|
|
G4ThreeVector& pMax) const
|
|
{
|
|
U3Vector aMin, aMax;
|
|
Base_t::Extent(aMin, aMax);
|
|
pMin = G4ThreeVector(aMin.x(), aMin.y(), aMin.z());
|
|
pMax = G4ThreeVector(aMax.x(), aMax.y(), aMax.z());
|
|
|
|
// Check correctness of the bounding box
|
|
//
|
|
if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
|
|
{
|
|
std::ostringstream message;
|
|
message << "Bad bounding box (min >= max) for solid: "
|
|
<< GetName() << " !"
|
|
<< "\npMin = " << pMin
|
|
<< "\npMax = " << pMax;
|
|
G4Exception("G4UTessellatedSolid::BoundingLimits()",
|
|
"GeomMgt0001", JustWarning, message);
|
|
StreamInfo(G4cout);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Calculate extent under transform and specified limit
|
|
|
|
G4bool
|
|
G4UTessellatedSolid::CalculateExtent(const EAxis pAxis,
|
|
const G4VoxelLimits& pVoxelLimit,
|
|
const G4AffineTransform& pTransform,
|
|
G4double& pMin, G4double& pMax) const
|
|
{
|
|
G4ThreeVector bmin, bmax;
|
|
|
|
// Check bounding box (bbox)
|
|
//
|
|
BoundingLimits(bmin,bmax);
|
|
G4BoundingEnvelope bbox(bmin,bmax);
|
|
|
|
// Use simple bounding-box to help in the case of complex meshes
|
|
//
|
|
return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
|
|
|
|
#if 0
|
|
// Precise extent computation (disabled by default for this shape)
|
|
//
|
|
G4double kCarToleranceHalf = 0.5*kCarTolerance;
|
|
if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
|
|
{
|
|
return (pMin < pMax) ? true : false;
|
|
}
|
|
|
|
// The extent is calculated as cumulative extent of the pyramids
|
|
// formed by facets and the center of the bounding box.
|
|
//
|
|
G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
|
|
G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
|
|
|
|
G4ThreeVectorList base;
|
|
G4ThreeVectorList apex(1);
|
|
std::vector<const G4ThreeVectorList *> pyramid(2);
|
|
pyramid[0] = &base;
|
|
pyramid[1] = &apex;
|
|
apex[0] = (bmin+bmax)*0.5;
|
|
|
|
// main loop along facets
|
|
pMin = kInfinity;
|
|
pMax = -kInfinity;
|
|
for (G4int i=0; i<GetNumberOfFacets(); ++i)
|
|
{
|
|
G4VFacet* facet = GetFacet(i);
|
|
if (std::abs((facet->GetSurfaceNormal()).dot(facet->GetVertex(0)-apex[0]))
|
|
< kCarToleranceHalf) continue;
|
|
|
|
base.resize(3);
|
|
for (G4int k=0; k<3; ++k) { base[k] = facet->GetVertex(k); }
|
|
G4double emin,emax;
|
|
G4BoundingEnvelope benv(pyramid);
|
|
if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax)) continue;
|
|
if (emin < pMin) pMin = emin;
|
|
if (emax > pMax) pMax = emax;
|
|
if (eminlim > pMin && emaxlim < pMax) break; // max possible extent
|
|
}
|
|
return (pMin < pMax);
|
|
#endif
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreatePolyhedron()
|
|
//
|
|
G4Polyhedron* G4UTessellatedSolid::CreatePolyhedron () const
|
|
{
|
|
G4int nVertices = fVertexList.size();
|
|
G4int nFacets = fFacets.size();
|
|
G4PolyhedronArbitrary *polyhedron = new G4PolyhedronArbitrary (nVertices,
|
|
nFacets);
|
|
for (G4int j = 0; j < nVertices; ++j)
|
|
{
|
|
polyhedron->AddVertex(fVertexList[j]);
|
|
}
|
|
|
|
for (G4int i = 0; i < nFacets; ++i)
|
|
{
|
|
G4int v[3]; // Only facets with 3 vertices are defined in VecGeom
|
|
G4VFacet* facet = GetFacet(i);
|
|
for (G4int j=0; j<3; ++j) // Retrieve indexing directly from VecGeom
|
|
{
|
|
v[j] = facet->GetVertexIndex(j) + 1;
|
|
}
|
|
polyhedron->AddFacet(v[0],v[1],v[2]);
|
|
}
|
|
polyhedron->SetReferences();
|
|
|
|
return (G4Polyhedron*) polyhedron;
|
|
}
|
|
|
|
#endif // G4GEOM_USE_USOLIDS
|