StRoot: StDaqLib/TPC/TPCV2P0_ZS

00001 /***************************************************************************
00002  * $Id: TPCV2P0_ZS_SR.cxx,v 1.29 2008/01/20 00:35:42 perev Exp $
00003  * Author: M.J. LeVine
00004  ***************************************************************************
00005  * Description: TPC V2.0 Zero Suppressed Reader
00006  *      
00007  *
00008  *   change log
00009  * 28-May-99 MJL on encountering a missing TPCSEQD bank,
00010  *    tries to fill in the Pad_array structs using the RAW banks (if present)
00011  * 31-May-99 MJL terminate on encountering pad 255
00012  * 03-Jun-99 MJL added return TRUE to TPCV2P0_ZS_SR::initialize()
00013  * 10-Jun-99 IS (Iwona Sakrejda) - The compiler we are using currently in Root
00014  *   cannot contain the scope of the "for" loop index within parenthesis.
00015  *   So if the next loop uses same index, it cannot be Declared again.
00016  *   I made 2 for rcg  and marked them both in  the code.
00017  * 20-Jun-99 MJL corrected Iwona's fix, which depends on the "leak" out of the
00018  *  'for' scope to define the variable elsewhere. At the very least this makes 
00019  *   gdb very confused. Now the offending rcb is defined outside the scope of
00020  *   all for loops
00021  * 21-Jun-99 MJL change behavior on discovering a "bit 5" error. 
00022  *   Now skip sequences
00023  *   until next "switch=1" sequence
00024  * 23-Jun-99 MJL most output now supressed with EventReader.verbose
00025  * 07-Jul-99 MJL if no banks found for a given rcb,mz just skip it. 
00026  *           No longer return FALSE
00027  * 27-Jul-99 MJL init RowSpacePts = 0 to make destructor robust
00028  * 29-Aug-99 MJL #include <Stiostream.h> for HP platform
00029  * 07-Feb-00 MJL add diagnostics when bad cluster data encountered
00030  * 23-Feb-00 MJL fix bug (~line 229) which didn't handle split sequences
00031  *               correctly. Thanks to Herb Ward.
00032  * 24-Feb-00 MJL clean up loop structure, add comments everywhere
00033  * 28-Feb-00 MJL protect against hardware quirks in VRAM
00034  * 29-Feb-00 MJL change loop logic line 220 (test seqCnt, not i)
00035  *
00036  ***************************************************************************
00037  * $Log: TPCV2P0_ZS_SR.cxx,v $
00038  * Revision 1.29  2008/01/20 00:35:42  perev
00039  * Supress redundant print
00040  *
00041  * Revision 1.28  2007/12/24 06:04:33  fine
00042  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00043  *
00044  * Revision 1.27  2004/03/25 21:07:32  ward
00045  * Suppress more debug messages.
00046  *
00047  * Revision 1.26  2004/03/24 18:44:58  ward
00048  * Suppress debug messages.
00049  *
00050  * Revision 1.25  2004/03/10 05:53:08  jeromel
00051  * Left a debug line in (to remove later)
00052  *
00053  * Revision 1.24  2004/03/04 21:51:29  ward
00054  * Replaced MERGE_SEQUENCES with a StDAQMaker chain parameter, as suggested by Landgraf and Lauret.
00055  *
00056  * Revision 1.23  2004/02/03 20:07:18  jml
00057  * added MERGE_SEQUENCES define
00058  *
00059  * Revision 1.22  2003/10/01 20:55:06  ward
00060  * Protection against empty TPCSEQD banks.
00061  *
00062  * Revision 1.21  2003/09/02 17:55:33  perev
00063  * gcc 3.2 updates + WarnOff
00064  *
00065  * Revision 1.20  2000/11/15 21:02:02  ward
00066  * Another .daq corruption check.  It is on the TPCSEQD bank.
00067  *
00068  * Revision 1.19  2000/11/07 16:30:27  ward
00069  * New check for .daq corruption, with kStErr from St_tpcdaq_Maker.
00070  *
00071  * Revision 1.18  2000/07/05 09:17:26  ward
00072  * Fixed a one-off subscripting err & removed ref to a deleted obj.
00073  *
00074  * Revision 1.17  2000/06/22 21:19:16  ward
00075  * added stop<start to bad cluster criteria
00076  *
00077  * Revision 1.16  2000/02/29 20:20:29  levine
00078  * corrected loop logic line 220
00079  *
00080  * Revision 1.15  2000/02/28 22:02:51  levine
00081  * add protection against illegal CPP sequences - was causing unitialized pointers
00082  *
00083  * Revision 1.14  2000/02/08 21:34:06  levine
00084  * added diagnostics for bad cluster pointers
00085  *
00086  * Revision 1.13  2000/01/04 20:55:05  levine
00087  * Implemented memory-mapped file access in EventReader.cxx. Old method
00088  * (via seeks) is still possible by setting mmapp=0 in
00089  *
00090  *      getEventReader(fd,offset,(const char *)logfile,mmapp);
00091  *
00092  *
00093  * but memory-mapped access is much more effective.
00094  *
00095  * Revision 1.12  1999/12/09 02:50:41  levine
00096  * #define changed to get rid of unused fee array defs for TPCv?P0_ZS_SR.cxx
00097  * only
00098  *
00099  * Revision 1.11  1999/12/07 23:10:46  levine
00100  * changes to silence the gcc compiler warnings
00101  *
00102  * Revision 1.10  1999/09/02 21:47:12  fisyak
00103  * HP corrections
00104  *
00105  * Revision 1.9  1999/07/27 23:08:08  levine
00106  * bug fix: initialize RowSpacePts[] =0 to make destructor robust
00107  *
00108  * Revision 1.8  1999/07/21 21:15:41  levine
00109  *
00110  * TPCV2P0_ZS_SR.cxx changed to include the TPCV2P0_ZS_SR::getSpacePts()
00111  * (cluster-finder reader). TPCV1P0_ZS_SR.cxx changed to include empty
00112  * version of the same method.
00113  *
00114  * Revision 1.7  1999/07/07 19:55:43  levine
00115  * Now behaves correctly when encountering a partially populated (e.g., one RB) sector
00116  *
00117  * Revision 1.6  1999/07/02 04:43:24  levine
00118  * Many changes -
00119  *  navigates to head of TPCP bank independent of position.
00120  *  move declarations out of loops where they were upsetting some compilers
00121  *  suppress output from class libraries with run-time switch EventReader.verbose
00122  *  added TPCV2P0_CPP_SR::getAsicParams()
00123  *
00124  *
00125  **************************************************************************/
00126 #include <Stiostream.h>
00127 #include <assert.h>
00128 #include "StDaqLib/GENERIC/EventReader.hh"
00129 #include "TPCV2P0.hh"
00130 
00131 #define MAKE_THE_DAMNED_COMPILER_SILENT
00132 // #define MERGE_SEQUENCES replaced by mMergeSequences, Herb Ward, Mar 4 2004.
00133 
00134 #include "fee_pin.h"
00135 // 
00136 using namespace OLDEVP;
00137 
00138 TPCV2P0_ZS_SR::TPCV2P0_ZS_SR(int s, TPCV2P0_Reader *det, char mergeSequences)
00139 {
00140   assert(mergeSequences==0||mergeSequences==1); 
00141   mMergeSequences=mergeSequences;
00142 
00143   sector   = s-1;               // convert the sector into internal representation
00144   detector = det;
00145   if (detector->ercpy->verbose){
00146     cout << "Constructing TPCV2P0_ZS_SR" << endl
00147          << "  MergeSequence is " << (mMergeSequences?"ON":"OFF") << endl;
00148   }
00149 
00150   // NULLS in banks array
00151   memset((char *)adcd_p, 0, sizeof(adcd_p));
00152   memset((char *)adcx_p, 0, sizeof(adcx_p));
00153   memset((char *)seqd_p, 0, sizeof(seqd_p));
00154 
00155   for(int ii=TPC_PADROWS-1;ii>=0;ii--) RowSpacePts[ii]=0;   
00156 
00157 }
00158 
00159 int TPCV2P0_ZS_SR::initialize()
00160 {
00161   for (int row=0; row<TPC_PADROWS; row++) {
00162     for (int pad=0; pad<TPC_MAXPADS; pad++) {
00163       Pad_array[row][pad].nseq=0;
00164       Pad_array[row][pad].seq= (Sequence *)0;
00165     }
00166   }
00167 
00168   // *** DEBUG LINE *** COMMENT LATER ***
00169 //VP  cout << "TPCV2P0_ZS_SR::initialize : mMergeSequences=" << (mMergeSequences?"ON":"OFF") << endl;
00170 
00171   int rcb; // define for following for loops
00172   // store pointers to the ADCD, ADCX, SEQD banks
00173   for(rcb = 0; rcb < 6; rcb++)
00174   {
00175     for(int mz = 0; mz < 3; mz++)
00176     {
00177       adcd_p[rcb][mz] = detector->getBankTPCADCD(sector,rcb,mz);
00178       if ((void *)adcd_p[rcb][mz] != NULL) {
00179         // if (detector->ercpy->verbose) printf("found ADCD RB%d MZ%d\n",rcb+1,mz+1);
00180         fflush(stdout);
00181       }
00182       adcx_p[rcb][mz] = detector->getBankTPCADCX(sector,rcb,mz);
00183       if ((void *)adcx_p[rcb][mz] != NULL) {
00184         // if (detector->ercpy->verbose) printf("found ADCX RB%d MZ%d\n",rcb+1,mz+1);
00185         fflush(stdout);
00186       }
00187       seqd_p[rcb][mz] = detector->getBankTPCSEQD(sector,rcb,mz);
00188       if ((void *)seqd_p[rcb][mz] != NULL) {
00189         // if (detector->ercpy->verbose) printf("found SEQD RB%d MZ%d\n",rcb+1,mz+1);
00190         fflush(stdout);
00191       }
00192     }
00193   }
00194    
00195 
00196   // search through the  SEQD banks to build our tables of what's where
00197 
00198   // This stupid compiler thinks rcb's scope extends here, so I removed int
00199   // The original line should go in when we upgrade to a better compiler 
00200   //  for(int rcb = 0; rcb < 6; rcb++) {
00201   for(rcb = 0; rcb < 6; rcb++) {
00202     for(int mz = 0; mz < 3; mz++) {
00203       if (seqd_p[rcb][mz] == (classname(Bank_TPCSEQD) *)NULL) {
00204         //TPCSEQD bank doesn't exist
00205         // set up raw data pointers
00206         TPCV2P0_PADK_SR *padkr = detector->getPADKReader(sector);
00207         //      if (!padkr) return FALSE;
00208         if (!padkr) continue;
00209         classname(Bank_TPCADCR) *adcr =
00210           detector->getBankTPCADCR(sector,rcb,mz) ; //pointer to ADC raw bank
00211         //      if (!adcr) return FALSE;
00212         if (!adcr) continue;
00213         classname(Bank_TPCCPPR) *cppr =
00214           detector->getBankTPCCPPR(sector,rcb,mz) ; //pointer to CPP raw bank
00215         //      if (!cppr) return FALSE;
00216         if (!cppr) continue;
00217 
00218         // go through the CPPR/ADCR banks
00219         if (detector->ercpy->verbose) 
00220           printf("reconstructing from RAW banks: SEC%d RB%d MZ%d\n",sector,rcb+1,mz+1);
00221         PADK_entry ent;
00222 
00223         for (int row=1; row<=TPC_PADROWS; row++) {
00224           for (int pad=1; pad<=tpcRowLen[row-1]; pad++) {
00225             padkr->get(row, pad, &ent);
00226             if((ent.mz != mz+1) || (ent.rb != rcb+1)) continue;
00227             struct ASIC_Cluster *clusters = 
00228               (ASIC_Cluster *)(cppr->entry + 32*ent.offset);
00229 
00230             int lastbin = -2, len = 0;
00231             int i, start, stop=-1, newseq;
00232             for (i=0; i<TPC_MXSEQUENCE; i++) { //loop over ASIC sequences
00233               start = clusters[i].start_time_bin;
00234               if ((start < 0)||(start==511)||(start<=stop)) break;
00235               //protect against hardware quirks in VRAM
00236               newseq = (start>lastbin+1);//sequence not broken in pieces by MZ
00237               stop = clusters[i].stop_time_bin;
00238               //MJL: not used:   len = stop - start + 1;
00239               // catch bad values of start, stop
00240               if ( stop<start || start<0 || start>511 || stop<0 || stop>511) {
00241                 struct EventInfo ei;
00242                 ei = detector->ercpy->getEventInfo();
00243                 printf("%s:%d: bad TPC cluster data detected\n",
00244                        __FILE__,__LINE__); 
00245                 printf("evt# %d , sector %d, RB %d, MZ %d row %d, pad %d\n", 
00246                          ei.EventSeqNo,sector+1,rcb+1,mz+1,row,pad);
00247                 printf("cluster %d: start=0x%x   stop=0x%x\n",
00248                        i,clusters[i].start_time_bin,clusters[i].stop_time_bin);
00249                 break; //stop processing this pad
00250               }
00251               lastbin = stop;
00252               if (newseq) Pad_array[row-1][pad-1].nseq++;
00253               //update the cluster counter for this pad
00254               // ...nseq now has CORRECT count of distinct ASIC sequences
00255             } // loop over ASIC sequences
00256             if (i==TPC_MXSEQUENCE) {
00257               //did we overflow the ASIC cluster pointer array
00258               // do the rest here by hand
00259             }
00260 
00261             // finished scanning for total number of distinct sequences
00262             // this scan is only used to determine the number of sequences
00263             int nseq = Pad_array[row-1][pad-1].nseq;
00264             if (!nseq) continue; // only if there are sequences on this pad
00265             Pad_array[row-1][pad-1].seq= 
00266               (Sequence *)malloc(nseq*sizeof(Sequence)); 
00267             if (Pad_array[row-1][pad-1].seq==NULL) {
00268               cout << "failed to malloc() Sequence structures " << endl;
00269               return FALSE;
00270             }
00271             lastbin = -2;
00272             len = 0;
00273             int seqCnt = 0;   
00274 
00275             // loop over sequences, filling in structs
00276             for (i=0; seqCnt<nseq; i++) { //loop over ASIC sequences
00277               if (i<TPC_MXSEQUENCE) {
00278                 start = clusters[i].start_time_bin;
00279                 if ((start < 0)||(start==511)) break;
00280                 newseq = (start>lastbin+1);
00281                      //sequence not broken in pieces by MZ
00282                 stop = clusters[i].stop_time_bin;
00283                 len = stop - start + 1;
00284                 // catch bad values of start, stop
00285                 if ( stop<start || start<0 || start>511 || stop<0 || stop>511) {
00286                   struct EventInfo ei;
00287                   ei = detector->ercpy->getEventInfo();
00288                   printf("%s:%d: bad TPC cluster data detected\n",
00289                          __FILE__,__LINE__); 
00290                   printf("evt# %d , sector %d, RB %d, MZ %d row %d, pad %d\n", 
00291                          ei.EventSeqNo,sector+1,rcb+1,mz+1,row,pad);
00292                   printf("cluster %d: start=0x%x   stop=0x%x\n",
00293                          i,clusters[i].start_time_bin,clusters[i].stop_time_bin);
00294                   break; //stop processing this pad
00295                 }
00296                 lastbin = stop;
00297                 if (newseq) {
00298                   int offset = ent.offset * padkr->getADCBytes() + start;
00299                   Pad_array[row-1][pad-1].seq[seqCnt].startTimeBin = start;
00300                   Pad_array[row-1][pad-1].seq[seqCnt].Length = len;
00301                   Pad_array[row-1][pad-1].seq[seqCnt].FirstAdc = 
00302                              (u_char *)(adcr->ADC + offset);
00303                   seqCnt++;
00304                 }
00305                 else { // continuation of previous sequence
00306                   assert( seqCnt>=1 && seqCnt<=nseq );
00307                   Pad_array[row-1][pad-1].seq[seqCnt-1].Length += len;
00308                 }
00309               }
00310               else {//did we overflow the ASIC cluster pointer array?
00311                 // do the rest here by hand (TBDL)
00312               }      
00313             } // loop on seq
00314           }   // loop on pad
00315         }     // loop on row
00316       }       // if TPCSEQD doesn't exist 
00317       // use this loop when SEQD exists:
00318       else { //TPCSEQD bank exists
00319         // if (detector->ercpy->verbose) printf("TPCSEQD found sector %d  RB%d MZ%d\n",sector+1,rcb+1,mz+1);
00320 
00321         int padrow=-1, pad=-1, lastbin=-2, oldstart=0;
00322         int len = seqd_p[rcb][mz]->header.BankLength - (sizeof(Bank_Header)/4);
00323         int numseq = (4*len)/sizeof(short); // find # sequences this bank
00324         // go through the SEQD twice:
00325         // First:  malloc the Sequence arrays needed
00326         // Second: fill in the Sequence structs
00327 
00328         // get a pointer to the CPPr bank for debugging only
00329         //      classname(Bank_TPCCPPR) *cppr =
00330         //detector->getBankTPCCPPR(sector,rcb,mz) ; //pointer to CPP raw bank
00331         // get a pointer to the PADK bank for debugging only
00332         //      TPCV2P0_PADK_SR *padkr = detector->getPADKReader(sector);
00333 
00334         int i=0,iOld=-1; // Herb, 02nov2000
00335         while (i<numseq) { // loop over the #sequences in TPCSEQD
00336           if(i<=iOld) return FALSE;   // Herb, 02nov2000, as a check for corruption in .daq file
00337           iOld=i;   // Herb, 02nov2000
00338           if (seqd_p[rcb][mz]->sequence[i]<0) { //padrow, pad
00339             padrow = (seqd_p[rcb][mz]->sequence[i]>>8)& 0x7f;
00340             pad = (seqd_p[rcb][mz]->sequence[i])& 0xff;
00341             if (pad==255) break; 
00342             //pad 255 exists only in extraneous last word
00343             oldstart = 0;
00344             lastbin = -2;
00345             i++;
00346           }
00347           else { // start|lastseq|len
00348             if (padrow <0 || pad <0) {
00349               printf("encountered bad SEQD bank RB %d, Mezz %d\n", rcb+1, mz+1);
00350               return FALSE;
00351             }
00352 
00353             unsigned short work = seqd_p[rcb][mz]->sequence[i];
00354             int start = work>>6;
00355             int len = work & 0x1f;
00356             if (start >= oldstart) { // still on same pad
00357 
00358               if(mMergeSequences) { if (start>lastbin+1)  Pad_array[padrow-1][pad-1].nseq++; }
00359               else { Pad_array[padrow-1][pad-1].nseq++;  }
00360 
00361               // don't increment nseq if sequences are adjacent!
00362               lastbin = start+len-1;
00363               oldstart = start;
00364               if (work & 0x20 ) {//last sequence ?
00365                 assert(padrow>=1&&pad>=1); // Herb_Oct_01_2003, added this assert.
00366                 int nseq = Pad_array[padrow-1][pad-1].nseq;
00367                 if (nseq) { // only if there are sequences on this pad
00368                   //allocate memory for Sequence arrays
00369                   if (Pad_array[padrow-1][pad-1].seq) {
00370                     printf("ERROR DETECTED: Pad_array[%d][%d] already malloced\n",
00371                            padrow-1,pad-1);
00372                     return FALSE; // Herb, 15nov2000.  Causes root4star to skip the event.
00373                   }
00374                   Pad_array[padrow-1][pad-1].seq= 
00375                     (Sequence *)malloc(nseq*sizeof(Sequence));
00376                   if (Pad_array[padrow-1][pad-1].seq==NULL) {
00377                     cout << "failed to malloc() Sequence structures " << endl;
00378                     return FALSE;
00379                   }
00380                 }
00381                 pad++; // default to next pad in this padrow
00382                 lastbin = -2; // set lastbin for new pad
00383                 oldstart=0;
00384               }
00385               i++;
00386               continue;
00387             }
00388             else {     // starting new pad without bit 5 set!
00389               if (detector->ercpy->verbose) printf("new pad detected with bit 5 clear!\n");
00390               fflush(stdout);
00391               // for debug only:
00392               // classname(Bank_TPCPADK) *padk = detector->getBankTPCPADK(sector, rcb, mz);
00393 
00394               while (seqd_p[rcb][mz]->sequence[i]>0 && i<numseq) i++; // skip until "switch=1"
00395               //              return FALSE;
00396               assert(padrow>=1&&pad>=1); // Herb_Oct_01_2003, added this assert.
00397               int nseq = Pad_array[padrow-1][pad-1].nseq;
00398               if (nseq) { // only if there are sequences on this pad
00399                 // allocate memory for Sequence arrays
00400                 // make sure we don't do it more than once
00401                 if (Pad_array[padrow-1][pad-1].seq==NULL) {
00402                   Pad_array[padrow-1][pad-1].seq= 
00403                     (Sequence *)malloc(nseq*sizeof(Sequence));
00404                   if (Pad_array[padrow-1][pad-1].seq==NULL) {
00405                     cout << "failed to malloc() Sequence structures " << endl;
00406                     return FALSE;
00407                   }
00408                 }
00409               }  // if (nseq)
00410             }    //  else { ...starting new pad without bit 5 set
00411           }      //  else { ...start|lastseq|len
00412         }        // while (i<numseq)
00413         int nseq;
00414 
00415         if (padrow <1 || pad <1) { // Jerome and Herb, Oct 1 2003.
00416           nseq = 0;
00417           // if (iOld==-1) (void) printf("Did not loop over bank TPCSEQD");
00418           // else          (void) printf("Sequence=%d for SEQD bank\n",numseq);
00419         } else {
00420           nseq = Pad_array[padrow-1][pad-1].nseq;
00421         }
00422 
00423         if (nseq) { // only if there are sequences on this pad
00424           // allocate memory for Sequence arrays
00425           // make sure we don't do it more than once
00426           if (Pad_array[padrow-1][pad-1].seq==NULL) {
00427             Pad_array[padrow-1][pad-1].seq= 
00428               (Sequence *)malloc(nseq*sizeof(Sequence));
00429             if (Pad_array[padrow-1][pad-1].seq==NULL) {
00430               cout << "failed to malloc() Sequence structures " << endl;
00431               return FALSE;
00432             }
00433           }// if Pad_array[padrow-1][pad-1].seq==NULL
00434         }// if (nseq)
00435 
00436         // process TPCSEQD to fill in the Pad_array[][].seq structs
00437         u_char *adc_locn = (u_char *)adcd_p[rcb][mz]->ADC;
00438         padrow=-1; pad=-1; lastbin=-2; oldstart = 0; i=0;
00439         int pad_seq;
00440 
00441         while  (i<numseq)  {
00442           if (seqd_p[rcb][mz]->sequence[i]<0) { //padrow, pad
00443             padrow = (seqd_p[rcb][mz]->sequence[i]>>8)& 0x7f;
00444             pad = (seqd_p[rcb][mz]->sequence[i])& 0xff;
00445             if (pad==255) break; //pad 255 exists only in extraneous last word
00446             pad_seq = 0;
00447             oldstart=0;
00448             lastbin = -2;
00449             i++;
00450           }
00451           else { // (start|lastseq|len)
00452             unsigned short work = seqd_p[rcb][mz]->sequence[i];
00453             int start = work>>6;
00454             int len = work & 0x1f;
00455 
00456             if (start >= oldstart) { // still on same pad
00457               //is this sequence adjacent to previous one?
00458 
00459               if(mMergeSequences) {  // Replaces an ifdef MERGE_SEQUENCES, Herb Ward, Mar 4 2004
00460                 if (start>lastbin+1)  {   // Not adjoining previous sequence, no merge!
00461                   if (pad_seq>=Pad_array[padrow-1][pad-1].nseq) {
00462                     printf("sequence overrun %s %d row %d pad %d seq %d\n",
00463                            __FILE__,__LINE__,padrow,pad,pad_seq);
00464                   }
00465 
00466                   Pad_array[padrow-1][pad-1].seq[pad_seq].startTimeBin = start;
00467                   Pad_array[padrow-1][pad-1].seq[pad_seq].Length = len;
00468                   Pad_array[padrow-1][pad-1].seq[pad_seq].FirstAdc = adc_locn;
00469                   adc_locn +=len;
00470                   pad_seq++;
00471                 }
00472                 else { // Merge sequence!
00473                   assert ( pad_seq>=1 && pad_seq<=Pad_array[padrow-1][pad-1].nseq);
00474                   
00475                   if (pad_seq>Pad_array[padrow-1][pad-1].nseq)
00476                     printf("sequence overrun %s %d row %d pad %d seq %d\n",
00477                            __FILE__,__LINE__,padrow,pad,pad_seq);
00478                   Pad_array[padrow-1][pad-1].seq[pad_seq-1].Length += len;
00479                   adc_locn +=len;
00480                 }
00481               } else { // if(mMergeSequences   Herb replaces an #else, Mar 4 2004.
00482 
00483                 if (pad_seq>=Pad_array[padrow-1][pad-1].nseq) {
00484                   printf("sequence overrun %s %d row %d pad %d seq %d\n",
00485                          __FILE__,__LINE__,padrow,pad,pad_seq);
00486                 }
00487                 
00488                 Pad_array[padrow-1][pad-1].seq[pad_seq].startTimeBin = start;
00489                 Pad_array[padrow-1][pad-1].seq[pad_seq].Length = len;
00490                 Pad_array[padrow-1][pad-1].seq[pad_seq].FirstAdc = adc_locn;
00491                 adc_locn +=len;
00492                 pad_seq++;
00493               } // if(mMergeSequences)  Herb Ward, Mar 4 2004.
00494  
00495               lastbin = start+len-1;
00496               oldstart = start;
00497               if (work & 0x20) {//last sequence ?
00498                 pad++;    // default to next pad in this padrow
00499                 pad_seq = 0;
00500                 lastbin = -2; // set lastbin for new pad        
00501                 oldstart=0;
00502               }
00503               i++;
00504             }
00505             else {    // starting new pad without bit 5 set!
00506               if (detector->ercpy->verbose) {
00507                 printf("new pad detected with bit 5 clear!\n");
00508                 fflush(stdout);
00509               }
00510                // skip until next "switch=1"
00511               while (seqd_p[rcb][mz]->sequence[i]>0 && i<numseq) i++; 
00512             }  // new pad starting with bit 5 set
00513           }    // (start|lastseq|len)
00514         }      // while (i<numseq)
00515       }//TPCSEQD bank exists
00516     }// loop over mz
00517   }// loop over rcb
00518 
00519   return TRUE;
00520 }
00521 
00522 TPCV2P0_ZS_SR::~TPCV2P0_ZS_SR()
00523 {
00524 
00525   // Herb commented this Jul 4 2000, because Victor 
00526   // deletes the reader object object before calling this function (see 
00527   // StDAQReader::readEvent), so that ercpy is not defined.
00528   // if (detector->ercpy->verbose) cout << "Deleting TPCV2P0_ZS_SR" << endl;
00529 
00530 
00531   //free memory allocated for Sequence arrays
00532   for (int row=0; row<TPC_PADROWS; row++) {
00533     for (int pad=0; pad<tpcRowLen[row]; pad++) { // Herb changed "row-1" to "row", Jul 4 2000.
00534       void *memaddr = Pad_array[row][pad].seq;
00535       if (memaddr) free(memaddr);
00536     }
00537   }
00538   for (int rrow=0; rrow<TPC_PADROWS; rrow++) {
00539     if (RowSpacePts[rrow]) free(RowSpacePts[rrow]);
00540   }
00541 }
00542 
00543 int TPCV2P0_ZS_SR::getPadList(int PadRow, u_char **padList)
00544 {
00545     // Construct the padlist array for this PadRow
00546   int pad;
00547   if (PadRow == 0 || PadRow > TPC_PADROWS) return -1;
00548 
00549   // Fill in padrows
00550   int npad=0;
00551   for (pad=1; pad<=tpcRowLen[PadRow-1]; pad++)
00552   {
00553     if (Pad_array[PadRow-1][pad-1].nseq) padlist[PadRow-1][npad++] = pad;
00554   }
00555   // confusing syntax but correct
00556   *padList = &padlist[PadRow-1][0];
00557 
00558   return npad;
00559 }
00560 
00561 int TPCV2P0_ZS_SR::getSequences(int PadRow, int Pad, int *nSeq, 
00562                                 Sequence **SeqData)
00563 {
00564   *nSeq = Pad_array[PadRow-1][Pad-1].nseq;   // number of sequences this pad
00565   *SeqData = Pad_array[PadRow-1][Pad-1].seq;  // pass back pointer to Sequence array 
00566   return 0;
00567 }
00568 
00569 int TPCV2P0_ZS_SR::getFeeSequences(int Fee, int Pin, int *nSeq, 
00570                                 Sequence **SeqData)
00571 {
00572   unsigned short PadRow = row_vs_fee[Fee][Pin];
00573   unsigned short Pad = pad_vs_fee[Fee][Pin];
00574   *nSeq = Pad_array[PadRow-1][Pad-1].nseq;   // number of sequences this pad
00575   *SeqData = Pad_array[PadRow-1][Pad-1].seq;  // pass back pointer to Sequence array 
00576   return 0;
00577 }
00578 
00579 
00580 // Read the clusters (space points) found in the mezzanine cluster-finder
00581 int TPCV2P0_ZS_SR::getSpacePts(int PadRow, int *nSpacePts, SpacePt **SpacePts)
00582 {
00583   int rb, row;
00584   classname(Bank_TPCMZCLD) *cld;
00585   int numSpPts = 0; // keep running total for malloc
00586 
00587   for (row=0; row<TPC_PADROWS; nsptrow[row++]=0);
00588 
00589   for (rb=0; rb<6; rb++) {
00590     for (int mz=0; mz<3; mz++) {
00591       //pointer to TPCMZCLD bank
00592       cld_p[rb][mz] = detector->getBankTPCMZCLD(sector,rb,mz) ; 
00593       cld = cld_p[rb][mz];
00594       if (!cld) continue;
00595       int *ptr = (int *)&cld->stuff;
00596       for (int ir=0; ir<cld->NumRows; ir++){
00597         int row = *ptr++;
00598         int nsp = *ptr++; // bump pointer to beginning of space points
00599         nsptrow[row-1] += nsp;  // add num space pts to running total
00600         ptr += 2*nsp;
00601       }
00602     }
00603   }
00604   if (detector->ercpy->verbose) cout << "sector "<<sector<<": found " 
00605                                      <<numSpPts<<" space pts" <<endl;
00606   
00607   for (row=0; row<TPC_PADROWS; row++) {
00608     RowSpacePts[row] = (SpacePt *)malloc(nsptrow[row]*sizeof(struct SpacePt));
00609     if (RowSpacePts[row]==NULL) {
00610       cout << "failed to malloc() Space Point structures " << endl;
00611       return FALSE;
00612     }
00613   }
00614 
00615   for (rb=0; rb<6; rb++) {
00616     for (int mz=0; mz<3; mz++) {
00617       cld = cld_p[rb][mz];  // pointer to TPCMZCLD bank
00618       if (!cld) continue;
00619       int *ptr = &cld->stuff[0];
00620       for (int ir=0; ir<cld->NumRows; ir++){
00621         int row = *ptr++;
00622         int nsp = *ptr++;   // bump pointer to beginning of space points
00623         for (int isp=0; isp<nsp; isp++, ptr+=2) {
00624           RowSpacePts[row-1][isp] = *(SpacePt *)ptr;
00625         }
00626       }
00627     }
00628   }
00629   *nSpacePts = nsptrow[PadRow-1];
00630   *SpacePts = RowSpacePts[PadRow-1];
00631   return TRUE;
00632 }
00633 
00634 
00635 int TPCV2P0_ZS_SR::MemUsed()
00636 {
00637   return 0;
00638 }
00639
StDaqLib/TPC/TPCV2P0_ZS_SR.cxx
