This class is a abstract base class (ABC) doing common tasks that tracking geometries need done. More...

#include <TrackingGeometry.h>

Public Member Functions
	TrackingGeometry (const std::string &name, const Acts::GeometryContext &gctx, const std::string &gdml)

virtual	~TrackingGeometry ()=default
	Destructor.

G4VPhysicalVolume *	findDaughterByName (G4VPhysicalVolume *pvol, G4String name)

void	getAllDaughters (G4VPhysicalVolume *pvol)

void	convertG4Rot (const G4RotationMatrix *g4rot, Acts::RotationMatrix3 &rot) const

Acts::Vector3	convertG4Pos (const G4ThreeVector &g4pos) const

void	dumpGeometry (const std::string &outputDir, const Acts::GeometryContext &gctx) const

std::shared_ptr< const Acts::TrackingGeometry >	getTG () const

Acts::Transform3	getTransform (const G4VPhysicalVolume &phex, bool toTrackingFrame=false) const

Acts::Transform3	toTracker (const Acts::Transform3 &trans) const

void	makeLayerSurfacesMap ()

void	getSurfaces (std::vector< const Acts::Surface * > &surfaces) const

const Acts::Surface *	getSurface (int layerid) const

const std::string &	fieldMapFile () const
	Full path to the field map file extracted from the GDML auxiliary data.

Public Member Functions inherited from framework::ConditionsObject
	ConditionsObject (const std::string &name)
	Class constructor.

virtual	~ConditionsObject ()
	Destructor.

std::string	getName () const
	Get the name of this object.

Static Public Member Functions
static bool	compareZlocation (const G4VPhysicalVolume &pvol_a, const G4VPhysicalVolume &pvol_b)

Public Attributes
std::unordered_map< unsigned int, const Acts::Surface * >	layer_surface_map_

std::vector< std::shared_ptr< tracking::geo::DetectorElement > >	det_elements_

Protected Attributes
const Acts::GeometryContext &	gctx_

std::string	gdml_ {""}

Acts::RotationMatrix3	x_rot_

Acts::RotationMatrix3	y_rot_

std::shared_ptr< const Acts::TrackingGeometry >	t_geometry_ {nullptr}

G4VPhysicalVolume *	f_world_phys_vol_ {nullptr}

Private Attributes
std::string	field_map_file_ {""}

Detailed Description

This class is a abstract base class (ABC) doing common tasks that tracking geometries need done.

Right now, in LDMX, there are two (or three) distinct tracking geometries: The tagger tracker, the recoil tracker, and the ECal. Sometimes the tagger and recoil are combined into a single tracker geometry but the ECal is always distinct.

While this class inherits from ConditionsObject, it should never have a provider. Only the concrete derived classes should have providers.

Definition at line 33 of file TrackingGeometry.h.

Constructor & Destructor Documentation

◆ TrackingGeometry()

tracking::geo::TrackingGeometry::TrackingGeometry	(	const std::string &	name,
		const Acts::GeometryContext &	gctx,
		const std::string &	gdml )

Parameters

[in]	name	the name of this geometry condition object
[in]	gctx	the geometry context for this geometry
[in]	gdml	the path to the detector GDML to load

We are about to use the G4GDMLParser and would like to silence the output from parsing the geometry. This can only be done by redirecting G4cout and G4cerr via the G4UImanager.

The Simulator (if it is running) will already do this redirection for us and we don't want to override it, so we check if there is a simulation running by seeing if the run manager is created. If it isn't, then we redirect G4cout and G4cerr to a G4Session that just throws away all those messages.

Definition at line 33 of file TrackingGeometry.cxx.

    : framework::ConditionsObject(name), gctx_{gctx}, gdml_{gdml} {
  // Build The rotation matrix to the tracking frame
  // Rotate the sensors to be orthogonal to X
  double rotation_angle = M_PI * 0.5;
 
  // 0 0 -1
  // 0 1 0
  // 1 0 0
 
  // This rotation is needed to have the plane orthogonal to the X direction.
  //  Rotation of the surfaces
  Acts::Vector3 x_pos1(cos(rotation_angle), 0., sin(rotation_angle));
  Acts::Vector3 y_pos1(0., 1., 0.);
  Acts::Vector3 z_pos1(-sin(rotation_angle), 0., cos(rotation_angle));
 
  y_rot_.col(0) = x_pos1;
  y_rot_.col(1) = y_pos1;
  y_rot_.col(2) = z_pos1;
 
  // Rotate the sensors to put them in the proper orientation in Z
  Acts::Vector3 x_pos2(1., 0., 0.);
  Acts::Vector3 y_pos2(0., cos(rotation_angle), sin(rotation_angle));
  Acts::Vector3 z_pos2(0., -sin(rotation_angle), cos(rotation_angle));
 
  x_rot_.col(0) = x_pos2;
  x_rot_.col(1) = y_pos2;
  x_rot_.col(2) = z_pos2;
 
  std::unique_ptr<SilentG4> silence;
  if (G4RunManager::GetRunManager() == nullptr) {
    // no run manager ==> no simulation
    silence = std::make_unique<SilentG4>();
    // these lines compied from G4UImanager::SetCoutDestination
    // to avoid creating G4UImanager unnecessarily
    G4coutbuf.SetDestination(silence.get());
    G4cerrbuf.SetDestination(silence.get());
  }
 
  // Get the world volume
  G4GDMLParser parser;
 
  // Validation requires internet
  parser.Read(gdml_, false);
 
  // Extract field map filename from GDML auxiliary data and resolve full path.
  // GDML path: .../data/detectors/<det>/detector.gdml
  // Field map:  .../data/fieldmap/<filename>
  const G4GDMLAuxListType* aux_list = parser.GetAuxList();
  for (const auto& aux : *aux_list) {
    if (aux.type == "MagneticField") {
      for (const auto& sub : *aux.auxList) {
        if (sub.type == "File") {
          boost::filesystem::path fmap(std::string(sub.value));
          if (fmap.is_absolute()) {
            field_map_file_ = fmap.string();
          } else {
            boost::filesystem::path prefix = boost::filesystem::path(gdml_)
                                                 .parent_path()
                                                 .parent_path()
                                                 .parent_path();
            field_map_file_ = (prefix / "fieldmap" / fmap).string();
          }
          break;
        }
      }
      break;
    }
  }
 
  if (field_map_file_.empty()) {
    ldmx_log(warn) << "TrackingGeometry: no MagneticField/File auxiliary "
                      "entry found in '"
                   << gdml_ << "' — tracking will use a zero B-field";
  }
 
  f_world_phys_vol_ = parser.GetWorldVolume();
 
  if (silence) {
    // we created the session and silenced G4
    // undo that now incase others have use for G4
    // nullptr => standard (ldmx_log(trace) and std::cerr)
    G4coutbuf.SetDestination(nullptr);
    G4cerrbuf.SetDestination(nullptr);
  }
}

Member Function Documentation

◆ compareZlocation()

static bool tracking::geo::TrackingGeometry::compareZlocation	(	const G4VPhysicalVolume &	pvol_a,
		const G4VPhysicalVolume &	pvol_b )

inlinestatic

Definition at line 49 of file TrackingGeometry.h.

                                                                {
    return (pvol_a.GetTranslation().z() < pvol_b.GetTranslation().z());
  };

◆ convertG4Pos()

Acts::Vector3 tracking::geo::TrackingGeometry::convertG4Pos ( const G4ThreeVector & g4pos ) const

Definition at line 281 of file TrackingGeometry.cxx.

                                                                           {
  Acts::Vector3 trans{g4pos.x(), g4pos.y(), g4pos.z()};
 
  {
    ldmx_log(trace) << "g4pos::" << g4pos;
    ldmx_log(trace) << "trans" << trans;
  }
 
  return trans;
}

◆ convertG4Rot()

