G4VTwistSurface.hh

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.          *
// ********************************************************************
//
// G4VTwistSurface
//
// Class description:
//
// Abstract base class for boundary surface of G4VSolid.
 
// Author: Kotoyo Hoshina (Chiba University), 01.08.2002 - Created.
//         Oliver Link (CERN), 13.11.2003 - Integration in Geant4
//               from original version in Jupiter-2.5.02 application.
// --------------------------------------------------------------------
#ifndef G4VTWISTSURFACE_HH
#define G4VTWISTSURFACE_HH
 
#include <CLHEP/Units/SystemOfUnits.h>
 
#include "G4VSolid.hh"
#include "geomdefs.hh"
 
#include "G4RotationMatrix.hh"
 
#define G4VSURFACENXX 10
 
/**
 * @brief G4VTwistSurface is a base class for boundary surface of a G4VSolid.
 */
 
class G4VTwistSurface
{
  public:
 
    enum EValidate { kDontValidate = 0, kValidateWithTol = 1, 
                     kValidateWithoutTol = 2, kUninitialized = 3 };
 
    /**
     * Base constructor, given a name.
     *  @param[in] name The surface name.
     */
    G4VTwistSurface (const G4String& name);
 
    /**
     * Constructs a surface, given its parameters.
     *  @param[in] name The surface name.
     *  @param[in] rot Rotation: 0.5*(phi-width segment).
     *  @param[in] tlate Translation.
     *  @param[in] handedness Orientation: R-hand = 1, L-hand = -1.
     *  @param[in] axis0 First axis.
     *  @param[in] axis1 Second axis.
     *  @param[in] axis0min Minimum in first axis.
     *  @param[in] axis1min Minimum in second axis.
     *  @param[in] axis0max Maximum in first axis.
     *  @param[in] axis1max Maximum in second axis.
     */
    G4VTwistSurface (const G4String& name,
                     const G4RotationMatrix& rot,
                     const G4ThreeVector&    tlate,
                           G4int             handedness,
                     const EAxis             axis0,
                     const EAxis             axis1,
                           G4double          axis0min = -kInfinity,
                           G4double          axis1min = -kInfinity,
                           G4double          axis0max = kInfinity,
                           G4double          axis1max = kInfinity);
 
    /**
     * Default destructor.
     */
    virtual ~G4VTwistSurface() = default;
 
    /**
     * Returns the phi-location of point 'me' (phi relation between 'me' and
     * 'vec' projected on z=0 plane). If 'me' is on -ve-phi-side of 'vec', it
     * returns 1; on the other hand, if 'me' is on +ve-phi-side of 'vec',
     * it returns -1. If 'me' is on boundary of 'vec', it returns 0.
     *  @returns The z-coordinate of normal vector of me.cross(vec).
     */
    virtual G4int AmIOnLeftSide(const G4ThreeVector& me, 
                                const G4ThreeVector& vec, 
                                      G4bool withTol = true);
 
    /**
     * Returns the distance to the nearest boundary from an arbitrary point 'p' 
     * in local coodinate.
     *  @param[in] areacode Point location code according to axes.
     *  @param[out] xx The returned reference point on boundary.
     *  @param[in] p The arbitrary point in input.
     */
    virtual G4double DistanceToBoundary(G4int areacode,
                                        G4ThreeVector& xx,
                                        const G4ThreeVector& p) ;
 
    /**
     * Returns the distance from outside to a boundary from an arbitrary
     * point 'gp' and direction 'gv'.
     *  @param[in] gp The arbitrary point.
     *  @param[in] gv The direction vector.
     *  @param[out] gxxbest The returned reference point on boundary.
     */
    virtual G4double DistanceToIn(const G4ThreeVector& gp,
                                  const G4ThreeVector& gv,
                                        G4ThreeVector& gxxbest);
 
    /**
     * Returns the distance from inside to a boundary from an arbitrary
     * point 'gp' and direction 'gv'.
     *  @param[in] gp The arbitrary point.
     *  @param[in] gv The direction vector.
     *  @param[out] gxxbest The returned reference point on boundary.
     */
    virtual G4double  DistanceToOut(const G4ThreeVector& gp,
                                    const G4ThreeVector& gv,
                                          G4ThreeVector& gxxbest);
 
    /**
     * Returns the safety distance to a boundary from an arbitrary point 'gp'.
     *  @param[in] gp The arbitrary point.
     *  @param[out] gxxbest The returned reference point on boundary.
     */
    virtual G4double DistanceTo(const G4ThreeVector& gp,
                                      G4ThreeVector& gxx);
      
    /**
     * Returns the distance to surface, given point 'gp' and direction 'gv'.
     *  @param[in] gp The point from where computing the distance.
     *  @param[in] gv The direction along which computing the distance.
     *  @param[out] gxx Vector of global points based on number of solutions.
     *  @param[out] distance The distance vector based on number of solutions.
     *  @param[out] areacode The location vector based on number of solutions.
     *  @param[out] isvalid Validity vector based on number of solutions.
     *  @param[in] validate Adopted validation criteria.
     *  @returns The number of solutions.
     */
    virtual G4int DistanceToSurface(const G4ThreeVector& gp,
                                    const G4ThreeVector& gv,
                                          G4ThreeVector  gxx[],
                                          G4double       distance[],
                                          G4int          areacode[],
                                          G4bool         isvalid[],
                                    EValidate validate = kValidateWithTol) = 0;
 
    /**
     * Returns the safety distance to surface, given point 'gp'.
     *  @param[in] gp The point from where computing the safety distance.
     *  @param[out] gxx Vector of global points based on number of solutions.
     *  @param[out] distance The distance vector based on number of solutions.
     *  @param[out] areacode The location vector based on number of solutions.
     *  @returns The number of solutions.
     */
    virtual G4int DistanceToSurface(const G4ThreeVector& gp,
                                          G4ThreeVector  gxx[],
                                          G4double       distance[],
                                          G4int          areacode[]) = 0;
                                             
    /**
     * Returns a normal vector at a surface (or very close to the surface)
     * point at 'p'.
     *  @param[in] p The point where computing the normal.
     *  @param[in] isGlobal If true, it returns the normal in global coordinates.
     *  @returns The normal vector.
     */
    virtual G4ThreeVector GetNormal(const G4ThreeVector& p,
                                          G4bool isGlobal) = 0;
   
    /**
     * Returns parameters of boundaries.
     *  @param[in] areacode The location code.
     *  @param[out] d Boundary direction.
     *  @param[out] x0 The point on boundary.
     *  @param[out] boundarytype The boundary code.
     */
    virtual void GetBoundaryParameters(const G4int& areacode,
                                             G4ThreeVector& d,
                                             G4ThreeVector& x0,
                                             G4int& boundarytype) const;
 
    /**
     * Returns Z projection of point 'p' on boundary.
     *  @param[in] areacode The location code.
     *  @param[out] p The arbitrary point.
     *  @returns The Z projection on boundary.
     */
    virtual G4ThreeVector GetBoundaryAtPZ(G4int areacode,
                                          const G4ThreeVector& p) const;
 
    /**
     * Utility methods to compute the distance from a plane/line.
     */
    inline G4double DistanceToPlaneWithV(const G4ThreeVector& p,
                                         const G4ThreeVector& v,
                                         const G4ThreeVector& x0,
                                         const G4ThreeVector& n0,
                                               G4ThreeVector& xx);
    inline G4double DistanceToPlane(const G4ThreeVector& p,
                                    const G4ThreeVector& x0,
                                    const G4ThreeVector& n0,
                                          G4ThreeVector& xx);
    inline G4double DistanceToPlane(const G4ThreeVector& p,
                                    const G4ThreeVector& x0,
                                    const G4ThreeVector& t1,
                                    const G4ThreeVector& t2,
                                          G4ThreeVector& xx,
                                          G4ThreeVector& n);
    inline G4double DistanceToLine (const G4ThreeVector& p,
                                    const G4ThreeVector& x0,
                                    const G4ThreeVector& d,
                                          G4ThreeVector& xx);
 
    /**
     * Test functions/accessors, based on 'areacode' location.
     */
    inline G4bool IsAxis0 (G4int areacode) const;
    inline G4bool IsAxis1 (G4int areacode) const;
    inline G4bool IsOutside (G4int areacode) const;
    inline G4bool IsInside (G4int areacode, G4bool testbitmode = false) const;
    inline G4bool IsBoundary (G4int areacode, G4bool testbitmode = false) const;
    inline G4bool IsCorner (G4int areacode, G4bool testbitmode = false) const;
    inline G4bool IsValidNorm() const { return fIsValidNorm; }
    G4bool IsSameBoundary (G4VTwistSurface* surface1, G4int areacode1,
                           G4VTwistSurface* surface2, G4int areacode2 ) const;
    inline G4int GetAxisType(G4int areacode, G4int whichaxis) const;
 
    /**
     * Utility functions computing global/local point/direction.
     */
    inline G4ThreeVector ComputeGlobalPoint (const G4ThreeVector& lp) const;
    inline G4ThreeVector ComputeLocalPoint (const G4ThreeVector& gp) const;
    inline G4ThreeVector ComputeGlobalDirection (const G4ThreeVector& lp) const;
    inline G4ThreeVector ComputeLocalDirection (const G4ThreeVector& gp) const;
  
    /**
     * Modifiers for axes.
     */
    inline void SetAxis(G4int i, const EAxis axis) { fAxis[i] = axis; }
    inline void SetNeighbours(G4VTwistSurface* ax0min, G4VTwistSurface* ax1min, 
                              G4VTwistSurface* ax0max, G4VTwistSurface* ax1max);
 
    /**
     * Returns point on surface given the axes.
     */
    virtual G4ThreeVector SurfacePoint(G4double, G4double,
                                       G4bool isGlobal = false ) = 0 ;
 
    /**
     * Internal accessors to be implemented in concrete derived classes.
     */
    virtual G4double GetBoundaryMin(G4double) = 0 ;
    virtual G4double GetBoundaryMax(G4double) = 0 ;
    virtual G4double GetSurfaceArea() = 0 ;
    virtual void GetFacets(G4int m, G4int n, G4double xyz[][3],
                           G4int faces[][4], G4int iside) = 0 ;
 
    /**
     * Node/face mapping functions.
     */
    G4int GetNode( G4int i, G4int j, G4int m, G4int n, G4int iside ) ;
    G4int GetFace( G4int i, G4int j, G4int m, G4int n, G4int iside ) ;
 
    /**
     * Checks face visibility, based on verteces and orientation.
     *  @returns -1 if invisible; 1 if visible.
     */
    G4int GetEdgeVisibility( G4int i, G4int j, G4int m, G4int n,
                             G4int number, G4int orientation) ;
 
    /**
     * Returns the surface name.
     */
    inline const G4String& GetName() const { return fName; }
 
    /**
     * Prints on standard output surface data.
     */
    void DebugPrint() const;
 
    /**
     * Fake default constructor for usage restricted to direct object
     * persistency for clients requiring preallocation of memory for
     * persistifiable objects.
     */
    G4VTwistSurface(__void__&);
 
  protected:
 
    /**
     * Internal accessors.
     */
    inline G4VTwistSurface** GetNeighbours() { return fNeighbours; } 
    inline G4int GetNeighbours(G4int areacode, G4VTwistSurface* surfaces[]);
    inline G4ThreeVector GetCorner(G4int areacode) const;
    void GetBoundaryAxis(G4int areacode, EAxis axis[]) const;
    void GetBoundaryLimit(G4int areacode, G4double limit[]) const;
    virtual G4int GetAreaCode(const G4ThreeVector& xx, G4bool withtol=true) = 0;
 
    /**
     * Modifier for boundaries.
     *  @param[in] axiscode The location code, either: sAxis0 & sAxisMin,
     *             sAxis0 & sAxisMax, sAxis1 & sAxisMin, sAxis1 & sAxisMax.
     *  @param[in] direction Direction.
     *  @param[in] x0 Point on boundary.
     *  @param[in] boundarytype The shape of locus from the start point to
     *             end point of boundary (ex. sAxisRho = linear line which
     *             start point is fixed at origin; sAxisPhi = part of circle
     *             which center placed at the origin.
     */
    virtual void SetBoundary(const G4int& axiscode, 
                             const G4ThreeVector& direction,
                             const G4ThreeVector& x0, 
                             const G4int& boundarytype);
 
    /**
     * Modifier for corners.
     */
    void SetCorner(G4int areacode, G4double x, G4double y, G4double z);
 
  private:
 
    /**
     * Internal setters to be implemented in concrete dereived classes.
     */
    virtual void SetBoundaries() = 0;
    virtual void SetCorners()    = 0;
   
  // data members ---------------------------------------------------------
 
  public:
 
