lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 3.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 15:55:53 +02:00
parent e7d7193284
commit cfcb558cfe
3050 changed files with 91703 additions and 48310 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/solids/BREPS/include/G4ConicalSurface.hh
+149 -186
View File
@@ -5,223 +5,186 @@
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4ConicalSurface.hh,v 1.4 2000/02/16 12:02:51 gcosmo Exp $
// GEANT4 tag $Name: geant4-02-00 $
// $Id: G4ConicalSurface.hh,v 1.7 2000/11/08 14:22:00 gcosmo Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
/* /usr/local/gismo/repo/geometry/G4ConicalSurface.h,v 1.5 1993/12/30 02:13:59 rensing Exp */
// File: G4ConicalSurface.h
// Author: Alan Breakstone
// Contents ---------------------------------------------------------
// ----------------------------------------------------------------------
// Class G4ConicalSurface
//
// G4ConicalSurface
//
// Description:
// Class Description:
//
// C++ header file for the Gismo G4ConicalSurface class, derived from
// Surface class.
// Uses the GmsListLink, G4ThreeVec, G4ThreeMat, Ray, Helix, and Surface
// classes.
// A G4ConicalSurface is a semi-infinite conical surface defined by
// an axis and an opening angle, defined as the angle between the axis
// and the conical surface, with the origin being the apex of the cone.
// A G4ConicalSurface is a semi-infinite conical surface defined by
// an axis and an opening angle, defined as the angle between the axis
// and the conical surface, with the origin being the apex of the cone.
// The code for G4ConicalSurface has been derived from the original
// implementation in the "Gismo" package.
//
// End --------------------------------------------------------------
// Interface Dependencies -------------------------------------------
#ifndef __CONICALSURFACE_H
#define __CONICALSURFACE_H
// Author: A.Breakstone
// Adaptation: J.Sulkimo, P.Urban.
// Revisions by: L.Broglia, G.Cosmo.
// ----------------------------------------------------------------------
#ifndef __G4CONICALSURFACE_H
#define __G4CONICALSURFACE_H
#include "G4Surface.hh"
class G4ThreeMat;
// End Interface Dependencies ---------------------------------------
// Class //
class G4ConicalSurface: public G4Surface
class G4ConicalSurface : public G4Surface
{
private:
G4Vector3D axis; // direction of axis of G4ConicalSurface (unit vector)
G4double angle; // half opening angle of G4ConicalSurface, in radians
// range is 0 < angle < PI/2
public:
public: // with description
G4ConicalSurface();
// Default constructor:
// default axis is ( 1.0, 0.0, 0.0 ),
// default angle is 1.0 radians.
G4ConicalSurface( const G4Point3D& o, const G4Vector3D& a, G4double e );
virtual ~G4ConicalSurface() {}
// Normal constructor:
// first argument is the origin of the G4ConicalSurface
// second argument is the axis of the G4ConicalSurface
// third argument is the angle of the G4ConicalSurface.
G4String GetEntityType() { return G4String("Conical_Surface"); }
virtual ~G4ConicalSurface();
// Virtual destructor.
inline G4int operator==( const G4ConicalSurface& c );
// Equality operator.
inline G4String GetEntityType() const;
// Returns type identifier of the shape.
virtual const char* NameOf() const;
// Returns the class name.
// G4ConicalSurface( const G4ConicalSurface& c ): G4Surface( c.origin )
// { axis = c.axis; angle = c.angle; }
virtual const char* NameOf() const { return "G4ConicalSurface"; }
virtual void PrintOn( G4std::ostream& os = G4cout ) const;
int operator==( const G4ConicalSurface& c )
{
return origin == c.origin && axis == c.axis && angle == c.angle;
}
// Printing function, streaming surface's attributes.
virtual G4double HowNear( const G4Vector3D& x ) const;
// Returns the distance from a point to a semi-infinite G4ConicalSurface.
// The point x is the (input) argument.
// The distance is positive if the point is Inside, negative if it
// is outside
// virtual G4double distanceAlongRay( int which_way, const G4Ray* ry,
// G4Vector3D& p ) const;
// Added 18.7-95
void CalcBBox();
// Added 18.7-95 , same as distanceAlongRay, but uses G4Ray.h
int Intersect( const G4Ray& ry );
// Computes the bounding-box.
// virtual G4double distanceAlongHelix( int which_way,
// const Helix* hx, G4Vector3D& p ) const;
// G4Vector3D Normal( const G4Vector3D& p ) const;
G4int Intersect( const G4Ray& ry );
// Returns the distance along a Ray (straight line with G4Vector3D) to
// leave or enter a G4ConicalSurface.
// If the G4Vector3D of the Ray is opposite to that of the Normal to
// the G4ConicalSurface at the intersection point, it will not leave the
// G4ConicalSurface.
// Similarly, if the G4Vector3D of the Ray is along that of the Normal
// to the G4ConicalSurface at the intersection point, it will not enter the
// G4ConicalSurface.
// This method is called by all finite shapes sub-classed to
// G4ConicalSurface.
// A negative result means no intersection.
// If no valid intersection point is found, set the distance
// and intersection point to large numbers.
virtual G4Vector3D SurfaceNormal( const G4Point3D& p ) const;
virtual int Inside( const G4Vector3D& x ) const;
virtual int WithinBoundary( const G4Vector3D& x ) const;
// Returns the Normal unit vector to the G4ConicalSurface at a point p
// on (or nearly on) the G4ConicalSurface.
virtual G4double Scale() const { return 1.0; }
virtual G4int Inside( const G4Vector3D& x ) const;
// Returns 1 if the point x is Inside the G4ConicalSurface, 0 otherwise.
// Outside means that the distance to the G4ConicalSurface would be
// negative. Uses the HowNear() function to calculate this distance.
// virtual void rotate( G4double alpha, G4double beta,
// G4double gamma, G4ThreeMat& m, int inverse );
// virtual void rotate( G4double alpha, G4double beta,
// G4double gamma, int inverse );
G4Vector3D GetAxis() const { return axis; }
G4double GetAngle() const { return angle; }
virtual G4int WithinBoundary( const G4Vector3D& x ) const;
// Returns 1 if point x is on the G4ConicalSurface, otherwise return zero
// Since a G4ConicalSurface is infinite in extent, the function
// will just check if the point is on the G4ConicalSurface (to the surface
// precision).
virtual G4double Scale() const;
// Function overwritten by finite-sized derived classes which returns
// a radius, unless it is zero, in which case it returns the smallest
// non-zero dimension.
// Since a semi-infinite cone has no Scale associated with it, it returns
// the arbitrary number 1.0.
// Used for Scale-invariant tests of surface thickness.
inline G4Vector3D GetAxis() const;
inline G4double GetAngle() const;
// Return the axis and angle of the G4ConicalSurface.
void SetAngle( G4double e );
// Changes the angle of the G4ConicalSurface.
// Requires angle to range from 0 to PI/2.
public: // without description
/*
virtual G4double distanceAlongRay( G4int which_way, const G4Ray* ry,
G4Vector3D& p ) const;
// Returns the distance along a Ray to enter or leave a G4ConicalSurface.
// The first (input) argument is +1 to leave or -1 to enter
// The second (input) argument is a pointer to the Ray
// The third (output) argument returns the intersection point.
virtual G4double distanceAlongHelix( G4int which_way, const Helix* hx,
G4Vector3D& p ) const;
// Returns the distance along a Helix to enter or leave a G4ConicalSurface.
// The first (input) argument is +1 to leave or -1 to enter
// The second (input) argument is a pointer to the Helix
// The third (output) argument returns the intersection point.
G4Vector3D Normal( const G4Vector3D& p ) const;
// Returns the Normal unit vector to a G4ConicalSurface
// at a point p on (or nearly on) the G4ConicalSurface.
virtual void rotate( G4double alpha, G4double beta,
G4double gamma, G4ThreeMat& m, G4int inverse );
// Rotates the G4ConicalSurface (angles are assumed to be given in
// radians), arguments:
// - first about global x-axis by angle alpha,
// - second about global y-axis by angle beta,
// - third about global z-axis by angle gamma,
// - fourth (output) argument gives the calculated rotation matrix,
// - fifth (input) argument is an integer flag which if
// non-zero reverses the order of the rotations.
virtual void rotate( G4double alpha, G4double beta,
G4double gamma, G4int inverse );
// Rotates the G4ConicalSurface (angles are assumed to be given in
// radians), arguments:
// - first about global x-axis by angle alpha,
// - second about global y-axis by angle beta,
// - third about global z-axis by angle gamma,
// - fourth (input) argument is an integer flag which if
// non-zero reverses the order of the rotations.
private:
// virtual G4double gropeAlongHelix( const Helix* hx ) const;
//
// Description of functions -----------------------------------------
//
// default constructor
//----->G4ConicalSurface();
//
// Normal constructor: first argument is the origin of the G4ConicalSurface
// second argument is the axis of the G4ConicalSurface
// third argument is the angle of the G4ConicalSurface
//----->G4ConicalSurface(const G4Vector3D& o, const G4Vector3D& a, G4double e);
//
// destructor
//----->virtual ~G4ConicalSurface() {}
//
// copy constructor
//----->G4ConicalSurface( const G4ConicalSurface& c ): Surface( c.origin )
//-----> { axis = c.axis; angle = c.angle; }
//
// function to return class name
//----->virtual const char* NameOf() const { return "G4ConicalSurface"; }
//
// printing function
//----->virtual void PrintOn( G4std::ostream& os = G4cout ) const;
//
// equality operator
//----->int operator==( const G4ConicalSurface& c )
//-----> { return origin == c.origin && axis == c.axis
//-----> && angle == c.angle; }
//
// function which returns the distance from a point to a G4ConicalSurface
// the (input) argument is the point x
// the distance is positive if the point is Inside,
// negative if it is outside
//----->virtual G4double HowNear( const G4Vector3D& x ) const;
//
// function which returns the distance along a Ray to enter or leave a
// G4ConicalSurface.
// the first (input) argument is +1 to leave or -1 to enter
// the second (input) argument is a pointer to the Ray
// the third (output) argument returns the intersection point
//----->virtual G4double distanceAlongRay( int which_way, const Ray* ry,
//-----> G4Vector3D& p ) const;
//
// function which returns the distance along a Helix to enter or leave a
// G4ConicalSurface.
// the first (input) argument is +1 to leave or -1 to enter
// the second (input) argument is a pointer to the Helix
// the third (output) argument returns the intersection point
//----->virtual G4double distanceAlongHelix( int which_way, const Helix* hx,
//-----> G4Vector3D& p ) const;
//
// function which returns the Normal unit vector to a G4ConicalSurface
// at a point p on (or nearly on) the G4ConicalSurface
//----->virtual G4Vector3D Normal( const G4Vector3D& p ) const;
//
// function which returns
// true (1) if the point x is Inside the G4ConicalSurface,
// false (0) otherwise
//----->virtual int Inside( const G4Vector3D& x ) const;
//
// function overwritten by finite-sized derived classes which returns
// true (1) if the point x is within the boundary, false (0)
// otherwise.
// Since a G4ConicalSurface is infinite in extent, the function
// will just check if the point is on the G4ConicalSurface
// (to the surface precision).
//----->virtual int WithinBoundary( const G4Vector3D& x ) const;
//
// function overwritten by finite-sized derived classes which returns
// a radius, unless it is zero, in which case it returns
// the smallest non-zero dimension.
// Since a semi-infinite cone has no Scale associated with it,
// returns the arbitrary number 1.0.
// Used for Scale-invariant tests of surface thickness.
//----->virtual G4double Scale() const { return 1.0; }
//
// function to rotate the G4ConicalSurface (4 input arguments)
// first about global x-axis by angle alpha,
// second about global y-axis by angle beta,
// third about global z-axis by angle gamma
// the angles are assumed to be given in radians
// the fourth (output) argument gives the calculated rotation
// matrix
// the fifth (input) argument is an integer flag which if
// non-zero reverses the order of the rotations
//----->virtual void rotate( G4double alpha, G4double beta,
//-----> G4double gamma, G4ThreeMat& m, int inverse );
//
// function to rotate the G4ConicalSurface (4 input arguments)
// first about global x-axis by angle alpha,
// second about global y-axis by angle beta,
// third about global z-axis by angle gamma
// the angles are assumed to be given in radians
// the fourth (input) argument is an integer flag which if
// non-zero reverses the order of the rotations
//----->virtual void rotate( G4double alpha, G4double beta,
//-----> G4double gamma, int inverse );
//
// functions to return the axis and angle of the G4ConicalSurface
//----->direction GetAxis() const { return axis; }
//----->G4double GetAngle() const { return angle; }
//
// function to change the angle of the G4ConicalSurface
//----->void SetAngle( G4double e );
//
//
// Private function to use a crude technique to find the intersection
// of a Helix with a G4ConicalSurface. It returns the turning angle along the
// Helix at which the intersection occurs or -1.0 if no intersection
// point is found. The argument to the call is the pointer to the Helix.
//----->virtual G4double gropeAlongHelix( const Helix* hx ) const;
virtual G4double gropeAlongHelix( const Helix* hx ) const;
// Private function to use a crude technique to find the intersection
// of a Helix with a G4ConicalSurface. It returns the turning angle
// along the Helix at which the intersection occurs or -1.0 if no
// intersection point is found.
// The argument to the call is the pointer to the Helix.
*/
private:
G4ConicalSurface(const G4ConicalSurface&);
G4ConicalSurface& operator=(const G4ConicalSurface&);
// Private copy constructor and assignment operator.
private:
G4Vector3D axis;
// Direction of axis of G4ConicalSurface (unit vector).
G4double angle;
// Half opening angle of G4ConicalSurface, in radians
// range is 0 < angle < PI/2.
};
#include "G4ConicalSurface.icc"
#endif