#include <PndLmdGeometryHelper.h>

Public Member Functions
virtual	~PndLmdGeometryHelper ()

	PndLmdGeometryHelper (const PndLmdGeometryHelper &)=delete

void	operator= (const PndLmdGeometryHelper &)=delete

const PndLmdHitLocationInfo &	getHitLocationInfo (const std::string &volume_path)

const PndLmdHitLocationInfo &	getHitLocationInfo (int sensor_id)

std::vector< int >	getAvailableOverlapIDs ()

int	getOverlapIdFromSensorIDs (int id1, int id2)

int	getSensorOneFromOverlapID (int overlapID)

int	getSensorTwoFromOverlapID (int overlapID)

TVector3	transformPndGlobalToLmdLocal (const TVector3 &vec)

TVector3	transformPndGlobalToSensor (const TVector3 &vec, int sensorId)

bool	isOverlappingArea (const int id1, const int id2)

const std::string	getPath (unsigned char...)

const TGeoHMatrix	getMatrixPndGlobalToSensor (const int sensorId)

const TGeoHMatrix	getMatrixSensorToPndGlobal (const int sensorId)

const TGeoHMatrix	getMatrixPndGlobalToLmdLocal ()

const TGeoHMatrix	getMatrixLmdLocalToPndGlobal ()

std::vector< std::string >	getAllAlignPaths (bool sensors=true, bool modules=false, bool planes=false, bool halfs=false, bool detector=false)

std::vector< PndLmdOverlapInfo >	getOverlapInfos (int iHalf=-1, int iPlane=-1, int iModule=-1)

std::vector< std::string >	getAllAlignableVolumePaths () const

Static Public Member Functions
static PndLmdGeometryHelper &	getInstance ()

Private Member Functions
	PndLmdGeometryHelper (const std::string &geo_params_config_file_url="")

const PndLmdHitLocationInfo &	createMappingEntry (int sensor_id)

const PndLmdHitLocationInfo &	createMappingEntry (const std::string &volume_path)

PndLmdHitLocationInfo	translateVolumePathToHitLocationInfo (const std::string &volume_path) const

Private Attributes
boost::property_tree::ptree	geometry_properties

std::vector< std::pair < std::string, bool > >	navigation_paths

std::map< std::string, PndLmdHitLocationInfo >	volume_path_to_hit_info_mapping

std::map< int, PndLmdHitLocationInfo >	sensor_id_to_hit_info_mapping

std::string	lmd_root_path

TGeoManager *	fGeoManager

std::mutex	accessMutex

Detailed Description

Definition at line 67 of file PndLmdGeometryHelper.h.

Constructor & Destructor Documentation

PndLmdGeometryHelper::PndLmdGeometryHelper ( const std::string & geo_params_config_file_url = "" )

inlineprivate

Definition at line 80 of file PndLmdGeometryHelper.h.

References exit(), and TString.

                                                                                :
                         fGeoManager(gGeoManager) {
                 std::string file_url(geo_params_config_file_url);
                 if (geo_params_config_file_url == "") {
                         file_url = std::getenv("VMCWORKDIR");
                         file_url += "/macro/detectors/lmd/lmd-geo-params.json";
                 }
                 // load parameters
                 try {
                         read_json(file_url, geometry_properties);
                 }
                 catch (std::exception &e) {
                         std::cerr << "PndLmdGeometryHelper::PndLmdGeometryHelper(): ERROR! Parameter file not present!\n";
                         std::cerr << "Was looking for file: " << file_url << "\n";
                         exit(1);
                 }
 
                 if (!fGeoManager) {
                         std::cerr
                             << "ERROR! gGeoManager is unitialized! Please populate the gGeoManager or initialize a run!\n";
                         exit(2);
                 }
 
                 auto pt_general = geometry_properties.get_child("general");
                 for (boost::property_tree::ptree::value_type &nav_path : pt_general.get_child("navigation_paths")) {
                         navigation_paths.push_back(
                             std::make_pair(nav_path.second.get<std::string>("name"),
                                 nav_path.second.get<bool>("is_alignable")));
                 }
 
                 TString actPath = fGeoManager->GetPath();
                 std::stringstream lmd_path;
                 fGeoManager->CdTop();
                 lmd_path << fGeoManager->GetPath() << "/" << navigation_paths[0].first << "_0";
                 lmd_root_path = lmd_path.str();
                 if (actPath != "" && actPath != " ") fGeoManager->cd(actPath);
 
         }

