G4FastSimulationManager Class Reference

#include <G4FastSimulationManager.hh>

Public Member Functions
	G4FastSimulationManager (G4Envelope *anEnvelope, G4bool IsUnique=FALSE)
	~G4FastSimulationManager ()
void	AddFastSimulationModel (G4VFastSimulationModel *)
void	RemoveFastSimulationModel (G4VFastSimulationModel *)
G4bool	ActivateFastSimulationModel (const G4String &)
G4bool	InActivateFastSimulationModel (const G4String &)
void	ListTitle () const
void	ListModels () const
void	ListModels (const G4ParticleDefinition *) const
void	ListModels (const G4String &aName) const
const G4Envelope *	GetEnvelope () const
G4VFastSimulationModel *	GetFastSimulationModel (const G4String &modelName, const G4VFastSimulationModel *previousFound, G4bool &foundPrevious) const
const std::vector< G4VFastSimulationModel * > &	GetFastSimulationModelList () const
void	FlushModels ()
G4bool	PostStepGetFastSimulationManagerTrigger (const G4Track &, const G4Navigator *a=nullptr)
G4VParticleChange *	InvokePostStepDoIt ()
G4bool	AtRestGetFastSimulationManagerTrigger (const G4Track &, const G4Navigator *a=nullptr)
G4VParticleChange *	InvokeAtRestDoIt ()
G4bool	operator== (const G4FastSimulationManager &) const

Detailed Description

Definition at line 73 of file G4FastSimulationManager.hh.

Constructor & Destructor Documentation

G4FastSimulationManager()

G4FastSimulationManager::G4FastSimulationManager	(	G4Envelope *	anEnvelope,
		G4bool	IsUnique = FALSE )

Definition at line 52 of file G4FastSimulationManager.cc.

  : fFastTrack(anEnvelope, IsUnique)
{
  // Communicates to the region that it becomes a
  // envelope and with this fast simulation manager.
  anEnvelope->SetFastSimulationManager(this);
 
  // Add itself to the GlobalFastSimulationManager
  G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->AddFastSimulationManager(this);
}

Referenced by operator==().

~G4FastSimulationManager()

G4FastSimulationManager::~G4FastSimulationManager

(

)

Definition at line 66 of file G4FastSimulationManager.cc.

{
  //
  // Check out the Envelope about this pointer. If in use,
  // resets the Logical Volume IsEnvelope flag to avoid clash.
  //
  if (fFastTrack.GetEnvelope()->GetFastSimulationManager() == this)
    fFastTrack.GetEnvelope()->ClearFastSimulationManager();
  // Remove itself from the GlobalFastSimulationManager
  G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->RemoveFastSimulationManager(
    this);
}

Member Function Documentation

ActivateFastSimulationModel()

G4bool G4FastSimulationManager::ActivateFastSimulationModel

(

const G4String &

aName

)

Definition at line 83 of file G4FastSimulationManager.cc.

{
  G4int iModel;
 
  // If the model is already active, do nothing.
  for (iModel = 0; iModel < (G4int)ModelList.size(); ++iModel)
    if (ModelList[iModel]->GetName() == aName) return true;
 
  // Look for in the fInactivatedModels list, if found push_back it back to
  // the ModelList
  for (iModel = 0; iModel < (G4int)fInactivatedModels.size(); ++iModel)
    if (fInactivatedModels[iModel]->GetName() == aName) {
      ModelList.push_back(fInactivatedModels.removeAt(iModel));
      // forces the fApplicableModelList to be rebuild
      fLastCrossedParticle = nullptr;
      return true;
    }
  return false;
}

AddFastSimulationModel()

void G4FastSimulationManager::AddFastSimulationModel ( G4VFastSimulationModel * fsm )

inline

Definition at line 164 of file G4FastSimulationManager.hh.

{
  ModelList.push_back(fsm);
  // forces the fApplicableModelList to be rebuild
  fLastCrossedParticle = nullptr;
}

