ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | Static Private Attributes | Friends | List of all members
SbPolyhedron Class Reference

#include <SbPolyhedron.h>

Inheritance diagram for SbPolyhedron:
Collaboration diagram for SbPolyhedron:

Public Member Functions

 SbPolyhedron (int Nvert=0, int Nface=0)
 
 SbPolyhedron (const SbPolyhedron &from)
 
virtual ~SbPolyhedron ()
 
virtual SbPolyhedron & operator= (const SbPolyhedron &from)
 
int GetNoVertices () const
 
int GetNoFacets () const
 
SbPolyhedron & Transform (const HEPVis::SbRotation &rot, const SbVec3d &trans)
 
bool GetNextVertexIndex (int &index, int &edgeFlag) const
 
HVPoint3D GetVertex (int index) const
 
const HVPoint3D & GetVertexFast (int index) const
 
bool GetNextVertex (HVPoint3D &vertex, int &edgeFlag) const
 
bool GetNextVertex (HVPoint3D &vertex, int &edgeFlag, HVNormal3D &normal) const
 
bool GetNextEdgeIndeces (int &i1, int &i2, int &edgeFlag, int &iface1, int &iface2) const
 
bool GetNextEdgeIndeces (int &i1, int &i2, int &edgeFlag) const
 
bool GetNextEdge (HVPoint3D &p1, HVPoint3D &p2, int &edgeFlag) const
 
bool GetNextEdge (HVPoint3D &p1, HVPoint3D &p2, int &edgeFlag, int &iface1, int &iface2) const
 
void GetFacet (int iFace, int &n, int *iNodes, int *edgeFlags=0, int *iFaces=0) const
 
void GetFacet (int iFace, int &n, HVPoint3D *nodes, int *edgeFlags=0, HVNormal3D *normals=0) const
 
bool GetNextFacet (int &n, HVPoint3D *nodes, int *edgeFlags=0, HVNormal3D *normals=0) const
 
HVNormal3D GetNormal (int iFace) const
 
HVNormal3D GetUnitNormal (int iFace) const
 
bool GetNextNormal (HVNormal3D &normal) const
 
bool GetNextUnitNormal (HVNormal3D &normal) const
 
SbPolyhedron add (const SbPolyhedron &p) const
 
SbPolyhedron subtract (const SbPolyhedron &p) const
 
SbPolyhedron intersect (const SbPolyhedron &p) const
 
double GetSurfaceArea () const
 
double GetVolume () const
 

Static Public Member Functions

static int GetNumberOfRotationSteps ()
 
static void SetNumberOfRotationSteps (int n)
 
static void ResetNumberOfRotationSteps ()
 

Protected Member Functions

void AllocateMemory (int Nvert, int Nface)
 
int FindNeighbour (int iFace, int iNode, int iOrder) const
 
HVNormal3D FindNodeNormal (int iFace, int iNode) const
 
void CreatePrism ()
 
void RotateEdge (int k1, int k2, double r1, double r2, int v1, int v2, int vEdge, bool ifWholeCircle, int ns, int &kface)
 
void SetSideFacets (int ii[4], int vv[4], int *kk, double *r, double dphi, int ns, int &kface)
 
void RotateAroundZ (int nstep, double phi, double dphi, int np1, int np2, const double *z, double *r, int nodeVis, int edgeVis)
 
void SetReferences ()
 
void InvertFacets ()
 

Protected Attributes

int m_nvert
 
int m_nface
 
HVPoint3D * m_pV
 
SbFacet * m_pF
 

Static Private Attributes

static int s_numberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS
 

Friends

std::ostream & operator<< (std::ostream &, const SbPolyhedron &ph)
 

Detailed Description

Definition at line 231 of file SbPolyhedron.h.

Constructor & Destructor Documentation

◆ SbPolyhedron() [1/2]

SbPolyhedron::SbPolyhedron ( int  Nvert = 0,
int  Nface = 0 
)
inline

Definition at line 278 of file SbPolyhedron.h.

279  : m_nvert(Nvert), m_nface(Nface),
280  m_pV(Nvert ? new HVPoint3D[Nvert+1] : 0),
281  m_pF(Nface ? new SbFacet[Nface+1] : 0) {}

◆ SbPolyhedron() [2/2]

SbPolyhedron::SbPolyhedron ( const SbPolyhedron &  from)

Definition at line 140 of file SbPolyhedron.cxx.

147 {
148  if (from.m_nvert > 0 && from.m_nface > 0) {
149  m_nvert = from.m_nvert;
150  m_nface = from.m_nface;
151  m_pV = new HVPoint3D[m_nvert + 1];
152  m_pF = new SbFacet[m_nface + 1];
153  int i;
154  for (i=1; i<=m_nvert; i++) m_pV[i] = from.m_pV[i];
155  for (i=1; i<=m_nface; i++) m_pF[i] = from.m_pF[i];
156  }else{
157  m_nvert = 0; m_nface = 0; m_pV = 0; m_pF = 0;
158  }
159 }

◆ ~SbPolyhedron()

virtual SbPolyhedron::~SbPolyhedron ( )
inlinevirtual

Definition at line 287 of file SbPolyhedron.h.

287 { delete [] m_pV; delete [] m_pF; }

Member Function Documentation

◆ add()

SbPolyhedron SbPolyhedron::add ( const SbPolyhedron &  p) const

Definition at line 1842 of file SbPolyhedron.cxx.

1851 {
1852  // rbianchi change
1853  //return processor.execute(OP_UNION, *this, p);
1854  HEPVis_BooleanProcessor processor; //G.Barrand
1855  int err;
1856  return processor.execute(OP_UNION, *this, p, err);
1857  //---
1858 }

◆ AllocateMemory()

void SbPolyhedron::AllocateMemory ( int  Nvert,
int  Nface 
)
protected

Definition at line 267 of file SbPolyhedron.cxx.

279 {
280  m_nvert = Nvert;
281  m_nface = Nface;
282  m_pV = new HVPoint3D[m_nvert+1];
283  m_pF = new SbFacet[m_nface+1];
284 }

◆ CreatePrism()

void SbPolyhedron::CreatePrism ( )
protected

Definition at line 286 of file SbPolyhedron.cxx.

295 {
296  enum {DUMMY, BOTTOM, LEFT, BACK, RIGHT, FRONT, TOP};
297 
298  m_pF[1] = SbFacet(1,LEFT, 4,BACK, 3,RIGHT, 2,FRONT);
299  m_pF[2] = SbFacet(5,TOP, 8,BACK, 4,BOTTOM, 1,FRONT);
300  m_pF[3] = SbFacet(8,TOP, 7,RIGHT, 3,BOTTOM, 4,LEFT);
301  m_pF[4] = SbFacet(7,TOP, 6,FRONT, 2,BOTTOM, 3,BACK);
302  m_pF[5] = SbFacet(6,TOP, 5,LEFT, 1,BOTTOM, 2,RIGHT);
303  m_pF[6] = SbFacet(5,FRONT, 6,RIGHT, 7,BACK, 8,LEFT);
304 }

