TG4RootSolid.cxx

Go to the documentation of this file.

// @(#)root/g4root:$Id$
// Author: Andrei Gheata   07/08/06
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
 
#include "TG4RootSolid.h"
 
#include "G4AffineTransform.hh"
#include "G4Polyhedron.hh"
#include "G4VGraphicsScene.hh"
#include "G4VPVParameterisation.hh"
#include "G4Version.hh"
#include "G4VoxelLimits.hh"
#if G4VERSION_NUMBER < 1000
#include "G4NURBS.hh"
#include "G4NURBSbox.hh"
#endif
// #include "G4SystemOfUnits.hh"
#include "G4VisExtent.hh"
 
#include "TGeoBBox.h"
#include "TGeoShape.h"
#include "TMath.h"
 
// Moved after ROOT includes to avoid warnings about shadowing variables
// from CLHEP units
#include <G4SystemOfUnits.hh>
 
// ClassImp(TG4RootSolid)
 
static const Double_t gCm = 1. / cm;
 
//______________________________________________________________________________
TG4RootSolid::TG4RootSolid(TGeoShape* shape) : G4VSolid(shape->GetName())
{
  fShape = shape;
}
 
//______________________________________________________________________________
G4bool TG4RootSolid::CalculateExtent(const EAxis /*pAxis*/,
  const G4VoxelLimits& /*pVoxelLimit*/, const G4AffineTransform& /*pTransform*/,
  G4double& /*pMin*/, G4double& /*pMax*/) const
{
  G4cout << "Warning: TG4RootSolid::CalculateExtent() not implemented"
         << G4endl;
  return false;
}
 