PndLmdGeometryHelper::~PndLmdGeometryHelper ( )

virtual

Definition at line 15 of file PndLmdGeometryHelper.cxx.

15 {

16 }

PndLmdGeometryHelper::PndLmdGeometryHelper ( const PndLmdGeometryHelper & )

delete

Member Function Documentation

const PndLmdHitLocationInfo & PndLmdGeometryHelper::createMappingEntry ( int sensor_id )

private

Definition at line 144 of file PndLmdGeometryHelper.cxx.

References PndGeoHandling::GetPath(), PndGeoHandling::Instance(), sensor_id_to_hit_info_mapping, translateVolumePathToHitLocationInfo(), and volume_path_to_hit_info_mapping.

Referenced by getHitLocationInfo().

                                                                                    {
         PndGeoHandling *geo_handling = PndGeoHandling::Instance();
 
         std::string vol_path(geo_handling->GetPath(sensor_id).Data());
 
         PndLmdHitLocationInfo hit_loc_info = translateVolumePathToHitLocationInfo(vol_path);
         volume_path_to_hit_info_mapping[vol_path] = hit_loc_info;
         sensor_id_to_hit_info_mapping[sensor_id] = hit_loc_info;
 
         return sensor_id_to_hit_info_mapping[sensor_id];
 }

const PndLmdHitLocationInfo & PndLmdGeometryHelper::createMappingEntry ( const std::string & volume_path )

private

Definition at line 156 of file PndLmdGeometryHelper.cxx.

References PndGeoHandling::GetShortID(), PndGeoHandling::Instance(), sensor_id_to_hit_info_mapping, translateVolumePathToHitLocationInfo(), and volume_path_to_hit_info_mapping.

                                                                                                   {
         PndGeoHandling *geo_handling = PndGeoHandling::Instance();
 
         int sensor_id(geo_handling->GetShortID(volume_path.c_str()));
 
         PndLmdHitLocationInfo hit_loc_info = translateVolumePathToHitLocationInfo(volume_path);
         volume_path_to_hit_info_mapping[volume_path] = hit_loc_info;
         sensor_id_to_hit_info_mapping[sensor_id] = hit_loc_info;
 
         return volume_path_to_hit_info_mapping[volume_path];
 }

std::vector< std::string > PndLmdGeometryHelper::getAllAlignableVolumePaths ( ) const

Definition at line 420 of file PndLmdGeometryHelper.cxx.

References fGeoManager, i, and navigation_paths.

Referenced by getAllAlignPaths().

                                                                             {
         TGeoNode* node = fGeoManager->GetTopNode();
 
         std::vector<std::string> alignable_volumes;
 
         if (fGeoManager->GetNAlignable() > 0) {
                 for (int i = 0; i < fGeoManager->GetNAlignable(); ++i) {
                         TGeoPNEntry* entry = fGeoManager->GetAlignableEntry(i);
                         if (entry) alignable_volumes.push_back(entry->GetPath());
                 }
         }
         else {
                 std::vector<std::pair<TGeoNode*, std::string> > current_paths;
                 current_paths.push_back(std::make_pair(node, fGeoManager->GetPath()));
 
                 while (current_paths.size() > 0) {
                         auto temp_current_paths = current_paths;
                         current_paths.clear();
                         for (auto const curpath : temp_current_paths) {
                                 std::stringstream reg_exp;
                                 for (auto nav_path : navigation_paths) {
                                         reg_exp << "/" + nav_path.first << "_(\\d+)";
                                         std::smatch match;
                                         if (std::regex_search(curpath.second, match, std::regex(reg_exp.str() + "/*$"))) {
                                                 if (nav_path.second) alignable_volumes.push_back(curpath.second);
                                                 break;
                                         }
                                 }
                                 for (int i = 0; i < curpath.first->GetNdaughters(); ++i) {
                                         node = curpath.first->GetDaughter(i);
                                         std::stringstream full_path;
                                         full_path << curpath.second << "/" << node->GetName();
                                         current_paths.push_back(std::make_pair(node, full_path.str()));
                                 }
                         }
                 }
         }
         return alignable_volumes;
 }

