ATLAS Offline Software
SoCons.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /*-----------------------------HEPVis---------------------------------------*/
6 /* */
7 /* Node: SoCons */
8 /* Description: Represents the G4Cons Geant Geometry entity */
9 /* Author: Joe Boudreau Nov 11 1996 */
10 /* */
11 /*--------------------------------------------------------------------------*/
12 
13 // this :
14 #include <VP1HEPVis/nodes/SoCons.h>
15 #include "RevolutionSurfaceUtil.h"
16 
17 #include <cassert>
18 #include <cmath>
19 #include <Inventor/SbBox.h>
20 #include <Inventor/actions/SoAction.h>
21 #include <Inventor/misc/SoChildList.h>
22 #include <Inventor/nodes/SoSeparator.h>
23 #include <Inventor/nodes/SoIndexedFaceSet.h>
24 #include <Inventor/nodes/SoNormal.h>
25 #include <Inventor/nodes/SoCoordinate3.h>
26 #include <Inventor/nodes/SoNormalBinding.h>
27 #include <Inventor/SoPrimitiveVertex.h>
28 #include <Inventor/elements/SoTextureCoordinateElement.h>
29 #include <Inventor/elements/SoGLCacheContextElement.h>
30 
31 #include "SbMath.h"
32 
33 // This statement is required
34 SO_NODE_SOURCE(SoCons)
35 
36 // Constructor
37 SoCons::SoCons() {
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 }
56 
57 // Destructor
58 SoCons::~SoCons() {
59  delete m_children;
60 }
61 
62 //____________________________________________________________________
63 void SoCons::initClass()
64 {
65  [[maybe_unused]] static const bool didInit = [&]() {
66  SO_NODE_INIT_CLASS(SoCons,SoShape,"Shape");
67  return true;
68  }();
69 }
70 
71 
72 // generatePrimitives
73 void SoCons::generatePrimitives(SoAction *action) {
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 }
235 
236 // getChildren
237 SoChildList *SoCons::getChildren() const {
238  return m_children;
239 }
240 
241 
242 // computeBBox
243 void SoCons::computeBBox(SoAction *, SbBox3f &box, SbVec3f &center ){
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 }
250 
251 
252 
253 
254 // updateChildren
255 void SoCons::updateChildren() {
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 }
406 
407 // generateChildren
408 void SoCons::generateChildren() {
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 }
430 
431 // generateAlternateRep
432 void SoCons::generateAlternateRep() {
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 }
441 
442 // clearAlternateRep
443 void SoCons::clearAlternateRep() {
444  alternateRep.setValue(NULL);
445 }
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:64
FCOS
#define FCOS(x)
Definition: SbMath.h:13
SoCons.h
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
SoCons::clearAlternateRep
virtual void clearAlternateRep()
We better be able to clear it, too!
Definition: SoCons.cxx:443
M_PI
#define M_PI
Definition: ActiveFraction.h:11
SbMath.h
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
SoCons::generatePrimitives
virtual void generatePrimitives(SoAction *action)
Generate Primitives, required.
Definition: SoCons.cxx:73
lumiFormat.i
int i
Definition: lumiFormat.py:92
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::~SoCons
virtual ~SoCons()
Destructor, required.
Definition: SoCons.cxx:58
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
SoCons::computeBBox
virtual void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center)
compute bounding Box, required
Definition: SoCons.cxx:243
compileRPVLLRates.nf
nf
Definition: compileRPVLLRates.py:89
python.CaloScaleNoiseConfig.action
action
Definition: CaloScaleNoiseConfig.py:77
RevolutionSurfaceUtil.h
python.changerun.pv
pv
Definition: changerun.py:81
SoCons::getChildren
virtual SoChildList * getChildren() const
GetChildList, required whenever the class has hidden children.
Definition: SoCons.cxx:237
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::initClass
static void initClass()
Class Initializer, required.
Definition: SoCons.cxx:63
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:
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
SoCons::generateAlternateRep
virtual void generateAlternateRep()
Generate AlternateRep, required.
Definition: SoCons.cxx:432
Generated on Thu Jul 4 2024 21:27:12 for ATLAS Offline Software by   doxygen 1.8.18