RE06ParallelWorld Class Reference

#include <RE06ParallelWorld.hh>

Inheritance diagram for RE06ParallelWorld:

Collaboration diagram for RE06ParallelWorld:

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

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

Additional Inherited Members
Protected Member Functions inherited from G4VUserParallelWorld
G4VPhysicalVolume *	GetWorld ()
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)
Protected Attributes inherited from G4VUserParallelWorld
G4String	fWorldName

Detailed Description

Definition at line 41 of file RE06ParallelWorld.hh.

Constructor & Destructor Documentation

RE06ParallelWorld()

RE06ParallelWorld::RE06ParallelWorld

(

G4String

worldName

)

Definition at line 56 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 77 of file RE06ParallelWorld.cc.

{;}

Member Function Documentation

Construct()

void RE06ParallelWorld::Construct ( void  )

virtual

Implements G4VUserParallelWorld.

Definition at line 82 of file RE06ParallelWorld.cc.

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

Here is the call graph for this function:

ConstructSD()

void RE06ParallelWorld::ConstructSD ( )

virtual

Reimplemented from G4VUserParallelWorld.

Definition at line 93 of file RE06ParallelWorld.cc.

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

Here is the call graph for this function:

IsSerial()

G4bool RE06ParallelWorld::IsSerial ( ) const

inline

Definition at line 51 of file RE06ParallelWorld.hh.

{ return fSerial; }

Here is the call graph for this function:

SetSerialGeometry()

void RE06ParallelWorld::SetSerialGeometry

(

G4bool

ser

)

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

Here is the call graph for this function:

SetupDetectors()

void RE06ParallelWorld::SetupDetectors ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetupGeometry()

void RE06ParallelWorld::SetupGeometry ( )

private

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

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fCalName

G4String RE06ParallelWorld::fCalName[3]

private

Definition at line 61 of file RE06ParallelWorld.hh.

fCalorLogical

G4LogicalVolume* RE06ParallelWorld::fCalorLogical[3]

private

Definition at line 57 of file RE06ParallelWorld.hh.

fCalorPhysical

G4VPhysicalVolume* RE06ParallelWorld::fCalorPhysical[3]

private

Definition at line 59 of file RE06ParallelWorld.hh.

fConstructed

G4bool RE06ParallelWorld::fConstructed

private

Definition at line 62 of file RE06ParallelWorld.hh.

fLayerLogical

G4LogicalVolume* RE06ParallelWorld::fLayerLogical[3]

private

Definition at line 58 of file RE06ParallelWorld.hh.

fLayerPhysical

G4VPhysicalVolume* RE06ParallelWorld::fLayerPhysical[3]

private

Definition at line 60 of file RE06ParallelWorld.hh.

fNumberOfLayers

G4int RE06ParallelWorld::fNumberOfLayers

private

Definition at line 66 of file RE06ParallelWorld.hh.

fSDConstructed

G4ThreadLocal G4bool RE06ParallelWorld::fSDConstructed = false

staticprivate

Definition at line 63 of file RE06ParallelWorld.hh.

fSerial

G4bool RE06ParallelWorld::fSerial

private

Definition at line 64 of file RE06ParallelWorld.hh.

fTotalThickness

G4double RE06ParallelWorld::fTotalThickness

private

Definition at line 65 of file RE06ParallelWorld.hh.

---

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

• RE06ParallelWorld.hh
• RE06ParallelWorld.cc