void tracking::geo::TrackingGeometry::convertG4Rot	(	const G4RotationMatrix *	g4rot,
		Acts::RotationMatrix3 &	rot ) const

Definition at line 257 of file TrackingGeometry.cxx.

                                                                    {
  // If the rotation is the identity then g4rot will be a null ptr.
  // So then check it and fill rot accordingly
 
  rot = Acts::RotationMatrix3::Identity();
 
  if (g4rot) {
    rot(0, 0) = g4rot->xx();
    rot(0, 1) = g4rot->xy();
    rot(0, 2) = g4rot->xz();
 
    rot(1, 0) = g4rot->yx();
    rot(1, 1) = g4rot->yy();
    rot(1, 2) = g4rot->yz();
 
    rot(2, 0) = g4rot->zx();
    rot(2, 1) = g4rot->zy();
    rot(2, 2) = g4rot->zz();
  }
}

◆ dumpGeometry()

void tracking::geo::TrackingGeometry::dumpGeometry	(	const std::string &	outputDir,
		const Acts::GeometryContext &	gctx ) const

Definition at line 180 of file TrackingGeometry.cxx.

                                                                           {
  if (!t_geometry_) return;
 
  {
    ldmx_log(trace) << __PRETTY_FUNCTION__;
 
    for (auto const& surface_id : layer_surface_map_) {
      ldmx_log(trace) << " " << surface_id.first;
      ldmx_log(trace) << " Check the surface";
      //      surfaceId.second->toStream(gctx, ldmx_log(trace));
      surface_id.second->toStream(gctx);
      ldmx_log(trace) << " GeometryID: " << surface_id.second->geometryId();
      ldmx_log(trace) << " GeometryID value: "
                      << surface_id.second->geometryId().value();
    }
  }
 
  // Should fail if already exists
  boost::filesystem::create_directory(outputDir);
 
  double output_scalor = 1.0;
  size_t output_precision = 6;
 
  Acts::ObjVisualization3D obj_vis(output_precision, output_scalor);
  Acts::ViewConfig container_view{.color = {220, 220, 220}};
  Acts::ViewConfig volume_view{.color = {220, 220, 0}};
  Acts::ViewConfig sensitive_view{.color = {0, 180, 240}};
  Acts::ViewConfig passive_view{.color = {240, 280, 0}};
  Acts::ViewConfig grid_view{.color = {220, 0, 0}};
 
  Acts::GeometryView3D::drawTrackingVolume(
      obj_vis, *(t_geometry_->highestTrackingVolume()), gctx, container_view,
      volume_view, passive_view, sensitive_view, grid_view, true, "", ".");
}

◆ fieldMapFile()

const std::string & tracking::geo::TrackingGeometry::fieldMapFile ( ) const

inline

Full path to the field map file extracted from the GDML auxiliary data.

Empty if no MagneticField auxiliary block was found.

Definition at line 85 of file TrackingGeometry.h.

85{ return field_map_file_; }

◆ findDaughterByName()

G4VPhysicalVolume * tracking::geo::TrackingGeometry::findDaughterByName	(	G4VPhysicalVolume *	pvol,
		G4String	name )

Definition at line 133 of file TrackingGeometry.cxx.

                                                                       {
  G4LogicalVolume* lvol = pvol->GetLogicalVolume();
  for (G4int i = 0; i < lvol->GetNoDaughters(); i++) {
    G4VPhysicalVolume* f_daughter_phys_vol = lvol->GetDaughter(i);
    std::string d_name = f_daughter_phys_vol->GetName();
    if (d_name.find(name) != std::string::npos) return f_daughter_phys_vol;
    // if (fDaughterPhysVol->GetName() == name) return fDaughterPhysVol;
  }
 
  return nullptr;
}

◆ getAllDaughters()

void tracking::geo::TrackingGeometry::getAllDaughters ( G4VPhysicalVolume * pvol )

