RMGNavigationTools.hh

// Copyright (C) 2022 Luigi Pertoldi <https://orcid.org/0000-0002-0467-2571>
//
// This program is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option) any
// later version.
//
// This program 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 Lesser General Public License for more
// details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
#ifndef _RMG_NAVIGATION_TOOLS_HH_
#define _RMG_NAVIGATION_TOOLS_HH_
 
#include <regex>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "G4AffineTransform.hh"
#include "G4LogicalVolume.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4VPhysicalVolume.hh"
#include "G4VSolid.hh"
 
// TODO: write function that locates points in global coordinates by using an
// auxiliary G4Navigator. The G4Navigator instance must be unique and its
// access thread-safe.
 
namespace RMGNavigationTools {

  G4LogicalVolume* FindLogicalVolume(std::string name);
 
  std::set<G4VPhysicalVolume*> FindPhysicalVolume(std::string name, std::string copy_nr = ".*");
  G4VPhysicalVolume* FindDirectMother(const G4VPhysicalVolume* volume);
  std::set<G4VPhysicalVolume*> FindDirectMothers(const G4VPhysicalVolume* volume);

  void PrintListOfLogicalVolumes();
  void PrintListOfPhysicalVolumes();
 
  struct VolumeTreeEntry {
      VolumeTreeEntry() = delete;
      VolumeTreeEntry(const VolumeTreeEntry&) = default;
      VolumeTreeEntry& operator=(const VolumeTreeEntry&) = default;
      VolumeTreeEntry(const G4VPhysicalVolume* pv) { physvol = pv; }
 
      const G4VPhysicalVolume* physvol;
 
      G4ThreeVector vol_global_translation; // origin
      G4RotationMatrix vol_global_rotation; // identity
      std::vector<G4RotationMatrix> partial_rotations;
      std::vector<G4ThreeVector> partial_translations;
  };

  std::vector<VolumeTreeEntry> FindGlobalPositions(const G4VPhysicalVolume* pv);

  VolumeTreeEntry FindGlobalPosition(const G4VPhysicalVolume* pv);

  struct VolumeCacheEntry {
      G4AffineTransform inverse_transform;
      const G4VSolid* solid{};
      size_t num_daughters{};
      std::vector<G4AffineTransform> daughter_transforms;
      std::vector<const G4VSolid*> daughter_solids;
  };

  // Cache for volume data, keyed by physical volume pointer
  extern G4ThreadLocal std::unordered_map<const G4VPhysicalVolume*, VolumeCacheEntry> volume_cache;

  std::unordered_map<const G4VPhysicalVolume*, VolumeCacheEntry>::iterator GetVolumeCacheEntry(
      const G4VPhysicalVolume* pv
  );
 
} // namespace RMGNavigationTools
 
#endif
 
// vim: tabstop=2 shiftwidth=2 expandtab