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

SoCons - Inventor version of the G4Cons Geant Geometry entity. More...

#include <SoCons.h>

Inheritance diagram for SoCons:
Collaboration diagram for SoCons:

Public Member Functions

 SoCons ()
 Constructor, required. More...
 
virtual void generateAlternateRep ()
 Generate AlternateRep, required. More...
 
virtual void clearAlternateRep ()
 We better be able to clear it, too! More...
 

Static Public Member Functions

static void initClass ()
 Class Initializer, required. More...
 

Public Attributes

SoSFFloat fRmin1
 Inside radius at -fDz. More...
 
SoSFFloat fRmin2
 Inside radius at +fDz. More...
 
SoSFFloat fRmax1
 Outside radius at -fDz. More...
 
SoSFFloat fRmax2
 Outside radius at +fDz. More...
 
SoSFFloat fDz
 Half-length along Z. More...
 
SoSFFloat fSPhi
 Starting angle, in radians. More...
 
SoSFFloat fDPhi
 Delta-angle, in radians. More...
 
SoSFBool smoothDraw
 An Inventor option - slightly better render, worse performance. More...
 
SoSFInt32 pOverrideNPhi
 Override number of phi subdivision used for rendering shape (i.e. More...
 
SoSFNode alternateRep
 Alternate rep required - for use by users without HEPVis shared objects. More...
 

Protected Member Functions

virtual void computeBBox (SoAction *action, SbBox3f &box, SbVec3f &center)
 compute bounding Box, required More...
 
virtual void generatePrimitives (SoAction *action)
 Generate Primitives, required. More...
 
virtual SoChildList * getChildren () const
 GetChildList, required whenever the class has hidden children. More...
 
virtual ~SoCons ()
 Destructor, required. More...
 

Private Member Functions

 SO_NODE_HEADER (SoCons)
 
void generateChildren ()
 Generate Children. More...
 
void updateChildren ()
 Used to modify hidden children when a data field is changed. More...
 
void inc (double &sinPhi, double &cosPhi, double sinDeltaPhi, double cosDeltaPhi) const
 help with trigonometry. increments sines an cosines by an angle. More...
 

Private Attributes

SoChildList * m_children
 ChildList. Required whenever the class has hidden children. More...
 

Detailed Description

SoCons - Inventor version of the G4Cons Geant Geometry entity.

Node: SoCons

Description: The Inventor version of the G4Cons Geant Geometry entity

Author: Joe Boudreau Nov 11 1996

The documentation from Geant says:

A G4Cons is, in the general case, a Phi segment of a cone, with half-length fDz, inner and outer radii specified at -fDz and +fDz. The Phi segment is described by a starting fSPhi angle, and the +fDPhi delta angle for the shape. If the delta angle is >=2*M_PI, the shape is treated as continuous in Phi

Member Data: 

 fRmin1  inside radius at  -fDz
 fRmin2  inside radius at  +fDz
 fRmax1  outside radius at -fDz
 fRmax2  outside radius at +fDz
 fDz     half length in z

 fSPhi   starting angle of the segment in radians
 fDPhi   delta angle of the segment in radians

Definition at line 50 of file SoCons.h.

Constructor & Destructor Documentation

◆ SoCons()

SoCons::SoCons ( )

Constructor, required.

Definition at line 37 of file SoCons.cxx.

37  {
38  // This statement is required
39  SO_NODE_CONSTRUCTOR(SoCons);
40 
41  // Data fields are initialized like this:
42  SO_NODE_ADD_FIELD(fRmin1, (0.0));
43  SO_NODE_ADD_FIELD(fRmin2, (0.0));
44  SO_NODE_ADD_FIELD(fRmax1, (1.0));
45  SO_NODE_ADD_FIELD(fRmax2, (1.0));
46  SO_NODE_ADD_FIELD(fDz, (10.0));
47  SO_NODE_ADD_FIELD(fSPhi, (0.0));
48  SO_NODE_ADD_FIELD(fDPhi, ((float)(2*M_PI)));
49  SO_NODE_ADD_FIELD(smoothDraw, (TRUE));
50  SO_NODE_ADD_FIELD(pOverrideNPhi, (0));
51  SO_NODE_ADD_FIELD(alternateRep, (NULL));
52  m_children = new SoChildList(this);
53 
54  setNodeType(EXTENSION);
55 }

◆ ~SoCons()

SoCons::~SoCons ( )
protectedvirtual

Destructor, required.

Definition at line 58 of file SoCons.cxx.

58  {
59  delete m_children;
60 }

Member Function Documentation

◆ clearAlternateRep()

void SoCons::clearAlternateRep ( )
virtual

We better be able to clear it, too!

Definition at line 443 of file SoCons.cxx.

443  {
444  alternateRep.setValue(NULL);
445 }

◆ computeBBox()

void SoCons::computeBBox ( SoAction *  action,
SbBox3f &  box,
SbVec3f &  center 
)
protectedvirtual

compute bounding Box, required

Definition at line 243 of file SoCons.cxx.

243  {
244  RevolutionSurfaceUtil::setBBoxPars(fSPhi.getValue(), fDPhi.getValue(),
245  std::min(fRmin1.getValue(),fRmin1.getValue()),
246  std::max(fRmax1.getValue(),fRmax1.getValue()),
247  -fDz.getValue(),fDz.getValue(),
248  box, center );
249 }

◆ generateAlternateRep()

void SoCons::generateAlternateRep ( )
virtual

Generate AlternateRep, required.

Generating an alternate representation must be done upon users request. It allows an Inventor program to read back the file without requiring this code to be dynamically linked. If the users expects that this code will be dynamically linked, he need not invoke this method.

Definition at line 432 of file SoCons.cxx.

432  {
433 
434  // This routine sets the alternate representation to the child
435  // list of this mode.
436 
437  if (m_children->getLength() == 0) generateChildren();
438  updateChildren();
439  alternateRep.setValue((SoSeparator *) ( *m_children)[0]);
440 }

◆ generateChildren()

void SoCons::generateChildren ( )
private

Generate Children.

Used to create the hidden children. Required whenever the node has hidden children.

Definition at line 408 of file SoCons.cxx.

408  {
409 
410  // This routines creates one SoSeparator, one SoCoordinate3, and
411  // one SoLineSet, and puts it in the child list. This is done only
412  // once, whereas redrawing the position of the coordinates occurs each
413  // time an update is necessary, in the updateChildren routine.
414 
415  assert(m_children->getLength() ==0);
416  SoSeparator *sep = new SoSeparator();
417  SoCoordinate3 *theCoordinates = new SoCoordinate3();
418  SoNormal *theNormals = new SoNormal();
419  SoNormalBinding *theNormalBinding = new SoNormalBinding();
420  SoIndexedFaceSet *theFaceSet = new SoIndexedFaceSet();
421  //
422  // This line costs some in render quality! but gives speed.
423  //
424  sep->addChild(theCoordinates);
425  sep->addChild(theNormals);
426  sep->addChild(theNormalBinding);
427  sep->addChild(theFaceSet);
428  m_children->append(sep);
429 }

◆ generatePrimitives()

void SoCons::generatePrimitives ( SoAction *  action)
protectedvirtual

Generate Primitives, required.

Definition at line 73 of file SoCons.cxx.

73  {
74  // This variable is used to store each vertex
75  SoPrimitiveVertex pv;
76 
77  // Access the stat from the action
78  SoState *state = action->getState();
79  if (!state)
80  return;
81 
82  // See if we have to use a texture coordinate function,
83  // rather than generating explicit texture coordinates.
84  SbBool useTexFunction=
85  (SoTextureCoordinateElement::getType(state) ==
86  SoTextureCoordinateElement::FUNCTION);
87 
88  // If we need to generate texture coordinates with a function,
89  // we'll need an SoGLTextureCoordinateElement. Otherwise, we'll
90  // set up the coordinates directly.
91  const SoTextureCoordinateElement *tce = NULL;
92  SbVec4f texCoord;
93  if (useTexFunction) {
94  tce = SoTextureCoordinateElement::getInstance(state);
95  } else {
96  texCoord[2] = 0.0;
97  texCoord[3] = 1.0;
98  }
99  SbVec3f point, normal;
100 
102  //-----------------------------------------------------
103 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
104  point.setValue((float)(x),(float)(y),(float)(z)); \
105  normal.setValue((float)(nx),(float)(ny),(float)(nz)); \
106  if (useTexFunction) { \
107  texCoord=tce->get(point,normal); \
108  } else { \
109  texCoord[0]=(float)(s); \
110  texCoord[1]=(float)(t); \
111  } \
112  pv.setPoint(point); \
113  pv.setNormal(normal); \
114  pv.setTextureCoords(texCoord); \
115  shapeVertex(&pv);
116  //-----------------------------------------------------
118 
119  int NPHI = RevolutionSurfaceUtil::nphiDivisions( fDPhi.getValue(), this->getComplexityValue(action), pOverrideNPhi.getValue() );
120 
121  double deltaPhi = fDPhi.getValue()/NPHI;
122  double phi0 = fSPhi.getValue();
123  double phi1 = phi0 + fDPhi.getValue();
124  double rMax1 = fRmax1.getValue();
125  double rMin1 = fRmin1.getValue();
126  double rMax2 = fRmax2.getValue();
127  double rMin2 = fRmin2.getValue();
128  double zMax = fDz.getValue();
129  double zMin = -zMax;
130  double cosPhi0 = cos(phi0);
131  double sinPhi0 = sin(phi0);
132  double cosPhi1 = cos(phi1);
133  double sinPhi1 = sin(phi1);
134  double cosDeltaPhi = cos(deltaPhi);
135  double sinDeltaPhi = sin(deltaPhi);
136  //
137  // The outer surface!
138  //
139  int i;
140  double sinPhi=sinPhi0;
141  double cosPhi=cosPhi0;
142 
143  {
144  double dR =rMax2-rMax1;
145  double dZ =zMax-zMin;
146  double cosTheta = -dR/sqrt(dR*dR+dZ*dZ);
147  double sinTheta = dZ/sqrt(dR*dR+dZ*dZ);
148 
149  beginShape(action,TRIANGLE_STRIP);
150  for (i = 0; i<=NPHI; i++) {
151  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,0.0,0.0,sinTheta*cosPhi,sinTheta*sinPhi,cosTheta);
152  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,sinTheta*cosPhi,sinTheta*sinPhi,cosTheta);
153  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
154  }
155  endShape();
156  }
157  //
158  // The inner surface!
159  //
160 
161  sinPhi=sinPhi0;
162  cosPhi=cosPhi0;
163 
164  {
165  double dR =rMin2-rMin1;
166  double dZ =zMax-zMin;
167  double cosTheta = -dR/sqrt(dR*dR+dZ*dZ);
168  double sinTheta = dZ/sqrt(dR*dR+dZ*dZ);
169  beginShape(action,TRIANGLE_STRIP);
170  for (i = 0; i<=NPHI; i++) {
171  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,0.0,0.0,-sinTheta*cosPhi,-sinTheta*sinPhi,-cosTheta);
172  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,1.0,1.0,-sinTheta*cosPhi,-sinTheta*sinPhi,-cosTheta);
173  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
174  }
175  endShape();
176  }
177  if (fabs(deltaPhi)<2.0*M_PI) {
178  //
179  // The end
180  //
181  beginShape(action,TRIANGLE_STRIP);
182  sinPhi=sinPhi0;
183  cosPhi=cosPhi0;
184  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,0.0,0.0,sinPhi,-cosPhi,0);
185  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,sinPhi,-cosPhi,0);
186  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,1.0,0.0,sinPhi,-cosPhi,0);
187  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,0.0,1.0,sinPhi,-cosPhi,0);
188  endShape();
189  //
190  // The other end
191  //
192  beginShape(action,TRIANGLE_STRIP);
193  sinPhi=sinPhi1;
194  cosPhi=cosPhi1;
195  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi, zMax,0.0,0.0,-sinPhi,+cosPhi,0);
196  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi, zMin,1.0,1.0,-sinPhi,+cosPhi,0);
197  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi, zMax,1.0,0.0,-sinPhi,+cosPhi,0);
198  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi, zMin,0.0,1.0,-sinPhi,+cosPhi,0);
199  endShape();
200  }
201 
202  //
203  // The outer surface at z=+PDZ
204  //
205  beginShape(action,TRIANGLE_STRIP);
206  sinPhi=sinPhi0;
207  cosPhi=cosPhi0;
208  for (i = 0; i<=NPHI; i++) {
209  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,0.0,0.0,0,0,1);
210  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,1.0,1.0,0,0,1);
211  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
212  }
213  endShape();
214  //
215  // The outer surface at z=-PDZ
216  //
217  beginShape(action,TRIANGLE_STRIP);
218  sinPhi=sinPhi0;
219  cosPhi=cosPhi0;
220  for (i = 0; i<=NPHI; i++) {
221  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,0.0,0.0,0,0,-1);
222  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,0,0,-1);
223  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
224  }
225  endShape();
226 
227  if (state&&state->isElementEnabled(SoGLCacheContextElement::getClassStackIndex())) {
228  //Encourage auto caching
229  SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DO_AUTO_CACHE);
230 #if ((COIN_MAJOR_VERSION>=3)||((COIN_MAJOR_VERSION==2)&&(COIN_MINOR_VERSION>=5)))
231  SoGLCacheContextElement::incNumShapes(state);
232 #endif
233  }
234 }

