---

Geometry.h

Go to the documentation of this file.

#ifndef Geometry_h
#define Geometry_h

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include "TMatrix.h"
#include "TRotation.h"
#include "TVector3.h"
#include "TBID.h"

#define MAX_HEC_CELLS  400 //what to do here?
#define MAX_EMEC_CELLS 1200
/*! -Class:    Geometry
  - Author:   Ian Gable (igable@uvic.ca)
  - Date:      05/09/2002
  - Description: Geometry can be used to determine the z, eta, and phi coords given
                        a particular  febno. It reads a specific geometry file of a specific format
                        which is passed to the class in the constructor.
  - Notes:           This class will not operate properly if the file format is changed.
*/

using std::vector;
using std::map;
using std::multimap;
using std::string;
using std::cout;
using std::endl;
using std::pair;

class Geometry {

 public:

  /** Constructor
    * @param hecGeoFileName The name of the Hec Geometry File. Can be relative or absolute path.
    * @param emecGeoFileName The name of the Emec Geometry file. Can be relative or absolute path.
    * @param globalGeoFileName The name of the file used to make the transformation betweem detector
    *               local and 'nominal test beam' coordinate systems.
    */

  Geometry(string hecGeoFileName, string emecGeoFileName, string globalGeoFileName);

  // ==== public hec methods =======================

  //! get the hec integer eta index (test beam)
  int hec_ieta(int febno);

  //! get the hec integer phi index (test beam)
  int hec_iphi(int febno);

  //! get the hec integer z index (test beam)
  int hec_iz(int febno);

  //! get the hec interger module index (test beam)
  int hec_imod(int febno);

  //! get the hec eta (median) coordinate
  float hec_eta(int febno);

  //! get the hec phi (median) coordinate (rad)
  float hec_phi(int febno);

  //! get the hec z (median) coordinate (cm)
  float hec_z(int febno);

  //! get the hec delta eta
  float hec_deta(int febno);

  //! get the hec delta phi (rad)
  float hec_dphi(int febno);

  //! get the hec delta z (cm)
  float hec_dz(int febno);

  //! is the cell with febno Connected in the Hec
  bool hec_isConnected(int febno) ;

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * hec keyed with febno. The TVector3 is a ROOT object containing
     * the (median) center x,y,z in the hec local detector coordinate system
     */
  map<int,TVector3> hec_LocalCenterMap();

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * hec keyed with febno. The TVector3 is a ROOT object containing
     * the (median) center x,y,z in the test beam coordinate system
     */
  map<int,TVector3> hec_TBCenterMap();

    /** Return the TVector3 object which is the (median) center of the cell in the 
    * hec local detector coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 hec_LocalCenter(int febno);

    /** Return the TVector3 object which is the (median) center of the cell in the 
    * test beam coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 hec_TBCenter(int febno);

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * hec keyed with febno. The TVector3 is a ROOT object containing
     * the GeoCenter of the cell in the hec local detector coordinate system
     */
  map<int,TVector3> hec_LocalGeoCenterMap();

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * hec keyed with febno. The TVector3 is a ROOT object containing
     * the GeoCenter of the cell in the test beam coordinate system
     */
  map<int,TVector3> hec_TBGeoCenterMap();

    /** Return the TVector3 object which is the GeoCenter of the cell in the 
    * hec local detector coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 hec_LocalGeoCenter(int febno);

    /** Return the TVector3 object which is the GeoCenter of the cell in the 
    * test beam coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 hec_TBGeoCenter(int febno);

  /** Return the volume (cm^3) of the cell
    * @param febno The febno of the cell.
    */
  double hec_Volume(int febno);

  /** Return a STL multimap which has as the key a double which is the distance
    * to the nearest neighbors in the Hec. The second thing in the map is
    * the febno of that cell.  All calculations done in the test beam coordinate system
    * using the (median) center of cells.
    * @param point The point in the test beam system which you wish to
    *              calculate the nearest neighbors of.
    *
    */
  multimap< double,int > hec_neighbors(TVector3 point);

