RE06ParallelWorld Class Reference

#include <Doxymodules_runAndEvent.h>

Inheritance diagram for RE06ParallelWorld:

Public Member Functions
	RE06ParallelWorld (G4String worldName)
virtual	~RE06ParallelWorld ()
virtual void	Construct ()
virtual void	ConstructSD ()
void	SetSerialGeometry (G4bool ser)
G4bool	IsSerial () const

Private Member Functions
void	SetupGeometry ()
void	SetupDetectors ()

Private Attributes
G4LogicalVolume *	fCalorLogical [3]
G4LogicalVolume *	fLayerLogical [3]
G4VPhysicalVolume *	fCalorPhysical [3]
G4VPhysicalVolume *	fLayerPhysical [3]
G4String	fCalName [3]
G4bool	fConstructed
G4bool	fSerial
G4double	fTotalThickness
G4int	fNumberOfLayers

Static Private Attributes
static G4ThreadLocal G4bool	fSDConstructed = false

Detailed Description

Definition at line 138 of file Doxymodules_runAndEvent.h.

Constructor & Destructor Documentation

RE06ParallelWorld()

RE06ParallelWorld::RE06ParallelWorld

(

G4String

worldName

)

Definition at line 55 of file RE06ParallelWorld.cc.

:G4VUserParallelWorld(worldName),
 fConstructed(false),
 fSerial(false),
 fTotalThickness(2.0*m),
 fNumberOfLayers(20)
{
  for(size_t i=0;i<3;i++)
  {
    fCalorLogical[i] = 0;
    fLayerLogical[i] = 0;
    fCalorPhysical[i] = 0;
    fLayerPhysical[i] = 0;
  }
  fCalName[0] = "Calor-AP";
  fCalName[1] = "Calor-BP";
  fCalName[2] = "Calor-CP";
}

~RE06ParallelWorld()

RE06ParallelWorld::~RE06ParallelWorld ( )

virtual

Definition at line 76 of file RE06ParallelWorld.cc.

{;}

Member Function Documentation

Construct()

void RE06ParallelWorld::Construct ( )

virtual

Definition at line 81 of file RE06ParallelWorld.cc.

{
  if(!fConstructed)
  { 
    fConstructed = true;
    SetupGeometry();
  }
}

ConstructSD()

void RE06ParallelWorld::ConstructSD ( )

virtual

Definition at line 92 of file RE06ParallelWorld.cc.

{
  if(!fSDConstructed)
  {
    fSDConstructed = true;
    SetupDetectors();
  }
}

SetSerialGeometry()

void RE06ParallelWorld::SetSerialGeometry

(

G4bool

ser

)

Definition at line 200 of file RE06ParallelWorld.cc.

{
  if(fSerial==serial) return;
  fSerial=serial;
  if(!fConstructed) return;
  for(G4int i=0;i<3;i++)
  {
    if(fSerial)
    { 
      fCalorPhysical[i]
        ->SetTranslation(G4ThreeVector(0.,0.,G4double(i-1)*2.*m)); 
    }
    else
    { 
      fCalorPhysical[i]
        ->SetTranslation(G4ThreeVector(0.,G4double(i-1)*m,0.)); 
    }
  }
}

IsSerial()

G4bool RE06ParallelWorld::IsSerial ( ) const

inline

Definition at line 50 of file RE06ParallelWorld.hh.

{ return fSerial; }

SetupGeometry()

void RE06ParallelWorld::SetupGeometry ( )

private

Definition at line 102 of file RE06ParallelWorld.cc.

{
  //     
  // World
  //
  G4VPhysicalVolume* ghostWorld = GetWorld();
  G4LogicalVolume* worldLogical = ghostWorld->GetLogicalVolume();
  
  //                               
  // Calorimeter
  //  
  G4VSolid* calorSolid 
    = new G4Tubs("Calor",0.0,0.5*m,fTotalThickness/2.,0.0,360.*deg);
  G4int i;
  for(i=0;i<3;i++)
  {
    fCalorLogical[i] = new G4LogicalVolume(calorSolid,0,fCalName[i]);
    if(fSerial)
    {
      fCalorPhysical[i] = new G4PVPlacement(0,
                 G4ThreeVector(0.,0.,G4double(i-1)*fTotalThickness),
                 fCalorLogical[i],fCalName[i],worldLogical,false,i);
    }
    else
    {
      fCalorPhysical[i] = new G4PVPlacement(0,
                 G4ThreeVector(0.,G4double(i-1)*m,0.),
                 fCalorLogical[i],fCalName[i],worldLogical,false,i);
    }
  }
 
  //                                 
  // Layers --- as absorbers
  //
  G4VSolid* layerSolid 
    = new G4Tubs("Layer",0.0,0.5*m,fTotalThickness/2.,0.0,360.*deg);
  for(i=0;i<3;i++)
  {
    fLayerLogical[i] 
      = new G4LogicalVolume(layerSolid,0,fCalName[i]+"_LayerLog");
    fLayerPhysical[i] 
      = new G4PVReplica(fCalName[i]+"_Layer",fLayerLogical[i],fCalorLogical[i],
                        kRho,fNumberOfLayers,0.5*m/fNumberOfLayers);
  }
   
}

SetupDetectors()

void RE06ParallelWorld::SetupDetectors ( )

private

Definition at line 151 of file RE06ParallelWorld.cc.

{
  G4SDManager::GetSDMpointer()->SetVerboseLevel(1);
  G4String filterName, particleName;
 
  G4SDParticleFilter* gammaFilter 
    = new G4SDParticleFilter(filterName="gammaFilter",particleName="gamma");
  G4SDParticleFilter* electronFilter 
    = new G4SDParticleFilter(filterName="electronFilter",particleName="e-");
  G4SDParticleFilter* positronFilter 
    = new G4SDParticleFilter(filterName="positronFilter",particleName="e+");
  G4SDParticleFilter* epFilter 
    = new G4SDParticleFilter(filterName="epFilter");
  epFilter->add(particleName="e-");
  epFilter->add(particleName="e+");
 
  for(G4int i=0;i<3;i++)
  {
    G4String detName = fCalName[i]+"_para";
    G4MultiFunctionalDetector* det = new G4MultiFunctionalDetector(detName);
 
    G4VPrimitiveScorer* primitive;
    primitive = new G4PSEnergyDeposit("eDep");
    det->RegisterPrimitive(primitive);
    primitive = new G4PSNofSecondary("nGamma");
    primitive->SetFilter(gammaFilter);
    det->RegisterPrimitive(primitive);
    primitive = new G4PSNofSecondary("nElectron");
    primitive->SetFilter(electronFilter);
    det->RegisterPrimitive(primitive);
    primitive = new G4PSNofSecondary("nPositron");
    primitive->SetFilter(positronFilter);
    det->RegisterPrimitive(primitive);
    primitive = new G4PSTrackLength("trackLength");
    primitive->SetFilter(epFilter);
    det->RegisterPrimitive(primitive);
    primitive = new G4PSNofStep("nStep");
    primitive->SetFilter(epFilter);
    det->RegisterPrimitive(primitive);
 
    G4SDManager::GetSDMpointer()->AddNewDetector(det);
    SetSensitiveDetector(fLayerLogical[i], det);
  }
  G4SDManager::GetSDMpointer()->SetVerboseLevel(0);
  
}

Member Data Documentation

fCalorLogical

G4LogicalVolume* RE06ParallelWorld::fCalorLogical[3]

private

Definition at line 56 of file RE06ParallelWorld.hh.

fLayerLogical

G4LogicalVolume* RE06ParallelWorld::fLayerLogical[3]

private

Definition at line 57 of file RE06ParallelWorld.hh.

fCalorPhysical

G4VPhysicalVolume* RE06ParallelWorld::fCalorPhysical[3]

private

Definition at line 58 of file RE06ParallelWorld.hh.

fLayerPhysical

G4VPhysicalVolume* RE06ParallelWorld::fLayerPhysical[3]

private

Definition at line 59 of file RE06ParallelWorld.hh.

fCalName

G4String RE06ParallelWorld::fCalName[3]

private

Definition at line 60 of file RE06ParallelWorld.hh.

fConstructed

G4bool RE06ParallelWorld::fConstructed

private

Definition at line 61 of file RE06ParallelWorld.hh.

fSDConstructed

G4ThreadLocal G4bool RE06ParallelWorld::fSDConstructed = false

staticprivate

Definition at line 62 of file RE06ParallelWorld.hh.

fSerial

G4bool RE06ParallelWorld::fSerial

private

Definition at line 63 of file RE06ParallelWorld.hh.

fTotalThickness

G4double RE06ParallelWorld::fTotalThickness

private

Definition at line 64 of file RE06ParallelWorld.hh.

fNumberOfLayers

G4int RE06ParallelWorld::fNumberOfLayers

private

Definition at line 65 of file RE06ParallelWorld.hh.

---

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

• .doxygen/Doxymodules_runAndEvent.h
• extended/runAndEvent/RE06/include/RE06ParallelWorld.hh
• extended/runAndEvent/RE06/src/RE06ParallelWorld.cc