#include <G4GlobalFastSimulationManager.hh>

Public Member Functions
void	ActivateFastSimulationModel (const G4String &)

void	AddFastSimulationManager (G4FastSimulationManager *)

void	AddFSMP (G4FastSimulationManagerProcess *)

void	FastSimulationNeedsToBeClosed ()

G4VFastSimulationModel *	GetFastSimulationModel (const G4String &modelName, const G4VFastSimulationModel *previousFound=0) const

void	InActivateFastSimulationModel (const G4String &)

void	ListEnvelopes (const G4ParticleDefinition *)

void	ListEnvelopes (const G4String &aName="all", listType aListType=NAMES_ONLY)

void	RemoveFastSimulationManager (G4FastSimulationManager *)

void	RemoveFSMP (G4FastSimulationManagerProcess *)

void	ShowSetup ()

	~G4GlobalFastSimulationManager ()

Static Public Member Functions
static G4GlobalFastSimulationManager *	GetGlobalFastSimulationManager ()

static G4GlobalFastSimulationManager *	GetInstance ()

Private Member Functions
void	DisplayRegion (G4Region motherRegion, G4int depth, std::vector< G4ParticleDefinition > &particles) const

	G4GlobalFastSimulationManager ()

Private Attributes
G4FastSimulationVector< G4FastSimulationManagerProcess >	fFSMPVector

G4FastSimulationMessenger *	fTheFastSimulationMessenger

G4FastSimulationVector< G4FastSimulationManager >	ManagedManagers

Static Private Attributes
static G4ThreadLocal G4GlobalFastSimulationManager *	fGlobalFastSimulationManager = 0

Detailed Description

Definition at line 84 of file G4GlobalFastSimulationManager.hh.

Constructor & Destructor Documentation

◆ ~G4GlobalFastSimulationManager()

G4GlobalFastSimulationManager::~G4GlobalFastSimulationManager ( )

Definition at line 95 of file G4GlobalFastSimulationManager.cc.

{
  delete fTheFastSimulationMessenger;
  fTheFastSimulationMessenger = 0;
}

References fTheFastSimulationMessenger.

◆ G4GlobalFastSimulationManager()

G4GlobalFastSimulationManager::G4GlobalFastSimulationManager ( )

private

Definition at line 87 of file G4GlobalFastSimulationManager.cc.

{
  fTheFastSimulationMessenger = new G4FastSimulationMessenger(this);
}

References fTheFastSimulationMessenger.

Referenced by GetGlobalFastSimulationManager().

Member Function Documentation

◆ ActivateFastSimulationModel()

void G4GlobalFastSimulationManager::ActivateFastSimulationModel ( const G4String & aName )

Definition at line 126 of file G4GlobalFastSimulationManager.cc.

{
  G4bool result = false;
  for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    result = result || ManagedManagers[ifsm]->
                       ActivateFastSimulationModel(aName);
  if(result) 
    G4cout << "Model " << aName << " activated.";
  else
    G4cout << "Model " << aName << " not found.";
  G4cout << G4endl;
}

References ActivateFastSimulationModel(), G4cout, G4endl, and ManagedManagers.

Referenced by ActivateFastSimulationModel(), and G4FastSimulationMessenger::SetNewValue().

◆ AddFastSimulationManager()

void G4GlobalFastSimulationManager::AddFastSimulationManager ( G4FastSimulationManager * fsmanager )

Definition at line 104 of file G4GlobalFastSimulationManager.cc.

{
  ManagedManagers.push_back(fsmanager);
}

References ManagedManagers.

◆ AddFSMP()

void G4GlobalFastSimulationManager::AddFSMP ( G4FastSimulationManagerProcess * fp )

Definition at line 116 of file G4GlobalFastSimulationManager.cc.

{
  fFSMPVector.push_back(fp);
}

References fFSMPVector.

Referenced by G4FastSimulationManagerProcess::G4FastSimulationManagerProcess().

◆ DisplayRegion()

void G4GlobalFastSimulationManager::DisplayRegion	(	G4Region *	motherRegion,
		G4int	depth,
		std::vector< G4ParticleDefinition * > &	particles
	)		const

private

Definition at line 209 of file G4GlobalFastSimulationManager.cc.