//______________________________________________________________________________
EInside TG4RootSolid::Inside(const G4ThreeVector& p) const
{
  Double_t pt[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  Bool_t in = fShape->Contains(pt);
  // Temporary computation of safety due to the fact that TGeoShape does
  // not return kSurface
  G4double safety = fShape->Safety(pt, in) * cm;
  if (TMath::Abs(safety) < 0.5 * kCarTolerance) return kSurface;
  if (in) return kInside;
  return kOutside;
}
 
//______________________________________________________________________________
G4ThreeVector TG4RootSolid::SurfaceNormal(const G4ThreeVector& p) const
{
  Double_t pt[3], dir[3], norm[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  dir[0] = 0.0;
  dir[1] = 0.0;
  dir[2] = 1.0;
  fShape->ComputeNormal(pt, dir, norm);
  pt[0] += norm[0] * 2. * kCarTolerance;
  pt[1] += norm[1] * 2. * kCarTolerance;
  pt[2] += norm[2] * 2. * kCarTolerance;
  // Do a trick that should work if the point p is on the surface...
  G4ThreeVector n(norm[0], norm[1], norm[2]);
  Bool_t in = fShape->Contains(pt);
  if (!in) return n;
  n.set(-norm[0], -norm[1], -norm[2]);
  return n;
}
 
//______________________________________________________________________________
G4double TG4RootSolid::DistanceToIn(
  const G4ThreeVector& p, const G4ThreeVector& v) const
{
  Double_t pt[3], dir[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  dir[0] = v.x();
  dir[1] = v.y();
  dir[2] = v.z();
  G4double dist = fShape->DistFromOutside(pt, dir, 3) * cm;
  if (dist < TGeoShape::Big()) return dist;
  return kInfinity;
}
 
//______________________________________________________________________________
G4double TG4RootSolid::DistanceToIn(const G4ThreeVector& p) const
{
  Double_t pt[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  G4double safety = fShape->Safety(pt, kFALSE) * cm;
  return safety;
}
 
//______________________________________________________________________________
G4double TG4RootSolid::DistanceToOut(const G4ThreeVector& p,
  const G4ThreeVector& v, const G4bool calcNorm, G4bool* validNorm,
  G4ThreeVector* n) const
{
  Double_t pt[3], dir[3], norm[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  dir[0] = v.x();
  dir[1] = v.y();
  dir[2] = v.z();
  G4double dist = fShape->DistFromInside(pt, dir, 3) * cm;
  if (calcNorm) *validNorm = true;
  if (dist < 0.5 * kCarTolerance)
    dist = 0.;
  else {
    pt[0] += dist * dir[0];
    pt[1] += dist * dir[1];
    pt[2] += dist * dir[2];
  }
  if (calcNorm) {
    fShape->ComputeNormal(pt, dir, norm);
    *n = G4ThreeVector(norm[0], norm[1], norm[2]);
  }
  return dist;
}
 
//______________________________________________________________________________
G4double TG4RootSolid::DistanceToOut(const G4ThreeVector& p) const
{
  Double_t pt[3];
  pt[0] = p.x() * gCm;
  pt[1] = p.y() * gCm;
  pt[2] = p.z() * gCm;
  G4double safety = fShape->Safety(pt, kTRUE) * cm;
  return safety;
}
 
//______________________________________________________________________________
void TG4RootSolid::ComputeDimensions(G4VPVParameterisation* /*p*/,
  const G4int /*n*/, const G4VPhysicalVolume* /*pRep*/)
{
  G4cout << "Warning: TG4RootSolid::ComputeDimensions() not implemented"
         << G4endl;
}
 
//______________________________________________________________________________
G4double TG4RootSolid::GetCubicVolume()
{
  G4double capacity = fShape->Capacity() * cm3;
  return capacity;
}
 
//______________________________________________________________________________
G4GeometryType TG4RootSolid::GetEntityType() const
{
  return G4String(fShape->ClassName());
}
 
//______________________________________________________________________________
G4ThreeVector TG4RootSolid::GetPointOnSurface() const
{
  G4cout << "Warning: TG4RootSolid::GetPointOnSurface() not implemented"
         << G4endl;
  return G4ThreeVector(0., 0., 0.);
}
 
//______________________________________________________________________________
std::ostream& TG4RootSolid::StreamInfo(std::ostream& os) const
{
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: ROOT solid / " << fShape->ClassName() << "\n"
     << " Bounding box: \n"
     << "    half length X: " << ((TGeoBBox*)fShape)->GetDX() * cm / mm
     << " mm \n"
     << "    half length Y: " << ((TGeoBBox*)fShape)->GetDY() * cm / mm
     << " mm \n"
     << "    half length Z: " << ((TGeoBBox*)fShape)->GetDZ() * cm / mm
     << " mm \n"
     << "-----------------------------------------------------------\n";
 
  return os;
}
 
// Visualization functions
 
//______________________________________________________________________________
void TG4RootSolid::DescribeYourselfTo(G4VGraphicsScene& scene) const
{
  scene.AddSolid(*this);
}
 
//______________________________________________________________________________
G4VisExtent TG4RootSolid::GetExtent() const
{
  G4double dx = ((TGeoBBox*)fShape)->GetDX() * cm;
  G4double dy = ((TGeoBBox*)fShape)->GetDY() * cm;
  G4double dz = ((TGeoBBox*)fShape)->GetDZ() * cm;
  const Double_t* origin = ((TGeoBBox*)fShape)->GetOrigin();
  G4double ox = origin[0] * cm;
  G4double oy = origin[1] * cm;
  G4double oz = origin[2] * cm;
  return G4VisExtent(-dx + ox, dx + ox, -dy + oy, dy + oy, -dz + oz, dz + oz);
}
 
//______________________________________________________________________________
G4Polyhedron* TG4RootSolid::CreatePolyhedron() const
{
  G4double dx = ((TGeoBBox*)fShape)->GetDX() * cm;
  G4double dy = ((TGeoBBox*)fShape)->GetDY() * cm;
  G4double dz = ((TGeoBBox*)fShape)->GetDZ() * cm;
  return new G4PolyhedronBox(dx, dy, dz);
}
 
#if G4VERSION_NUMBER < 1000
//______________________________________________________________________________
G4NURBS* TG4RootSolid::CreateNURBS() const
{
  return NULL;
}
#endif
 
//______________________________________________________________________________
G4Polyhedron* TG4RootSolid::GetPolyhedron() const
{
  return CreatePolyhedron();
}
 
//______________________________________________________________________________
const G4VSolid* TG4RootSolid::GetConstituentSolid(G4int /*no*/) const
{
  return NULL;
}
 
//______________________________________________________________________________
G4VSolid* TG4RootSolid::GetConstituentSolid(G4int /*no*/)
{
  return NULL;
}
 
//______________________________________________________________________________
const G4DisplacedSolid* TG4RootSolid::GetDisplacedSolidPtr() const
{
  return NULL;
}
 
//______________________________________________________________________________
G4DisplacedSolid* TG4RootSolid::GetDisplacedSolidPtr()
{
  return NULL;
}