G4USolid.cc

Go to the documentation of this file.

//
// ********************************************************************
// * 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.          *
// ********************************************************************
//
//
// $Id:$
// GEANT4 tag $Name:$
//
//
// G4USolid implementation
//
// --------------------------------------------------------------------

#include "G4USolid.hh"
#include "G4AffineTransform.hh"
#include "G4VoxelLimits.hh"
#include "G4VGraphicsScene.hh"
#include "G4Polyhedron.hh"
#include "G4PolyhedronArbitrary.hh"
#include "G4VisExtent.hh"
#include "G4PhysicalConstants.hh"

#include "G4AutoLock.hh"

namespace
{
  G4Mutex polyhedronMutex = G4MUTEX_INITIALIZER;
}

G4USolid::G4USolid(const G4String& name, VUSolid* s) :
  G4VSolid(name), fShape(s), fRebuildPolyhedron(false), fPolyhedron(0)
{
}

G4USolid::G4USolid(__void__& a)
  : G4VSolid(a), fShape(0), fRebuildPolyhedron(false), fPolyhedron(0)
{
}

G4USolid::~G4USolid()
{
  delete fPolyhedron; fPolyhedron = 0;
}

G4bool G4USolid::operator==(const G4USolid& s) const
{
  return (this == &s) ? true : false;
}

EInside G4USolid::Inside(const G4ThreeVector& p) const
{
  UVector3 pt;
  VUSolid::EnumInside in_temp;
  EInside in = kOutside;
  pt.x = p.x();
  pt.y = p.y();
  pt.z = p.z(); // better assign at construction

  in_temp = fShape->Inside(pt);

  if (in_temp == VUSolid::eSurface)return kSurface;
  if (in_temp == VUSolid::eInside)return kInside;

  return in;
}

G4ThreeVector G4USolid::SurfaceNormal(const G4ThreeVector& pt) const
{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z();
  UVector3 n;
  fShape->Normal(p, n);
  return G4ThreeVector(n.x, n.y, n.z);
}

