Par04ParallelFastWorld Class Reference

#include <Par04ParallelFastWorld.hh>

Inheritance diagram for Par04ParallelFastWorld:

Public Member Functions
	Par04ParallelFastWorld (G4String aWorldName, const Par04DetectorConstruction *aMassDetector, const Par04ParallelFullWorld *aParallelFull)
	~Par04ParallelFastWorld ()
virtual void	Construct () final
virtual void	ConstructSD () final
void	Print ()

Private Attributes
const Par04DetectorConstruction *	fMassDetector
	Messenger that allows to modify geometry.
const Par04ParallelFullWorld *	fParallelFull
std::vector< G4LogicalVolume * >	fLogicalCell
G4int	fNbOfLayers = 1
G4int	fNbOfSlices = 1
G4int	fNbOfRows = 1
G4double	fLayerThickness = 0

Detailed Description

Definition at line 38 of file Par04ParallelFastWorld.hh.

Constructor & Destructor Documentation

Par04ParallelFastWorld()

Par04ParallelFastWorld::Par04ParallelFastWorld	(	G4String	aWorldName,
		const Par04DetectorConstruction *	aMassDetector,
		const Par04ParallelFullWorld *	aParallelFull
	)

Definition at line 52 of file Par04ParallelFastWorld.cc.

  :G4VUserParallelWorld(aWorldName), fMassDetector(aMassDetector), fParallelFull(aParallelFull) {
  fNbOfLayers = fMassDetector->GetNbOfLayers();
}

~Par04ParallelFastWorld()

Par04ParallelFastWorld::~Par04ParallelFastWorld ( )

default

Member Function Documentation

Construct()

void Par04ParallelFastWorld::Construct ( )

finalvirtual

Definition at line 65 of file Par04ParallelFastWorld.cc.

{
  // In parallel world material does not matter
  G4Material* dummy   = nullptr;
 
  // Build parallel geometry:
  auto parallelLogicalVolume = GetWorld()->GetLogicalVolume();
 
  G4double detectorInnerRadius = fMassDetector->GetInnerRadius();
  G4double detectorLength = fMassDetector->GetLength();
  G4double fullLayerThickness = fMassDetector->GetAbsorberThickness(0)
    + fMassDetector->GetAbsorberThickness(1);
  fLayerThickness = fullLayerThickness;
  // Get an updated value
  fNbOfLayers = fMassDetector->GetNbOfLayers();
  fNbOfSlices = fParallelFull->GetNbOfSlices();
  fNbOfRows = fParallelFull->GetNbOfRows();
  G4double detectorRadius = fNbOfLayers * fullLayerThickness;
  G4double detectorOuterRadius = detectorInnerRadius + detectorRadius;
  G4double rowThickness = detectorLength / fNbOfRows;
  G4double full2Pi = 2.* CLHEP::pi * rad;
  Print();
 
  // Insert cells to create a readout structure that contains both passive and active materials
  // Mostly a copy from the detector construction
  auto solidDetector = new G4Tubs("Detector",                // name
                                   detectorInnerRadius,      // inner radius
                                   detectorOuterRadius,      // outer radius
                                   detectorLength / 2.,      // half-width in Z
                                   0,                        // start angle
                                   full2Pi);                 // delta angle
  auto logicDetector = new G4LogicalVolume(solidDetector,    // solid
                                            dummy,           // material
                                            "Detector");     // name
  new G4PVPlacement(0,                                       // no rotation
                    G4ThreeVector(0, 0, 0),                  // detector centre at (0,0,0)
                    logicDetector,                           // logical volume
                    "Detector",                              // name
                    parallelLogicalVolume,                   // mother volume
                    false,                                   // not used
                    9999,                                    // copy number
                    true);                                   // check overlaps
 
 
  //--------- Detector cylinder (division along z axis)  ---------
  auto solidRow = new G4Tubs("Row", detectorInnerRadius, detectorOuterRadius, rowThickness / 2.,
                             0,  full2Pi);
 
  auto logicRow = new G4LogicalVolume(solidRow, dummy, "Row");
  if (fNbOfRows > 1)
    new G4PVReplica("Row",
                    logicRow,
                    logicDetector,
                    kZAxis,
                    fNbOfRows,
                    rowThickness);
  else
    new G4PVPlacement(0,
                      G4ThreeVector(),
                      logicRow,
                      "Row",
                      logicDetector,
                      false,
                      0);
 
  //--------- Detector slices (division in azimuthal angle)  ---------
  G4double cellPhi = full2Pi / fNbOfSlices;
  auto solidSlice = new G4Tubs("Slice", detectorInnerRadius, detectorOuterRadius, rowThickness/2,
                               0, cellPhi);
  auto logicSlice = new G4LogicalVolume(solidSlice,
                                        dummy,
                                        "Slice");
  if(fNbOfSlices>1) {
    new G4PVReplica("Slice",
                    logicSlice,
                    logicRow,
                    kPhi,
                    fNbOfSlices,
                    cellPhi,
                    -cellPhi);
  } else {
      new G4PVPlacement(0,
                        G4ThreeVector(),
                        logicSlice,
                        "Slice",
                        logicRow,
                        false,
                        0);
  }
 
  //--------- Detector cells (division along radial axis)  ---------
  G4VisAttributes attribs;
  attribs.SetColour(G4Colour(0, 1, 0, 0.1));
  attribs.SetForceSolid(true);
  if(fNbOfLayers>1) {
    auto solidCell = new G4Tubs("Cell", detectorInnerRadius,
                                detectorInnerRadius + fLayerThickness,
                                rowThickness/2, 0, cellPhi);
    fLogicalCell.push_back(new G4LogicalVolume(solidCell, dummy, "Cell_0"));
    new G4PVReplica("Cell",
                    fLogicalCell.back(),
                    logicSlice,
                    kRho,
                    fNbOfLayers,
                    fLayerThickness,
                    detectorInnerRadius);
  } else {
    auto solidCell = new G4Tubs("Cell", detectorInnerRadius,
                                  detectorInnerRadius + fLayerThickness,
                                  rowThickness/2, 0, cellPhi);
      fLogicalCell.push_back(new G4LogicalVolume(solidCell, dummy, "Cell"));
      fLogicalCell.back()->SetVisAttributes(attribs);
      new G4PVPlacement(0,
                        G4ThreeVector(),
                        fLogicalCell.back(),
                        "Cell",
                        logicSlice,
                        false,
                        0);
  }
  Print();
}

