#include <G4ReflectedSolid.hh>

Inheritance diagram for G4ReflectedSolid:

Public Member Functions
	G4ReflectedSolid (const G4String &pName, G4VSolid *pSolid, const G4Transform3D &transform)

virtual	~G4ReflectedSolid ()

EInside	Inside (const G4ThreeVector &p) const

G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

G4ThreeVector	GetPointOnSurface () const

G4VSolid *	Clone () const

virtual G4GeometryType	GetEntityType () const

virtual const G4ReflectedSolid *	GetReflectedSolidPtr () const

virtual G4ReflectedSolid *	GetReflectedSolidPtr ()

G4VSolid *	GetConstituentMovedSolid () const

G4Transform3D	GetTransform3D () const

void	SetTransform3D (G4Transform3D &)

G4Transform3D	GetDirectTransform3D () const

void	SetDirectTransform3D (G4Transform3D &)

std::ostream &	StreamInfo (std::ostream &os) const

	G4ReflectedSolid (const G4ReflectedSolid &rhs)

G4ReflectedSolid &	operator= (const G4ReflectedSolid &rhs)

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

G4Polyhedron *	GetPolyhedron () const

Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)

virtual	~G4VSolid ()

G4bool	operator== (const G4VSolid &s) const

G4String	GetName () const

void	SetName (const G4String &name)

G4double	GetTolerance () const

virtual G4double	GetCubicVolume ()

virtual G4double	GetSurfaceArea ()

void	DumpInfo () const

virtual G4VisExtent	GetExtent () const

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const

virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()

	G4VSolid (__void__ &)

	G4VSolid (const G4VSolid &rhs)

G4VSolid &	operator= (const G4VSolid &rhs)

Protected Member Functions
G4AffineTransform	GetTransform () const

void	SetTransform (G4AffineTransform &)

G4AffineTransform	GetDirectTransform () const

void	SetDirectTransform (G4AffineTransform &)

G4RotationMatrix	GetFrameRotation () const

void	SetFrameRotation (const G4RotationMatrix &)

G4ThreeVector	GetFrameTranslation () const

void	SetFrameTranslation (const G4ThreeVector &)

G4RotationMatrix	GetObjectRotation () const

void	SetObjectRotation (const G4RotationMatrix &)

G4ThreeVector	GetObjectTranslation () const

void	SetObjectTranslation (const G4ThreeVector &)

Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const

void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Attributes
G4VSolid *	fPtrSolid

G4AffineTransform *	fPtrTransform

G4AffineTransform *	fDirectTransform

G4Transform3D *	fPtrTransform3D

G4Transform3D *	fDirectTransform3D

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 51 of file G4ReflectedSolid.hh.

Constructor & Destructor Documentation

G4ReflectedSolid::G4ReflectedSolid	(	const G4String &	pName,
		G4VSolid *	pSolid,
		const G4Transform3D &	transform
	)

Definition at line 56 of file G4ReflectedSolid.cc.

References fDirectTransform, fDirectTransform3D, fPtrSolid, fPtrTransform, fPtrTransform3D, HepGeom::Transform3D::getTranslation(), HepGeom::Transform3D::inverse(), and G4AffineTransform::Invert().

Referenced by Clone().

   : G4VSolid(pName), fpPolyhedron(0)
 {
   fPtrSolid = pSolid ;
   G4RotationMatrix rotMatrix ;
   
   fDirectTransform =
      new G4AffineTransform(rotMatrix, transform.getTranslation()) ;  
   fPtrTransform    =
      new G4AffineTransform(rotMatrix, transform.getTranslation()) ; 
   fPtrTransform->Invert() ;
 
   fDirectTransform3D = new G4Transform3D(transform) ;
   fPtrTransform3D    = new G4Transform3D(transform.inverse()) ;   
 }

G4ReflectedSolid::~G4ReflectedSolid ( )

virtual

Definition at line 77 of file G4ReflectedSolid.cc.

References fDirectTransform, fDirectTransform3D, fpPolyhedron, fPtrTransform, and fPtrTransform3D.

 {
   if(fPtrTransform)
   {
     delete fPtrTransform; fPtrTransform=0;
     delete fDirectTransform; fDirectTransform=0;
   }
   if(fPtrTransform3D)
   {
     delete fPtrTransform3D; fPtrTransform3D=0;
     delete fDirectTransform3D; fDirectTransform3D=0;
   }
   delete fpPolyhedron;
 }

G4ReflectedSolid::G4ReflectedSolid ( const G4ReflectedSolid & rhs )

Definition at line 95 of file G4ReflectedSolid.cc.