  /** Return a STL multimap which has as the key a double which is the distance
    * to the nearest neighbors in the hec for a particular layer. The second thing in the map is
    * the febno of that cell. All calculations done in the test beam coordinate system
    * using the (median) center of cells.
    * @param point The point in the test beam coordinate system which you wish to
    *              calculate the nearest neighbors of.
    * @param layer The layer which you want the search confined to.
    *
    */
  multimap< double,int > hec_neighbors(TVector3 point, int layer);

  /** Return a STL multimap which has as the key a double which is the shortest distance
    * to the line given by the input line parameterization from the median of the cell. The second
    * thing in the map is the febno of that cell.  All calculations done in the test beam
    * coordinate system using the (median) center of cells.
    * @param lineParameters The line parameterized by the four numbers contained in the
    *           vector in order a0, b0, a1, b1.
    *
    */
  multimap< double,int > hec_neighbors(vector<float> lineParameters);

  /** Return a STL multimap which has as the key a double which is the shortest distance
    * to the line given by the input line parameterization from the median of the cell. The second
    * thing in the map is the febno of that cell.  All calculations done in the test beam
    * coordinate system using the (median) center of cells.
    * @param lineParameters The line parameterized by the four numbers contained in the
    *           vector in order a0, b0, a1, b1.
    * @param layer The layer which you want the search confined to.
    *
    */
  multimap< double,int > hec_neighbors(vector<float> lineParameters, int layer);

  /** Produce a vector of feb numbers which is a list of cells which are in direct
    * contact with the cell passed to the function on a per layer basis.  The list will have 2,3, or 4
    * elements in it.
    * @param febno The cell which you wish to find it's touching neighbors
    * @param layer The layer which you with to have the search confined.
    */
  vector<int> hec_neighbors(int febno);

  /** Produce a vector of feb numbers which is a list of cells which are in direct
    * contact with the cell passed to the function on a per layer basis.  The list will have 2,3, or 4
    * elements in it.
    * @param febno The cell which you wish to find it's touching neighbors
    * @param layer The layer which you with to have the search confined.
    */
  vector<int> hec_neighbors(int febno, int layer);

  /** Take a point in the hec local detector coordinate system and transform it to
    * the test beam coordinate system
    * @param local A TVector3 in the hec local detector coordinate system which you
    *              transform to the test beam system.
    */
  TVector3 hec_LocalToTB(TVector3 local);

  /** Take a point in the test beam coordinate system and transform it to
    * the hec local detector system
    * @param tb A TVector3 in the hec test beam coordinate system which you
    *           transform to the Local coordinate system.
    */
  TVector3 hec_TBToLocal(TVector3 tb);


  /** Draw the pad artwork of the HEC at all three layers and fill each cell with a color \
    * contour histogram.
    * @param inputMap A STL map with key the febno of the cell and the value being any
    *                 particular value you wish to plot on the hec.
    * @param canID The number assigned to a particular canvas. Assigning a number other then
    *             zero will cause the canvas with that particular ID to be over written. If zero is given
    *             then a new canvas with a new number will be created.
    * @param lockScale Set to true if you want this scale between all the layers to be the same.
    * @param scaleLower Set a user defined lower limit to the scale.
    * @param scaleUpper Set a user defined upper limit to the scale. If scalleUpper = scaleLower = 0
    *             then a scale range is automatically picked.
    */
  void draw2DHec(map<int,float> inputMap, int canID=0, bool lockScale=false, float scaleLower=0, float scaleUpper=0,string userTitle = "");