◆ FindNeighbour()

int SbPolyhedron::FindNeighbour ( int  iFace,
int  iNode,
int  iOrder 
) const
protected

Definition at line 189 of file SbPolyhedron.cxx.

198 {
199  int i;
200  for (i=0; i<4; i++) {
201  if (iNode == iabs(m_pF[iFace].m_edge[i].v)) break;
202  }
203  if (i == 4) {
204  std::cerr
205  << "SbPolyhedron::FindNeighbour: face " << iFace
206  << " has no node " << iNode
207  << std::endl;
208  return 0;
209  }
210  if (iOrder < 0) {
211  if ( --i < 0) i = 3;
212  if (m_pF[iFace].m_edge[i].v == 0) i = 2;
213  }
214  return (m_pF[iFace].m_edge[i].v > 0) ? 0 : m_pF[iFace].m_edge[i].f;
215 }

◆ FindNodeNormal()

HVNormal3D SbPolyhedron::FindNodeNormal ( int  iFace,
int  iNode 
) const
protected

Definition at line 217 of file SbPolyhedron.cxx.

226 {
227  HVNormal3D normal = GetUnitNormal(iFace);
228  int k = iFace, iOrder = 1;
229 
230  for(;;) {
231  k = FindNeighbour(k, iNode, iOrder);
232  if (k == iFace) break;
233  if (k > 0) {
234  normal += GetUnitNormal(k);
235  }else{
236  if (iOrder < 0) break;
237  k = iFace;
238  iOrder = -iOrder;
239  }
240  }
241  normal.normalize();
242  return normal;
243 }

◆ GetFacet() [1/2]

void SbPolyhedron::GetFacet ( int  iFace,
int &  n,
HVPoint3D *  nodes,
int *  edgeFlags = 0,
HVNormal3D *  normals = 0 
) const

Definition at line 1151 of file SbPolyhedron.cxx.

1161 {
1162  int iNodes[4];
1163  GetFacet(index, n, iNodes, edgeFlags);
1164  if (n != 0) {
1165  for (int i=0; i<4; i++) {
1166  nodes[i] = m_pV[iNodes[i]];
1167  if (normals != 0) normals[i] = FindNodeNormal(index,iNodes[i]);
1168  }
1169  }
1170 }

◆ GetFacet() [2/2]

void SbPolyhedron::GetFacet ( int  iFace,
int &  n,
int *  iNodes,
int *  edgeFlags = 0,
int *  iFaces = 0 
) const

Definition at line 1117 of file SbPolyhedron.cxx.

1127 {
1128  if (iFace < 1 || iFace > m_nface) {
1129  std::cerr
1130  << "SbPolyhedron::GetFacet: irrelevant index " << iFace
1131  << std::endl;
1132  n = 0;
1133  }else{
1134  int i, k;
1135  for (i=0; i<4; i++) {
1136  k = m_pF[iFace].m_edge[i].v;
1137  if (k == 0) break;
1138  if (iFaces != 0) iFaces[i] = m_pF[iFace].m_edge[i].f;
1139  if (k > 0) {
1140  iNodes[i] = k;
1141  if (edgeFlags != 0) edgeFlags[i] = 1;
1142  }else{
1143  iNodes[i] = -k;
1144  if (edgeFlags != 0) edgeFlags[i] = -1;
1145  }
1146  }
1147  n = i;
1148  }
1149 }

◆ GetNextEdge() [1/2]

bool SbPolyhedron::GetNextEdge ( HVPoint3D &  p1,
HVPoint3D &  p2,
int &  edgeFlag 
) const

Definition at line 1076 of file SbPolyhedron.cxx.

1088 {
1089  int i1,i2;
1090  bool rep = GetNextEdgeIndeces(i1,i2,edgeFlag);
1091  p1 = m_pV[i1];
1092  p2 = m_pV[i2];
1093  return rep;
1094 }

◆ GetNextEdge() [2/2]

bool SbPolyhedron::GetNextEdge ( HVPoint3D &  p1,
HVPoint3D &  p2,
int &  edgeFlag,
int &  iface1,
int &  iface2 
) const

Definition at line 1097 of file SbPolyhedron.cxx.

1109 {
1110  int i1,i2;
1111  bool rep = GetNextEdgeIndeces(i1,i2,edgeFlag,iface1,iface2);
1112  p1 = m_pV[i1];
1113  p2 = m_pV[i2];
1114  return rep;
1115 }

◆ GetNextEdgeIndeces() [1/2]

bool SbPolyhedron::GetNextEdgeIndeces ( int &  i1,
int &  i2,
int &  edgeFlag 
) const

Definition at line 1060 of file SbPolyhedron.cxx.

1070 {
1071  int kface1, kface2;
1072  return GetNextEdgeIndeces(i1, i2, edgeFlag, kface1, kface2);
1073 }

◆ GetNextEdgeIndeces() [2/2]

bool SbPolyhedron::GetNextEdgeIndeces ( int &  i1,
int &  i2,
int &  edgeFlag,
int &  iface1,
int &  iface2 
) const

Definition at line 1007 of file SbPolyhedron.cxx.

1019 {
1020  static int iFace = 1;
1021  static int iQVertex = 0;
1022  static int iOrder = 1;
1023  int k1, k2, kflag, kface1, kface2;
1024 
1025  if (iFace == 1 && iQVertex == 0) {
1026  k2 = m_pF[m_nface].m_edge[0].v;
1027  k1 = m_pF[m_nface].m_edge[3].v;
1028  if (k1 == 0) k1 = m_pF[m_nface].m_edge[2].v;
1029  if (iabs(k1) > iabs(k2)) iOrder = -1;
1030  }
1031 
1032  do {
1033  k1 = m_pF[iFace].m_edge[iQVertex].v;
1034  kflag = k1;
1035  k1 = iabs(k1);
1036  kface1 = iFace;
1037  kface2 = m_pF[iFace].m_edge[iQVertex].f;
1038  if (iQVertex >= 3 || m_pF[iFace].m_edge[iQVertex+1].v == 0) {
1039  iQVertex = 0;
1040  k2 = iabs(m_pF[iFace].m_edge[iQVertex].v);
1041  iFace++;
1042  }else{
1043  iQVertex++;
1044  k2 = iabs(m_pF[iFace].m_edge[iQVertex].v);
1045  }
1046  } while (iOrder*k1 > iOrder*k2);
1047 
1048  i1 = k1; i2 = k2; edgeFlag = (kflag > 0) ? 1 : 0;
1049  iface1 = kface1; iface2 = kface2;
1050 
1051  if (iFace > m_nface) {
1052  iFace = 1; iOrder = 1;
1053  return false;
1054  }else{
1055  return true;
1056  }
1057 }

