G4WorkerThread Class Reference

AAADEBUG. More...

#include <G4WorkerThread.hh>

Public Member Functions
void	SetThreadId (G4int threadId)
G4int	GetThreadId () const
void	SetNumberThreads (G4int numnberThreads)
G4int	GetNumberThreads () const

Static Public Member Functions
static void	BuildGeometryAndPhysicsVector ()
static void	DestroyGeometryAndPhysicsVector ()
static void	UpdateGeometryAndPhysicsVectorFromMaster ()

Detailed Description

AAADEBUG.

Definition at line 42 of file G4WorkerThread.hh.

Member Function Documentation

void G4WorkerThread::BuildGeometryAndPhysicsVector ( )

static

Definition at line 79 of file G4WorkerThread.cc.

References G4GeometryWorkspacePool::CreateAndUseWorkspace(), G4SolidsWorkspacePool::CreateAndUseWorkspace(), G4GeometryWorkspacePool::GetInstance(), G4SolidsWorkspacePool::GetInstance(), G4VModularPhysicsList::GetSubInstanceManager(), G4VPhysicsConstructor::GetSubInstanceManager(), G4ParticleDefinition::GetSubInstanceManager(), and G4VUserPhysicsList::GetSubInstanceManager().

Referenced by tbbTask::execute(), and G4MTRunManagerKernel::StartThread().

{
    // Initialise all split classes in the geometry with copy of data from master thread
    G4GeometryWorkspacePool::GetInstance()->CreateAndUseWorkspace();
    G4SolidsWorkspacePool::GetInstance()->CreateAndUseWorkspace();

    //Geometry related, split classes mechanism: instantiate sub-instance for this thread
    //const_cast<G4LVManager&>(G4LogicalVolume::GetSubInstanceManager()).SlaveCopySubInstanceArray();
    //const_cast<G4PVManager&>(G4VPhysicalVolume::GetSubInstanceManager()).SlaveCopySubInstanceArray();
    //const_cast<G4PVRManager&>(G4PVReplica::GetSubInstanceManager()).SlaveCopySubInstanceArray();
    //const_cast<G4RegionManager&>(G4Region::GetSubInstanceManager()).SlaveInitializeSubInstance();
    //G4Material::g4materialSubInstanceManager.SlaveCopySubInstanceArray(); //< Not anymore splitted class
    //const_cast<G4PlSideManager&>(G4PolyconeSide::GetSubInstanceManager()).SlaveInitializeSubInstance();
    //const_cast<G4PhSideManager&>(G4PolyhedraSide::GetSubInstanceManager()).SlaveInitializeSubInstance();
    //Physics related
    //const_cast<G4PVecManager&>(G4PhysicsVector::GetSubInstanceManager()).SlaveInitializeSubInstance();
/////@@    const_cast<G4DecayChannelManager&>(G4VDecayChannel::GetSubInstanceManager()).NewSubInstances();
    const_cast<G4PDefManager&>(G4ParticleDefinition::GetSubInstanceManager()).NewSubInstances();
    const_cast<G4VUPLManager&>(G4VUserPhysicsList::GetSubInstanceManager()).NewSubInstances();
    const_cast<G4VPCManager&>(G4VPhysicsConstructor::GetSubInstanceManager()).NewSubInstances();
    const_cast<G4VMPLManager&>(G4VModularPhysicsList::GetSubInstanceManager()).SlaveCopySubInstanceArray();
    /*
    G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
    for (size_t ip=0; ip<physVolStore->size(); ip++)
    {
        G4VPhysicalVolume* physVol = (*physVolStore)[ip];
        G4LogicalVolume *g4LogicalVolume = physVol->GetLogicalVolume();
        //use shadow pointer
        G4VSolid *g4VSolid = g4LogicalVolume->GetMasterSolid();
        G4PVReplica *g4PVReplica = 0;
        g4PVReplica =  dynamic_cast<G4PVReplica*>(physVol);
        if (g4PVReplica)
        {
            //g4PVReplica->SlaveG4PVReplica(g4PVReplica);
            g4PVReplica->InitialiseWorker(g4PVReplica);
            G4PVParameterised *g4PVParameterised = 0;
            g4PVParameterised =  dynamic_cast<G4PVParameterised*>(physVol);
            if (g4PVParameterised)
            {
                //01.25.2009 Xin Dong: For a G4PVParameterised instance, assoicated a
                //cloned solid for each worker thread. If all solids support this clone
                //method, we do not need to dynamically cast to solids that support this
                //clone method. Before all solids support this clone method, we do similar
                //thing here to dynamically cast and then get the clone method.
                
                //Threads may clone some 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 *slaveg4VSolid = g4VSolid->Clone();
                aLock.unlock();
                //g4LogicalVolume->SlaveG4LogicalVolume(g4LogicalVolume, slaveg4VSolid, 0);
                g4LogicalVolume->InitialiseWorker(g4LogicalVolume,slaveg4VSolid,0);
            }
            else
            {
                //g4LogicalVolume->SlaveG4LogicalVolume(g4LogicalVolume, g4VSolid, 0);
                g4LogicalVolume->InitialiseWorker(g4LogicalVolume,g4VSolid,0);
            }
        }
        else
        {
            //g4LogicalVolume->SlaveG4LogicalVolume(g4LogicalVolume, g4VSolid, 0);
            g4LogicalVolume->InitialiseWorker(g4LogicalVolume,g4VSolid,0);
        }
    }
     */
    
    //const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
    
    //size_t nmat = theMaterialTable->size();
    //size_t i;
    //for(i=0; i<nmat; i++) {
    //    ((*theMaterialTable)[i])->SlaveG4Material();
    //}
}

