Geant4Converters.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Geant4Converters.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2022 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Common.hpp"
#include "Acts/Surfaces/Surface.hpp"

#include <array>
#include <memory>
#include <tuple>

#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4Transform3D.hh"

class G4Box;
class G4Material;
class G4Trd;
class G4Trap;
class G4Tubs;
class G4VSolid;
class G4VPhysicalVolume;

namespace Acts {

struct Geant4AlgebraConverter {
  // A potential scalar between Geant4 and ACTS
  ActsScalar scale = 1.;

  Transform3 transform(const G4ThreeVector& g4Trans);

  Transform3 transform(const G4RotationMatrix& g4Rot,
                       const G4ThreeVector& g4Trans);

  Transform3 transform(const G4Transform3D& g4Trf);

  Transform3 transform(const G4VPhysicalVolume& g4PhysVol);
};

class AnnulusBounds;
class CylinderBounds;
class RadialBounds;
class RectangleBounds;
class TrapezoidBounds;
class PlanarBounds;
class LineBounds;

// The following set of converters convert a Geant4 volume shape
// to an ACTS surface bounds object, this is for converting the volume
// based geometry into a surfaced based one.
//
// The obviously smallest expansion/extrusion is condensed to the epsilon
// thin surface.
struct Geant4ShapeConverter {
  ActsScalar scale = 1.;
  bool keepAxisOrder = false;

  std::tuple<std::shared_ptr<CylinderBounds>, ActsScalar> cylinderBounds(
      const G4Tubs& g4Tubs);

  std::tuple<std::shared_ptr<RadialBounds>, ActsScalar> radialBounds(
      const G4Tubs& g4Tubs);

  std::shared_ptr<LineBounds> lineBounds(const G4Tubs& g4Tubs);

  std::tuple<std::shared_ptr<RectangleBounds>, std::array<int, 2u>, ActsScalar>
  rectangleBounds(const G4Box& g4Box);

  std::tuple<std::shared_ptr<TrapezoidBounds>, std::array<int, 2u>, ActsScalar>
  trapezoidBounds(const G4Trd& g4Trd);

  std::tuple<std::shared_ptr<PlanarBounds>, std::array<int, 2u>, ActsScalar>
  planarBounds(const G4VSolid& g4Solid);
};

struct Geant4PhysicalVolumeConverter {
  Surface::SurfaceType forcedType = Surface::SurfaceType::Other;

  std::shared_ptr<Surface> surface(const G4VPhysicalVolume& g4PhysVol,
                                   const Transform3& toGlobal,
                                   bool convertMaterial = false,
                                   ActsScalar compressed = 0.);
};

class Material;
class HomogeneousSurfaceMaterial;
class HomogeneousVolumeMaterial;

struct Geant4MaterialConverter {
  Material material(const G4Material& g4Material, ActsScalar compression = 1);

  std::shared_ptr<HomogeneousSurfaceMaterial> surfaceMaterial(
      const G4Material& g4Material, ActsScalar original, ActsScalar compressed);
};

class CylinderVolumeBounds;

struct Geant4VolumeConverter {
  std::shared_ptr<CylinderVolumeBounds> cylinderBounds(const G4Tubs& g4Tubs);
};

}  // namespace Acts