TSDetectorConstruction Class Reference

#include <Doxymodules_parallel.h>

Inheritance diagram for TSDetectorConstruction:

Public Types
typedef std::map< G4String, G4Material * >	MaterialCollection_t
typedef std::set< G4LogicalVolume * >	ScoringVolumes_t

Public Member Functions
	TSDetectorConstruction ()
virtual	~TSDetectorConstruction ()
G4VPhysicalVolume *	Construct ()
const G4ThreeVector &	GetWorldDimensions () const
const ScoringVolumes_t &	GetScoringVolumes () const
const G4String &	GetMFDName () const
G4int	GetTotalTargets () const

Static Public Member Functions
static TSDetectorConstruction *	Instance ()

Protected Member Functions
virtual MaterialCollection_t	ConstructMaterials ()
virtual G4VPhysicalVolume *	ConstructWorld (const MaterialCollection_t &)
virtual void	ConstructSDandField ()

Private Attributes
G4VPhysicalVolume *	fWorldPhys
ScoringVolumes_t	fScoringVolumes
G4String	fWorldMaterialName
G4String	fTargetMaterialName
G4String	fCasingMaterialName
G4ThreeVector	fWorldDim
G4ThreeVector	fTargetDim
G4ThreeVector	fTargetSections
G4String	fMfdName

Static Private Attributes
static TSDetectorConstruction *	fgInstance = 0

Detailed Description

Definition at line 146 of file Doxymodules_parallel.h.

Member Typedef Documentation

MaterialCollection_t

typedef std::map<G4String, G4Material*> TSDetectorConstruction::MaterialCollection_t

Definition at line 74 of file TSDetectorConstruction.hh.

ScoringVolumes_t

typedef std::set<G4LogicalVolume*> TSDetectorConstruction::ScoringVolumes_t

Definition at line 75 of file TSDetectorConstruction.hh.

Constructor & Destructor Documentation

TSDetectorConstruction()

TSDetectorConstruction::TSDetectorConstruction

(

)

Definition at line 88 of file TSDetectorConstruction.cc.

  : fWorldPhys(0)
  , fWorldMaterialName("G4_Galactic")
  , fTargetMaterialName("G4_B")
  , fCasingMaterialName("G4_WATER")
  , fWorldDim(G4ThreeVector(0.5 * m, 0.5 * m, 0.5 * m))
  , fTargetDim(G4ThreeVector(0.5 * m, 0.5 * m, 0.5 * m))
  , fTargetSections(G4ThreeVector(5, 5, 5))
  , fMfdName("Target_MFD")
{
  fgInstance = this;
}

~TSDetectorConstruction()

TSDetectorConstruction::~TSDetectorConstruction ( )

virtual

Definition at line 103 of file TSDetectorConstruction.cc.

{ fgInstance = 0; }

Member Function Documentation

Instance()

TSDetectorConstruction * TSDetectorConstruction::Instance ( )

static

Definition at line 81 of file TSDetectorConstruction.cc.

{
  return fgInstance;
}

Construct()

G4VPhysicalVolume * TSDetectorConstruction::Construct

(

)

Definition at line 107 of file TSDetectorConstruction.cc.

{
  return ConstructWorld(ConstructMaterials());
}

GetWorldDimensions()

const G4ThreeVector & TSDetectorConstruction::GetWorldDimensions ( ) const

inline

Definition at line 85 of file TSDetectorConstruction.hh.

{ return fWorldDim; }

GetScoringVolumes()

const ScoringVolumes_t & TSDetectorConstruction::GetScoringVolumes ( ) const

inline

Definition at line 86 of file TSDetectorConstruction.hh.

  {
    return fScoringVolumes;
  }

GetMFDName()

const G4String & TSDetectorConstruction::GetMFDName ( ) const

inline

Definition at line 90 of file TSDetectorConstruction.hh.

{ return fMfdName; }

GetTotalTargets()

G4int TSDetectorConstruction::GetTotalTargets ( ) const

inline

Definition at line 91 of file TSDetectorConstruction.hh.

  {
    return fTargetSections.x() * fTargetSections.y() * fTargetSections.z();
  }