std::vector< std::string > PndLmdGeometryHelper::getAllAlignPaths	(	bool	sensors = `true`,
		bool	modules = `false`,
		bool	planes = `false`,
		bool	halfs = `false`,
		bool	detector = `false`
	)

Definition at line 361 of file PndLmdGeometryHelper.cxx.

References getAllAlignableVolumePaths(), navigation_paths, and s.

Referenced by createPndLmdMisalignmentMatrices().

                                {
 
         std::vector<std::string> result;
         auto all_volume_paths = getAllAlignableVolumePaths();
 
         std::vector<std::string> filter_strings;
 
         if (detector) filter_strings.push_back(navigation_paths[0].first);
         if (halfs) filter_strings.push_back(navigation_paths[1].first);
         if (planes) filter_strings.push_back(navigation_paths[2].first);
         if (modules) filter_strings.push_back(navigation_paths[3].first);
         if (sensors) filter_strings.push_back(navigation_paths[4].first);
 
         std::cout << "total number of alignable volumes: " << all_volume_paths.size() << std::endl;
 
         for (auto filter_string : filter_strings) {
                 auto found(all_volume_paths.begin());
                 while (found != all_volume_paths.end()) {
                         found = std::find_if(found, all_volume_paths.end(), [&](const std::string& s) {
                                 std::stringstream reg_exp;
                                 reg_exp<<"^.*/" << filter_string << "_(\\d+)/*$";
                                 std::smatch match;
                                 return std::regex_search(s, match, std::regex(reg_exp.str()));
                         });
 
                         if (found != all_volume_paths.end()) {
                                 result.push_back(*found);
                                 ++found;
                         }
                 }
         }
 
         // just for fun and so it's easier to examine it
         std::sort(result.begin(), result.end());
 
         return result;
 }

std::vector< int > PndLmdGeometryHelper::getAvailableOverlapIDs ( )

Definition at line 188 of file PndLmdGeometryHelper.cxx.

References getOverlapInfos().

Referenced by PndLmdAlignQA::calculateOverlapingAreas(), PndLmdAlignQA::checkForMatrixFiles(), and PndLmdAlignManager::init().

                                                             {
         std::vector<int> result;
         auto infos = getOverlapInfos();
         for (auto &info : infos) {
                 result.push_back(info.overlapID);
         }
         return result;
 }

const PndLmdHitLocationInfo & PndLmdGeometryHelper::getHitLocationInfo ( const std::string & volume_path )

Definition at line 168 of file PndLmdGeometryHelper.cxx.

References createMappingEntry(), and volume_path_to_hit_info_mapping.

Referenced by PndLmdDigiQTask::Exec(), PndLmdPairFinderTask::Exec(), getOverlapIdFromSensorIDs(), getOverlapInfos(), and PndLmdPairFinderTask::getStatistics().

                                                                                                   {
         auto const &result = volume_path_to_hit_info_mapping.find(volume_path);
         if (result != volume_path_to_hit_info_mapping.end()) {
                 return result->second;
         }
         else {
                 return createMappingEntry(volume_path);
         }
 }

const PndLmdHitLocationInfo & PndLmdGeometryHelper::getHitLocationInfo ( int sensor_id )

Definition at line 178 of file PndLmdGeometryHelper.cxx.