◆ GetNextFacet()

bool SbPolyhedron::GetNextFacet ( int &  n,
HVPoint3D *  nodes,
int *  edgeFlags = 0,
HVNormal3D *  normals = 0 
) const

Definition at line 1173 of file SbPolyhedron.cxx.

1184 {
1185  static int iFace = 1;
1186 
1187  if (edgeFlags == 0) {
1188  GetFacet(iFace, n, nodes);
1189  }else if (normals == 0) {
1190  GetFacet(iFace, n, nodes, edgeFlags);
1191  }else{
1192  GetFacet(iFace, n, nodes, edgeFlags, normals);
1193  }
1194 
1195  if (++iFace > m_nface) {
1196  iFace = 1;
1197  return false;
1198  }else{
1199  return true;
1200  }
1201 }

◆ GetNextNormal()

bool SbPolyhedron::GetNextNormal ( HVNormal3D &  normal) const

Definition at line 1255 of file SbPolyhedron.cxx.

1265 {
1266  static int iFace = 1;
1267  normal = GetNormal(iFace);
1268  if (++iFace > m_nface) {
1269  iFace = 1;
1270  return false;
1271  }else{
1272  return true;
1273  }
1274 }

◆ GetNextUnitNormal()

bool SbPolyhedron::GetNextUnitNormal ( HVNormal3D &  normal) const

Definition at line 1276 of file SbPolyhedron.cxx.

1286 {
1287  bool rep = GetNextNormal(normal);
1288  normal.normalize();
1289  return rep;
1290 }

◆ GetNextVertex() [1/2]

bool SbPolyhedron::GetNextVertex ( HVPoint3D &  vertex,
int &  edgeFlag 
) const

Definition at line 957 of file SbPolyhedron.cxx.

968 {
969  int index;
970  bool rep = GetNextVertexIndex(index, edgeFlag);
971  vertex = m_pV[index];
972  return rep;
973 }

◆ GetNextVertex() [2/2]

bool SbPolyhedron::GetNextVertex ( HVPoint3D &  vertex,
int &  edgeFlag,
HVNormal3D &  normal 
) const

Definition at line 975 of file SbPolyhedron.cxx.

987 {
988  static int iFace = 1;
989  static int iNode = 0;
990 
991  if (m_nface == 0) return false; // empty polyhedron
992 
993  int k = m_pF[iFace].m_edge[iNode].v;
994  if (k > 0) { edgeFlag = 1; } else { edgeFlag = -1; k = -k; }
995  vertex = m_pV[k];
996  normal = FindNodeNormal(iFace,k);
997  if (iNode >= 3 || m_pF[iFace].m_edge[iNode+1].v == 0) {
998  iNode = 0;
999  if (++iFace > m_nface) iFace = 1;
1000  return false; // last node
1001  }else{
1002  ++iNode;
1003  return true; // not last node
1004  }
1005 }

◆ GetNextVertexIndex()

bool SbPolyhedron::GetNextVertexIndex ( int &  index,
int &  edgeFlag 
) const

Definition at line 902 of file SbPolyhedron.cxx.

911 {
912  static int iFace = 1;
913  static int iQVertex = 0;
914  int vIndex = m_pF[iFace].m_edge[iQVertex].v;
915 
916  edgeFlag = (vIndex > 0) ? 1 : 0;
917  index = iabs(vIndex);
918 
919  if (iQVertex >= 3 || m_pF[iFace].m_edge[iQVertex+1].v == 0) {
920  iQVertex = 0;
921  if (++iFace > m_nface) iFace = 1;
922  return false; // Last Edge
923  }else{
924  ++iQVertex;
925  return true; // not Last Edge
926  }
927 }

◆ GetNoFacets()

int SbPolyhedron::GetNoFacets ( ) const
inline

Definition at line 296 of file SbPolyhedron.h.

296 { return m_nface; }

◆ GetNormal()

HVNormal3D SbPolyhedron::GetNormal ( int  iFace) const

Definition at line 1203 of file SbPolyhedron.cxx.

1212 {
1213  if (iFace < 1 || iFace > m_nface) {
1214  std::cerr
1215  << "SbPolyhedron::GetNormal: irrelevant index " << iFace
1216  << std::endl;
1217  return HVNormal3D();
1218  }
1219 
1220  int i0 = iabs(m_pF[iFace].m_edge[0].v);
1221  int i1 = iabs(m_pF[iFace].m_edge[1].v);
1222  int i2 = iabs(m_pF[iFace].m_edge[2].v);
1223  int i3 = iabs(m_pF[iFace].m_edge[3].v);
1224  if (i3 == 0) i3 = i0;
1225  return (m_pV[i2] - m_pV[i0]).cross(m_pV[i3] - m_pV[i1]);
1226 }

◆ GetNoVertices()

int SbPolyhedron::GetNoVertices ( ) const
inline

Definition at line 293 of file SbPolyhedron.h.

293 { return m_nvert; }

◆ GetNumberOfRotationSteps()

static int SbPolyhedron::GetNumberOfRotationSteps ( )
inlinestatic

Definition at line 375 of file SbPolyhedron.h.

375 { return s_numberOfRotationSteps; }

◆ GetSurfaceArea()

double SbPolyhedron::GetSurfaceArea ( ) const

Definition at line 1292 of file SbPolyhedron.cxx.

1301 {
1302  double s = 0.;
1303  for (int iFace=1; iFace<=m_nface; iFace++) {
1304  int i0 = iabs(m_pF[iFace].m_edge[0].v);
1305  int i1 = iabs(m_pF[iFace].m_edge[1].v);
1306  int i2 = iabs(m_pF[iFace].m_edge[2].v);
1307  int i3 = iabs(m_pF[iFace].m_edge[3].v);
1308  if (i3 == 0) i3 = i0;
1309  s += ((m_pV[i2] - m_pV[i0]).cross(m_pV[i3] - m_pV[i1])).length();
1310  }
1311  return s/2.;
1312 }

◆ GetUnitNormal()

HVNormal3D SbPolyhedron::GetUnitNormal ( int  iFace) const

Definition at line 1228 of file SbPolyhedron.cxx.

