Par04ParallelFullWorld Class Reference

#include <Par04ParallelFullWorld.hh>

Inheritance diagram for Par04ParallelFullWorld:

Public Member Functions
	Par04ParallelFullWorld (G4String aWorldName, const Par04DetectorConstruction *aMassDetector)
	~Par04ParallelFullWorld ()
virtual void	Construct () final
virtual void	ConstructSD () final
void	SetNbOfSlices (G4int aNumber)
	Set number of slices.
G4int	GetNbOfSlices () const
	Get number of slices.
void	SetNbOfRows (G4int aNumber)
	Set number of rows.
G4int	GetNbOfRows () const
	Get number of rows.
G4int	GetNbOfLayers () const
	Get number of layers.
void	Print ()

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

Detailed Description

Definition at line 37 of file Par04ParallelFullWorld.hh.

Constructor & Destructor Documentation

Par04ParallelFullWorld()

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

Definition at line 52 of file Par04ParallelFullWorld.cc.

  :G4VUserParallelWorld(aWorldName), fMassDetector(aMassDetector) {
  fParallelMessenger         = new Par04ParallelMessenger(this);
  fNbOfLayers = fMassDetector->GetNbOfLayers();
}

~Par04ParallelFullWorld()

Par04ParallelFullWorld::~Par04ParallelFullWorld ( )

default

Member Function Documentation

Construct()

void Par04ParallelFullWorld::Construct ( )

finalvirtual

Definition at line 65 of file Par04ParallelFullWorld.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);
  G4double sensitiveLayerOffset = 0;
  if(fMassDetector->GetAbsorberSensitivity(0))
    fLayerThickness = fMassDetector->GetAbsorberThickness(0);
  else
    sensitiveLayerOffset = fMassDetector->GetAbsorberThickness(0);
  if(fMassDetector->GetAbsorberSensitivity(1))
    fLayerThickness += fMassDetector->GetAbsorberThickness(1);
 
  fNbOfLayers = fMassDetector->GetNbOfLayers(); // Get an updated value
  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(fNbOfLayers>1 && fullLayerThickness == fLayerThickness) {
    new G4PVReplica("Slice",
                    logicSlice,
                    logicRow,
                    kPhi,
                    fNbOfSlices,
                    cellPhi,
                    -cellPhi);
  } else {
    // full simulation readout, cannot use replica because of gaps between absorbers
    for (int iSlice = 0; iSlice<fNbOfSlices; iSlice++) {
      auto  rotation = new G4RotationMatrix();
      rotation->setPhi((iSlice+0.5)*cellPhi);
      new G4PVPlacement(rotation,
                        G4ThreeVector(),
                        logicSlice,
                        "Slice_"+std::to_string(iSlice),
                        logicRow,
                        false,
                        iSlice);
    }
  }
 
  //--------- Detector cells (division along radial axis)  ---------
  G4VisAttributes attribs;
  attribs.SetColour(G4Colour(0, 1, 0, 0.1));
  attribs.SetForceSolid(true);
  if(fNbOfLayers>1 && fullLayerThickness == fLayerThickness) {
    auto solidCell = new G4Tubs("Cell", detectorInnerRadius + sensitiveLayerOffset,
                                detectorInnerRadius + sensitiveLayerOffset + 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 {
    // full simulation readout, cannot use replica because of gaps between absorbers
    for (int iLayer = 0; iLayer<fNbOfLayers; iLayer++) {
      auto solidCell = new G4Tubs("Cell_"+std::to_string(iLayer),
                                  detectorInnerRadius + iLayer * fullLayerThickness
                                  + sensitiveLayerOffset,
                                  detectorInnerRadius + iLayer * fullLayerThickness
                                  + sensitiveLayerOffset + fLayerThickness,
                                  rowThickness/2, 0, cellPhi);
      fLogicalCell.push_back(new G4LogicalVolume(solidCell, dummy, "Cell_"+std::to_string(iLayer)));
      fLogicalCell.back()->SetVisAttributes(attribs);
      new G4PVPlacement(0,
                        G4ThreeVector(),
                        fLogicalCell.back(),
                        "Cell_"+std::to_string(iLayer),
                        logicSlice,
                        false,
                        iLayer);
    }
  }
  Print();
}

ConstructSD()

void Par04ParallelFullWorld::ConstructSD ( )

finalvirtual

Definition at line 205 of file Par04ParallelFullWorld.cc.

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

SetNbOfSlices()

void Par04ParallelFullWorld::SetNbOfSlices ( G4int  aNumber )

inline

Set number of slices.

Definition at line 48 of file Par04ParallelFullWorld.hh.

{ fNbOfSlices = aNumber; };

GetNbOfSlices()

G4int Par04ParallelFullWorld::GetNbOfSlices ( ) const

inline

Get number of slices.

Definition at line 50 of file Par04ParallelFullWorld.hh.

{ return fNbOfSlices; };

SetNbOfRows()

void Par04ParallelFullWorld::SetNbOfRows ( G4int  aNumber )

inline

Set number of rows.

Definition at line 52 of file Par04ParallelFullWorld.hh.

{ fNbOfRows = aNumber; };

GetNbOfRows()

G4int Par04ParallelFullWorld::GetNbOfRows ( ) const

inline

Get number of rows.

Definition at line 54 of file Par04ParallelFullWorld.hh.

{ return fNbOfRows; };

GetNbOfLayers()

G4int Par04ParallelFullWorld::GetNbOfLayers ( ) const

inline

Get number of layers.

Definition at line 56 of file Par04ParallelFullWorld.hh.

{ return fNbOfLayers; };

Print()

void Par04ParallelFullWorld::Print

(

)

Definition at line 218 of file Par04ParallelFullWorld.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 for full simulation.\n------- Therefore thickness is "
         << "only a thickness of sensitive absorbers = " << G4BestUnit(fLayerThickness, "Length")
         << "\n-----------------------------------------------------" << G4endl;
}

Member Data Documentation

fParallelMessenger

Par04ParallelMessenger* Par04ParallelFullWorld::fParallelMessenger = nullptr

private

Messenger that allows to modify geometry.

Definition at line 62 of file Par04ParallelFullWorld.hh.

fMassDetector

const Par04DetectorConstruction* Par04ParallelFullWorld::fMassDetector

private

Definition at line 63 of file Par04ParallelFullWorld.hh.

fLogicalCell

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

private

Definition at line 64 of file Par04ParallelFullWorld.hh.

fNbOfLayers

G4int Par04ParallelFullWorld::fNbOfLayers = 1

private

Definition at line 65 of file Par04ParallelFullWorld.hh.

fNbOfSlices

G4int Par04ParallelFullWorld::fNbOfSlices = 1

private

Definition at line 66 of file Par04ParallelFullWorld.hh.

fNbOfRows

G4int Par04ParallelFullWorld::fNbOfRows = 1

private

Definition at line 67 of file Par04ParallelFullWorld.hh.

fLayerThickness

G4double Par04ParallelFullWorld::fLayerThickness = 0

private

Definition at line 68 of file Par04ParallelFullWorld.hh.

---

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

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