References createMappingEntry(), and sensor_id_to_hit_info_mapping.

                                                                                    {
         auto const &result = sensor_id_to_hit_info_mapping.find(sensor_id);
         if (result != sensor_id_to_hit_info_mapping.end()) {
                 return result->second;
         }
         else {
                 return createMappingEntry(sensor_id);
         }
 }

static PndLmdGeometryHelper& PndLmdGeometryHelper::getInstance ( )

inlinestatic

Definition at line 125 of file PndLmdGeometryHelper.h.

Referenced by createPndLmdMisalignmentMatrices(), PndLmdTrkQTask::Exec(), PndLmdPairFinderTask::Init(), PndLmdAlignQA::init(), PndLmdAlignManager::init(), PndLmdTrackFinderTask::SortHitsByDet2(), PndLmdTrackFinderCATask::SortHitsByDetSimple2(), testAlignMatrices(), PndLmdSensorAligner::transformToLmdLocal(), and PndLmdSensorAligner::transformToSensorOne().

                                                    {
                 static PndLmdGeometryHelper instance;
                 return instance;
         }

const TGeoHMatrix PndLmdGeometryHelper::getMatrixLmdLocalToPndGlobal ( )

Definition at line 353 of file PndLmdGeometryHelper.cxx.

References getMatrixPndGlobalToLmdLocal().

                                                                      {
         return getMatrixPndGlobalToLmdLocal().Inverse();
 }

const TGeoHMatrix PndLmdGeometryHelper::getMatrixPndGlobalToLmdLocal ( )

Definition at line 338 of file PndLmdGeometryHelper.cxx.

References accessMutex, fGeoManager, lmd_root_path, and TString.

Referenced by getMatrixLmdLocalToPndGlobal(), transformPndGlobalToLmdLocal(), and PndLmdSensorAligner::transformToLmdLocal().

                                                                      {
 
         // to ensure only one thred at a time can do this
                 std::lock_guard<std::mutex> lock(accessMutex);
 
         TString actPath = fGeoManager->GetPath();
 
         fGeoManager->cd(lmd_root_path.c_str());
         TGeoHMatrix *matrix = (TGeoHMatrix *) (fGeoManager->GetCurrentMatrix());
 
         if (actPath != "" && actPath != " ") fGeoManager->cd(actPath);
 
         return *matrix;
 }

const TGeoHMatrix PndLmdGeometryHelper::getMatrixPndGlobalToSensor ( const int sensorId )

Definition at line 222 of file PndLmdGeometryHelper.cxx.

References accessMutex, fGeoManager, PndGeoHandling::GetPath(), PndGeoHandling::Instance(), and TString.

Referenced by getMatrixSensorToPndGlobal(), PndLmdAlignQA::getMatrixSensorToSensor(), getMatrixSensorToSensor(), transformPndGlobalToSensor(), and PndLmdSensorAligner::transformToSensorOne().

                                                                                      {
 
         // to ensure only one thred at a time can do this
         std::lock_guard<std::mutex> lock(accessMutex);
 
         PndGeoHandling *geo_handling = PndGeoHandling::Instance();
         std::string vol_path(geo_handling->GetPath(int(sensorId)));
 
         TString actPath = fGeoManager->GetPath();
         // go to active part of sensor
         fGeoManager->cd(vol_path.c_str());
         // we want the matrix of the whole sensor. so just cd up once
         fGeoManager->CdUp();
 
         TGeoHMatrix matrix = *fGeoManager->GetCurrentMatrix();
         if (actPath != "" && actPath != " ") fGeoManager->cd(actPath);
 
         return matrix;
 }

const TGeoHMatrix PndLmdGeometryHelper::getMatrixSensorToPndGlobal ( const int sensorId )

Definition at line 242 of file PndLmdGeometryHelper.cxx.

References getMatrixPndGlobalToSensor().

                                                                                      {
         return getMatrixPndGlobalToSensor(sensorId).Inverse();
 }