References fDirectTransform, fDirectTransform3D, fPtrTransform, and fPtrTransform3D.

   : G4VSolid(rhs), fPtrSolid(rhs.fPtrSolid), fpPolyhedron(0)
 {
   fPtrTransform      = new G4AffineTransform(*rhs.fPtrTransform);
   fDirectTransform   = new G4AffineTransform(*rhs.fDirectTransform);
   fPtrTransform3D    = new G4Transform3D(*rhs.fPtrTransform3D);
   fDirectTransform3D = new G4Transform3D(*rhs.fDirectTransform3D);
 }

Member Function Documentation

G4bool G4ReflectedSolid::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pMin,
		G4double &	pMax
	)		const

virtual

Implements G4VSolid.

Definition at line 266 of file G4ReflectedSolid.cc.

 {
 
   G4VoxelLimits unLimit;
   G4AffineTransform unTransform;
 
   G4double x1 = -kInfinity, x2 = kInfinity,
            y1 = -kInfinity, y2 = kInfinity,
            z1 = -kInfinity, z2 = kInfinity;
 
   G4bool existsAfterClip = false ;
   existsAfterClip =
       fPtrSolid->CalculateExtent(kXAxis,unLimit,unTransform,x1,x2);
   existsAfterClip =
       fPtrSolid->CalculateExtent(kYAxis,unLimit,unTransform,y1,y2);
   existsAfterClip =
       fPtrSolid->CalculateExtent(kZAxis,unLimit,unTransform,z1,z2);
 
   existsAfterClip = false;
   pMin = +kInfinity ;
   pMax = -kInfinity ;
 
   G4Transform3D pTransform3D = G4Transform3D(pTransform.NetRotation().inverse(),
                                              pTransform.NetTranslation());
  
   G4Transform3D transform3D  = pTransform3D*(*fDirectTransform3D);
 
   G4Point3D tmpPoint;
 
   // Calculate rotated vertex coordinates
 
   G4ThreeVectorList* vertices = new G4ThreeVectorList();
 
   if (vertices)
   {
     vertices->reserve(8);
 
     G4ThreeVector vertex0(x1,y1,z1) ;
     tmpPoint    = transform3D*G4Point3D(vertex0);
     vertex0     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex0);
 
     G4ThreeVector vertex1(x2,y1,z1) ;
     tmpPoint    = transform3D*G4Point3D(vertex1);
     vertex1     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex1);
 
     G4ThreeVector vertex2(x2,y2,z1) ;
     tmpPoint    = transform3D*G4Point3D(vertex2);
     vertex2     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex2);
 
     G4ThreeVector vertex3(x1,y2,z1) ;
     tmpPoint    = transform3D*G4Point3D(vertex3);
     vertex3     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex3);
 
     G4ThreeVector vertex4(x1,y1,z2) ;
     tmpPoint    = transform3D*G4Point3D(vertex4);
     vertex4     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex4);
 
     G4ThreeVector vertex5(x2,y1,z2) ;
     tmpPoint    = transform3D*G4Point3D(vertex5);
     vertex5     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex5);
 
     G4ThreeVector vertex6(x2,y2,z2) ;
     tmpPoint    = transform3D*G4Point3D(vertex6);
     vertex6     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex6);
 
     G4ThreeVector vertex7(x1,y2,z2) ;
     tmpPoint    = transform3D*G4Point3D(vertex7);
     vertex7     = G4ThreeVector(tmpPoint.x(),tmpPoint.y(),tmpPoint.z());
     vertices->push_back(vertex7);
   }
   else
   {
     DumpInfo();
     G4Exception("G4ReflectedSolid::CalculateExtent()",
                 "GeomMgt0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   
   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(transform3D.inverse()*G4Point3D(clipCentre)) != kOutside)
         {
           pMin = pVoxelLimit.GetMinExtent(pAxis);
         }
         else
         {
           pMin -= kCarTolerance;
         }
         clipCentre(pAxis) = pVoxelLimit.GetMaxExtent(pAxis);
 
         if (Inside(transform3D.inverse()*G4Point3D(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(transform3D.inverse()*G4Point3D(clipCentre)) != kOutside)
     {
       existsAfterClip = true ;
       pMin            = pVoxelLimit.GetMinExtent(pAxis) ;
       pMax            = pVoxelLimit.GetMaxExtent(pAxis) ;
     }
   } 
   delete vertices;
   return existsAfterClip;
 }

G4VSolid * G4ReflectedSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 559 of file G4ReflectedSolid.cc.

References G4ReflectedSolid().

 {
   return new G4ReflectedSolid(*this);
 }

void G4ReflectedSolid::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtual

Reimplemented from G4VSolid.

Definition at line 532 of file G4ReflectedSolid.cc.

References G4VSolid::DumpInfo(), FatalException, and G4Exception().

 {
   DumpInfo();
   G4Exception("G4ReflectedSolid::ComputeDimensions()",
                "GeomMgt0001", FatalException,
                "Method not applicable in this context!");
 }

G4Polyhedron * G4ReflectedSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 606 of file G4ReflectedSolid.cc.

References G4VSolid::CreatePolyhedron(), fDirectTransform3D, fPtrSolid, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, and HepPolyhedron::Transform().

Referenced by GetPolyhedron().

 {
   G4Polyhedron* polyhedron = fPtrSolid->CreatePolyhedron();
   if (polyhedron)
   {
     polyhedron->Transform(*fDirectTransform3D);
     return polyhedron;
   }
   else
   {
     std::ostringstream message;
     message << "Solid - " << GetName()
             << " - original solid has no" << G4endl
             << "corresponding polyhedron. Returning NULL!";
     G4Exception("G4ReflectedSolid::CreatePolyhedron()",
                 "GeomMgt1001", JustWarning, message);
     return 0;
   }
 }

void G4ReflectedSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 596 of file G4ReflectedSolid.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

G4double G4ReflectedSolid::DistanceToIn	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v
	)		const

