Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4PVPlacement Class Reference

#include <G4PVPlacement.hh>

+ Inheritance diagram for G4PVPlacement:

Public Member Functions

 G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (const G4Transform3D &Transform3D, G4LogicalVolume *pCurrentLogical, const G4String &pName, G4LogicalVolume *pMotherLogical, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
 G4PVPlacement (const G4Transform3D &Transform3D, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother, G4bool pMany, G4int pCopyNo, G4bool pSurfChk=false)
 
virtual ~G4PVPlacement ()
 
G4int GetCopyNo () const
 
void SetCopyNo (G4int CopyNo)
 
G4bool CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1)
 
 G4PVPlacement (__void__ &)
 
 G4PVPlacement (const G4PVPlacement &)=delete
 
G4PVPlacement & operator= (const G4PVPlacement &)=delete
 
G4bool IsMany () const
 
G4bool IsReplicated () const
 
G4bool IsParameterised () const
 
G4VPVParameterisation * GetParameterisation () const
 
void GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const
 
G4bool IsRegularStructure () const
 
G4int GetRegularStructureId () const
 
EVolume VolumeType () const
 
- Public Member Functions inherited from G4VPhysicalVolume
 G4VPhysicalVolume (G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother)
 
virtual ~G4VPhysicalVolume ()
 
 G4VPhysicalVolume (const G4VPhysicalVolume &)=delete
 
G4VPhysicalVolume & operator= (const G4VPhysicalVolume &)=delete
 
G4bool operator== (const G4VPhysicalVolume &p) const
 
G4RotationMatrix * GetObjectRotation () const
 
G4RotationMatrix GetObjectRotationValue () const
 
G4ThreeVector GetObjectTranslation () const
 
const G4RotationMatrix * GetFrameRotation () const
 
G4ThreeVector GetFrameTranslation () const
 
const G4ThreeVector GetTranslation () const
 
const G4RotationMatrix * GetRotation () const
 
void SetTranslation (const G4ThreeVector &v)
 
G4RotationMatrix * GetRotation ()
 
void SetRotation (G4RotationMatrix *)
 
G4LogicalVolume * GetLogicalVolume () const
 
void SetLogicalVolume (G4LogicalVolume *pLogical)
 
G4LogicalVolume * GetMotherLogical () const
 
void SetMotherLogical (G4LogicalVolume *pMother)
 
const G4String & GetName () const
 
void SetName (const G4String &pName)
 
virtual G4int GetMultiplicity () const
 
virtual EVolume VolumeType () const =0
 
virtual G4bool IsMany () const =0
 
virtual G4int GetCopyNo () const =0
 
virtual void SetCopyNo (G4int CopyNo)=0
 
virtual G4bool IsReplicated () const =0
 
virtual G4bool IsParameterised () const =0
 
virtual G4VPVParameterisation * GetParameterisation () const =0
 
virtual void GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const =0
 
virtual G4bool IsRegularStructure () const =0
 
virtual G4int GetRegularStructureId () const =0
 
virtual G4bool CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int errMax=1)
 
 G4VPhysicalVolume (__void__ &)
 
G4int GetInstanceID () const
 
EVolume DeduceVolumeType () const
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicalVolume
static const G4PVManager & GetSubInstanceManager ()
 
static void Clean ()
 
- Protected Member Functions inherited from G4VPhysicalVolume
void InitialiseWorker (G4VPhysicalVolume *pMasterObject, G4RotationMatrix *pRot, const G4ThreeVector &tlate)
 
void TerminateWorker (G4VPhysicalVolume *pMasterObject)
 
- Protected Attributes inherited from G4VPhysicalVolume
G4int instanceID
 
- Static Protected Attributes inherited from G4VPhysicalVolume
static G4GEOM_DLL G4PVManager subInstanceManager
 

Detailed Description

Definition at line 43 of file G4PVPlacement.hh.

Constructor & Destructor Documentation

◆ G4PVPlacement() [1/6]

G4PVPlacement::G4PVPlacement ( G4RotationMatrix *  pRot,
const G4ThreeVector &  tlate,
G4LogicalVolume *  pCurrentLogical,
const G4String &  pName,
G4LogicalVolume *  pMotherLogical,
G4bool  pMany,
G4int  pCopyNo,
G4bool  pSurfChk = false 
)

Definition at line 96 of file G4PVPlacement.cc.