◆ getChildren()

SoChildList * SoCons::getChildren ( ) const
protectedvirtual

GetChildList, required whenever the class has hidden children.

Definition at line 237 of file SoCons.cxx.

237  {
238  return m_children;
239 }

◆ inc()

void SoCons::inc ( double &  sinPhi,
double &  cosPhi,
double  sinDeltaPhi,
double  cosDeltaPhi 
) const
inlineprivate

help with trigonometry. increments sines an cosines by an angle.

Definition at line 169 of file SoCons.h.

169  {
170  double oldSin=sinPhi,oldCos=cosPhi;
171  sinPhi = oldSin*cosDeltaPhi+oldCos*sinDeltaPhi;
172  cosPhi = oldCos*cosDeltaPhi-oldSin*sinDeltaPhi;
173  }

◆ initClass()

void SoCons::initClass ( )
static

Class Initializer, required.

Definition at line 63 of file SoCons.cxx.

64 {
65  [[maybe_unused]] static const bool didInit = [&]() {
66  SO_NODE_INIT_CLASS(SoCons,SoShape,"Shape");
67  return true;
68  }();
69 }

◆ SO_NODE_HEADER()

SoCons::SO_NODE_HEADER ( SoCons  )
private

◆ updateChildren()

void SoCons::updateChildren ( )
private

