B5::DetectorConstruction Class Reference

Detector construction. More...

#include <Doxymodules_basic.h>

Inheritance diagram for B5::DetectorConstruction:

Public Member Functions
	DetectorConstruction ()
	~DetectorConstruction () override
G4VPhysicalVolume *	Construct () override
void	ConstructSDandField () override
void	SetArmAngle (G4double val)
G4double	GetArmAngle ()
void	ConstructMaterials ()

Private Member Functions
void	DefineCommands ()

Private Attributes
G4GenericMessenger *	fMessenger = nullptr
G4LogicalVolume *	fHodoscope1Logical = nullptr
G4LogicalVolume *	fHodoscope2Logical = nullptr
G4LogicalVolume *	fWirePlane1Logical = nullptr
G4LogicalVolume *	fWirePlane2Logical = nullptr
G4LogicalVolume *	fCellLogical = nullptr
G4LogicalVolume *	fHadCalScintiLogical = nullptr
G4LogicalVolume *	fMagneticLogical = nullptr
G4double	fArmAngle = 30.*CLHEP::deg
G4RotationMatrix *	fArmRotation = nullptr
G4VPhysicalVolume *	fSecondArmPhys = nullptr

Static Private Attributes
static G4ThreadLocal MagneticField *	fMagneticField = nullptr
static G4ThreadLocal G4FieldManager *	fFieldMgr = nullptr

Detailed Description

Detector construction.

Definition at line 186 of file Doxymodules_basic.h.

Constructor & Destructor Documentation

DetectorConstruction()

B5::DetectorConstruction::DetectorConstruction

(

)

Definition at line 78 of file DetectorConstruction.cc.

{
  fArmRotation = new G4RotationMatrix();
  fArmRotation->rotateY(fArmAngle);
 
  // define commands for this class
  DefineCommands();
}

~DetectorConstruction()

B5::DetectorConstruction::~DetectorConstruction ( )

override

Definition at line 89 of file DetectorConstruction.cc.

{
  delete fArmRotation;
  delete fMessenger;
}

Member Function Documentation

Construct()

G4VPhysicalVolume * B5::DetectorConstruction::Construct ( )

override

Definition at line 97 of file DetectorConstruction.cc.