1237 {
1238  if (iFace < 1 || iFace > m_nface) {
1239  std::cerr
1240  << "SbPolyhedron::GetUnitNormal: irrelevant index " << iFace
1241  << std::endl;
1242  return HVNormal3D();
1243  }
1244 
1245  int i0 = iabs(m_pF[iFace].m_edge[0].v);
1246  int i1 = iabs(m_pF[iFace].m_edge[1].v);
1247  int i2 = iabs(m_pF[iFace].m_edge[2].v);
1248  int i3 = iabs(m_pF[iFace].m_edge[3].v);
1249  if (i3 == 0) i3 = i0;
1250  HVNormal3D nm = (m_pV[i2] - m_pV[i0]).cross(m_pV[i3] - m_pV[i1]);
1251  nm.normalize();
1252  return nm;
1253 }

◆ GetVertex()

HVPoint3D SbPolyhedron::GetVertex ( int  index) const

Definition at line 929 of file SbPolyhedron.cxx.

938 {
939  if (index <= 0 || index > m_nvert) {
940  std::cerr
941  << "SbPolyhedron::GetVertex: irrelevant index " << index
942  << std::endl;
943  return HVPoint3D();
944  }
945  return m_pV[index];
946 }

◆ GetVertexFast()

const HVPoint3D & SbPolyhedron::GetVertexFast ( int  index) const

Definition at line 950 of file SbPolyhedron.cxx.

950  { //G.Barrand
951  return m_pV[index];
952 }

◆ GetVolume()

double SbPolyhedron::GetVolume ( ) const

Definition at line 1314 of file SbPolyhedron.cxx.

1323 {
1324  double v = 0.;
1325  for (int iFace=1; iFace<=m_nface; iFace++) {
1326  int i0 = iabs(m_pF[iFace].m_edge[0].v);
1327  int i1 = iabs(m_pF[iFace].m_edge[1].v);
1328  int i2 = iabs(m_pF[iFace].m_edge[2].v);
1329  int i3 = iabs(m_pF[iFace].m_edge[3].v);
1330  HVPoint3D g;
1331  if (i3 == 0) {
1332  i3 = i0;
1333  g = (m_pV[i0]+m_pV[i1]+m_pV[i2]) * (1.0f/3.0f);
1334  }else{
1335  g = (m_pV[i0]+m_pV[i1]+m_pV[i2]+m_pV[i3]) * 0.25f;
1336  }
1337  v += ((m_pV[i2] - m_pV[i0]).cross(m_pV[i3] - m_pV[i1])).dot(g);
1338  }
1339  return v/6.;
1340 }

◆ intersect()

SbPolyhedron SbPolyhedron::intersect ( const SbPolyhedron &  p) const

Definition at line 1860 of file SbPolyhedron.cxx.

1869 {
1870  // rbianchi change
1871  //return processor.execute(OP_INTERSECTION, *this, p);
1872  HEPVis_BooleanProcessor processor; //G.Barrand
1873  int err;
1874  return processor.execute(OP_INTERSECTION, *this, p, err);
1875  //---
1876 }

◆ InvertFacets()

void SbPolyhedron::InvertFacets ( )
protected

Definition at line 819 of file SbPolyhedron.cxx.

828 {
829  if (m_nface <= 0) return;
830  int i, k, nnode, v[4],f[4];
831  for (i=1; i<=m_nface; i++) {
832  nnode = (m_pF[i].m_edge[3].v == 0) ? 3 : 4;
833  for (k=0; k<nnode; k++) {
834  v[k] = (k+1 == nnode) ? m_pF[i].m_edge[0].v : m_pF[i].m_edge[k+1].v;
835  if (v[k] * m_pF[i].m_edge[k].v < 0) v[k] = -v[k];
836  f[k] = m_pF[i].m_edge[k].f;
837  }
838  for (k=0; k<nnode; k++) {
839  m_pF[i].m_edge[nnode-1-k].v = v[k];
840  m_pF[i].m_edge[nnode-1-k].f = f[k];
841  }
842  }
843 }

◆ operator=()

SbPolyhedron & SbPolyhedron::operator= ( const SbPolyhedron &  from)
virtual

Reimplemented in SbPolyhedronGenericTrap, SbPolyhedronArbitrary, SbPolyhedronPolygonXSect, SbPolyhedronTorus, SbPolyhedronSphere, SbPolyhedronPcon, SbPolyhedronPgon, SbPolyhedronTube, SbPolyhedronTubs, SbPolyhedronCone, SbPolyhedronCons, SbPolyhedronPara, SbPolyhedronTrap, SbPolyhedronBox, SbPolyhedronTrd1, and SbPolyhedronTrd2.

Definition at line 161 of file SbPolyhedron.cxx.

170 {
171  if (this == &from) return *this;
172  delete [] m_pV;
173  delete [] m_pF;
174  if (from.m_nvert > 0 && from.m_nface > 0) {
175  m_nvert = from.m_nvert;
176  m_nface = from.m_nface;
177  m_pV = new HVPoint3D[m_nvert + 1];
178  m_pF = new SbFacet[m_nface + 1];
179  int i;
180  for (i=1; i<=m_nvert; i++) m_pV[i] = from.m_pV[i];
181  for (i=1; i<=m_nface; i++) m_pF[i] = from.m_pF[i];
182  }else{
183  m_nvert = 0; m_nface = 0; m_pV = 0; m_pF = 0;
184  }
185  return *this;
186 }

◆ ResetNumberOfRotationSteps()

static void SbPolyhedron::ResetNumberOfRotationSteps ( )
inlinestatic

Definition at line 381 of file SbPolyhedron.h.

381  {
382  s_numberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS;
383  }

◆ RotateAroundZ()

void SbPolyhedron::RotateAroundZ ( int  nstep,
double  phi,
double  dphi,
int  np1,
int  np2,
const double *  z,
double *  r,
int  nodeVis,
int  edgeVis 
)
protected

Definition at line 438 of file SbPolyhedron.cxx.