Definition at line 146 of file TrackingGeometry.cxx.

                                                              {
  G4LogicalVolume* lvol = pvol->GetLogicalVolume();
 
  ldmx_log(trace) << "Checking daughters of ::" << pvol->GetName();
 
  for (G4int i = 0; i < lvol->GetNoDaughters(); i++) {
    G4VPhysicalVolume* f_daughter_phys_vol = lvol->GetDaughter(i);
 
    ldmx_log(trace) << "name::" << f_daughter_phys_vol->GetName();
    ldmx_log(trace) << "pos_::" << f_daughter_phys_vol->GetTranslation();
    ldmx_log(trace)
        << "n_dau::"
        << f_daughter_phys_vol->GetLogicalVolume()->GetNoDaughters();
    ldmx_log(trace) << "replica::" << f_daughter_phys_vol->IsReplicated();
    ldmx_log(trace) << "copyNR::" << f_daughter_phys_vol->GetCopyNo();
 
    getAllDaughters(f_daughter_phys_vol);
  }
}

◆ getSurface()

const Acts::Surface * tracking::geo::TrackingGeometry::getSurface ( int layerid ) const

inline

Definition at line 77 of file TrackingGeometry.h.

                                                   {
    return layer_surface_map_.at(layerid);
  }

◆ getSurfaces()

void tracking::geo::TrackingGeometry::getSurfaces ( std::vector< const Acts::Surface * > & surfaces ) const

Definition at line 292 of file TrackingGeometry.cxx.

                                                   {
  if (!t_geometry_)
    EXCEPTION_RAISE("BadGeometry",
                    "TrackingGeometry::getSurfaces tGeometry is null");
 
  const Acts::TrackingVolume* t_volume = t_geometry_->highestTrackingVolume();
  if (t_volume->confinedVolumes()) {
    for (auto volume : t_volume->confinedVolumes()->arrayObjects()) {
      if (volume->confinedLayers()) {
        for (const auto& layer : volume->confinedLayers()->arrayObjects()) {
          if (layer->layerType() == Acts::navigation) continue;
          for (auto surface : layer->surfaceArray()->surfaces()) {
            if (surface) {
              surfaces.push_back(surface);
 
            }  // surface exists
          }  // surfaces
        }  // layers objects
      }  // confined layers
    }  // volumes objects
  }  // confined volumes
}

◆ getTG()

std::shared_ptr< const Acts::TrackingGeometry > tracking::geo::TrackingGeometry::getTG ( ) const

inline

Definition at line 61 of file TrackingGeometry.h.

                                                          {
    return t_geometry_;
  };

◆ getTransform()

Acts::Transform3 tracking::geo::TrackingGeometry::getTransform	(	const G4VPhysicalVolume &	phex,
		bool	toTrackingFrame = false ) const

Definition at line 217 of file TrackingGeometry.cxx.

                                                                            {
  Acts::Vector3 pos(phex.GetTranslation().x(), phex.GetTranslation().y(),
                    phex.GetTranslation().z());
 
  Acts::RotationMatrix3 rotation;
  convertG4Rot(phex.GetRotation(), rotation);
 
  // rotate to the tracking frame
  if (toTrackingFrame) {
    pos(0) = phex.GetTranslation().z();
    pos(1) = phex.GetTranslation().x();
    pos(2) = phex.GetTranslation().y();
    rotation = x_rot_ * y_rot_ * rotation;
  }
 
  Acts::Translation3 translation(pos);
 
  Acts::Transform3 transform(translation * rotation);
 
  return transform;
}

◆ makeLayerSurfacesMap()

void tracking::geo::TrackingGeometry::makeLayerSurfacesMap ( )

