VecGeomG4Map.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef O2_SIMSETUP_VECGEOMG4MAP_H_
#define O2_SIMSETUP_VECGEOMG4MAP_H_
 
#include <VecGeom/volumes/PlacedVolume.h>
 
#include <cstddef>
#include <cstdint>
#include <unordered_map>
#include <vector>
 
class G4VPhysicalVolume;
class TG4RootDetectorConstruction;
class TGeoNode;
 
namespace o2::simsetup
{
 
class VecGeomG4Map
{
 public:
  void build(TG4RootDetectorConstruction const& dc, bool flattenAssemblies);
 
  G4VPhysicalVolume* const* chain(int vgId, unsigned& size) const
  {
    if (static_cast<std::size_t>(vgId) >= mChainSize.size()) {
      size = 0;
      return nullptr;
    }
    size = mChainSize[vgId];
    return mChain.data() + mChainBegin[vgId];
  }
 
  vecgeom::VPlacedVolume const* toVecGeom(int g4Id) const { return mG4ToVG[g4Id]; }
 
  static vecgeom::VPlacedVolume const* ambiguous()
  {
    return reinterpret_cast<vecgeom::VPlacedVolume const*>(std::uintptr_t{1});
  }
 
  std::vector<vecgeom::VPlacedVolume const*> const& candidates(int g4Id) const
  {
    static const std::vector<vecgeom::VPlacedVolume const*> empty;
    const auto it = mAmbiguous.find(g4Id);
    return it == mAmbiguous.end() ? empty : it->second;
  }
 
  bool chainMatches(vecgeom::VPlacedVolume const* pv, G4VPhysicalVolume* const* first, std::size_t n) const
  {
    unsigned size = 0;
    auto* const* own = chain(pv->id(), size);
    if (size != n) {
      return false;
    }
    for (std::size_t i = 0; i < n; ++i) {
      if (own[i] != first[i]) {
        return false;
      }
    }
    return true;
  }
 
  unsigned chainSize(int vgId) const
  {
    return static_cast<std::size_t>(vgId) < mChainSize.size() ? mChainSize[vgId] : 0;
  }
 
  vecgeom::VPlacedVolume const* world() const { return mWorld; }
 
  std::size_t ambiguousCount() const { return mAmbiguous.size(); }
 
  std::size_t size() const { return mPairs; }
 
 private:
  void registerPair(vecgeom::VPlacedVolume const* parent, vecgeom::VPlacedVolume const* pv,
                    std::vector<TGeoNode*> const& nodes, TG4RootDetectorConstruction const& dc);
 
  std::vector<unsigned> mChainBegin;
  std::vector<unsigned> mChainSize;
  std::vector<G4VPhysicalVolume*> mChain;
  std::vector<vecgeom::VPlacedVolume const*> mG4ToVG;
  std::unordered_map<int, std::vector<vecgeom::VPlacedVolume const*>> mAmbiguous;
  vecgeom::VPlacedVolume const* mWorld = nullptr;
  std::size_t mPairs = 0;
  std::size_t mMispaired = 0;
};
 
} // namespace o2::simsetup
 
#endif