Geant4 11.2.2
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)
 
 ~G4PVPlacement () override
 
G4int GetCopyNo () const override
 
void SetCopyNo (G4int CopyNo) override
 
G4bool CheckOverlaps (G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1) override
 
 G4PVPlacement (__void__ &)
 
 G4PVPlacement (const G4PVPlacement &)=delete
 
G4PVPlacement & operator= (const G4PVPlacement &)=delete
 
G4bool IsMany () const override
 
G4bool IsReplicated () const override
 
G4bool IsParameterised () const override
 
G4VPVParameterisation * GetParameterisation () const override
 
void GetReplicationData (EAxis &axis, G4int &nReplicas, G4double &width, G4double &offset, G4bool &consuming) const override
 
G4bool IsRegularStructure () const override
 
G4int GetRegularStructureId () const override
 
EVolume VolumeType () const override
 
- 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
 
 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 41 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 97 of file G4PVPlacement.cc.

105 : G4VPhysicalVolume(pRot, tlate, pName, pCurrentLogical, nullptr),
106 fmany(pMany), fcopyNo(pCopyNo)
107{
108 if (pCurrentLogical == pMotherLogical)
109 {
110 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
111 FatalException, "Cannot place a volume inside itself!");
112 }
113 SetMotherLogical(pMotherLogical);
114 if (pMotherLogical != nullptr) { pMotherLogical->AddDaughter(this); }
115 if ((pSurfChk) && ((pMotherLogical) != nullptr)) { CheckOverlaps(); }
116}
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4LogicalVolume::AddDaughter
void AddDaughter(G4VPhysicalVolume *p)
Definition G4LogicalVolume.cc:281
G4PVPlacement::CheckOverlaps
G4bool CheckOverlaps(G4int res=1000, G4double tol=0., G4bool verbose=true, G4int maxErr=1) override
Definition G4PVPlacement.cc:243
G4VPhysicalVolume::G4VPhysicalVolume
G4VPhysicalVolume(G4RotationMatrix *pRot, const G4ThreeVector &tlate, const G4String &pName, G4LogicalVolume *pLogical, G4VPhysicalVolume *pMother)
Definition G4VPhysicalVolume.cc:54
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 != nullptr) { pMotherLogical->AddDaughter(this); }
141 if ((pSurfChk) && ((pMotherLogical) != nullptr)) { CheckOverlaps(); }
142}
CLHEP::HepRotation::inverse
HepRotation inverse() const
G4VPhysicalVolume::GetRotation
const G4RotationMatrix * GetRotation() const
Definition G4VPhysicalVolume.cc:160
G4VPhysicalVolume::SetRotation
void SetRotation(G4RotationMatrix *)
Definition G4VPhysicalVolume.cc:170
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 40 of file G4PVPlacement.cc.

48 : G4VPhysicalVolume(pRot, tlate, pName, pLogical, pMother),
49 fmany(pMany), fcopyNo(pCopyNo)
50{
51 if (pMother != nullptr)
52 {
53 G4LogicalVolume* motherLogical = pMother->GetLogicalVolume();
54 if (pLogical == motherLogical)
55 {
56 G4Exception("G4PVPlacement::G4PVPlacement()", "GeomVol0002",
57 FatalException, "Cannot place a volume inside itself!");
58 }
59 SetMotherLogical(motherLogical);
60 motherLogical->AddDaughter(this);
61 if (pSurfChk) { CheckOverlaps(); }
62 }
63}
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 68 of file G4PVPlacement.cc.

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

◆ ~G4PVPlacement()

G4PVPlacement::~G4PVPlacement ( )
override

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 )
overridevirtual

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

◆ GetCopyNo()

G4int G4PVPlacement::GetCopyNo ( ) const
inlineoverridevirtual

Implements G4VPhysicalVolume.

Definition at line 111 of file G4PVPlacement.hh.

111{ return fcopyNo; }

Referenced by CheckOverlaps().

◆ GetParameterisation()

G4VPVParameterisation * G4PVPlacement::GetParameterisation ( ) const
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 196 of file G4PVPlacement.cc.

197{
198 return nullptr;
199}

◆ GetRegularStructureId()

G4int G4PVPlacement::GetRegularStructureId ( ) const
overridevirtual

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
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 204 of file G4PVPlacement.cc.

206{
207 // No-operations
208}

◆ IsMany()

G4bool G4PVPlacement::IsMany ( ) const
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 164 of file G4PVPlacement.cc.

165{
166 return fmany;
167}

◆ IsParameterised()

G4bool G4PVPlacement::IsParameterised ( ) const
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 188 of file G4PVPlacement.cc.

189{
190 return false;
191}

◆ IsRegularStructure()

G4bool G4PVPlacement::IsRegularStructure ( ) const
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 215 of file G4PVPlacement.cc.

216{
217 return false;
218}

◆ IsReplicated()

G4bool G4PVPlacement::IsReplicated ( ) const
overridevirtual

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)
overridevirtual

Implements G4VPhysicalVolume.

Definition at line 172 of file G4PVPlacement.cc.

173{
174 fcopyNo = newCopyNo;
175}

◆ VolumeType()

EVolume G4PVPlacement::VolumeType ( ) const
overridevirtual

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: