StRoot: StDaqLib/FTPC/FTPV1P0.cxx Source File

00001 /***************************************************************************
00002  * $Id: FTPV1P0.cxx,v 1.6 2007/12/24 06:04:13 fine Exp $
00003  * Author: M.J. LeVine, J.Klay, H.Huemmler
00004  ***************************************************************************
00005  * Description:  FTPV1P0 implementation
00006  *      
00007  *
00008  *   change log
00009  *
00010  * JLK 11-Jul-2000 Added new geometry files to correctly navigate banks
00011  ***************************************************************************
00012  * $Log: FTPV1P0.cxx,v $
00013  * Revision 1.6  2007/12/24 06:04:13  fine
00014  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00015  *
00016  * Revision 1.5  2001/06/27 22:05:11  jcs
00017  * Comment out unsed variable rcvb
00018  *
00019  * Revision 1.4  2001/06/25 22:57:22  jcs
00020  * add correction for FTPC sector handling
00021  *
00022  * Revision 1.3  2001/06/19 20:51:21  jeromel
00023  * Commited for Janet S.
00024  *
00025  * Revision 1.2  2000/08/18 15:38:58  ward
00026  * New FTPC stuff from JKlay and Hummler.
00027  *
00028  * Revision 1.2  2000/07/11 16:07:58 jklay
00029  * Added new include file which properly translates the global sector 
00030  * numbering 0-59 to the physical mapping as per 
00031  * http://wwwstar.mppmu.mpg.de/map/mapping.html
00032  *
00033  * Revision 1.1  2000/01/18 18:01:19  levine
00034  * Hummler's implementaiton of FTPC reader. Note that method
00035  *
00036  * FTPV1P0_ZS_SR::getFeeSequences(int Fee, int Pin, int *nSeq,
00037  *                                 Sequence **SeqData)
00038  *
00039  * causes exit() since the required #include file has not yet been
00040  * (correctly) implemented.
00041  *
00042  *
00043  **************************************************************************/
00044 
00045 #include "FTPV1P0.hh"
00046 #include "azim_to_rcvb.h"
00047 
00048 using namespace OLDEVP;
00049 
00050 FTPV1P0_PADK_SR::FTPV1P0_PADK_SR(int s, FTPV1P0_Reader *det)
00051 {
00052   sector = s;
00053   detector = det;
00054 }
00055 
00056 int FTPV1P0_PADK_SR::initialize()
00057 {
00058 
00059   // zero out lookup array  
00060   memset((char *)packed_address, 0, sizeof(packed_address));
00061 
00062 
00063   FTPPADK_entry ent;
00064 
00065   classname(Bank_FTPPADK) *raw_bank = detector->getBankFTPPADK(sector);
00066   if(!raw_bank)
00067   {
00068 //    printf("No PADK DATA, sector %d\n",sector);
00069 //    printf("ERR: %s\n",detector->errstr0);
00070   }
00071   else
00072   {
00073 //    printf("PADK DATA for sector %d\n",sector);
00074       for(int i=0; i < FTP_MZPADS; i++)
00075       {
00076          int padrow = raw_bank->index[i].pad_row;
00077          int pad = raw_bank->index[i].pad;
00078          if((padrow == 0xFF) && (pad == 0xFF)) continue;
00079                   
00080          ent.offset = i;
00081                 
00082          // convert to correct FTPC software padrow
00083          padrow = ((int)(padrow-1)/6)%2+1;
00084          place(padrow, pad, &ent);
00085       }
00086        
00087   }
00088 
00089   return TRUE;
00090 }
00091 
00092 void FTPV1P0_PADK_SR::place(short padrow, short pad, FTPPADK_entry *p)
00093 {
00094   padrow--; pad--;  // use c standard for array
00095   packed_address[padrow][pad] = pack(p->offset);
00096 }
00097 
00098 void FTPV1P0_PADK_SR::get(short padrow, short pad, FTPPADK_entry *p)
00099 {
00100   padrow--; pad--;  // use c standard for array
00101   unpack(p,packed_address[padrow][pad]);
00102 //   printf("get row %d pad %d address %d\n", padrow, pad, packed_address[padrow][pad]);
00103 }
00104 
00105 short FTPV1P0_PADK_SR::pack(short offset)
00106 {
00107   short p = offset;  // 10 bits
00108   return p;
00109 } 
00110 
00111 void FTPV1P0_PADK_SR::unpack(FTPPADK_entry *entry, short paddress)
00112 {
00113   entry->offset = paddress & 0x03FF;
00114 }
00115 
00116 ZeroSuppressedReader *FTPV1P0_Reader::getZeroSuppressedReader(int sector)
00117 {
00118   
00119   FTPV1P0_ZS_SR *zs = new FTPV1P0_ZS_SR(sector, this);
00120   if(!zs->initialize())
00121   {
00122     delete zs;
00123     zs = NULL;
00124   }
00125   return (ZeroSuppressedReader *)zs;
00126 }
00127 
00128 ADCRawReader *FTPV1P0_Reader::getADCRawReader(int sector)
00129 {
00130   FTPV1P0_ADCR_SR *adc = new FTPV1P0_ADCR_SR(sector, this);
00131   if(!adc->initialize())
00132   {
00133     delete adc;
00134     adc = NULL;
00135   }
00136   return (ADCRawReader *)adc;
00137 }
00138 
00139 PedestalReader *FTPV1P0_Reader::getPedestalReader(int sector)
00140 {
00141   FTPV1P0_PEDR_SR *ped = new FTPV1P0_PEDR_SR(sector, this);
00142   if(!ped->initialize())
00143   {
00144     delete ped;
00145     ped = NULL;
00146   }
00147 
00148   return (PedestalReader *)ped;
00149 }
00150 
00151 PedestalRMSReader *FTPV1P0_Reader::getPedestalRMSReader(int sector)
00152 {
00153   FTPV1P0_PRMS_SR *rms = new FTPV1P0_PRMS_SR(sector, this);
00154   if(!rms->initialize())
00155   {
00156     delete rms;
00157     rms = NULL;
00158   }
00159 
00160   return (PedestalRMSReader *)rms;
00161 }
00162 
00163 GainReader *FTPV1P0_Reader::getGainReader(int sector)
00164 {
00165   return NULL;
00166 }
00167 
00168 CPPReader *FTPV1P0_Reader::getCPPReader(int sector)
00169 {
00170   FTPV1P0_CPP_SR *cpp = new FTPV1P0_CPP_SR(sector, this);
00171   if(!cpp->initialize())
00172   {
00173     delete cpp;
00174     cpp = NULL;
00175   }
00176 
00177   return (CPPReader *)cpp;
00178 }
00179 
00180 BadChannelReader *FTPV1P0_Reader::getBadChannelReader(int sector)
00181 {
00182   return NULL;
00183 }
00184 
00185 ConfigReader *FTPV1P0_Reader::getConfigReader(int sector)
00186 {
00187   return NULL;
00188 }
00189 
00190 FTPV1P0_PADK_SR *FTPV1P0_Reader::getPADKReader(int sector)
00191 {
00192   
00193   FTPV1P0_PADK_SR *p;
00194 
00195   if ((sector <= 0) || (sector > 60))
00196   {
00197     pERROR(ERR_BAD_ARG);
00198     return NULL;
00199   }
00200 
00201 //  p = padk[sector];
00202   p = padk[sector-1];     //JCS
00203   if(p == NULL)
00204   {
00205     p = new FTPV1P0_PADK_SR(sector, this);
00206     if(!p->initialize())
00207     {
00208       cout << "Error Reading PADK banks, sector=" << sector 
00209            << ": " << errstr().c_str() << endl;
00210       delete p;
00211       return NULL;
00212     }
00213   }
00214 //  padk[sector] = p;
00215   padk[sector-1] = p;
00216   return p;
00217 }
00218 
00219 FTPV1P0_Reader::FTPV1P0_Reader(EventReader *er, classname(Bank_FTPP) *pftp)
00220 {
00221   pBankFTPP = pftp;  // copy arg into class variable
00222   ercpy = er; // squirrel away pointer eventreader for our friends
00223 
00224   if (!pBankFTPP->test_CRC()) ERROR(ERR_CRC);
00225   if (pBankFTPP->swap() < 0) ERROR(ERR_SWAP);
00226   pBankFTPP->header.CRC = 0;
00227 
00228   // We can have a padk for each of 60 sectors
00229   for(int i=0;i<FTP_SECTORS;i++)
00230   {
00231     padk[i] = NULL;
00232   }
00233 }
00234 
00235 FTPV1P0_Reader::~FTPV1P0_Reader()
00236 {
00237   
00238   // Delete Sector Readers buffers (The actual readers are deleted by client)
00239   
00240   // Delete PADK's
00241   for(int i=0;i<FTP_SECTORS;i++)
00242   {
00243     if(padk[i] != NULL) delete padk[i];
00244   }   
00245 }
00246 
00247 int FTPV1P0_Reader::MemUsed()
00248 {
00249   return 0;
00250 }
00251 
00252 // -----------------------------------------------------
00253 // Here lie bank retrieval functions
00254 // ---- These NAVIGATE to the raw banks
00255 // ----------------------------------------------------- 
00256 
00257 classname(Bank_FTPCHAP) *FTPV1P0_Reader::getBankFTPCHAP(int sector)
00258 {
00259   if((sector <= 0) || (sector > 60))
00260   {
00261     pERROR(ERR_BAD_ARG);
00262     return NULL;
00263   }
00264 
00265 //  //JLK This is new 11-July-2000 - we now have geometry files
00266   int chamber = sector_map[sector-1][0]; //convert to internal...
00267   if((chamber < 0) || (chamber >= 2))  //check...
00268   {
00269     pERROR(ERR_BAD_ARG);
00270     return NULL;
00271   }
00272 
00273 //  int chamber = sector;
00274   if((!pBankFTPP->Chamber[chamber].offset) ||
00275      (!pBankFTPP->Chamber[chamber].length))
00276   {
00277     pERROR(ERR_BANK);
00278     return NULL;
00279   }
00280 
00281   classname(Bank_FTPCHAP) *ptr = (classname(Bank_FTPCHAP) *)
00282                       (((INT32 *)pBankFTPP) + 
00283                         pBankFTPP->Chamber[chamber].offset);
00284 
00285   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00286   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00287   ptr->header.CRC = 0;
00288  
00289 //  ptr->print();
00290  
00291   return ptr;
00292 }
00293 
00294 classname(Bank_FTPRBP) *FTPV1P0_Reader::getBankFTPRBP(int sector, 
00295                                            classname(Bank_FTPCHAP) *chap)
00296 {
00297   if ((sector <= 0) || (sector > 60))
00298   {
00299     pERROR(ERR_BAD_ARG);
00300     return NULL;
00301   }
00302 
00303   //JLK This is new 11-July-2000 - we now have geometry files  
00304   int rcvb = sector_map[sector-1][1]; if(rcvb>9) rcvb-=10;
00305   if ((rcvb < 0) || (rcvb >= 10))
00306   {
00307     pERROR(ERR_BAD_ARG);
00308     return NULL;
00309   }
00310 
00311 //   printf("getBankFTPRBP RB: %d\n",rcvb);
00312 //   chap->print();
00313 
00314 //  cout << "getBankFTPRBP RB Offset: " << chap->RcvBoard[rcvb].offset << endl;
00315 //  cout << "getBankFTPRBP RB Length: " << chap->RcvBoard[rcvb].length << endl;
00316   if ((!chap->RcvBoard[rcvb].offset) ||
00317       (!chap->RcvBoard[rcvb].length) )
00318   { 
00319     pERROR(ERR_BANK); 
00320     return NULL; 
00321   }
00322 
00323   classname(Bank_FTPRBP) *ptr = (classname(Bank_FTPRBP) *)
00324                      (((INT32 *)chap) + 
00325                       chap->RcvBoard[rcvb].offset);
00326 
00327   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00328   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00329   ptr->header.CRC = 0;
00330 
00331 //  ptr->print();
00332   return ptr;
00333 }
00334 
00335 classname(Bank_FTPAZIP) *FTPV1P0_Reader::getBankFTPAZIP(int sector, 
00336                                                 classname(Bank_FTPRBP) *rbp)
00337 {
00338   if((sector <= 0) || (sector > 60))
00339   {
00340     pERROR(ERR_BAD_ARG);
00341     return NULL;
00342   }
00343   //JLK This is new 11-July-2000 - we now have geometry files
00344 //  int rcvb = sector_map[sector-1][1];     //JCS - apparently unused
00345   int intsec = sector_map[sector-1][2];
00346 
00347   if((intsec < 0) || (intsec >= 3))
00348   {
00349     pERROR(ERR_BAD_ARG);
00350     return NULL;
00351   }
00352 
00353   if((!rbp->Sector[intsec].offset) ||
00354      (!rbp->Sector[intsec].length))
00355   {
00356     pERROR(ERR_BANK);
00357     return NULL;
00358   }
00359 
00360   classname(Bank_FTPAZIP) *ptr = (classname(Bank_FTPAZIP) *)
00361                       (((INT32 *)rbp) + 
00362                         rbp->Sector[intsec].offset);
00363 
00364   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00365   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00366   ptr->header.CRC = 0;
00367  
00368 //  ptr->print();
00369   return ptr;
00370 }
00371 
00372 classname(Bank_FTPMZP) *FTPV1P0_Reader::getBankFTPMZP(int sector, 
00373         classname(Bank_FTPRBP) *azip)
00374 //                                                      classname(Bank_FTPAZIP) *azip)
00375 {
00376 
00377   if ((sector <= 0) || (sector > 60))
00378   {
00379     pERROR(ERR_BAD_ARG);
00380     return NULL;
00381   }
00382 
00383   //JLK This is new 11-July-2000 - we now have geometry files
00384 //  int rcvb = sector_map[sector-1][1];     //JCS - apparently unused
00385   int mz = sector_map[sector-1][2];  //SAME as rcvbsector
00386   if ((mz < 0) || (mz >= 3))
00387   {
00388     pERROR(ERR_BAD_ARG);
00389     return NULL;
00390   }
00391 
00392 //  cout << "getBankFTPMZP Mezz Offset: " << azip->Mz[mz].offset << endl;
00393 //  cout << "getBankFTPMZP Mezz Length: " << azip->Mz[mz].length << endl;
00394 //  if ((!azip->Mz[mz].offset) || (!azip->Mz[mz].length))
00395 //  cout << "getBankFTPMZP Mezz Offset: " << azip->Sector[mz].offset << endl;
00396 //  cout << "getBankFTPMZP Mezz Length: " << azip->Sector[mz].length << endl;
00397   if ((!azip->Sector[mz].offset) || (!azip->Sector[mz].length))
00398   { 
00399     pERROR(ERR_BANK); 
00400     return NULL; 
00401   }
00402 
00403   classname(Bank_FTPMZP) *ptr = (classname(Bank_FTPMZP) *)
00404                      (((INT32 *)azip) +
00405                       azip->Sector[mz].offset);
00406 //      azip->Mz[mz].offset);
00407 
00408   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00409   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00410   ptr->header.CRC = 0;
00411 
00412 //  printf("getBankFTPMZP Mezz: %d\n",mz);
00413 //  ptr->print();
00414 
00415   return ptr;
00416 }
00417 
00418 classname(Bank_FTPMZP) *FTPV1P0_Reader::getBankFTPMZP(int sector)
00419 {
00420   if ((sector <= 0) || (sector > 60))
00421   {
00422     pERROR(ERR_BAD_ARG);
00423     return NULL;
00424   }
00425 
00426   classname(Bank_FTPCHAP) *chap = getBankFTPCHAP(sector);
00427   if(!chap) return NULL;
00428   
00429   classname(Bank_FTPRBP) *rbp = getBankFTPRBP(sector, chap);
00430   if(!rbp) return NULL;
00431 
00432   classname(Bank_FTPAZIP) *azip = getBankFTPAZIP(sector, rbp);
00433   if(!azip) return NULL;
00434 
00435 //classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector,azip);
00436   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector,rbp);
00437   if(!mzp) 
00438   {
00439     return NULL;
00440   } else return mzp;
00441 }
00442 
00443 classname(Bank_FTPADCD) *FTPV1P0_Reader::getBankFTPADCD(int sector)
00444 {
00445   errnum = 0;
00446   errstr0[0] = '\0';
00447 
00448   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00449   if(!mzp) return NULL;
00450 
00451   if((!mzp->FTPADCD.offset) || (!mzp->FTPADCD.length))
00452   { 
00453     pERROR(ERR_BANK); 
00454     return NULL; 
00455   }
00456 
00457   classname(Bank_FTPADCD) *ptr = (classname(Bank_FTPADCD) *)
00458                       (((INT32 *)mzp) +
00459                        mzp->FTPADCD.offset);
00460 
00461   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00462   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00463   ptr->header.CRC = 0;
00464 
00465   return ptr;
00466 }
00467 
00468 classname(Bank_FTPSEQD) *FTPV1P0_Reader::getBankFTPSEQD(int sector)
00469 {
00470   errnum = 0;
00471   errstr0[0] = '\0';
00472 
00473   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00474   if(!mzp) return NULL;
00475 
00476   if((!mzp->FTPSEQD.offset) || (!mzp->FTPSEQD.length))
00477   { 
00478     pERROR(ERR_BANK); 
00479     return NULL; 
00480   }
00481 
00482   classname(Bank_FTPSEQD) *ptr = (classname(Bank_FTPSEQD) *)
00483                       (((INT32 *)mzp) +
00484                        mzp->FTPSEQD.offset);
00485 
00486   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00487   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00488   ptr->header.CRC = 0;
00489 
00490   return ptr;
00491 }
00492 
00493 classname(Bank_FTPADCX) *FTPV1P0_Reader::getBankFTPADCX(int sector)
00494 {
00495   errnum = 0;
00496   errstr0[0] = '\0';
00497 
00498   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00499   if(!mzp) return NULL;
00500 
00501   if((!mzp->FTPADCX.offset) || (!mzp->FTPADCX.length))
00502   { 
00503     pERROR(ERR_BANK); 
00504     return NULL; 
00505   }
00506 
00507   classname(Bank_FTPADCX) *ptr = (classname(Bank_FTPADCX) *)
00508                       (((INT32 *)mzp) +
00509                        mzp->FTPADCX.offset);
00510 
00511   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00512   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00513   ptr->header.CRC = 0;
00514 
00515   return ptr;
00516 }
00517 
00518 classname(Bank_FTPPADK) *FTPV1P0_Reader::getBankFTPPADK(int sector)
00519 {
00520   errnum = 0;
00521   errstr0[0] = '\0';
00522 
00523   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00524   if(!mzp) return NULL;
00525 
00526 //   printf(" sector: %d\n",sector);
00527 //   mzp->print();
00528 
00529   if((!mzp->FTPPADK.offset) || (!mzp->FTPPADK.length))
00530   { 
00531     pERROR(ERR_BANK); 
00532     return NULL; 
00533   }
00534 
00535   classname(Bank_FTPPADK) *ptr = (classname(Bank_FTPPADK) *)
00536                       (((INT32 *)mzp) +
00537                        mzp->FTPPADK.offset);
00538 
00539   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00540   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00541   ptr->header.CRC = 0;
00542 
00543   return ptr;
00544 };
00545 
00546 classname(Bank_FTPCPPR) *FTPV1P0_Reader::getBankFTPCPPR(int sector)
00547 {
00548   errnum = 0;
00549   errstr0[0] = '\0';
00550   
00551   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00552   if(!mzp) return NULL;
00553 
00554   if((!mzp->FTPCPPR.offset) || (!mzp->FTPCPPR.length))
00555   { 
00556     pERROR(ERR_BANK); 
00557     return NULL; 
00558   }
00559 
00560   classname(Bank_FTPCPPR) *ptr = (classname(Bank_FTPCPPR) *)
00561                       (((INT32 *)mzp) +
00562                         mzp->FTPCPPR.offset);
00563 
00564   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00565   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00566   ptr->header.CRC = 0;
00567 
00568   return ptr;       
00569 }
00570 
00571 classname(Bank_FTPADCR) *FTPV1P0_Reader::getBankFTPADCR(int sector)
00572 {
00573   errnum = 0;
00574   errstr0[0] = '\0';
00575 
00576   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00577   if(!mzp) return NULL;
00578 
00579   if((!mzp->FTPADCR.offset) || (!mzp->FTPADCR.length))
00580   { 
00581     pERROR(ERR_BANK); 
00582     return NULL; 
00583   }
00584 
00585   classname(Bank_FTPADCR) *ptr = (classname(Bank_FTPADCR) *)
00586                       (((INT32 *)mzp) +
00587                         mzp->FTPADCR.offset);
00588 
00589   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00590   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00591   ptr->header.CRC = 0;
00592 
00593   return ptr;       
00594 }
00595 
00596 classname(Bank_FTPCFGR) *FTPV1P0_Reader::getBankFTPCFGR(int sector)
00597 {
00598   return NULL;
00599 }
00600 
00601 classname(Bank_FTPPEDR) *FTPV1P0_Reader::getBankFTPPEDR(int sector)
00602 {
00603   errnum = 0;
00604   errstr0[0] = '\0';
00605   
00606   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00607   if(!mzp) return NULL;
00608 
00609   if((!mzp->FTPPEDR.offset) || (!mzp->FTPPEDR.length))
00610   { 
00611     pERROR(ERR_BANK); 
00612     return NULL; 
00613   }
00614 
00615   classname(Bank_FTPPEDR) *ptr = (classname(Bank_FTPPEDR) *)
00616                       (((INT32 *)mzp) +
00617                         mzp->FTPPEDR.offset);
00618 
00619   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00620   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00621   ptr->header.CRC = 0;
00622 
00623   return ptr;      
00624 
00625 }
00626 
00627 classname(Bank_FTPRMSR) *FTPV1P0_Reader::getBankFTPRMSR(int sector)
00628 {
00629   errnum = 0;
00630   errstr0[0] = '\0';
00631   
00632   classname(Bank_FTPMZP) *mzp = getBankFTPMZP(sector);
00633   if(!mzp) return NULL;
00634 
00635   if((!mzp->FTPRMSR.offset) || (!mzp->FTPRMSR.length))
00636   { 
00637     pERROR(ERR_BANK); 
00638     return NULL; 
00639   }
00640 
00641   classname(Bank_FTPRMSR) *ptr = (classname(Bank_FTPRMSR) *)
00642                       (((INT32 *)mzp) +
00643                         mzp->FTPRMSR.offset);
00644 
00645   if(!ptr->test_CRC()) { pERROR(ERR_CRC); return NULL; }
00646   if(ptr->swap() < 0) { pERROR(ERR_SWAP); return NULL; }
00647   ptr->header.CRC = 0;
00648 
00649   return ptr;       
00650 
00651 }
00652 
00653 classname(Bank_FTPGAINR) *FTPV1P0_Reader::getBankFTPGAINR(int sector)
00654 {
00655   cout << "warning: FTPV1P0_Reader::getBankFTPGAINR() not implemented!"<< endl;
00656   return NULL;
00657 }
00658 
00659 classname(Bank_FTPBADR) *FTPV1P0_Reader::getBankFTPBADR(int sector)
00660 {
00661   cout << "warning: FTPV1P0_Reader::getBankFTPBADR() not implemented!"<< endl;
00662   return NULL;
00663 }