ConstructMaterials()

TSDetectorConstruction::MaterialCollection_t TSDetectorConstruction::ConstructMaterials ( )

protectedvirtual

Definition at line 115 of file TSDetectorConstruction.cc.

{
  MaterialCollection_t materials;
  G4NistManager* nist = G4NistManager::Instance();
 
  materials["World"]  = nist->FindOrBuildMaterial(fWorldMaterialName);
  materials["Target"] = nist->FindOrBuildMaterial(fTargetMaterialName);
  materials["Casing"] = nist->FindOrBuildMaterial(fCasingMaterialName);
 
  return materials;
}

ConstructWorld()

G4VPhysicalVolume * TSDetectorConstruction::ConstructWorld ( const MaterialCollection_t &  materials )

protectedvirtual

Definition at line 129 of file TSDetectorConstruction.cc.

{
  G4UserLimits* steplimit =
    new G4UserLimits(0.1 * (fTargetDim.z() / fTargetSections.z()));
  G4bool check_overlap = false;
 
  G4Box* world_solid = new G4Box("World", 0.5 * fWorldDim.x(),
                                 0.5 * fWorldDim.y(), 0.5 * fWorldDim.z());
  G4LogicalVolume* world_log =
    new G4LogicalVolume(world_solid, materials.find("World")->second, "World");
  fWorldPhys = new G4PVPlacement(0, G4ThreeVector(0.), "World", world_log, 0,
                                 false, 0, check_overlap);
 
  G4int nz = fTargetSections.z();
  G4int ny = fTargetSections.y();
  G4int nx = fTargetSections.x();
 
  // spacing between sections
  G4double sx = fTargetDim.x() / fTargetSections.x();
  G4double sy = fTargetDim.y() / fTargetSections.y();
  G4double sz = fTargetDim.z() / fTargetSections.z();
 
  // G4cout << "World has dimensions : "
  //<< G4BestUnit(fWorldDim, "Length") << G4endl;
 
  //------------------------------------------------------------------------//
  // Set Visual Attributes
  //------------------------------------------------------------------------//
  G4VisAttributes* red   = new G4VisAttributes(G4Color(1., 0., 0., 1.0));
  G4VisAttributes* green = new G4VisAttributes(G4Color(0., 1., 0., 0.25));
  G4VisAttributes* blue  = new G4VisAttributes(G4Color(0., 0., 1., 0.1));
  G4VisAttributes* white = new G4VisAttributes(G4Color(1., 1., 1., 1.));
 
  white->SetVisibility(true);
  red->SetVisibility(true);
  green->SetVisibility(true);
  blue->SetVisibility(true);
 
  white->SetForceWireframe(true);
  red->SetForceSolid(true);
  green->SetForceSolid(true);
  blue->SetForceSolid(true);
 
  world_log->SetVisAttributes(white);
 
  for(G4int k = 0; k < nz; ++k)
    for(G4int j = 0; j < ny; ++j)
      for(G4int i = 0; i < nx; ++i)
      {
        // displacement of section
        G4double dx =
          0.5 * sx + static_cast<G4double>(i) * sx - 0.5 * fWorldDim.x();
        G4double dy =
          0.5 * sy + static_cast<G4double>(j) * sy - 0.5 * fWorldDim.y();
        G4double dz =
          0.5 * sz + static_cast<G4double>(k) * sz - 0.5 * fWorldDim.z();
        G4ThreeVector td = G4ThreeVector(dx, dy, -dz);
        // make unique name
        std::stringstream ss_name;
        ss_name << "Target_" << i << "_" << j << "_" << k;
 
        G4Box* target_solid =
          new G4Box(ss_name.str(), 0.5 * sx, 0.5 * sy, 0.5 * sz);
 
        G4Material* target_material = 0;
        G4bool is_casing            = true;
 
        if(j == 0 || j + 1 == ny || i == 0 || i + 1 == nx ||
           (nz > 1 && (k == 0 || k + 1 == nz)))
          target_material = materials.find("Casing")->second;
        else
        {
          target_material = materials.find("Target")->second;
          is_casing       = false;
        }
 
        G4LogicalVolume* target_log =
          new G4LogicalVolume(target_solid, target_material, ss_name.str());
 
        target_log->SetUserLimits(steplimit);
 
        new G4PVPlacement(0, td, ss_name.str(), target_log, fWorldPhys, true,
                          k * nx * ny + j * nx + i, check_overlap);
 
        fScoringVolumes.insert(target_log);
 
        if(is_casing)
          target_log->SetVisAttributes(blue);
        else
        {
          // making a checkerboard for kicks...
          G4bool even_z = (k % 2 == 0) ? true : false;
          G4bool even_y = (j % 2 == 0) ? true : false;
          G4bool even_x = (i % 2 == 0) ? true : false;
 
          G4VisAttributes* theColor = nullptr;
 
          if((even_z))
          {
            if((even_y && even_x) || (!even_y && !even_x))
              theColor = red;
            else
              theColor = green;
          }
          else  // ! even_z
          {
            if((!even_y && even_x) || (even_y && !even_x))
              theColor = red;
            else
              theColor = green;
          }
 
          target_log->SetVisAttributes(theColor);
        }
      }
 
  return fWorldPhys;
}