virtual

Implements G4VSolid.

Definition at line 460 of file G4ReflectedSolid.cc.

References G4VSolid::DistanceToIn(), fPtrSolid, HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {    
   G4Point3D newPoint     = (*fDirectTransform3D)*G4Point3D(p) ;
   G4Point3D newDirection = (*fDirectTransform3D)*G4Point3D(v) ;
   newDirection.unit() ;
   return fPtrSolid->DistanceToIn(
        G4ThreeVector(newPoint.x(),newPoint.y(),newPoint.z()),
        G4ThreeVector(newDirection.x(),newDirection.y(),newDirection.z())) ;   
 }

G4double G4ReflectedSolid::DistanceToIn ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 477 of file G4ReflectedSolid.cc.

References G4VSolid::DistanceToIn(), fPtrSolid, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {
   G4Point3D newPoint = (*fDirectTransform3D)*G4Point3D(p) ;
   return fPtrSolid->DistanceToIn(
                     G4ThreeVector(newPoint.x(),newPoint.y(),newPoint.z())) ;   
 }

G4double G4ReflectedSolid::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `false`,
		G4bool *	validNorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Implements G4VSolid.

Definition at line 489 of file G4ReflectedSolid.cc.

References G4VSolid::DistanceToOut(), fPtrSolid, HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {
   G4ThreeVector solNorm ; 
 
   G4Point3D newPoint     = (*fDirectTransform3D)*G4Point3D(p) ;
   G4Point3D newDirection = (*fDirectTransform3D)*G4Point3D(v);
   newDirection.unit() ;
 
   G4double dist =
     fPtrSolid->DistanceToOut(
               G4ThreeVector(newPoint.x(),newPoint.y(),newPoint.z()),
               G4ThreeVector(newDirection.x(),newDirection.y(),newDirection.z()),
               calcNorm, validNorm, &solNorm) ;
   if(calcNorm)
   { 
     G4Point3D newN = (*fDirectTransform3D)*G4Point3D(solNorm);
     newN.unit() ;
     *n = G4ThreeVector(newN.x(),newN.y(),newN.z());
   }
   return dist ;  
 }

G4double G4ReflectedSolid::DistanceToOut ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 520 of file G4ReflectedSolid.cc.

References G4VSolid::DistanceToOut(), fPtrSolid, HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {
   G4Point3D newPoint = (*fDirectTransform3D)*G4Point3D(p);
   return fPtrSolid->DistanceToOut(
                     G4ThreeVector(newPoint.x(),newPoint.y(),newPoint.z()));   
 }

G4VSolid * G4ReflectedSolid::GetConstituentMovedSolid ( ) const

Definition at line 150 of file G4ReflectedSolid.cc.

References fPtrSolid.

Referenced by G4tgbGeometryDumper::DumpSolid().

 { 
   return fPtrSolid; 
 } 

G4AffineTransform G4ReflectedSolid::GetDirectTransform ( ) const

protected

Definition at line 171 of file G4ReflectedSolid.cc.

References fDirectTransform.

 {
   G4AffineTransform aTransform= *fDirectTransform;
   return aTransform;
 }

G4Transform3D G4ReflectedSolid::GetDirectTransform3D ( ) const

