PndMdtIGeometry.h

Go to the documentation of this file.

#ifndef PNDMDTIGEOMETRY_H
#define PNDMDTIGEOMETRY_H 1

#include "TVector3.h"
#include "TGeoVolume.h"
#include <vector>
#include "TF1.h"
#include <map>
#include <set>
#include "PndMdtID.h"
#include "TGeoMatrix.h"
#include <iostream>

using std::ostream;
ostream &operator<<(ostream &os, const TVector3 &v3);

class PndMdtIGeometry : public TNamed {

 public:
  static PndMdtIGeometry *Instance();
  PndMdtIGeometry();
  ~PndMdtIGeometry();

  void SetVerbose(Int_t _v) { fVerbose = _v; }
  void AddSensor(TString _v) { fSensorSet.insert(_v); }
  // version and Init() should be invoked first before using access functions
  // now only support ROOT geometry version 0, 1, 2
  Bool_t Init();
  //================================================================
  // Access to Tube Geometery for given parameters
  Bool_t GetTubeCenter(Int_t iDetId, TVector3 &pos) const
  {
    std::map<Int_t, InfoType>::const_iterator it = fGeoMap.find(iDetId);
    if (it == fGeoMap.end())
      return kFALSE;
    pos = it->second.Position;
    return kTRUE;
  }
  //
  Bool_t GetTubeLength(Int_t iDetId, Double_t &len) const
  {
    std::map<Int_t, InfoType>::const_iterator it = fGeoMap.find(iDetId);
    if (it == fGeoMap.end())
      return kFALSE;
    len = it->second.Length;
    return kTRUE;
  }
  //
  Bool_t GetStripLength(Int_t iDetId, Double_t &len) const
  {
    std::map<Int_t, InfoType>::const_iterator it = fGeoMap.find(iDetId);
    if (it == fGeoMap.end())
      return kFALSE;
    len = it->second.Length;
    return kTRUE;
  }
  Bool_t GetStripCenter(Int_t iDetId, TVector3 &pos) const
  {
    std::map<Int_t, InfoType>::const_iterator it = fGeoMap.find(iDetId);
    if (it == fGeoMap.end())
      return kFALSE;
    pos = it->second.Position;
    return kTRUE;
  }
  Bool_t GetLayerBoundary(Int_t iLayer, TVector3 &LBPos, TVector3 &RTPos) const
  {
    std::map<Int_t, LayerBoundary>::const_iterator it = fLayerInfoMap.find(iLayer);
    if (it == fLayerInfoMap.end())
      return kFALSE;
    LBPos = TVector3(it->second.minX, it->second.minY, it->second.minZ);
    RTPos = TVector3(it->second.maxX, it->second.maxY, it->second.maxZ);
    return kTRUE;
  }
  Bool_t MasterToLocal(Int_t iDetId, TVector3 &master, TVector3 &local)
  {
    std::map<Int_t, InfoType>::const_iterator it = fGeoMap.find(iDetId);
    if (it == fGeoMap.end())
      return kFALSE;
    TVector3 center = it->second.Position;
    TGeoMatrix *fMtrx = it->second.Matrix;
    if (!fMtrx)
      return kFALSE;
    // fMtrx->Print();
    // fMtrx->MasterToLocal(&center[0], &local[0]);
    // std::cout<<"local 1 "<<local<<std::endl;
    fMtrx->MasterToLocal(&master[0], &local[0]);
    // std::cout<<"local 2 "<<local<<std::endl;
    return kTRUE;
  }
  Bool_t MapWireToStrip(Int_t iDetId, const TVector3 &fEntryPos, Int_t &fStripDetID)
  {
    static const Double_t cSTRIPWIDTH = 1.;   // cent meter;
    static const Double_t cGAPOFSTRIPS = 0.0; // cent meter;
    Short_t iMod = PndMdtID::Module(iDetId);
    Short_t iSec = PndMdtID::Sector(iDetId);
    Short_t iLayer = PndMdtID::Layer(iDetId);
    Int_t layerID = PndMdtID::LayerID(iMod, iSec, iLayer);
    LayerInfoMapIter it = fLayerInfoMap.find(layerID);
    if (it == fLayerInfoMap.end())
      return kFALSE;
    Int_t fStripNo;
    if (iMod == 1)
      fStripNo = (fEntryPos.Z() - it->second.minZ) / (cSTRIPWIDTH + cGAPOFSTRIPS);
    else if (iMod == 2) // endcap
    {
      if (iLayer < 2)
        fStripNo = (fEntryPos.Y() - it->second.minY) / (cSTRIPWIDTH + cGAPOFSTRIPS);
      else
        fStripNo = (fEntryPos.X() - it->second.minX) / (cSTRIPWIDTH + cGAPOFSTRIPS);
    } else
      fStripNo = (fEntryPos.X() - it->second.minX) / (cSTRIPWIDTH + cGAPOFSTRIPS);
    fStripDetID = PndMdtID::Identifier(iMod, iSec, iLayer, fStripNo);
    return kTRUE;
  }
  void Print() const;

 private:
  std::set<TString> fSensorSet;
  Bool_t FindSensorinPath(TString path)
  {
    Bool_t ret = kFALSE;
    std::set<TString>::iterator it = fSensorSet.begin();
    std::set<TString>::iterator end = fSensorSet.end();
    while (it != end) {
      if (path.Contains(*it)) {
        ret = kTRUE;
        break;
      }
      ++it;
    }
    return ret;
  }

 private:
  Int_t fVerbose;
  Bool_t fGoodGeometry;
  TString fStateTip;

 public:
  struct InfoType {
    TVector3 Position;
    Double_t Length;
    TGeoMatrix *Matrix;
  };

 private:
  std::map<Int_t, InfoType> fGeoMap;
  std::map<Int_t, TGeoMatrix *> fMatrixMap;

 public:
  struct LayerBoundary {
    Double_t minX;
    Double_t minY;
    Double_t minZ;
    Double_t maxX;
    Double_t maxY;
    Double_t maxZ;
  };

 private:
  std::map<Int_t, LayerBoundary> fLayerInfoMap;
  typedef std::map<Int_t, LayerBoundary>::iterator LayerInfoMapIter;
  typedef std::pair<Int_t, LayerBoundary> LayerInfoMapValue;

  Int_t fBarrelVersion;
  Int_t fEndcapVersion;
  Int_t fForwardVersion;
  Int_t fMuonFilterVersion;
  Int_t fNumofMdt;
  Int_t fNumofStrip;
  Bool_t fInitialized;

  void LoadGeometry(TGeoNode *node);
  Bool_t GetStripInfo();
  Bool_t GetGeometryInfoV2(const TString &fFullPath, const TString &Name);
  void InsertLayerInfo(Int_t layerID, const TVector3 &pos, const TVector3 &lwh);

  Bool_t AddTubeInfo(Int_t detID, const TVector3 &center, Double_t wirelen, TGeoMatrix *matrix);
  Bool_t AddStripInfo(Int_t detID, TVector3 stripPos, Double_t stripLen, TGeoMatrix *matrix = 0);
  Bool_t AddMatrix(Int_t layerID, TGeoMatrix *matrix);

  static PndMdtIGeometry *fInstance;

  ClassDef(PndMdtIGeometry, 1);
};

#endif