{
  // Construct materials
  ConstructMaterials();
  auto air = G4Material::GetMaterial("G4_AIR");
  //auto argonGas = G4Material::GetMaterial("_Ar");
  auto argonGas = G4Material::GetMaterial("G4_Ar");
  auto scintillator = G4Material::GetMaterial("G4_PLASTIC_SC_VINYLTOLUENE");
  auto csI = G4Material::GetMaterial("G4_CESIUM_IODIDE");
  auto lead = G4Material::GetMaterial("G4_Pb");
 
  // Option to switch on/off checking of volumes overlaps
  //
  G4bool checkOverlaps = true;
 
  // geometries --------------------------------------------------------------
  // experimental hall (world volume)
  auto worldSolid
    = new G4Box("worldBox",10.*m,3.*m,10.*m);
  auto worldLogical
    = new G4LogicalVolume(worldSolid,air,"worldLogical");
  auto worldPhysical = new G4PVPlacement(
    nullptr, G4ThreeVector(), worldLogical, "worldPhysical", nullptr, false, 0, checkOverlaps);
 
  // Tube with Local Magnetic field
 
  auto magneticSolid
    = new G4Tubs("magneticTubs",0.,1.*m,1.*m,0.,360.*deg);
 
  fMagneticLogical
    = new G4LogicalVolume(magneticSolid, air, "magneticLogical");
 
  // placement of Tube
 
  auto fieldRot = new G4RotationMatrix();
  fieldRot->rotateX(90.*deg);
  new G4PVPlacement(fieldRot,G4ThreeVector(),fMagneticLogical,
                    "magneticPhysical",worldLogical,
                    false,0,checkOverlaps);
 
  // set step limit in tube with magnetic field
  auto userLimits = new G4UserLimits(1 * m);
  fMagneticLogical->SetUserLimits(userLimits);
 
  // first arm
  auto firstArmSolid
    = new G4Box("firstArmBox",1.5*m,1.*m,3.*m);
  auto firstArmLogical
    = new G4LogicalVolume(firstArmSolid,air,"firstArmLogical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., -5. * m), firstArmLogical, "firstArmPhysical",
    worldLogical, false, 0, checkOverlaps);
 
  // second arm
  auto secondArmSolid
    = new G4Box("secondArmBox",2.*m,2.*m,3.5*m);
  auto secondArmLogical
    = new G4LogicalVolume(secondArmSolid,air,"secondArmLogical");
  auto x = -5.*m * std::sin(fArmAngle);
  auto z = 5.*m * std::cos(fArmAngle);
  fSecondArmPhys
    = new G4PVPlacement(fArmRotation,G4ThreeVector(x,0.,z),secondArmLogical,
                        "fSecondArmPhys",worldLogical,
                        false,0,checkOverlaps);
 
  // hodoscopes in first arm
  auto hodoscope1Solid
    = new G4Box("hodoscope1Box",5.*cm,20.*cm,0.5*cm);
  fHodoscope1Logical
    = new G4LogicalVolume(hodoscope1Solid,scintillator,"hodoscope1Logical");
 
  for (auto i=0;i<kNofHodoscopes1;i++) {
      G4double x1 = (i-kNofHodoscopes1/2)*10.*cm;
      new G4PVPlacement(nullptr, G4ThreeVector(x1, 0., -1.5 * m), fHodoscope1Logical,
        "hodoscope1Physical", firstArmLogical, false, i, checkOverlaps);
  }
 
  // drift chambers in first arm
  auto chamber1Solid
    = new G4Box("chamber1Box",1.*m,30.*cm,1.*cm);
  auto chamber1Logical
    = new G4LogicalVolume(chamber1Solid,argonGas,"chamber1Logical");
 
  for (auto i=0;i<kNofChambers;i++) {
    G4double z1 = (i-kNofChambers/2)*0.5*m;
    new G4PVPlacement(nullptr, G4ThreeVector(0., 0., z1), chamber1Logical, "chamber1Physical",
      firstArmLogical, false, i, checkOverlaps);
  }
 
  // "virtual" wire plane
  auto wirePlane1Solid
    = new G4Box("wirePlane1Box",1.*m,30.*cm,0.1*mm);
  fWirePlane1Logical
    = new G4LogicalVolume(wirePlane1Solid,argonGas,"wirePlane1Logical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 0.), fWirePlane1Logical, "wirePlane1Physical",
    chamber1Logical, false, 0, checkOverlaps);
 
  // hodoscopes in second arm
  auto hodoscope2Solid
    = new G4Box("hodoscope2Box",5.*cm,20.*cm,0.5*cm);
  fHodoscope2Logical
    = new G4LogicalVolume(hodoscope2Solid,scintillator,"hodoscope2Logical");
 
  for (auto i=0;i<kNofHodoscopes2;i++) {
      G4double x2 = (i-kNofHodoscopes2/2)*10.*cm;
      new G4PVPlacement(nullptr, G4ThreeVector(x2, 0., 0.), fHodoscope2Logical,
        "hodoscope2Physical", secondArmLogical, false, i, checkOverlaps);
  }
 
  // drift chambers in second arm
  auto chamber2Solid
    = new G4Box("chamber2Box",1.5*m,30.*cm,1.*cm);
  auto chamber2Logical
    = new G4LogicalVolume(chamber2Solid,argonGas,"chamber2Logical");
 
  for (auto i=0;i<kNofChambers;i++) {
    G4double z2 = (i-kNofChambers/2)*0.5*m - 1.5*m;
    new G4PVPlacement(nullptr, G4ThreeVector(0., 0., z2), chamber2Logical, "chamber2Physical",
      secondArmLogical, false, i, checkOverlaps);
  }
 
  // "virtual" wire plane
  auto wirePlane2Solid
    = new G4Box("wirePlane2Box",1.5*m,30.*cm,0.1*mm);
  fWirePlane2Logical
    = new G4LogicalVolume(wirePlane2Solid,argonGas,"wirePlane2Logical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 0.), fWirePlane2Logical, "wirePlane2Physical",
    chamber2Logical, false, 0, checkOverlaps);
 
  // CsI calorimeter
  auto emCalorimeterSolid
    = new G4Box("EMcalorimeterBox",1.5*m,30.*cm,15.*cm);
  auto emCalorimeterLogical
    = new G4LogicalVolume(emCalorimeterSolid,csI,"EMcalorimeterLogical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 2. * m), emCalorimeterLogical,
    "EMcalorimeterPhysical", secondArmLogical, false, 0, checkOverlaps);
 
  // EMcalorimeter cells
  auto cellSolid
    = new G4Box("cellBox",7.5*cm,7.5*cm,15.*cm);
  fCellLogical
    = new G4LogicalVolume(cellSolid,csI,"cellLogical");
  G4VPVParameterisation* cellParam = new CellParameterisation();
  new G4PVParameterised("cellPhysical",fCellLogical,emCalorimeterLogical,
                        kXAxis,kNofEmCells,cellParam);
 
  // hadron calorimeter
  auto hadCalorimeterSolid
    = new G4Box("HadCalorimeterBox",1.5*m,30.*cm,50.*cm);
  auto hadCalorimeterLogical
    = new G4LogicalVolume(hadCalorimeterSolid,lead,"HadCalorimeterLogical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 3. * m), hadCalorimeterLogical,
    "HadCalorimeterPhysical", secondArmLogical, false, 0, checkOverlaps);
 
  // hadron calorimeter column
  auto HadCalColumnSolid
    = new G4Box("HadCalColumnBox",15.*cm,30.*cm,50.*cm);
  auto HadCalColumnLogical
    = new G4LogicalVolume(HadCalColumnSolid,lead,"HadCalColumnLogical");
  new G4PVReplica("HadCalColumnPhysical",HadCalColumnLogical,
                  hadCalorimeterLogical,kXAxis,kNofHadColumns,30.*cm);
 
  // hadron calorimeter cell
  auto HadCalCellSolid
    = new G4Box("HadCalCellBox",15.*cm,15.*cm,50.*cm);
  auto HadCalCellLogical
    = new G4LogicalVolume(HadCalCellSolid,lead,"HadCalCellLogical");
  new G4PVReplica("HadCalCellPhysical",HadCalCellLogical,
                  HadCalColumnLogical,kYAxis,kNofHadRows,30.*cm);
 
  // hadron calorimeter layers
  auto HadCalLayerSolid
    = new G4Box("HadCalLayerBox",15.*cm,15.*cm,2.5*cm);
  auto HadCalLayerLogical
    = new G4LogicalVolume(HadCalLayerSolid,lead,"HadCalLayerLogical");
  new G4PVReplica("HadCalLayerPhysical",HadCalLayerLogical,
                  HadCalCellLogical,kZAxis,kNofHadCells,5.*cm);
 
  // scintillator plates
  auto HadCalScintiSolid
    = new G4Box("HadCalScintiBox",15.*cm,15.*cm,0.5*cm);
  fHadCalScintiLogical
    = new G4LogicalVolume(HadCalScintiSolid,scintillator,
                          "HadCalScintiLogical");
  new G4PVPlacement(nullptr, G4ThreeVector(0., 0., 2. * cm), fHadCalScintiLogical,
    "HadCalScintiPhysical", HadCalLayerLogical, false, 0, checkOverlaps);
 
  // visualization attributes ------------------------------------------------
 
  G4VisAttributes invisible(G4VisAttributes::GetInvisible());
  G4VisAttributes invisibleBlue(false, G4Colour::Blue());
  G4VisAttributes invisibleGreen(false, G4Colour::Green());
  G4VisAttributes invisibleYellow(false, G4Colour::Yellow());
  G4VisAttributes blue(G4Colour::Blue());
  G4VisAttributes cgray(G4Colour::Gray());
  G4VisAttributes green(G4Colour::Green());
  G4VisAttributes red(G4Colour::Red());
  G4VisAttributes yellow(G4Colour::Yellow());
 
  worldLogical->SetVisAttributes(invisible);
  firstArmLogical->SetVisAttributes(invisible);
  secondArmLogical->SetVisAttributes(invisible);
 
  fMagneticLogical->SetVisAttributes(cgray);
  fHodoscope1Logical->SetVisAttributes(red);
  fHodoscope2Logical->SetVisAttributes(red);
 
  chamber1Logical->SetVisAttributes(green);
  chamber2Logical->SetVisAttributes(green);
  fWirePlane1Logical->SetVisAttributes(invisibleGreen);
  fWirePlane2Logical->SetVisAttributes(invisibleGreen);
 
  emCalorimeterLogical->SetVisAttributes(invisibleYellow);
  fCellLogical->SetVisAttributes(yellow);
 
  hadCalorimeterLogical->SetVisAttributes(blue);
  HadCalColumnLogical->SetVisAttributes(invisibleBlue);
  HadCalCellLogical->SetVisAttributes(invisibleBlue);
  HadCalLayerLogical->SetVisAttributes(invisibleBlue);
  fHadCalScintiLogical->SetVisAttributes(invisibleBlue);
 
  // return the world physical volume ----------------------------------------
 
  return worldPhysical;
}

