#include <ExGflashDetectorConstruction.hh>

Inheritance diagram for ExGflashDetectorConstruction:

Collaboration diagram for ExGflashDetectorConstruction:

Public Member Functions
	ExGflashDetectorConstruction ()

	~ExGflashDetectorConstruction ()

virtual G4VPhysicalVolume *	Construct ()

virtual void	ConstructSDandField ()

const G4VPhysicalVolume *	GetCristal (int num__crystal)

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

Private Attributes
G4LogicalVolume *	fCrystal_log

G4VPhysicalVolume *	fCrystal_phys [100]

G4Region *	fRegion

Static Private Attributes
static G4ThreadLocal GFlashShowerModel *	fFastShowerModel = 0

static G4ThreadLocal GFlashHomoShowerParameterisation *	fParameterisation = 0

static G4ThreadLocal GFlashParticleBounds *	fParticleBounds = 0

static G4ThreadLocal GFlashHitMaker *	fHitMaker = 0

Additional Inherited Members
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 46 of file ExGflashDetectorConstruction.hh.

Constructor & Destructor Documentation

◆ ExGflashDetectorConstruction()

ExGflashDetectorConstruction::ExGflashDetectorConstruction ( )

Definition at line 72 of file ExGflashDetectorConstruction.cc.

   :G4VUserDetectorConstruction()
 {
   G4cout<<"ExGflashDetectorConstruction::Detector constructor"<<G4endl;
 }

◆ ~ExGflashDetectorConstruction()

ExGflashDetectorConstruction::~ExGflashDetectorConstruction ( )

Definition at line 80 of file ExGflashDetectorConstruction.cc.

 {
   delete fFastShowerModel; 
   delete fParameterisation;
   delete fParticleBounds;
   delete fHitMaker;
 }

Member Function Documentation

◆ Construct()