Referenced by G4VFastSimulationModel::G4VFastSimulationModel().

AtRestGetFastSimulationManagerTrigger()

G4bool G4FastSimulationManager::AtRestGetFastSimulationManagerTrigger	(	const G4Track &	track,
		const G4Navigator *	a = nullptr )

Definition at line 236 of file G4FastSimulationManager.cc.

{
  // If particle type changed re-build the fApplicableModelList.
  if (fLastCrossedParticle != track.GetDefinition()) {
    fLastCrossedParticle = track.GetDefinition();
    fApplicableModelList.clear();
    // If Model List is empty, do nothing !
    if (ModelList.empty()) return false;
 
    for (auto iModel : ModelList) {
      if (iModel->IsApplicable(*(track.GetDefinition()))) {
        fApplicableModelList.push_back(iModel);
      }
    }
  }
 
  // If Applicable Model List is empty, do nothing !
  if (fApplicableModelList.empty()) return false;
 
  // -- Register current track
  fFastTrack.SetCurrentTrack(track, theNavigator);
 
  // -- (note: compared to the PostStepGetFastSimulationManagerTrigger,
  // --  the test to see if the particle is on the boundary but leaving
  // --  is irrelevant here)
 
  // Loops on the models to see if one of them wants to trigger:
  for (auto iModel : fApplicableModelList) {
    if (iModel->AtRestModelTrigger(fFastTrack)) {
      fFastStep.Initialize(fFastTrack);
      fTriggedFastSimulationModel = iModel;
      return true;
    }
  }
  //--------------------------------------------
  // Nobody asks to gain control, returns false
  //--------------------------------------------
  return false;
}

FlushModels()

void G4FastSimulationManager::FlushModels

(

)

Definition at line 142 of file G4FastSimulationManager.cc.

{
  for (auto& iModel : ModelList) {
    iModel->Flush();
  }
}

GetEnvelope()

const G4Envelope * G4FastSimulationManager::GetEnvelope ( ) const

inline

Definition at line 183 of file G4FastSimulationManager.hh.

{
  return fFastTrack.GetEnvelope();
}

GetFastSimulationModel()

G4VFastSimulationModel * G4FastSimulationManager::GetFastSimulationModel	(	const G4String &	modelName,
		const G4VFastSimulationModel *	previousFound,
		G4bool &	foundPrevious ) const

Definition at line 118 of file G4FastSimulationManager.cc.

{
  G4VFastSimulationModel* model = nullptr;
  for (auto iModel : ModelList) {
    if (iModel->GetName() == modelName) {
      if (previousFound == nullptr) {
        model = iModel;
        break;
      }
      if (iModel == previousFound) {
        foundPrevious = true;
        continue;
      }
      if (foundPrevious) {
        model = iModel;
        break;
      }
    }
  }
  return model;
}

GetFastSimulationModelList()

const std::vector< G4VFastSimulationModel * > & G4FastSimulationManager::GetFastSimulationModelList ( ) const

inline

Definition at line 126 of file G4FastSimulationManager.hh.

    {
      return ModelList;
    }

InActivateFastSimulationModel()

G4bool G4FastSimulationManager::InActivateFastSimulationModel

(

const G4String &

aName

)

Definition at line 103 of file G4FastSimulationManager.cc.

{
  // Look for in the ModelList, if found remove from it and keep the pointer
  // on the fInactivatedModels list.
  for (G4int iModel = 0; iModel < (G4int)ModelList.size(); ++iModel)
    if (ModelList[iModel]->GetName() == aName) {
      fInactivatedModels.push_back(ModelList.removeAt(iModel));
      // forces the fApplicableModelList to be rebuild
      fLastCrossedParticle = nullptr;
      return true;
    }
  return false;
}

InvokeAtRestDoIt()

G4VParticleChange * G4FastSimulationManager::InvokeAtRestDoIt

(

)