104 : G4VPhysicalVolume(pRot, tlate, pName, pCurrentLogical, nullptr),
105 fmany(pMany), fcopyNo(pCopyNo)
106{
107 if (pCurrentLogical == pMotherLogical)
108 {
109 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
110 FatalException, "Cannot place a volume inside itself!");
111 }
112 SetMotherLogical(pMotherLogical);
113 if (pMotherLogical) { pMotherLogical->AddDaughter(this); }
114 if ((pSurfChk) && (pMotherLogical)) { CheckOverlaps(); }
115}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
G4LogicalVolume::AddDaughter
void AddDaughter(G4VPhysicalVolume *p)
Definition: G4LogicalVolume.cc:271
G4PVPlacement::CheckOverlaps
G4bool CheckOverlaps(G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1)
Definition: G4PVPlacement.cc:243
G4VPhysicalVolume::SetMotherLogical
void SetMotherLogical(G4LogicalVolume *pMother)

◆ G4PVPlacement() [2/6]

G4PVPlacement::G4PVPlacement ( const G4Transform3D &  Transform3D,
G4LogicalVolume *  pCurrentLogical,
const G4String &  pName,
G4LogicalVolume *  pMotherLogical,
G4bool  pMany,
G4int  pCopyNo,
G4bool  pSurfChk = false 
)

Definition at line 121 of file G4PVPlacement.cc.

128 : G4VPhysicalVolume(nullptr, Transform3D.getTranslation(),
129 pName, pCurrentLogical, nullptr),
130 fmany(pMany), fcopyNo(pCopyNo)
131{
132 if (pCurrentLogical == pMotherLogical)
133 {
134 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
135 FatalException, "Cannot place a volume inside itself!");
136 }
137 SetRotation( NewPtrRotMatrix(Transform3D.getRotation().inverse()) );
138 fallocatedRotM = (GetRotation() != nullptr);
139 SetMotherLogical(pMotherLogical);
140 if (pMotherLogical) { pMotherLogical->AddDaughter(this); }
141 if ((pSurfChk) && (pMotherLogical)) { CheckOverlaps(); }
142}
CLHEP::HepRotation::inverse
HepRotation inverse() const
G4VPhysicalVolume::GetRotation
const G4RotationMatrix * GetRotation() const
Definition: G4VPhysicalVolume.cc:152
G4VPhysicalVolume::SetRotation
void SetRotation(G4RotationMatrix *)
Definition: G4VPhysicalVolume.cc:162
HepGeom::Transform3D::getRotation
CLHEP::HepRotation getRotation() const
HepGeom::Transform3D::getTranslation
CLHEP::Hep3Vector getTranslation() const

◆ G4PVPlacement() [3/6]

G4PVPlacement::G4PVPlacement ( G4RotationMatrix *  pRot,
const G4ThreeVector &  tlate,
const G4String &  pName,
G4LogicalVolume *  pLogical,
G4VPhysicalVolume *  pMother,
G4bool  pMany,
G4int  pCopyNo,
G4bool  pSurfChk = false 
)

Definition at line 39 of file G4PVPlacement.cc.

47 : G4VPhysicalVolume(pRot, tlate, pName, pLogical, pMother),
48 fmany(pMany), fcopyNo(pCopyNo)
49{
50 if (pMother)
51 {
52 G4LogicalVolume* motherLogical = pMother->GetLogicalVolume();
53 if (pLogical == motherLogical)
54 {
55 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
56 FatalException, "Cannot place a volume inside itself!");
57 }
58 SetMotherLogical(motherLogical);
59 motherLogical->AddDaughter(this);
60 if (pSurfChk) { CheckOverlaps(); }
61 }
62}
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const

◆ G4PVPlacement() [4/6]

G4PVPlacement::G4PVPlacement ( const G4Transform3D &  Transform3D,
const G4String &  pName,
G4LogicalVolume *  pLogical,
G4VPhysicalVolume *  pMother,
G4bool  pMany,
G4int  pCopyNo,
G4bool  pSurfChk = false 
)

Definition at line 67 of file G4PVPlacement.cc.