463 {
464  static double wholeCircle = 2*M_PI;
465 
466  // S E T R O T A T I O N P A R A M E T E R S
467 
468  bool ifWholeCircle = (fabs(dphi-wholeCircle) < perMillion) ?
469  true : false;
470  double delPhi = ifWholeCircle ? wholeCircle : dphi;
471  int nSphi = (nstep > 0) ?
472  nstep : int(delPhi*GetNumberOfRotationSteps()/wholeCircle+.5);
473  if (nSphi == 0) nSphi = 1;
474  int nVphi = ifWholeCircle ? nSphi : nSphi+1;
475  bool ifClosed = np1 > 0 ? false : true;
476 
477  // C O U N T V E R T E C E S
478 
479  int absNp1 = iabs(np1);
480  int absNp2 = iabs(np2);
481  int i1beg = 0;
482  int i1end = absNp1-1;
483  int i2beg = absNp1;
484  int i2end = absNp1+absNp2-1;
485  int i, j, k;
486 
487  for(i=i1beg; i<=i2end; i++) {
488  if (fabs(r[i]) < perMillion) r[i] = 0.;
489  }
490 
491  j = 0; // external nodes
492  for (i=i1beg; i<=i1end; i++) {
493  j += (r[i] == 0.) ? 1 : nVphi;
494  }
495 
496  bool ifSide1 = false; // internal nodes
497  bool ifSide2 = false;
498 
499  if (r[i2beg] != r[i1beg] || z[i2beg] != z[i1beg]) {
500  j += (r[i2beg] == 0.) ? 1 : nVphi;
501  ifSide1 = true;
502  }
503 
504  for(i=i2beg+1; i<i2end; i++) {
505  j += (r[i] == 0.) ? 1 : nVphi;
506  }
507 
508  if (r[i2end] != r[i1end] || z[i2end] != z[i1end]) {
509  if (absNp2 > 1) j += (r[i2end] == 0.) ? 1 : nVphi;
510  ifSide2 = true;
511  }
512 
513  // C O U N T F A C E S
514 
515  k = ifClosed ? absNp1*nSphi : (absNp1-1)*nSphi; // external faces
516 
517  if (absNp2 > 1) { // internal faces
518  for(i=i2beg; i<i2end; i++) {
519  if (r[i] > 0. || r[i+1] > 0.) k += nSphi;
520  }
521 
522  if (ifClosed) {
523  if (r[i2end] > 0. || r[i2beg] > 0.) k += nSphi;
524  }
525  }
526 
527  if (!ifClosed) { // side faces
528  if (ifSide1 && (r[i1beg] > 0. || r[i2beg] > 0.)) k += nSphi;
529  if (ifSide2 && (r[i1end] > 0. || r[i2end] > 0.)) k += nSphi;
530  }
531 
532  if (!ifWholeCircle) { // phi_side faces
533  k += ifClosed ? 2*absNp1 : 2*(absNp1-1);
534  }
535 
536  // A L L O C A T E M E M O R Y
537 
538  AllocateMemory(j, k);
539 
540  // G E N E R A T E V E R T E C E S
541 
542  int *kk;
543  kk = new int[absNp1+absNp2];
544 
545  k = 1;
546  for(i=i1beg; i<=i1end; i++) {
547  kk[i] = k;
548  if (r[i] == 0.) { m_pV[k++] = HVPoint3D(0, 0, z[i]); } else { k += nVphi; }
549  }
550 
551  i = i2beg;
552  if (ifSide1) {
553  kk[i] = k;
554  if (r[i] == 0.) { m_pV[k++] = HVPoint3D(0, 0, z[i]); } else { k += nVphi; }
555  }else{
556  kk[i] = kk[i1beg];
557  }
558 
559  for(i=i2beg+1; i<i2end; i++) {
560  kk[i] = k;
561  if (r[i] == 0.) { m_pV[k++] = HVPoint3D(0, 0, z[i]); } else { k += nVphi; }
562  }
563 
564  if (absNp2 > 1) {
565  i = i2end;
566  if (ifSide2) {
567  kk[i] = k;
568  if (r[i] == 0.) m_pV[k] = HVPoint3D(0, 0, z[i]);
569  }else{
570  kk[i] = kk[i1end];
571  }
572  }
573 
574  double cosPhi, sinPhi;
575 
576  for(j=0; j<nVphi; j++) {
577  cosPhi = cos(phi+j*delPhi/nSphi);
578  sinPhi = sin(phi+j*delPhi/nSphi);
579  for(i=i1beg; i<=i2end; i++) {
580  if (r[i] != 0.) m_pV[kk[i]+j] = HVPoint3D(r[i]*cosPhi,r[i]*sinPhi,z[i]);
581  }
582  }
583 
584  // G E N E R A T E E X T E R N A L F A C E S
585 
586  int v1,v2;
587 
588  k = 1;
589  v2 = ifClosed ? nodeVis : 1;
590  for(i=i1beg; i<i1end; i++) {
591  v1 = v2;
592  if (!ifClosed && i == i1end-1) {
593  v2 = 1;
594  }else{
595  v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 : nodeVis;
596  }
597  RotateEdge(kk[i], kk[i+1], r[i], r[i+1], v1, v2,
598  edgeVis, ifWholeCircle, nSphi, k);
599  }
600  if (ifClosed) {
601  RotateEdge(kk[i1end], kk[i1beg], r[i1end],r[i1beg], nodeVis, nodeVis,
602  edgeVis, ifWholeCircle, nSphi, k);
603  }
604 
605  // G E N E R A T E I N T E R N A L F A C E S
606 
607  if (absNp2 > 1) {
608  v2 = ifClosed ? nodeVis : 1;
609  for(i=i2beg; i<i2end; i++) {
610  v1 = v2;
611  if (!ifClosed && i==i2end-1) {
612  v2 = 1;
613  }else{
614  v2 = (r[i] == r[i+1] && r[i+1] == r[i+2]) ? -1 : nodeVis;
615  }
616  RotateEdge(kk[i+1], kk[i], r[i+1], r[i], v2, v1,
617  edgeVis, ifWholeCircle, nSphi, k);
618  }
619  if (ifClosed) {
620  RotateEdge(kk[i2beg], kk[i2end], r[i2beg], r[i2end], nodeVis, nodeVis,
621  edgeVis, ifWholeCircle, nSphi, k);
622  }
623  }
624 
625  // G E N E R A T E S I D E F A C E S
626 
627  if (!ifClosed) {
628  if (ifSide1) {
629  RotateEdge(kk[i2beg], kk[i1beg], r[i2beg], r[i1beg], 1, 1,
630  -1, ifWholeCircle, nSphi, k);
631  }
632  if (ifSide2) {
633  RotateEdge(kk[i1end], kk[i2end], r[i1end], r[i2end], 1, 1,
634  -1, ifWholeCircle, nSphi, k);
635  }
636  }
637 
638  // G E N E R A T E S I D E F A C E S for the case of incomplete circle
639 
640  if (!ifWholeCircle) {
641 
642  int ii[4], vv[4];
643 
644  if (ifClosed) {
645  for (i=i1beg; i<=i1end; i++) {
646  ii[0] = i;
647  ii[3] = (i == i1end) ? i1beg : i+1;
648  ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
649  ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
650  vv[0] = -1;
651  vv[1] = 1;
652  vv[2] = -1;
653  vv[3] = 1;
654  SetSideFacets(ii, vv, kk, r, dphi, nSphi, k);
655  }
656  }else{
657  for (i=i1beg; i<i1end; i++) {
658  ii[0] = i;
659  ii[3] = i+1;
660  ii[1] = (absNp2 == 1) ? i2beg : ii[0]+absNp1;
661  ii[2] = (absNp2 == 1) ? i2beg : ii[3]+absNp1;
662  vv[0] = (i == i1beg) ? 1 : -1;
663  vv[1] = 1;
664  vv[2] = (i == i1end-1) ? 1 : -1;
665  vv[3] = 1;
666  SetSideFacets(ii, vv, kk, r, dphi, nSphi, k);
667  }
668  }
669  }
670 
671  delete [] kk;
672 
673  if (k-1 != m_nface) {
674  std::cerr
675  << "Polyhedron::RotateAroundZ: number of generated faces ("
676  << k-1 << ") is not equal to the number of allocated faces ("
677  << m_nface << ")"
678  << std::endl;
679  }
680 }

