TSDetectorConstruction Class Reference

#include <TSDetectorConstruction.hh>

Inheritance diagram for TSDetectorConstruction:

Collaboration 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
Public Member Functions inherited from G4VUserDetectorConstruction
	G4VUserDetectorConstruction ()
virtual	~G4VUserDetectorConstruction ()
virtual void	CloneSD ()
virtual void	CloneF ()
void	RegisterParallelWorld (G4VUserParallelWorld *)
G4int	ConstructParallelGeometries ()
void	ConstructParallelSD ()
G4int	GetNumberOfParallelWorld () const
G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Static Public Member Functions
static TSDetectorConstruction *	Instance ()

Protected Member Functions
virtual MaterialCollection_t	ConstructMaterials ()
virtual G4VPhysicalVolume *	ConstructWorld (const MaterialCollection_t &)
virtual void	ConstructSDandField ()
Protected Member Functions inherited from G4VUserDetectorConstruction
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)

Detailed Description

Definition at line 74 of file TSDetectorConstruction.hh.

Member Typedef Documentation

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

Definition at line 77 of file TSDetectorConstruction.hh.

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

Definition at line 78 of file TSDetectorConstruction.hh.

Constructor & Destructor Documentation

TSDetectorConstruction::TSDetectorConstruction

(

)

Definition at line 92 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 ( )

virtual

Definition at line 107 of file TSDetectorConstruction.cc.

{
  fgInstance = 0;
}

Member Function Documentation

G4VPhysicalVolume * TSDetectorConstruction::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 114 of file TSDetectorConstruction.cc.

{
    return ConstructWorld(ConstructMaterials());
}

Here is the call graph for this function:

TSDetectorConstruction::MaterialCollection_t TSDetectorConstruction::ConstructMaterials ( )

protectedvirtual

Definition at line 122 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void TSDetectorConstruction::ConstructSDandField ( )

protectedvirtual

Reimplemented from G4VUserDetectorConstruction.

Definition at line 277 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);
    }
}

Here is the call graph for this function:

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

protectedvirtual

Definition at line 137 of file TSDetectorConstruction.cc.

{
    G4UserLimits* steplimit = new G4UserLimits(0.1*(fTargetDim.z()
                                                    /fTargetSections.z()));
    G4bool check_overlap = true;

    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const G4String& TSDetectorConstruction::GetMFDName ( ) const

inline

Definition at line 91 of file TSDetectorConstruction.hh.

{ return fMfdName; }

const ScoringVolumes_t& TSDetectorConstruction::GetScoringVolumes ( ) const

inline

Definition at line 89 of file TSDetectorConstruction.hh.

    { return fScoringVolumes; }

const G4ThreeVector& TSDetectorConstruction::GetWorldDimensions ( ) const

inline

Definition at line 88 of file TSDetectorConstruction.hh.

{ return fWorldDim; }

Here is the caller graph for this function:

TSDetectorConstruction * TSDetectorConstruction::Instance ( void  )

static

Definition at line 85 of file TSDetectorConstruction.cc.

{
  return fgInstance;
}

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p02/examples/extended/parallel/ThreadsafeScorers/include/TSDetectorConstruction.hh
• source/geant4.10.03.p02/examples/extended/parallel/ThreadsafeScorers/src/TSDetectorConstruction.cc