int PndLmdGeometryHelper::getOverlapIdFromSensorIDs	(	int	id1,
		int	id2
	)

Definition at line 246 of file PndLmdGeometryHelper.cxx.

References getHitLocationInfo().

Referenced by PndLmdPairFinderTask::Exec(), getOverlapInfos(), and isOverlappingArea().

                                                                     {
 
         int fhalf, fplane, fmodule, fside, fsensor;
         int bhalf, bplane, bmodule, bside, bsensor;
 
         auto const &infoOne = getHitLocationInfo(id1);
         auto const &infoTwo = getHitLocationInfo(id2);
 
         int smalloverlap = -1;
 
         fhalf = infoOne.detector_half;
         bhalf = infoTwo.detector_half;
 
         fside = infoOne.module_side;
         bside = infoTwo.module_side;
 
         fplane = infoOne.plane;
         bplane = infoTwo.plane;
 
         fmodule = infoOne.module;
         bmodule = infoTwo.module;
 
         fsensor = infoOne.module_sensor_id;
         bsensor = infoTwo.module_sensor_id;
 
         if (bhalf != fhalf) {
                 return -1;
         }
 
         if (fside == bside) {
                 return -1;
         }
 
         if (bplane != fplane) {
                 return -1;
         }
         if (bmodule != fmodule) {
                 return -1;
         }
 
         // check if the ids are sorted
         if(fside > bside){
                 cout << "PndLmdGeometryHelper::WARNING: pair with ids (" << id1 << ", " << id2 << ") is not sorted.\n";
                 cout << "this shouldn't happen here anymore!\n";
 
                 // the last checks only involve fsensor and bsensor
                 std::swap(fsensor, bsensor);
         }
 
         // 0to5
         if (fsensor == 0 && bsensor == 5) {
                 smalloverlap = 0;
         }
         // 3to8
         else if (fsensor == 3 && bsensor == 8) {
                 smalloverlap = 1;
         }
         // 4to9
         else if (fsensor == 4 && bsensor == 9) {
                 smalloverlap = 2;
         }
         // 3to6
         else if (fsensor == 3 && bsensor == 6) {
                 smalloverlap = 3;
         }
         // 1to8
         else if (fsensor == 1 && bsensor == 8) {
                 smalloverlap = 4;
         }
         // 2to8
         else if (fsensor == 2 && bsensor == 8) {
                 smalloverlap = 5;
         }
         // 2to9
         else if (fsensor == 2 && bsensor == 9) {
                 smalloverlap = 6;
         }
         // 3to7
         else if (fsensor == 3 && bsensor == 7) {
                 smalloverlap = 7;
         }
         // 4to7
         else if (fsensor == 4 && bsensor == 7) {
                 smalloverlap = 8;
         }
         // don't overlap, return -1
         else {
                 return -1;
         }
         return 1000 * fhalf + 100 * fplane + 10 * fmodule + smalloverlap;
 }

std::vector< PndLmdOverlapInfo > PndLmdGeometryHelper::getOverlapInfos	(	int	iHalf = `-1`,
		int	iPlane = `-1`,
		int	iModule = `-1`
	)

Definition at line 78 of file PndLmdGeometryHelper.cxx.

References all, PndLmdHitLocationInfo::detector_half, exit(), getHitLocationInfo(), getOverlapIdFromSensorIDs(), PndGeoHandling::GetPath(), gGeoManager, PndLmdOverlapInfo::hit1, PndLmdOverlapInfo::hit2, PndLmdOverlapInfo::id1, PndLmdOverlapInfo::id2, PndGeoHandling::Instance(), isOverlappingArea(), PndLmdOverlapInfo::mat1, PndLmdOverlapInfo::mat2, PndLmdHitLocationInfo::module, PndLmdOverlapInfo::overlapID, PndLmdOverlapInfo::path1, PndLmdOverlapInfo::path2, and PndLmdHitLocationInfo::plane.