◆ RotateEdge()

void SbPolyhedron::RotateEdge ( int  k1,
int  k2,
double  r1,
double  r2,
int  v1,
int  v2,
int  vEdge,
bool  ifWholeCircle,
int  ns,
int &  kface 
)
protected

Definition at line 306 of file SbPolyhedron.cxx.

327 {
328  if (r1 == 0. && r2 == 0) return;
329 
330  int i;
331  int i1 = k1;
332  int i2 = k2;
333  int ii1 = ifWholeCircle ? i1 : i1+ns;
334  int ii2 = ifWholeCircle ? i2 : i2+ns;
335  int vv = ifWholeCircle ? vEdge : 1;
336 
337  if (ns == 1) {
338  if (r1 == 0.) {
339  m_pF[kface++] = SbFacet(i1,0, v2*i2,0, (i2+1),0);
340  }else if (r2 == 0.) {
341  m_pF[kface++] = SbFacet(i1,0, i2,0, v1*(i1+1),0);
342  }else{
343  m_pF[kface++] = SbFacet(i1,0, v2*i2,0, (i2+1),0, v1*(i1+1),0);
344  }
345  }else{
346  if (r1 == 0.) {
347  m_pF[kface++] = SbFacet(vv*i1,0, v2*i2,0, vEdge*(i2+1),0);
348  for (i2++,i=1; i<ns-1; i2++,i++) {
349  m_pF[kface++] = SbFacet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0);
350  }
351  m_pF[kface++] = SbFacet(vEdge*i1,0, v2*i2,0, vv*ii2,0);
352  }else if (r2 == 0.) {
353  m_pF[kface++] = SbFacet(vv*i1,0, vEdge*i2,0, v1*(i1+1),0);
354  for (i1++,i=1; i<ns-1; i1++,i++) {
355  m_pF[kface++] = SbFacet(vEdge*i1,0, vEdge*i2,0, v1*(i1+1),0);
356  }
357  m_pF[kface++] = SbFacet(vEdge*i1,0, vv*i2,0, v1*ii1,0);
358  }else{
359  m_pF[kface++] = SbFacet(vv*i1,0, v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
360  for (i1++,i2++,i=1; i<ns-1; i1++,i2++,i++) {
361  m_pF[kface++] = SbFacet(vEdge*i1,0, v2*i2,0, vEdge*(i2+1),0,v1*(i1+1),0);
362  }
363  m_pF[kface++] = SbFacet(vEdge*i1,0, v2*i2,0, vv*ii2,0, v1*ii1,0);
364  }
365  }
366 }

◆ SetNumberOfRotationSteps()

void SbPolyhedron::SetNumberOfRotationSteps ( int  n)
static

Definition at line 245 of file SbPolyhedron.cxx.

254 {
255  const int nMin = 3;
256  if (n < nMin) {
257  std::cerr
258  << "SbPolyhedron::SetNumberOfRotationSteps: attempt to set the\n"
259  << "number of steps per circle < " << nMin << "; forced to " << nMin
260  << std::endl;
261  s_numberOfRotationSteps = nMin;
262  }else{
263  s_numberOfRotationSteps = n;
264  }
265 }

◆ SetReferences()

void SbPolyhedron::SetReferences ( )
protected

Definition at line 682 of file SbPolyhedron.cxx.

691 {
692  if (m_nface <= 0) return;
693 
694  struct edgeListMember {
695  edgeListMember *next;
696  int v2;
697  int iface;
698  int iedge;
699  } *edgeList, *freeList, **headList;
700 
701 
702  // A L L O C A T E A N D I N I T I A T E L I S T S
703 
704  edgeList = new edgeListMember[2*m_nface];
705  headList = new edgeListMember*[m_nvert];
706 
707  int i;
708  for (i=0; i<m_nvert; i++) {
709  headList[i] = 0;
710  }
711  freeList = edgeList;
712  for (i=0; i<2*m_nface-1; i++) {
713  edgeList[i].next = &edgeList[i+1];
714  }
715  edgeList[2*m_nface-1].next = 0;
716 
717  // L O O P A L O N G E D G E S
718 
719  int iface, iedge, nedge, i1, i2, k1, k2;
720  edgeListMember *prev, *cur;
721 
722  for(iface=1; iface<=m_nface; iface++) {
723  nedge = (m_pF[iface].m_edge[3].v == 0) ? 3 : 4;
724  for (iedge=0; iedge<nedge; iedge++) {
725  i1 = iedge;
726  i2 = (iedge < nedge-1) ? iedge+1 : 0;
727  i1 = iabs(m_pF[iface].m_edge[i1].v);
728  i2 = iabs(m_pF[iface].m_edge[i2].v);
729  k1 = (i1 < i2) ? i1 : i2; // k1 = ::min(i1,i2);
730  k2 = (i1 > i2) ? i1 : i2; // k2 = ::max(i1,i2);
731 
732  // check head of the List corresponding to k1
733  cur = headList[k1];
734  if (cur == 0) {
735  headList[k1] = freeList;
736  freeList = freeList->next;
737  cur = headList[k1];
738  cur->next = 0;
739  cur->v2 = k2;
740  cur->iface = iface;
741  cur->iedge = iedge;
742  continue;
743  }
744 
745  if (cur->v2 == k2) {
746  headList[k1] = cur->next;
747  cur->next = freeList;
748  freeList = cur;
749  m_pF[iface].m_edge[iedge].f = cur->iface;
750  m_pF[cur->iface].m_edge[cur->iedge].f = iface;
751  i1 = (m_pF[iface].m_edge[iedge].v < 0) ? -1 : 1;
752  i2 = (m_pF[cur->iface].m_edge[cur->iedge].v < 0) ? -1 : 1;
753  if (i1 != i2) {
754  std::cerr
755  << "Polyhedron::SetReferences: different edge visibility "
756  << iface << "/" << iedge << "/"
757  << m_pF[iface].m_edge[iedge].v << " and "
758  << cur->iface << "/" << cur->iedge << "/"
759  << m_pF[cur->iface].m_edge[cur->iedge].v
760  << std::endl;
761  }
762  continue;
763  }
764 
765  // check List itself
766  for (;;) {
767  prev = cur;
768  cur = prev->next;
769  if (cur == 0) {
770  prev->next = freeList;
771  freeList = freeList->next;
772  cur = prev->next;
773  cur->next = 0;
774  cur->v2 = k2;
775  cur->iface = iface;
776  cur->iedge = iedge;
777  break;
778  }
779 
780  if (cur->v2 == k2) {
781  prev->next = cur->next;
782  cur->next = freeList;
783  freeList = cur;
784  m_pF[iface].m_edge[iedge].f = cur->iface;
785  m_pF[cur->iface].m_edge[cur->iedge].f = iface;
786  i1 = (m_pF[iface].m_edge[iedge].v < 0) ? -1 : 1;
787  i2 = (m_pF[cur->iface].m_edge[cur->iedge].v < 0) ? -1 : 1;
788  if (i1 != i2) {
789  std::cerr
790  << "Polyhedron::SetReferences: different edge visibility "
791  << iface << "/" << iedge << "/"
792  << m_pF[iface].m_edge[iedge].v << " and "
793  << cur->iface << "/" << cur->iedge << "/"
794  << m_pF[cur->iface].m_edge[cur->iedge].v
795  << std::endl;
796  }
797  break;
798  }
799  }
800  }
801  }
802 
803  // C H E C K T H A T A L L L I S T S A R E E M P T Y
804 
805  for (i=0; i<m_nvert; i++) {
806  if (headList[i] != 0) {
807  std::cerr
808  << "Polyhedron::SetReferences: List " << i << " is not empty"
809  << std::endl;
810  }
811  }
812 
813  // F R E E M E M O R Y
814 
815  delete [] edgeList;
816  delete [] headList;
817 }

