Par01DetectorConstruction Class Reference

#include <Par01DetectorConstruction.hh>

Inheritance diagram for Par01DetectorConstruction:

Collaboration diagram for Par01DetectorConstruction:

Public Member Functions
	Par01DetectorConstruction ()
virtual	~Par01DetectorConstruction ()
virtual G4VPhysicalVolume *	Construct ()
virtual void	ConstructSDandField ()
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 41 of file Par01DetectorConstruction.hh.

Constructor & Destructor Documentation

Par01DetectorConstruction::Par01DetectorConstruction

(

)

Definition at line 57 of file Par01DetectorConstruction.cc.

{;}

Par01DetectorConstruction::~Par01DetectorConstruction ( )

virtual

Definition at line 62 of file Par01DetectorConstruction.cc.

{;}

Member Function Documentation

G4VPhysicalVolume * Par01DetectorConstruction::Construct ( void  )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 67 of file Par01DetectorConstruction.cc.

{
  G4cout << "\nPar01DetectorConstruction....\n" << G4endl;
  
  //--------- Material definition ---------
  // Get nist material manager
  G4NistManager* nistManager = G4NistManager::Instance();

  // Build materials
  G4Material* air    = nistManager->FindOrBuildMaterial("G4_AIR");
  G4Material* csi    = nistManager->FindOrBuildMaterial("G4_CESIUM_IODIDE");
  G4Material* helium = nistManager->FindOrBuildMaterial("G4_He");
  G4Material* iron   = nistManager->FindOrBuildMaterial("G4_Fe");

  
  //--------- G4VSolid, G4LogicalVolume, G4VPhysicalVolume  ---------
  
  //--------------
  // World:
  //--------------
  G4Box *WorldBox= new G4Box("WorldBox",400*cm, 400*cm, 400*cm);
  G4LogicalVolume *WorldLog=new G4LogicalVolume(WorldBox,air,
                                                "WorldLogical", 0, 0, 0);
  G4PVPlacement *WorldPhys=new G4PVPlacement(0,G4ThreeVector(),
                                             "WorldPhysical",
                                             WorldLog,
                                             0,false,0);
  // Size of detectors:
  G4double detectSize = 125*cm;
  
  //-----------------------------
  // "Drift Chamber":
  // Not used in parameterisation.
  //-----------------------------
  // -- Logical volume:
  G4Box *driftChamberBox
    = new G4Box("DriftChamberSolid", detectSize, detectSize, 40*cm);
  G4LogicalVolume *driftChamberLog
    = new G4LogicalVolume(driftChamberBox,helium,
                          "DriftChamberLogical", 0, 0, 0);
  // -- Placement:
  // G4PVPlacement *driftChamberPhys  =
      new G4PVPlacement(0,G4ThreeVector(0., 0., 50*cm),
                        "DriftChamberPhysical",
                        driftChamberLog,
                        WorldPhys,false,0);
  
  //--------------------------
  // "Calorimeter": used in
  // parameterisation below
  //--------------------------
  // -- Logical volume:
  G4Box *calorimeterBox
    = new G4Box("CalorimeterSolid", detectSize, detectSize, 20*cm);
  G4LogicalVolume *calorimeterLog = new G4LogicalVolume(calorimeterBox,air,
                                                        "CalorimeterLogical", 0, 0, 0);
  // -- Placement:
  G4PVPlacement *calorimeterPhys  = new G4PVPlacement(0,G4ThreeVector(0., 0., 120*cm),
                                                      "CalorimeterPhysical",
                                                      calorimeterLog,
                                                      WorldPhys,false,0);
  
  //--------------------------------------
  // The calorimeter is filled with
  // crystals:
  //--------------------------------------
  // -- Logical volume:
  G4double CrystalX = 2.5*cm;
  G4double CrystalY = CrystalX;
  G4double CrystalZ = 20*cm;
  G4Box *CrystalSolid = new G4Box("CrystalSolid", CrystalX, CrystalY, CrystalZ);
  fCrystalLog       = new G4LogicalVolume(CrystalSolid,csi,
                                            "CrystalLogical", 0, 0, 0);
  
  G4String tName1("Crystal");        // Allow all target physicals to share
  // same name (delayed copy)
  
  // -- and placements inside the calorimeter:
  G4int copyNo=0;
  G4double xTlate, yTlate;
  fnX = 48;
  fnY = 48;
  for (G4int j = 0; j < fnY; j++)
    {
      yTlate = -detectSize + 3*CrystalY + j*2*CrystalY;
      for (G4int i = 0; i < fnX; i++)
        {
          xTlate = -detectSize + 3*CrystalX + i*2*CrystalX;
          new G4PVPlacement(0,G4ThreeVector(xTlate,yTlate,0*cm),
                            tName1,
                            fCrystalLog,
                            calorimeterPhys,false,copyNo++);
        }
    }


  //--------------------------
  // "Hadron Calorimeter": used
  // in parameterisation with
  // a parallel geometry
  //--------------------------
  // -- Logical volume:
  G4Box *hadCaloBox
    = new G4Box("HadCaloSolid", detectSize, detectSize, 50*cm);
  G4LogicalVolume *hadCaloLog = new G4LogicalVolume(hadCaloBox,air,
                                                     "HadCaloLogical", 0, 0, 0);
  // -- Placement:
  G4PVPlacement *hadCaloPhys  = new G4PVPlacement(0,G4ThreeVector(0., 0., 200*cm),
                                                   "HadCaloPhysical",
                                                   hadCaloLog,
                                                   WorldPhys,false,0);
  
  //--------------------------------------
  // The calorimeter is filled with
  // towers:
  //--------------------------------------
  // -- Logical volume:
  G4double TowerX = 5*cm;
  G4double TowerY = TowerX;
  G4double TowerZ = 45*cm;
  G4Box *TowerSolid = new G4Box("TowerSolid", TowerX, TowerY, TowerZ);
  fTowerLog       = new G4LogicalVolume(TowerSolid,iron,
                                          "TowerLogical", 0, 0, 0);
  
  G4String tName2("Tower");
  
  // -- and placements inside the calorimeter:
  copyNo=0;
  fnXhad = 23;
  fnYhad = 23;
  for (G4int jj = 0; jj < fnYhad; jj++)
    {
      yTlate = -detectSize + 3*TowerY + jj*2*TowerY;
      for (G4int i = 0; i < fnXhad; i++)
         {
          xTlate = -detectSize + 3*TowerX + i*2*TowerX;
           new G4PVPlacement(0,G4ThreeVector(xTlate,yTlate,0*cm),
                             tName2,
                             fTowerLog,
                             hadCaloPhys,false,copyNo++);
         }
    }
  
  
 
  
  // -- Makes the calorimeterLog volume becoming a G4Region: 
   G4Region* caloRegion = new G4Region("EM_calo_region");
   caloRegion->AddRootLogicalVolume(calorimeterLog);
   std::vector<double> cuts; 
   cuts.push_back(1.0*mm);cuts.push_back(1.0*mm);cuts.push_back(1.0*mm);cuts.push_back(1.0*mm);
   caloRegion->SetProductionCuts(new G4ProductionCuts());
   caloRegion->GetProductionCuts()->SetProductionCuts(cuts);

   //  Makes had. calo a region to:
   G4Region* hadRegion = new G4Region("HAD_calo_region");
   hadRegion->AddRootLogicalVolume(hadCaloLog);
   cuts.clear();
   cuts.push_back(1.0*cm);cuts.push_back(1.0*cm);cuts.push_back(1.0*cm);cuts.push_back(1.0*cm);
   hadRegion->SetProductionCuts(new G4ProductionCuts());
   hadRegion->GetProductionCuts()->SetProductionCuts(cuts);

  //--------- Visualization attributes -------------------------------
  WorldLog->SetVisAttributes(G4VisAttributes::GetInvisible());

  G4VisAttributes * driftchamberTubeVisAtt
    = new G4VisAttributes(G4Colour(0.0,1.0,0.0));
  driftchamberTubeVisAtt->SetForceWireframe(true);
  driftChamberLog->SetVisAttributes(driftchamberTubeVisAtt);
  
  G4VisAttributes * calorimeterBoxVisAtt
    = new G4VisAttributes(G4Colour(0.0,0.0,1.0));
  calorimeterBoxVisAtt->SetForceWireframe(true);
  calorimeterLog->SetVisAttributes(calorimeterBoxVisAtt);
  
  G4VisAttributes * crystalVisAtt
    = new G4VisAttributes(G4Colour(1.0,0.0,0.0));
  crystalVisAtt->SetForceWireframe(true);
  fCrystalLog->SetVisAttributes(crystalVisAtt);

  G4VisAttributes * hadCaloBoxVisAtt
    = new G4VisAttributes(G4Colour(1.0,0.0,1.0));
  hadCaloBoxVisAtt->SetForceWireframe(true);
  hadCaloLog->SetVisAttributes(hadCaloBoxVisAtt);
  
  G4VisAttributes * towerVisAtt
    = new G4VisAttributes(G4Colour(0.5,0.0,1.0));
  towerVisAtt->SetForceWireframe(true);
  fTowerLog->SetVisAttributes(towerVisAtt);
  
  //------------------------------------------------------------------
  
  
  //-----------------------
  // Returns the pointer to
  // the physical world:
  //-----------------------
  return WorldPhys;
}

