TG4GeometryManager.h

Go to the documentation of this file.

#ifndef TG4_GEOMETRY_MANAGER_H
#define TG4_GEOMETRY_MANAGER_H
 
//------------------------------------------------
// The Geant4 Virtual Monte Carlo package
// Copyright (C) 2007 - 2015 Ivana Hrivnacova
// All rights reserved.
//
// For the licensing terms see geant4_vmc/LICENSE.
// Contact: root-vmc@cern.ch
//-------------------------------------------------
 
 
#include "TG4DetConstructionMessenger.h"
#include "TG4FieldParameters.h"
#include "TG4Globals.h"
#include "TG4Verbose.h"
 
#include <vector>
 
class TG4Field;
class TG4GeometryServices;
class TG4OpGeometryManager;
class TG4ModelConfigurationManager;
class TG4BiasingManager;
class TG4G3CutVector;
class TG4G3ControlVector;
class TG4VUserRegionConstruction;
class TG4VUserPostDetConstruction;
class TG4RadiatorDescription;
class TG4RootDetectorConstruction;
 
class G4LogicalVolume;
class G4EquationOfMotion;
class G4MagIntegratorStepper;
 
class TVirtualMCGeometry;
class TVirtualMagField;
 
 
class TG4GeometryManager : public TG4Verbose
{
 public:
  TG4GeometryManager(const TString& userGeometry);
  virtual ~TG4GeometryManager();
 
  // static access method
  static TG4GeometryManager* Instance();
 
  TVirtualMCGeometry* GetMCGeometry() const;
  TG4OpGeometryManager* GetOpManager() const;
  TG4ModelConfigurationManager* GetFastModelsManager() const;
  TG4ModelConfigurationManager* GetEmModelsManager() const;
 
  // functions for building geometry
  void ConstructGeometry();
  void ConstructSDandField();
  void FinishGeometry();
  void UpdateField();
  void CreateFieldParameters(const G4String& fieldVolName);
  TG4RadiatorDescription* CreateRadiator(const G4String& volName);
  void SetUserLimits(
    const TG4G3CutVector& cuts, const TG4G3ControlVector& controls) const;
  void SetIsLocalField(G4bool isLocalField);
  void SetIsZeroField(G4bool isZeroField);
  void SetIsUserMaxStep(G4bool isUserMaxStep);
  void SetIsMaxStepInLowDensityMaterials(G4bool isMaxStep);
 
  // set Root detector construction
  void SetRootDetectorConstruction(
    TG4RootDetectorConstruction* rootDetectorConstruction);
  // set user region construction
  void SetUserRegionConstruction(
    TG4VUserRegionConstruction* userRegionConstruction);
  void SetUserPostDetConstruction(
    TG4VUserPostDetConstruction* userPostDetConstruction);
  void SetUserEquationOfMotion(
    G4EquationOfMotion* equation, G4String volumeName = "");
  void SetUserStepper(
    G4MagIntegratorStepper* stepper, G4String volumeName = "");
 
  void SetLimitDensity(G4double density);
  void SetMaxStepInLowDensityMaterials(G4double maxStep);
 
  // printing
  void PrintFieldStatistics() const;
 
  // get methods
  const std::vector<TG4RadiatorDescription*>& GetRadiators() const;
 
 private:
  TG4GeometryManager(const TG4GeometryManager& right);
  TG4GeometryManager& operator=(const TG4GeometryManager& right);
 
  // methods
  void CreateMCGeometry();
  void ConstructG4GeometryViaVMC();
  void ConstructG4GeometryViaVGM();
  void ConstructG4Geometry();
  void FillMediumMapFromG3();
  void FillMediumMapFromG4();
  void FillMediumMapFromRoot();
  void FillMediumMap();
  TG4FieldParameters* GetOrCreateFieldParameters(const G4String& volumeName);
  void CreateField(TVirtualMagField* magField,
    TG4FieldParameters* fieldParameters, G4LogicalVolume* lv);
  void ConstructGlobalField();
  void ConstructZeroFields();
  void ConstructLocalFields();
 
  // static data members
  static TG4GeometryManager* fgInstance; 
 
  static const G4double fgDefaultLimitDensity;
 
  static const G4double fgDefaultMaxStep;
 
  // data members
  TG4DetConstructionMessenger fMessenger; 
  TG4GeometryServices* fGeometryServices; 
  TVirtualMCGeometry* fMCGeometry;        
  TG4RootDetectorConstruction* fRootDetectorConstruction; 
  TG4OpGeometryManager* fOpManager;       
 
  TG4ModelConfigurationManager* fFastModelsManager;
 
  TG4ModelConfigurationManager* fEmModelsManager;
 
  TG4BiasingManager* fBiasingManager;
 
  G4String fUserGeometry;
 
  std::vector<TG4FieldParameters*> fFieldParameters;
 
  static G4ThreadLocal std::vector<TG4Field*>* fgFields;
 
  std::vector<TG4RadiatorDescription*> fRadiators;
 
  TG4VUserRegionConstruction* fUserRegionConstruction;
 
  TG4VUserPostDetConstruction* fUserPostDetConstruction;
 
  G4bool fIsLocalField;
 
  G4bool fIsZeroField;
 
  G4bool fIsCachedMagneticField;
 
  G4bool fIsUserMaxStep;
 
  G4bool fIsMaxStepInLowDensityMaterials;
 
  G4double fLimitDensity;
 
  G4double fMaxStepInLowDensityMaterials;
};
 
// inline methods
 
inline TG4GeometryManager* TG4GeometryManager::Instance()
{
  return fgInstance;
}
 
inline TG4OpGeometryManager* TG4GeometryManager::GetOpManager() const
{
  return fOpManager;
}
 
inline TG4ModelConfigurationManager*
TG4GeometryManager::GetFastModelsManager() const
{
  return fFastModelsManager;
}
 
inline TG4ModelConfigurationManager*
TG4GeometryManager::GetEmModelsManager() const
{
  return fEmModelsManager;
}
 
inline void TG4GeometryManager::SetRootDetectorConstruction(
  TG4RootDetectorConstruction* rootDetectorConstruction)
{
  fRootDetectorConstruction = rootDetectorConstruction;
}
 
inline void TG4GeometryManager::SetLimitDensity(G4double density)
{
  fLimitDensity = density;
}
 
inline void TG4GeometryManager::SetMaxStepInLowDensityMaterials(
  G4double maxStep)
{
  fMaxStepInLowDensityMaterials = maxStep;
}
 
inline const std::vector<TG4RadiatorDescription*>&
TG4GeometryManager::GetRadiators() const
{
  return fRadiators;
}
 
#endif // TG4_GEOMETRY_MANAGER_H