StRoot: StEEmcUtil/EEmcSmdMap/EEmcSmdMap.h Source File

00001 #ifndef __EEmcSmdMap__
00002 #define __EEmcSmdMap__
00003 
00004 /*
00005  *
00006  * \class  EEmcSmdMap
00007  * \date   12/02/03
00008  * \author jwebb
00009  *
00010  * This class provides the range of SMD strips which fall within the
00011  * fiducial volume of a specified EEMC tower.  It is designed to access
00012  * a lookup table.  The entries in the table were determined by 
00013  * calculating the crossing point of all SMD U and V strip pairs.  
00014  * Crossing points which fell within the fiducical limits of a given
00015  * tower at a plane centered on the mean-z of the U and V planes
00016  * were used to determine the allowable range of U and V strips.
00017  *
00018  * This class is implemented as a singleton... i.e., get a pointer to
00019  * the class by EEmcSmdMap *map = EEmcSmdMap::instance(), instead of
00020  * calling the constructor.
00021  *
00022  * Usage:
00023  *
00024  * EEmcSmdMap *map = EEmcSmdMap::instance();
00025  * Int_t uMin,uMax,vMin,vMax;
00026  * map -> getRangeU( sector, subsector, etabin, uMin, uMax); // all arguements
00027  * map -> getRangeV( sector, subsector, etabin, vMin, vMax); // indexed from 0
00028  *
00029  * Int_t iuv;
00030  * map -> getRange( sector, subsector, etabin, iuv, vMin, vMax); // to be retired due to nonunique name, see below,JB
00031  * map -> getRangeTw2Smd( isector, isubsector, ietabin, iuv, ivMin, ivMax); 
00032  *
00033  * map -> getRangeSmd2Smd( isector, iuv, istrip, juv, jMin, jMax);  
00034  * returns range of strips from the other plane , all counts from 0.   
00035  * Input: arguments with prefix 'i', output with prefix 'j'
00036  *
00037  * Limitations:
00038  *
00039  * 1. Strip ranges are approximate and should not be trusted to more
00040  *    than two or three strips.  This should be sufficient for most 
00041  *    purposes.
00042  *
00043  * 2. Only U-V planes which are nominally within a given sector are
00044  *    considered.  In other words, this class does not currently 
00045  *    provide any information on strips which overlap from adjacent
00046  *    sectors near the tie-rods.
00047  *
00048  */
00049 
00050 #include <TObject.h>
00051 #include <TString.h>
00052 
00053 #include <vector>
00054 #include <assert.h>
00055 
00056 #include "StEEmcUtil/EEmcGeom/EEmcGeomDefs.h"
00057 class EEmcStrip2StripMapItem;
00058 
00059 //-- Structure to map strip ranges to towers --
00060 struct EEmcStripMapItem {
00061   const Char_t *tower;
00062   Int_t   uMin;   // minimum u strip, all indexed from 0
00063   Int_t   uMax;   // maximum u strip
00064   Int_t   vMin;   // minimum v strip
00065   Int_t   vMax;   // maximum v strip
00066 };
00067 
00068 //-- Maps towers to individual strips --
00069 struct EEmcTowerMapItem  {
00070  EEmcTowerMapItem() : nTower(0) {}
00071   Int_t                nTower;    // Number of towers which match strip
00072   std::vector<TString> towers;    // [nTower] array of tower names, eg 01TA01
00073   std::vector<Int_t>   sector;    // [nTower] array of sectors
00074   std::vector<Int_t>   subsector; // [nTower] array of subsectors
00075   std::vector<Int_t>   etabin;    // [nTower] array of etabins
00076 };
00077 
00078 
00079 
00080 class EEmcSmdMap : public TObject 
00081 {
00082 public:
00083 
00084   EEmcSmdMap();
00085   virtual ~EEmcSmdMap(){ /* nada */ };
00086   
00087   // return the single instance of this class
00088   static EEmcSmdMap *instance();
00089 
00091   //
00092   // Get min and max strips in each orientation which
00093   //   match the given tower.  All arguements are c++
00094   //   indices (i.e. sector runs from 0-11 not 1-12).
00095   //
00096   // Min and max returned via reference.
00097   //
00098   void getRangeU( Int_t sector,  
00099                   Int_t subsector,  
00100                   Int_t etabin,  
00101                   Int_t &uMin,
00102                   Int_t &uMax ) const {
00103     
00104     uMin = mSmdMap[sector][subsector][etabin].uMin;
00105     uMax = mSmdMap[sector][subsector][etabin].uMax;
00106     
00107   }
00108   void getRangeV( Int_t sector,  
00109                   Int_t subsector,  
00110                   Int_t etabin,  
00111                   Int_t &vMin,
00112                   Int_t &vMax ) const {
00113 
00114     vMin = mSmdMap[sector][subsector][etabin].vMin;
00115     vMax = mSmdMap[sector][subsector][etabin].vMax;
00116 
00117   }
00118   // Min and max returned via reference.
00119   //
00120   
00121   void getRangeTw2Smd ( Int_t sector,  
00122                   Int_t subsector,  
00123                   Int_t etabin,  
00124                   Int_t iuv,
00125                   Int_t &Min,
00126                   Int_t &Max ) const {
00127     switch(iuv) {
00128     case 0: return getRangeU( sector, subsector, etabin, Min, Max);
00129     case 1: return getRangeV( sector, subsector, etabin, Min, Max);
00130     default: {assert(2==3);} 
00131     }
00132   }
00133 
00134   // to be retired seeon,JB
00135   void getRange ( Int_t sector,  
00136                   Int_t subsector,  
00137                   Int_t etabin,  
00138                   Int_t iuv,
00139                   Int_t &Min,
00140                   Int_t &Max ) const {
00141     getRangeTw2Smd (sector, subsector, etabin, iuv, Min, Max); 
00142   }
00143   
00144   // Central strip(s) returned vis reference.
00145   //
00146   void getMiddleU ( Int_t sector,
00147                     Int_t subsector,
00148                     Int_t etabin,
00149                     Int_t &umid ) const {
00150     umid = (
00151       mSmdMap[sector][subsector][etabin].uMin +
00152       mSmdMap[sector][subsector][etabin].uMax ) / 2;
00153 
00154   }
00155   void getMiddleV ( Int_t sector,
00156                     Int_t subsector,
00157                     Int_t etabin,
00158                     Int_t &vmid ) const {
00159     vmid = (
00160       mSmdMap[sector][subsector][etabin].vMin +
00161       mSmdMap[sector][subsector][etabin].vMax ) / 2;
00162 
00163   }
00164   //
00166 
00167 
00169   //
00170   // Get min and max strips in the other plane 
00171   //   match the a given strips.  All arguements are c++
00172   //   indices (i.e. sector runs from 0-11 not 1-12).
00173   //
00174   // juv, jMin and jMax returned via reference.
00175   //
00176   void getRangeSmd2Smd( Int_t isector, Int_t iuv, Int_t istrip,
00177                         Int_t &juv, Int_t &jMin, Int_t &jMax ) const;
00178 
00179   //
00181 
00183   //
00184   // Get the number of towers which "belong" to this
00185   // strip.  "sec", "plane" and "strip" are counted
00186   // from 0.
00187   //
00188   Int_t getNTowers( Int_t sec, 
00189                     Int_t plane, 
00190                     Int_t strip ) const { 
00191     return mTowerMap[sec][plane][strip].nTower; 
00192   }
00193 
00194   // For the specified sector, plane and strip (numbered
00195   // from 0), return the "nth" tower's subsector and
00196   // eta bin.
00197   void getTower( Int_t sec, Int_t plane, Int_t strip, 
00198                   Int_t ntow, Int_t &sub, Int_t &eta ) const {
00199     sub = mTowerMap[sec][plane][strip].subsector[ntow];
00200     eta = mTowerMap[sec][plane][strip].etabin[ntow];
00201     return;
00202   }
00203   void getTower( Int_t sec, Int_t plane, Int_t strip, 
00204                   Int_t ntow, Int_t &sub, Int_t &eta, TString &name ) const {
00205     sub  = mTowerMap[sec][plane][strip].subsector[ntow];
00206     eta  = mTowerMap[sec][plane][strip].etabin[ntow];
00207     name = mTowerMap[sec][plane][strip].towers[ntow];
00208     return;
00209   }
00210 
00211 private:
00212 
00213   void InitStrip2Strip();
00214   static EEmcSmdMap *sInstance;
00215  
00216   EEmcStripMapItem mSmdMap[ kEEmcNumSectors ][ kEEmcNumSubSectors ][ kEEmcNumEtas ];
00217   EEmcTowerMapItem mTowerMap[ kEEmcNumSectors ][ kEEmcNumSmdUVs ][ kEEmcNumStrips ];
00218 
00219   enum { mxS=3,mxI=2};
00220 
00221   EEmcStrip2StripMapItem *mSmd2SmdMap[ kEEmcNumSectors][kEEmcNumSmdUVs];
00222   void Init();
00223 
00224   ClassDef(EEmcSmdMap,1);
00225 };
00226 
00227 #endif