StRoot: StEvent/StTpcRawData.h Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StTpcRawData.h,v 2.9 2012/05/07 14:41:59 fisyak Exp $
00004  *
00005  * Author: Yuri Fisyak, Mar 2008
00006  ***************************************************************************
00007  *
00008  * Description:
00009  *
00010  ***************************************************************************
00011  *
00012  * $Log: StTpcRawData.h,v $
00013  * Revision 2.9  2012/05/07 14:41:59  fisyak
00014  * Remove hardcoded separation between Inner and Outer Sectors
00015  *
00016  * Revision 2.8  2011/03/31 19:27:47  fisyak
00017  * Add more safety for work with pixel data
00018  *
00019  * Revision 2.7  2009/11/23 22:20:51  ullrich
00020  * Minor cleanup performed, fixed compiler warnings.
00021  *
00022  * Revision 2.6  2009/10/12 23:52:32  fisyak
00023  * Fix relation npad from pad row
00024  *
00025  * Revision 2.5  2008/07/31 20:47:27  fisyak
00026  * Modify operator += and =
00027  *
00028  * Revision 2.4  2008/06/20 14:56:34  fisyak
00029  * Add protection for pad no.
00030  *
00031  * Revision 2.3  2008/05/27 14:40:08  fisyak
00032  * keep pixel raw data as short istead of uchar
00033  *
00034  * Revision 2.2  2008/04/24 16:06:25  fisyak
00035  * Clean up before next move
00036  *
00037  * Revision 2.1  2008/03/13 16:42:24  ullrich
00038  * Initial Revision
00039  *
00040  **************************************************************************/
00041 #ifndef StTpcRawData_h
00042 #define StTpcRawData_h
00043 
00044 #include "StObject.h"
00045 #include <vector>
00046 #include <utility>
00047 #include "StSequence.hh"
00048 #include "StTpcPixel.h"
00049 #include "StDetectorDbMaker/St_tpcPadPlanesC.h"
00050 #define __MaxNumberOfTimeBins__ 512
00051 typedef std::vector<Short_t>  StVectorADC;
00052 typedef std::vector<UShort_t> StVectorIDT;
00053 
00054 class StDigitalPair {
00055 public:
00056     StDigitalPair(UShort_t time=0)      {mTime=time;}
00057     virtual ~StDigitalPair() {}
00058     void add(Short_t adc)               {mAdc.push_back(adc);}
00059     void add(Short_t adc,Int_t idt)     {mAdc.push_back(adc); mIdt.push_back(idt);}
00060     
00061     Short_t* adc()   const {return (Short_t*)&mAdc[0];}                 
00062     Bool_t   isIdt() const {return mAdc.size() == mIdt.size();}
00063     UShort_t*idt()   const {return (UShort_t*) (isIdt() ? &mIdt[0] : 0);}                       
00064     Int_t    size()  const {return mAdc.size();}
00065     UShort_t time()  const {return mTime;}
00066 
00067 private:
00068     UShort_t    mTime;
00069     StVectorADC mAdc;
00070     StVectorIDT mIdt; 
00071 };
00072 
00073 typedef std::vector<StDigitalPair>           StDigitalTimeBins;
00074 typedef std::vector<StDigitalTimeBins>       StDigitalPadRow;
00075 typedef std::vector<StDigitalPadRow>         StDigitalSector;
00076 
00077 typedef std::vector<StDigitalPair>::iterator StDigitalTimeBinIterator;
00078 typedef StDigitalTimeBins::iterator          StDigitalTimeBinsIterator;
00079 typedef StDigitalPadRow::iterator            StDigitalPadRowIterator;
00080 typedef StDigitalSector::iterator            StDigitalRowIterator;
00081 
00082 typedef std::vector<StSequence>              StVecSequence;
00083 typedef std::vector<UShort_t*>               StVecIds;
00084 typedef std::vector<UChar_t>                 StVecPads;
00085 typedef std::vector<UChar_t>                   StVecUChar;
00086 typedef std::vector<Int_t>                     StVecInt;
00087 typedef std::vector<StTpcPixel>              StVectPixel;
00088 
00089 class StTpcDigitalSector : public StObject {
00090 public:
00091     StTpcDigitalSector(void *db = 0);
00092     virtual ~StTpcDigitalSector() {}
00093     // access functions
00094     const StDigitalTimeBins* timeBinsOfRowAndPad(Int_t rowN, Int_t padN) const { return (&mData[(rowN-1)][(padN-1)]);}
00095     StDigitalTimeBins*       timeBinsOfRowAndPad(Int_t rowN, Int_t padN)       { return (&mData[(rowN-1)][(padN-1)]);}
00096     StDigitalPadRow*         padsOfRow(Int_t rowN)                             { return (&mData[(rowN-1)]);}
00097     StDigitalSector*         rows()                                            { return (&mData);}
00098     
00099     Int_t  numberOfRows()                               const    { return mData.size();}
00100     Int_t  numberOfPadsInRow(Int_t rowN)                const    { return mData[(rowN-1)].size();}
00101     Int_t  numberOfTimeBins(Int_t rowN, Int_t padN)     const    { return mData[(rowN-1)][(padN-1)].size();}
00102     
00103     // Adding
00104     void   assignTimeBins(int, int, StDigitalTimeBins*);
00105     Int_t  getSequences(Int_t row, Int_t pad, Int_t *nSeq, StSequence** seq, UShort_t ***Id);
00106     Int_t  getPadList(Int_t row, UChar_t **padList);
00107     Int_t  getTimeAdc(Int_t row, Int_t pad, Short_t ADCs[__MaxNumberOfTimeBins__], 
00108                       UShort_t IDTs[__MaxNumberOfTimeBins__]); // with  8 => 10 conversion
00109     Int_t  getTimeAdc(Int_t row, Int_t pad, UChar_t  ADCs[__MaxNumberOfTimeBins__], 
00110                       UShort_t IDTs[__MaxNumberOfTimeBins__]);
00111     Int_t  putTimeAdc(Int_t row, Int_t pad, Short_t *ADCs, UShort_t *IDTs = 0);     // with 10 =>  8 conversion
00112     Int_t  putTimeAdc(Int_t row, Int_t pad, UChar_t  *ADCs, UShort_t *IDTs = 0);
00113     void   setSector(Int_t sector) {mSector = sector;} 
00114     void   clear();
00115     Int_t  cleanup();
00116     virtual void   Print(const Option_t *opt="") const;
00117     virtual Int_t  PrintTimeAdc(Int_t row, Int_t pad) const;
00118     StTpcDigitalSector &operator+= (StTpcDigitalSector& v);
00119     Int_t numberOfPadsAtRow(Int_t row) {return (row > 0 && row <= mNoRows) ? St_tpcPadPlanesC::instance()->padsPerRow(row) : 0;}
00120     StTpcDigitalSector& operator=(const StTpcDigitalSector&);
00121 private:
00122     StTpcDigitalSector(const StTpcDigitalSector&);
00123 
00124 private:
00125     StDigitalSector       mData;
00126     Int_t                 mSector;
00127     StVecPads             mPadList;
00128     StVecSequence         mSequence;
00129     StVecIds              mIds;
00130     Int_t                 mNoRows;
00131     ClassDef(StTpcDigitalSector,2)
00132 };
00133 
00134 class StTpcRawData : public StObject {
00135 public:
00136     StTpcRawData(Int_t noSectors = 24) {setNoSectors(noSectors);}
00137     virtual ~StTpcRawData() {clear();}
00138     UInt_t size() {return mSectors.size();}
00139     UInt_t getNoSectors() {return size();}
00140     StTpcDigitalSector *GetSector(UInt_t sector) {return sector > 0 && sector <= size() ? mSectors[sector-1] : 0;}
00141     StTpcDigitalSector *getSector(UInt_t sector) {return GetSector(sector);}
00142     Int_t  getVecOfPixels(StVectPixel &pixels, Int_t sector, Int_t row, Int_t padMin = 1, Int_t padMax = -1, 
00143                           Int_t tMin = 0, Int_t tMax = -1);
00144     void   setNoSectors(UInt_t noSectors = 0) {mSectors.resize(noSectors); for (UInt_t i = 0; i < noSectors; i++) mSectors[i] = 0;} 
00145     void   setSector(UInt_t sector, StTpcDigitalSector* digitSector);
00146     void   clear() {Clear();}
00147     void   Clear(const Option_t *opt = ""); 
00148     StTpcRawData &operator+= (StTpcRawData& v);
00149     virtual void Print(const Option_t *opt="") const; 
00150 private:
00151     std::vector<StTpcDigitalSector*> mSectors;
00152     ClassDef(StTpcRawData,1)
00153  };
00154 #endif