BDSGeometryComponent.hh

/* 
Beam Delivery Simulation (BDSIM) Copyright (C) BDSIM Collaboration, 2001 - 2026.
 
This file is part of BDSIM.
 
BDSIM is free software: you can redistribute it and/or modify 
it under the terms of the GNU General Public License as published 
by the Free Software Foundation version 3 of the License.
 
BDSIM is distributed in the hope that it will be useful, but 
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with BDSIM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef BDSGEOMETRYCOMPONENT_H
#define BDSGEOMETRYCOMPONENT_H
 
#include "BDSExtent.hh"
#include "BDSSDType.hh"
 
#include "globals.hh"           // geant4 globals / types
#include "G4LogicalVolume.hh"
#include "G4Transform3D.hh"
 
#include <map>
#include <set>
#include <utility>              //for std::pair
 
class G4AssemblyVolume;
class G4UserLimits;
class G4VisAttributes;
class G4VPhysicalVolume;
class G4VSensitiveDetector;
class G4VSolid;
namespace CLHEP {
  class HepRotation;
}
typedef CLHEP::HepRotation G4RotationMatrix;
 
class BDSGeometryComponent
{
public:
  BDSGeometryComponent(G4VSolid*            containerSolidIn,
                       G4LogicalVolume*     containerLVIn,
                       const BDSExtent&     extentIn            = BDSExtent(),
                       const BDSExtent&     innerExtentIn       = BDSExtent(),
                       const G4ThreeVector& placementOffsetIn   = G4ThreeVector(0,0,0),
                       G4RotationMatrix*    placementRotationIn = nullptr);
  
  BDSGeometryComponent(G4AssemblyVolume* containerAssemblyIn,
                       const BDSExtent&     extentIn            = BDSExtent(),
                       const BDSExtent&     innerExtentIn       = BDSExtent(),
                       const G4ThreeVector& placementOffsetIn   = G4ThreeVector(0,0,0),
                       G4RotationMatrix*    placementRotationIn = nullptr);
  
  BDSGeometryComponent(const BDSGeometryComponent& component);
  BDSGeometryComponent& operator=(const BDSGeometryComponent&) = delete;
  virtual ~BDSGeometryComponent();
  G4bool ContainerIsAssembly() const {return containerIsAssembly;}
 
  virtual inline G4String  GetName()                   const {return containerLogicalVolume->GetName();}
  inline G4VSolid*         GetContainerSolid()         const {return containerSolid;}
  inline G4LogicalVolume*  GetContainerLogicalVolume() const {return containerLogicalVolume;}
  inline G4AssemblyVolume* GetContainerAssemblyVolume() const {return containerAssembly;}
  inline G4Transform3D     GetPlacementTransform()     const;
  inline G4ThreeVector     GetPlacementOffset()        const {return placementOffset;}
  inline G4RotationMatrix* GetPlacementRotation()      const {return placementRotation;}
  inline BDSExtent         GetExtent()                 const {return outerExtent;}
  inline BDSExtent         GetInnerExtent()            const {return innerExtent;}
  inline std::pair<G4double,G4double> GetExtentX()     const {return outerExtent.ExtentX();}
  inline std::pair<G4double,G4double> GetExtentY()     const {return outerExtent.ExtentY();}
  inline std::pair<G4double,G4double> GetExtentZ()     const {return outerExtent.ExtentZ();}
  inline std::pair<G4double,G4double> GetInnerExtentX() const {return innerExtent.ExtentX();}   
  inline std::pair<G4double,G4double> GetInnerExtentY() const {return innerExtent.ExtentY();}
  inline std::pair<G4double,G4double> GetInnerExtentZ() const {return innerExtent.ExtentZ();}
  virtual std::set<G4VPhysicalVolume*> GetAllPhysicalVolumes()  const {return allPhysicalVolumes;}
  virtual std::set<G4RotationMatrix*>  GetAllRotationMatrices() const {return allRotationMatrices;}
  virtual std::set<G4VisAttributes*>   GetAllVisAttributes()    const {return allVisAttributes;}
  virtual std::set<G4UserLimits*>      GetAllUserLimits()       const {return allUserLimits;}
  virtual std::set<BDSGeometryComponent*> GetAllDaughters()     const {return allDaughters;}
  virtual std::set<G4VSolid*>          GetAllSolids()           const {return allSolids;}
  
  inline void SetPlacementOffset(const G4ThreeVector& offsetIn) {placementOffset = G4ThreeVector(offsetIn);}
 
  inline void SetExtent(const BDSExtent& extIn)      {outerExtent = extIn;}
  inline void SetInnerExtent(const BDSExtent& extIn) {innerExtent = extIn;}
  
  G4ThreeVector GetExtentPositive() const {return outerExtent.ExtentPositive();}
 
  G4ThreeVector GetExtentNegative() const {return outerExtent.ExtentNegative();}
 
  void InheritExtents(BDSGeometryComponent const * const anotherComponent);
 
  void InheritExtents(BDSGeometryComponent const * const anotherComponent,
                      const G4ThreeVector& offset);
 
  void RegisterDaughter(BDSGeometryComponent* anotherComponent) {allDaughters.insert(anotherComponent);}
  
  inline void RegisterSolid(G4VSolid* solid) {allSolids.insert(solid);}
 
  void RegisterSolid(const std::set<G4VSolid*>& solids);
  
  inline void RegisterLogicalVolume(G4LogicalVolume* logicalVolume) {allLogicalVolumes.insert(logicalVolume);}
  
  void RegisterLogicalVolume(const std::set<G4LogicalVolume*>& localVolumes);
  
  void RegisterSensitiveVolume(G4LogicalVolume* sensitiveVolume,
                               BDSSDType sensitivityType);
 
  void RegisterSensitiveVolume(const std::set<G4LogicalVolume*>& sensitiveVolumes,
                               BDSSDType sensitivityType);
 
  void RegisterSensitiveVolume(const std::map<G4LogicalVolume*, BDSSDType>& sensitiveVolumes);
    
  inline void RegisterPhysicalVolume(G4VPhysicalVolume* physicalVolume) {allPhysicalVolumes.insert(physicalVolume);}
 
  void RegisterPhysicalVolume(const std::set<G4VPhysicalVolume*>& physicalVolumes);
 
  inline void RegisterRotationMatrix(G4RotationMatrix* rotationMatrix) {allRotationMatrices.insert(rotationMatrix);}
 
  void RegisterRotationMatrix(const std::set<G4RotationMatrix*>& rotationMatrices);
 
  inline void RegisterVisAttributes(G4VisAttributes* visAttribute) {allVisAttributes.insert(visAttribute);}
 
  void RegisterVisAttributes(const std::set<G4VisAttributes*>& visAttributes);
 
  inline void RegisterUserLimits(G4UserLimits* userLimit) {allUserLimits.insert(userLimit);}
 
  void RegisterUserLimits(const std::set<G4UserLimits*>& userLimits);
  
  void InheritObjects(BDSGeometryComponent* component);
 
  virtual std::set<G4LogicalVolume*> GetAllLogicalVolumes() const;
 
  virtual std::set<G4LogicalVolume*> GetAllBiasingVolumes() const;
  
  virtual std::map<G4LogicalVolume*, BDSSDType> GetAllSensitiveVolumes() const;
 
  inline void MakeAllVolumesSensitive(BDSSDType stype = BDSSDType::energydep) {RegisterSensitiveVolume(GetAllLogicalVolumes(), stype);}
 
  virtual void AttachSensitiveDetectors();
 
  virtual void ExcludeLogicalVolumeFromBiasing(G4LogicalVolume* lv);
 
  void StripOuterAndMakeAssemblyVolume();
 
  static void AttachUserLimitsToAssembly(G4AssemblyVolume* av,
                                         G4UserLimits* ul);
 
protected:
  G4bool           containerIsAssembly; 
  G4VSolid*        containerSolid;
  G4LogicalVolume* containerLogicalVolume;
  G4AssemblyVolume* containerAssembly;
  BDSExtent        outerExtent;
  BDSExtent        innerExtent;
  
  std::set<BDSGeometryComponent*> allDaughters;
  
  std::set<G4VSolid*> allSolids;
  
  std::set<G4LogicalVolume*> allLogicalVolumes;
  // we have to keep a registry of all logical volumes to be able to associate
  // information with them at construction time - for example S position - that
  // can't be stored in the Logical Volume class itself without modifying geant
 
  std::map<G4LogicalVolume*, BDSSDType> sensitivity;
 
  G4bool overrideSensitivity;
 
  std::set<G4VPhysicalVolume*> allPhysicalVolumes;
 
  std::set<G4RotationMatrix*> allRotationMatrices;
 
  std::set<G4VisAttributes*> allVisAttributes;
 
  std::set<G4UserLimits*>    allUserLimits;
 
  G4ThreeVector                 placementOffset;
 
  G4RotationMatrix*             placementRotation;
 
  std::set<G4LogicalVolume*>* lvsExcludedFromBiasing;
};
 
inline G4Transform3D BDSGeometryComponent::GetPlacementTransform() const
{
  if (!placementRotation)
    {return G4Transform3D(G4RotationMatrix(), placementOffset);}
  else
    {return G4Transform3D(*placementRotation, placementOffset);}
}
 
#endif