  /** Draw the pad artwork of the HEC at all 3 layers on 3 seperate cavases
    * and fill each cell with a color contour histogram.
    * @param inputMap A STL map with key the febno of the cell and the value being any
    *                 particular value you wish to plot on the emec.
    * @param canID The number assigned to a particular canvas. Assigning a number other then
    *             zero will cause the canvas with that particular ID to be over written. If zero is given
    *             then a new canvas with a new number will be created.
    * @param lockScale Set to true if you want this scale between all the layers to be the same.
    * @param scaleLower Set a user defined lower limit to the scale.
    * @param scaleUpper Set a user defined upper limit to the scale. If scalleUpper = scaleLower = 0
    *             then a scale range is automatically picked.
    */
  void draw2DHecDetail(map<int,float> inputMap, int canID=0, bool lockScale=false, float scaleLower=0, float scaleUpper=0, string userTitle = "");


  // ==== public emec methods =======================

  //! get the emec integer eta index (test beam)
  int emec_ieta(int febno);

  //! get the emec integer phi index (test beam)
  int emec_iphi(int febno);

  //! get the emec integer z index (test beam)
  int emec_iz(int febno);

  //! get the emec eta (median) coordinate
  float emec_eta(int febno);

  //! get the emec phi (median) coordinate (rad)
  float emec_phi(int febno);

  //! get the emec z (median) coordinate (cm)
  float emec_z(int febno);

  //! get the emec delta eta
  float emec_deta(int febno);

  //! get the emec delta phi (rad)
  float emec_dphi(int febno);

  //! get the emec delta z (cm)
  float emec_dz(int febno);

  //! is the cell with febno Connected in the emec
  bool emec_isConnected(int febno) ;

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * emec keyed with febno. The TVector3 is a ROOT object containing
     * the (median) center x,y,z in the emec local detector coordinate system
     */
  map<int,TVector3> emec_LocalCenterMap();

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * emec keyed with febno. The TVector3 is a ROOT object containing
     * the (median) center x,y,z in the test beam coordinate system
     */
  map<int,TVector3> emec_TBCenterMap();

  /** Return the TVector3 object which the (median) center of the cell in the 
    * emec local detector coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 emec_LocalCenter(int febno);

  /** Return the TVector3 object which the (median) center of the cell in the 
    * test beam coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 emec_TBCenter(int febno);

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * emec keyed with febno. The TVector3 is a ROOT object containing
     * the GeoCenter of the cell in the emec local detector coordinate system
     */
  map<int,TVector3> emec_LocalGeoCenterMap();

   /** Return a map<int,TVector3> which is a complete list of all the cells in the
     * emec keyed with febno. The TVector3 is a ROOT object containing
     * the GeoCenter of the cell in the test beam coordinate system
     */
  map<int,TVector3> emec_TBGeoCenterMap();

    /** Return the TVector3 object which is the GeoCenter of the cell in the 
    * emec local detector coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 emec_LocalGeoCenter(int febno);

    /** Return the TVector3 object which is the GeoCenter of the cell in the 
    * test beam coordinate system
    * @param febno The febno of the cell.
    */
  TVector3 emec_TBGeoCenter(int febno);

  /** Return the volume (cm^3) of the cell
    * @param febno The febno of the cell.
    */
  double emec_Volume(int febno);

  /** Return a STL multimap which has as the key a double which is the distance
    * to the nearest neighbors in the emec. The second thing in the map is
    * the febno of that cell. All calculations done in the test beam coordinate system
    * using the (median) center of cells.
    * @param point The point in the test beam coordinate system which you wish to
    *              calculate the nearest neighbors of.
    *
    */
  multimap< double,int > emec_neighbors(TVector3 point);

  /** Return a STL multimap which has as the key a double which is the distance
    * to the nearest neighbors in the emec for a particular layer. The second thing in the map is
    * the febno of that cell. All calculations done in the test beam coordinate system
    * using the (median) center of cells.
    * @param point The point in the test beam coordinate system which you wish to
    *              calculate the nearest neighbors of.
    * @param layer The layer which what the search confined to.
    *
    */
  multimap< double,int > emec_neighbors(TVector3 point, int layer);