Definition at line 199 of file G4ReflectedSolid.cc.

References fDirectTransform3D.

 {
   G4Transform3D aTransform= *fDirectTransform3D;
   return aTransform;
 }

G4GeometryType G4ReflectedSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 135 of file G4ReflectedSolid.cc.

Referenced by StreamInfo().

 {
   return G4String("G4ReflectedSolid");
 }

G4RotationMatrix G4ReflectedSolid::GetFrameRotation ( ) const

protected

Definition at line 213 of file G4ReflectedSolid.cc.

References fDirectTransform, and G4AffineTransform::NetRotation().

 {
   G4RotationMatrix InvRotation= fDirectTransform->NetRotation();
   return InvRotation;
 }

G4ThreeVector G4ReflectedSolid::GetFrameTranslation ( ) const

protected

Definition at line 226 of file G4ReflectedSolid.cc.

References fPtrTransform, and G4AffineTransform::NetTranslation().

 {
   return fPtrTransform->NetTranslation();
 }

G4RotationMatrix G4ReflectedSolid::GetObjectRotation ( ) const

protected

Definition at line 238 of file G4ReflectedSolid.cc.

References fPtrTransform, and G4AffineTransform::NetRotation().

 {
   G4RotationMatrix Rotation= fPtrTransform->NetRotation();
   return Rotation;
 }

G4ThreeVector G4ReflectedSolid::GetObjectTranslation ( ) const

protected

Definition at line 251 of file G4ReflectedSolid.cc.

References fDirectTransform, and G4AffineTransform::NetTranslation().

 {
   return fDirectTransform->NetTranslation();
 }

G4ThreeVector G4ReflectedSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 547 of file G4ReflectedSolid.cc.