Used to modify hidden children when a data field is changed.

Required whenever the class has hidden children.

Definition at line 255 of file SoCons.cxx.

255  {
256 
257 
258  // Redraw the G4Cons....
259 
260  assert(m_children->getLength()==1);
261  SoSeparator *sep = (SoSeparator *) ( *m_children)[0];
262  SoCoordinate3 *theCoordinates = (SoCoordinate3 *) ( sep->getChild(0));
263  SoNormal *theNormals = (SoNormal *) ( sep->getChild(1));
264  SoNormalBinding *theNormalBinding = (SoNormalBinding *) ( sep->getChild(2));
265  SoIndexedFaceSet *theFaceSet = (SoIndexedFaceSet *) ( sep->getChild(3));
266 
267  const int NPHI=96, NPOINTS=2*(2*NPHI+2), NFACES=4*NPHI+2, NINDICES = NFACES*5;
268  float points[NPOINTS][3], normals[NFACES][3];
269 #ifdef INVENTOR2_0
270  static long indices[NINDICES];
271 #else
272  static int32_t indices[NINDICES];
273 #endif
274  static int init=0;
275  double phi, pp, DeltaPhi;
276 
277  // Indices need to be generated once! This is here to keep it close to the point
278  // generation, since otherwise it will be confusing.
279 
280  int i;
281  if (!init) {
282  init = 1;
283  // Outer face
284  for (i = 0; i< NPHI; i++) {
285  // 0 1 3 2;
286  indices[5*i+0] = 2*i+0;
287  indices[5*i+1] = 2*i+1;
288  indices[5*i+2] = 2*i+3;
289  indices[5*i+3] = 2*i+2;
290  indices[5*i+4] = SO_END_FACE_INDEX;
291  }
292  // the inner face
293  for (i=0;i<NPHI;i++) {
294  indices[5*1*NPHI + 5*i+0] = 2*NPHI+2 + 2*i+0;
295  indices[5*1*NPHI + 5*i+1] = 2*NPHI+2 + 2*i+1;
296  indices[5*1*NPHI + 5*i+2] = 2*NPHI+2 + 2*i+3;
297  indices[5*1*NPHI + 5*i+3] = 2*NPHI+2 + 2*i+2;
298  indices[5*1*NPHI + 5*i+4] = SO_END_FACE_INDEX;
299  }
300  // the top side
301  for (i=0;i<NPHI;i++) {
302  indices[5*2*NPHI + 5*i+0] = 2*i+0;
303  indices[5*2*NPHI + 5*i+1] = 2*i+2;
304  indices[5*2*NPHI + 5*i+2] = NPOINTS - (2*i+4);
305  indices[5*2*NPHI + 5*i+3] = NPOINTS - (2*i+2);
306  indices[5*2*NPHI + 5*i+4] = SO_END_FACE_INDEX;
307  }
308  // the bottom side
309  for (i=0;i<NPHI;i++) {
310  indices[5*3*NPHI + 5*i+0] = 2*i+1;
311  indices[5*3*NPHI + 5*i+1] = NPOINTS - (2*i+1);
312  indices[5*3*NPHI + 5*i+2] = NPOINTS - (2*i+3);
313  indices[5*3*NPHI + 5*i+3] = 2*i+3;
314  indices[5*3*NPHI + 5*i+4] = SO_END_FACE_INDEX;
315  }
316  // the odd side
317  indices[5*4*NPHI +0] = 2*NPHI;
318  indices[5*4*NPHI +1] = 2*NPHI+1;
319  indices[5*4*NPHI +2] = 2*NPHI+3;
320  indices[5*4*NPHI +3] = 2*NPHI+2;
321  indices[5*4*NPHI +4] = SO_END_FACE_INDEX;
322  // aother odd side
323  indices[5*4*NPHI +5 +0] = 0;
324  indices[5*4*NPHI +5 +1] = NPOINTS-2;
325  indices[5*4*NPHI +5 +2] = NPOINTS-1;
326  indices[5*4*NPHI +5 +3] = 1;
327  indices[5*4*NPHI +5 +4] = SO_END_FACE_INDEX;
328  }
329  // Points need to be generated each time:
330  // The outer surface
331  DeltaPhi = fDPhi.getValue()/NPHI, phi = fSPhi.getValue();
332  float t,st,ct;
333  t = FATAN((fRmax2.getValue()-fRmax1.getValue())/(2*fDz.getValue()));
334  st = FSIN(t);
335  ct = FCOS(t);
336  for (i = 0; i<=NPHI; i++) {
337  points[2*i+0][0] = fRmax2.getValue()*FCOS(phi);
338  points[2*i+0][1] = fRmax2.getValue()*FSIN(phi);
339  points[2*i+0][2] = +fDz.getValue();
340  points[2*i+1][0] = fRmax1.getValue()*FCOS(phi);
341  points[2*i+1][1] = fRmax1.getValue()*FSIN(phi);
342  points[2*i+1][2] = -fDz.getValue();
343  pp = phi+DeltaPhi/2.0;
344  if (i!=NPHI) {
345  normals[i][0] = ct * FCOS(pp);
346  normals[i][1] = ct * FSIN(pp);
347  normals[i][2] = -st;
348  }
349  phi+=DeltaPhi;
350  }
351  // The inner surface
352  phi = fSPhi.getValue() + fDPhi.getValue();
353  t = FATAN((fRmin2.getValue()-fRmin1.getValue())/(2*fDz.getValue()));
354  st = FSIN(t);
355  ct = FCOS(t);
356  for (i = 0; i<=NPHI; i++) {
357  points[2*NPHI+2+2*i+0][0] = fRmin2.getValue()*FCOS(phi);
358  points[2*NPHI+2+2*i+0][1] = fRmin2.getValue()*FSIN(phi);
359  points[2*NPHI+2+2*i+0][2] = +fDz.getValue();
360  points[2*NPHI+2+2*i+1][0] = fRmin1.getValue()*FCOS(phi);
361  points[2*NPHI+2+2*i+1][1] = fRmin1.getValue()*FSIN(phi);
362  points[2*NPHI+2+2*i+1][2] = -fDz.getValue();
363  pp = phi-DeltaPhi/2.0;
364  if (i!=NPHI) {
365  normals[NPHI+i][0] = -ct*FCOS(pp);
366  normals[NPHI+i][1] = -ct*FSIN(pp);
367  normals[NPHI+i][2] = st;
368  }
369  phi-=DeltaPhi;
370  }
371  // The top side
372  for (i=0;i<NPHI;i++) {
373  normals[2*NPHI+i][0]=normals[2*NPHI+i][1]=0;
374  normals[2*NPHI+i][2]= 1.0;
375  }
376  // The bottom side
377  for (i=0;i<NPHI;i++) {
378  normals[3*NPHI+i][0]=normals[3*NPHI+i][1]=0;
379  normals[3*NPHI+i][2]= -1.0;
380  }
381  // The odd side
382  phi = fSPhi.getValue();
383  normals[4*NPHI+0][0]= FSIN(phi);
384  normals[4*NPHI+0][1]= -FCOS(phi);
385  normals[4*NPHI+0][2]= 0;
386 
387  // Another odd side
388  phi = fSPhi.getValue()+fDPhi.getValue();
389  normals[4*NPHI+1][0]= -FSIN(phi);
390  normals[4*NPHI+1][1]= +FCOS(phi);
391  normals[4*NPHI+1][2]=0;
392 
393  for (int np=0;np<NPOINTS;np++) theCoordinates->point.set1Value(np,points[np][0],points[np][1],points[np][2]);
394  theFaceSet->coordIndex.setValues(0,NINDICES,indices);
395  if (smoothDraw.getValue()) {
396  // This Line is replaced by the next one because of an apparent Bug in Inventor (mem. leak).
397  // theNormals->vector.deleteValues(0);
398  for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
399  theNormalBinding->value=SoNormalBinding::PER_FACE;
400  }
401  else {
402  for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
403  theNormalBinding->value=SoNormalBinding::PER_FACE;
404  }
405 }