ConstructSD()

void Par04ParallelFastWorld::ConstructSD ( )

finalvirtual

Definition at line 190 of file Par04ParallelFastWorld.cc.

{
  // -- sensitive detectors:
  G4SDManager* SDman = G4SDManager::GetSDMpointer();
  Par04ParallelFastSensitiveDetector* caloSD =
    new Par04ParallelFastSensitiveDetector("parallelFastSD", fNbOfLayers, fNbOfSlices);
  SDman->AddNewDetector(caloSD);
  for(const auto& logicalCell: fLogicalCell)
   logicalCell->SetSensitiveDetector(caloSD);
}

Print()

void Par04ParallelFastWorld::Print

(

)

Definition at line 203 of file Par04ParallelFastWorld.cc.

                                   {
  G4cout << "\n------------------------------------------------------"
         << "\n Readout geometry with physics layout is set in parallel geometry:\t"
         << "\n Cylindrical detector is divided along radius (layers), phi (slices), and z (rows)."
         << "\n Number of layers is determined by number of layers set in detector construction. "
         << "\n- Number of layers: " << fNbOfLayers << "\n------- Number of slices: " << fNbOfSlices
         << "\n- Number of rows: " << fNbOfRows;
  G4cout << "\n Readout will collect energy from fast simulation.\n------- Thickness is "
         <<  "a sum of all absorbers" << " = " << G4BestUnit(fLayerThickness, "Length")
         << "\n-----------------------------------------------------" << G4endl;
}

Member Data Documentation

fMassDetector

const Par04DetectorConstruction* Par04ParallelFastWorld::fMassDetector

private

Messenger that allows to modify geometry.

Definition at line 53 of file Par04ParallelFastWorld.hh.

fParallelFull

const Par04ParallelFullWorld* Par04ParallelFastWorld::fParallelFull

private

Definition at line 54 of file Par04ParallelFastWorld.hh.

fLogicalCell

std::vector<G4LogicalVolume*> Par04ParallelFastWorld::fLogicalCell

private

Definition at line 55 of file Par04ParallelFastWorld.hh.

fNbOfLayers

G4int Par04ParallelFastWorld::fNbOfLayers = 1

private

Definition at line 56 of file Par04ParallelFastWorld.hh.

fNbOfSlices

G4int Par04ParallelFastWorld::fNbOfSlices = 1

private

Definition at line 57 of file Par04ParallelFastWorld.hh.

fNbOfRows

G4int Par04ParallelFastWorld::fNbOfRows = 1

private

Definition at line 58 of file Par04ParallelFastWorld.hh.

fLayerThickness

G4double Par04ParallelFastWorld::fLayerThickness = 0

private

Definition at line 59 of file Par04ParallelFastWorld.hh.

---

The documentation for this class was generated from the following files:

• extended/parameterisations/Par04/include/Par04ParallelFastWorld.hh
• extended/parameterisations/Par04/src/Par04ParallelFastWorld.cc