G4GeometryWorkspace Class Reference

#include <G4GeometryWorkspace.hh>

Public Member Functions
	G4GeometryWorkspace ()
	~G4GeometryWorkspace ()
void	UseWorkspace ()
void	ReleaseWorkspace ()
void	DestroyWorkspace ()
void	InitialiseWorkspace ()
void	SetVerbose (G4bool v)
G4bool	GetVerbose ()

Protected Member Functions
void	InitialisePhysicalVolumes ()
G4bool	CloneParameterisedSolids (G4PVParameterised *paramVol)
G4bool	CloneReplicaSolid (G4PVReplica *)

Detailed Description

Definition at line 57 of file G4GeometryWorkspace.hh.

Constructor & Destructor Documentation

G4GeometryWorkspace::G4GeometryWorkspace

(

)

Definition at line 43 of file G4GeometryWorkspace.cc.

References G4GeomSplitter< T >::GetOffset(), G4PVReplica::GetSubInstanceManager(), G4VPhysicalVolume::GetSubInstanceManager(), G4Region::GetSubInstanceManager(), G4LogicalVolume::GetSubInstanceManager(), and InitialiseWorkspace().

  : fVerbose(false)
{
  fpLogicalVolumeSIM=
      &const_cast<G4LVManager&>(G4LogicalVolume::GetSubInstanceManager());
  fpPhysicalVolumeSIM=
      &const_cast<G4PVManager&>( G4VPhysicalVolume::GetSubInstanceManager() );
  fpReplicaSIM=
      &const_cast<G4PVRManager&>(G4PVReplica::GetSubInstanceManager());
  fpRegionSIM=
      &const_cast<G4RegionManager&>(G4Region::GetSubInstanceManager());

  // Create a work area for Logical Volumes in this thread - then capture its address
  InitialiseWorkspace();
  
  fLogicalVolumeOffset= fpLogicalVolumeSIM->GetOffset();

  fPhysicalVolumeOffset= fpPhysicalVolumeSIM->GetOffset();

  fReplicaOffset= fpReplicaSIM->GetOffset();

  fRegionOffset= fpRegionSIM->GetOffset();
}

G4GeometryWorkspace::~G4GeometryWorkspace

(

)

Definition at line 67 of file G4GeometryWorkspace.cc.

{
  
}

Member Function Documentation

G4bool G4GeometryWorkspace::CloneParameterisedSolids ( G4PVParameterised *  paramVol )

protected

Definition at line 194 of file G4GeometryWorkspace.cc.

References G4VSolid::Clone(), G4VPVParameterisation::ComputeSolid(), FatalException, G4endl, G4Exception(), G4VSolid::GetEntityType(), G4VPhysicalVolume::GetLogicalVolume(), G4PVReplica::GetMultiplicity(), G4PVParameterised::GetParameterisation(), G4LogicalVolume::GetSolid(), G4LogicalVolume::InitialiseWorker(), and G4TemplateAutoLock< M, L, U >::unlock().

Referenced by InitialisePhysicalVolumes().

{
  // Each G4PVParameterised instance, has associated with it at least one
  // solid for each worker thread.
  // *Simple* Parameterisations have a single type of solid, and the
  // pointer points to the same instance of a solid during the  simulation.
  // For this case, it is possible to adapt automatically to
  // multi-threading, simply by cloning the solid - so long
  // as all solids support the Clone() method.
  
  // Check whether it is a simple parameterisation or not
  G4VPVParameterisation *param= paramVol->GetParameterisation();
  unsigned int numCopies= paramVol->GetMultiplicity();
  unsigned int numDifferent= 0;

  G4LogicalVolume *logicalV= paramVol->GetLogicalVolume();
  // assert( logicalV != 0);
  G4VSolid *solid= logicalV->GetSolid();
  
  for( unsigned int i=0; i< numCopies; i++)
  {
    G4VSolid *solidChk= param->ComputeSolid(i, paramVol);
    if( solidChk != solid)
    {
      numDifferent++;
    }
  }
  if( numDifferent>0 )
  {
    G4ExceptionDescription ed;

    ed << " Parameterisation is implemented using several instances of Solids "
       << " - potentially to support different types of solids. " << G4endl;
    ed << "  The current implementation of Geant4-MT does not support "
    << " this type of Parameterisation" << G4endl;
    G4Exception("G4GeometryWorkspace::CloneParameterisedVolume", "GeometryNotSupportedInMT-01",
                FatalException, ed);
  }
  
  // Threads may attempt to clone a solids simultaneously. Those cloned solids will be
  // registered into a shared solid store (C++ container). Need a lock to
  // guarantee thread safety
  G4AutoLock aLock(&solidclone);
  G4VSolid *workerSolid = solid->Clone();
  aLock.unlock();
  if( workerSolid )
  {
    logicalV->InitialiseWorker(logicalV,workerSolid,0);
  }else{
    // In the case that not all solids support(ed) the Clone()
    // method, we do similar thing here to dynamically cast
    // and then get the clone method.
    G4ExceptionDescription ed;
    ed << " ERROR: Unable to initialise geometry for worker node." << G4endl;
    ed << " A solid lacks the Clone() method - or Clone() failed." << G4endl;
    ed << "   Type of solid: " << solid->GetEntityType() << G4endl;
    ed << "   Parameters: " << *solid << G4endl;
    G4Exception(" G4GeometryWorkspace::CloneParameterisedVolume", "MT-BuildGeometry001",
                FatalException, ed);
  }
  return true; // It Worked
}