Definition at line 277 of file G4FastSimulationManager.cc.

{
  fTriggedFastSimulationModel->AtRestDoIt(fFastTrack, fFastStep);
  return &fFastStep;
}

InvokePostStepDoIt()

G4VParticleChange * G4FastSimulationManager::InvokePostStepDoIt

(

)

Definition at line 226 of file G4FastSimulationManager.cc.

{
  fTriggedFastSimulationModel->DoIt(fFastTrack, fFastStep);
  return &fFastStep;
}

ListModels() [1/3]

void G4FastSimulationManager::ListModels

(

)

const

Definition at line 295 of file G4FastSimulationManager.cc.

{
  G4cout << "Current Models for the ";
  ListTitle();
  G4cout << " envelope:\n";
 
  for (auto iModel : ModelList)
    G4cout << "   " << iModel->GetName() << "\n";
 
  for (auto iModel : fInactivatedModels)
    G4cout << "   " << iModel->GetName() << "(inactivated)\n";
}

ListModels() [2/3]

void G4FastSimulationManager::ListModels

(

const G4ParticleDefinition *

particleDefinition

)

const

Definition at line 354 of file G4FastSimulationManager.cc.

{
  std::size_t iModel;
  G4bool unique = true;
 
  // Active Models
  for (iModel = 0; iModel < ModelList.size(); ++iModel)
    if (ModelList[iModel]->IsApplicable(*particleDefinition)) {
      G4cout << "Envelope ";
      ListTitle();
      G4cout << ", Model " << ModelList[iModel]->GetName() << "." << G4endl;
      // -- Verify unicity of model attached to particleDefinition:
      for (auto jModel = iModel + 1; jModel < ModelList.size(); jModel++)
        if (ModelList[jModel]->IsApplicable(*particleDefinition)) unique = false;
    }
 
  // Inactive Models
  for (iModel = 0; iModel < fInactivatedModels.size(); ++iModel)
    if (fInactivatedModels[iModel]->IsApplicable(*particleDefinition)) {
      G4cout << "Envelope ";
      ListTitle();
      G4cout << ", Model " << fInactivatedModels[iModel]->GetName() << " (inactivated)." << G4endl;
    }
 
  if (!unique) {
    G4ExceptionDescription ed;
    ed << "Two or more active Models are available for the same particle type, in the same "
          "envelope/region."
       << G4endl;
    G4Exception(
      "G4FastSimulationManager::ListModels(const G4ParticleDefinition* particleDefinition) const",
      "FastSim001", JustWarning, ed, "Models risk to exclude each other.");
  }
  unique = false;
}

ListModels() [3/3]

void G4FastSimulationManager::ListModels

(

const G4String &

aName

)

const

Definition at line 308 of file G4FastSimulationManager.cc.

{
  std::size_t iModel;
  G4int titled = 0;
  G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
 
  // Active Models
  for (iModel = 0; iModel < ModelList.size(); ++iModel)
    if (ModelList[iModel]->GetName() == modelName || modelName == "all") {
      if ((titled++) == 0) {
        G4cout << "In the envelope ";
        ListTitle();
        G4cout << ",\n";
      }
      G4cout << "  the model " << ModelList[iModel]->GetName() << " is applicable for :\n     ";
 
      G4int list_started = 0;
      for (G4int iParticle = 0; iParticle < theParticleTable->entries(); iParticle++)
        if (ModelList[iModel]->IsApplicable(*(theParticleTable->GetParticle(iParticle)))) {
          if ((list_started++) != 0) G4cout << ", ";
          G4cout << theParticleTable->GetParticle(iParticle)->GetParticleName();
        }
      G4cout << G4endl;
    }
 
  // Inactive Models
  for (iModel = 0; iModel < fInactivatedModels.size(); ++iModel)
    if (fInactivatedModels[iModel]->GetName() == modelName || modelName == "all") {
      if ((titled++) == 0) {
        G4cout << "In the envelope ";
        ListTitle();
        G4cout << ",\n";
      }
      G4cout << "  the model " << fInactivatedModels[iModel]->GetName()
             << " (inactivated) is applicable for :\n     ";
 
      G4int list_started = 0;
      for (G4int iParticle = 0; iParticle < theParticleTable->entries(); iParticle++)
        if (fInactivatedModels[iModel]->IsApplicable(*(theParticleTable->GetParticle(iParticle)))) {
          if ((list_started++) != 0) G4cout << ", ";
          G4cout << theParticleTable->GetParticle(iParticle)->GetParticleName();
        }
      G4cout << G4endl;
    }
}

