PndGeoHandling.h

Go to the documentation of this file.

#ifndef PNDGEOHANDLING_H
#define PNDGEOHANDLING_H

#include "PndSensorNamePar.h"
#include "PndSensorNameIdMap.h"

#include "FairRun.h"
#include "FairRuntimeDb.h"
#include "FairTask.h"

#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TString.h"
#include "TVector3.h"
#include "TMatrixD.h"

#include <string>
#include <iostream>
#include <vector>

class PndGeoHandling : public FairTask {
 public:
  PndGeoHandling(); 
  static PndGeoHandling *Instance();

  static void Destroy()
  {
    if (fInstance) {
      delete fInstance;
      fInstance = nullptr;
    }
  }

  // PndGeoHandling(TGeoManager* aGeoMan);
  PndGeoHandling(TString mcFile, TString parFile);
  PndGeoHandling(Int_t runID, TString parFile);
  PndGeoHandling(PndSensorNamePar *SensorNamePar);

  virtual ~PndGeoHandling(){};

  virtual void SetParContainers();

  //  static PndGeoHandling* Instance();

  //  TString GetCurrentID(); ///< returns the ID of the current node
  //  TString GetID(TString path); ///< for a given TGeoManager-path the ID is returned
  //  TString GetPath(TString id); ///< for a given ID the path is returned

  TString GetPath(Int_t shortID); 
  Int_t GetShortID(TString path); 

  TString GetVolumeID(TString name);                                       
  std::vector<TString> GetNamesLevel(Int_t level, TString startPath = ""); //, bool fullPath = false); //[R.K.03/2017] unused variable
  void GetOUVPath(TString path, TVector3 &o, TVector3 &u, TVector3 &v);    
  //  void GetOUVId(TString id, TVector3& o, TVector3& u, TVector3& v); ///< for a volume given by its ID the o, u, v vectors for the plane are returned
  void GetOUVShortId(Int_t shortId, TVector3 &o, TVector3 &u, TVector3 &v)
  {
    if (fSensorNamePar != 0)
      GetOUVPath(GetPath(shortId), o, u, v);
  }

  TGeoHMatrix *GetMatrixPath(TString path);
  //  TGeoHMatrix* GetMatrixId(TString id);
  TGeoHMatrix *GetMatrixShortId(Int_t shortId) { return GetMatrixPath(GetPath(shortId)); }

  //  TVector3 GetSensorDimensionsId(TString id);
  TVector3 GetSensorDimensionsPath(TString path);
  TVector3 GetSensorDimensionsShortId(Int_t shortId) { return GetSensorDimensionsPath(GetPath(shortId)); }

  //  TVector3 MasterToLocalId(const TVector3& master, const TString& id);
  TVector3 MasterToLocalPath(const TVector3 &master, const TString &id);
  TVector3 MasterToLocalShortId(const TVector3 &master, const Int_t &shortId) { return MasterToLocalPath(master, GetPath(shortId)); }

  //  TVector3 LocalToMasterId(const TVector3& local, const TString& id);
  TVector3 LocalToMasterPath(const TVector3 &local, const TString &id);
  TVector3 LocalToMasterShortId(const TVector3 &local, const Int_t &shortId) { return LocalToMasterPath(local, GetPath(shortId)); }

  // TODO: Recheck the error calculation for 3-vectors
  //  TMatrixD MasterToLocalErrorsId(const TMatrixD& master, const TString& id);
  TMatrixD MasterToLocalErrorsPath(const TMatrixD &master, const TString &id);
  TMatrixD MasterToLocalErrorsShortId(const TMatrixD &master, const Int_t &shortId) { return MasterToLocalErrorsPath(master, GetPath(shortId)); }

  //  TMatrixD LocalToMasterErrorsId(const TMatrixD& local, const TString& id);
  TMatrixD LocalToMasterErrorsPath(const TMatrixD &local, const TString &id);
  TMatrixD LocalToMasterErrorsShortId(const TMatrixD &local, const Int_t &shortId) { return LocalToMasterErrorsPath(local, GetPath(shortId)); }

  TMatrixD GetCurrentRotationMatrix();

  void SetVerbose(Int_t v) { fVerbose = v; }
  void SetGeoManager(TGeoManager *geo) { fGeoMan = geo; };
  void SetSensorNamePar(PndSensorNamePar *par) { fSensorNamePar = par; }

  // Bool_t cd(TString id); ///< as the cd command of TGeoManager just with the ID
  Bool_t cd(Int_t id);   
  void FillLevelNames(); 

  TString FindNodePath(TGeoNode *node);
  void DiveDownToNode(TGeoNode *node);
  void cd(TGeoNode *node); 

  void DiveDownToNodeContainingString(TString name); 

  void CreateUniqueSensorId(TString startName, std::vector<std::string> listOfSensitives); 
  bool VolumeIsSensitive(
    TString &path,
    std::vector<std::string> &listOfSensitives); 

  void PrintSensorNames()
  {
    if (fSensorNamePar)
      fSensorNamePar->Print();
  }

  TObjArray *GetSensorNames()
  {
    if (fSensorNamePar != nullptr)
      return fSensorNamePar->GetSensorNames();
    else
      return nullptr;
  }

  std::vector<TString> GetSensorNamesWithString(TString value)
  {
    if (fSensorNamePar != nullptr)
      return fSensorNamePar->GetSensorNamesWithString(value);
    else {
      std::vector<TString> empty;
      return empty;
    }
  }

  Int_t GetRunId(TString mcFile);
  void GetGeoManager();
  TGeoManager *GetGeoMan() { return fGeoMan; }
  void GetSensorNamePar();
  void FillSensorMap() { fSensorNamePar->FillMap(); }
  void InitRuntimeDb(TString parFileName);

  PndGeoHandling &operator=(const PndGeoHandling &) { return *this; }

  void CreateUniqueSensorId(const TString &startName, const std::vector<std::string> &listOfSensitives, PndSensorNameIdMap *idmap);

 protected:
  Int_t GetIdForSensor(TString &sensName) const;

  InitStatus Init()
  {
    fSensorNamePar->FillMap();
    return kSUCCESS;
  }

  virtual InitStatus ReInit()
  {
    fGeoMan = 0;
    fGeoMan = gGeoManager;
    return kSUCCESS;
  }

 private:
  static PndGeoHandling *fInstance;
  PndGeoHandling(PndGeoHandling &gh)
    : FairTask(), fGeoMan(gh.fGeoMan), fSensorNamePar(gh.fSensorNamePar), fRtdb(gh.fRtdb), fLevelNames(gh.fLevelNames), fLevel(gh.fLevel), fFullPath(gh.fFullPath),
      fRunId(gh.fRunId), fVerbose(gh.fVerbose)
  {
  }

  void DiveDownToFillSensNamePar(std::vector<std::string> listOfSensitives);

  TGeoManager *fGeoMan{nullptr};
  PndSensorNamePar *fSensorNamePar{nullptr};
  FairRuntimeDb *fRtdb{nullptr};
  // static PndGeoHandling* fGeoHandlingInstance;

  std::vector<TString> fLevelNames{};
  Int_t fLevel{0};
  bool fFullPath{true};
  Int_t fRunId{0};
  Int_t fVerbose{0};

  PndSensorNameIdMap *fCurrentIdMap{nullptr};

  ClassDef(PndGeoHandling, 3);
};

#endif