00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050 #include "StTpcRawData.h"
00051 #include "Riostream.h"
00052 #include <assert.h>
00053 #include "TMath.h"
00054 #include "StDaqLib/TPC/trans_table.hh"
00055 #include "StDetectorDbMaker/St_tpcPadPlanesC.h"
00056 ClassImp(StTpcDigitalSector);
00057 ClassImp(StTpcRawData);
00058
00059 StTpcDigitalSector::StTpcDigitalSector(void *db) {
00060 StDigitalTimeBins timeBins;
00061 mNoRows = St_tpcPadPlanesC::instance()->padRows();
00062 for(Int_t row=1; row <= mNoRows; row++) {
00063 StDigitalPadRow padRow;
00064 for (Int_t pad = 0; pad < numberOfPadsAtRow(row); pad++) {
00065 padRow.push_back( timeBins);
00066 }
00067 mData.push_back(padRow);
00068 }
00069 }
00070
00071 void StTpcDigitalSector::clear() {
00072 for(UInt_t row=0; row<mData.size(); row++) {
00073 for(UInt_t ipad=0; ipad<mData[row].size(); ipad++) {
00074 mData[row][ipad].clear();
00075 }
00076 }
00077 }
00078
00079 void StTpcDigitalSector::assignTimeBins(Int_t rowN, Int_t padN, StDigitalTimeBins* tbins) {
00080 assert( (rowN >= 1 && rowN <= mNoRows ) ||
00081 (padN >= 1 && padN <= numberOfPadsAtRow(rowN)));
00082 StDigitalPadRow &Row = mData[(rowN-1)];
00083 StDigitalTimeBins &Pad = Row[(padN-1)];
00084 if (Pad.size() > 0) Pad.clear();
00085 Pad.swap(*tbins);
00086 }
00087
00088 Int_t StTpcDigitalSector::cleanup() {
00089 UInt_t numberOfEmptyRows=0;
00090 for (UInt_t iRow=0; iRow<mData.size(); iRow++) {
00091 UInt_t numberOfEmptyPads=0;
00092 for (UInt_t iPad=0; iPad<mData[iRow].size(); iPad++) {
00093 if (mData[iRow][iPad].size()<7) {
00094 mData[iRow][iPad].clear();
00095 numberOfEmptyPads++;
00096 }
00097 }
00098 if (numberOfEmptyPads == mData[iRow].size()) {
00099 mData[iRow].clear();
00100 numberOfEmptyRows++;
00101 }
00102 }
00103
00104 if (numberOfEmptyRows==mData.size()) return 1;
00105 else return 0;
00106 }
00107
00108 Int_t StTpcDigitalSector::getSequences(Int_t row, Int_t pad, Int_t *nSeq, StSequence** Seq, UShort_t ***Ids) {
00109 *Seq=0;
00110 if (Ids) *Ids=0;*nSeq=0;
00111 mSequence.clear();
00112 mIds.clear();
00113 StDigitalTimeBins* TrsPadData = timeBinsOfRowAndPad(row,pad);
00114 if (!TrsPadData) return 1;
00115 StDigitalTimeBins &trsPadData = *TrsPadData;
00116 Int_t nTimeBins = trsPadData.size();
00117 if (!nTimeBins) return 2;
00118
00119 StSequence aSequence;
00120 static UChar_t ADCs[__MaxNumberOfTimeBins__];
00121 static UShort_t IDTs[__MaxNumberOfTimeBins__];
00122 getTimeAdc(row,pad,ADCs, IDTs);
00123
00124 for (Int_t ibin=0;ibin<nTimeBins;ibin++) {
00125 aSequence.length = trsPadData[ibin].size();
00126 if (aSequence.length > 31) aSequence.length = 31;
00127 aSequence.startTimeBin = trsPadData[ibin].time();
00128 aSequence.firstAdc = &ADCs[aSequence.startTimeBin];
00129 mSequence.push_back(aSequence);
00130 mIds.push_back(&IDTs[aSequence.startTimeBin]);
00131 }
00132 *nSeq = mSequence.size();
00133 *Seq = &mSequence[0];
00134 if (Ids) *Ids = &mIds[0];
00135 return 0;
00136 }
00137
00138 Int_t StTpcDigitalSector::getPadList(Int_t row, UChar_t **padList) {
00139 mPadList.clear();
00140 assert( row>=1 && row <=mNoRows);
00141
00142 for(Int_t ii = 1; ii <= numberOfPadsAtRow(row); ii++) {
00143 if (numberOfTimeBins(row,ii) > 0) {
00144 mPadList.push_back(ii);
00145 }
00146 }
00147 *padList = &mPadList[0];
00148 return mPadList.size();
00149 }
00150
00151 Int_t StTpcDigitalSector::putTimeAdc(Int_t row, Int_t pad, Short_t *ADCs, UShort_t *IDTs) {
00152 Int_t ntimebins = 0;
00153 StDigitalTimeBins digPadData;
00154 Int_t tbC = -999;
00155 for (Int_t tb = 0; tb < __MaxNumberOfTimeBins__; tb++) {
00156 if (! ADCs[tb]) continue;
00157 if (tb != tbC+1) digPadData.push_back(StDigitalPair(tb));
00158 tbC = tb;
00159 if (IDTs) digPadData.back().add(ADCs[tb],IDTs[tb]);
00160 else digPadData.back().add(ADCs[tb]);
00161 ntimebins++;
00162 }
00163 if (ntimebins) assignTimeBins(row,pad,&digPadData);
00164 return ntimebins;
00165 }
00166
00167 Int_t StTpcDigitalSector::putTimeAdc(Int_t row, Int_t pad, UChar_t *ADCs, UShort_t *IDTs) {
00168 Int_t ntimebins = 0;
00169 StDigitalTimeBins digPadData;
00170 Int_t tbC = -999;
00171 for (Int_t tb = 0; tb < __MaxNumberOfTimeBins__; tb++) {
00172 if (! ADCs[tb]) continue;
00173 if (tb != tbC+1) digPadData.push_back(StDigitalPair(tb));
00174 tbC = tb;
00175 Short_t adc = log8to10_table[ADCs[tb]];
00176 if (IDTs) digPadData.back().add(adc,IDTs[tb]);
00177 else digPadData.back().add(adc);
00178 ntimebins++;
00179 }
00180 assignTimeBins(row,pad,&digPadData);
00181 return ntimebins;
00182 }
00183
00184 Int_t StTpcDigitalSector::getTimeAdc(Int_t row, Int_t pad,
00185 Short_t ADCs[__MaxNumberOfTimeBins__],
00186 UShort_t IDTs[__MaxNumberOfTimeBins__]) {
00187
00188 UInt_t nTimeSeqs = 0;
00189 memset (ADCs, 0, __MaxNumberOfTimeBins__*sizeof(Short_t));
00190 memset (IDTs, 0, __MaxNumberOfTimeBins__*sizeof(UShort_t));
00191 StDigitalTimeBins* TrsPadData = timeBinsOfRowAndPad(row,pad);
00192 if (! TrsPadData) return nTimeSeqs;
00193 StDigitalTimeBins &trsPadData = *TrsPadData;
00194 nTimeSeqs = trsPadData.size();
00195 if (! nTimeSeqs) return nTimeSeqs;
00196 for (UInt_t i = 0; i < nTimeSeqs; i++) {
00197 StDigitalPair &digPair = trsPadData[i];
00198 UInt_t ntbk = digPair.size();
00199 UInt_t tb = digPair.time();
00200 UInt_t isIdt= digPair.isIdt();
00201 for (UInt_t j = 0; j < ntbk; j++, tb++) {
00202 ADCs[tb] = digPair.adc()[j];
00203 if (isIdt) IDTs[tb] = digPair.idt()[j];
00204 }
00205 }
00206 return nTimeSeqs;
00207 }
00208
00209 Int_t StTpcDigitalSector::getTimeAdc(Int_t row, Int_t pad,
00210 UChar_t ADCs[__MaxNumberOfTimeBins__],
00211 UShort_t IDTs[__MaxNumberOfTimeBins__]) {
00212
00213
00214 UInt_t nTimeSeqs = 0;
00215 memset (ADCs, 0, __MaxNumberOfTimeBins__*sizeof(UChar_t));
00216 memset (IDTs, 0, __MaxNumberOfTimeBins__*sizeof(UShort_t));
00217 StDigitalTimeBins* TrsPadData = timeBinsOfRowAndPad(row,pad);
00218 if (! TrsPadData) return nTimeSeqs;
00219 StDigitalTimeBins &trsPadData = *TrsPadData;
00220 nTimeSeqs = trsPadData.size();
00221 if (! nTimeSeqs) return nTimeSeqs;
00222 for (UInt_t i = 0; i < nTimeSeqs; i++) {
00223 StDigitalPair &digPair = trsPadData[i];
00224 UInt_t ntbk = digPair.size();
00225 UInt_t tb = digPair.time();
00226 UInt_t isIdt= digPair.isIdt();
00227 for (UInt_t j = 0; j < ntbk; j++, tb++) {
00228 if (digPair.adc()[j] <= 0) continue;
00229 ADCs[tb] = log10to8_table[digPair.adc()[j]];
00230 if (isIdt) IDTs[tb] = digPair.idt()[j];
00231 }
00232 }
00233 return nTimeSeqs;
00234 }
00235
00236 Int_t StTpcDigitalSector::PrintTimeAdc(Int_t row, Int_t pad) const {
00237 UInt_t nTimeSeqs = 0;
00238 const StDigitalTimeBins* TrsPadData = timeBinsOfRowAndPad(row,pad);
00239 if (! TrsPadData) return nTimeSeqs;
00240 const StDigitalTimeBins &trsPadData = *TrsPadData;
00241 nTimeSeqs = trsPadData.size();
00242 if (! nTimeSeqs) return nTimeSeqs;
00243 cout << "Time/Adc/IdTruth for row " << row << "\tpad " << pad << endl;
00244 for (UInt_t i = 0; i < nTimeSeqs; i++) {
00245 StDigitalPair digPair = trsPadData[i];
00246 UInt_t ntbk = digPair.size();
00247 UInt_t tb = digPair.time();
00248 for (UInt_t j = 0; j < ntbk; j++, tb++) {
00249 if (digPair.adc()[j] <= 0) continue;
00250 cout << "\t" << tb << "\t" << digPair.adc()[j] << "\t" << digPair.idt()[j] << endl;
00251 }
00252 }
00253 return nTimeSeqs;
00254 }
00255
00256 StTpcDigitalSector &StTpcDigitalSector::operator+= (StTpcDigitalSector& v) {
00257 static Short_t ADCs1[__MaxNumberOfTimeBins__], ADCs2[__MaxNumberOfTimeBins__];
00258 static UShort_t IDTs1[__MaxNumberOfTimeBins__], IDTs2[__MaxNumberOfTimeBins__];
00259 for (Int_t row = 1; row <= mNoRows; row++) {
00260 Int_t npad2 = v.numberOfPadsInRow(row);
00261 if (! npad2) continue;
00262 for (Int_t pad = 1; pad <= numberOfPadsAtRow(row); pad++) {
00263 Int_t ntb2 = v.numberOfTimeBins(row,pad);
00264 if (! ntb2) continue;
00265 Int_t ntb1 = numberOfTimeBins(row,pad);
00266 if (! ntb1) {
00267 StDigitalTimeBins tbins2 = *v.timeBinsOfRowAndPad(row,pad);
00268 assignTimeBins(row,pad,&tbins2);
00269 continue;
00270 }
00271 getTimeAdc(row,pad,ADCs1,IDTs1);
00272 v.getTimeAdc(row,pad,ADCs2,IDTs2);
00273 Bool_t ifIDT = false;
00274 for (Int_t i = 0; i < __MaxNumberOfTimeBins__; i++) {
00275 if (! ifIDT && (IDTs1[i] || IDTs2[i])) ifIDT = true;
00276 if ((IDTs1[i] || IDTs2[i]) && ADCs1[i] < ADCs2[i]) IDTs1[i] = IDTs2[i];
00277 ADCs1[i] += ADCs2[i];
00278 }
00279 if (ifIDT) putTimeAdc(row, pad, ADCs1, IDTs1);
00280 else putTimeAdc(row, pad, ADCs1);
00281 }
00282 }
00283 return *this;
00284 }
00285
00286 StTpcDigitalSector &StTpcDigitalSector::operator= (const StTpcDigitalSector& v) {
00287 for (Int_t row = 1; row <= mNoRows; row++) {
00288 Int_t npad2 = v.numberOfPadsInRow(row);
00289 if (! npad2) continue;
00290 for (Int_t pad = 1; pad <= numberOfPadsAtRow(row); pad++) {
00291 Int_t ntb2 = v.numberOfTimeBins(row,pad);
00292 if (! ntb2) continue;
00293 StDigitalTimeBins tbins2 = *v.timeBinsOfRowAndPad(row,pad);
00294 assignTimeBins(row,pad,&tbins2);
00295 continue;
00296 }
00297 }
00298 return *this;
00299 }
00300
00301 void StTpcDigitalSector::Print(const Option_t *opt) const {
00302 TString Opt(opt);
00303 for (Int_t row = 1; row <= mNoRows; row++) {
00304
00305 Int_t npads = numberOfPadsInRow(row);
00306 for (Int_t pad = 1; pad <= npads; pad++) {
00307
00308 Int_t ntb = numberOfTimeBins(row,pad);
00309 if (! ntb) continue;
00310 cout << "sector/row/pad = " << mSector << "/" << row << "/" << pad << " = " << ntb << " time sequences" << endl;
00311 if (Opt.Contains("all",TString::kIgnoreCase)) PrintTimeAdc(row,pad);
00312 }
00313 }
00314 }
00315
00316 void StTpcRawData::setSector(UInt_t sector, StTpcDigitalSector* digitSector) {
00317 if (sector > 0 && sector <= mSectors.size()) {
00318 if (mSectors[sector-1]) delete mSectors[sector-1];
00319 digitSector->setSector(sector);
00320 mSectors[sector-1] = digitSector;
00321 }
00322 }
00323
00324 void StTpcRawData::Clear(const Option_t*) {
00325 for (UInt_t ii=0; ii<mSectors.size(); ii++) {SafeDelete(mSectors[ii]);}
00326 }
00327
00328 Int_t StTpcRawData::getVecOfPixels(StVectPixel &pixels, Int_t sector, Int_t row, Int_t padMin, Int_t padMax, Int_t tMin, Int_t tMax) {
00329 pixels.clear();
00330 StTpcDigitalSector *s = GetSector(sector);
00331 if (s) {
00332 static Short_t ADCs[__MaxNumberOfTimeBins__];
00333 static UShort_t IDTs[__MaxNumberOfTimeBins__];
00334 Int_t npads = s->numberOfPadsInRow(row);
00335 if (npads) {
00336 if (padMin < 1) padMin = 1;
00337 if (padMax < padMin) padMax = s->numberOfPadsAtRow(row);
00338 if (tMin < 0) tMin = 0;
00339 if (tMax < tMin) tMax = __MaxNumberOfTimeBins__ - 1;
00340 tMax = TMath::Min(tMax, __MaxNumberOfTimeBins__ - 1);
00341 for (Int_t pad = padMin; pad <= padMax; pad++) {
00342 Int_t ntbs = s->numberOfTimeBins(row,pad);
00343 if (ntbs) {
00344 s->getTimeAdc(row,pad,ADCs,IDTs);
00345 for (Int_t tb = tMin; tb <= tMax; tb++) {
00346 if (ADCs[tb]) pixels.push_back(StTpcPixel(kTpcId,sector,row,pad,tb,ADCs[tb],IDTs[tb],0));
00347 }
00348 }
00349 }
00350 }
00351 }
00352 return pixels.size();
00353 }
00354
00355 void StTpcRawData::Print(const Option_t *opt) const {
00356 Int_t N = ((StTpcRawData *) this)->size();
00357 for (Int_t i = 0; i < N; i++) {
00358 StTpcDigitalSector *sector = ((StTpcDigitalSector* )mSectors[i]);
00359 if (sector) sector->Print(opt);
00360 }
00361 }
00362
00363 StTpcRawData &StTpcRawData::operator+= (StTpcRawData& v) {
00364 for (Int_t sec = 1; sec <= 24; sec++) {
00365 StTpcDigitalSector *a = getSector(sec);
00366 StTpcDigitalSector *b = v.getSector(sec);
00367 if (!b ) continue;
00368 if (!a) {
00369 a = new StTpcDigitalSector();
00370 *a = *b;
00371 setSector(sec, a);
00372 continue;
00373 }
00374 *a += *b;
00375 }
00376 return *this;
00377 }