Member Data Documentation

◆ alternateRep

SoSFNode SoCons::alternateRep

Alternate rep required - for use by users without HEPVis shared objects.

Definition at line 97 of file SoCons.h.

◆ fDPhi

SoSFFloat SoCons::fDPhi

Delta-angle, in radians.

Definition at line 84 of file SoCons.h.

◆ fDz

SoSFFloat SoCons::fDz

Half-length along Z.

Definition at line 76 of file SoCons.h.

◆ fRmax1

SoSFFloat SoCons::fRmax1

Outside radius at -fDz.

Definition at line 68 of file SoCons.h.

◆ fRmax2

SoSFFloat SoCons::fRmax2

Outside radius at +fDz.

Definition at line 72 of file SoCons.h.

◆ fRmin1

SoSFFloat SoCons::fRmin1

Inside radius at -fDz.

Definition at line 60 of file SoCons.h.

◆ fRmin2

SoSFFloat SoCons::fRmin2

Inside radius at +fDz.

Definition at line 64 of file SoCons.h.

◆ fSPhi

SoSFFloat SoCons::fSPhi

Starting angle, in radians.

Definition at line 80 of file SoCons.h.

◆ m_children

SoChildList* SoCons::m_children
private

ChildList. Required whenever the class has hidden children.

Definition at line 164 of file SoCons.h.