G4double G4USolid::DistanceToIn(const G4ThreeVector& pt,
                                const G4ThreeVector& d)const
{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  UVector3 v;
  v.x = d.x();
  v.y = d.y();
  v.z = d.z(); // better assign at construction
  G4double dist = fShape->DistanceToIn(p, v);
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

G4double G4USolid::DistanceToIn(const G4ThreeVector& pt) const
{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  G4double dist = fShape->SafetyFromOutside(p); // true?
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

G4double G4USolid::DistanceToOut(const G4ThreeVector& pt,
                                 const G4ThreeVector& d,
                                 const G4bool calcNorm,
                                 G4bool* validNorm,
                                 G4ThreeVector* norm) const
{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  UVector3 v;
  v.x = d.x();
  v.y = d.y();
  v.z = d.z(); // better assign at construction
  UVector3 n;
  bool valid;
  G4double dist = fShape->DistanceToOut(p, v, n,valid); // should use local variable
  if(calcNorm)
  {
    if(valid){ *validNorm = true;}
    else {* validNorm =false;}
    if(*validNorm)
    { norm->setX(n.x);
      norm->setY(n.y);
      norm->setZ(n.z);
    } // *norm = n, but only after calcNorm check
  }
  if (dist > kInfinity) dist = kInfinity;
  return dist;
}

G4double G4USolid::DistanceToOut(const G4ThreeVector& pt) const
{
  UVector3 p;
  p.x = pt.x();
  p.y = pt.y();
  p.z = pt.z(); // better assign at construction
  return fShape->SafetyFromInside(p); // true?
}

G4double G4USolid::GetCubicVolume()
{
  return fShape->Capacity();
}

G4double G4USolid::GetSurfaceArea()
{
  return fShape->SurfaceArea();
}

G4ThreeVector G4USolid::GetPointOnSurface() const
{
  UVector3 p;
  p = fShape->GetPointOnSurface();
  return G4ThreeVector(p.x, p.y, p.z);
}

G4bool G4USolid::CalculateExtent(const EAxis pAxis,
                                 const G4VoxelLimits& pVoxelLimit,
                                 const G4AffineTransform& pTransform,
                                 G4double& pMin, G4double& pMax) const
{
  if (!pTransform.IsRotated())
  {
    VUSolid::EAxisType eAxis = VUSolid::eXaxis;
    G4double offset = pTransform.NetTranslation().x();
    if (pAxis == kYAxis)
    {
      eAxis = VUSolid::eYaxis;
      offset = pTransform.NetTranslation().y();
    }
    if (pAxis == kZAxis)
    {
      eAxis = VUSolid::eZaxis;
      offset = pTransform.NetTranslation().z();
    }
    fShape->ExtentAxis(eAxis, pMin, pMax);

    pMin += offset;
    pMax += offset;

    if (pVoxelLimit.IsLimited())
    {
      switch (pAxis)
      {
        case kXAxis:
          if ((pMin > pVoxelLimit.GetMaxXExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinXExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinXExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxXExtent());
          }
          break;
        case kYAxis:
          if ((pMin > pVoxelLimit.GetMaxYExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinYExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinYExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxYExtent());
          }
          break;
        case kZAxis:
          if ((pMin > pVoxelLimit.GetMaxZExtent() + kCarTolerance) ||
              (pMax < pVoxelLimit.GetMinZExtent() - kCarTolerance))
          {
            return false;
          }
          else
          {
            pMin = std::max(pMin, pVoxelLimit.GetMinZExtent());
            pMax = std::min(pMax, pVoxelLimit.GetMaxZExtent());
          }
          break;
        default:
          break;
      }
      pMin -= kCarTolerance ;
      pMax += kCarTolerance ;
    }
    return true;
  }
  else  // General rotated case - create and clip mesh to boundaries
  {
    // Rotate BoundingBox and Calculate Extent as for BREPS

    G4bool existsAfterClip = false ;
    G4ThreeVectorList* vertices ;

    pMin = +kInfinity ;
    pMax = -kInfinity ;

    // Calculate rotated vertex coordinates

    vertices = CreateRotatedVertices(pTransform) ;
    ClipCrossSection(vertices, 0, pVoxelLimit, pAxis, pMin, pMax) ;
    ClipCrossSection(vertices, 4, pVoxelLimit, pAxis, pMin, pMax) ;
    ClipBetweenSections(vertices, 0, pVoxelLimit, pAxis, pMin, pMax) ;

    if (pVoxelLimit.IsLimited(pAxis) == false)
    {
      if ((pMin != kInfinity) || (pMax != -kInfinity))
      {
        existsAfterClip = true ;

        // Add 2*tolerance to avoid precision troubles

        pMin -= kCarTolerance;
        pMax += kCarTolerance;
      }
    }
    else
    {
      G4ThreeVector clipCentre(
        (pVoxelLimit.GetMinXExtent() + pVoxelLimit.GetMaxXExtent()) * 0.5,
        (pVoxelLimit.GetMinYExtent() + pVoxelLimit.GetMaxYExtent()) * 0.5,
        (pVoxelLimit.GetMinZExtent() + pVoxelLimit.GetMaxZExtent()) * 0.5);

      if ((pMin != kInfinity) || (pMax != -kInfinity))
      {
        existsAfterClip = true ;


        // Check to see if endpoints are in the solid

        clipCentre(pAxis) = pVoxelLimit.GetMinExtent(pAxis);

        if (Inside(pTransform.Inverse().TransformPoint(clipCentre)) != kOutside)
        {
          pMin = pVoxelLimit.GetMinExtent(pAxis);
        }
        else
        {
          pMin -= kCarTolerance;
        }
        clipCentre(pAxis) = pVoxelLimit.GetMaxExtent(pAxis);

        if (Inside(pTransform.Inverse().TransformPoint(clipCentre)) != kOutside)
        {
          pMax = pVoxelLimit.GetMaxExtent(pAxis);
        }
        else
        {
          pMax += kCarTolerance;
        }
      }

      // Check for case where completely enveloping clipping volume
      // If point inside then we are confident that the solid completely
      // envelopes the clipping volume. Hence set min/max extents according
      // to clipping volume extents along the specified axis.

      else if (Inside(pTransform.Inverse().TransformPoint(clipCentre))
               != kOutside)
      {
        existsAfterClip = true ;
        pMin            = pVoxelLimit.GetMinExtent(pAxis) ;
        pMax            = pVoxelLimit.GetMaxExtent(pAxis) ;
      }
    }
    delete vertices;
    return existsAfterClip;
  }
}

void G4USolid::ComputeDimensions(G4VPVParameterisation*,
                                 const G4int,
                                 const G4VPhysicalVolume*)
{
    std::ostringstream message;
    message << "Illegal call to G4USolid::ComputeDimensions()" << G4endl
            << "Method not overloaded by derived class !";
    G4Exception("G4USolid::ComputeDimensions()", "GeomSolids0003",
                FatalException, message);
}

void G4USolid::DescribeYourselfTo(G4VGraphicsScene& scene) const
{
  scene.AddSolid(*this);
}

G4GeometryType G4USolid::GetEntityType() const
{

  G4String string = fShape->GetEntityType();
  return "G4" + string;
}

std::ostream& G4USolid::StreamInfo(std::ostream& os) const
{
  return fShape->StreamInfo(os);
}

G4USolid::G4USolid(const G4USolid& rhs)
  : G4VSolid(rhs), fRebuildPolyhedron(false), fPolyhedron(0)
{
  fShape = rhs.fShape->Clone();
}

G4USolid& G4USolid::operator=(const G4USolid& rhs)
{
  // Check assignment to self
  //
  if (this == &rhs)
  {
    return *this;
  }

  // Copy base class data
  //
  G4VSolid::operator=(rhs);

  // Copy data
  //
  fShape = rhs.fShape->Clone();
  fRebuildPolyhedron = false;
  delete fPolyhedron; fPolyhedron = 0;

  return *this;
}

G4VSolid* G4USolid::Clone() const
{
  std::ostringstream message;
  message << "Clone() method not implemented for type: "
          << GetEntityType() << "!" << G4endl
          << "Returning NULL pointer!";
  G4Exception("G4USolid::Clone()", "GeomSolids1001", JustWarning, message);
  return 0;
}

G4ThreeVectorList*
G4USolid::CreateRotatedVertices(const G4AffineTransform& pTransform) const
{
  G4double xMin, xMax, yMin, yMax, zMin, zMax;

  fShape->ExtentAxis(VUSolid::eXaxis, xMin, xMax);
  fShape->ExtentAxis(VUSolid::eYaxis, yMin, yMax);
  fShape->ExtentAxis(VUSolid::eZaxis, zMin, zMax);

  G4ThreeVectorList* vertices;
  vertices = new G4ThreeVectorList();

  if (vertices)
  {
    vertices->reserve(8);
    G4ThreeVector vertex0(xMin, yMin, zMin);
    G4ThreeVector vertex1(xMax, yMin, zMin);
    G4ThreeVector vertex2(xMax, yMax, zMin);
    G4ThreeVector vertex3(xMin, yMax, zMin);
    G4ThreeVector vertex4(xMin, yMin, zMax);
    G4ThreeVector vertex5(xMax, yMin, zMax);
    G4ThreeVector vertex6(xMax, yMax, zMax);
    G4ThreeVector vertex7(xMin, yMax, zMax);

    vertices->push_back(pTransform.TransformPoint(vertex0));
    vertices->push_back(pTransform.TransformPoint(vertex1));
    vertices->push_back(pTransform.TransformPoint(vertex2));
    vertices->push_back(pTransform.TransformPoint(vertex3));
    vertices->push_back(pTransform.TransformPoint(vertex4));
    vertices->push_back(pTransform.TransformPoint(vertex5));
    vertices->push_back(pTransform.TransformPoint(vertex6));
    vertices->push_back(pTransform.TransformPoint(vertex7));
  }
  else
  {
    G4Exception("G4VUSolid::CreateRotatedVertices()", "FatalError",
                FatalException, "Out of memory - Cannot allocate vertices!");
  }
  return vertices;
}

G4Polyhedron* G4USolid::CreatePolyhedron() const
{
  G4int index = 0;
  if (fShape->GetEntityType() == "Box")
  {
    double array[3];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronBox(array[0], array[1], array[2]);
  }
  if (fShape->GetEntityType() == "Tubs")
  {
    double array[5];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronTubs(array[0], array[1], array[2], array[3], array[4]);
  }
  if (fShape->GetEntityType() == "Cons")
  {
    double array[7];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronCons(array[0], array[1], array[2], array[3], array[4], array[5], array[6]);
  }
  if (fShape->GetEntityType() == "Orb")
  {
    double array[1];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronSphere(0., array[0], 0., 2 * pi, 0., pi);
  }
  if (fShape->GetEntityType() == "Sphere")
  {
    double array[6];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronSphere(array[0], array[1], array[2], array[3], array[4], array[5]);
  }
  if (fShape->GetEntityType() == "Tet")
  {
    double array[12];
    fShape->GetParametersList(index, array);
    G4Polyhedron* ph = new G4Polyhedron;
    double xyz[4][3];
    static int faces[4][4] = {{1, 3, 2, 0}, {1, 4, 3, 0}, {1, 2, 4, 0}, {2, 3, 4, 0}};
    xyz[0][0] = array[0];
    xyz[0][1] = array[1];
    xyz[0][2] = array[2];
    xyz[1][0] = array[3];
    xyz[1][1] = array[4];
    xyz[1][2] = array[5];
    xyz[2][0] = array[6];
    xyz[2][1] = array[7];
    xyz[2][2] = array[8];
    xyz[3][0] = array[9];
    xyz[3][1] = array[10];
    xyz[3][2] = array[11];

    ph->createPolyhedron(4, 4, xyz, faces);    
    return ph;
  }
  if (fShape->GetEntityType() == "Trd")
  {
    double array[5];
    fShape->GetParametersList(index, array);
    return new G4PolyhedronTrd2(array[0], array[1], array[2], array[3], array[4]);
  }
  if (fShape->GetEntityType() == "Trap")
  {
    double array[12];
    fShape->GetParametersList(index, array);
    double phi = (array[11] != 1.0) ? (std::atan(array[10] / array[9])) : (0.0);
    double alpha1 = std::atan(array[4]);
    double alpha2 = std::atan(array[8]);
    double theta = std::acos(array[11]);

    return new G4PolyhedronTrap(array[0], theta, phi,
                                array[1], array[2], array[3], alpha1,
                                array[5], array[6], array[7], alpha2);
  }

  /*
  if(fShape->GetEntityType()=="TessellatedSolid"){

      G4Polyhedron *uPolyhedron=fShape->GetPolyhedron();
      std::size_t nVertices = (*uPolyhedron).vertices.size();
      std::size_t nFacets   = (*uPolyhedron).facets.size();

      G4PolyhedronArbitrary *polyhedron =
      new G4PolyhedronArbitrary (nVertices, nFacets);

      for (std::vector<UVector3>::const_iterator v = (*uPolyhedron).vertices.begin();
           v!=(*uPolyhedron).vertices.end(); v++)
     {
           UVector3 p=(*v);
           G4ThreeVector pt(p.x,p.y,p.z);

           polyhedron->AddVertex(pt);
      }
      for (std::vector<UFacet>::const_iterator f=(*uPolyhedron).facets.begin();
          f != (*uPolyhedron).facets.end(); f++)
      {
   polyhedron->AddFacet((*f).f1,(*f).f2,(*f).f3,(*f).f4);
      }

     return (G4Polyhedron*) polyhedron;
  }
  */

  return 0;
}

G4Polyhedron* G4USolid::GetPolyhedron() const
{
  if (!fPolyhedron ||
      fRebuildPolyhedron ||
      fPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
      fPolyhedron->GetNumberOfRotationSteps())
  {
    G4AutoLock l(&polyhedronMutex);
    delete fPolyhedron;
    fPolyhedron = CreatePolyhedron();
    fRebuildPolyhedron = false;
    l.unlock();
  }
  return fPolyhedron;
}

G4VisExtent G4USolid:: GetExtent() const
{
  G4VisExtent extent;
  G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
  G4AffineTransform affineTransform;
  G4double vmin, vmax;
  CalculateExtent(kXAxis, voxelLimits, affineTransform, vmin, vmax);
  extent.SetXmin(vmin);
  extent.SetXmax(vmax);
  CalculateExtent(kYAxis, voxelLimits, affineTransform, vmin, vmax);
  extent.SetYmin(vmin);
  extent.SetYmax(vmax);
  CalculateExtent(kZAxis, voxelLimits, affineTransform, vmin, vmax);
  extent.SetZmin(vmin);
  extent.SetZmax(vmax);
  return extent;
}