void G4WorkerThread::DestroyGeometryAndPhysicsVector ( )

static

Definition at line 156 of file G4WorkerThread.cc.

References G4GeometryWorkspace::DestroyWorkspace(), G4SolidsWorkspace::DestroyWorkspace(), G4SolidsWorkspacePool::GetInstance(), G4GeometryWorkspacePool::GetInstance(), G4VModularPhysicsList::GetSubInstanceManager(), G4VPhysicsConstructor::GetSubInstanceManager(), G4VUserPhysicsList::GetSubInstanceManager(), G4SolidsWorkspacePool::GetWorkspace(), and G4GeometryWorkspacePool::GetWorkspace().

Referenced by G4MTRunManagerKernel::StartThread().

{
#if 0
    // Manage Geometry Workspace explicitly
    fGeometryWrk->ReleaseAndDestroyWorkspace();
    delete fGeometryWrk;
    fGeometryWrk=0;
#else
    // Alternative:
    // Initialise all split classes in the geometry with copy of data from master thread
    // G4GeometryWorkspacePool::GetInstance()->ReleaseAndDestroyMyWorkspace();
    G4GeometryWorkspacePool::GetInstance()->GetWorkspace()->DestroyWorkspace();
    G4SolidsWorkspacePool::GetInstance()->GetWorkspace()->DestroyWorkspace();
#endif
//    
//
//    G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
//    for (size_t ip=0; ip<physVolStore->size(); ip++)
//    {
//        G4VPhysicalVolume* physVol = (*physVolStore)[ip];
//        G4LogicalVolume *g4LogicalVolume = physVol->GetLogicalVolume();
//        //    G4VSolid *g4VSolid = g4LogicalVolume->fSolid;
//        G4PVReplica *g4PVReplica = 0;
//        g4PVReplica =  dynamic_cast<G4PVReplica*>(physVol);
//        if (g4PVReplica)
//        {
//            //g4PVReplica->DestroySlaveG4PVReplica(g4PVReplica);
//            g4PVReplica->TerminateWorker(g4PVReplica);
//            G4PVParameterised *g4PVParameterised = 0;
//            g4PVParameterised =  dynamic_cast<G4PVParameterised*>(physVol);
//            if (g4PVParameterised)
//            {
//                //        G4VSolid *slaveg4VSolid = g4VSolid->Clone();
//                //g4LogicalVolume->DestroySlaveG4LogicalVolume(g4LogicalVolume);
//                g4LogicalVolume->TerminateWorker(g4LogicalVolume);
//                //        delete slaveg4VSolid;
//            }
//            else
//            {
//                //g4LogicalVolume->DestroySlaveG4LogicalVolume(g4LogicalVolume);
//                g4LogicalVolume->TerminateWorker(g4LogicalVolume);
//            }
//        }
//        else
//        {
//            //g4LogicalVolume->DestroySlaveG4LogicalVolume(g4LogicalVolume);
//            g4LogicalVolume->TerminateWorker(g4LogicalVolume);
//        }
//    }
//    
//    //const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
//    
//    //size_t nmat = theMaterialTable->size();
//    //size_t i;
//    //for(i=0; i<nmat; i++) {
//    //    ((*theMaterialTable)[i])->DestroySlaveG4Material();
//    //}
//    
//    const_cast<G4LVManager&>(G4LogicalVolume::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4PVManager&>(G4VPhysicalVolume::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4PVRManager&>(G4PVReplica::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4PDefManager&>(G4ParticleDefinition::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4RegionManager&>(G4Region::GetSubInstanceManager()).FreeSlave();
//    //const_cast<G4PVecManager&>(G4PhysicsVector::GetSubInstanceManager()).FreeSlave();
///////@@    const_cast<G4DecayChannelManager&>(G4VDecayChannel::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4PlSideManager&>(G4PolyconeSide::GetSubInstanceManager()).FreeSlave();
//    const_cast<G4PhSideManager&>(G4PolyhedraSide::GetSubInstanceManager()).FreeSlave();
    const_cast<G4VUPLManager&>(G4VUserPhysicsList::GetSubInstanceManager()).FreeSlave();
    const_cast<G4VPCManager&>(G4VPhysicsConstructor::GetSubInstanceManager()).FreeSlave();
    const_cast<G4VMPLManager&>(G4VModularPhysicsList::GetSubInstanceManager()).FreeSlave();
}