ListTitle()

void G4FastSimulationManager::ListTitle

(

)

const

Definition at line 283 of file G4FastSimulationManager.cc.

{
  G4cout << fFastTrack.GetEnvelope()->GetName();
  if (fFastTrack.GetEnvelope()->GetWorldPhysical()
      == G4TransportationManager::GetTransportationManager()
           ->GetNavigatorForTracking()
           ->GetWorldVolume())
    G4cout << " (mass geom.)";
  else
    G4cout << " (// geom.)";
}

Referenced by ListModels(), ListModels(), and ListModels().

operator==()

G4bool G4FastSimulationManager::operator== ( const G4FastSimulationManager & fsm ) const

inline

Definition at line 178 of file G4FastSimulationManager.hh.

{
  return this == &fsm;
}

PostStepGetFastSimulationManagerTrigger()

G4bool G4FastSimulationManager::PostStepGetFastSimulationManagerTrigger	(	const G4Track &	track,
		const G4Navigator *	a = nullptr )

Definition at line 172 of file G4FastSimulationManager.cc.

{
  // If particle type changed re-build the fApplicableModelList.
  if (fLastCrossedParticle != track.GetDefinition()) {
    fLastCrossedParticle = track.GetDefinition();
    fApplicableModelList.clear();
    // If Model List is empty, do nothing !
    if (ModelList.empty()) return false;
 
    for (auto iModel : ModelList) {
      if (iModel->IsApplicable(*(track.GetDefinition()))) {
        fApplicableModelList.push_back(iModel);
      }
    }
  }
 
  // If Applicable Model List is empty, do nothing !
  if (fApplicableModelList.empty()) return false;
 
  // -- Register current track
  fFastTrack.SetCurrentTrack(track, theNavigator);
 
  // tests if particle are on the boundary and leaving,
  // in this case do nothing !
  if (fFastTrack.OnTheBoundaryButExiting()) return false;
 
  // Loops on the ModelTrigger() methods
  for (auto iModel : fApplicableModelList)
    //---------------------------------------------------
    // Asks the ModelTrigger method if it must be trigged now.
    //---------------------------------------------------
 
    if (iModel->ModelTrigger(fFastTrack)) {
      //--------------------------------------------------
      // The model will be applied. Initializes the G4FastStep
      // with the current state of the G4Track and
      // same usefull parameters.
      // In particular it does SetLocalEnergyDeposit(0.0).
      //--------------------------------------------------
      fFastStep.Initialize(fFastTrack);
 
      // Keeps the FastSimulationModel pointer to call the
      // DoIt() method.
      fTriggedFastSimulationModel = iModel;
      return true;
    }
 
  //--------------------------------------------
  // Nobody asks to gain control, returns false
  //--------------------------------------------
  return false;
}

RemoveFastSimulationModel()

void G4FastSimulationManager::RemoveFastSimulationModel ( G4VFastSimulationModel * fsm )

inline

Definition at line 171 of file G4FastSimulationManager.hh.

{
  if (ModelList.remove(fsm) == nullptr) fInactivatedModels.remove(fsm);
  // forces the fApplicableModelList to be rebuild
  fLastCrossedParticle = nullptr;
}

---

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

• G4FastSimulationManager.hh
• G4FastSimulationManager.cc