74 : G4VPhysicalVolume(NewPtrRotMatrix(Transform3D.getRotation().inverse()),
75 Transform3D.getTranslation(), pName, pLogical, pMother),
76 fmany(pMany), fcopyNo(pCopyNo)
77{
78 fallocatedRotM = (GetRotation() != 0);
79 if (pMother)
80 {
81 G4LogicalVolume* motherLogical = pMother->GetLogicalVolume();
82 if (pLogical == motherLogical)
83 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
84 FatalException, "Cannot place a volume inside itself!");
85 SetMotherLogical(motherLogical);
86 motherLogical->AddDaughter(this);
87 if (pSurfChk) { CheckOverlaps(); }
88 }
89}

◆ ~G4PVPlacement()

G4PVPlacement::~G4PVPlacement ( )
virtual

Definition at line 156 of file G4PVPlacement.cc.

157{
158 if( fallocatedRotM ){ delete this->GetRotation() ; }
159}

◆ G4PVPlacement() [5/6]

G4PVPlacement::G4PVPlacement ( __void__ &  a)

Definition at line 148 of file G4PVPlacement.cc.

149 : G4VPhysicalVolume(a)
150{
151}

◆ G4PVPlacement() [6/6]

G4PVPlacement::G4PVPlacement ( const G4PVPlacement &  )
delete

Member Function Documentation

◆ CheckOverlaps()

G4bool G4PVPlacement::CheckOverlaps ( G4int  res = 1000,
G4double  tol = 0.,
G4bool  verbose = true,
G4int  maxErr = 1 
)
virtual

Reimplemented from G4VPhysicalVolume.

Definition at line 243 of file G4PVPlacement.cc.