Here is the call graph for this function:

void Par01DetectorConstruction::ConstructSDandField ( )

virtual

Reimplemented from G4VUserDetectorConstruction.

Definition at line 269 of file Par01DetectorConstruction.cc.

{
  //--------- Sensitive detector -------------------------------------
  G4SDManager* SDman = G4SDManager::GetSDMpointer();
  G4String calorimeterSDname = "Par01/Calorimeter";
  Par01CalorimeterSD* CalorimeterSD = new Par01CalorimeterSD( calorimeterSDname,
                                                              fnX*fnY,
                                                              "CalCollection" );
  SDman->AddNewDetector( CalorimeterSD );
  fCrystalLog->SetSensitiveDetector(CalorimeterSD); 
  
  G4String hadCalorimeterSDname = "Par01/HadronCalorimeter";
  Par01CalorimeterSD* HadCalorimeterSD = new Par01CalorimeterSD( hadCalorimeterSDname,
                                                                 fnXhad*fnYhad,
                                                                 "HadCollection" );
  SDman->AddNewDetector( HadCalorimeterSD );
  fTowerLog->SetSensitiveDetector(HadCalorimeterSD); 
  
  // --------------- fast simulation ----------------------------
  G4RegionStore* regionStore = G4RegionStore::GetInstance();
  
  G4Region* caloRegion = regionStore->GetRegion("EM_calo_region");
  // builds a model and sets it to the envelope of the calorimeter:
  new Par01EMShowerModel("emShowerModel",caloRegion);
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/examples/extended/parameterisations/Par01/include/Par01DetectorConstruction.hh
• source/geant4.10.03.p03/examples/extended/parameterisations/Par01/src/Par01DetectorConstruction.cc