StRoot: StDaqLib/TPC/TPCV2P0.cxx Source File

00001 /***************************************************************************
00002  * $Id: TPCV2P0.cxx,v 1.11 2007/12/24 06:04:32 fine Exp $
00003  * Author: Jeff Landgraf and M.J. LeVine
00004  ***************************************************************************
00005  * Description: common TPC (V2) implementation stuff
00006  *      
00007  *
00008  *   change log
00009  * 02-Jun-99 MJL fixed test on hypersector arg of getBankTPCSECP
00010  * 11-Jun-99 MJL merged PEDR PedRMS readers from RAW version
00011  * 23-Jun-99 MJL most output now supressed with EventReader.verbose
00012  * 23-Jun-99 MJL can now navigate DATAP even though offset/len to various
00013  *   lower banks are at arbitrary positions
00014  * 09-Jul-99 MJL removed navigation code from TPC_Reader. Introduced
00015  *               Bank_TPCP argument to TPCV2P0_Reader constructor
00016  * 20-Jul-99 MJL add error logging. Add bank type checking for every getBank...()
00017  * 27-Jul-99 MJL implement TPCV2P0_Reader::getBankTPCPEDR()
00018  * 27-Jul-99 MJL implement TPCV2P0_Reader::getBankTPCRMSR()
00019  *
00020  ***************************************************************************
00021  * $Log: TPCV2P0.cxx,v $
00022  * Revision 1.11  2007/12/24 06:04:32  fine
00023  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00024  *
00025  * Revision 1.10  2004/03/04 21:51:29  ward
00026  * Replaced MERGE_SEQUENCES with a StDAQMaker chain parameter, as suggested by Landgraf and Lauret.
00027  *
00028  * Revision 1.9  2002/10/13 20:43:37  ward
00029  * Support for decoding DAQ100 data and writing it into a table.
00030  *
00031  * Revision 1.8  2000/01/11 22:03:44  levine
00032  * convert string to char* via c_str() member
00033  * (from Brian Lasiuk)
00034  *
00035  * Revision 1.7  1999/07/27 23:19:32  levine
00036  * implemented methods TPCV2P0_Reader::getBankTPCPEDR()
00037  *                     TPCV2P0_Reader::getBankTPCRMSR()
00038  *
00039  * Revision 1.6  1999/07/21 21:32:39  levine
00040  *
00041  *
00042  * changes to include error logging to file.
00043  *
00044  * There are now 2 constructors for EventReader:
00045  *
00046  *  EventReader();
00047  *  EventReader(const char *logfilename);
00048  *
00049  * Constructed with no argument, there is no error logging. Supplying a file name
00050  * sends all diagnostic output to the named file (N.B. opens in append mode)
00051  *
00052  * See example in client.cxx for constructing a log file name based on the
00053  * datafile name.
00054  *
00055  * It is strongly advised to use the log file capability. You can grep it for
00056  * instances of "ERROR:" to trap anything noteworthy (i.e., corrupted data files).
00057  *
00058  * Revision 1.5  1999/07/10 21:31:25  levine
00059  * Detectors RICH, EMC, TRG now have their own (defined by each detector) interfaces.
00060  * Existing user code will not have to change any calls to TPC-like detector
00061  * readers.
00062  *
00063  * Revision 1.4  1999/07/03 04:25:48  levine
00064  * changes to get past Linux cyyyYompiler
00065  *
00066  * Revision 1.3  1999/07/02 04:43:24  levine
00067  * Many changes -
00068  *  navigates to head of TPCP bank independent of position.
00069  *  move declarations out of loops where they were upsetting some compilers
00070  *  suppress output from class libraries with run-time switch EventReader.verbose
00071  *  added TPCV2P0_CPP_SR::getAsicParams()
00072  *
00073  *
00074  **************************************************************************/
00075 // TPCV2P0 implementation
00076 #include "TPCV2P0.hh"
00077 
00078 using namespace OLDEVP;
00079 
00080 TPCV2P0_PADK_SR::TPCV2P0_PADK_SR(int s, TPCV2P0_Reader *det)
00081 {
00082   sector = s;
00083   detector = det;
00084 }
00085 
00086 int TPCV2P0_PADK_SR::initialize()
00087 {
00088   //  cout << "Initializing PADK sector: " << sector << endl;
00089 
00090   // zero out lookup array  
00091   memset((char *)packed_address, 0, sizeof(packed_address));
00092 
00093   //  cout << "Sizeof() = " << sizeof(packed_address) << endl;
00094 
00095   PADK_entry ent;
00096 
00097   for(int rcb = 0; rcb < 6; rcb++)
00098   {
00099     for(int mz = 0; mz < 3; mz++)
00100     {
00101       classname(Bank_TPCPADK) *raw_bank = detector->getBankTPCPADK(sector, rcb, mz);
00102       if(raw_bank)
00103       {
00104         //      printf("PADK DATA for sector %d, rcb %d, mz %d\n",sector,rcb,mz);
00105       }
00106       else
00107         {// missing PADK bank
00108         //               printf("No PADK DATA, sector %d, rcb %d, mz %d\n",sector,rcb,mz);
00109         //               printf("ERR: %s\n",detector->errstr0);
00110                 continue;
00111       }
00112 
00113       for(int i=0; i < TPC_MZPADS; i++)
00114       {
00115                 int padrow = raw_bank->index[i].pad_row;
00116                 int pad = raw_bank->index[i].pad;
00117                 if((padrow == 0xFF) && (pad == 0xFF)) continue;
00118                   
00119                 ent.offset = i;
00120                 ent.mz = mz+1;
00121                 ent.rb = rcb+1;
00122                 
00123                 place(padrow, pad, &ent);
00124       }
00125     }
00126   }
00127        
00128   return TRUE;
00129 }
00130 
00131 void TPCV2P0_PADK_SR::place(short padrow, short pad, PADK_entry *p)
00132 {
00133   padrow--; pad--;  // use c standard for array
00134   packed_address[padrow][pad] = pack(p->rb, p->mz, p->offset);
00135 }
00136 
00137 void TPCV2P0_PADK_SR::get(short padrow, short pad, PADK_entry *p)
00138 {
00139   padrow--; pad--;  // use c standard for array
00140   unpack(p,packed_address[padrow][pad]);
00141 }
00142 
00143 short TPCV2P0_PADK_SR::pack(short rcb, short mz, short offset)
00144 {
00145   short p = rcb;  // 4 bits 
00146   p = p << 2;  
00147   p += mz;      // 2 bits
00148   p = p << 10;
00149   p += offset;  // 10 bits
00150   return p;
00151 } 
00152 
00153 void TPCV2P0_PADK_SR::unpack(PADK_entry *entry, short paddress)
00154 {
00155   entry->offset = paddress & 0x03FF;
00156   entry->mz = (paddress & 0x0C00) >> 10;
00157   entry->rb = paddress >> 12;
00158 }
00159 
00160 ZeroSuppressedReader *TPCV2P0_Reader::getZeroSuppressedReader(int sector)
00161 {
00162   char mergeSequences;
00163   if(sector>=100) { sector-=100; mergeSequences=1; } else mergeSequences=0;
00164   if (ercpy->verbose) cout << "getTPCV2P0_ZS_SR sector(" << sector <<")" << endl;
00165   
00166   TPCV2P0_ZS_SR *zsp = new TPCV2P0_ZS_SR(sector, this, mergeSequences);
00167   if(!zsp->initialize())
00168   {
00169   if (ercpy->verbose) 
00170     cout << "ERROR: getTPCV2P0_ZS_SR FAILED sector(" << sector <<")" << endl;
00171     delete zsp;
00172     zsp = NULL;
00173   }
00174 
00175   return (ZeroSuppressedReader *)zsp;
00176 }
00177 
00178 ADCRawReader *TPCV2P0_Reader::getADCRawReader(int sector)
00179 {
00180   //  cout << "getTPCV2P0_ADCR_SR" << endl;
00181   TPCV2P0_ADCR_SR *adc = new TPCV2P0_ADCR_SR(sector, this);
00182   if(!adc->initialize())
00183   {
00184     delete adc;
00185     adc = NULL;
00186   }
00187 
00188   return (ADCRawReader *)adc;
00189 }
00190 
00191 PedestalReader *TPCV2P0_Reader::getPedestalReader(int sector)
00192 {
00193   //  cout << "getTPCV2P0_P_SR" << endl;
00194   TPCV2P0_PEDR_SR *ped = new TPCV2P0_PEDR_SR(sector, this);
00195   if(!ped->initialize())
00196     {
00197       delete ped;
00198       ped = NULL;
00199     }
00200 
00201   return (PedestalReader *)ped;
00202 }
00203 
00204 PedestalRMSReader *TPCV2P0_Reader::getPedestalRMSReader(int sector)
00205 {
00206   // cout << "getTPCV2P0_PRMS_SR" << endl;
00207   TPCV2P0_PRMS_SR *rms = new TPCV2P0_PRMS_SR(sector, this);
00208   if(!rms->initialize())
00209     {
00210       delete rms;
00211       rms = NULL;
00212     }
00213   
00214   return (PedestalRMSReader *)rms;
00215 }
00216 
00217 GainReader *TPCV2P0_Reader::getGainReader(int sector)
00218 {
00219   if (ercpy->verbose) cout << "getTPCV2P0_G_SR" << endl;
00220   return NULL;
00221 }
00222 
00223 CPPReader *TPCV2P0_Reader::getCPPReader(int sector)
00224 {
00225   //  cout << "getTPCV2P0_CPP_SR" << endl;
00226   TPCV2P0_CPP_SR *cpp = new TPCV2P0_CPP_SR(sector, this);
00227   if(!cpp->initialize())
00228   {
00229     delete cpp;
00230     cpp = NULL;
00231   }
00232 
00233   return (CPPReader *)cpp;}
00234 
00235 BadChannelReader *TPCV2P0_Reader::getBadChannelReader(int sector)
00236 {
00237   if (ercpy->verbose) cout << "getTPCV2P0_BC_SR" << endl;
00238   return NULL;
00239 }
00240 
00241 ConfigReader *TPCV2P0_Reader::getConfigReader(int sector)
00242 {
00243   if (ercpy->verbose) cout << "getTPCV2P0_CR_SR" << endl;
00244   return NULL;
00245 }
00246 
00247 TPCV2P0_PADK_SR *TPCV2P0_Reader::getPADKReader(int sector)
00248 {
00249   //  cout << "GetPADKReader" << endl;
00250   
00251   TPCV2P0_PADK_SR *p;
00252   p = padk[sector];
00253   if(p == NULL)
00254   {
00255     p = new TPCV2P0_PADK_SR(sector, this);
00256     if(!p->initialize())
00257     {
00258       if (ercpy->verbose) cout << "Error Reading PADK banks, sector=" << sector 
00259            << ": " << errstr().c_str() << endl;
00260       delete p;
00261       return NULL;
00262     }
00263   }
00264   padk[sector] = p;
00265   return p;
00266 }
00267 
00268 TPCV2P0_Reader::TPCV2P0_Reader(EventReader *er, classname(Bank_TPCP) *ptpc)
00269 {
00270   pBankTPCP = ptpc; // copy pointer into class variable
00271   motherPointerBank=pBankTPCP; // Herb Oct 2002 for DAQ100.
00272   ercpy = er; // squirrel away pointer eventreader for our friends
00273 
00274   if (!pBankTPCP->test_CRC()) ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,"TPCP");
00275   if (pBankTPCP->swap() < 0) ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,"TPCP");
00276   pBankTPCP->header.CRC = 0;
00277   // We can have a padk for each of 24 sectors
00278   for(int i=0;i<TPC_SECTORS;i++)
00279   {
00280     padk[i] = NULL;
00281   }
00282 }
00283 
00284 TPCV2P0_Reader::~TPCV2P0_Reader()
00285 {
00286   //  cout << "TPCV2P0 destructor" << endl;
00287   
00288   // Delete Sector Readers buffers (The actual readers are deleted by client)
00289   
00290   // Delete PADK's
00291   for(int i=0;i<TPC_SECTORS;i++)
00292   {
00293     if(padk[i] != NULL) delete padk[i];
00294   }   
00295 }
00296 
00297 int TPCV2P0_Reader::MemUsed()
00298 {
00299   return 0;
00300 }
00301 
00302 // -----------------------------------------------------
00303 // Here lie bank retrieval functions
00304 // ---- These NAVAGATE to the raw banks
00305 // ----------------------------------------------------- 
00306 
00307 classname(Bank_TPCSECP) *TPCV2P0_Reader::getBankTPCSECP(int hypersector)
00308 {
00309   if((hypersector <= 0) || (hypersector >= 24))
00310   {
00311     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,"TPCSECP");
00312     return NULL;
00313   }
00314   hypersector--; //convert to internal represenation
00315 
00316   if((!pBankTPCP->HyperSector[hypersector].offset) ||
00317      (!pBankTPCP->HyperSector[hypersector].length))
00318   {
00319     char str0[40];
00320     sprintf(str0,"getBankTPCSECP(hs %d)",hypersector);
00321     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0);
00322     return NULL;
00323   }
00324 
00325   classname(Bank_TPCSECP) *ptr = (classname(Bank_TPCSECP) *)
00326                       (((INT32 *)pBankTPCP) + 
00327                         pBankTPCP->HyperSector[hypersector].offset);
00328 
00329   if(strncmp(ptr->header.BankType,"TPCSECP",7)) {
00330     char str0[40];
00331     sprintf(str0,"getBankTPCSECP(hs %d)",hypersector);
00332     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return NULL; 
00333   }
00334   if(!ptr->test_CRC()) { 
00335     char str0[40];
00336     sprintf(str0,"getBankTPCSECP(hs %d)",hypersector);
00337     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00338   }
00339   if(ptr->swap() < 0) { 
00340     char str0[40];
00341     sprintf(str0,"getBankTPCSECP(hs %d)",hypersector);
00342     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00343   }
00344   ptr->header.CRC = 0;
00345  
00346   return ptr;
00347 }
00348 
00349 classname(Bank_TPCRBP) *TPCV2P0_Reader::getBankTPCRBP(int interleaved_rb, 
00350                                            classname(Bank_TPCSECP) *secp)
00351 {
00352   int sector = secp->header.BankId;
00353   if ((interleaved_rb < 0) || (interleaved_rb >= 12))
00354   {
00355     char str0[40];
00356     sprintf(str0,"getBankTPCRBP(sec %d rb %d )",sector,interleaved_rb);
00357     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00358     return NULL;
00359   }
00360 
00361 //   printf("getBankTPCRBP RB: %d\n",interleaved_rb);
00362 //   secp->print();
00363 
00364   if ((!secp->RcvBoard[interleaved_rb].offset) ||
00365       (!secp->RcvBoard[interleaved_rb].length) )
00366   { 
00367     //    pERROR(ERR_BANK); 
00368     return NULL; 
00369   }
00370 
00371   classname(Bank_TPCRBP) *ptr = (classname(Bank_TPCRBP) *)
00372                      (((INT32 *)secp) + 
00373                       secp->RcvBoard[interleaved_rb].offset);
00374 
00375   if(strncmp(ptr->header.BankType,"TPCRBP",6)) {
00376     char str0[40];
00377     sprintf(str0,"getBankTPCRBP(sec %d rb %d )",sector,interleaved_rb);
00378     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00379   }
00380   if(!ptr->test_CRC()) {
00381     char str0[40];
00382     sprintf(str0,"getBankTPCRBP(sec %d rb %d )",sector,interleaved_rb);
00383     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00384   }
00385   if(ptr->swap() < 0) {
00386     char str0[40];
00387     sprintf(str0,"getBankTPCRBP(sec %d rb %d )",sector,interleaved_rb);
00388     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00389   }
00390   ptr->header.CRC = 0;
00391 
00392   return ptr;
00393 }
00394 
00395 classname(Bank_TPCMZP) *TPCV2P0_Reader::getBankTPCMZP(int mz, classname(Bank_TPCRBP) *rbp)
00396 {
00397   int rb = rbp->header.BankId;
00398   if ((mz < 0) || (mz >= 3))
00399   {
00400     char str0[40];
00401     sprintf(str0,"getBankTPCMZP(rb %d  mz %d )",rb,mz);
00402     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00403     return NULL;
00404   }
00405 
00406   if ((!rbp->Mz[mz].offset) || (!rbp->Mz[mz].length))
00407   { 
00408     char str0[40];
00409     sprintf(str0,"getBankTPCMZP(rb %d  mz %d )",rb,mz);
00410     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00411     return NULL; 
00412   }
00413 
00414   classname(Bank_TPCMZP) *ptr = (classname(Bank_TPCMZP) *)
00415                      (((INT32 *)rbp) +
00416                       rbp->Mz[mz].offset);
00417 
00418   if(strncmp(ptr->header.BankType,"TPCMZP",6)) {
00419     char str0[40];
00420     sprintf(str0,"getBankTPCMZP(rb %d  mz %d )",rb,mz);
00421     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00422   }
00423   if(!ptr->test_CRC()) {
00424     char str0[40];
00425     sprintf(str0,"getBankTPCMZP(rb %d  mz %d )",rb,mz);
00426     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00427   }
00428   if(ptr->swap() < 0) { 
00429     char str0[40];
00430     sprintf(str0,"getBankTPCMZP(rb %d  mz %d )",rb,mz);
00431     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00432   }
00433   ptr->header.CRC = 0;
00434 
00435 //    printf("getBankTPCMZP Mezz: %d\n",mz);
00436 //    ptr->print();
00437 
00438   return ptr;
00439 }
00440 
00441 classname(Bank_TPCMZP) *TPCV2P0_Reader::getBankTPCMZP(int sector, int rb, int mz)
00442 {
00443   if ((sector < 0) || (sector >= TPC_SECTORS))
00444   {
00445     char str0[40];
00446     sprintf(str0,"getBankTPCMZP(sec %d, rb %d, mz %d )",sector,rb,mz);
00447     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00448     return NULL;
00449   }
00450   if ((rb < 0) || (rb >= 6))
00451   {
00452     char str0[40];
00453     sprintf(str0,"getBankTPCMZP(sec %d, rb %d, mz %d )",sector,rb,mz);
00454     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00455     return NULL;
00456   }
00457   if ((mz < 0) || (mz >= 3))
00458   {
00459     char str0[40];
00460     sprintf(str0,"getBankTPCMZP(sec %d, rb %d, mz %d )",sector,rb,mz);
00461     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00462     return NULL;
00463   }
00464 
00465   classname(Bank_TPCSECP) *secp = getBankTPCSECP(2*(sector/2)+1);
00466   // use odd slots 1,...,23
00467   if(!secp) return NULL;
00468   
00469   classname(Bank_TPCRBP) *rbp;
00470   if (sector%2)                // internal sector odd->sector even->7..12 
00471   {
00472     rbp = getBankTPCRBP(rb + 6, secp);
00473   }
00474   else                          // internal sector even->sector odd->1..6
00475   {
00476     rbp = getBankTPCRBP(rb, secp);
00477   }
00478   if(!rbp) return NULL;
00479 
00480   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(mz,rbp);
00481   return mzp;
00482 }
00483 
00484 classname(Bank_TPCADCD) *TPCV2P0_Reader::getBankTPCADCD(int sector, int rb, int mz)
00485 {
00486     errnum = 0;
00487   errstr0[0] = '\0';
00488 
00489   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00490   if(!mzp) return NULL;
00491 
00492 //   printf(" sector: %d  RB: %d  MZ: %d\n", sector, rb, mz);
00493 //   mzp->print();
00494 
00495   if((!mzp->TPCADCD.offset) || (!mzp->TPCADCD.length))
00496   { 
00497     char str0[40];
00498     sprintf(str0,"getBankTPCADCD(sec %d rb %d  mz %d )",sector,rb,mz);
00499     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00500     return NULL; 
00501   }
00502 
00503   classname(Bank_TPCADCD) *ptr = (classname(Bank_TPCADCD) *)
00504                       (((INT32 *)mzp) +
00505                        mzp->TPCADCD.offset);
00506 
00507   if(strncmp(ptr->header.BankType,"TPCADCD",7)) {
00508     char str0[40];
00509     sprintf(str0,"getBankTPCADCD(sec %d rb %d  mz %d )",sector,rb,mz);
00510     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00511   }
00512   if(!ptr->test_CRC()) { 
00513     char str0[40];
00514     sprintf(str0,"getBankTPCADCD(sec %d rb %d  mz %d )",sector,rb,mz);
00515     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00516   }
00517   if(ptr->swap() < 0) { 
00518     char str0[40];
00519     sprintf(str0,"getBankTPCADCD(sec %d rb %d  mz %d )",sector,rb,mz);
00520     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00521   }
00522   ptr->header.CRC = 0;
00523 
00524   return ptr;
00525 }
00526 
00527 classname(Bank_TPCSEQD) *TPCV2P0_Reader::getBankTPCSEQD(int sector, int rb, int mz)
00528 {
00529   errnum = 0;
00530   errstr0[0] = '\0';
00531 
00532   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00533   if(!mzp) return NULL;
00534 
00535 //   printf(" sector: %d  RB: %d  MZ: %d\n", sector, rb, mz);
00536 //   mzp->print();
00537 
00538   if((!mzp->TPCSEQD.offset) || (!mzp->TPCSEQD.length))
00539   { 
00540     char str0[40];
00541     sprintf(str0,"getBankTPCSEQD(sec %d rb %d  mz %d )",sector,rb,mz);
00542     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00543     return NULL; 
00544   }
00545 
00546   classname(Bank_TPCSEQD) *ptr = (classname(Bank_TPCSEQD) *)
00547                       (((INT32 *)mzp) +
00548                        mzp->TPCSEQD.offset);
00549 
00550   if(strncmp(ptr->header.BankType,"TPCSEQD",7)) {
00551     char str0[40];
00552     sprintf(str0,"getBankTPCSEQD(sec %d rb %d  mz %d )",sector,rb,mz);
00553     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00554   }
00555   if(!ptr->test_CRC()) { 
00556     char str0[40];
00557     sprintf(str0,"getBankTPCSEQD(sec %d rb %d  mz %d )",sector,rb,mz);
00558     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00559   }
00560   if(ptr->swap() < 0) { 
00561     char str0[40];
00562     sprintf(str0,"getBankTPCSEQD(sec %d rb %d  mz %d )",sector,rb,mz);
00563     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00564   }
00565   ptr->header.CRC = 0;
00566 
00567   return ptr;}
00568 
00569 classname(Bank_TPCADCX) *TPCV2P0_Reader::getBankTPCADCX(int sector, int rb, int mz)
00570 {
00571   errnum = 0;
00572   errstr0[0] = '\0';
00573 
00574   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00575   if(!mzp) return NULL;
00576 
00577 //   printf(" sector: %d  RB: %d  MZ: %d\n", sector, rb, mz);
00578 //   mzp->print();
00579 
00580   if((!mzp->TPCADCX.offset) || (!mzp->TPCADCX.length))
00581   { 
00582     char str0[40];
00583     sprintf(str0,"getBankTPCADCX(sec %d rb %d  mz %d )",sector,rb,mz);
00584     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00585     return NULL; 
00586   }
00587 
00588   classname(Bank_TPCADCX) *ptr = (classname(Bank_TPCADCX) *)
00589                       (((INT32 *)mzp) +
00590                        mzp->TPCADCX.offset);
00591 
00592   if(strncmp(ptr->header.BankType,"TPCADCX",7)) {
00593     char str0[40];
00594     sprintf(str0,"getBankTPCADCX(sec %d rb %d  mz %d )",sector,rb,mz);
00595     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00596   }
00597   if(!ptr->test_CRC()) {
00598     char str0[40];
00599     sprintf(str0,"getBankTPCADCX(sec %d rb %d  mz %d )",sector,rb,mz);
00600     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00601   }
00602   if(ptr->swap() < 0) {
00603     char str0[40];
00604     sprintf(str0,"getBankTPCADCX(sec %d rb %d  mz %d )",sector,rb,mz);
00605     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00606   }
00607   ptr->header.CRC = 0;
00608 
00609   return ptr;}
00610 
00611 classname(Bank_TPCPADK) *TPCV2P0_Reader::getBankTPCPADK(int sector, int rb, int mz)
00612 {
00613   errnum = 0;
00614   errstr0[0] = '\0';
00615 
00616   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00617   if(!mzp) return NULL;
00618 
00619 //   printf(" sector: %d  RB: %d  MZ: %d\n", sector, rb, mz);
00620 //   mzp->print();
00621 
00622   if((!mzp->TPCPADK.offset) || (!mzp->TPCPADK.length))
00623   { 
00624     char str0[40];
00625     sprintf(str0,"getBankTPCPADK(sec %d rb %d  mz %d )",sector,rb,mz);
00626     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00627     return NULL; 
00628   }
00629 
00630   classname(Bank_TPCPADK) *ptr = (classname(Bank_TPCPADK) *)
00631                       (((INT32 *)mzp) +
00632                        mzp->TPCPADK.offset);
00633 
00634   if(strncmp(ptr->header.BankType,"TPCPADK",7)) {
00635     char str0[40];
00636     sprintf(str0,"getBankTPCPADK(sec %d rb %d  mz %d )",sector,rb,mz);
00637     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00638   }
00639   if(!ptr->test_CRC()) {
00640     char str0[40];
00641     sprintf(str0,"getBankTPCPADK(sec %d rb %d  mz %d )",sector,rb,mz);
00642     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00643   }
00644   if(ptr->swap() < 0) {
00645     char str0[40];
00646     sprintf(str0,"getBankTPCPADK(sec %d rb %d  mz %d )",sector,rb,mz);
00647     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00648   }
00649   ptr->header.CRC = 0;
00650 
00651   return ptr;
00652 };
00653 
00654 classname(Bank_TPCCPPR) *TPCV2P0_Reader::getBankTPCCPPR(int sector, int rb, int mz)
00655 {
00656   errnum = 0;
00657   errstr0[0] = '\0';
00658   
00659   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00660   if(!mzp) return NULL;
00661 
00662   if((!mzp->TPCCPPR.offset) || (!mzp->TPCCPPR.length))
00663   { 
00664     char str0[40];
00665     sprintf(str0,"getBankTPCCPPR(sec %d rb %d  mz %d )",sector,rb,mz);
00666     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00667     return NULL; 
00668   }
00669 
00670   classname(Bank_TPCCPPR) *ptr = (classname(Bank_TPCCPPR) *)
00671                       (((INT32 *)mzp) +
00672                         mzp->TPCCPPR.offset);
00673 
00674   if(strncmp(ptr->header.BankType,"TPCCPPR",7)) {
00675     char str0[40];
00676     sprintf(str0,"getBankTPCCPPR(sec %d rb %d  mz %d )",sector,rb,mz);
00677     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00678   }
00679   if(!ptr->test_CRC()) {
00680     char str0[40];
00681     sprintf(str0,"getBankTPCCPPR(sec %d rb %d  mz %d )",sector,rb,mz);
00682     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00683   }
00684   if(ptr->swap() < 0) { 
00685     char str0[40];
00686     sprintf(str0,"getBankTPCCPPR(sec %d rb %d  mz %d )",sector,rb,mz);
00687     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00688   }
00689   ptr->header.CRC = 0;
00690 
00691   return ptr;       
00692 }
00693 
00694 classname(Bank_TPCADCR) *TPCV2P0_Reader::getBankTPCADCR(int sector, int rb, int mz)
00695 {
00696   errnum = 0;
00697   errstr0[0] = '\0';
00698   
00699   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00700   if(!mzp) return NULL;
00701 
00702   if((!mzp->TPCADCR.offset) || (!mzp->TPCADCR.length))
00703   { 
00704     char str0[40];
00705     sprintf(str0,"getBankTPCADCR(sec %d rb %d  mz %d )",sector,rb,mz);
00706     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00707     return NULL; 
00708   }
00709 
00710   classname(Bank_TPCADCR) *ptr = (classname(Bank_TPCADCR) *)
00711                       (((INT32 *)mzp) +
00712                         mzp->TPCADCR.offset);
00713 
00714   if(strncmp(ptr->header.BankType,"TPCADCR",7)) {
00715     char str0[40];
00716     sprintf(str0,"getBankTPCADCR(sec %d rb %d  mz %d )",sector,rb,mz);
00717     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00718   }
00719   if(!ptr->test_CRC()) {
00720     char str0[40];
00721     sprintf(str0,"getBankTPCADCR(sec %d rb %d  mz %d )",sector,rb,mz);
00722     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00723   }
00724   if(ptr->swap() < 0) {
00725     char str0[40];
00726     sprintf(str0,"getBankTPCADCR(sec %d rb %d  mz %d )",sector,rb,mz);
00727     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00728   }
00729   ptr->header.CRC = 0;
00730 
00731   return ptr;       
00732 }
00733 
00734 classname(Bank_TPCMZCLD) *TPCV2P0_Reader::getBankTPCMZCLD(int sector, int rb, int mz)
00735 {
00736   errnum = 0;
00737   errstr0[0] = '\0';
00738   
00739   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00740   if(!mzp) return NULL;
00741 
00742   if((!mzp->TPCMZCLD.offset) || (!mzp->TPCMZCLD.length))
00743   { 
00744     char str0[40];
00745     sprintf(str0,"getBankTPCMZCLD(sec %d rb %d  mz %d )",sector,rb,mz);
00746     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00747     return NULL; 
00748   }
00749 
00750   classname(Bank_TPCMZCLD) *ptr = (classname(Bank_TPCMZCLD) *)
00751                       (((INT32 *)mzp) +
00752                         mzp->TPCMZCLD.offset);
00753 
00754   if(strncmp(ptr->header.BankType,"TPCMZCLD",8)) {
00755     char str0[40];
00756     sprintf(str0,"getBankTPCMZCLD(sec %d rb %d  mz %d )",sector,rb,mz);
00757     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00758   }
00759   if(!ptr->test_CRC()) { 
00760     char str0[40];
00761     sprintf(str0,"getBankTPCMZCLD(sec %d rb %d  mz %d )",sector,rb,mz);
00762     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00763   }
00764   if(ptr->swap() < 0) { 
00765     char str0[40];
00766     sprintf(str0,"getBankTPCMZCLD(sec %d rb %d  mz %d )",sector,rb,mz);
00767     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00768   }
00769   ptr->header.CRC = 0;
00770 
00771   return ptr;       
00772 }
00773 
00774 
00775 classname(Bank_TPCCFGR) *TPCV2P0_Reader::getBankTPCCFGR(int sector, int rb, int mz)
00776 {
00777   return NULL;
00778 }
00779 
00780 classname(Bank_TPCPEDR) *TPCV2P0_Reader::getBankTPCPEDR(int sector, int rb, int mz)
00781 {
00782   errnum = 0;
00783   errstr0[0] = '\0';
00784   
00785   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00786   if(!mzp) return NULL;
00787 
00788   if((!mzp->TPCPEDR.offset) || (!mzp->TPCPEDR.length))
00789   { 
00790     char str0[40];
00791     sprintf(str0,"getBankTPCPEDR(sec %d rb %d  mz %d )",sector,rb,mz);
00792     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00793     return NULL; 
00794   }
00795 
00796   classname(Bank_TPCPEDR) *ptr = (classname(Bank_TPCPEDR) *)
00797                       (((INT32 *)mzp) +
00798                         mzp->TPCPEDR.offset);
00799 
00800   if(strncmp(ptr->header.BankType,"TPCPEDR",7)) {
00801     char str0[40];
00802     sprintf(str0,"getBankTPCPEDR(sec %d rb %d  mz %d )",sector,rb,mz);
00803     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00804   }
00805   if(!ptr->test_CRC()) { 
00806     char str0[40];
00807     sprintf(str0,"getBankTPCPEDR(sec %d rb %d  mz %d )",sector,rb,mz);
00808     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00809   }
00810   if(ptr->swap() < 0) { 
00811     char str0[40];
00812     sprintf(str0,"getBankTPCPEDR(sec %d rb %d  mz %d )",sector,rb,mz);
00813     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00814   }
00815   ptr->header.CRC = 0;
00816 
00817   return ptr;       
00818 }
00819 
00820 
00821 classname(Bank_TPCRMSR) *TPCV2P0_Reader::getBankTPCRMSR(int sector, int rb, int mz)
00822 {
00823   errnum = 0;
00824   errstr0[0] = '\0';
00825   
00826   classname(Bank_TPCMZP) *mzp = getBankTPCMZP(sector, rb, mz);
00827   if(!mzp) return NULL;
00828 
00829   if((!mzp->TPCRMSR.offset) || (!mzp->TPCRMSR.length))
00830   { 
00831     char str0[40];
00832     sprintf(str0,"getBankTPCRMSR(sec %d rb %d  mz %d )",sector,rb,mz);
00833     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00834     return NULL; 
00835   }
00836 
00837   classname(Bank_TPCRMSR) *ptr = (classname(Bank_TPCRMSR) *)
00838                       (((INT32 *)mzp) +
00839                         mzp->TPCRMSR.offset);
00840 
00841   if(strncmp(ptr->header.BankType,"TPCRMSR",7)) {
00842     char str0[40];
00843     sprintf(str0,"getBankTPCRMSR(sec %d rb %d  mz %d )",sector,rb,mz);
00844     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00845   }
00846   if(!ptr->test_CRC()) { 
00847     char str0[40];
00848     sprintf(str0,"getBankTPCRMSR(sec %d rb %d  mz %d )",sector,rb,mz);
00849     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00850   }
00851   if(ptr->swap() < 0) { 
00852     char str0[40];
00853     sprintf(str0,"getBankTPCRMSR(sec %d rb %d  mz %d )",sector,rb,mz);
00854     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00855   }
00856   ptr->header.CRC = 0;
00857 
00858   return ptr;       
00859 }
00860 
00861 classname(Bank_TPCGAINR) *TPCV2P0_Reader::getBankTPCGAINR(int sector, int rb, int mz)
00862 {
00863   return NULL;
00864 }
00865 
00866 classname(Bank_TPCBADR) *TPCV2P0_Reader::getBankTPCBADR(int sector, int rb, int mz)
00867 {
00868   return NULL;
00869 }
00870