245{
246 if (res <= 0) { return false; }
247
248 G4VSolid* solid = GetLogicalVolume()->GetSolid();
249 G4LogicalVolume* motherLog = GetMotherLogical();
250 if (motherLog == nullptr) { return false; }
251
252 G4int trials = 0;
253 G4bool retval = false;
254
255 if (verbose)
256 {
257 G4cout << "Checking overlaps for volume " << GetName()
258 << " (" << solid->GetEntityType() << ") ... ";
259 }
260
261 // Check that random points are gererated correctly
262 //
263 G4ThreeVector ptmp = solid->GetPointOnSurface();
264 if (solid->Inside(ptmp) != kSurface)
265 {
266 G4String position[3] = { "outside", "surface", "inside" };
267 std::ostringstream message;
268 message << "Sample point is not on the surface !" << G4endl
269 << " The issue is detected for volume "
270 << GetName() << ':' << GetCopyNo()
271 << " (" << solid->GetEntityType() << ")" << G4endl
272 << " generated point " << ptmp
273 << " is " << position[solid->Inside(ptmp)];
274 G4Exception("G4PVPlacement::CheckOverlaps()",
275 "GeomVol1002", JustWarning, message);
276 return false;
277 }
278
279 // Generate random points on the surface of the solid,
280 // transform them into the mother volume coordinate system
281 // and find the bonding box
282 //
283 std::vector<G4ThreeVector> points(res);
284 G4double xmin = kInfinity, ymin = kInfinity, zmin = kInfinity;
285 G4double xmax = -kInfinity, ymax = -kInfinity, zmax = -kInfinity;
286 G4AffineTransform Tm(GetRotation(), GetTranslation());
287 for (G4int i = 0; i < res; ++i)
288 {
289 points[i] = Tm.TransformPoint(solid->GetPointOnSurface());
290 xmin = std::min(xmin, points[i].x());
291 ymin = std::min(ymin, points[i].y());
292 zmin = std::min(zmin, points[i].z());
293 xmax = std::max(xmax, points[i].x());
294 ymax = std::max(ymax, points[i].y());
295 zmax = std::max(zmax, points[i].z());
296 }
297 G4ThreeVector scenter(0.5*(xmax+xmin), 0.5*(ymax+ymin), 0.5*(zmax+zmin));
298 G4double sradius = 0.5*G4ThreeVector(xmax-xmin, ymax-ymin, zmax-zmin).mag();
299
300 // Check overlap with the mother volume
301 //
302 G4VSolid* motherSolid = motherLog->GetSolid();
303 for (G4int i = 0; i < res; ++i)
304 {
305 G4ThreeVector mp = points[i];
306 if (motherSolid->Inside(mp) != kOutside) continue;
307 G4double distin = motherSolid->DistanceToIn(mp);
308 if (distin > tol)
309 {
310 ++trials;
311 retval = true;
312 std::ostringstream message;
313 message << "Overlap with mother volume !" << G4endl
314 << " Overlap is detected for volume "
315 << GetName() << ':' << GetCopyNo()
316 << " (" << solid->GetEntityType() << ")" << G4endl
317 << " with its mother volume " << motherLog->GetName()
318 << " (" << motherSolid->GetEntityType() << ")" << G4endl
319 << " at mother local point " << mp << ", "
320 << "overlapping by at least: "
321 << G4BestUnit(distin, "Length");
322 if (trials >= maxErr)
323 {
324 message << G4endl
325 << "NOTE: Reached maximum fixed number -" << maxErr
326 << "- of overlaps reports for this volume !";
327 }
328 G4Exception("G4PVPlacement::CheckOverlaps()",
329 "GeomVol1002", JustWarning, message);
330 if (trials >= maxErr) { return true; }
331 break;
332 }
333 }
334
335 // Checking overlaps with each 'sister' volume
336 //
337 G4VSolid* previous = nullptr;
338 G4ThreeVector pmin_local(0.,0.,0.), pmax_local(0.,0.,0.);
339
340 for (size_t k = 0; k < motherLog->GetNoDaughters(); ++k)
341 {
342 G4VPhysicalVolume* daughter = motherLog->GetDaughter(k);
343 if (daughter == this) continue;
344
345 G4AffineTransform Td(daughter->GetRotation(), daughter->GetTranslation());
346 G4VSolid* daughterSolid = daughter->GetLogicalVolume()->GetSolid();
347 if (previous != daughterSolid)
348 {
349 daughterSolid->BoundingLimits(pmin_local, pmax_local);
350 previous = daughterSolid;
351 }
352 G4double distout = -kInfinity;
353 G4ThreeVector plocal;
354 if (!Td.IsRotated()) {
355 G4ThreeVector offset = Td.NetTranslation();
356 G4ThreeVector pmin(pmin_local + offset);
357 G4ThreeVector pmax(pmax_local + offset);
358 if (pmin.x() >= xmax) continue;
359 if (pmin.y() >= ymax) continue;
360 if (pmin.z() >= zmax) continue;
361 if (pmax.x() <= xmin) continue;
362 if (pmax.y() <= ymin) continue;
363 if (pmax.z() <= zmin) continue;
364 for (G4int i = 0; i < res; ++i)
365 {
366 G4ThreeVector p = points[i];
367 if (p.x() <= pmin.x()) continue;
368 if (p.x() >= pmax.x()) continue;
369 if (p.y() <= pmin.y()) continue;
370 if (p.y() >= pmax.y()) continue;
371 if (p.z() <= pmin.z()) continue;
372 if (p.z() >= pmax.z()) continue;
373 G4ThreeVector md = p - offset;
374 if (daughterSolid->Inside(md) == kInside)
375 {
376 G4double dtmp = daughterSolid->DistanceToOut(md);
377 if (dtmp <= tol) continue;
378 distout = dtmp;
379 plocal = md;
380 break;
381 }
382 }
383 }
384 else
385 {
386 G4ThreeVector pmin(pmin_local), pmax(pmax_local);
387 G4ThreeVector dcenter = Td.TransformPoint(0.5*(pmin + pmax));
388 G4double dradius = 0.5*((pmax - pmin).mag());
389 if ((scenter - dcenter).mag2() >= (sradius + dradius)*(sradius + dradius)) continue;
390 if (dcenter.x() - dradius >= xmax) continue;
391 if (dcenter.y() - dradius >= ymax) continue;
392 if (dcenter.z() - dradius >= zmax) continue;
393 if (dcenter.x() + dradius <= xmin) continue;
394 if (dcenter.y() + dradius <= ymin) continue;
395 if (dcenter.z() + dradius <= zmin) continue;
396
397 G4ThreeVector pbox[8] = {
398 G4ThreeVector(pmin.x(), pmin.y(), pmin.z()),
399 G4ThreeVector(pmax.x(), pmin.y(), pmin.z()),
400 G4ThreeVector(pmin.x(), pmax.y(), pmin.z()),
401 G4ThreeVector(pmax.x(), pmax.y(), pmin.z()),
402 G4ThreeVector(pmin.x(), pmin.y(), pmax.z()),
403 G4ThreeVector(pmax.x(), pmin.y(), pmax.z()),
404 G4ThreeVector(pmin.x(), pmax.y(), pmax.z()),
405 G4ThreeVector(pmax.x(), pmax.y(), pmax.z())
406 };
407 G4double dxmin = kInfinity, dymin = kInfinity, dzmin = kInfinity;
408 G4double dxmax = -kInfinity, dymax = -kInfinity, dzmax = -kInfinity;
409 for (G4int i = 0; i < 8; ++i)
410 {
411 G4ThreeVector p = Td.TransformPoint(pbox[i]);
412 dxmin = std::min(dxmin, p.x());
413 dymin = std::min(dymin, p.y());
414 dzmin = std::min(dzmin, p.z());
415 dxmax = std::max(dxmax, p.x());
416 dymax = std::max(dymax, p.y());
417 dzmax = std::max(dzmax, p.z());
418 }
419 if (dxmin >= xmax) continue;
420 if (dymin >= ymax) continue;
421 if (dzmin >= zmax) continue;
422 if (dxmax <= xmin) continue;
423 if (dymax <= ymin) continue;
424 if (dzmax <= zmin) continue;
425 for (G4int i = 0; i < res; ++i)
426 {
427 G4ThreeVector p = points[i];
428 if (p.x() >= dxmax) continue;
429 if (p.x() <= dxmin) continue;
430 if (p.y() >= dymax) continue;
431 if (p.y() <= dymin) continue;
432 if (p.z() >= dzmax) continue;
433 if (p.z() <= dzmin) continue;
434 G4ThreeVector md = Td.InverseTransformPoint(p);
435 if (daughterSolid->Inside(md) == kInside)
436 {
437 G4double dtmp = daughterSolid->DistanceToOut(md);
438 if (dtmp <= tol) continue;
439 distout = dtmp;
440 plocal = md;
441 break;
442 }
443 }
444 }
445
446 if (distout > tol)
447 {
448 ++trials;
449 retval = true;
450 std::ostringstream message;
451 message << "Overlap with volume already placed !" << G4endl
452 << " Overlap is detected for volume "
453 << GetName() << ':' << GetCopyNo()
454 << " (" << solid->GetEntityType() << ")" << G4endl
455 << " with " << daughter->GetName()
456 << ':' << daughter->GetCopyNo()
457 << " (" << daughterSolid->GetEntityType() << ")"
458 << " volume's" << G4endl
459 << " local point " << plocal << ", "
460 << "overlapping by at least: "
461 << G4BestUnit(distout, "Length");
462 if (trials >= maxErr)
463 {
464 message << G4endl
465 << "NOTE: Reached maximum fixed number -" << maxErr
466 << "- of overlaps reports for this volume !";
467 }
468 G4Exception("G4PVPlacement::CheckOverlaps()",
469 "GeomVol1002", JustWarning, message);
470 if (trials >= maxErr) { return true; }
471 }
472 else if (distout == kInfinity)
473 {
474 // Now checking that 'sister' volume is not totally included
475 // and overlapping. Generate a single point on the surface of
476 // the 'sister' volume and verify that the point in NOT inside
477 // the current volume
478 //
479 G4ThreeVector dPoint = daughterSolid->GetPointOnSurface();
480
481 // Transform the generated point to the mother's coordinate system
482 // and then to current volume's coordinate system
483 //
484 G4ThreeVector mp2 = Td.TransformPoint(dPoint);
485 G4ThreeVector msi = Tm.InverseTransformPoint(mp2);
486
487 if (solid->Inside(msi) == kInside)
488 {
489 ++trials;
490 retval = true;
491 std::ostringstream message;
492 message << "Overlap with volume already placed !" << G4endl
493 << " Overlap is detected for volume "
494 << GetName() << ':' << GetCopyNo()
495 << " (" << solid->GetEntityType() << ")" << G4endl
496 << " apparently fully encapsulating volume "
497 << daughter->GetName() << ':' << daughter->GetCopyNo()
498 << " (" << daughterSolid->GetEntityType() << ")"
499 << " at the same level !";
500 if (trials >= maxErr)
501 {
502 message << G4endl
503 << "NOTE: Reached maximum fixed number -" << maxErr
504 << "- of overlaps reports for this volume !";
505 }
506 G4Exception("G4PVPlacement::CheckOverlaps()",
507 "GeomVol1002", JustWarning, message);
508 if (trials >= maxErr) { return true; }
509 }
510 }
511 }
512
513 if (verbose && trials == 0) { G4cout << "OK! " << G4endl; }
514 return retval;
515}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
G4BestUnit
#define G4BestUnit(a, b)
Definition: G4SteppingVerbose.cc:45
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:36
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::mag
double mag() const
G4LogicalVolume::GetSolid
G4VSolid * GetSolid() const
Definition: G4LogicalVolume.cc:403
G4LogicalVolume::GetNoDaughters
size_t GetNoDaughters() const
G4LogicalVolume::GetDaughter
G4VPhysicalVolume * GetDaughter(const G4int i) const
G4LogicalVolume::GetName
const G4String & GetName() const
G4PVPlacement::GetCopyNo
G4int GetCopyNo() const
Definition: G4PVPlacement.hh:117
G4VPhysicalVolume::GetMotherLogical
G4LogicalVolume * GetMotherLogical() const
G4VPhysicalVolume::GetTranslation
const G4ThreeVector GetTranslation() const
Definition: G4VPhysicalVolume.cc:142
G4VPhysicalVolume::GetCopyNo
virtual G4int GetCopyNo() const =0
G4VPhysicalVolume::GetName
const G4String & GetName() const
G4VSolid::Inside
virtual EInside Inside(const G4ThreeVector &p) const =0
G4VSolid::DistanceToOut
virtual G4double DistanceToOut(const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const =0
G4VSolid::GetPointOnSurface
virtual G4ThreeVector GetPointOnSurface() const
Definition: G4VSolid.cc:140
G4VSolid::BoundingLimits
virtual void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const
Definition: G4VSolid.cc:653
G4VSolid::DistanceToIn
virtual G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const =0
G4VSolid::GetEntityType
virtual G4GeometryType GetEntityType() const =0
kInside
@ kInside
Definition: geomdefs.hh:70
kOutside
@ kOutside
Definition: geomdefs.hh:68
kSurface
@ kSurface
Definition: geomdefs.hh:69

Referenced by G4PVPlacement().

◆ GetCopyNo()

G4int G4PVPlacement::GetCopyNo ( ) const
inlinevirtual

Implements G4VPhysicalVolume.

Definition at line 117 of file G4PVPlacement.hh.

117{ return fcopyNo; }

Referenced by CheckOverlaps().

◆ GetParameterisation()

G4VPVParameterisation * G4PVPlacement::GetParameterisation ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 196 of file G4PVPlacement.cc.

197{
198 return nullptr;
199}

◆ GetRegularStructureId()

G4int G4PVPlacement::GetRegularStructureId ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 225 of file G4PVPlacement.cc.

226{
227 return 0;
228}

◆ GetReplicationData()

void G4PVPlacement::GetReplicationData ( EAxis &  axis,
G4int &  nReplicas,
G4double &  width,
G4double &  offset,
G4bool &  consuming 
) const
virtual

Implements G4VPhysicalVolume.

Definition at line 204 of file G4PVPlacement.cc.

206{
207 // No-operations
208}

◆ IsMany()

G4bool G4PVPlacement::IsMany ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 164 of file G4PVPlacement.cc.

165{
166 return fmany;
167}

◆ IsParameterised()

G4bool G4PVPlacement::IsParameterised ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 188 of file G4PVPlacement.cc.

189{
190 return false;
191}

◆ IsRegularStructure()

G4bool G4PVPlacement::IsRegularStructure ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 215 of file G4PVPlacement.cc.

216{
217 return false;
218}

◆ IsReplicated()

G4bool G4PVPlacement::IsReplicated ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 180 of file G4PVPlacement.cc.

181{
182 return false;
183}

◆ operator=()

G4PVPlacement & G4PVPlacement::operator= ( const G4PVPlacement &  )
delete

◆ SetCopyNo()

void G4PVPlacement::SetCopyNo ( G4int  CopyNo)
virtual

Implements G4VPhysicalVolume.

Definition at line 172 of file G4PVPlacement.cc.

173{
174 fcopyNo = newCopyNo;
175}

◆ VolumeType()

EVolume G4PVPlacement::VolumeType ( ) const
virtual

Implements G4VPhysicalVolume.

Definition at line 235 of file G4PVPlacement.cc.

236{
237 return kNormal;
238}
kNormal
@ kNormal
Definition: geomdefs.hh:84
The documentation for this class was generated from the following files: