Import Geant4 0.0.0 source tree

2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
@@ -0,0 +1,189 @@
+#ifndef __surface_h
+#define __surface_h 1
+
+#include "geomdefs.hh"
+#include "G4CurveVector.hh"
+#include "G4PointRat.hh"
+#include "G4Ray.hh"
+#include "G4BoundingBox3D.hh"
+#include "G4STEPEntity.hh"
+#include "G4SurfaceBoundary.hh"
+
+// This is the combined G4Surface class
+class G4Surface: public G4STEPEntity
+{
+public:
+
+  G4Surface();
+  virtual ~G4Surface();
+
+  // sets the boundaries of the surface.
+  // The curves in the CurveVector must be non-intersecting
+  // closed curves.
+  void SetBoundaries(G4CurveVector*);
+  // It calls InitBounded -- empty by default
+
+protected:
+
+  virtual void InitBounded() { }
+
+public:
+
+  // type information, needed for STEP output (see STEPinterface)
+  virtual G4String GetEntityType(){return G4String("Surface");}
+
+  // The origin should move to the derived classes
+  int operator==( const G4Surface& s ) { return origin == s.origin; }
+
+  // such a function is needed
+  // (see G4VSolid::DistanceToIn(const G4ThreeVector&) )
+  // but the G4surface implementation is useless.
+  // Overriding functions don't take the surface
+  // boundary into account.
+  virtual G4double HowNear( const G4Vector3D& x ) const; 
+
+  //virtual G4double distanceAlongRay( int which_way, const G4Ray* ry,
+  //				       G4Vector3D& p ) const;
+
+  // unnecessary -- origin should move to descendants
+  G4Vector3D GetOrigin() const { return origin; }
+
+  // Gerep members
+  // bad function names -- use Set and Get
+  // ??
+  inline G4double Distance()    { return distance; }
+  inline void Distance(const G4double Dist)  { distance=Dist; }    
+
+  // a boolean flag, not used by the surfaces themselves
+  virtual inline int  Active(){return active;}
+  virtual inline void Active(const int act){active=act;}
+
+  // Isn't this the same as HowNear? (This one is used by G4BREPSolid.)
+  virtual G4double ClosestDistanceToPoint(const G4Point3D&);
+
+  // uhit and vhit are never set.
+  // Only BSplineSurface overrides.
+  // There is a G4UVHit class.
+  virtual G4double GetUHit() { return uhit; }
+  virtual G4double GetVHit() { return vhit; }  
+
+  // Intersection with a ray. the result is put into
+  // some data members.
+  virtual int Intersect(const G4Ray&);
+
+  // Surface normal calculation.
+  virtual G4Vector3D Normal( const G4Vector3D& p ) const;
+
+  // Bounding box calculation.
+  virtual void CalcBBox();
+
+  // For NURBS, there is a two pass intersection algorithm.
+  // Sometimes, the result of the cheap one tells us 
+  // that execution of the expensive one is not necessary.
+  // Evaluation (Evaluate?) is one of them.
+  // better names wanted!
+  virtual G4Point3D Evaluation(const G4Ray& G4Rayref);
+  virtual int Evaluate(register const G4Ray& Rayref);  
+
+  // There is Active(int) instead.
+  virtual inline void Deactivate(){active=0;}
+  
+  // Distance(kInfinity); bbox->SetDistance(kInfinity);};
+
+  virtual inline void Reset(){Intersected=0;active = 1; distance = kInfinity;};
+
+  // one function for type info (GetEntityType) should be enough
+  virtual char *Name() const { return "G4Surface"; }
+  virtual int MyType() const { return Type; }  
+
+  // To be replaced by a CLHEP vector operation
+  inline static void Project (G4double& Coord, const G4Point3D& Pt2, 
+			      const G4Plane& Pl1                     )
+  {
+    Coord = Pt2.x()*Pl1.a + Pt2.y()*Pl1.b + Pt2.z()*Pl1.c - Pl1.d;
+  }
+
+  // Used by BREPSolid. Thus it's probably needed.
+  virtual void Project(){}
+
+  // Only in G4FPlane. Should be private to that class?
+  virtual void CalcNormal(){}  
+
+  // Only in G4FPlane. BREPSolid::IsConvex uses it.
+  // But who uses BREPSolid::IsConvex?
+  // Thus: probably not needed. But knowing
+  // if the surface is convex could be used for optimization. 
+  virtual int IsConvex(){return -1;}
+
+  // Only in G4FPlane, but G4BREPSolid uses them.
+  virtual int GetConvex(){return 0;}
+
+  virtual int GetNumberOfPoints(){return 0;}
+
+  virtual const G4Point3D& GetPoint(const int Count)
+  {
+    const G4Point3D* tmp= new G4Point3D(0,0,0);
+    return *tmp;
+  }
+
+  // L. Broglia
+  void   SetSameSense(G4int sameSense0) { sameSense = sameSense0; }
+  G4int  GetSameSense()                 { return sameSense      ; }
+  
+  G4BoundingBox3D* GetBBox() { return bbox; }
+
+  // there is Normal as well -- so what do these do?
+  virtual G4Ray* Norm(){return (G4Ray*)0;}
+  virtual G4Vector3D SurfaceNormal(const G4Point3D& Pt) const =0;  
+
+  // should be at least protected, but BREPSolid uses these data members.
+  // So why not a Get function?
+
+
+public:
+
+  G4BoundingBox3D* bbox;
+  G4Point3D closest_hit;
+
+protected:
+
+  // The boundaries of the surface.
+  G4SurfaceBoundary surfaceBoundary;
+
+  // BSplineSurface anf FPlane sets it, no one gets it
+  int Intersected;
+
+  // see Get... members
+  G4Vector3D origin;	// origin of Surface
+  int Type;
+  int AdvancedFace;
+  int active;
+  G4double distance;
+  G4double uhit,vhit;
+
+  // L. Broglia
+  G4int sameSense;
+
+protected:
+
+  // Maybe kInfinity instead?
+  const G4double FLT_MAXX;
+
+  // Maybe kCarTolerance instead?
+  const G4double FLT_EPSILO;
+
+  // temporary solution so that G4SurfaceList sees this member
+  // but G4SurfaceList should go.
+
+
+public:
+  G4Surface* next;
+
+};
+
+#endif
+
+
+
+
+