G4bool G4GeometryWorkspace::CloneReplicaSolid ( G4PVReplica *  replicaPV )

protected

Definition at line 161 of file G4GeometryWorkspace.cc.

References G4VSolid::Clone(), FatalException, G4endl, G4Exception(), G4VSolid::GetEntityType(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetSolid(), G4LogicalVolume::InitialiseWorker(), and G4TemplateAutoLock< M, L, U >::unlock().

Referenced by InitialisePhysicalVolumes().

{
   // Create a clone of the solid for this replica in this thread

   // Check that it is not a parameterisation ? 

   // The solid Ptr is in the Logical Volume
  G4LogicalVolume *logicalV= replicaPV ->GetLogicalVolume();
  G4VSolid *solid= logicalV->GetSolid();

  G4AutoLock aLock(&solidclone);
  G4VSolid *workerSolid = solid->Clone();
  aLock.unlock();

  if( workerSolid )
  {
    logicalV->InitialiseWorker(logicalV,workerSolid,0);
  }else{
    // In the case that not all solids support(ed) the Clone()
    // method, we do similar thing here to dynamically cast
    // and then get the clone method.
    G4ExceptionDescription ed;
    ed << " ERROR: Unable to initialise geometry for worker node." << G4endl;
    ed << " A solid lacks the Clone() method - or Clone() failed." << G4endl;
    ed << "   Type of solid: " << solid->GetEntityType() << G4endl;
    ed << "   Parameters: " << *solid << G4endl;
    G4Exception(" G4GeometryWorkspace::CloneParameterisedVolume", "MT-BuildGeometry001",
                FatalException, ed);
    return false; 
  }
  return true; // It Worked
}

void G4GeometryWorkspace::DestroyWorkspace

(

)

Definition at line 283 of file G4GeometryWorkspace.cc.

References G4GeomSplitter< T >::FreeSlave(), G4PhysicalVolumeStore::GetInstance(), G4VPhysicalVolume::GetLogicalVolume(), G4PVReplica::TerminateWorker(), and G4LogicalVolume::TerminateWorker().

Referenced by G4WorkerThread::DestroyGeometryAndPhysicsVector(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

{
  G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
  for (size_t ip=0; ip<physVolStore->size(); ip++)
  {
    G4VPhysicalVolume* physVol = (*physVolStore)[ip];
    G4LogicalVolume *logicalVol = physVol->GetLogicalVolume();
    G4PVReplica *g4PVReplica = 0;
    g4PVReplica =  dynamic_cast<G4PVReplica*>(physVol);
    if (g4PVReplica)
    {
      g4PVReplica->TerminateWorker(g4PVReplica);
      G4PVParameterised *paramVol = 0;
      paramVol =  dynamic_cast<G4PVParameterised*>(physVol);
      if (paramVol)
      {
        // G4VSolid *solid = logicalVol->fSolid;
        logicalVol->TerminateWorker(logicalVol);
        // if( solid->IsClone() ) delete solid;
      }
      else
      {
        logicalVol->TerminateWorker(logicalVol);
      }
    }
    else
    {
      logicalVol->TerminateWorker(logicalVol);
    }
  }
  
  fpLogicalVolumeSIM->FreeSlave();
  fpPhysicalVolumeSIM->FreeSlave();
  fpReplicaSIM->FreeSlave();
  fpRegionSIM->FreeSlave();
}

G4bool G4GeometryWorkspace::GetVerbose ( )

inline

Definition at line 71 of file G4GeometryWorkspace.hh.

{ return fVerbose;   } 

void G4GeometryWorkspace::InitialisePhysicalVolumes ( )

protected

Definition at line 115 of file G4GeometryWorkspace.cc.

References CloneParameterisedSolids(), CloneReplicaSolid(), FatalException, G4cout, G4endl, G4Exception(), G4PhysicalVolumeStore::GetInstance(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMasterSolid(), G4PVReplica::InitialiseWorker(), G4LogicalVolume::InitialiseWorker(), and G4PVReplica::IsParameterised().

Referenced by InitialiseWorkspace().

  {
    G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
    for (size_t ip=0; ip<physVolStore->size(); ip++)
    {
        G4VPhysicalVolume* physVol = (*physVolStore)[ip];
        G4LogicalVolume *logicalVol = physVol->GetLogicalVolume();
        //use shadow pointer
        G4VSolid *solid = logicalVol->GetMasterSolid();
        G4PVReplica *g4PVReplica = 0;
        g4PVReplica =  dynamic_cast<G4PVReplica*>(physVol);
        if (!g4PVReplica)
        {
            // Placement volume
            logicalVol->InitialiseWorker(logicalVol,solid,0);
        }
        else
        {          
            //g4PVReplica->SlaveG4PVReplica(g4PVReplica);
            g4PVReplica->InitialiseWorker(g4PVReplica);
            if( ! g4PVReplica->IsParameterised() )
            {
               logicalVol->InitialiseWorker(logicalVol,solid,0);
               // If the replica's solid (in LV) is changed during navigation, it must be thread-private
               CloneReplicaSolid( g4PVReplica );
            }
            else
            {
               G4PVParameterised *paramVol
                   =  dynamic_cast<G4PVParameterised*>(physVol);
               if (!paramVol)
               {
                  G4Exception("G4GeometryWorkspace::CreateAndUseWorkspace", "Runtime Error PV01",
                              FatalException,
                              "Cannot find Parameterisation for G4PVParameterised object.");
               }
               CloneParameterisedSolids( paramVol );
            }
        }
    }
    if( fVerbose )
       G4cout << "G4GeometryWorkspace::InitialisePhysicalVolumes: "
              << "Copying geometry - Done!" << G4endl;
}

void G4GeometryWorkspace::InitialiseWorkspace

(

)

Definition at line 259 of file G4GeometryWorkspace.cc.

References G4cout, G4endl, InitialisePhysicalVolumes(), G4GeomSplitter< T >::SlaveCopySubInstanceArray(), and G4GeomSplitter< T >::SlaveInitializeSubInstance().

Referenced by G4GeometryWorkspace(), and G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster().

{
  if( fVerbose ) 
     G4cout << "G4GeometryWorkspace::InitialiseWorkspace: Copying geometry - Start " << G4endl;
  
  // Implementation copied from  G4WorkerThread::BuildGeometryAndPhysicsVector()
  //  and improved for G4PVParamaterised
  //   John Apostolakis, May 30, 2013
  
  //Geometry related, split classes mechanism:
  //   Do *NOT* instantiate sub-instance for this thread,
  //     just copy the contents !!
  fpLogicalVolumeSIM->SlaveCopySubInstanceArray();
  fpPhysicalVolumeSIM->SlaveCopySubInstanceArray();
  fpReplicaSIM->SlaveCopySubInstanceArray();
  fpRegionSIM->SlaveInitializeSubInstance();

  InitialisePhysicalVolumes();
  
  if( fVerbose ) 
     G4cout << "G4GeometryWorkspace::InitialiseWorkspace: "
            << "Copying geometry - Done!" << G4endl;
}

void G4GeometryWorkspace::ReleaseWorkspace

(

)

Definition at line 102 of file G4GeometryWorkspace.cc.

References G4GeomSplitter< T >::UseWorkArea().

Referenced by G4GeometryWorkspacePool::Recycle().

{
  fpLogicalVolumeSIM->UseWorkArea(0);
  fpPhysicalVolumeSIM->UseWorkArea(0);
  
  fpReplicaSIM->UseWorkArea(0);
  fpRegionSIM->UseWorkArea(0);
}

void G4GeometryWorkspace::SetVerbose ( G4bool  v )

inline

Definition at line 70 of file G4GeometryWorkspace.hh.

References test::v.

{ fVerbose=v; } 

void G4GeometryWorkspace::UseWorkspace

(

)

Definition at line 76 of file G4GeometryWorkspace.cc.

References G4cout, G4endl, and G4GeomSplitter< T >::UseWorkArea().

Referenced by G4GeometryWorkspacePool::FindOrCreateWorkspace().

{
  if( fVerbose ) 
     G4cout << "G4GeometryWorkspace::UseWorkspace: Start " << G4endl;

  // Implementation copied from  G4WorkerThread::BuildGeometryAndPhysicsVector()
  //  and improved for G4PVParamaterised
  //   John Apostolakis, May 30, 2013
  
  //Geometry related, split classes mechanism: instantiate sub-instance for this thread
  fpLogicalVolumeSIM->UseWorkArea(fLogicalVolumeOffset);
  fpPhysicalVolumeSIM->UseWorkArea(fPhysicalVolumeOffset);
  
  fpReplicaSIM->UseWorkArea(fReplicaOffset);
  fpRegionSIM->UseWorkArea(fRegionOffset);

  // When recycling a workspace 
  //   - it must be a lightweight operation, to reuse a valid work area
  //   - so it must NOT Initialise anything!
  // Do not call InitialisePhysicalVolumes();

  if( fVerbose ) 
     G4cout << "G4GeometryWorkspace::UseWorkspace:  End " << G4endl;
}

---

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

• G4GeometryWorkspace.hh
• G4GeometryWorkspace.cc