G4int G4WorkerThread::GetNumberThreads

(

)

const

Definition at line 45 of file G4WorkerThread.cc.

{
    return numThreads;
}

G4int G4WorkerThread::GetThreadId

(

)

const

Definition at line 35 of file G4WorkerThread.cc.

Referenced by G4MTRunManagerKernel::StartThread(), and G4WorkerRunManager::StoreRNGStatus().

{
    return threadId;
}

void G4WorkerThread::SetNumberThreads

(

G4int

numnberThreads

)

Definition at line 40 of file G4WorkerThread.cc.

Referenced by G4MTRunManager::CreateAndStartWorkers().

{
    numThreads = nw;
}

void G4WorkerThread::SetThreadId

(

G4int

threadId

)

Definition at line 30 of file G4WorkerThread.cc.

Referenced by G4MTRunManager::CreateAndStartWorkers().

{
    threadId = tid;
}

void G4WorkerThread::UpdateGeometryAndPhysicsVectorFromMaster ( )

static

Definition at line 231 of file G4WorkerThread.cc.

References G4GeometryWorkspace::DestroyWorkspace(), G4SolidsWorkspace::DestroyWorkspace(), G4Region::GetFastSimulationManager(), G4LogicalVolume::GetFieldManager(), G4GeometryWorkspacePool::GetInstance(), G4SolidsWorkspacePool::GetInstance(), G4LogicalVolumeStore::GetInstance(), G4RegionStore::GetInstance(), G4LogicalVolume::GetMasterFieldManager(), G4LogicalVolume::GetMasterSensitiveDetector(), G4LogicalVolume::GetRegion(), G4Region::GetRegionalSteppingAction(), G4LogicalVolume::GetSensitiveDetector(), G4GeometryWorkspacePool::GetWorkspace(), G4SolidsWorkspacePool::GetWorkspace(), G4GeometryWorkspace::InitialiseWorkspace(), G4SolidsWorkspace::InitialiseWorkspace(), G4LogicalVolume::IsRootRegion(), python.hepunit::second, G4Region::SetFastSimulationManager(), G4LogicalVolume::SetFieldManager(), G4LogicalVolume::SetRegion(), G4Region::SetRegionalSteppingAction(), G4LogicalVolume::SetRegionRootFlag(), and G4LogicalVolume::SetSensitiveDetector().

Referenced by G4MTRunManagerKernel::StartThread().