ConstructSDandField()

void TSDetectorConstruction::ConstructSDandField ( )

protectedvirtual

Definition at line 251 of file TSDetectorConstruction.cc.

{
  //------------------------------------------------//
  //            MultiFunctionalDetector             //
  //------------------------------------------------//
  // Define MultiFunctionalDetector with name.
  G4MultiFunctionalDetector* MFDet = new G4MultiFunctionalDetector(fMfdName);
  G4SDManager::GetSDMpointer()->AddNewDetector(MFDet);
  G4VPrimitiveScorer* edep = new G4PSEnergyDeposit("EnergyDeposit");
  MFDet->RegisterPrimitive(edep);
  G4VPrimitiveScorer* nstep = new G4PSNofStep("NumberOfSteps");
  MFDet->RegisterPrimitive(nstep);
 
  // add scoring volumes
  for(auto ite : fScoringVolumes)
  {
    SetSensitiveDetector(ite, MFDet);
  }
}

Member Data Documentation

fgInstance

TSDetectorConstruction * TSDetectorConstruction::fgInstance = 0

staticprivate

Definition at line 102 of file TSDetectorConstruction.hh.

fWorldPhys

G4VPhysicalVolume* TSDetectorConstruction::fWorldPhys

private

Definition at line 103 of file TSDetectorConstruction.hh.

fScoringVolumes

ScoringVolumes_t TSDetectorConstruction::fScoringVolumes

private

Definition at line 104 of file TSDetectorConstruction.hh.

fWorldMaterialName

G4String TSDetectorConstruction::fWorldMaterialName

private

Definition at line 105 of file TSDetectorConstruction.hh.

fTargetMaterialName

G4String TSDetectorConstruction::fTargetMaterialName

private

Definition at line 106 of file TSDetectorConstruction.hh.

fCasingMaterialName

G4String TSDetectorConstruction::fCasingMaterialName

private

Definition at line 107 of file TSDetectorConstruction.hh.

fWorldDim

G4ThreeVector TSDetectorConstruction::fWorldDim

private

Definition at line 108 of file TSDetectorConstruction.hh.

fTargetDim

G4ThreeVector TSDetectorConstruction::fTargetDim

private

Definition at line 109 of file TSDetectorConstruction.hh.

fTargetSections

G4ThreeVector TSDetectorConstruction::fTargetSections

private

Definition at line 110 of file TSDetectorConstruction.hh.

fMfdName

G4String TSDetectorConstruction::fMfdName

private

Definition at line 111 of file TSDetectorConstruction.hh.

---

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

• .doxygen/Doxymodules_parallel.h
• extended/parallel/ThreadsafeScorers/include/TSDetectorConstruction.hh
• extended/parallel/ThreadsafeScorers/src/TSDetectorConstruction.cc