Gabriele Cosmo
994 lines
33 KiB
Plaintext
994 lines
33 KiB
Plaintext
// Copyright (C) 2010, Guy Barrand. All rights reserved.
|
|
// See the file tools.license for terms.
|
|
|
|
#ifndef tools_hep_polyhedron
|
|
#define tools_hep_polyhedron
|
|
|
|
// see (lengthy) doc and disclaimer at end.
|
|
|
|
#include "../lina/vec3d"
|
|
#include "../lina/rotd"
|
|
|
|
#ifdef TOOLS_MEM
|
|
#include "../mem"
|
|
#include "../S_STRING"
|
|
#endif
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
//#define TOOLS_HEP_PH_OUT_ERR
|
|
//#define TOOLS_HEP_PH_OUT_ERR_TRD2
|
|
//#define TOOLS_HEP_PH_NOT_OPT
|
|
|
|
#ifdef TOOLS_HEP_PH_OUT_ERR
|
|
#include <iostream>
|
|
#endif
|
|
|
|
#ifdef TOOLS_HEP_PH_OUT_ERR_TRD2
|
|
#include <iostream>
|
|
#endif
|
|
|
|
#include <cmath>
|
|
|
|
namespace tools {
|
|
namespace hep {
|
|
|
|
typedef vec3d HVPoint3D;
|
|
typedef HVPoint3D HVNormal3D;
|
|
typedef HVPoint3D HVVector3D;
|
|
|
|
//WARNING : with SbFacet, take care of exlib::geant4::polyhedron
|
|
// that attempts to copy the private content of G4Facet.
|
|
// (see WARNING here).
|
|
|
|
class SbFacet {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::SbFacet)
|
|
#endif
|
|
|
|
friend class polyhedron;
|
|
#ifndef SWIG
|
|
friend std::ostream& operator<<(std::ostream&, const SbFacet &facet);
|
|
//G.Barrand
|
|
friend int operator == (const SbFacet & v1, const SbFacet & v2);
|
|
friend int operator != (const SbFacet & v1, const SbFacet & v2);
|
|
#endif
|
|
|
|
private:
|
|
typedef struct { int v,f; } edge_t; //G.Barrand
|
|
edge_t edge[4];
|
|
|
|
public:
|
|
SbFacet(int v1=0, int f1=0, int v2=0, int f2=0,
|
|
int v3=0, int f3=0, int v4=0, int f4=0)
|
|
{
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
edge[0].v=v1; edge[0].f=f1; edge[1].v=v2; edge[1].f=f2;
|
|
edge[2].v=v3; edge[2].f=f3; edge[3].v=v4; edge[3].f=f4; }
|
|
|
|
virtual ~SbFacet() {
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
//public:
|
|
protected:
|
|
SbFacet(const SbFacet & aFrom) {
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
edge[0].v = aFrom.edge[0].v;
|
|
edge[0].f = aFrom.edge[0].f;
|
|
edge[1].v = aFrom.edge[1].v;
|
|
edge[1].f = aFrom.edge[1].f;
|
|
edge[2].v = aFrom.edge[2].v;
|
|
edge[2].f = aFrom.edge[2].f;
|
|
edge[3].v = aFrom.edge[3].v;
|
|
edge[3].f = aFrom.edge[3].f;
|
|
}
|
|
SbFacet& operator=(const SbFacet& aFrom) {
|
|
edge[0].v = aFrom.edge[0].v;
|
|
edge[0].f = aFrom.edge[0].f;
|
|
edge[1].v = aFrom.edge[1].v;
|
|
edge[1].f = aFrom.edge[1].f;
|
|
edge[2].v = aFrom.edge[2].v;
|
|
edge[2].f = aFrom.edge[2].f;
|
|
edge[3].v = aFrom.edge[3].v;
|
|
edge[3].f = aFrom.edge[3].f;
|
|
return *this;
|
|
}
|
|
public:
|
|
bool isEqual(const SbFacet& aFrom) const { //G.Barrand
|
|
if(edge[0].v!=aFrom.edge[0].v) return false;
|
|
if(edge[0].f!=aFrom.edge[0].f) return false;
|
|
|
|
if(edge[1].v!=aFrom.edge[1].v) return false;
|
|
if(edge[1].f!=aFrom.edge[1].f) return false;
|
|
|
|
if(edge[2].v!=aFrom.edge[2].v) return false;
|
|
if(edge[2].f!=aFrom.edge[2].f) return false;
|
|
|
|
if(edge[3].v!=aFrom.edge[3].v) return false;
|
|
if(edge[3].f!=aFrom.edge[3].f) return false;
|
|
|
|
return true;
|
|
}
|
|
void GetEdge(int i,int& v,int& f) const { //G.Barrand
|
|
v = edge[i].v;
|
|
f = edge[i].f;
|
|
}
|
|
|
|
void set(int v1, int f1, int v2, int f2, //G.Barrand
|
|
int v3, int f3, int v4, int f4) {
|
|
edge[0].v=v1; edge[0].f=f1; edge[1].v=v2; edge[1].f=f2;
|
|
edge[2].v=v3; edge[2].f=f3; edge[3].v=v4; edge[3].f=f4;
|
|
}
|
|
|
|
|
|
void Set(int v[8]) //G.Barrand
|
|
{ edge[0].v = v[0]; edge[0].f = v[1];
|
|
edge[1].v = v[2]; edge[1].f = v[3];
|
|
edge[2].v = v[4]; edge[2].f = v[5];
|
|
edge[3].v = v[6]; edge[3].f = v[7]; }
|
|
};
|
|
|
|
//G.Barrand :
|
|
//int operator == (const SbFacet & v1, const SbFacet & v2);
|
|
//int operator != (const SbFacet & v1, const SbFacet & v2);
|
|
|
|
class polyhedron {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::polyhedron)
|
|
#endif
|
|
|
|
#ifndef SWIG
|
|
friend std::ostream& operator<<(std::ostream&, const polyhedron &ph);
|
|
//G.Barrand
|
|
friend int operator == (const polyhedron & v1, const polyhedron & v2);
|
|
friend int operator != (const polyhedron & v1, const polyhedron & v2);
|
|
#endif
|
|
|
|
private: //G.Barrand
|
|
//std::string* m_name; //have a pointer to optimize memory.
|
|
protected:
|
|
int nvert, nface;
|
|
HVPoint3D* pV;
|
|
SbFacet* pF;
|
|
private:
|
|
int fNumberOfRotationSteps;
|
|
|
|
protected:
|
|
static double _M_PI() {return 3.1415926535897931160E0;}
|
|
//static double _M_PI_2() {return 1.5707963267948965580E0;}
|
|
|
|
// Allocate memory for polyhedron
|
|
void AllocateMemory(int Nvert, int Nface);
|
|
|
|
// Find neighbouring facet
|
|
int FindNeighbour(int iFace, int iNode, int iOrder) const;
|
|
|
|
// Find normal at node
|
|
HVNormal3D FindNodeNormal(int iFace, int iNode) const;
|
|
|
|
// Create polyhedron for prism with quadrilateral base
|
|
void CreatePrism();
|
|
|
|
// Generate facets by revolving an edge around Z-axis
|
|
void RotateEdge(int k1, int k2, double r1, double r2,
|
|
int v1, int v2, int vEdge,
|
|
bool ifWholeCircle, int ns, int &kface);
|
|
|
|
// Set side facets for the case of incomplete rotation
|
|
void SetSideFacets(int ii[4], int vv[4],
|
|
int *kk, double *r,
|
|
double dphi, int ns, int &kface);
|
|
|
|
// Create polyhedron for body of revolution around Z-axis
|
|
void RotateAroundZ(int nstep, double phi, double dphi,
|
|
int np1, int np2,
|
|
const double *z, double *r,
|
|
int nodeVis, int edgeVis);
|
|
|
|
// For each edge set reference to neighbouring facet
|
|
void SetReferences();
|
|
|
|
// Invert the order on nodes in facets
|
|
void InvertFacets();
|
|
public: //public for iv2sg
|
|
static int NUMBER_OF_STEPS() {return 24;}
|
|
public: //for iv2sg
|
|
static void do_not_set_NUMBER_OF_STEPS(int){}
|
|
public:
|
|
polyhedron(int Nvert=0, int Nface=0)
|
|
: /*m_name(0) //G.Barrand
|
|
,*/nvert(Nvert),nface(Nface)
|
|
,pV(Nvert ? new HVPoint3D[Nvert+1] : 0)
|
|
,pF(Nface ? new SbFacet[Nface+1] : 0)
|
|
,fNumberOfRotationSteps(NUMBER_OF_STEPS())
|
|
{
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
public:
|
|
virtual ~polyhedron() {
|
|
//delete m_name; //G.Barrand.
|
|
delete [] pV; delete [] pF;
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
public:
|
|
polyhedron(const polyhedron & from);
|
|
polyhedron& operator=(const polyhedron & from);
|
|
public:
|
|
//G.Barrand : handle a name to help debugging.
|
|
/*
|
|
void setName(const std::string& aName) {
|
|
delete m_name;
|
|
m_name = new std::string(aName);
|
|
}
|
|
const std::string& getName() const {
|
|
if(!m_name) return s_empty();
|
|
return *m_name;
|
|
}
|
|
*/
|
|
//G.Barrand :end
|
|
|
|
void Set(int Nvert, HVPoint3D* aV,
|
|
int Nface, SbFacet* aF) //G.Barrand
|
|
{ delete [] pV; delete [] pF;
|
|
nvert = Nvert; nface = Nface; pV = aV; pF = aF;}
|
|
|
|
void Empty() //G.Barrand
|
|
{ nvert = 0; nface = 0; pV = 0;pF = 0;}
|
|
|
|
// Get number of vertices
|
|
int GetNoVertices() const { return nvert; }
|
|
|
|
// Get number of facets
|
|
int GetNoFacets() const { return nface; }
|
|
|
|
// Transform the polyhedron
|
|
polyhedron& Translate(double,double,double);
|
|
polyhedron& Transform(const rotd& rot,double,double,double);
|
|
polyhedron& Transform(const rotd& rot,const vec3d& trans);
|
|
|
|
// Get next vertex index of the quadrilateral
|
|
//G.Barrand
|
|
bool GetNextVertexIndex(int & index, int & edgeFlag) const;
|
|
|
|
// Get vertex by index
|
|
HVPoint3D GetVertex(int index) const;
|
|
const HVPoint3D& GetVertexFast(int index) const; //G.Barrand
|
|
|
|
//G.Barrand : to optimize SoPolyhedron.
|
|
HVPoint3D* GetPV() const {return pV;} //G.Barrand
|
|
SbFacet* GetPF() const {return pF;} //G.Barrand
|
|
|
|
// Get next vertex + edge visibility of the quadrilateral
|
|
bool GetNextVertex(HVPoint3D & vertex, int & edgeFlag) const;
|
|
|
|
// Get next vertex + edge visibility + normal of the quadrilateral
|
|
bool GetNextVertex(HVPoint3D & vertex, int & edgeFlag,
|
|
HVNormal3D & normal) const;
|
|
|
|
// Get indeces of the next edge with indeces of the faces
|
|
bool GetNextEdgeIndeces(int & i1, int & i2, int & edgeFlag,
|
|
int & iface1, int & iface2) const;
|
|
|
|
// Get indeces of the next edge
|
|
bool GetNextEdgeIndeces(int & i1, int & i2, int & edgeFlag) const;
|
|
|
|
// Get next edge
|
|
bool GetNextEdge(HVPoint3D &p1, HVPoint3D &p2, int &edgeFlag) const;
|
|
|
|
// Get next edge
|
|
bool GetNextEdge(HVPoint3D &p1, HVPoint3D &p2, int &edgeFlag,
|
|
int &iface1, int &iface2) const;
|
|
|
|
// Get face by index
|
|
void GetFacet(int iFace, int &n, int *iNodes,
|
|
int *edgeFlags = 0, int *iFaces = 0) const;
|
|
|
|
// Get face by index
|
|
void GetFacet(int iFace, int &n, HVPoint3D *nodes,
|
|
int *edgeFlags = 0, HVNormal3D *normals = 0) const;
|
|
|
|
// Get next face with normals at the nodes
|
|
bool GetNextFacet(int &n, HVPoint3D *nodes,
|
|
int *edgeFlags=0, HVNormal3D *normals=0) const;
|
|
|
|
// Get normal of the face given by index
|
|
HVNormal3D GetNormal(int iFace) const;
|
|
|
|
// Get unit normal of the face given by index
|
|
HVNormal3D GetUnitNormal(int iFace) const;
|
|
|
|
// Get normal of the next face
|
|
bool GetNextNormal(HVNormal3D &normal) const;
|
|
|
|
// Get normal of unit length of the next face
|
|
bool GetNextUnitNormal(HVNormal3D &normal) const;
|
|
|
|
// Boolean operations
|
|
polyhedron add(const polyhedron &p) const;
|
|
polyhedron subtract(const polyhedron &p) const;
|
|
polyhedron intersect(const polyhedron &p) const;
|
|
|
|
// Get area of the surface of the polyhedron
|
|
double GetSurfaceArea() const;
|
|
|
|
// Get volume of the polyhedron
|
|
double GetVolume() const;
|
|
|
|
bool isEqual(const polyhedron &p) const; //G.Barrand
|
|
bool isConsistent(const char* = 0) const; //G.Barrand
|
|
void dump(std::ostream&) const;
|
|
|
|
// Get number of steps for whole circle
|
|
int GetNumberOfRotationSteps(); //G.Barrand : no more static.
|
|
|
|
// Set number of steps for whole circle
|
|
void SetNumberOfRotationSteps(int n);
|
|
|
|
// Reset number of steps for whole circle to default value
|
|
void ResetNumberOfRotationSteps(); //G.Barrand : have code in .cxx.
|
|
|
|
public:
|
|
//G.Barrand : have the below set_ to optimize exlib/sg/polyhedron setup.
|
|
bool set_polyhedron_cons(double Rmn1, double Rmx1,
|
|
double Rmn2, double Rmx2, double Dz,
|
|
double Phi1, double Dphi,
|
|
int nstep = 0); //G.Barrand
|
|
bool set_polyhedron_tube(double Rmin, double Rmax, double Dz,
|
|
int nstep = 0){
|
|
return set_polyhedron_cons(Rmin, Rmax, Rmin, Rmax, Dz, 0, 2*_M_PI(), nstep);
|
|
}
|
|
|
|
double vxy(const double* xy,int i,int j) {return xy[i*2+j];}
|
|
bool set_polyhedron_arb8(double Dz,const double* xy);
|
|
|
|
bool set_polyhedron_trd2(double Dx1, double Dx2,
|
|
double Dy1, double Dy2, double Dz);
|
|
bool set_polyhedron_box(double Dx, double Dy, double Dz){
|
|
return set_polyhedron_trd2(Dx, Dx, Dy, Dy, Dz);
|
|
}
|
|
bool set_polyhedron_trd1(double Dx1, double Dx2,
|
|
double Dy, double Dz){
|
|
return set_polyhedron_trd2(Dx1, Dx2, Dy, Dy, Dz);
|
|
}
|
|
bool set_polyhedron_trap(double Dz, double Theta, double Phi,
|
|
double Dy1,
|
|
double Dx1, double Dx2, double Alp1,
|
|
double Dy2,
|
|
double Dx3, double Dx4, double Alp2);
|
|
|
|
bool set_polyhedron_para(double Dx, double Dy, double Dz,
|
|
double Alpha, double Theta,
|
|
double Phi){
|
|
return set_polyhedron_trap(Dz,Theta,Phi,Dy,Dx,Dx,Alpha,Dy,Dx,Dx,Alpha);
|
|
}
|
|
|
|
bool set_polyhedron_pgon(double phi, double dphi, int npdv, int nz,
|
|
const double *z,
|
|
const double *rmin,
|
|
const double *rmax);
|
|
bool set_polyhedron_pcon(double phi, double dphi, int nz,
|
|
const double *z,
|
|
const double *rmin,
|
|
const double *rmax) {
|
|
return set_polyhedron_pgon(phi, dphi, 0, nz, z, rmin, rmax);
|
|
}
|
|
|
|
bool set_polyhedron_tubs(double Rmin, double Rmax,
|
|
double Dz,
|
|
double Phi1, double Dphi,
|
|
int nstep) {//G.Barrand
|
|
return set_polyhedron_cons(Rmin, Rmax, Rmin, Rmax, Dz, Phi1, Dphi, nstep);
|
|
}
|
|
|
|
bool set_polyhedron_cone(double Rmn1, double Rmx1,
|
|
double Rmn2, double Rmx2,
|
|
double Dz,
|
|
int nstep) {
|
|
return set_polyhedron_cons(Rmn1, Rmx1, Rmn2, Rmx2, Dz, 0, 2*_M_PI(), nstep);
|
|
}
|
|
|
|
bool set_polyhedron_torus(double rmin,double rmax,double rtor,
|
|
double phi,double dphi,
|
|
int nphi, //G.Barrand
|
|
int nthe); //G.Barrand
|
|
|
|
bool set_polyhedron_xtru(int a_npts,int a_nz,
|
|
double* a_xs,double* a_ys,double* a_zs,
|
|
bool a_acw = true,
|
|
bool a_zfb = true);
|
|
|
|
bool set_polyhedron_sphere(double rmin, double rmax,
|
|
double phi, double dphi,
|
|
double the, double dthe,
|
|
int nphi = 0,
|
|
int nthe = 0); //G.Barrand
|
|
|
|
bool set_polyhedron_hype(double a_st_in,double a_st_out,
|
|
double a_rmin,double a_rmax,double a_dz,
|
|
int a_nz = 10,int a_nphi = 24);
|
|
bool set_polyhedron_eltu(double a_dx,double a_dy,double a_dz,
|
|
int a_nz = 10,int a_nphi = 24);
|
|
private: //G.Barrand
|
|
int _ixy(int,int,int,int,bool,bool);
|
|
void _clear(){
|
|
//used in set_polyhedronXxx()
|
|
delete [] pV;
|
|
pV = 0;
|
|
delete [] pF;
|
|
pF = 0;
|
|
nvert = 0;
|
|
nface = 0;
|
|
}
|
|
bool CHECK_INDEX(const char* a_method,int a_index) const;
|
|
};
|
|
|
|
//G.Barrand :
|
|
//int operator == (const polyhedron & v1, const polyhedron & v2);
|
|
//int operator != (const polyhedron & v1, const polyhedron & v2);
|
|
|
|
// G.Barrand : introduce iabs to avoid a mess with cmath and some compiler.
|
|
inline int Sb_iabs(int a) {
|
|
return a < 0 ? -a : a;
|
|
}
|
|
|
|
inline //G.Barrand
|
|
bool polyhedron::GetNextVertexIndex(int &index, int &edgeFlag) const
|
|
/***********************************************************************
|
|
* *
|
|
* Name: polyhedron::GetNextVertexIndex Date: 03.09.96 *
|
|
* Author: Yasuhide Sawada Revised: *
|
|
* *
|
|
* Function: *
|
|
* *
|
|
***********************************************************************/
|
|
{
|
|
static int iFace = 1;
|
|
static int iQVertex = 0;
|
|
//G.Barrand : int vIndex = pF[iFace].edge[iQVertex].v;
|
|
SbFacet::edge_t* edge = pF[iFace].edge; //G.Barrand : optimize.
|
|
int vIndex = edge[iQVertex].v;
|
|
|
|
edgeFlag = (vIndex > 0) ? 1 : 0;
|
|
index = Sb_iabs(vIndex);
|
|
|
|
if(index>nvert) {
|
|
#ifdef TOOLS_HEP_PH_OUT_ERR
|
|
std::cerr << "polyhedron::GetNextVertexIndex: pV index problem "
|
|
<< index << " exceed " << nvert << std::endl;
|
|
#endif
|
|
index = 0;
|
|
}
|
|
|
|
//G.Barrand : if (iQVertex >= 3 || pF[iFace].edge[iQVertex+1].v == 0) {
|
|
if (iQVertex >= 3 || edge[iQVertex+1].v == 0) {
|
|
iQVertex = 0;
|
|
if (++iFace > nface) iFace = 1;
|
|
return false; // Last Edge
|
|
}else{
|
|
++iQVertex;
|
|
return true; // not Last Edge
|
|
}
|
|
}
|
|
|
|
class polyhedron_trd2 : public polyhedron {
|
|
public:
|
|
polyhedron_trd2(double Dx1, double Dx2,
|
|
double Dy1, double Dy2, double Dz);
|
|
virtual ~polyhedron_trd2(){}
|
|
public:
|
|
polyhedron_trd2(const polyhedron_trd2& a_from):polyhedron(a_from){}
|
|
polyhedron_trd2& operator=(const polyhedron_trd2& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_arb8 : public polyhedron {
|
|
public:
|
|
polyhedron_arb8(double Dz,const double* xy);
|
|
virtual ~polyhedron_arb8(){}
|
|
public:
|
|
polyhedron_arb8(const polyhedron_arb8& a_from):polyhedron(a_from){}
|
|
polyhedron_arb8& operator=(const polyhedron_arb8& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_xtru : public polyhedron {
|
|
public:
|
|
polyhedron_xtru(int a_npts,int a_nz,
|
|
double* a_xs,double* a_ys,double* a_zs,
|
|
bool a_acw = true,
|
|
bool a_zfb = true);
|
|
virtual ~polyhedron_xtru(){}
|
|
public:
|
|
polyhedron_xtru(const polyhedron_xtru& a_from):polyhedron(a_from){}
|
|
polyhedron_xtru& operator=(const polyhedron_xtru& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
class polyhedron_hype : public polyhedron {
|
|
public:
|
|
polyhedron_hype(double a_st_in,double a_st_out,
|
|
double a_rmin,double a_rmax,double a_dz,
|
|
int a_nz = 10,int a_nphi = 24);
|
|
virtual ~polyhedron_hype(){}
|
|
public:
|
|
polyhedron_hype(const polyhedron_hype& a_from):polyhedron(a_from){}
|
|
polyhedron_hype& operator=(const polyhedron_hype& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
class polyhedron_trd1 : public polyhedron_trd2 {
|
|
public:
|
|
polyhedron_trd1(double Dx1, double Dx2,
|
|
double Dy, double Dz);
|
|
virtual ~polyhedron_trd1(){}
|
|
public:
|
|
polyhedron_trd1(const polyhedron_trd1& a_from):polyhedron_trd2(a_from){}
|
|
polyhedron_trd1& operator=(const polyhedron_trd1& a_from){
|
|
polyhedron_trd2::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_box : public polyhedron_trd2 {
|
|
public:
|
|
polyhedron_box(double Dx, double Dy, double Dz);
|
|
virtual ~polyhedron_box(){}
|
|
public:
|
|
polyhedron_box(const polyhedron_box& a_from):polyhedron_trd2(a_from){}
|
|
polyhedron_box& operator=(const polyhedron_box& a_from){
|
|
polyhedron_trd2::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_trap : public polyhedron {
|
|
public:
|
|
polyhedron_trap(double Dz, double Theta, double Phi,
|
|
double Dy1,
|
|
double Dx1, double Dx2, double Alp1,
|
|
double Dy2,
|
|
double Dx3, double Dx4, double Alp2);
|
|
virtual ~polyhedron_trap(){}
|
|
public:
|
|
polyhedron_trap(const polyhedron_trap& a_from):polyhedron(a_from){}
|
|
polyhedron_trap& operator=(const polyhedron_trap& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_para : public polyhedron_trap {
|
|
public:
|
|
polyhedron_para(double Dx, double Dy, double Dz,
|
|
double Alpha, double Theta, double Phi);
|
|
virtual ~polyhedron_para(){}
|
|
public:
|
|
polyhedron_para(const polyhedron_para& a_from):polyhedron_trap(a_from){}
|
|
polyhedron_para& operator=(const polyhedron_para& a_from){
|
|
polyhedron_trap::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_cons : public polyhedron {
|
|
public:
|
|
polyhedron_cons(double Rmn1, double Rmx1,
|
|
double Rmn2, double Rmx2, double Dz,
|
|
double Phi1, double Dphi,
|
|
int nstep = 0); //G.Barrand
|
|
virtual ~polyhedron_cons(){}
|
|
public:
|
|
polyhedron_cons(const polyhedron_cons& a_from):polyhedron(a_from){}
|
|
polyhedron_cons& operator=(const polyhedron_cons& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_cone : public polyhedron_cons {
|
|
public:
|
|
polyhedron_cone(double Rmn1, double Rmx1,
|
|
double Rmn2, double Rmx2, double Dz,
|
|
int nstep = 0); //G.Barrand
|
|
virtual ~polyhedron_cone(){}
|
|
public:
|
|
polyhedron_cone(const polyhedron_cone& a_from):polyhedron_cons(a_from){}
|
|
polyhedron_cone& operator=(const polyhedron_cone& a_from){
|
|
polyhedron_cons::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_tubs : public polyhedron_cons {
|
|
public:
|
|
polyhedron_tubs(double Rmin, double Rmax, double Dz,
|
|
double Phi1, double Dphi,
|
|
int nstep = 0); //G.Barrand
|
|
virtual ~polyhedron_tubs(){}
|
|
public:
|
|
polyhedron_tubs(const polyhedron_tubs& a_from):polyhedron_cons(a_from){}
|
|
polyhedron_tubs& operator=(const polyhedron_tubs& a_from){
|
|
polyhedron_cons::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_tube : public polyhedron_cons {
|
|
public:
|
|
polyhedron_tube(double Rmin, double Rmax, double Dz,int nstep = 0); //G.Barrand
|
|
virtual ~polyhedron_tube(){}
|
|
public:
|
|
polyhedron_tube(const polyhedron_tube& a_from):polyhedron_cons(a_from){}
|
|
polyhedron_tube& operator=(const polyhedron_tube& a_from){
|
|
polyhedron_cons::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_pgon : public polyhedron {
|
|
public:
|
|
polyhedron_pgon(double phi, double dphi, int npdv, int nz,
|
|
const double *z,
|
|
const double *rmin,
|
|
const double *rmax);
|
|
virtual ~polyhedron_pgon(){}
|
|
public:
|
|
polyhedron_pgon(const polyhedron_pgon& a_from):polyhedron(a_from){}
|
|
polyhedron_pgon& operator=(const polyhedron_pgon& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_pcon : public polyhedron_pgon {
|
|
public:
|
|
polyhedron_pcon(double phi, double dphi, int nz,
|
|
const double *z,
|
|
const double *rmin,
|
|
const double *rmax);
|
|
virtual ~polyhedron_pcon(){}
|
|
public:
|
|
polyhedron_pcon(const polyhedron_pcon& a_from):polyhedron_pgon(a_from){}
|
|
polyhedron_pcon& operator=(const polyhedron_pcon& a_from){
|
|
polyhedron_pgon::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_sphere : public polyhedron {
|
|
public:
|
|
polyhedron_sphere(double rmin, double rmax,
|
|
double phi, double dphi,
|
|
double the, double dthe,
|
|
int nphi = 0,
|
|
int nthe = 0); //G.Barrand
|
|
virtual ~polyhedron_sphere(){}
|
|
public:
|
|
polyhedron_sphere(const polyhedron_sphere& a_from):polyhedron(a_from){}
|
|
polyhedron_sphere& operator=(const polyhedron_sphere& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
class polyhedron_torus : public polyhedron {
|
|
public:
|
|
polyhedron_torus(double rmin, double rmax, double rtor,
|
|
double phi, double dphi,
|
|
int nphi = 0,
|
|
int nthe = 0); //G.Barrand
|
|
virtual ~polyhedron_torus(){}
|
|
public:
|
|
polyhedron_torus(const polyhedron_torus& a_from):polyhedron(a_from){}
|
|
polyhedron_torus& operator=(const polyhedron_torus& a_from){
|
|
polyhedron::operator=(a_from);
|
|
return *this;
|
|
}
|
|
//virtual polyhedron& operator = (const polyhedron& from) {
|
|
// return polyhedron::operator = (from);
|
|
//}
|
|
};
|
|
|
|
//G.Barrand : begin
|
|
class polyhedronProcessor {
|
|
#ifdef TOOLS_MEM
|
|
TOOLS_SCLASS(tools::hep::polyhedronProcessor)
|
|
#endif
|
|
public:
|
|
enum Operation { //Must be the same than BooleanProcessor OP_XXX.
|
|
UNION = 0
|
|
,INTERSECTION = 1
|
|
,SUBTRACTION = 2
|
|
};
|
|
private:
|
|
typedef std::pair<Operation,polyhedron> op_t;
|
|
public:
|
|
polyhedronProcessor(){
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
virtual ~polyhedronProcessor(){
|
|
#ifdef TOOLS_MEM
|
|
mem::decrement(s_class().c_str());
|
|
#endif
|
|
}
|
|
private:
|
|
polyhedronProcessor(const polyhedronProcessor&){
|
|
#ifdef TOOLS_MEM
|
|
mem::increment(s_class().c_str());
|
|
#endif
|
|
}
|
|
polyhedronProcessor& operator=(const polyhedronProcessor&){return *this;}
|
|
public:
|
|
void push_back(Operation a_op,const polyhedron& a_polyhedron) {
|
|
m_ops.push_back(op_t(a_op,a_polyhedron));
|
|
}
|
|
bool execute(polyhedron&);
|
|
void clear() { m_ops.clear();}
|
|
bool is_same_op() const {
|
|
if(!m_ops.size()) return true;
|
|
Operation op = m_ops[0].first;
|
|
std::vector<op_t>::const_iterator it;
|
|
for(it=m_ops.begin();it!=m_ops.end();++it) {
|
|
if((*it).first!=op) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//private:
|
|
bool execute1(polyhedron&,const std::vector<unsigned int>&);
|
|
private:
|
|
std::vector<op_t> m_ops;
|
|
};
|
|
//G.Barrand : end
|
|
|
|
//inline const std::string& stype(const polyhedron&) {
|
|
// static const std::string s_v("tools::hep::polyhedron");
|
|
// return s_v;
|
|
//}
|
|
|
|
}}
|
|
|
|
#include "polyhedron.icc"
|
|
|
|
namespace tools {
|
|
namespace hep {
|
|
|
|
template <class MATRIX>
|
|
inline void tsf_polyhedron(polyhedron& a_ph,const MATRIX& a_matrix) {
|
|
typedef typename MATRIX::elem_t T;
|
|
int nvert = a_ph.GetNoVertices();
|
|
hep::HVPoint3D* pV = a_ph.GetPV();
|
|
if (nvert > 0) {
|
|
T x,y,z;
|
|
for (int i=1; i<=nvert; i++) {
|
|
hep::HVPoint3D& p = pV[i];
|
|
x = T(p.x());
|
|
y = T(p.y());
|
|
z = T(p.z());
|
|
a_matrix.mul_3(x,y,z);
|
|
p.set_value(x,y,z);
|
|
}
|
|
}
|
|
}
|
|
|
|
}}
|
|
|
|
#endif
|
|
|
|
//--------------------------------------------------------------------//
|
|
// JFB: //
|
|
// polyhedron was HepPolyhedron, retrofitted to Open Inventor //
|
|
// infrastructure: //
|
|
//--------------------------------------------------------------------//
|
|
|
|
|
|
// ********************************************************************
|
|
// * DISCLAIMER *
|
|
// * *
|
|
// * The following disclaimer summarizes all the specific disclaimers *
|
|
// * of contributors to this software. The specific disclaimers,which *
|
|
// * govern, are listed with their locations in: *
|
|
// * http://cern.ch/geant4/license *
|
|
// * *
|
|
// * 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. *
|
|
// * *
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// Class Description:
|
|
// polyhedron is an intermediate class between description of a shape
|
|
// and visualization systems. It is intended to provide some service like:
|
|
// - polygonization of shapes with triangulization (quadrilaterization)
|
|
// of complex polygons;
|
|
// - calculation of normals for faces and vertices;
|
|
// - finding result of boolean operation on polyhedra;
|
|
//
|
|
// Public constructors:
|
|
//
|
|
// polyhedron_box (dx,dy,dz)
|
|
// - create polyhedron for Box;
|
|
// polyhedron_trd1 (dx1,dx2,dy,dz)
|
|
// - create polyhedron for G3 Trd1;
|
|
// polyhedron_trd2 (dx1,dx2,dy1,dy2,dz)
|
|
// - create polyhedron for G3 Trd2;
|
|
// polyhedron_trap (dz,theta,phi, h1,bl1,tl1,alp1, h2,bl2,tl2,alp2)
|
|
// - create polyhedron for G3 Trap;
|
|
// polyhedron_para (dx,dy,dz,alpha,theta,phi)
|
|
// - create polyhedron for G3 Para;
|
|
// polyhedron_tube (rmin,rmax,dz,nstep=0)
|
|
// - create polyhedron for G3 Tube;
|
|
// polyhedron_tubs (rmin,rmax,dz,phi1,dphi,nstep=0)
|
|
// - create polyhedron for G3 Tubs;
|
|
// polyhedron_cone (rmin1,rmax1,rmin2,rmax2,dz,nstep=0)
|
|
// - create polyhedron for G3 Cone;
|
|
// polyhedron_cons (rmin1,rmax1,rmin2,rmax2,dz,phi1,dphi,nstep=0)
|
|
// - create polyhedron for G3 Cons;
|
|
// polyhedron_pgon (phi,dphi,npdv,nz, z(*),rmin(*),rmax(*))
|
|
// - create polyhedron for G3 Pgon;
|
|
// polyhedron_pcon (phi,dphi,nz, z(*),rmin(*),rmax(*))
|
|
// - create polyhedron for G3 Pcon;
|
|
// polyhedron_sphere (rmin,rmax,phi,dphi,the,dthe,nstep=0)
|
|
// - create polyhedron for Sphere;
|
|
// polyhedron_torus (rmin,rmax,rtor,phi,dphi,nstep=0)
|
|
// - create polyhedron for Torus;
|
|
// Public functions:
|
|
//
|
|
// GetNoVertices () - returns number of vertices;
|
|
// GetNoFacets () - returns number of faces;
|
|
// GetNextVertexIndex (index,edgeFlag) - get vertex indeces of the
|
|
// quadrilaterals in order;
|
|
// returns false when finished each face;
|
|
// GetVertex (index) - returns vertex by index;
|
|
// GetNextVertex (vertex,edgeFlag) - get vertices with edge visibility
|
|
// of the quadrilaterals in order;
|
|
// returns false when finished each face;
|
|
// GetNextVertex (vertex,edgeFlag,normal) - get vertices with edge
|
|
// visibility and normal of the quadrilaterals
|
|
// in order; returns false when finished each face;
|
|
// GetNextEdgeIndeces (i1,i2,edgeFlag) - get indeces of the next edge;
|
|
// returns false for the last edge;
|
|
// GetNextEdgeIndeces (i1,i2,edgeFlag,iface1,iface2) - get indeces of
|
|
// the next edge with indeces of the faces
|
|
// to which the edge belongs;
|
|
// returns false for the last edge;
|
|
// GetNextEdge (p1,p2,edgeFlag) - get next edge;
|
|
// returns false for the last edge;
|
|
// GetNextEdge (p1,p2,edgeFlag,iface1,iface2) - get next edge with indeces
|
|
// of the faces to which the edge belongs;
|
|
// returns false for the last edge;
|
|
// GetFacet (index,n,nodes,edgeFlags=0,normals=0) - get face by index;
|
|
// GetNextFacet (n,nodes,edgeFlags=0,normals=0) - get next face with normals
|
|
// at the nodes; returns false for the last face;
|
|
// GetNormal (index) - get normal of face given by index;
|
|
// GetUnitNormal (index) - get unit normal of face given by index;
|
|
// GetNextNormal (normal) - get normals of each face in order;
|
|
// returns false when finished all faces;
|
|
// GetNextUnitNormal (normal) - get normals of unit length of each face
|
|
// in order; returns false when finished all faces;
|
|
// GetSurfaceArea() - get surface area of the polyhedron;
|
|
// GetVolume() - get volume of the polyhedron;
|
|
// GetNumberOfRotationSteps() - get number of steps for whole circle;
|
|
// SetNumberOfRotationSteps (n) - set number of steps for whole circle;
|
|
// ResetNumberOfRotationSteps() - reset number of steps for whole circle
|
|
// to default value;
|
|
// History:
|
|
//
|
|
// 20.06.96 Evgeni Chernyaev <Evgueni.Tcherniaev@cern.ch> - initial version
|
|
//
|
|
// 23.07.96 John Allison
|
|
// - added GetNoVertices, GetNoFacets, GetNextVertex, GetNextNormal
|
|
//
|
|
// 30.09.96 E.Chernyaev
|
|
// - added GetNextVertexIndex, GetVertex by Yasuhide Sawada
|
|
// - added GetNextUnitNormal, GetNextEdgeIndeces, GetNextEdge
|
|
// - improvements: angles now expected in radians
|
|
// int -> G4int, double -> G4double
|
|
// - G4ThreeVector replaced by either G4Point3D or G4Normal3D
|
|
//
|
|
// 15.12.96 E.Chernyaev
|
|
// - private functions G4PolyhedronAlloc, G4PolyhedronPrism renamed
|
|
// to AllocateMemory and CreatePrism
|
|
// - added private functions GetNumberOfRotationSteps, RotateEdge,
|
|
// RotateAroundZ, SetReferences
|
|
// - rewritten G4PolyhedronCons;
|
|
// - added G4PolyhedronPara, ...Trap, ...Pgon, ...Pcon, ...Sphere, ...Torus,
|
|
// so full List of implemented shapes now looks like:
|
|
// BOX, TRD1, TRD2, TRAP, TUBE, TUBS, CONE, CONS, PARA, PGON, PCON,
|
|
// SPHERE, TORUS
|
|
//
|
|
// 01.06.97 E.Chernyaev
|
|
// - RotateAroundZ modified and SetSideFacets added to allow Rmin=Rmax
|
|
// in bodies of revolution
|
|
//
|
|
// 24.06.97 J.Allison
|
|
// - added static private member fNumberOfRotationSteps and static public
|
|
// functions void SetNumberOfRotationSteps (G4int n) and
|
|
// void ResetNumberOfRotationSteps (). Modified
|
|
// GetNumberOfRotationSteps() appropriately. Made all three functions
|
|
// inline (at end of this .hh file).
|
|
// Usage:
|
|
// G4Polyhedron::SetNumberOfRotationSteps
|
|
// (fpView -> GetViewParameters ().GetNoOfSides ());
|
|
// pPolyhedron = solid.CreatePolyhedron ();
|
|
// G4Polyhedron::ResetNumberOfRotationSteps ();
|
|
//
|
|
// 19.03.00 E.Chernyaev
|
|
// - added boolean operations (add, subtract, intersect) on polyhedra;
|
|
//
|
|
// 25.05.01 E.Chernyaev
|
|
// - added GetSurfaceArea() and GetVolume();
|
|
//
|
|
|