References fPtrSolid, G4VSolid::GetPointOnSurface(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {
   G4ThreeVector p    =  fPtrSolid->GetPointOnSurface();
   G4Point3D newPoint = (*fDirectTransform3D)*G4Point3D(p);
 
   return G4ThreeVector(newPoint.x(),newPoint.y(),newPoint.z());
 }

G4Polyhedron * G4ReflectedSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 631 of file G4ReflectedSolid.cc.

References CreatePolyhedron(), fpPolyhedron, HepPolyhedron::GetNumberOfRotationSteps(), and G4Polyhedron::GetNumberOfRotationStepsAtTimeOfCreation().

 {
   if (!fpPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron ();
     }
   return fpPolyhedron;
 }

const G4ReflectedSolid * G4ReflectedSolid::GetReflectedSolidPtr ( ) const

virtual

Definition at line 140 of file G4ReflectedSolid.cc.

 {
   return this;
 }

G4ReflectedSolid * G4ReflectedSolid::GetReflectedSolidPtr ( )

virtual

Definition at line 145 of file G4ReflectedSolid.cc.

 {
   return this;
 }

G4AffineTransform G4ReflectedSolid::GetTransform ( ) const

protected

Definition at line 157 of file G4ReflectedSolid.cc.

References fPtrTransform.

 {
    G4AffineTransform aTransform = *fPtrTransform;
    return aTransform;
 }

G4Transform3D G4ReflectedSolid::GetTransform3D ( ) const

Definition at line 185 of file G4ReflectedSolid.cc.

References fPtrTransform3D.

 {
   G4Transform3D aTransform = *fPtrTransform3D;
   return aTransform;
 }

EInside G4ReflectedSolid::Inside ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 426 of file G4ReflectedSolid.cc.

References fPtrSolid, G4VSolid::Inside(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

Referenced by CalculateExtent().

 {
 
   G4Point3D newPoint = (*fDirectTransform3D)*G4Point3D(p) ;
   // G4Point3D newPoint = (*fPtrTransform3D)*G4Point3D(p) ;
 
   return fPtrSolid->Inside(G4ThreeVector(newPoint.x(),
                                          newPoint.y(),
                                          newPoint.z())) ; 
 }

G4ReflectedSolid & G4ReflectedSolid::operator= ( const G4ReflectedSolid & rhs )

Definition at line 107 of file G4ReflectedSolid.cc.

References fDirectTransform, fDirectTransform3D, fpPolyhedron, fPtrSolid, fPtrTransform, fPtrTransform3D, and G4VSolid::operator=().

 {
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   fPtrSolid= rhs.fPtrSolid; fpPolyhedron= 0;
   delete fPtrTransform;
   fPtrTransform= new G4AffineTransform(*rhs.fPtrTransform);
   delete fDirectTransform;
   fDirectTransform= new G4AffineTransform(*rhs.fDirectTransform);
   delete fPtrTransform3D;
   fPtrTransform3D= new G4Transform3D(*rhs.fPtrTransform3D);
   delete fDirectTransform3D;
   fDirectTransform3D= new G4Transform3D(*rhs.fDirectTransform3D);
 
   return *this;
 }

void G4ReflectedSolid::SetDirectTransform ( G4AffineTransform & transform )

protected

Definition at line 177 of file G4ReflectedSolid.cc.

References fDirectTransform, and fpPolyhedron.

 {
   fDirectTransform = &transform ;
   fpPolyhedron = 0;
 }

void G4ReflectedSolid::SetDirectTransform3D ( G4Transform3D & transform )

Definition at line 205 of file G4ReflectedSolid.cc.

References fDirectTransform3D, and fpPolyhedron.

 {
   fDirectTransform3D = &transform ;
   fpPolyhedron = 0;
 }

void G4ReflectedSolid::SetFrameRotation ( const G4RotationMatrix & matrix )

protected

Definition at line 219 of file G4ReflectedSolid.cc.

References fDirectTransform, and G4AffineTransform::SetNetRotation().

 {
   fDirectTransform->SetNetRotation(matrix);
 }

void G4ReflectedSolid::SetFrameTranslation ( const G4ThreeVector & vector )

protected

Definition at line 231 of file G4ReflectedSolid.cc.

References fPtrTransform, and G4AffineTransform::SetNetTranslation().

 {
   fPtrTransform->SetNetTranslation(vector);
 }

void G4ReflectedSolid::SetObjectRotation ( const G4RotationMatrix & matrix )

protected

Definition at line 244 of file G4ReflectedSolid.cc.

References fPtrTransform, and G4AffineTransform::SetNetRotation().

 {
   fPtrTransform->SetNetRotation(matrix);
 }

void G4ReflectedSolid::SetObjectTranslation ( const G4ThreeVector & vector )

protected

Definition at line 256 of file G4ReflectedSolid.cc.

References fDirectTransform, and G4AffineTransform::SetNetTranslation().

 {
   fDirectTransform->SetNetTranslation(vector);
 }

void G4ReflectedSolid::SetTransform ( G4AffineTransform & transform )

protected

Definition at line 163 of file G4ReflectedSolid.cc.

References fpPolyhedron, and fPtrTransform.

 {
    fPtrTransform = &transform ;
    fpPolyhedron = 0;
 }

void G4ReflectedSolid::SetTransform3D ( G4Transform3D & transform )

Definition at line 191 of file G4ReflectedSolid.cc.

References fpPolyhedron, and fPtrTransform3D.

 {
   fPtrTransform3D = &transform ;
   fpPolyhedron = 0;
 }

std::ostream & G4ReflectedSolid::StreamInfo ( std::ostream & os ) const

virtual

Implements G4VSolid.

Definition at line 569 of file G4ReflectedSolid.cc.

References fDirectTransform, fPtrSolid, GetEntityType(), G4VSolid::GetName(), G4AffineTransform::NetRotation(), G4AffineTransform::NetTranslation(), CLHEP::HepRotation::print(), and G4VSolid::StreamInfo().

 {
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for Reflected solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: " << GetEntityType() << "\n"
      << " Parameters of constituent solid: \n"
      << "===========================================================\n";
   fPtrSolid->StreamInfo(os);
   os << "===========================================================\n"
      << " Transformations: \n"
      << "    Direct transformation - translation : \n"
      << "           " << fDirectTransform->NetTranslation() << "\n"
      << "                          - rotation    : \n"
      << "           ";
   fDirectTransform->NetRotation().print(os);
   os << "\n"
      << "===========================================================\n";
 
   return os;
 }

G4ThreeVector G4ReflectedSolid::SurfaceNormal ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 442 of file G4ReflectedSolid.cc.

References fPtrSolid, G4VSolid::SurfaceNormal(), HepGeom::BasicVector3D< T >::unit(), HepGeom::BasicVector3D< T >::x(), HepGeom::BasicVector3D< T >::y(), and HepGeom::BasicVector3D< T >::z().

 {
   G4Point3D newPoint = (*fDirectTransform3D)*G4Point3D(p) ;
   G4ThreeVector normal =
       fPtrSolid->SurfaceNormal(G4ThreeVector(newPoint.x(),
                                              newPoint.y(),
                                              newPoint.z() ) ) ;
   G4Point3D newN = (*fDirectTransform3D)*G4Point3D(normal) ;
   newN.unit() ;
 
   return G4ThreeVector(newN.x(),newN.y(),newN.z()) ;    
 }