{
  G4String indent = "        ";
  for (G4int I=0; I<depth; I++) indent += "    ";
  G4cout << indent << "Region: `" << region->GetName() <<"'"  << G4endl;
  G4FastSimulationManager* fastSimManager = region->GetFastSimulationManager();
  if (fastSimManager)
    {
      indent += "    ";
      G4cout << indent << "Model(s):" << G4endl;
      indent += "    ";
      for (size_t im=0; im<fastSimManager->GetFastSimulationModelList().size(); im++)
    {
      G4cout << indent << "`" << (fastSimManager->GetFastSimulationModelList())[im]->GetName() << "'";
      G4cout << " ; applicable to:";
      G4ParticleTable* particles = G4ParticleTable::GetParticleTable();
      for (G4int iParticle=0; iParticle<particles->entries(); iParticle++)
        {
          if ((fastSimManager->GetFastSimulationModelList())[im]->IsApplicable(*(particles->GetParticle(iParticle))))
        {
          G4cout << " " << particles->GetParticle(iParticle)->GetParticleName();
          G4bool known(false);
          for (size_t l=0; l<particlesKnown.size();l++) if(particlesKnown[l] == particles->GetParticle(iParticle)) {known = true; break;}
          if (!known) G4cout << "[!!]";
        }
        }
      G4cout << G4endl;
    }
    }
  
  // -- all that to check mothership of "region"
  G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
  for (size_t ip=0; ip<physVolStore->size(); ip++)
    {
      G4VPhysicalVolume* physVol = (*physVolStore)[ip];
      if (physVol->GetLogicalVolume()->IsRootRegion())
    if (physVol->GetMotherLogical())
      {
        G4Region* thisVolMotherRegion = physVol->GetMotherLogical()->GetRegion();
        if (thisVolMotherRegion == region)
          DisplayRegion(physVol->GetLogicalVolume()->GetRegion(), depth+1, particlesKnown);
      }
    }
}

References DisplayRegion(), G4ParticleTable::entries(), G4cout, G4endl, G4Region::GetFastSimulationManager(), G4FastSimulationManager::GetFastSimulationModelList(), G4PhysicalVolumeStore::GetInstance(), G4VPhysicalVolume::GetLogicalVolume(), G4VPhysicalVolume::GetMotherLogical(), G4Region::GetName(), G4ParticleTable::GetParticle(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4LogicalVolume::GetRegion(), and G4LogicalVolume::IsRootRegion().

Referenced by DisplayRegion(), and ShowSetup().

◆ FastSimulationNeedsToBeClosed()

void G4GlobalFastSimulationManager::FastSimulationNeedsToBeClosed ( )

◆ GetFastSimulationModel()

G4VFastSimulationModel * G4GlobalFastSimulationManager::GetFastSimulationModel	(	const G4String &	modelName,
		const G4VFastSimulationModel *	previousFound = `0`
	)		const

Definition at line 302 of file G4GlobalFastSimulationManager.cc.

{
  G4VFastSimulationModel* model = 0;
  // -- flag used to navigate accross the various managers;
  bool foundPrevious(false);
  for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    {
      model = ManagedManagers[ifsm]->
              GetFastSimulationModel(modelName, previousFound, foundPrevious);
      if (model) break;
    }
  return model;
}

References GetFastSimulationModel(), and ManagedManagers.

Referenced by GetFastSimulationModel().

◆ GetGlobalFastSimulationManager()

G4GlobalFastSimulationManager * G4GlobalFastSimulationManager::GetGlobalFastSimulationManager ( )

static

Definition at line 70 of file G4GlobalFastSimulationManager.cc.

{
  if(!fGlobalFastSimulationManager)
    fGlobalFastSimulationManager = new G4GlobalFastSimulationManager;
  
  return fGlobalFastSimulationManager;
}

References fGlobalFastSimulationManager, and G4GlobalFastSimulationManager().

Referenced by G4FastSimulationManager::G4FastSimulationManager(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), GetInstance(), G4FastSimulationManager::~G4FastSimulationManager(), and G4FastSimulationManagerProcess::~G4FastSimulationManagerProcess().

◆ GetInstance()

G4GlobalFastSimulationManager * G4GlobalFastSimulationManager::GetInstance ( )

static

Definition at line 79 of file G4GlobalFastSimulationManager.cc.

{
  return G4GlobalFastSimulationManager::GetGlobalFastSimulationManager();
}

References GetGlobalFastSimulationManager().

◆ InActivateFastSimulationModel()

void G4GlobalFastSimulationManager::InActivateFastSimulationModel ( const G4String & aName )

Definition at line 139 of file G4GlobalFastSimulationManager.cc.

{
  G4bool result = false;
  for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    result = result || ManagedManagers[ifsm]->
                       InActivateFastSimulationModel(aName);
  if (result) G4cout << "Model " << aName << " inactivated.";
  else        G4cout << "Model " << aName << " not found.";
  G4cout << G4endl;
}

References G4cout, G4endl, InActivateFastSimulationModel(), and ManagedManagers.

Referenced by InActivateFastSimulationModel(), and G4FastSimulationMessenger::SetNewValue().

◆ ListEnvelopes() [1/2]

void G4GlobalFastSimulationManager::ListEnvelopes ( const G4ParticleDefinition * aPD )

Definition at line 295 of file G4GlobalFastSimulationManager.cc.

{
  for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    ManagedManagers[ifsm]->ListModels(aPD);
}

References ManagedManagers.

◆ ListEnvelopes() [2/2]

void G4GlobalFastSimulationManager::ListEnvelopes	(	const G4String &	aName = `"all"`,
		listType	aListType = `NAMES_ONLY`
	)

Definition at line 259 of file G4GlobalFastSimulationManager.cc.

{
  if (theType == ISAPPLICABLE)
    {
      for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++) ManagedManagers[ifsm]->ListModels(aName);
      return;
    }
  
  if(aName == "all")
    {
      G4int titled = 0;
      for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    {
      if(theType == NAMES_ONLY)
        {
          if(!(titled++))
        G4cout << "Current Envelopes for Fast Simulation:\n";
          G4cout << "   "; 
          ManagedManagers[ifsm]->ListTitle();
          G4cout << G4endl;
        }
      else ManagedManagers[ifsm]->ListModels();
    }
    }
  else
    {
      for (size_t ifsm=0; ifsm<ManagedManagers.size(); ifsm++)
    if(aName == ManagedManagers[ifsm]-> GetEnvelope()->GetName())
      {
        ManagedManagers[ifsm]->ListModels();
        break;
      }
    }
}