  /** Return a STL multimap which has as the key a double which is the shortest distance
    * to the line given by the input line parameterization from the median of the cell. The second
    * thing in the map is the febno of that cell.  All calculations done in the test beam
    * coordinate system using the (median) center of cells.
    * @param lineParameters The line parameterized by the four numbers contained in the
    *           vector in order a0, b0, a1, b1.
    *
    */
  multimap< double,int > emec_neighbors(vector<float> lineParameters);

  /** Return a STL multimap which has as the key a double which is the shortest distance
    * to the line given by the input line parameterization from the median of the cell. The second
    * thing in the map is the febno of that cell.  All calculations done in the test beam
    * coordinate system using the (median) center of cells.
    * @param lineParameters The line parameterized by the four numbers contained in the
    *           vector in order a0, b0, a1, b1.
    * @param layer The layer which you want the search confined to.
    *
    */
  multimap< double,int > emec_neighbors(vector<float> lineParameters, int layer);

  /** Produce a vector of feb numbers which is a list of cells which are in direct
    * contact with the cell passed to the function.  The method works in 3D
    * elements in it.
    * @param febno The cell which you wish to find it's touching neighbors
    */
  vector<int> emec_neighbors(int febno);

  /** Produce a vector of feb numbers which is a list of cells which are in direct
    * contact with the cell passed to the function on a per layer basis.  The list will have 2,3, or 4
    * elements in it.
    * @param febno The cell which you wish to find it's touching neighbors
    * @param layer The layer which you with to have the search confined.
    */
  vector<int> emec_neighbors(int febno, int layer);

  /** Take a point in the emec local detector coordinate system and transform it to
    * the test beam system
    * @param local A TVector3 in the emec local detector coordinate system which you
    *              transform to the test beam system.
    */
  TVector3 emec_LocalToTB(TVector3 local);

  /** Take a point in the test beam coordinate system and transform it to
    * the emec local detector coordinate system
    * @param tb A TVector3 in the test beam coordinate system which you wish to
    *           transform to the emec local detector coordinate system.
    */
  TVector3 emec_TBToLocal(TVector3 tb);

  /** Draw the pad artwork of the EMEC at all four layers on a single canvas without numbering the cells
    * and fill each cell with a color contour histogram.
    * @param inputMap A STL map with key the febno of the cell and the value being any
    *                 particular value you wish to plot on the emec.
    * @param canID The number assigned to a particular canvas. Assigning a number other then
    *             zero will cause the canvas with that particular ID to be over written. If zero is given
    *             then a new canvas with a new number will be created.
    * @param lockScale Set to true if you want this scale between all the layers to be the same.
    * @param scaleLower Set a user defined lower limit to the scale.
    * @param scaleUpper Set a user defined upper limit to the scale. If scalleUpper = scaleLower = 0
    *             then a scale range is automatically picked.
    */
  void draw2DEmec(map<int,float> inputMap, int canID=0, bool lockScale=false, float scaleLower=0, float scaleUpper=0, string userTitle = "");

  /** Draw the pad artwork of the EMEC at all four layers on four seperate cavases
    * and fill each cell with a color contour histogram.
    * @param inputMap A STL map with key the febno of the cell and the value being any
    *                 particular value you wish to plot on the emec.
    * @param canID The number assigned to a particular canvas. Assigning a number other then
    *             zero will cause the canvas with that particular ID to be over written. If zero is given
    *             then a new canvas with a new number will be created.
    * @param lockScale Set to true if you want this scale between all the layers to be the same.
    * @param scaleLower Set a user defined lower limit to the scale.
    * @param scaleUpper Set a user defined upper limit to the scale. If scalleUpper = scaleLower = 0
    *             then a scale range is automatically picked.
    */
  void draw2DEmecDetail(map<int,float> inputMap, int canID=0, bool lockScale=false, float scaleLower=0, float scaleUpper=0, string userTitle = "");

  //==== pan-detector public methods ==========

  /** Draw the complete 3D geometry of the of the 2002 combined beam test.
    */
  void draw3DGeometry();