ConstructSDandField()

void B5::DetectorConstruction::ConstructSDandField ( )

override

Definition at line 324 of file DetectorConstruction.cc.

{
  // sensitive detectors -----------------------------------------------------
  auto sdManager = G4SDManager::GetSDMpointer();
  G4String SDname;
 
  auto hodoscope1 = new HodoscopeSD(SDname="/hodoscope1");
  sdManager->AddNewDetector(hodoscope1);
  fHodoscope1Logical->SetSensitiveDetector(hodoscope1);
 
  auto hodoscope2 = new HodoscopeSD(SDname="/hodoscope2");
  sdManager->AddNewDetector(hodoscope2);
  fHodoscope2Logical->SetSensitiveDetector(hodoscope2);
 
  auto chamber1 = new DriftChamberSD(SDname="/chamber1");
  sdManager->AddNewDetector(chamber1);
  fWirePlane1Logical->SetSensitiveDetector(chamber1);
 
  auto chamber2 = new DriftChamberSD(SDname="/chamber2");
  sdManager->AddNewDetector(chamber2);
  fWirePlane2Logical->SetSensitiveDetector(chamber2);
 
  auto emCalorimeter = new EmCalorimeterSD(SDname="/EMcalorimeter");
  sdManager->AddNewDetector(emCalorimeter);
  fCellLogical->SetSensitiveDetector(emCalorimeter);
 
  auto hadCalorimeter = new HadCalorimeterSD(SDname="/HadCalorimeter");
  sdManager->AddNewDetector(hadCalorimeter);
  fHadCalScintiLogical->SetSensitiveDetector(hadCalorimeter);
 
  // magnetic field ----------------------------------------------------------
  fMagneticField = new MagneticField();
  fFieldMgr = new G4FieldManager();
  fFieldMgr->SetDetectorField(fMagneticField);
  fFieldMgr->CreateChordFinder(fMagneticField);
  G4bool forceToAllDaughters = true;
  fMagneticLogical->SetFieldManager(fFieldMgr, forceToAllDaughters);
}