Referenced by buildCyclic(), PndLmdAlignQA::checkCombined(), compareICPmatrices(), compareShiftDataShiftGeo(), getAvailableOverlapIDs(), getSensorOneFromOverlapID(), getSensorTwoFromOverlapID(), and saveMatricesToJson().

                  {
         std::vector<PndLmdOverlapInfo> result;
 
         bool all = false;
 
         if (iHalf < 0 || iPlane < 0 || iModule < 0) {
                 all = true;
         }
         //FIXME: this should be read from config file
         if (iHalf > 2 || iPlane > 4 || iModule > 5) {
                 std::cerr << "ERROR. Invalid module specified.\n";
                 return result;
         }
 
         PndGeoHandling *geo_handling = PndGeoHandling::Instance();
         if (!geo_handling) {
                 std::cerr << "WARNING! No geoHandling present!\n";
                 exit(1);
         }
 
         PndLmdHitLocationInfo hitLoc;
 
         // FIXME: also, this might break if our sensor ids are not 0-399. this needs handling!
         for (int iSensor = 0; iSensor < 400; iSensor++) {
                 for (int jSensor = iSensor; jSensor < 400; jSensor++) {
                         if (isOverlappingArea(iSensor, jSensor)) {
 
                                 if (!all) {
                                         hitLoc = getHitLocationInfo(iSensor);
                                         if (iHalf != hitLoc.detector_half) continue;
                                         if (iPlane != hitLoc.plane) continue;
                                         if (iModule != hitLoc.module) continue;
                                 }
 
                                 PndLmdOverlapInfo temp;
 
                                 std::string path1(geo_handling->GetPath(int(iSensor)));
                                 gGeoManager->cd(path1.c_str());
                                 temp.mat1 = gGeoManager->GetCurrentMatrix();
                                 gGeoManager->CdUp();            //exclude toActiveRect from path
                                 path1 = (gGeoManager->GetPath());
                                 std::string path2(geo_handling->GetPath(int(jSensor)));
                                 gGeoManager->cd(path2.c_str());
                                 temp.mat2 = gGeoManager->GetCurrentMatrix();
                                 gGeoManager->CdUp();            //exclude toActiveRect from path
                                 path2 = (gGeoManager->GetPath());
 
                                 auto overlapID = getOverlapIdFromSensorIDs(iSensor, jSensor);
                                 temp.path1 = path1;
                                 temp.path2 = path2;
                                 temp.overlapID = overlapID;
                                 temp.id1 = iSensor;
                                 temp.id2 = jSensor;
 
                                 temp.hit1 = getHitLocationInfo(iSensor);
                                 temp.hit2 = getHitLocationInfo(jSensor);
 
                                 result.push_back(temp);
                         }
                 }
         }
 
         return result;
 }

const std::string PndLmdGeometryHelper::getPath ( unsigned char... )

int PndLmdGeometryHelper::getSensorOneFromOverlapID ( int overlapID )

Definition at line 400 of file PndLmdGeometryHelper.cxx.

References getOverlapInfos().

Referenced by PndLmdAlignQA::calculateOverlapingAreas(), and PndLmdSensorAligner::transformToSensorOne().

                                                                  {
         auto allInfos = getOverlapInfos();
         for (auto &info : allInfos) {
                 if (info.overlapID == overlapID) {
                         return info.id1;
                 }
         }
         return -1;
 }

int PndLmdGeometryHelper::getSensorTwoFromOverlapID ( int overlapID )

Definition at line 410 of file PndLmdGeometryHelper.cxx.

References getOverlapInfos().

Referenced by PndLmdAlignQA::calculateOverlapingAreas().

                                                                  {
         auto allInfos = getOverlapInfos();
         for (auto &info : allInfos) {
                 if (info.overlapID == overlapID) {
                         return info.id2;
                 }
         }
         return -1;
 }

bool PndLmdGeometryHelper::isOverlappingArea	(	const int	id1,
		const int	id2
	)

Definition at line 357 of file PndLmdGeometryHelper.cxx.

