ExGflashDetectorConstruction Class Reference

#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

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

(

)

Definition at line 72 of file ExGflashDetectorConstruction.cc.

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

ExGflashDetectorConstruction::~ExGflashDetectorConstruction

(

)

Definition at line 80 of file ExGflashDetectorConstruction.cc.

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

Member Function Documentation

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::GetInvisible());
  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:

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

Here is the call graph for this function:

const G4VPhysicalVolume* ExGflashDetectorConstruction::GetCristal ( int  num__crystal )

inline

Definition at line 56 of file ExGflashDetectorConstruction.hh.

  {return fCrystal_phys[num__crystal];};

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p03/examples/extended/parameterisations/gflash/include/ExGflashDetectorConstruction.hh
• source/geant4.10.03.p03/examples/extended/parameterisations/gflash/src/ExGflashDetectorConstruction.cc