SetArmAngle()

void B5::DetectorConstruction::SetArmAngle

(

G4double

val

)

Definition at line 404 of file DetectorConstruction.cc.

{
  if (!fSecondArmPhys) {
      G4cerr << "Detector has not yet been constructed." << G4endl;
      return;
  }
 
  fArmAngle = val;
  *fArmRotation = G4RotationMatrix();  // make it unit vector
  fArmRotation->rotateY(fArmAngle);
  auto x = -5.*m * std::sin(fArmAngle);
  auto z = 5.*m * std::cos(fArmAngle);
  fSecondArmPhys->SetTranslation(G4ThreeVector(x,0.,z));
 
  // tell G4RunManager that we change the geometry
  G4RunManager::GetRunManager()->GeometryHasBeenModified();
}

GetArmAngle()

G4double B5::DetectorConstruction::GetArmAngle ( )

inline

Definition at line 62 of file DetectorConstruction.hh.

{ return fArmAngle; }

ConstructMaterials()

void B5::DetectorConstruction::ConstructMaterials

(

)

Definition at line 365 of file DetectorConstruction.cc.

{
  auto nistManager = G4NistManager::Instance();
 
  // Air
  nistManager->FindOrBuildMaterial("G4_AIR");
 
  // Argon gas
  nistManager->FindOrBuildMaterial("G4_Ar");
  // With a density different from the one defined in NIST
  // G4double density = 1.782e-03*g/cm3;
  // nistManager->BuildMaterialWithNewDensity("_Ar","G4_Ar",density);
  // !! cases segmentation fault
 
  // Scintillator
  // (PolyVinylToluene, C_9H_10)
  nistManager->FindOrBuildMaterial("G4_PLASTIC_SC_VINYLTOLUENE");
 
  // CsI
  nistManager->FindOrBuildMaterial("G4_CESIUM_IODIDE");
 
  // Lead
  nistManager->FindOrBuildMaterial("G4_Pb");
 
  // Vacuum "Galactic"
  // nistManager->FindOrBuildMaterial("G4_Galactic");
 
  // Vacuum "Air with low density"
  // auto air = G4Material::GetMaterial("G4_AIR");
  // G4double density = 1.0e-5*air->GetDensity();
  // nistManager
  //   ->BuildMaterialWithNewDensity("Air_lowDensity", "G4_AIR", density);
 
  G4cout << G4endl << "The materials defined are : " << G4endl << G4endl;
  G4cout << *(G4Material::GetMaterialTable()) << G4endl;
}