{
    //=================================================
    //Step-0: keep sensitive detector and field manager
    //=================================================
    // First remember SD and Filed Associated with worker
    //  in order to re-use it
    // (note that all the stuff after this will reset SD and Field
    typedef std::map<G4LogicalVolume*,std::pair<G4VSensitiveDetector*,G4FieldManager*> > LV2SDFM;
    LV2SDFM lvmap;
    typedef std::map<G4LogicalVolume*,std::pair<G4Region*,G4bool> > LV2Region;
    LV2Region lv2rmap;
    typedef std::map<G4Region*,std::pair<G4FastSimulationManager*,G4UserSteppingAction*> > R2FSM;
    R2FSM rgnmap;
    G4LogicalVolumeStore* mLogVolStore = G4LogicalVolumeStore::GetInstance();
    for(size_t ip=0; ip<mLogVolStore->size(); ip++)
    {
        G4LogicalVolume *lv = (*mLogVolStore)[ip];
        //The following needs an explanation.
        //Consider the case in which the user adds one LogVolume between the runs. The problem is that the thread-local part
        //(split class) of the G4LogicalVolume object is not initialized for workers because the initialization is done once when the
        //thread starts (see G4MTRunManagerKernel::StartThread Step-2 that calls G4WorkerThread::BuildGeometryAndPhysicsVector in this class)
        //The problem is that pointers of SD and FM for these newly added LV
        //may be invalid pointers (because never initialized, we have seen this behavior in our testing). If now we remember
        //them and re-use them in Step-4 below we set invalid pointers to LV for this thread.
        //Thus we need a way to know if for a given LV we need to remember or not the SD and FM pointers.
        //To solve this problem: We assume that the ConstructSDandField is called also by Master thread
        //thus for newly added LV the shadow pointers of SD and Fields are correct.
        // (LIMITATION: this assumption may be too stringent, a user to save memory could instantiate SD only
        // for workers, but we require this not to happen!).
        // Thus is a SD and FieldMgr are needed for this particular LV, and shadow are !=0 it means that user
        // wants an SD and FM to be associated with LV, we get the values and we remember them.
        G4VSensitiveDetector* sd = 0;
        G4FieldManager* fmgr = 0;
        if ( lv->GetMasterSensitiveDetector() != 0 ) sd = lv->GetSensitiveDetector();
        if ( lv->GetMasterFieldManager() != 0 ) fmgr = lv->GetFieldManager();
        if ( sd || fmgr ) lvmap[lv] = std::make_pair(sd,fmgr);
        G4Region* rgn = lv->GetRegion();
        G4bool isRoot = lv->IsRootRegion();
        if ( rgn || isRoot ) lv2rmap[lv] = std::make_pair(rgn,isRoot);
    }
    G4RegionStore* mRegStore = G4RegionStore::GetInstance();
    for(size_t ir=0; ir<mRegStore->size(); ir++)
    {
        G4Region* reg = (*mRegStore)[ir];
        G4FastSimulationManager* fsm = reg->GetFastSimulationManager();
        G4UserSteppingAction* usa = reg->GetRegionalSteppingAction();
        if ( reg || usa ) rgnmap[reg] = std::make_pair(fsm,usa);
    }

    //===========================
    //Step-1: Clean the workspace
    //===========================
    G4GeometryWorkspace* geomWorkspace= G4GeometryWorkspacePool::GetInstance()->GetWorkspace();
    geomWorkspace->DestroyWorkspace();
    G4SolidsWorkspace* solidWorkspace = G4SolidsWorkspacePool::GetInstance()->GetWorkspace();
    solidWorkspace->DestroyWorkspace();
    
    //===========================
    //Step-2: Re-create and initialize workspace
    //===========================
    geomWorkspace->InitialiseWorkspace();
    solidWorkspace->InitialiseWorkspace();

    // Alternative
    //
    // To wipe, release and get a new one ...
    // G4GeometryWorkspacePool *fWorkspaceMgr=  G4GeometryWorkspaceOutlet::GetInstance();
    // fWorkspaceMgr->ReleaseAndDestroyMyWorkspace();
    // Now re-create
    // fWorkspaceMgr->CreateAndUseWorkspace();
    
    
    //===================================================
    //Step-4: Restore sensitive detector and field manaer
    //===================================================
    for ( LV2SDFM::const_iterator it = lvmap.begin() ; it != lvmap.end() ; ++it )
    {
        G4LogicalVolume* lv      = it->first;
        G4VSensitiveDetector* sd = (it->second).first;
        G4FieldManager* fmgr       = (it->second).second;
        if(fmgr) lv->SetFieldManager(fmgr, false); //What should be the second parameter? We use always false for MT mode
        if(sd) lv->SetSensitiveDetector(sd);
    }
    for ( LV2Region::const_iterator it2 = lv2rmap.begin() ; it2 != lv2rmap.end() ; it2++ )
    {
        G4LogicalVolume* lv2 = it2->first;
        G4Region* rgn = (it2->second).first;
        if(rgn) lv2->SetRegion(rgn);
        G4bool isRoot = (it2->second).second;
        lv2->SetRegionRootFlag(isRoot);
    }
    for ( R2FSM::const_iterator it3 = rgnmap.begin() ; it3 != rgnmap.end() ; it3++ )
    {
        G4Region* reg = it3->first;
        G4FastSimulationManager* fsm = (it3->second).first;
        if(fsm) reg->SetFastSimulationManager(fsm);
        G4UserSteppingAction* usa = (it3->second).second;
        if(usa) reg->SetRegionalSteppingAction(usa);
    }
}

---

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

• G4WorkerThread.hh
• G4WorkerThread.cc