BelleLathe.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include "G4Types.hh"
 
#include "G4CSGSolid.hh"
#include "G4Polyhedron.hh"
#include <vector>
 
namespace Belle2 {
  namespace ECL {
 
    struct zr_t {
      double z; 
      double r; 
    };
 
    struct cachezr_t {
      double z; 
      double r; 
      double dz; 
      double dr; 
      double s2; 
      double is2; 
      double is; 
      double zmin; 
      double zmax; 
      double r2min; 
      double r2max; 
      double ta; 
      bool isconvex; 
    };
 
    struct vector_t {
      double x; 
      double y; 
      double z; 
    };
 
    struct triangle_t {
      int i0; 
      int i1; 
      int i2; 
    };
 
    inline double dotxy(const vector_t& u, const vector_t& v)
    {
      return u.x * v.x + u.y * v.y;
    }
 
    class BelleLathe : public G4CSGSolid {
    public:  // with description
      explicit BelleLathe(const G4String& pName);
 
      BelleLathe(const G4String& pName, double phi0, double dphi, int n, double* z, double* rin, double* rout);
      BelleLathe(const G4String& pName, double, double, const std::vector<zr_t>&);
 
      virtual ~BelleLathe();
 
      // Methods for solid
 
      void ComputeDimensions(G4VPVParameterisation* p,
                             const G4int n,
                             const G4VPhysicalVolume* pRep);
 
      G4bool CalculateExtent(const EAxis pAxis,
                             const G4VoxelLimits& pVoxelLimit,
                             const G4AffineTransform& pTransform,
                             G4double& pMin, G4double& pMax) const;
 
      EInside Inside(const G4ThreeVector& p) 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;
 
      G4GeometryType GetEntityType() const;
 
      G4ThreeVector GetPointOnSurface() const;
 
      G4double GetCubicVolume() {return fCubicVolume;}
 
      G4double GetSurfaceArea() {return fSurfaceArea;}
 
      G4VSolid* Clone() const;
 
      void BoundingLimits(G4ThreeVector& pMin, G4ThreeVector& pMax) const;
 
      std::ostream& StreamInfo(std::ostream& os) const;
 
      void          DescribeYourselfTo(G4VGraphicsScene& scene) const;
      G4Polyhedron* CreatePolyhedron() const;
 
    public:  // without description
 
      explicit BelleLathe(__void__&);
 
      BelleLathe(const BelleLathe& rhs);
      BelleLathe& operator=(const BelleLathe& rhs);
 
    protected:  // with description
      bool insector(double, double) const; 
      // double sectorside_intersection(double, const vector_t&, const vector_t&) const ;
      // double sectorside_intersection(double, const G4ThreeVector&, const G4ThreeVector&) const ;
      //  double sectorside(const G4ThreeVector&, const G4ThreeVector&, bool, bool) const;
      int    wn_poly(const zr_t&) const; 
      double mindist(const zr_t&) const; 
      std::vector<double> linecross(const G4ThreeVector&, const G4ThreeVector&) const;
      void eartrim() const; 
      zr_t normal(const zr_t&, double&) const ; 
      void getvolarea(); 
      void Init(const std::vector<zr_t>&, double, double); 
    private:
      std::vector<zr_t> fcontour; 
      std::vector<cachezr_t> fcache; 
      std::vector<double> fz; 
      std::vector<int> findx; 
      std::vector<int> fseg; 
      mutable std::vector<double> farea; 
      mutable std::vector<triangle_t> ftlist; 
      double fphi; 
      double fdphi; 
      double fs0; 
      double fc0; 
      double fs1; 
      double fc1; 
      double fn0x; 
      double fn0y; 
      double fn1x; 
      double fn1y; 
      double frmin; 
      double frmax; 
      double fzmin; 
      double fzmax; 
      bool fgtpi; 
      bool ftwopi; 
      G4VSolid* fshape; 
      mutable std::vector<G4ThreeVector> fsurf; 
    };
 
    class PolyhedronBelleLathe: public G4Polyhedron {
    public:
      PolyhedronBelleLathe(const std::vector<zr_t>&, const std::vector<triangle_t>&, double, double); 
      virtual ~PolyhedronBelleLathe(); 
    };
  }
}