DefineCommands()

void B5::DetectorConstruction::DefineCommands ( )

private

Definition at line 424 of file DetectorConstruction.cc.

{
  // Define /B5/detector command directory using generic messenger class
  fMessenger = new G4GenericMessenger(this,
                                      "/B5/detector/",
                                      "Detector control");
 
  // armAngle command
  auto& armAngleCmd
    = fMessenger->DeclareMethodWithUnit("armAngle","deg",
                                &DetectorConstruction::SetArmAngle,
                                "Set rotation angle of the second arm.");
  armAngleCmd.SetParameterName("angle", true);
  armAngleCmd.SetRange("angle>=0. && angle<180.");
  armAngleCmd.SetDefaultValue("30.");
}

Member Data Documentation

fMagneticField

G4ThreadLocal MagneticField * B5::DetectorConstruction::fMagneticField = nullptr

staticprivate

Definition at line 69 of file DetectorConstruction.hh.

fFieldMgr

G4ThreadLocal G4FieldManager * B5::DetectorConstruction::fFieldMgr = nullptr

staticprivate

Definition at line 70 of file DetectorConstruction.hh.

fMessenger

G4GenericMessenger* B5::DetectorConstruction::fMessenger = nullptr

private

Definition at line 72 of file DetectorConstruction.hh.

fHodoscope1Logical

G4LogicalVolume* B5::DetectorConstruction::fHodoscope1Logical = nullptr

private

Definition at line 74 of file DetectorConstruction.hh.

fHodoscope2Logical

G4LogicalVolume* B5::DetectorConstruction::fHodoscope2Logical = nullptr

private

Definition at line 75 of file DetectorConstruction.hh.

fWirePlane1Logical

G4LogicalVolume* B5::DetectorConstruction::fWirePlane1Logical = nullptr

private

Definition at line 76 of file DetectorConstruction.hh.

fWirePlane2Logical

G4LogicalVolume* B5::DetectorConstruction::fWirePlane2Logical = nullptr

private

Definition at line 77 of file DetectorConstruction.hh.

fCellLogical

G4LogicalVolume* B5::DetectorConstruction::fCellLogical = nullptr

private

Definition at line 78 of file DetectorConstruction.hh.

fHadCalScintiLogical

G4LogicalVolume* B5::DetectorConstruction::fHadCalScintiLogical = nullptr

private

Definition at line 79 of file DetectorConstruction.hh.

fMagneticLogical

G4LogicalVolume* B5::DetectorConstruction::fMagneticLogical = nullptr

private

Definition at line 80 of file DetectorConstruction.hh.

fArmAngle

G4double B5::DetectorConstruction::fArmAngle = 30.*CLHEP::deg

private

Definition at line 82 of file DetectorConstruction.hh.

fArmRotation

G4RotationMatrix* B5::DetectorConstruction::fArmRotation = nullptr

private

Definition at line 83 of file DetectorConstruction.hh.

fSecondArmPhys

G4VPhysicalVolume* B5::DetectorConstruction::fSecondArmPhys = nullptr

private

Definition at line 84 of file DetectorConstruction.hh.

---

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

• .doxygen/Doxymodules_basic.h
• basic/B5/include/DetectorConstruction.hh
• basic/B5/src/DetectorConstruction.cc