References G4cout, G4endl, ISAPPLICABLE, ManagedManagers, and NAMES_ONLY.

Referenced by G4FastSimulationMessenger::SetNewValue().

◆ RemoveFastSimulationManager()

void G4GlobalFastSimulationManager::RemoveFastSimulationManager ( G4FastSimulationManager * fsmanager )

Definition at line 110 of file G4GlobalFastSimulationManager.cc.

{
  ManagedManagers.remove(fsmanager);
}

References ManagedManagers, and G4FastSimulationVector< T >::remove().

◆ RemoveFSMP()

void G4GlobalFastSimulationManager::RemoveFSMP ( G4FastSimulationManagerProcess * fp )

Definition at line 121 of file G4GlobalFastSimulationManager.cc.

{
  fFSMPVector.remove(fp);
}

References fFSMPVector, and G4FastSimulationVector< T >::remove().

Referenced by G4FastSimulationManagerProcess::~G4FastSimulationManagerProcess().

◆ ShowSetup()

void G4GlobalFastSimulationManager::ShowSetup ( )

Definition at line 154 of file G4GlobalFastSimulationManager.cc.

{
  std::vector<G4VPhysicalVolume*> worldDone;
  G4VPhysicalVolume* world;
  G4RegionStore* regions = G4RegionStore::GetInstance();
  // ----------------------------------------------------
  // -- loop on regions to get the list of world volumes:
  // ----------------------------------------------------
  G4cout << "\nFast simulation setup:" << G4endl;
  for (size_t i=0; i<regions->size(); i++)
    {
      world = (*regions)[i]->GetWorldPhysical();
      if (world == nullptr) // region does not belong to any (existing) world
        {
          continue;
        }
      G4bool newWorld = true;
      for (size_t ii=0; ii<worldDone.size(); ii++) if (worldDone[ii] == world) {newWorld = false; break;}
      if (newWorld)
    {
      worldDone.push_back(world);
      G4Region* worldRegion = world->GetLogicalVolume()->GetRegion();
      // -- preambule: print physical volume and region names...
      if (world == G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume())
        G4cout << "\n    * Mass Geometry with ";
      else
        G4cout << "\n    * Parallel Geometry with ";
      G4cout << "world volume: `" << world->GetName() << "' [region : `" << worldRegion->GetName() << "']"  << G4endl;
      // -- ... and print G4FSMP(s) attached to this world volume:
      G4bool findG4FSMP(false);
      // -- show to what particles this G4FSMP is attached to:
      std::vector<G4ParticleDefinition*> particlesKnown;
      for (size_t ip=0; ip<fFSMPVector.size(); ip++)
        if (fFSMPVector[ip]->GetWorldVolume() == world)
          {
        G4cout << "        o G4FastSimulationProcess: '" << fFSMPVector[ip]->GetProcessName() << "'" << G4endl;
        G4cout << "                      Attached to:";
        G4ParticleTable* particles = G4ParticleTable::GetParticleTable();
        for (G4int iParticle=0; iParticle<particles->entries(); iParticle++)
          {
            G4ParticleDefinition*  particle = particles->GetParticle(iParticle);
            G4ProcessVector*      processes = particle->GetProcessManager()->GetProcessList();
            if (processes->contains(fFSMPVector[ip])) {G4cout << " " << particle->GetParticleName(); findG4FSMP = true; particlesKnown.push_back(particle);}
          }
        G4cout << G4endl;
          }
      if (!findG4FSMP) G4cout << "        o G4FastSimulationProcess: (none)" << G4endl;
      // -- now display the regions in this world volume, with mother<->daughter link shown by indentation:
      G4cout << "        o Region(s) and model(s) setup:" << G4endl;
      DisplayRegion(worldRegion, 1, particlesKnown);
    }
    }
}