ATLAS Offline Software
SoLAr.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: SoLAr */
8 /* Description: Represents the G4LAr Geant Geometry entity */
9 /* Author: Joe Boudreau Nov 11 1996 */
10 /* */
11 /*--------------------------------------------------------------------------*/
12 
13 #include <VP1HEPVis/nodes/SoLAr.h>
14 #include "RevolutionSurfaceUtil.h"
15 
16 #include <iostream>
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 // This statement is required
32 SO_NODE_SOURCE(SoLAr)
33 
34 // LArtructor
35 SoLAr::SoLAr() {
36  // This statement is required
37  SO_NODE_CONSTRUCTOR(SoLAr);
38 
39  // Data fields are initialized like this:
40  SO_NODE_ADD_FIELD(fRmin, (0.0));
41  SO_NODE_ADD_FIELD(fRmax, (0.0));
42  SO_NODE_ADD_FIELD(fDz, (0.0));
43  SO_NODE_ADD_FIELD(fSPhi, (0.0));
44  SO_NODE_ADD_FIELD(fDPhi, ((float)(2*M_PI)));
45  SO_NODE_ADD_FIELD(smoothDraw, (TRUE));
46  SO_NODE_ADD_FIELD(pOverrideNPhi, (0));
47  SO_NODE_ADD_FIELD(alternateRep, (NULL));
48  m_children = new SoChildList(this);
49 
50  float rMinDef[]={10.0, 15.0, 10.0};
51  float rMaxDef[]={11.0, 17.0, 12.0};
52  float zDef []={-10.0, 0.0, 10.0};
53 
54  fRmin.setValues(0,2,rMinDef);
55  fRmax.setValues(0,2,rMaxDef);
56  fDz.setValues(0,2,zDef);
57  setNodeType(EXTENSION);
58 }
59 
60 // Destructor
61 SoLAr::~SoLAr() {
62  delete m_children;
63 }
64 
65 //____________________________________________________________________
66 void SoLAr::initClass()
67 {
68  [[maybe_unused]] static const bool didInit = [&]() {
69  SO_NODE_INIT_CLASS(SoLAr,SoShape,"Shape");
70  return true;
71  }();
72 }
73 
74 
75 // generatePrimitives
76 void SoLAr::generatePrimitives(SoAction *action) {
77  // This variable is used to store each vertex
78  SoPrimitiveVertex pv;
79 
80  // Access the stat from the action
81  SoState *state = action->getState();
82  if (!state)
83  return;
84 
85  // See if we have to use a texture coordinate function,
86  // rather than generating explicit texture coordinates.
87  SbBool useTexFunction=
88  (SoTextureCoordinateElement::getType(state) ==
89  SoTextureCoordinateElement::FUNCTION);
90 
91  // If we need to generate texture coordinates with a function,
92  // we'll need an SoGLTextureCoordinateElement. Otherwise, we'll
93  // set up the coordinates directly.
94  const SoTextureCoordinateElement *tce = NULL;
95  SbVec4f texCoord;
96  if (useTexFunction) {
97  tce = SoTextureCoordinateElement::getInstance(state);
98  } else {
99  texCoord[2] = 0.0;
100  texCoord[3] = 1.0;
101  }
102  SbVec3f point, normal;
103 
105  //-----------------------------------------------------
106 #define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz) \
107  point.setValue((float)(x),(float)(y),(float)(z)); \
108  normal.setValue((float)(nx),(float)(ny),(float)(nz)); \
109  if (useTexFunction) { \
110  texCoord=tce->get(point,normal); \
111  } else { \
112  texCoord[0]=(float)(s); \
113  texCoord[1]=(float)(t); \
114  } \
115  pv.setPoint(point); \
116  pv.setNormal(normal); \
117  pv.setTextureCoords(texCoord); \
118  shapeVertex(&pv);
119  //-----------------------------------------------------
121 
122  if (fRmin.getNum()!=fRmax.getNum() || fRmax.getNum() != fDz.getNum()) {
123  return;
124  }
125 
126  int nSeg = fRmin.getNum()-1;
127  if (nSeg<1) {
128  return;
129  }
130 
131  for (int p=0;p<nSeg;p++) {
132 
133  double rMin1= fRmin[p];
134  double rMin2= fRmin[p+1];
135 
136  double rMax1= fRmax[p];
137  double rMax2= fRmax[p+1];
138 
139  double zMin = fDz[p];
140  double zMax= fDz[p+1];
141 
142  int NPHI = RevolutionSurfaceUtil::nphiDivisions( fDPhi.getValue(), this->getComplexityValue(action), pOverrideNPhi.getValue() );
143 
144  double deltaPhi = fDPhi.getValue()/NPHI;
145  double phi0 = fSPhi.getValue();
146  double phi1 = phi0 + fDPhi.getValue();
147  double cosPhi0 = cos(phi0);
148  double sinPhi0 = sin(phi0);
149  double cosPhi1 = cos(phi1);
150  double sinPhi1 = sin(phi1);
151  double cosDeltaPhi = cos(deltaPhi);
152  double sinDeltaPhi = sin(deltaPhi);
153 
154  int i;
155  double sinPhi;
156  double cosPhi;
157 
158  //
159  // The outer surface!
160  //
161  if (1)
162  {
163  double dR =rMax2-rMax1;
164  double dZ =zMax-zMin;
165  double cosTheta = -dR/sqrt(dR*dR+dZ*dZ);
166  double sinTheta = dZ/sqrt(dR*dR+dZ*dZ);
167 
168  beginShape(action,TRIANGLE_STRIP);
169  sinPhi=sinPhi0;
170  cosPhi=cosPhi0;
171  for (i = 0; i<=NPHI; i++) {
172  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,0.0,0.0,sinTheta*cosPhi,sinTheta*sinPhi,cosTheta);
173  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,sinTheta*cosPhi,sinTheta*sinPhi,cosTheta);
174  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
175  }
176  endShape();
177  }
178  if (1)
179  //
180  // The inner surface!
181  //
182  {
183  beginShape(action,TRIANGLE_STRIP);
184  sinPhi=sinPhi0;
185  cosPhi=cosPhi0;
186 
187  double dR =rMin2-rMin1;
188  double dZ =zMax-zMin;
189  double cosTheta = -dR/sqrt(dR*dR+dZ*dZ);
190  double sinTheta = dZ/sqrt(dR*dR+dZ*dZ);
191 
192  for (i = 0; i<=NPHI; i++) {
193  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,0.0,0.0,-cosPhi*sinTheta,-sinPhi*sinTheta,-cosTheta);
194  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,1.0,1.0,-cosPhi*sinTheta,-sinPhi*sinTheta,-cosTheta);
195  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
196  }
197 
198  endShape();
199  }
200 
201  if (1) {
202  if (fabs(deltaPhi)<2.0*M_PI) {
203  //
204  // The end
205  //
206  beginShape(action,TRIANGLE_STRIP);
207  sinPhi=sinPhi0;
208  cosPhi=cosPhi0;
209  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,0.0,0.0,sinPhi,-cosPhi,0);
210  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,sinPhi,-cosPhi,0);
211  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,1.0,0.0,sinPhi,-cosPhi,0);
212  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,0.0,1.0,sinPhi,-cosPhi,0);
213  endShape();
214  //
215  // The other end
216  //
217  beginShape(action,TRIANGLE_STRIP);
218  sinPhi=sinPhi1;
219  cosPhi=cosPhi1;
220  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi, zMax,0.0,0.0,-sinPhi,+cosPhi,0);
221  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi, zMin,1.0,1.0,-sinPhi,+cosPhi,0);
222  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi, zMax,1.0,0.0,-sinPhi,+cosPhi,0);
223  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi, zMin,0.0,1.0,-sinPhi,+cosPhi,0);
224  endShape();
225  }
226  }
227  if (p==(nSeg-1)) {
228  //
229  // The outer surface at z=+PDZ
230  //
231  beginShape(action,TRIANGLE_STRIP);
232  sinPhi=sinPhi0;
233  cosPhi=cosPhi0;
234  for (i = 0; i<=NPHI; i++) {
235  GEN_VERTEX(pv,rMin2*cosPhi,rMin2*sinPhi,zMax,0.0,0.0,0,0,1);
236  GEN_VERTEX(pv,rMax2*cosPhi,rMax2*sinPhi,zMax,1.0,1.0,0,0,1);
237  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
238  }
239  endShape();
240  }
241  if (p==0) {
242  //
243  // The outer surface at z=-PDZ
244  //
245  beginShape(action,TRIANGLE_STRIP);
246  sinPhi=sinPhi0;
247  cosPhi=cosPhi0;
248  for (i = 0; i<=NPHI; i++) {
249  GEN_VERTEX(pv,rMin1*cosPhi,rMin1*sinPhi,zMin,0.0,0.0,0,0,-1);
250  GEN_VERTEX(pv,rMax1*cosPhi,rMax1*sinPhi,zMin,1.0,1.0,0,0,-1);
251  inc(sinPhi, cosPhi, sinDeltaPhi, cosDeltaPhi);
252  }
253  endShape();
254  }
255  }
256 
257  if (state&&state->isElementEnabled(SoGLCacheContextElement::getClassStackIndex())) {
258  //Encourage auto caching
259  SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DO_AUTO_CACHE);
260 #if ((COIN_MAJOR_VERSION>=3)||((COIN_MAJOR_VERSION==2)&&(COIN_MINOR_VERSION>=5)))
261  SoGLCacheContextElement::incNumShapes(state);
262 #endif
263  }
264 }
265 
266 // getChildren
267 SoChildList *SoLAr::getChildren() const {
268  return m_children;
269 }
270 
271 
272 // computeBBox
273 void SoLAr::computeBBox(SoAction *, SbBox3f &box, SbVec3f &center ){
274  if (fRmax.getNum()< 2) return;
275  if (fRmin.getNum()< 2) return;
276  if (fDz.getNum() < 2) return;
277 
278  double MinMin = fRmin[0];
279  double MaxMax = fRmax[0];
280 
281  double ZMin = fDz[0];
282  double ZMax = fDz[0];
283 
284 
285  for (int i=1;i<fRmin.getNum();i++) {
286  if (fRmin[i]<MinMin) MinMin=fRmin[i];
287  }
288 
289  for (int i=1;i<fRmax.getNum();i++) {
290  if (fRmax[i]>MaxMax) MaxMax=fRmax[i];
291  }
292 
293  for (int i=1;i<fDz.getNum();i++) {
294  if (fDz[i]>ZMax) ZMax=fDz[i];
295  if (fDz[i]<ZMin) ZMin=fDz[i];
296  }
297 
298  RevolutionSurfaceUtil::setBBoxPars(fSPhi.getValue(), fDPhi.getValue(),
299  MinMin, MaxMax,
300  ZMin,ZMax,
301  box, center );
302 }
303 
304 
305 
306 
307 // updateChildren
308 void SoLAr::updateChildren() {
309 
310 #ifdef IMPLEMENTED
311 
312  // (Not implemented so you do not get an alternate rep. Too bad.)
313 
314  // Redraw the G4LAr....
315 
316  assert(m_children->getLength()==1);
317  SoSeparator *sep = (SoSeparator *) ( *m_children)[0];
318  SoCoordinate3 *theCoordinates = (SoCoordinate3 *) ( sep->getChild(0));
319  SoNormal *theNormals = (SoNormal *) ( sep->getChild(1));
320  SoNormalBinding *theNormalBinding = (SoNormalBinding *) ( sep->getChild(2));
321  SoIndexedFaceSet *theFaceSet = (SoIndexedFaceSet *) ( sep->getChild(3));
322 
323  const int NPHI=96, NPOINTS=2*(2*NPHI+2), NFACES=4*NPHI+2, NINDICES = NFACES*5;
324  float points[NPOINTS][3], normals[NFACES][3];
325 #ifdef INVENTOR2_0
326  static long indices[NINDICES];
327 #else
328  static int32_t indices[NINDICES];
329 #endif
330  static int init=0;
331  double phi, pp, DeltaPhi;
332 
333  // Indices need to be generated once! This is here to keep it close to the point
334  // generation, since otherwise it will be confusing.
335 
336  int i;
337  if (!init) {
338  init = 1;
339  // Outer face
340  for (i = 0; i< NPHI; i++) {
341  // 0 1 3 2;
342  indices[5*i+0] = 2*i+0;
343  indices[5*i+1] = 2*i+1;
344  indices[5*i+2] = 2*i+3;
345  indices[5*i+3] = 2*i+2;
346  indices[5*i+4] = SO_END_FACE_INDEX;
347  }
348  // the inner face
349  for (i=0;i<NPHI;i++) {
350  indices[5*1*NPHI + 5*i+0] = 2*NPHI+2 + 2*i+0;
351  indices[5*1*NPHI + 5*i+1] = 2*NPHI+2 + 2*i+1;
352  indices[5*1*NPHI + 5*i+2] = 2*NPHI+2 + 2*i+3;
353  indices[5*1*NPHI + 5*i+3] = 2*NPHI+2 + 2*i+2;
354  indices[5*1*NPHI + 5*i+4] = SO_END_FACE_INDEX;
355  }
356  // the top side
357  for (i=0;i<NPHI;i++) {
358  indices[5*2*NPHI + 5*i+0] = 2*i+0;
359  indices[5*2*NPHI + 5*i+1] = 2*i+2;
360  indices[5*2*NPHI + 5*i+2] = NPOINTS - (2*i+4);
361  indices[5*2*NPHI + 5*i+3] = NPOINTS - (2*i+2);
362  indices[5*2*NPHI + 5*i+4] = SO_END_FACE_INDEX;
363  }
364  // the bottom side
365  for (i=0;i<NPHI;i++) {
366  indices[5*3*NPHI + 5*i+0] = 2*i+1;
367  indices[5*3*NPHI + 5*i+1] = NPOINTS - (2*i+1);
368  indices[5*3*NPHI + 5*i+2] = NPOINTS - (2*i+3);
369  indices[5*3*NPHI + 5*i+3] = 2*i+3;
370  indices[5*3*NPHI + 5*i+4] = SO_END_FACE_INDEX;
371  }
372  // the odd side
373  indices[5*4*NPHI +0] = 2*NPHI;
374  indices[5*4*NPHI +1] = 2*NPHI+1;
375  indices[5*4*NPHI +2] = 2*NPHI+3;
376  indices[5*4*NPHI +3] = 2*NPHI+2;
377  indices[5*4*NPHI +4] = SO_END_FACE_INDEX;
378  // aother odd side
379  indices[5*4*NPHI +5 +0] = 0;
380  indices[5*4*NPHI +5 +1] = NPOINTS-2;
381  indices[5*4*NPHI +5 +2] = NPOINTS-1;
382  indices[5*4*NPHI +5 +3] = 1;
383  indices[5*4*NPHI +5 +4] = SO_END_FACE_INDEX;
384  }
385  // Points need to be generated each time:
386  // The outer surface
387  DeltaPhi = fDPhi.getValue()/NPHI, phi = fSPhi.getValue();
388  float t,st,ct;
389  t = FATAN((fRmax2.getValue()-fRmax1.getValue())/(2*fDz.getValue()));
390  st = FSIN(t);
391  ct = FCOS(t);
392  for (i = 0; i<=NPHI; i++) {
393  points[2*i+0][0] = fRmax2.getValue()*FCOS(phi);
394  points[2*i+0][1] = fRmax2.getValue()*FSIN(phi);
395  points[2*i+0][2] = +fDz.getValue();
396  points[2*i+1][0] = fRmax1.getValue()*FCOS(phi);
397  points[2*i+1][1] = fRmax1.getValue()*FSIN(phi);
398  points[2*i+1][2] = -fDz.getValue();
399  pp = phi+DeltaPhi/2.0;
400  if (i!=NPHI) {
401  normals[i][0] = ct * FCOS(pp);
402  normals[i][1] = ct * FSIN(pp);
403  normals[i][2] = -st;
404  }
405  phi+=DeltaPhi;
406  }
407  // The inner surface
408  phi = fSPhi.getValue() + fDPhi.getValue();
409  t = FATAN((fRmin2.getValue()-fRmin1.getValue())/(2*fDz.getValue()));
410  st = FSIN(t);
411  ct = FCOS(t);
412  for (i = 0; i<=NPHI; i++) {
413  points[2*NPHI+2+2*i+0][0] = fRmin2.getValue()*FCOS(phi);
414  points[2*NPHI+2+2*i+0][1] = fRmin2.getValue()*FSIN(phi);
415  points[2*NPHI+2+2*i+0][2] = +fDz.getValue();
416  points[2*NPHI+2+2*i+1][0] = fRmin1.getValue()*FCOS(phi);
417  points[2*NPHI+2+2*i+1][1] = fRmin1.getValue()*FSIN(phi);
418  points[2*NPHI+2+2*i+1][2] = -fDz.getValue();
419  pp = phi-DeltaPhi/2.0;
420  if (i!=NPHI) {
421  normals[NPHI+i][0] = -ct*FCOS(pp);
422  normals[NPHI+i][1] = -ct*FSIN(pp);
423  normals[NPHI+i][2] = st;
424  }
425  phi-=DeltaPhi;
426  }
427  // The top side
428  for (i=0;i<NPHI;i++) {
429  normals[2*NPHI+i][0]=normals[2*NPHI+i][1]=0;
430  normals[2*NPHI+i][2]= 1.0;
431  }
432  // The bottom side
433  for (i=0;i<NPHI;i++) {
434  normals[3*NPHI+i][0]=normals[3*NPHI+i][1]=0;
435  normals[3*NPHI+i][2]= -1.0;
436  }
437  // The odd side
438  phi = fSPhi.getValue();
439  normals[4*NPHI+0][0]= FSIN(phi);
440  normals[4*NPHI+0][1]= -FCOS(phi);
441  normals[4*NPHI+0][2]= 0;
442 
443  // Another odd side
444  phi = fSPhi.getValue()+fDPhi.getValue();
445  normals[4*NPHI+1][0]= -FSIN(phi);
446  normals[4*NPHI+1][1]= +FCOS(phi);
447  normals[4*NPHI+1][2]=0;
448 
449  for (int np=0;np<NPOINTS;np++) theCoordinates->point.set1Value(np,points[np][0],points[np][1],points[np][2]);
450  theFaceSet->coordIndex.setValues(0,NINDICES,indices);
451  if (smoothDraw.getValue()) {
452  // This Line is replaced by the next one because of an apparent Bug in Inventor (mem. leak).
453  // theNormals->vector.deleteValues(0);
454  for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
455  theNormalBinding->value=SoNormalBinding::PER_FACE;
456  }
457  else {
458  for (int nf=0;nf<NFACES;nf++) theNormals->vector.set1Value(nf,normals[nf][0],normals[nf][1],normals[nf][2]);
459  theNormalBinding->value=SoNormalBinding::PER_FACE;
460  }
461 #endif
462 }
463 
464 // generateChildren
465 void SoLAr::generateChildren() {
466 #ifdef IMPLEMENTED
467  // (Not implemented so you do not get an alternate rep. Too bad.)
468 
469 
470  // This routines creates one SoSeparator, one SoCoordinate3, and
471  // one SoLineSet, and puts it in the child list. This is done only
472  // once, whereas redrawing the position of the coordinates occurs each
473  // time an update is necessary, in the updateChildren routine.
474 
475  assert(m_children->getLength() ==0);
476  SoSeparator *sep = new SoSeparator();
477  SoCoordinate3 *theCoordinates = new SoCoordinate3();
478  SoNormal *theNormals = new SoNormal();
479  SoNormalBinding *theNormalBinding = new SoNormalBinding();
480  SoIndexedFaceSet *theFaceSet = new SoIndexedFaceSet();
481  //
482  // This line costs some in render quality! but gives speed.
483  //
484  sep->addChild(theCoordinates);
485  sep->addChild(theNormals);
486  sep->addChild(theNormalBinding);
487  sep->addChild(theFaceSet);
488  m_children->append(sep);
489 #endif
490 }
491 
492 // generateAlternateRep
493 void SoLAr::generateAlternateRep() {
494 
495  // This routine sets the alternate representation to the child
496  // list of this mode.
497 
498  if (m_children->getLength() == 0) generateChildren();
499  updateChildren();
500  alternateRep.setValue((SoSeparator *) ( *m_children)[0]);
501 }
502 
503 // clearAlternateRep
504 void SoLAr::clearAlternateRep() {
505  alternateRep.setValue(NULL);
506 }
FATAN
#define FATAN(x)
Definition: SbMath.h:18
SoLAr
SoLAr - Inventor version of the G4Cons Geant Geometry entity.
Definition: SoLAr.h:36
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
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
SoLAr::generatePrimitives
virtual void generatePrimitives(SoAction *action)
Generate Primitives, required.
Definition: SoLAr.cxx:76
SoLAr::smoothDraw
SoSFBool smoothDraw
An Inventor option - slightly better render, worse performance.
Definition: SoLAr.h:66
M_PI
#define M_PI
Definition: ActiveFraction.h:11
SoLAr::fRmax
SoMFFloat fRmax
Outside radii.
Definition: SoLAr.h:50
GEN_VERTEX
#define GEN_VERTEX(pv, x, y, z, s, t, nx, ny, nz)
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
SoLAr::getChildren
virtual SoChildList * getChildren() const
GetChildList, required whenever the class has hidden children.
Definition: SoLAr.cxx:267
RevolutionSurfaceUtil::nphiDivisions
static int nphiDivisions(const float &dphi, const float &complexity, int OverrideNPhi=0)
Definition: RevolutionSurfaceUtil.h:21
SoLAr::generateChildren
void generateChildren()
Generate Children.
Definition: SoLAr.cxx:465
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
SoLAr::~SoLAr
virtual ~SoLAr()
Destructor, required.
Definition: SoLAr.cxx:61
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
SoLAr::clearAlternateRep
virtual void clearAlternateRep()
We better be able to clear it, too!
Definition: SoLAr.cxx:504
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
SoLAr::fDz
SoMFFloat fDz
Z Positions.
Definition: SoLAr.h:54
grepfile.sep
sep
Definition: grepfile.py:38
FSIN
#define FSIN(x)
Definition: SbMath.h:14
SoLAr::alternateRep
SoSFNode alternateRep
Alternate rep required - for use by users without HEPVis shared objects.
Definition: SoLAr.h:75
SoLAr::m_children
SoChildList * m_children
ChildList. Required whenever the class has hidden children.
Definition: SoLAr.h:142
python.PyKernel.init
def init(v_theApp, v_rootStream=None)
Definition: PyKernel.py:45
SoLAr::fSPhi
SoSFFloat fSPhi
Starting angle, in radians.
Definition: SoLAr.h:58
SoLAr::fDPhi
SoSFFloat fDPhi
Delta-angle, in radians.
Definition: SoLAr.h:62
SoLAr::updateChildren
void updateChildren()
Used to modify hidden children when a data field is changed.
Definition: SoLAr.cxx:308
python.CaloScaleNoiseConfig.action
action
Definition: CaloScaleNoiseConfig.py:77
RevolutionSurfaceUtil.h
python.changerun.pv
pv
Definition: changerun.py:81
SoLAr::computeBBox
virtual void computeBBox(SoAction *action, SbBox3f &box, SbVec3f &center)
compute bounding Box, required
Definition: SoLAr.cxx:273
SoLAr::generateAlternateRep
virtual void generateAlternateRep()
Generate AlternateRep, required.
Definition: SoLAr.cxx:493
SoLAr.h
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Ringer::getType
T getType(const char *cStr)
Return Ringer enumeration of type T identifying string type:
SoLAr::pOverrideNPhi
SoSFInt32 pOverrideNPhi
Override number of phi subdivision used for rendering shape (i.e.
Definition: SoLAr.h:71
SoLAr::inc
void inc(double &sinPhi, double &cosPhi, double sinDeltaPhi, double cosDeltaPhi) const
help with trigonometry. increments sines an cosines by an angle.
Definition: SoLAr.h:147
jobOptions.points
points
Definition: jobOptions.GenevaPy8_Zmumu.py:97
SoLAr::fRmin
SoMFFloat fRmin
Inside radii.
Definition: SoLAr.h:46
SoLAr::initClass
static void initClass()
Class Initializer, required.
Definition: SoLAr.cxx:66
Generated on Thu Nov 7 2024 21:26:23 for ATLAS Offline Software by   doxygen 1.8.18