  /** Return the FEB Serial Channel Number for the corresponding interger coordinates
    * (idet,ieta,iphi,iz). If the cell does not exist  -1 is returned ( there are no negative FEB Serial
    * Channel Numbers).
    *@param idet  Detector id: hec = 2, emec = 1
    *@param ieta hec = [ 1,14], emec = [ 0,67]
    *@param iphi hec=[ 1, 6], emec = [ 0,31]
    *@param iz hec = [ 1, 3], emec = [ 0, 3]
    */
  int FEBSerialChannelNumber(int idet, int ieta, int iphi, int iz );

  /** Return the FEB Serial Channel Number for the corresponding TBID.
    * If the cell does not exist  -1 is returned ( there are no negative FEB Serial
    * Channel Numbers).
    *@param id  The TBID of the cell for which you wish to get the febno.
    */
  int FEBSerialChannelNumber(TBID id);

  /** Return the TBID which corresponds to the input idet(hec = 2, emec = 1) and febno
    *@param idet the detector id(hec = 2, emec = 1);
    *@param febno the febno of the cell
    */
  TBID getTBID(int idet, int febno);


  // ==== Other public methods ========

  /** Take (eta, phi, z) coords and transform them to (x,y,z) coords
    * @param eta The eta coordinate
    * @param phi The this coordinate
    * @param z The z coordinate
    */
  TVector3 epzTOxyz(double eta, double phi, double z);

  /** Take a TVector3 which is packed with (rho,phi,z) coordinates and transform
    * them xyz coordinates
    * @param rhoPhi the TVector3 which contains the coords you wish to transform
    */
  TVector3 Geometry::rpzTOxyz(TVector3 rhoPhi);


 private:

  void loadHecGeometryFile(string geoFileName);
  void loadEmecGeometryFile(string geoFileName);
  void loadGlobalGeometryFile(string geoFileName);

  //======== private HEC variables and methods ==========
  void hecGeo();// intialization of the Hec geometry
  void buildTouchingNeighborsHec();

  void hecNotConnected(int febno);  // simple warning
  bool hecCheckBounds(int febno,string msg);  // febno bound checking
  
  TVector3 hecLocalGeoCenter(int febno);   // compute the GeoCenter of a hec cell
  double hecVolume(int febno);             // compute the volume of a hec cell (cm^3)
  // there are 1 or 2 (pad) families per readout cell
  // family == 1: first (lowest local z) family
  int hecNumberOfFamilies(int febno);   // number of hec families 
  double hecFamilyZ(int febno, int family);      // GeoCenter Z of a hec family (cm)
  double hecFamilyRhoMin(int febno, int family); // minimum rho of a hec family (cm)
  double hecFamilyRhoMax(int febno, int family); // maximum rho of a hec family (cm)
  double hecFamilyRho(int febno, int family);    // GeoCenter rho of a hec family (cm)
  double hecFamilyVolume(int febno, int family); // volume of a hec family (cm^3)

  vector<TVector2> hecCalculate4Corners(int febno); // get the 4 corners for a 2D hec display

  short m_hec_adc[MAX_HEC_CELLS];
  short m_hec_ieta[MAX_HEC_CELLS];
  short m_hec_iphi[MAX_HEC_CELLS];
  short m_hec_iz[MAX_HEC_CELLS];
  float m_hec_eta[MAX_HEC_CELLS];
  float m_hec_phi[MAX_HEC_CELLS];
  float m_hec_z[MAX_HEC_CELLS];
  float m_hec_deta[MAX_HEC_CELLS];
  float m_hec_dphi[MAX_HEC_CELLS];
  float m_hec_dz[MAX_HEC_CELLS];

  double m_tbHecPhiEuler;
  double m_tbHecThetaEuler;
  double m_tbHecPsiEuler;

  double m_tbHecXTrans;
  double m_tbHecYTrans;
  double m_tbHecZTrans;

  double m_hecInnerRhoMin;  // the inner hec rho in the first layer (cm)
  double m_hecInnerRhoMax;  // the inner hec rho in all but the first layer (cm)
  double m_hecOuterRho;     // the outer hec rho (cm)