References getOverlapIdFromSensorIDs().

Referenced by PndLmdPairFinderTask::candHitsOverlappingArea(), and getOverlapInfos().

                                                                          {
         return (getOverlapIdFromSensorIDs(id1, id2) > -1);
 }

void PndLmdGeometryHelper::operator= ( const PndLmdGeometryHelper & )

delete

TVector3 PndLmdGeometryHelper::transformPndGlobalToLmdLocal ( const TVector3 & vec )

Definition at line 197 of file PndLmdGeometryHelper.cxx.

References Double_t, and getMatrixPndGlobalToLmdLocal().

                                                                                   {
         Double_t result[3];
         Double_t temp[3];
 
         global.GetXYZ(temp);
 
         auto matrix = getMatrixPndGlobalToLmdLocal();
         matrix.MasterToLocal(temp, result);
 
         return TVector3(result);
 }

TVector3 PndLmdGeometryHelper::transformPndGlobalToSensor	(	const TVector3 &	vec,
		int	sensorId
	)

Definition at line 209 of file PndLmdGeometryHelper.cxx.

References Double_t, and getMatrixPndGlobalToSensor().

                                                                                                {
         Double_t result[3];
         Double_t temp[3];
 
         global.GetXYZ(temp);
 
         auto matrix = getMatrixPndGlobalToSensor(sensor_id);
         matrix.MasterToLocal(temp, result);
 
         return TVector3(result);
 }

PndLmdHitLocationInfo PndLmdGeometryHelper::translateVolumePathToHitLocationInfo ( const std::string & volume_path ) const

private

Definition at line 32 of file PndLmdGeometryHelper.cxx.

References PndGeoHandling::cd(), PndLmdHitLocationInfo::detector_half, fGeoManager, geometry_properties, PndGeoHandling::Instance(), PndLmdHitLocationInfo::module, PndLmdHitLocationInfo::module_sensor_id, PndLmdHitLocationInfo::module_side, navigation_paths, PndLmdHitLocationInfo::plane, and TString.

Referenced by createMappingEntry().

                                         {
         PndLmdHitLocationInfo hit_info;
         std::stringstream reg_exp;
         for (auto const &nav_path : navigation_paths) {
                 reg_exp << "/" << nav_path.first << "_(\\d+)";
         }
 
         std::smatch match;
 
         if (std::regex_search(volume_path, match, std::regex(reg_exp.str()))) {
                 hit_info.detector_half = (unsigned char) std::stoul(match[2]);
                 hit_info.plane = (unsigned char) std::stoul(match[3]);
                 hit_info.module = (unsigned char) std::stoul(match[4]);
                 unsigned char sensor_id((unsigned char) std::stoul(match[5]));
                 hit_info.module_side = 0;
                 hit_info.module_sensor_id = sensor_id;
 
                 unsigned int sensors_per_module_side = geometry_properties.get<unsigned int>(
                     "general.sensors_per_module_side");
 
                 if (sensor_id > sensors_per_module_side - 1) {
                         hit_info.module_side = 1;
                         sensor_id = sensor_id % (sensors_per_module_side - 1);
                 }
 
                 // now we have to make sure the TGeoManager builds the matrix cache
                 // correctly the only way we found (analogous to PndGeoHandling) is to
                 // dive down to this node from the top, then the matrix multiplications
                 // are done correctly
                 TString actPath = fGeoManager->GetPath();
                 fGeoManager->cd(volume_path.c_str());
                 PndGeoHandling::Instance()->cd(fGeoManager->GetCurrentNode());
                 if (actPath != "" && actPath != " ") fGeoManager->cd(actPath);
 
         }
         else {
                 throw std::runtime_error("PndLmdGeometryHelper::translateVolumePathToHitLocationInfo: geometry "
                                 "navigation paths mismatch!"
                                 " Seems like you used a different lmd geo config file to create a lmd "
                                 "root geometry which was use in your simulations...");
         }
 
         return hit_info;
 }