PndLmdGeometryHelper.h

Go to the documentation of this file.

#ifndef LMD_LMDMC_PNDLMDGEOMETRYHELPER_H_
#define LMD_LMDMC_PNDLMDGEOMETRYHELPER_H_

#include <exception>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <vector>

#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>

#include <TGeoManager.h>
#include <TVector3.h>

struct PndLmdHitLocationInfo {
        // we use small data types here as they can be packed into 8 bytes
        unsigned char detector_half;
        unsigned char plane;
        unsigned char module;
        unsigned char module_side;
        unsigned char module_sensor_id;

        friend std::ostream& operator<<(std::ostream& stream, const PndLmdHitLocationInfo& hit_info) {
                stream << "detector half: " << (unsigned int) hit_info.detector_half << "\n";
                stream << "detector plane: " << (unsigned int) hit_info.plane << "\n";
                stream << "module on half plane: " << (unsigned int) hit_info.module << "\n";
                stream << "side of module: " << (unsigned int) hit_info.module_side << "\n";
                stream << "sensor id: " << (unsigned int) hit_info.module_sensor_id << "\n";

                return stream;
        }

        bool operator <(const PndLmdHitLocationInfo &o) {
                return std::tie(detector_half, plane, module, module_side, module_sensor_id)
                    < std::tie(o.detector_half, o.plane, o.module, o.module_side, o.module_sensor_id);
        }
};

struct PndLmdOverlapInfo {
        std::string path1;
        std::string path2;
        int overlapID;
        int id1;
        int id2;

        TGeoHMatrix mat1;
        TGeoHMatrix mat2;

        // two dummy HitLocationInfo objects for the sensors
        PndLmdHitLocationInfo hit1;
        PndLmdHitLocationInfo hit2;

        friend std::ostream& operator<<(std::ostream& stream, const PndLmdOverlapInfo& overlap_info) {
                stream << "path 1: " << overlap_info.path1 << "\n";
                stream << "path 2: " << overlap_info.path2 << "\n";
                stream << "id 1: " << overlap_info.id1 << "\n";
                stream << "id 2: " << overlap_info.id2 << "\n";
                stream << "overlapID: " << overlap_info.overlapID << "\n";
                stream << "matrix 1: " << "\n";
                stream << "matrix 2: " << "\n";
                return stream;
        }
};

class PndLmdGeometryHelper {
        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;

        PndLmdGeometryHelper(const std::string& geo_params_config_file_url = "") :
                        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);

        }

        const PndLmdHitLocationInfo& createMappingEntry(int sensor_id);
        const PndLmdHitLocationInfo& createMappingEntry(const std::string& volume_path);

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

public:
        static PndLmdGeometryHelper& getInstance() {
                static PndLmdGeometryHelper instance;
                return instance;
        }

        virtual ~PndLmdGeometryHelper();

        PndLmdGeometryHelper(const PndLmdGeometryHelper&) = delete;
        void operator=(const PndLmdGeometryHelper&) = delete;

        const PndLmdHitLocationInfo& getHitLocationInfo(const std::string& volume_path);
        // this function with the global sensor id is much faster for lookups
        // so use that if you need speed!

        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);

        //can be restriced by half, plane and module
        std::vector<PndLmdOverlapInfo> getOverlapInfos(int iHalf=-1, int iPlane=-1, int iModule=-1);

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

};

#endif /* LMD_LMDMC_PNDLMDGEOMETRYHELPER_H_ */