Geant4  v4-10.4-release
 모두 클래스 네임스페이스들 파일들 함수 변수 타입정의 열거형 타입 열거형 멤버 Friends 매크로 그룹들 페이지들
G4TwistTubsFlatSide.cc
이 파일의 문서화 페이지로 가기
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // $Id: G4TwistTubsFlatSide.cc 72937 2013-08-14 13:20:38Z gcosmo $
28 //
29 //
30 // --------------------------------------------------------------------
31 // GEANT 4 class source file
32 //
33 //
34 // G4TwistTubsFlatSide.cc
35 //
36 // Author:
37 // 01-Aug-2002 - Kotoyo Hoshina (hoshina@hepburn.s.chiba-u.ac.jp)
38 //
39 // History:
40 // 13-Nov-2003 - O.Link (Oliver.Link@cern.ch), Integration in Geant4
41 // from original version in Jupiter-2.5.02 application.
42 // --------------------------------------------------------------------
43 
44 #include "G4TwistTubsFlatSide.hh"
45 #include "G4GeometryTolerance.hh"
46 
47 //=====================================================================
48 //* constructors ------------------------------------------------------
49 
51  const G4RotationMatrix &rot,
52  const G4ThreeVector &tlate,
53  const G4ThreeVector &n,
54  const EAxis axis0 ,
55  const EAxis axis1 ,
56  G4double axis0min,
57  G4double axis1min,
58  G4double axis0max,
59  G4double axis1max )
60  : G4VTwistSurface(name, rot, tlate, 0, axis0, axis1,
61  axis0min, axis1min, axis0max, axis1max)
62 {
63  if (axis0 == kPhi && axis1 == kRho) {
64  G4Exception("G4TwistTubsFlatSide::G4TwistTubsFlatSide()",
65  "GeomSolids0002", FatalErrorInArgument,
66  "Should swap axis0 and axis1!");
67  }
68 
69  G4ThreeVector normal = rot.inverse()*n;
70  fCurrentNormal.normal = normal.unit(); // in local coordinate system
71  fIsValidNorm = true;
72 
73  SetCorners();
74  SetBoundaries();
75 
76  fSurfaceArea = 1 ; // not yet implemented. This is NOT a problem for tracking
77 
78 }
79 
80 
81 
83  G4double EndInnerRadius[2],
84  G4double EndOuterRadius[2],
85  G4double DPhi,
86  G4double EndPhi[2],
87  G4double EndZ[2],
88  G4int handedness )
89  : G4VTwistSurface(name)
90 {
91  fHandedness = handedness; // +z = +ve, -z = -ve
92  fAxis[0] = kRho; // in local coordinate system
93  fAxis[1] = kPhi;
94  G4int i = (handedness < 0 ? 0 : 1);
95  fAxisMin[0] = EndInnerRadius[i]; // Inner-hype radius at z=0
96  fAxisMax[0] = EndOuterRadius[i]; // Outer-hype radius at z=0
97  fAxisMin[1] = -0.5*DPhi;
98  fAxisMax[1] = -fAxisMin[1];
99  fCurrentNormal.normal.set(0, 0, (fHandedness < 0 ? -1 : 1));
100  // Unit vector, in local coordinate system
101  fRot.rotateZ(EndPhi[i]);
102  fTrans.set(0, 0, EndZ[i]);
103  fIsValidNorm = true;
104 
105  SetCorners();
106  SetBoundaries();
107 
108  fSurfaceArea = 0.5*DPhi * (EndOuterRadius[i]*EndOuterRadius[i]
109  - EndInnerRadius[i]*EndInnerRadius[i] ) ;
110 
111 }
112 
113 
114 //=====================================================================
115 //* Fake default constructor ------------------------------------------
116 
118  : G4VTwistSurface(a), fSurfaceArea(0.)
119 {
120 }
121 
122 
123 //=====================================================================
124 //* destructor --------------------------------------------------------
125 
127 {
128 }
129 
130 //=====================================================================
131 //* GetNormal ---------------------------------------------------------
132 
134  G4bool isGlobal)
135 {
136  if (isGlobal) {
138  } else {
139  return fCurrentNormal.normal;
140  }
141 }
142 
143 //=====================================================================
144 //* DistanceToSurface(p, v) -------------------------------------------
145 
147  const G4ThreeVector &gv,
148  G4ThreeVector gxx[],
149  G4double distance[],
150  G4int areacode[],
151  G4bool isvalid[],
152  EValidate validate)
153 {
154  fCurStatWithV.ResetfDone(validate, &gp, &gv);
155 
156  if (fCurStatWithV.IsDone()) {
157  G4int i;
158  for (i=0; i<fCurStatWithV.GetNXX(); i++) {
159  gxx[i] = fCurStatWithV.GetXX(i);
160  distance[i] = fCurStatWithV.GetDistance(i);
161  areacode[i] = fCurStatWithV.GetAreacode(i);
162  isvalid[i] = fCurStatWithV.IsValid(i);
163  }
164  return fCurStatWithV.GetNXX();
165  } else {
166  // initialize
167  G4int i;
168  for (i=0; i<2; i++) {
169  distance[i] = kInfinity;
170  areacode[i] = sOutside;
171  isvalid[i] = false;
172  gxx[i].set(kInfinity, kInfinity, kInfinity);
173  }
174  }
175 
178 
179  //
180  // special case!
181  // if p is on surface, distance = 0.
182  //
183 
184  if (std::fabs(p.z()) == 0.) { // if p is on the plane
185  distance[0] = 0;
186  G4ThreeVector xx = p;
187  gxx[0] = ComputeGlobalPoint(xx);
188 
189  if (validate == kValidateWithTol) {
190  areacode[0] = GetAreaCode(xx);
191  if (!IsOutside(areacode[0])) {
192  isvalid[0] = true;
193  }
194  } else if (validate == kValidateWithoutTol) {
195  areacode[0] = GetAreaCode(xx, false);
196  if (IsInside(areacode[0])) {
197  isvalid[0] = true;
198  }
199  } else { // kDontValidate
200  areacode[0] = sInside;
201  isvalid[0] = true;
202  }
203 
204  return 1;
205  }
206  //
207  // special case end
208  //
209 
210  if (v.z() == 0) {
211 
212  fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
213  isvalid[0], 0, validate, &gp, &gv);
214  return 0;
215  }
216 
217  distance[0] = - (p.z() / v.z());
218 
219  G4ThreeVector xx = p + distance[0]*v;
220  gxx[0] = ComputeGlobalPoint(xx);
221 
222  if (validate == kValidateWithTol) {
223  areacode[0] = GetAreaCode(xx);
224  if (!IsOutside(areacode[0])) {
225  if (distance[0] >= 0) isvalid[0] = true;
226  }
227  } else if (validate == kValidateWithoutTol) {
228  areacode[0] = GetAreaCode(xx, false);
229  if (IsInside(areacode[0])) {
230  if (distance[0] >= 0) isvalid[0] = true;
231  }
232  } else { // kDontValidate
233  areacode[0] = sInside;
234  if (distance[0] >= 0) isvalid[0] = true;
235  }
236 
237  fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
238  isvalid[0], 1, validate, &gp, &gv);
239 
240 #ifdef G4TWISTDEBUG
241  G4cerr << "ERROR - G4TwistTubsFlatSide::DistanceToSurface(p,v)" << G4endl;
242  G4cerr << " Name : " << GetName() << G4endl;
243  G4cerr << " xx : " << xx << G4endl;
244  G4cerr << " gxx[0] : " << gxx[0] << G4endl;
245  G4cerr << " dist[0] : " << distance[0] << G4endl;
246  G4cerr << " areacode[0] : " << areacode[0] << G4endl;
247  G4cerr << " isvalid[0] : " << isvalid[0] << G4endl;
248 #endif
249  return 1;
250 }
251 
252 //=====================================================================
253 //* DistanceToSurface(p) ----------------------------------------------
254 
256  G4ThreeVector gxx[],
257  G4double distance[],
258  G4int areacode[])
259 {
260  // Calculate distance to plane in local coordinate,
261  // then return distance and global intersection points.
262  //
263 
265 
266  if (fCurStat.IsDone()) {
267  G4int i;
268  for (i=0; i<fCurStat.GetNXX(); i++) {
269  gxx[i] = fCurStat.GetXX(i);
270  distance[i] = fCurStat.GetDistance(i);
271  areacode[i] = fCurStat.GetAreacode(i);
272  }
273  return fCurStat.GetNXX();
274  } else {
275  // initialize
276  G4int i;
277  for (i=0; i<2; i++) {
278  distance[i] = kInfinity;
279  areacode[i] = sOutside;
280  gxx[i].set(kInfinity, kInfinity, kInfinity);
281  }
282  }
283 
286 
287  // The plane is placed on origin with making its normal
288  // parallel to z-axis.
289  if (std::fabs(p.z()) <= 0.5 * kCarTolerance) { // if p is on the plane, return 1
290  distance[0] = 0;
291  xx = p;
292  } else {
293  distance[0] = std::fabs(p.z());
294  xx.set(p.x(), p.y(), 0);
295  }
296 
297  gxx[0] = ComputeGlobalPoint(xx);
298  areacode[0] = sInside;
299  G4bool isvalid = true;
300  fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
301  isvalid, 1, kDontValidate, &gp);
302  return 1;
303 
304 }
305 
306 //=====================================================================
307 //* GetAreaCode -------------------------------------------------------
308 
310  G4bool withTol)
311 {
312  const G4double rtol
314 
315  G4int areacode = sInside;
316 
317  if (fAxis[0] == kRho && fAxis[1] == kPhi) {
318  G4int rhoaxis = 0;
319  // G4int phiaxis = 0;
320 
321  G4ThreeVector dphimin; // direction of phi-minimum boundary
322  G4ThreeVector dphimax; // direction of phi-maximum boundary
323  dphimin = GetCorner(sC0Max1Min);
324  dphimax = GetCorner(sC0Max1Max);
325 
326  if (withTol) {
327 
328  G4bool isoutside = false;
329 
330  // test boundary of rho-axis
331 
332  if (xx.getRho() <= fAxisMin[rhoaxis] + rtol) {
333 
334  areacode |= (sAxis0 & (sAxisRho | sAxisMin)) | sBoundary; // rho-min
335  if (xx.getRho() < fAxisMin[rhoaxis] - rtol) isoutside = true;
336 
337  } else if (xx.getRho() >= fAxisMax[rhoaxis] - rtol) {
338 
339  areacode |= (sAxis0 & (sAxisRho | sAxisMax)) | sBoundary; // rho-max
340  if (xx.getRho() > fAxisMax[rhoaxis] + rtol) isoutside = true;
341 
342  }
343 
344  // test boundary of phi-axis
345 
346  if (AmIOnLeftSide(xx, dphimin) >= 0) { // xx is on dphimin
347 
348  areacode |= (sAxis1 & (sAxisPhi | sAxisMin));
349  if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
350  else areacode |= sBoundary;
351 
352  if (AmIOnLeftSide(xx, dphimin) > 0) isoutside = true;
353 
354  } else if (AmIOnLeftSide(xx, dphimax) <= 0) { // xx is on dphimax
355 
356  areacode |= (sAxis1 & (sAxisPhi | sAxisMax));
357  if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
358  else areacode |= sBoundary;
359 
360  if (AmIOnLeftSide(xx, dphimax) < 0) isoutside = true;
361 
362  }
363 
364  // if isoutside = true, clear inside bit.
365  // if not on boundary, add axis information.
366 
367  if (isoutside) {
368  G4int tmpareacode = areacode & (~sInside);
369  areacode = tmpareacode;
370  } else if ((areacode & sBoundary) != sBoundary) {
371  areacode |= (sAxis0 & sAxisRho) | (sAxis1 & sAxisPhi);
372  }
373 
374  } else {
375 
376  // out of boundary of rho-axis
377 
378  if (xx.getRho() < fAxisMin[rhoaxis]) {
379  areacode |= (sAxis0 & (sAxisRho | sAxisMin)) | sBoundary;
380  } else if (xx.getRho() > fAxisMax[rhoaxis]) {
381  areacode |= (sAxis0 & (sAxisRho | sAxisMax)) | sBoundary;
382  }
383 
384  // out of boundary of phi-axis
385 
386  if (AmIOnLeftSide(xx, dphimin, false) >= 0) { // xx is leftside or
387  areacode |= (sAxis1 & (sAxisPhi | sAxisMin)) ; // boundary of dphimin
388  if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
389  else areacode |= sBoundary;
390 
391  } else if (AmIOnLeftSide(xx, dphimax, false) <= 0) { // xx is rightside or
392  areacode |= (sAxis1 & (sAxisPhi | sAxisMax)) ; // boundary of dphimax
393  if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
394  else areacode |= sBoundary;
395 
396  }
397 
398  if ((areacode & sBoundary) != sBoundary) {
399  areacode |= (sAxis0 & sAxisRho) | (sAxis1 & sAxisPhi);
400  }
401 
402  }
403  return areacode;
404  } else {
405 
406  std::ostringstream message;
407  message << "Feature NOT implemented !" << G4endl
408  << " fAxis[0] = " << fAxis[0] << G4endl
409  << " fAxis[1] = " << fAxis[1];
410  G4Exception("G4TwistTubsFlatSide::GetAreaCode()", "GeomSolids0001",
411  FatalException, message);
412  }
413  return areacode;
414 }
415 
416 
417 //=====================================================================
418 //* SetCorners --------------------------------------------------------
419 
421 {
422  // Set Corner points in local coodinate.
423 
424  if (fAxis[0] == kRho && fAxis[1] == kPhi) {
425 
426  G4int rhoaxis = 0; // kRho
427  G4int phiaxis = 1; // kPhi
428 
429  G4double x, y, z;
430  // corner of Axis0min and Axis1min
431  x = fAxisMin[rhoaxis]*std::cos(fAxisMin[phiaxis]);
432  y = fAxisMin[rhoaxis]*std::sin(fAxisMin[phiaxis]);
433  z = 0;
434  SetCorner(sC0Min1Min, x, y, z);
435  // corner of Axis0max and Axis1min
436  x = fAxisMax[rhoaxis]*std::cos(fAxisMin[phiaxis]);
437  y = fAxisMax[rhoaxis]*std::sin(fAxisMin[phiaxis]);
438  z = 0;
439  SetCorner(sC0Max1Min, x, y, z);
440  // corner of Axis0max and Axis1max
441  x = fAxisMax[rhoaxis]*std::cos(fAxisMax[phiaxis]);
442  y = fAxisMax[rhoaxis]*std::sin(fAxisMax[phiaxis]);
443  z = 0;
444  SetCorner(sC0Max1Max, x, y, z);
445  // corner of Axis0min and Axis1max
446  x = fAxisMin[rhoaxis]*std::cos(fAxisMax[phiaxis]);
447  y = fAxisMin[rhoaxis]*std::sin(fAxisMax[phiaxis]);
448  z = 0;
449  SetCorner(sC0Min1Max, x, y, z);
450 
451  } else {
452  std::ostringstream message;
453  message << "Feature NOT implemented !" << G4endl
454  << " fAxis[0] = " << fAxis[0] << G4endl
455  << " fAxis[1] = " << fAxis[1];
456  G4Exception("G4TwistTubsFlatSide::SetCorners()", "GeomSolids0001",
457  FatalException, message);
458  }
459 }
460 
461 //=====================================================================
462 //* SetBoundaries() ---------------------------------------------------
463 
465 {
466  // Set direction-unit vector of phi-boundary-lines in local coodinate.
467  // Don't call the function twice.
468 
469  if (fAxis[0] == kRho && fAxis[1] == kPhi) {
470 
471  G4ThreeVector direction;
472  // sAxis0 & sAxisMin
473  direction = GetCorner(sC0Min1Max) - GetCorner(sC0Min1Min);
474  direction = direction.unit();
475  SetBoundary(sAxis0 & (sAxisPhi | sAxisMin), direction,
477 
478  // sAxis0 & sAxisMax
479  direction = GetCorner(sC0Max1Max) - GetCorner(sC0Max1Min);
480  direction = direction.unit();
481  SetBoundary(sAxis0 & (sAxisPhi | sAxisMax), direction,
483 
484  // sAxis1 & sAxisMin
485  direction = GetCorner(sC0Max1Min) - GetCorner(sC0Min1Min);
486  direction = direction.unit();
487  SetBoundary(sAxis1 & (sAxisRho | sAxisMin), direction,
489 
490  // sAxis1 & sAxisMax
491  direction = GetCorner(sC0Max1Max) - GetCorner(sC0Min1Max);
492  direction = direction.unit();
493  SetBoundary(sAxis1 & (sAxisRho | sAxisMax), direction,
495  } else {
496  std::ostringstream message;
497  message << "Feature NOT implemented !" << G4endl
498  << " fAxis[0] = " << fAxis[0] << G4endl
499  << " fAxis[1] = " << fAxis[1];
500  G4Exception("G4TwistTubsFlatSide::SetBoundaries()", "GeomSolids0001",
501  FatalException, message);
502  }
503 }
504 
505 //=====================================================================
506 //* GetFacets() -------------------------------------------------------
507 
509  G4int faces[][4], G4int iside )
510 {
511 
512  G4ThreeVector p ;
513 
514  G4double rmin = fAxisMin[0] ;
515  G4double rmax = fAxisMax[0] ;
516  G4double phimin, phimax ;
517 
518  G4double r,phi ;
519 
520  G4int i,j ;
521 
522  G4int nnode,nface ;
523 
524  for ( i = 0 ; i<n ; i++ ) {
525 
526  r = rmin + i*(rmax-rmin)/(n-1) ;
527 
528  phimin = GetBoundaryMin(r) ;
529  phimax = GetBoundaryMax(r) ;
530 
531  for ( j = 0 ; j<k ; j++ )
532  {
533  phi = phimin + j*(phimax-phimin)/(k-1) ;
534 
535  nnode = GetNode(i,j,k,n,iside) ;
536  p = SurfacePoint(phi,r,true) ; // surface point in global coord.system
537 
538  xyz[nnode][0] = p.x() ;
539  xyz[nnode][1] = p.y() ;
540  xyz[nnode][2] = p.z() ;
541 
542  if ( i<n-1 && j<k-1 ) { // conterclock wise filling
543 
544  nface = GetFace(i,j,k,n,iside) ;
545 
546  if (fHandedness < 0) { // lower side
547  faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,-1) * ( GetNode(i ,j ,k,n,iside)+1) ;
548  faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,-1) * ( GetNode(i ,j+1,k,n,iside)+1) ;
549  faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,-1) * ( GetNode(i+1,j+1,k,n,iside)+1) ;
550  faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,-1) * ( GetNode(i+1,j ,k,n,iside)+1) ;
551  } else { // upper side
552  faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,1) * ( GetNode(i ,j ,k,n,iside)+1) ;
553  faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,1) * ( GetNode(i+1,j ,k,n,iside)+1) ;
554  faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,1) * ( GetNode(i+1,j+1,k,n,iside)+1) ;
555  faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,1) * ( GetNode(i ,j+1,k,n,iside)+1) ;
556 
557  }
558 
559 
560 
561  }
562  }
563  }
564 }
Float_t x
Definition: compare.C:6
G4int GetAreacode(G4int i) const
Definition: geomdefs.hh:54
static const G4int sC0Min1Max
void set(double x, double y, double z)
CurrentStatus fCurStatWithV
static const G4int sInside
const XML_Char * name
Definition: expat.h:151
G4bool IsInside(G4int areacode, G4bool testbitmode=false) const
static const G4int sAxisRho
virtual G4ThreeVector SurfacePoint(G4double, G4double, G4bool isGlobal=false)
Double_t xx
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
static const G4double kInfinity
Definition: geomdefs.hh:42
G4double fAxisMin[2]
virtual G4int DistanceToSurface(const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol)
virtual void SetBoundary(const G4int &axiscode, const G4ThreeVector &direction, const G4ThreeVector &x0, const G4int &boundarytype)
#define G4endl
Definition: G4ios.hh:61
Float_t y
Definition: compare.C:6
const char * p
Definition: xmltok.h:285
Double_t z
G4ThreeVector fTrans
void message(RunManager *runmanager)
Definition: ts_scorers.cc:72
static const G4int sCorner
void SetCurrentStatus(G4int i, G4ThreeVector &xx, G4double &dist, G4int &areacode, G4bool &isvalid, G4int nxx, EValidate validate, const G4ThreeVector *p, const G4ThreeVector *v=0)
double z() const
static double normal(HepRandomEngine *eptr)
Definition: RandPoisson.cc:77
G4double GetRadialTolerance() const
G4bool IsOutside(G4int areacode) const
G4int GetEdgeVisibility(G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
G4RotationMatrix fRot
static const G4int sC0Min1Min
virtual G4String GetName() const
G4double fAxisMax[2]
G4TwistTubsFlatSide(const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, const G4ThreeVector &n, const EAxis axis1=kRho, const EAxis axis2=kPhi, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)
void ResetfDone(EValidate validate, const G4ThreeVector *p, const G4ThreeVector *v=0)
double G4double
Definition: G4Types.hh:76
bool G4bool
Definition: G4Types.hh:79
static const G4int sAxis1
G4int GetFace(G4int i, G4int j, G4int m, G4int n, G4int iside)
static const G4int sC0Max1Max
virtual void GetFacets(G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside)
static const G4int sAxisPhi
void SetCorner(G4int areacode, G4double x, G4double y, G4double z)
virtual G4double GetBoundaryMax(G4double phi)
G4ThreeVector GetCorner(G4int areacode) const
G4GLOB_DLL std::ostream G4cerr
Hep3Vector unit() const
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.hh:65
G4ThreeVector ComputeGlobalPoint(const G4ThreeVector &lp) const
int G4int
Definition: G4Types.hh:78
EAxis
Definition: geomdefs.hh:54
virtual void SetBoundaries()
double getRho() const
virtual G4double GetBoundaryMin(G4double phi)
G4double GetDistance(G4int i) const
static const G4int sAxis0
G4ThreeVector ComputeLocalPoint(const G4ThreeVector &gp) const
HepRotation & rotateZ(double delta)
Definition: Rotation.cc:92
double x() const
virtual G4int GetAreaCode(const G4ThreeVector &xx, G4bool withTol=true)
static G4GeometryTolerance * GetInstance()
Char_t n[5]
static const G4int sOutside
G4SurfCurNormal fCurrentNormal
static const G4int sAxisMin
Definition: geomdefs.hh:54
double y() const
static const G4int sBoundary
virtual G4ThreeVector GetNormal(const G4ThreeVector &, G4bool isGlobal=false)
G4int GetNode(G4int i, G4int j, G4int m, G4int n, G4int iside)
static const G4int sC0Max1Min
static const G4int sAxisMax
G4ThreeVector GetXX(G4int i) const
CurrentStatus fCurStat
HepRotation inverse() const
virtual G4int AmIOnLeftSide(const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)
G4ThreeVector ComputeGlobalDirection(const G4ThreeVector &lp) const
G4bool IsValid(G4int i) const
G4ThreeVector ComputeLocalDirection(const G4ThreeVector &gp) const