StRoot: StDbUtilities/StTpcCoordinateTransform.hh Source File

00001 /***********************************************************************
00002  *
00003  * $Id: StTpcCoordinateTransform.hh,v 1.19 2012/05/07 14:38:41 fisyak Exp $
00004  *
00005  * Author: brian made this on  Feb 6, 1998
00006  *
00007  ***********************************************************************
00008  * Description:
00009  *
00010  * Geometrical transformation Routines for:
00011  * Raw Pad Coordinate  <-->  Local Coordinate
00012  *   Local Coordinate  <-->  Global Coordinate
00013  *
00014  * These Routines deal positions ONLY!
00015  *
00016  ***********************************************************************
00017  *
00018  * $Log: StTpcCoordinateTransform.hh,v $
00019  * Revision 1.19  2012/05/07 14:38:41  fisyak
00020  * Remvoe hardcoded separation between Inner and Outer Sectors
00021  *
00022  * Revision 1.18  2011/01/18 14:34:28  fisyak
00023  * Clean up TpcDb interfaces and Tpc coordinate transformation
00024  *
00025  * Revision 1.17  2009/11/02 17:32:25  fisyak
00026  * remove defaults in Tpc Coordinate transformations
00027  *
00028  * Revision 1.16  2009/09/23 23:30:14  fisyak
00029  * Follow up Valery's corrections
00030  *
00031  * Revision 1.15  2009/09/22 22:39:38  fine
00032  * fix the StThreeVector invocation
00033  *
00034  * Revision 1.14  2009/05/20 02:49:51  genevb
00035  * Introduce tpcPadrowT0 time offsets
00036  *
00037  * Revision 1.13  2008/05/27 14:26:40  fisyak
00038  * Use TChairs, absorb shift tau shift, introduce sector to sector time offset
00039  *
00040  * Revision 1.12  2007/07/12 19:22:01  fisyak
00041  * Tpc Drift Velocity depends on West/East half
00042  *
00043  * Revision 1.11  2007/03/21 16:39:05  fisyak
00044  * TpcCoordinate transformation via TGeoHMatrix
00045  *
00046  * Revision 1.10  2005/07/06 19:10:34  fisyak
00047  * Add TpcCoordinate transormation classes to dictionary, use templated StThreeVector
00048  *
00049  * Revision 1.9  2004/06/05 23:31:09  fisyak
00050  * Add (sector,row) for Tpc Coordinate/Direction transformations; Change sign of t0zoffset correction (to be synch. with fcf)
00051  *
00052  * Revision 1.8  2004/03/05 17:22:54  fisyak
00053  * Add TPC transformations for direction, aligned sectors, protection in order to stay in the same sector when moving from/to Pad coordinates
00054  *
00055  * Revision 1.7  2001/05/22 22:32:14  hardtke
00056  * Add tpc global to local transformations
00057  *
00058  * Revision 1.6  2000/07/27 23:06:50  hardtke
00059  * Hui requested that all member functions be public -- probably bad programming, but TRS needs to be speeded up
00060  *
00061  * Revision 1.5  2000/05/25 20:51:31  hardtke
00062  * make z-to-time functions public, use correct t0s, get rid of spurious 0.5
00063  *
00064  * Revision 1.4  2000/04/13 22:57:53  calderon
00065  * use lookup table of sines and cosines instead of calculating them
00066  * each time
00067  *
00068  * Revision 1.3  2000/02/10 01:19:37  calderon
00069  * Tpc Local Sector Coordinate definitions where
00070  * y is up,
00071  * z points toward central membrane,
00072  * x is such that everything is righthanded
00073  * There are still some parameters that need to be taken from
00074  * database.
00075  *
00076  * Revision 1.2  2000/02/02 23:01:38  calderon
00077  * Changes for CC5
00078  * Tests withs StTpcDb still going.
00079  *
00080  * Revision 1.1  1999/11/19 19:01:08  calderon
00081  * First version of files for StDbUtilities.
00082  * Note: this package uses StTpcDb.
00083  * There are some parameters
00084  * that are not yet kept in StTpcDb.  When StTpcDb has them, the code
00085  * will be changed to use them from StTpcDb.
00086  * There are no Ftpc or Svt Coordinate transformations in here yet.
00087  *
00088  * Revision 1.5  1999/10/04 16:00:46  long
00089  * new coordinate system in the trs
00090  *
00091  * Revision 1.5  1999/10/01  17:15:00  Hui Long
00092  * New definition of the coordinate system according to Brian nad Thomas's
00093  * proposal
00094  * Revision 1.4  1999/02/18 21:17:42  lasiuk
00095  * instantiate with electronics db
00096  *
00097  * Revision 1.3  1999/02/16 23:28:46  lasiuk
00098  * matrix(3) is a data member to avoid constructor calls
00099  * protection against pad<1
00100  * const removed from several functions (because of matrix)
00101  *
00102  * Revision 1.2  1999/01/28 02:51:40  lasiuk
00103  * add ()localSector --> Raw
00104  * add ()localSector --> Local
00105  *
00106  * Revision 1.1  1998/11/10 17:12:05  fisyak
00107  * Put Brian trs versin into StRoot
00108  *
00109  * Revision 1.5  1998/11/01 16:21:05  lasiuk
00110  * remove 'St' from variable declarations
00111  * add set functions in local Coordinates
00112  *
00113  * Revision 1.4  1998/10/22 00:23:17  lasiuk
00114  * Oct 22
00115  *
00116  * Revision 1.3  1998/06/04 23:13:18  lasiuk
00117  * add sector12 coordinate transform as public member
00118  *
00119  * Revision 1.2  1998/05/25 17:00:31  lasiuk
00120  * pass databases instead of filenames
00121  * do not use hardcoded numbers
00122  *
00123  * Revision 1.1  1998/05/21 21:27:37  lasiuk
00124  * Initial revision
00125  *
00126  *
00127  ***********************************************************************/
00128 #ifndef ST_COORDINATE_TRANSFORM_HH
00129 #define ST_COORDINATE_TRANSFORM_HH
00130 
00131 #include <stdlib.h>
00132 // SCL
00133 #include "StGlobals.hh"
00134 #include "SystemOfUnits.h"
00135 #include "StThreeVector.hh"
00136 #include "StTpcDb/StTpcDb.h"
00137 #include "StObject.h"
00138 
00139 //#define DEBUG_TPC 0
00140 //#define idb if(DEBUG_TPC) cout
00141 #include "StTpcPadCoordinate.hh"
00142 #include "StTpcLocalCoordinate.hh"
00143 #include "StTpcLocalSectorCoordinate.hh"
00144 #include "StTpcLocalSectorAlignedCoordinate.hh"
00145 #include "StGlobalCoordinate.hh"
00146 
00147 #include "StTpcLocalDirection.hh"
00148 #include "StTpcLocalSectorDirection.hh"
00149 #include "StTpcLocalSectorAlignedDirection.hh"
00150 #include "StGlobalDirection.hh"
00151   // pad              => sector12       =>   subsector => sector => tpc      => global
00152   // TpcPadCoordinate => TpcSectL => TpcSectLAligned => TpcLocal => Global
00153 class StTpcCoordinateTransform {//: public StObject {
00154 public:
00155   StTpcCoordinateTransform(StTpcDb* globalDbPointer=0);
00156   ~StTpcCoordinateTransform() {}
00157   //      Raw Data          <--> Tpc Local Sector Coordinates
00158   void  operator()(const StTpcLocalSectorCoordinate& a, StTpcPadCoordinate& b,Bool_t useT0=kTRUE, Bool_t useTau=kTRUE);
00159   void  operator()(const StTpcPadCoordinate& a, StTpcLocalSectorCoordinate& b,Bool_t useT0=kTRUE, Bool_t useTau=kTRUE);
00160   //      Raw Data          <--> Tpc Local  Coordinates
00161   void  operator()(const StTpcLocalCoordinate& a, StTpcPadCoordinate& b,Bool_t useT0=kTRUE, Bool_t useTau=kTRUE) 
00162   {StTpcLocalSectorCoordinate c; this->operator()(a,c); this->operator()(c,b,useT0,useTau);}
00163   void  operator()(const StTpcPadCoordinate& a, StTpcLocalCoordinate& b,Bool_t useT0=kTRUE, Bool_t useTau=kTRUE)
00164   {StTpcLocalSectorCoordinate c; this->operator()(a,c,useT0,useTau); this->operator()(c,b);}
00165   // Tpc Local Sector <--> TPC Local
00166   void  operator()(const        StTpcLocalSectorCoordinate& a, StTpcLocalCoordinate& b           )
00167   {gTpcDbPtr->Pad2Tpc(a.sector(),a.row()).LocalToMaster(a.position().xyz(),b.position().xyz()); b.setSector(a.sector()); b.setRow(a.row());}
00168   void  operator()(const        StTpcLocalSectorCoordinate& a, StTpcLocalSectorAlignedCoordinate& b) {b = a;}
00169   void  operator()(const         StTpcLocalSectorDirection& a, StTpcLocalDirection& b            )
00170   {gTpcDbPtr->Pad2Tpc(a.sector(),a.row()).LocalToMasterVect(a.position().xyz(),b.position().xyz()); b.setSector(a.sector()); b.setRow(a.row());}
00171   void  operator()(const         StTpcLocalSectorDirection& a, StTpcLocalSectorAlignedDirection& b)   {b = a;}
00172   void  operator()(const        StTpcLocalSectorCoordinate& a, StGlobalCoordinate& b)  
00173   {gTpcDbPtr->Pad2Glob(a.sector(),a.row()).LocalToMaster(a.position().xyz(),b.position().xyz());}
00174   void  operator()(const  StTpcLocalSectorDirection& a, StGlobalDirection& b) 
00175   {gTpcDbPtr->Pad2Glob(a.sector(),a.row()).LocalToMasterVect(a.position().xyz(),b.position().xyz());}
00176 
00177   void  operator()(const              StTpcLocalCoordinate& a, StTpcLocalSectorCoordinate& b     ) 
00178   {gTpcDbPtr->Pad2Tpc(a.sector(),a.row()).MasterToLocal(a.position().xyz(),b.position().xyz()); b.setSector(a.sector()); b.setRow(a.row());}
00179   void  operator()(const               StTpcLocalDirection& a, StTpcLocalSectorDirection& b      )
00180   {gTpcDbPtr->Pad2Tpc(a.sector(),a.row()).MasterToLocalVect(a.position().xyz(),b.position().xyz()); b.setSector(a.sector()); b.setRow(a.row());}
00181   void  operator()(const               StGlobalCoordinate& a,StTpcLocalSectorCoordinate& b,Int_t sector, Int_t row)
00182   {gTpcDbPtr->Pad2Glob(sector,row).MasterToLocal(a.position().xyz(),b.position().xyz()); b.setSector(sector); b.setRow(row);}
00183   void  operator()(const  StGlobalDirection& a,StTpcLocalSectorDirection& b,Int_t sector, Int_t row)
00184   {gTpcDbPtr->Pad2Glob(sector,row).MasterToLocalVect(a.position().xyz(),b.position().xyz()); b.setSector(sector); b.setRow(row);}
00185   // Internal TpcCoordinate <-->  Global Coordinate
00186   void  operator()(const StTpcLocalCoordinate& a, StGlobalCoordinate& b)
00187   {gTpcDbPtr->Tpc2GlobalMatrix().LocalToMaster(a.position().xyz(),b.position().xyz());}
00188   void  operator()(const StGlobalCoordinate& a, StTpcLocalCoordinate& b,Int_t sector, Int_t row)
00189   {gTpcDbPtr->Tpc2GlobalMatrix().MasterToLocal(a.position().xyz(),b.position().xyz()); b.setSector(sector); b.setRow(row);}
00190   void  operator()(const StTpcLocalDirection& a, StGlobalDirection& b)
00191   {gTpcDbPtr->Tpc2GlobalMatrix().LocalToMasterVect(a.position().xyz(),b.position().xyz());}
00192   void  operator()(const StGlobalDirection& a, StTpcLocalDirection& b,Int_t sector, Int_t row)
00193   {gTpcDbPtr->Tpc2GlobalMatrix().MasterToLocalVect(a.position().xyz(),b.position().xyz()); b.setSector(sector); b.setRow(row);}
00194   //      Raw Data          <-->  Global Coordinate
00195   void  operator()(const StTpcPadCoordinate& a, StGlobalCoordinate& b,Bool_t useT0=kTRUE, Bool_t useTau=kTRUE) 
00196   {StTpcLocalCoordinate c; this->operator()(a,c,useT0,useTau); this->operator()(c,b);}
00197   void  operator()(const StGlobalCoordinate& a, StTpcPadCoordinate& b,Int_t sector, Int_t row, Bool_t useT0=kTRUE, Bool_t useTau=kTRUE)
00198   {StTpcLocalCoordinate c; this->operator()(a,c,sector,row); this->operator()(c,b,useT0,useTau);}
00199   void  operator()(const StGlobalCoordinate& a, StTpcPadCoordinate& b) {
00200     StTpcLocalCoordinate c; gTpcDbPtr->Tpc2GlobalMatrix().MasterToLocal(a.position().xyz(),c.position().xyz());
00201     Int_t sector = sectorFromCoordinate(c.position());
00202     StThreeVector<double> d;
00203     gTpcDbPtr->SupS2Tpc(sector).MasterToLocal(c.position().xyz(),d.xyz());
00204     Int_t row   = rowFromLocal(d);
00205     this->operator()(a,b,sector,row,kTRUE,kTRUE);
00206   }
00207   Double_t   tBFromZ(Double_t z, Int_t sector, Int_t row) const;
00208   Double_t  zFromTB(Double_t tb, Int_t sector, Int_t row) const;
00209   // Transformation Routines!!
00210   // Raw Data (pad row timebin or drift L From tpc local sector Coordinates
00211   Int_t       rowFromLocal(const StThreeVector<Double_t>& a)         const;
00212   Double_t    padFromLocal(const StThreeVector<Double_t>& a, Int_t row)  const {return padFromX(a.x(), row);}
00213   Double_t    padFromX(Double_t x, Int_t row)                        const; 
00214   Int_t       rowFromLocal(const StTpcLocalSectorCoordinate& a)      const {return rowFromLocal(a.position());}
00215   Double_t    padFromLocal(const StTpcLocalSectorCoordinate& a)      const {return padFromLocal(a.position(),a.row());}
00216   // tpc local sector Coordinates from Raw Data
00217   StThreeVector<Double_t> xyFromRow(const StTpcPadCoordinate& a) {return StThreeVector<Double_t> (xFromPad(a.row(),a.pad()),yFromRow(a.row()),0);}
00218   Double_t                yFromRow(Int_t row)                        const {return (gTpcDbPtr->PadPlaneGeometry()->radialDistanceAtRow(row));}
00219   Double_t                xFromPad(Int_t row, Double_t pad)          const {    // x coordinate in sector 12
00220     Double_t pitch = (row<14) ? gTpcDbPtr->PadPlaneGeometry()->innerSectorPadPitch() : gTpcDbPtr->PadPlaneGeometry()->outerSectorPadPitch();
00221     return -pitch*(pad - (gTpcDbPtr->PadPlaneGeometry()->numberOfPadsAtRow(row)+1.)/2.);
00222   }
00223 // sector from Tpc local coordinates
00224   Int_t sectorFromCoordinate(const StThreeVector<double>& a) const{
00225     Double_t angle = TMath::RadToDeg()*TMath::ATan2(a.y(),a.x());
00226     if(angle<0) angle+= 360;
00227     Int_t sectorNumber= (int)( (angle+15)/30);
00228     if(a.z()>0){sectorNumber=15-sectorNumber; if(sectorNumber> 12)sectorNumber-=12;}
00229     else       {sectorNumber+=9;              if(sectorNumber<=12)sectorNumber+=12;}
00230     return sectorNumber;
00231   }
00232 private:
00233   StTpcDb*    gTpcDbPtr; 
00234   Double_t    mTimeBinWidth;
00235   Double_t    mInnerSectorzOffset; 
00236   Double_t    mOuterSectorzOffset; 
00237   Int_t       mNoOfInnerRows;
00238   Int_t       mNoOfRows;
00239   
00240   //  ClassDef(StTpcCoordinateTransform,0) //
00241 };
00242 
00243 #endif
00244 
00245 
00246