◆ SetSideFacets()

void SbPolyhedron::SetSideFacets ( int  ii[4],
int  vv[4],
int *  kk,
double *  r,
double  dphi,
int  ns,
int &  kface 
)
protected

Definition at line 368 of file SbPolyhedron.cxx.

387 {
388  int k1, k2, k3, k4;
389  if (fabs(dphi-M_PI) < perMillion) { // half a circle
390  for (int i=0; i<4; i++) {
391  k1 = ii[i];
392  k2 = (i == 3) ? ii[0] : ii[i+1];
393  if (r[k1] == 0. && r[k2] == 0.) vv[i] = -1;
394  }
395  }
396 
397  if (ii[1] == ii[2]) {
398  k1 = kk[ii[0]];
399  k2 = kk[ii[2]];
400  k3 = kk[ii[3]];
401  m_pF[kface++] = SbFacet(vv[0]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
402  if (r[ii[0]] != 0.) k1 += ns;
403  if (r[ii[2]] != 0.) k2 += ns;
404  if (r[ii[3]] != 0.) k3 += ns;
405  m_pF[kface++] = SbFacet(vv[2]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
406  }else if (kk[ii[0]] == kk[ii[1]]) {
407  k1 = kk[ii[0]];
408  k2 = kk[ii[2]];
409  k3 = kk[ii[3]];
410  m_pF[kface++] = SbFacet(vv[1]*k1,0, vv[2]*k2,0, vv[3]*k3,0);
411  if (r[ii[0]] != 0.) k1 += ns;
412  if (r[ii[2]] != 0.) k2 += ns;
413  if (r[ii[3]] != 0.) k3 += ns;
414  m_pF[kface++] = SbFacet(vv[2]*k3,0, vv[1]*k2,0, vv[3]*k1,0);
415  }else if (kk[ii[2]] == kk[ii[3]]) {
416  k1 = kk[ii[0]];
417  k2 = kk[ii[1]];
418  k3 = kk[ii[2]];
419  m_pF[kface++] = SbFacet(vv[0]*k1,0, vv[1]*k2,0, vv[3]*k3,0);
420  if (r[ii[0]] != 0.) k1 += ns;
421  if (r[ii[1]] != 0.) k2 += ns;
422  if (r[ii[2]] != 0.) k3 += ns;
423  m_pF[kface++] = SbFacet(vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
424  }else{
425  k1 = kk[ii[0]];
426  k2 = kk[ii[1]];
427  k3 = kk[ii[2]];
428  k4 = kk[ii[3]];
429  m_pF[kface++] = SbFacet(vv[0]*k1,0, vv[1]*k2,0, vv[2]*k3,0, vv[3]*k4,0);
430  if (r[ii[0]] != 0.) k1 += ns;
431  if (r[ii[1]] != 0.) k2 += ns;
432  if (r[ii[2]] != 0.) k3 += ns;
433  if (r[ii[3]] != 0.) k4 += ns;
434  m_pF[kface++] = SbFacet(vv[2]*k4,0, vv[1]*k3,0, vv[0]*k2,0, vv[3]*k1,0);
435  }
436 }

◆ subtract()

SbPolyhedron SbPolyhedron::subtract ( const SbPolyhedron &  p) const

Definition at line 1878 of file SbPolyhedron.cxx.

1887 {
1888  // rbianchi change
1889  //return processor.execute(OP_SUBTRACTION, *this, p);
1890  HEPVis_BooleanProcessor processor; //G.Barrand
1891  int err;
1892  return processor.execute(OP_SUBTRACTION, *this, p, err);
1893  //---
1894 }

◆ Transform()

SbPolyhedron & SbPolyhedron::Transform ( const HEPVis::SbRotation &  rot,
const SbVec3d &  trans 
)

Definition at line 878 of file SbPolyhedron.cxx.

882 {
883  if (m_nvert > 0) {
884  SbVec3d tmp;
885  for (int i=1; i<=m_nvert; i++) {
886  rotation.multVec(m_pV[i],tmp);
887  m_pV[i] = tmp+translation;
888  }
889  SbVec3d x; rotation.multVec(SbVec3d(1,0,0),x);
890  SbVec3d y; rotation.multVec(SbVec3d(0,1,0),y);
891  SbVec3d z; rotation.multVec(SbVec3d(0,0,1),z);
892  if ((x.cross(y)).dot(z) < 0) InvertFacets();
893  }
894  return *this;
895 }

Friends And Related Function Documentation

◆ operator<<

std::ostream& operator<< ( std::ostream &  ostr,
const SbPolyhedron &  ph 
)
friend

Definition at line 125 of file SbPolyhedron.cxx.

125  {
126  ostr << std::endl;
127  ostr << "Nverteces=" << ph.m_nvert << ", Nfacets=" << ph.m_nface << std::endl;
128  int i;
129  for (i=1; i<=ph.m_nvert; i++) {
130  ostr << "xyz(" << i << ")="
131  << ph.m_pV[i][0] << ' ' << ph.m_pV[i][1] << ' ' << ph.m_pV[i][2]
132  << std::endl;
133  }
134  for (i=1; i<=ph.m_nface; i++) {
135  ostr << "face(" << i << ")=" << ph.m_pF[i] << std::endl;
136  }
137  return ostr;
138 }

Member Data Documentation

◆ m_nface

int SbPolyhedron::m_nface
protected

Definition at line 238 of file SbPolyhedron.h.

◆ m_nvert

int SbPolyhedron::m_nvert
protected

Definition at line 238 of file SbPolyhedron.h.

◆ m_pF

SbFacet* SbPolyhedron::m_pF
protected

Definition at line 240 of file SbPolyhedron.h.

◆ m_pV

HVPoint3D* SbPolyhedron::m_pV
protected

Definition at line 239 of file SbPolyhedron.h.

◆ s_numberOfRotationSteps

int SbPolyhedron::s_numberOfRotationSteps = DEFAULT_NUMBER_OF_STEPS
staticprivate

Definition at line 235 of file SbPolyhedron.h.

The documentation for this class was generated from the following files:
InDetVertexTruthMatchUtils::DUMMY
@ DUMMY
Definition: InDetVertexTruthMatchUtils.h:25
SbPolyhedron::m_pF
SbFacet * m_pF
Definition: SbPolyhedron.h:240
beamspotman.r
def r
Definition: beamspotman.py:672
SbPolyhedron::FindNodeNormal
HVNormal3D FindNodeNormal(int iFace, int iNode) const
Definition: SbPolyhedron.cxx:217
SbPolyhedron::s_numberOfRotationSteps
static int s_numberOfRotationSteps
Definition: SbPolyhedron.h:235
SbFacet::m_edge
struct SbFacet::@64 m_edge[4]
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
beamspotman.cur
def cur
Definition: beamspotman.py:667
index
Definition: index.py:1
make_hlt_rep.rep
rep
Definition: make_hlt_rep.py:32
OP_INTERSECTION
#define OP_INTERSECTION
Definition: BooleanProcessor.h:90
SbPolyhedron::GetNextVertexIndex
bool GetNextVertexIndex(int &index, int &edgeFlag) const
Definition: SbPolyhedron.cxx:902
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
SbPolyhedron::GetNextEdgeIndeces
bool GetNextEdgeIndeces(int &i1, int &i2, int &edgeFlag, int &iface1, int &iface2) const
Definition: SbPolyhedron.cxx:1007
SbPolyhedron::GetFacet
void GetFacet(int iFace, int &n, int *iNodes, int *edgeFlags=0, int *iFaces=0) const
Definition: SbPolyhedron.cxx:1117
M_PI
#define M_PI
Definition: ActiveFraction.h:11
perMillion
#define perMillion
Definition: SbPolyhedron.cxx:16
DEFAULT_NUMBER_OF_STEPS
#define DEFAULT_NUMBER_OF_STEPS
Definition: SbPolyhedron.h:214
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
SbFacet::f
int f
Definition: SbPolyhedron.h:222
x
#define x
iabs
int iabs(int a)
Definition: SbPolyhedron.cxx:22
SbPolyhedron::GetNormal
HVNormal3D GetNormal(int iFace) const
Definition: SbPolyhedron.cxx:1203
SbPolyhedron::GetNextNormal
bool GetNextNormal(HVNormal3D &normal) const
Definition: SbPolyhedron.cxx:1255
python.changerun.kk
list kk
Definition: changerun.py:39
OP_UNION
#define OP_UNION
Definition: BooleanProcessor.h:89
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:183
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
beamspotman.n
n
Definition: beamspotman.py:727
xAOD::rotation
rotation
Definition: TrackSurface_v1.cxx:15
SbPolyhedron::AllocateMemory
void AllocateMemory(int Nvert, int Nface)
Definition: SbPolyhedron.cxx:267
SbPolyhedron::GetNumberOfRotationSteps
static int GetNumberOfRotationSteps()
Definition: SbPolyhedron.h:375
Trk::RIGHT
@ RIGHT
the drift radius is positive (see Trk::AtaStraightLine)
Definition: DriftCircleSide.h:22
SbPolyhedron::GetUnitNormal
HVNormal3D GetUnitNormal(int iFace) const
Definition: SbPolyhedron.cxx:1228
hist_file_dump.f
f
Definition: hist_file_dump.py:140
SbPolyhedron::SetSideFacets
void SetSideFacets(int ii[4], int vv[4], int *kk, double *r, double dphi, int ns, int &kface)
Definition: SbPolyhedron.cxx:368
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
dot.dot
def dot(G, fn, nodesToHighlight=[])
Definition: dot.py:5
SbPolyhedron::m_pV
HVPoint3D * m_pV
Definition: SbPolyhedron.h:239
SbFacet::v
int v
Definition: SbPolyhedron.h:222
OP_SUBTRACTION
#define OP_SUBTRACTION
Definition: BooleanProcessor.h:91
SbPolyhedron::FindNeighbour
int FindNeighbour(int iFace, int iNode, int iOrder) const
Definition: SbPolyhedron.cxx:189
HVNormal3D
HVPoint3D HVNormal3D
Definition: SbPolyhedron.h:199
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.index
string index
Definition: DeMoScan.py:362
SbPolyhedron::m_nface
int m_nface
Definition: SbPolyhedron.h:238
CalibCoolCompareRT.nm
nm
Definition: CalibCoolCompareRT.py:109
y
#define y
SbPolyhedron::InvertFacets
void InvertFacets()
Definition: SbPolyhedron.cxx:819
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
SbPolyhedron::RotateEdge
void RotateEdge(int k1, int k2, double r1, double r2, int v1, int v2, int vEdge, bool ifWholeCircle, int ns, int &kface)
Definition: SbPolyhedron.cxx:306
Trk::LEFT
@ LEFT
the drift radius is negative (see Trk::AtaStraightLine)
Definition: DriftCircleSide.h:20
SbFacet
Definition: SbPolyhedron.h:217
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
PlotCalibFromCool.vv
vv
Definition: PlotCalibFromCool.py:716
length
double length(const pvec &v)
Definition: FPGATrackSimLLPDoubletHoughTransformTool.cxx:26
HVPoint3D
Definition: SbPolyhedron.h:188
SbPolyhedron::m_nvert
int m_nvert
Definition: SbPolyhedron.h:238
python.SystemOfUnits.ns
float ns
Definition: SystemOfUnits.py:146
fitman.k
k
Definition: fitman.py:528
Generated on Thu Oct 30 2025 21:40:20 for ATLAS Offline Software by   doxygen 1.8.18