Gabriele Cosmo
227 lines
7.9 KiB
C++
227 lines
7.9 KiB
C++
// This code implementation is the intellectual property of
|
|
// the GEANT4 collaboration.
|
|
//
|
|
// By copying, distributing or modifying the Program (or any work
|
|
// based on the Program) you indicate your acceptance of this statement,
|
|
// and all its terms.
|
|
//
|
|
// $Id: G4CylindricalSurface.hh,v 1.1.10.1 1999/12/07 20:48:18 gunter Exp $
|
|
// GEANT4 tag $Name: geant4-01-00 $
|
|
//
|
|
/* /usr/local/gismo/repo/geometry/G4CylindricalSurface.h,v 1.16 1993/12/30 02:14:08 rensing Exp */
|
|
// File: G4CylindricalSurface.h
|
|
// Author: Alan Breakstone
|
|
|
|
// Contents ---------------------------------------------------------
|
|
//
|
|
// G4CylindricalSurface
|
|
//
|
|
// Description:
|
|
//
|
|
// C++ header file for Gismo G4CylindricalSurface class, derived from Surface class.
|
|
// Uses the GmsListLink, G4ThreeVec, G4ThreeMat, Ray, Helix, and Surface
|
|
// classes.
|
|
//
|
|
// End --------------------------------------------------------------
|
|
|
|
// Interface Dependencies -------------------------------------------
|
|
|
|
#ifndef __CYLINDER_H
|
|
#define __CYLINDER_H
|
|
|
|
#include "G4Surface.hh"
|
|
|
|
class G4ThreeMat;
|
|
|
|
// End Interface Dependencies ---------------------------------------
|
|
|
|
// Class //
|
|
|
|
// class G4Surface;
|
|
class G4CylindricalSurface: public G4Surface
|
|
{
|
|
protected: // make available to derived classes
|
|
|
|
G4Vector3D axis; // direction of axis of G4CylindricalSurface
|
|
// (unit vector)
|
|
G4double radius; // radius of G4CylindricalSurface
|
|
|
|
public:
|
|
G4CylindricalSurface();
|
|
G4CylindricalSurface( const G4Vector3D& o,
|
|
const G4Vector3D& a,
|
|
G4double r );
|
|
|
|
virtual ~G4CylindricalSurface() {}
|
|
|
|
// G4CylindricalSurface( const G4CylindricalSurface& c ):
|
|
// G4Surface( c.origin )
|
|
// { axis = c.axis; radius = c.radius; }
|
|
//
|
|
|
|
G4String GetEntityType(){return G4String("Cylindrical_Surface");}
|
|
|
|
virtual char *NameOf() const { return "G4CylindricalSurface"; }
|
|
|
|
virtual void PrintOn( ostream& os = G4cout ) const;
|
|
|
|
int operator==( const G4CylindricalSurface& c )
|
|
{
|
|
return ( origin == c.origin &&
|
|
axis == c.axis &&
|
|
radius == c.radius );
|
|
}
|
|
|
|
|
|
virtual G4double HowNear( const G4Vector3D& x ) const;
|
|
|
|
// virtual G4double distanceAlongRay( int which_way, const G4Ray* ry,
|
|
// G4Vector3D& p ) const;
|
|
// virtual G4double distanceAlongHelix( int which_way,
|
|
// const Helix* hx, G4Vector3D& p ) const;
|
|
|
|
virtual G4Vector3D Normal( const G4Vector3D& p ) const;
|
|
|
|
virtual G4Vector3D SurfaceNormal( const G4Point3D& p ) const;
|
|
|
|
virtual int Inside( const G4Vector3D& x ) const;
|
|
|
|
virtual int WithinBoundary( const G4Vector3D& x ) const;
|
|
|
|
virtual G4double Scale() const;
|
|
|
|
// virtual void rotate( G4double alpha, G4double beta,
|
|
// G4double gamma, G4ThreeMat& m, int inverse );
|
|
// virtual void rotate( G4double alpha, G4double beta,
|
|
// G4double gamma, int inverse );
|
|
|
|
int Intersect(const G4Ray& ry);
|
|
|
|
G4Vector3D GetAxis() const { return axis; }
|
|
|
|
G4double GetRadius() const { return radius; }
|
|
|
|
void SetRadius( G4double r );
|
|
|
|
private:
|
|
|
|
// virtual G4double gropeAlongHelix( const Helix* hx ) const;
|
|
//
|
|
//
|
|
// Description of functions -----------------------------------------
|
|
//
|
|
// default constructor
|
|
//----->G4CylindricalSurface();
|
|
//
|
|
// Normal constructor:first argument is the origin of the G4CylindricalSurface
|
|
// second argument is the axis of the G4CylindricalSurface
|
|
// third argument is the radius of the G4CylindricalSurface
|
|
//----->G4CylindricalSurface( const G4Vector3D& o,
|
|
// const G4Vector3D& a, G4double r );
|
|
//
|
|
// destructor
|
|
//----->virtual ~G4CylindricalSurface() {}
|
|
//
|
|
// copy constructor
|
|
//----->G4CylindricalSurface( const G4CylindricalSurface& c ):
|
|
// Surface( c.origin )
|
|
//-----> { axis = c.axis; radius = c.radius; }
|
|
//
|
|
// function to return class name
|
|
//----->virtual char *NameOf() const { return "G4CylindricalSurface"; }
|
|
//
|
|
// printing function
|
|
//----->virtual void PrintOn( ostream& os = G4cout ) const;
|
|
//
|
|
// equality operator
|
|
//----->int operator==( const G4CylindricalSurface& c )
|
|
//-----> { return origin == c.origin && axis == c.axis
|
|
//-----> && radius == c.radius; }
|
|
//
|
|
// function which returns the distance from a point to a G4CylindricalSurface
|
|
// 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
|
|
// G4CylindricalSurface.
|
|
// 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
|
|
// G4CylindricalSurface.
|
|
// 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
|
|
// G4CylindricalSurface at a point p
|
|
// on (or nearly on) the G4CylindricalSurface
|
|
//----->virtual G4Vector3D Normal( const G4Vector3D& p ) const;
|
|
//
|
|
// function which
|
|
// returns true (1) if the point x is Inside the G4CylindricalSurface,
|
|
// returns 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 G4CylindricalSurface is infinite in extent, the
|
|
// function will just check if the point is on the
|
|
// G4CylindricalSurface (to the surface precision).
|
|
//----->virtual int WithinBoundary( const G4Vector3D& x ) const;
|
|
//
|
|
// function overwritten by finite-sized derived classes which returns
|
|
// the radius, unless it is zero, in which case it returns
|
|
// the smallest non-zero dimension.
|
|
// Used for Scale-invariant tests of surface thickness.
|
|
//----->virtual G4double Scale() const;
|
|
//
|
|
// function to rotate the G4CylindricalSurface (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 G4CylindricalSurface (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 radius of the G4CylindricalSurface
|
|
//----->direction GetAxis() const { return axis; }
|
|
//----->G4double GetRadius() const { return radius; }
|
|
//
|
|
// function to change the radius of the G4CylindricalSurface
|
|
//----->void SetRadius( G4double r );
|
|
//
|
|
//
|
|
// Private function to use a crude technique to find the intersection
|
|
// of a Helix with a G4CylindricalSurface. 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;
|
|
};
|
|
|
|
#endif
|
|
|
|
|