  map<int,TVector3> m_hecLocalCenterMap;  // febno keyed map of (median) center x,y,z (local)
  map<int,TVector3> m_hecTBCenterMap;     // febno keyed map of (median) center x,y,z (TB)

  map<int,TVector3> m_hecLocalGeoCenterMap;  // febno keyed map of GeoCenter x,y,z (local)
  map<int,TVector3> m_hecTBGeoCenterMap;     // febno keyed map of GeoCenter x,y,z (TB)

  map<int,double> m_hecVolumeMap; // febno keyed map of cell volumes (cm^3)

  map<int, vector<int> > m_hecTouch; // a list which contains the cells touching per layer

  TRotation* m_tbHecRotation;
  TVector3* m_tbHecVectorTrans;

  short m_numHecCells;    // the number of cells according to the geometry file
  short m_hecFirstFebno;  // the first hec febno (=1)
  short m_hecLastFebno ;  // the last hec febno (=m_numHecCells)
  short m_hec2DcanvasNumber;
  short m_hec2DcanvasNumberDetail;


  //======== private EMEC variables and methods ==========

  void emecGeo(); // initialization of the Emec geometry

  void emecNotConnected(int febno);  // simple warning
  bool emecCheckBounds(int febno,string msg);  // febno bound checking

  TVector3 emecLocalGeoCenter(int febno);   // compute the GeoCenter of an emec cell
  double emecVolume(int febno);             // compute the volume of an emec cell (cm^3)

  void buildTouchingNeighborsEmec();

  short m_emec_adc[MAX_EMEC_CELLS];
  short m_emec_ieta[MAX_EMEC_CELLS];
  short m_emec_iphi[MAX_EMEC_CELLS];
  short m_emec_iz[MAX_EMEC_CELLS];
  float m_emec_eta[MAX_EMEC_CELLS];
  float m_emec_phi[MAX_EMEC_CELLS];
  float m_emec_z[MAX_EMEC_CELLS];
  float m_emec_deta[MAX_EMEC_CELLS];
  float m_emec_dphi[MAX_EMEC_CELLS];
  float m_emec_dz[MAX_EMEC_CELLS];

  double m_tbEmecPhiEuler;
  double m_tbEmecThetaEuler;
  double m_tbEmecPsiEuler;

  double m_tbEmecXTrans;
  double m_tbEmecYTrans;
  double m_tbEmecZTrans;

  map<int,TVector3> m_emecLocalCenterMap;  // febno keyed map of (median) center x,y,z (local)
  map<int,TVector3> m_emecTBCenterMap;     // febno keyed map of (median) center x,y,z (TB)

  map<int,TVector3> m_emecLocalGeoCenterMap;  // febno keyed map of GeoCenter x,y,z (local)
  map<int,TVector3> m_emecTBGeoCenterMap;     // febno keyed map of GeoCenter x,y,z (TB)

  map<int,double> m_emecVolumeMap; // febno keyed map of cell volumes (cm^3)

  map<int, vector<int> > m_emecTouch; // a list which contains the cells touching per layer

  TRotation* m_tbEmecRotation;
  TVector3* m_tbEmecVectorTrans;

  short m_numEmecCells;    // the number of cells according to the geometry file
  short m_emecFirstFebno;  // the first emec febno (=0)
  short m_emecLastFebno ;  // the last emec febno (m_numEmecCells-1)
  short m_emec2DcanvasNumber;
  short m_emec2DcanvasNumberDetail;

  //======== pan-detector private variables and methods ==========

  void buildIDMap();

  void addRange(int detectorType,int etaLow, int etaHigh, int phiLow, int phiHigh, int z, int febno);

  void addTouch(int detectorType, int source, int target);

  map<TBID, int> m_idMap;

  //==== various testing methods ===========
  void drawJunk();
  void histoEmecLayers();
  TMatrix* constructRotationMatrix(double t, double p, double s);
  void test();
};

#endif

---