Definition at line 316 of file TrackingGeometry.cxx.

                                            {
  std::vector<const Acts::Surface*> surfaces;
  getSurfaces(surfaces);
 
  for (auto& surface : surfaces) {
    // Layers from 1 to 14 - for the tagger
    // unsigned int layerId = (surface->geometryId().layer() / 2) ;  // Old 1
    // sensor per layer_
 
    unsigned int volume_id = surface->geometryId().volume();
    unsigned int layer_id = (surface->geometryId().layer() /
                             2);  // set layer_ ID  from 1 to 7 for the tagger
                                  // and from 1 to 6 for the recoil
    unsigned int sensor_id =
        surface->geometryId().sensitive() -
        1;  // set sensor ID from 0 to 1 for the tagger and from 0 to 9 for the
            // axial sensors in the back layers of the recoil
 
    ldmx_log(trace) << "VolumeID " << volume_id << " LayerId " << layer_id
                    << " sensorId " << sensor_id;
 
    // surface ID = vol * 1000 + ly * 100 + sensor
    unsigned int surface_id = volume_id * 1000 + layer_id * 100 + sensor_id;
 
    layer_surface_map_[surface_id] = surface;
 
  }  // surfaces loop
}

◆ toTracker()

Acts::Transform3 tracking::geo::TrackingGeometry::toTracker ( const Acts::Transform3 & trans ) const

Definition at line 242 of file TrackingGeometry.cxx.

                                       {
  Acts::Vector3 pos{trans.translation()(2), trans.translation()(0),
                    trans.translation()(1)};
 
  Acts::RotationMatrix3 rotation = trans.rotation();
  rotation = x_rot_ * y_rot_ * rotation;
 
  Acts::Translation3 translation(pos);
  Acts::Transform3 transform(translation * rotation);
 
  return transform;
}

Member Data Documentation

◆ det_elements_

std::vector<std::shared_ptr<tracking::geo::DetectorElement> > tracking::geo::TrackingGeometry::det_elements_

Definition at line 90 of file TrackingGeometry.h.

◆ f_world_phys_vol_

G4VPhysicalVolume* tracking::geo::TrackingGeometry::f_world_phys_vol_ {nullptr}

protected

Definition at line 98 of file TrackingGeometry.h.

98{nullptr};

◆ field_map_file_

std::string tracking::geo::TrackingGeometry::field_map_file_ {""}

private

Definition at line 101 of file TrackingGeometry.h.

101{""};

◆ gctx_

const Acts::GeometryContext& tracking::geo::TrackingGeometry::gctx_

protected

Definition at line 93 of file TrackingGeometry.h.

◆ gdml_

std::string tracking::geo::TrackingGeometry::gdml_ {""}

protected

Definition at line 94 of file TrackingGeometry.h.

94{""};

◆ layer_surface_map_

std::unordered_map<unsigned int, const Acts::Surface*> tracking::geo::TrackingGeometry::layer_surface_map_

Definition at line 81 of file TrackingGeometry.h.

◆ t_geometry_

std::shared_ptr<const Acts::TrackingGeometry> tracking::geo::TrackingGeometry::t_geometry_ {nullptr}

protected

Definition at line 97 of file TrackingGeometry.h.

97{nullptr};

◆ x_rot_

Acts::RotationMatrix3 tracking::geo::TrackingGeometry::x_rot_

protected

Definition at line 96 of file TrackingGeometry.h.

◆ y_rot_

Acts::RotationMatrix3 tracking::geo::TrackingGeometry::y_rot_

protected

Definition at line 96 of file TrackingGeometry.h.

The documentation for this class was generated from the following files:

Tracking/include/Tracking/geo/TrackingGeometry.h
Tracking/src/Tracking/geo/TrackingGeometry.cxx

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TrackingGeometry()

Member Function Documentation

◆ compareZlocation()

◆ convertG4Pos()

◆ convertG4Rot()

◆ dumpGeometry()

◆ fieldMapFile()

◆ findDaughterByName()

◆ getAllDaughters()

◆ getSurface()

◆ getSurfaces()

◆ getTG()

◆ getTransform()

◆ makeLayerSurfacesMap()

◆ toTracker()

Member Data Documentation

◆ det_elements_

◆ f_world_phys_vol_

◆ field_map_file_

◆ gctx_

◆ gdml_

◆ layer_surface_map_

◆ t_geometry_

◆ x_rot_

◆ y_rot_