    /** Boundary types. */
    static const G4int sOutside ;
    static const G4int sInside  ;
    static const G4int sBoundary;
    static const G4int sCorner;
    static const G4int sC0Min1Min;
    static const G4int sC0Max1Min;
    static const G4int sC0Max1Max;
    static const G4int sC0Min1Max;
    static const G4int sAxisMin;
    static const G4int sAxisMax;
    static const G4int sAxisX;
    static const G4int sAxisY;
    static const G4int sAxisZ;
    static const G4int sAxisRho;
    static const G4int sAxisPhi;
    static const G4int sAxis0;
    static const G4int sAxis1;
    static const G4int sSizeMask;
    static const G4int sAxisMask;
    static const G4int sAreaMask;
 
  protected:
 
    class CurrentStatus 
    {
      /**
       * @brief Internal class defining the surface status.
       */
      public:
 
        CurrentStatus();
        virtual ~CurrentStatus();
      
        inline G4ThreeVector GetXX(G4int i) const { return fXX[i]; }
        inline G4double GetDistance(G4int i) const { return fDistance[i]; }
        inline G4int GetAreacode(G4int i) const { return fAreacode[i]; }
        inline G4int GetNXX() const { return fNXX; }
        inline G4bool IsDone() const { return fDone; }
        inline G4bool IsValid(G4int i) const { return fIsValid[i]; }
 
        void SetCurrentStatus(G4int  i, 
                              G4ThreeVector& xx, 
                              G4double& dist, 
                              G4int& areacode, 
                              G4bool& isvalid,
                              G4int nxx,
                              EValidate validate,
                        const G4ThreeVector* p, 
                        const G4ThreeVector* v = nullptr);
 
        void ResetfDone(EValidate validate,
                  const G4ThreeVector* p, 
                  const G4ThreeVector* v = nullptr);
 
 
        void DebugPrint() const;
 
      private:
 
        G4double fDistance[G4VSURFACENXX];
        G4ThreeVector fXX[G4VSURFACENXX];
        G4int fAreacode[G4VSURFACENXX];
        G4bool fIsValid[G4VSURFACENXX];
        G4int fNXX;
        G4ThreeVector fLastp;
        G4ThreeVector fLastv;
        EValidate fLastValidate;
        G4bool fDone;
    };
      
    class Boundary 
    {
      /**
       * @brief Internal class defining a surface boundary type.
       */
      public:
 
        Boundary() = default;
        virtual ~Boundary() = default;
      
        void SetFields(const G4int& areacode, 
                       const G4ThreeVector& d, 
                       const G4ThreeVector& x0, 
                       const G4int& boundarytype);
      
        G4bool IsEmpty() const;
      
        G4bool GetBoundaryParameters(const G4int& areacode, 
                                           G4ThreeVector& d,
                                           G4ThreeVector& x0, 
                                           G4int& boundarytype) const;
 
      private:
 
        G4int fBoundaryAcode{-1};
        G4ThreeVector fBoundaryDirection;
        G4ThreeVector fBoundaryX0;
        G4int fBoundaryType{0};
    };
 
    EAxis fAxis[2];
    G4double fAxisMin[2];
    G4double fAxisMax[2];
    CurrentStatus fCurStatWithV;
    CurrentStatus fCurStat;
    G4RotationMatrix fRot;
    G4ThreeVector fTrans;
    G4int fHandedness;
 
    class G4SurfCurNormal
    {
      public:
 
        G4ThreeVector p;
        G4ThreeVector normal;
    };
 
    G4SurfCurNormal fCurrentNormal;
    G4bool fIsValidNorm;
    G4double kCarTolerance;
 
  private:
                     
    G4VTwistSurface* fNeighbours[4]; // {0,1,2,3} = sAxis0min, sAxis1min, 
                                     //             sAxis0max, sAxis1max
    G4ThreeVector fCorners[4]; // corners of the surface in local coordinate
    Boundary fBoundaries[4];   // boundaries of the surface.
    G4String fName;
   
    class G4SurfSideQuery
    {
      public:
 
        G4ThreeVector me;
        G4ThreeVector vec;
        G4bool  withTol;
        G4int amIOnLeftSide;
    };
    G4SurfSideQuery fAmIOnLeftSide;
};
 
//========================================================
// inline functions
//========================================================
 
#include "G4VTwistSurface.icc"
 
#endif