◆ pOverrideNPhi

SoSFInt32 SoCons::pOverrideNPhi

Override number of phi subdivision used for rendering shape (i.e.

ignore e.g. complexity value). Put field to 0 (the default) to ignore it.

Definition at line 93 of file SoCons.h.

◆ smoothDraw

SoSFBool SoCons::smoothDraw

An Inventor option - slightly better render, worse performance.

Definition at line 88 of file SoCons.h.

The documentation for this class was generated from the following files:
SoCons::fDz
SoSFFloat fDz
Half-length along Z.
Definition: SoCons.h:76
SoCons::fRmax2
SoSFFloat fRmax2
Outside radius at +fDz.
Definition: SoCons.h:72
FATAN
#define FATAN(x)
Definition: SbMath.h:18
max
#define max(a, b)
Definition: cfImp.cxx:41
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
FCOS
#define FCOS(x)
Definition: SbMath.h:13
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:160
SoCons::fDPhi
SoSFFloat fDPhi
Delta-angle, in radians.
Definition: SoCons.h:84
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
SoCons::fSPhi
SoSFFloat fSPhi
Starting angle, in radians.
Definition: SoCons.h:80
M_PI
#define M_PI
Definition: ActiveFraction.h:11
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
PlotPulseshapeFromCool.np
np
Definition: PlotPulseshapeFromCool.py:64
SoCons::updateChildren
void updateChildren()
Used to modify hidden children when a data field is changed.
Definition: SoCons.cxx:255
RevolutionSurfaceUtil::nphiDivisions
static int nphiDivisions(const float &dphi, const float &complexity, int OverrideNPhi=0)
Definition: RevolutionSurfaceUtil.h:21
SoCons::alternateRep
SoSFNode alternateRep
Alternate rep required - for use by users without HEPVis shared objects.
Definition: SoCons.h:97
SoCons::fRmin1
SoSFFloat fRmin1
Inside radius at -fDz.
Definition: SoCons.h:60
lumiFormat.i
int i
Definition: lumiFormat.py:85
RevolutionSurfaceUtil::setBBoxPars
static void setBBoxPars(const float &sphi, const float &dphi, const float &rmin, const float &rmax, const float &zmin, const float &zmax, SbBox3f &box, SbVec3f &center)
Definition: RevolutionSurfaceUtil.h:40
SoCons::pOverrideNPhi
SoSFInt32 pOverrideNPhi
Override number of phi subdivision used for rendering shape (i.e.
Definition: SoCons.h:93
python.Constants.TRUE
bool TRUE
for job options legacy (TODO: get rid of these!) ----------------------—
Definition: Control/AthenaCommon/python/Constants.py:22
calibdata.ct
ct
Definition: calibdata.py:418
SoCons::m_children
SoChildList * m_children
ChildList. Required whenever the class has hidden children.
Definition: SoCons.h:164
min
#define min(a, b)
Definition: cfImp.cxx:40
grepfile.sep
sep
Definition: grepfile.py:38
FSIN
#define FSIN(x)
Definition: SbMath.h:14
GEN_VERTEX
#define GEN_VERTEX(pv, x, y, z, s, t, nx, ny, nz)
python.PyKernel.init
def init(v_theApp, v_rootStream=None)
Definition: PyKernel.py:45
python.CaloScaleNoiseConfig.action
action
Definition: CaloScaleNoiseConfig.py:77
python.changerun.pv
pv
Definition: changerun.py:81
SoCons::inc
void inc(double &sinPhi, double &cosPhi, double sinDeltaPhi, double cosDeltaPhi) const
help with trigonometry. increments sines an cosines by an angle.
Definition: SoCons.h:169
SoCons
SoCons - Inventor version of the G4Cons Geant Geometry entity.
Definition: SoCons.h:50
SoCons::smoothDraw
SoSFBool smoothDraw
An Inventor option - slightly better render, worse performance.
Definition: SoCons.h:88
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Ringer::getType
T getType(const char *cStr)
Return Ringer enumeration of type T identifying string type:
jobOptions.points
points
Definition: jobOptions.GenevaPy8_Zmumu.py:97
SoCons::generateChildren
void generateChildren()
Generate Children.
Definition: SoCons.cxx:408
SoCons::fRmax1
SoSFFloat fRmax1
Outside radius at -fDz.
Definition: SoCons.h:68
SoCons::fRmin2
SoSFFloat fRmin2
Inside radius at +fDz.
Definition: SoCons.h:64
Generated on Thu Nov 7 2024 21:56:39 for ATLAS Offline Software by   doxygen 1.8.18