G4VPhysicalVolume * ExGflashDetectorConstruction::Construct ( void )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 90 of file ExGflashDetectorConstruction.cc.

 {
   //--------- Definitions of Solids, Logical Volumes, Physical Volumes ---------
   G4cout << "Defining the materials" << G4endl;
   // Get nist material manager
   G4NistManager* nistManager = G4NistManager::Instance();
   // Build materials
   G4Material* air   = nistManager->FindOrBuildMaterial("G4_AIR");
   G4Material* pbWO4 = nistManager->FindOrBuildMaterial("G4_PbWO4");
   
   /*******************************
    * The Experimental Hall       *
    *******************************/
   G4double experimentalHall_x=1000.*cm;
   G4double experimentalHall_y=1000.*cm;
   G4double experimentalHall_z=1000.*cm;
   
   G4VSolid* experimentalHall_box 
     = new G4Box("expHall_box",             // World Volume
                 experimentalHall_x,        // x size
                 experimentalHall_y,        // y size
                 experimentalHall_z);       // z size
   
   G4LogicalVolume* experimentalHall_log 
     = new G4LogicalVolume(experimentalHall_box,
                           air,
                           "expHall_log",
                           0,               //opt: fieldManager
                           0,               //opt: SensitiveDetector
                           0);              //opt: UserLimits
   G4VPhysicalVolume* experimentalHall_phys 
     = new G4PVPlacement(0,
                         G4ThreeVector(),   //at (0,0,0)
                         "expHall",
                         experimentalHall_log,
                         0,
                         false,
                         0);
   
   
   //------------------------------ 
   // Calorimeter segments
   //------------------------------
   // Simplified `CMS-like` PbWO4 crystal calorimeter  
   
   G4int nbOfCrystals = 10;  // this are the crystals PER ROW in this example 
                        // cube of 10 x 10 crystals 
                        // don't change it @the moment, since 
                        // the readout in event action assumes this 
                        // dimensions and is not automatically adapted
                        // in this version of the example :-( 
   // Simplified `CMS-like` PbWO4 crystal calorimeter  
   G4double calo_xside = 31*cm;
   G4double calo_yside = 31*cm;
   G4double calo_zside = 24*cm; 
 
   G4double crystalWidth = 3*cm;
   G4double crystalLength = 24*cm;
 
   calo_xside = (crystalWidth*nbOfCrystals)+1*cm;
   calo_yside = (crystalWidth*nbOfCrystals)+1*cm;
   calo_zside = crystalLength;
   
   G4Box* calo_box= new G4Box("CMS calorimeter",  // its name
                              calo_xside/2.,      // size
                              calo_yside/2.,
                              calo_zside/2.);
   G4LogicalVolume* calo_log 
     = new G4LogicalVolume(calo_box,      // its solid
                           air,           // its material
                           "calo log",    // its name
                           0,             // opt: fieldManager
                           0,             // opt: SensitiveDetector 
                           0);            // opt: UserLimit
   
   G4double xpos = 0.0;
   G4double ypos = 0.0;
   G4double zpos = 100.0*cm;
   new G4PVPlacement(0,
                     G4ThreeVector(xpos, ypos, zpos),
                     calo_log,
                     "calorimeter",
                     experimentalHall_log,
                     false,
                     1);
           
   // Crystals
   G4VSolid* crystal_box 
     = new G4Box("Crystal",                // its name
                  crystalWidth/2,
                  crystalWidth/2,
                  crystalLength/2);   
                            // size
   fCrystal_log 
     = new G4LogicalVolume(crystal_box,    // its solid
                           pbWO4,          // its material
                           "Crystal_log"); // its name
           
   for (G4int i=0; i<nbOfCrystals; i++)
     {
       
       for (G4int j=0; j<nbOfCrystals; j++)
         {  
           G4int n =  i*10+j;
           G4ThreeVector crystalPos((i*crystalWidth)-135,
                                    (j*crystalWidth)-135,0 );
           fCrystal_phys[n] 
             = new G4PVPlacement(0,               // no rotation
                                 crystalPos,      // translation
                                 fCrystal_log,
                                 "crystal",       // its name
                                 calo_log,
                                 false,
                                 i);
         }
     }  
   G4cout << "There are " << nbOfCrystals <<
     " crystals per row in the calorimeter, so in total "<<
     nbOfCrystals*nbOfCrystals << " crystals" << G4endl;  
   G4cout << "They have width of  " << crystalWidth /cm <<
     "  cm and a length of  " <<  crystalLength /cm
          <<" cm. The Material is "<< pbWO4 << G4endl;
   
   
   experimentalHall_log->SetVisAttributes(G4VisAttributes::Invisible);
   G4VisAttributes* caloVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
   G4VisAttributes* crystalVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,0.0));
   calo_log->SetVisAttributes(caloVisAtt);
   fCrystal_log->SetVisAttributes(crystalVisAtt);
 
   // define the fParameterisation region
   fRegion = new G4Region("crystals");
   calo_log->SetRegion(fRegion);
   fRegion->AddRootLogicalVolume(calo_log);
   
   return experimentalHall_phys;
 }

Here is the call graph for this function:

◆ ConstructSDandField()

void ExGflashDetectorConstruction::ConstructSDandField ( )

virtual

Reimplemented from G4VUserDetectorConstruction.

Definition at line 230 of file ExGflashDetectorConstruction.cc.

 {
   // -- sensitive detectors:
   G4SDManager* SDman = G4SDManager::GetSDMpointer();
   ExGflashSensitiveDetector* CaloSD
     = new ExGflashSensitiveDetector("Calorimeter",this);
   SDman->AddNewDetector(CaloSD);
   fCrystal_log->SetSensitiveDetector(CaloSD);
   
   // Get nist material manager
   G4NistManager* nistManager = G4NistManager::Instance();
   G4Material*          pbWO4 = nistManager->FindOrBuildMaterial("G4_PbWO4");
   // -- fast simulation models:
   // **********************************************
   // * Initializing shower modell
   // ***********************************************
   G4cout << "Creating shower parameterization models" << G4endl;
   fFastShowerModel = new GFlashShowerModel("fFastShowerModel", fRegion);
   fParameterisation = new GFlashHomoShowerParameterisation(pbWO4);
   fFastShowerModel->SetParameterisation(*fParameterisation);
   // Energy Cuts to kill particles:
   fParticleBounds = new GFlashParticleBounds();
   fFastShowerModel->SetParticleBounds(*fParticleBounds);
   // Makes the EnergieSpots
   fHitMaker = new GFlashHitMaker();
   fFastShowerModel->SetHitMaker(*fHitMaker);
   G4cout<<"end shower parameterization."<<G4endl;
   // **********************************************
 }