StRoot: StDaqLib/SVT/SVTV1P0.cxx Source File

00001 /***************************************************************************
00002  *      
00003  * $Id: SVTV1P0.cxx,v 1.5 2007/12/24 06:04:27 fine Exp $
00004  *      
00005  * Author: Jeff Landgraf, M.J. LeVine, Marcelo Munhoz, J. Schambach
00006  *      
00007  ***************************************************************************
00008  *      
00009  * Description: common SVT implementation stuff
00010  *      
00011  ***************************************************************************
00012  *      
00013  * $Log: SVTV1P0.cxx,v $
00014  * Revision 1.5  2007/12/24 06:04:27  fine
00015  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00016  *
00017  * Revision 1.4  2007/01/04 21:27:50  jml
00018  * zero suppressed reader no longer uses adcx, only seqd.  Fixes bug from early 2005
00019  *
00020  * Revision 1.3  2001/05/04 18:05:23  jschamba
00021  * Corrected several instances of wrong counting representation for hypersector
00022  * and mezzanine (internal counting from 0, physical from 1)
00023  *
00024  * Revision 1.2  2001/04/18 19:47:25  ward
00025  * StDaqLib/SVT stuff from Jo Schambach.
00026  *
00027  * Revision 1.1  2000/06/06 18:08:31  jml
00028  * Initial version of SVT Readers (author: marcello munholz, helen caines, js)
00029  *
00030  *      
00031  **************************************************************************/
00032 // SVT implementation
00033 #include "SVTV1P0.hh"
00034 
00035 using namespace OLDEVP;
00036 
00037 SVTV1P0_ANODK_SR::SVTV1P0_ANODK_SR(SVTV1P0_Reader *det)
00038 {
00039   detector = det;
00040 }
00041 
00042 int SVTV1P0_ANODK_SR::initialize(int maxSector)
00043 {
00044   //  cout << "Initializing ANODK wafer: " <<  wafer <<  endl;
00045 
00046   // zero out lookup array  
00047   memset((char *)packed_address, 0, sizeof(packed_address));
00048 
00049   //cout << "Sizeof() = " << sizeof(packed_address) << endl;
00050 
00051   ANODK_entry ent;
00052 
00053   for(int hypersector = 1; hypersector <= maxSector; hypersector++)
00054     {
00055       for(int rcb = 1; rcb <= 6; rcb++)
00056         {
00057           for(int mz = 1; mz <= 3; mz++)
00058             {
00059             
00060               classname(Bank_SVTANODK) *raw_bank = detector->getBankSVTANODK(hypersector, rcb, mz);
00061               if(raw_bank)
00062                 {
00063                   //printf("ANODK DATA for hypersector %d, rcb %d, mz %d\n",hypersector,rcb,mz);
00064                 }
00065               else
00066                 {
00067                   // missing ANODK bank
00068                   //printf("No ANODK DATA, hypersector %d, rcb %d, mz %d\n",hypersector,rcb,mz);
00069                   //printf("ERR: %s\n",detector->errstr0);
00070                   continue;
00071                 }
00072               
00073               for(int i=0; i < SVT_MZHYBRIDS; i++)
00074                 {
00075                   int barrel = raw_bank->index[i].barrel;
00076                   int ladder = raw_bank->index[i].ladder;
00077                   int wafer = raw_bank->index[i].waferID & 0x0F;
00078                   int hybrid = (raw_bank->index[i].waferID & 0xF0) >> 4;
00079                   
00080                   //if((padrow == 0xFF) && (anode == 0xFF)) continue;
00081                   
00082                   ent.offset = i;
00083                   ent.mz = mz;
00084                   ent.rb = rcb;
00085                   ent.hypersector = hypersector;
00086                   
00087                   place(barrel, ladder, wafer, hybrid, &ent);
00088 
00089                   //printf("ANODK DATA for barrel %d, ladder %d, wafer %d, hybrid %d\n",barrel,ladder,wafer,hybrid);
00090 
00091                 }
00092             }
00093         }
00094     }
00095 
00096   return TRUE;
00097 }
00098 
00099 void SVTV1P0_ANODK_SR::place(short barrel, short ladder, short wafer, short hybrid, ANODK_entry *p)
00100 {
00101   short waferIndex = getWaferIndex(barrel,ladder,wafer);
00102   packed_address[waferIndex-1][hybrid-1] = pack(p->hypersector, p->rb, p->mz, p->offset);
00103 }
00104 
00105 void SVTV1P0_ANODK_SR::get(short barrel, short ladder, short wafer, short hybrid, ANODK_entry *p)
00106 {
00107   short waferIndex = getWaferIndex(barrel,ladder,wafer);
00108   unpack(p,packed_address[waferIndex-1][hybrid-1]);
00109 }
00110 
00111 void SVTV1P0_ANODK_SR::get(short waferIndex, short hybrid, ANODK_entry *p)
00112 {
00113   unpack(p,packed_address[waferIndex-1][hybrid-1]);
00114 }
00115 
00116 short SVTV1P0_ANODK_SR::pack(short hypersector, short rcb, short mz, short offset)
00117 {
00118   //printf("SVTV1P0_ANODK_SR::pack:hypersector = %d, rcb = %d, mz = %d\n",hypersector,rcb,mz);
00119   short p = hypersector;  // 5 bits 
00120   p = p << 5;  
00121   p += rcb;  // 5 bits 
00122   p = p << 2;  
00123   p += mz;      // 2 bits
00124   p = p << 4;
00125   p += offset;  // 4 bits
00126   return p;
00127 } 
00128 
00129 void SVTV1P0_ANODK_SR::unpack(ANODK_entry *entry, short anodedress)
00130 {
00131   entry->offset = anodedress & 0x000F;
00132   entry->mz = (anodedress & 0x0030) >> 4;
00133   entry->rb = (anodedress & 0x07C0) >> 6;
00134   entry->hypersector = anodedress >> 11;
00135   //printf("SVTV1P0_ANODK_SR::unpack:hypersector = %d, rcb = %d, mz = %d\n",entry->hypersector,entry->rb,entry->mz);
00136 }
00137 
00138 short SVTV1P0_ANODK_SR::getWaferIndex(short barrel, short ladder, short wafer)
00139 {
00140  short index;
00141  int numberOfLadders[3] = {8,12,16};
00142  int numberOfWafers[3] = {4,6,7};
00143  // int numberOfHybrids = 2;
00144 
00145   switch  (barrel) {
00146     
00147   case 1:
00148     index = (ladder-1)*numberOfWafers[barrel-1] + wafer;
00149     break;
00150 
00151   case 2:
00152     index = numberOfLadders[barrel-2]*numberOfWafers[barrel-2] +
00153       (ladder-1)*numberOfWafers[barrel-1] + wafer;
00154     break;
00155 
00156   case 3:
00157     index = numberOfLadders[barrel-3]*numberOfWafers[barrel-3] + 
00158       numberOfLadders[barrel-2]*numberOfWafers[barrel-2] +
00159       (ladder-1)*numberOfWafers[barrel-1] + wafer;
00160     break;
00161 
00162  default:
00163    cout << "ERROR: There is NO barrel number " << barrel << " !!!" << endl;
00164    index = -1;
00165    break;
00166   }
00167 
00168   return index;
00169 }
00170 
00171 ZeroSuppressedReader *SVTV1P0_Reader::getZeroSuppressedReader(int wafer)
00172 {
00173   if (ercpy->verbose) cout << "getSVT_ZS_SR wafer = " <<  wafer << endl;
00174   
00175   SVTV1P0_ZS_SR *zsp = new SVTV1P0_ZS_SR(wafer, this);
00176   if(!zsp->initialize())
00177   {
00178   if (ercpy->verbose) 
00179     cout << "ERROR: getSVT_ZS_SR FAILED wafer = " << wafer << endl;
00180     delete zsp;
00181     zsp = NULL;
00182   }
00183 
00184   return (ZeroSuppressedReader *)zsp;
00185 }
00186 
00187 ZeroSuppressedReader *SVTV1P0_Reader::getZeroSuppressedReader(int barrel, int ladder, int wafer)
00188 {
00189   if (ercpy->verbose) cout << "getSVT_ZS_SR wafer = " <<  wafer << endl;
00190   
00191   SVTV1P0_ZS_SR *zsp = new SVTV1P0_ZS_SR(barrel, ladder, wafer, this);
00192   if(!zsp->initialize())
00193   {
00194   if (ercpy->verbose) 
00195     cout << "ERROR: getSVT_ZS_SR FAILED wafer = " << wafer << endl;
00196     delete zsp;
00197     zsp = NULL;
00198   }
00199 
00200   return (ZeroSuppressedReader *)zsp;
00201 }
00202 
00203 ADCRawReader *SVTV1P0_Reader::getADCRawReader(int wafer)
00204 {
00205   //  cout << "getSVT_ADCR_SR" << endl;
00206   SVTV1P0_ADCR_SR *adc = new SVTV1P0_ADCR_SR(wafer, this);
00207   if(!adc->initialize())
00208   {
00209     delete adc;
00210     adc = NULL;
00211   }
00212 
00213   return (ADCRawReader *)adc;
00214 }
00215 
00216 ADCRawReader *SVTV1P0_Reader::getADCRawReader(int barrel, int ladder, int wafer)
00217 {
00218   //  cout << "getSVT_ADCR_SR" << endl;
00219   SVTV1P0_ADCR_SR *adc = new SVTV1P0_ADCR_SR(barrel, ladder, wafer, this);
00220   if(!adc->initialize())
00221   {
00222     delete adc;
00223     adc = NULL;
00224   }
00225 
00226   return (ADCRawReader *)adc;
00227 }
00228 
00229 PedestalReader *SVTV1P0_Reader::getPedestalReader(int wafer)
00230 {
00231   //  cout << "getSVT_P_SR" << endl;
00232   SVTV1P0_PEDR_SR *ped = new SVTV1P0_PEDR_SR(wafer, this);
00233   if(!ped->initialize())
00234     {
00235       delete ped;
00236       ped = NULL;
00237     }
00238 
00239   return (PedestalReader *)ped;
00240 }
00241 
00242 PedestalReader *SVTV1P0_Reader::getPedestalReader(int barrel, int ladder, int wafer)
00243 {
00244   //  cout << "getSVT_P_SR" << endl;
00245   SVTV1P0_PEDR_SR *ped = new SVTV1P0_PEDR_SR(barrel, ladder, wafer, this);
00246   if(!ped->initialize())
00247     {
00248       delete ped;
00249       ped = NULL;
00250     }
00251 
00252   return (PedestalReader *)ped;
00253 }
00254 
00255 PedestalRMSReader *SVTV1P0_Reader::getPedestalRMSReader(int wafer)
00256 {
00257   // cout << "getSVT_PRMS_SR" << endl;
00258   SVTV1P0_PRMS_SR *rms = new SVTV1P0_PRMS_SR(wafer, this);
00259   if(!rms->initialize())
00260     {
00261       delete rms;
00262       rms = NULL;
00263     }
00264   
00265   return (PedestalRMSReader *)rms;
00266 }
00267 
00268 PedestalRMSReader *SVTV1P0_Reader::getPedestalRMSReader(int barrel, int ladder, int wafer)
00269 {
00270   // cout << "getSVT_PRMS_SR" << endl;
00271   SVTV1P0_PRMS_SR *rms = new SVTV1P0_PRMS_SR(barrel, ladder, wafer, this);
00272   if(!rms->initialize())
00273     {
00274       delete rms;
00275       rms = NULL;
00276     }
00277   
00278   return (PedestalRMSReader *)rms;
00279 }
00280 
00281 GainReader *SVTV1P0_Reader::getGainReader(int wafer)
00282 {
00283   if (ercpy->verbose) cout << "getSVT_G_SR" << endl;
00284   return NULL;
00285 }
00286 
00287 GainReader *SVTV1P0_Reader::getGainReader(int barrel, int ladder, int wafer)
00288 {
00289   if (ercpy->verbose) cout << "getSVT_G_SR" << endl;
00290   return NULL;
00291 }
00292 
00293 CPPReader *SVTV1P0_Reader::getCPPReader(int wafer)
00294 {
00295   //  cout << "getSVT_CPP_SR" << endl;
00296   SVTV1P0_CPP_SR *cpp = new SVTV1P0_CPP_SR(wafer, this);
00297   if(!cpp->initialize())
00298   {
00299     delete cpp;
00300     cpp = NULL;
00301   }
00302 
00303   return (CPPReader *)cpp;}
00304 
00305 CPPReader *SVTV1P0_Reader::getCPPReader(int barrel, int ladder, int wafer)
00306 {
00307   //  cout << "getSVT_CPP_SR" << endl;
00308   SVTV1P0_CPP_SR *cpp = new SVTV1P0_CPP_SR(barrel, ladder, wafer, this);
00309   if(!cpp->initialize())
00310   {
00311     delete cpp;
00312     cpp = NULL;
00313   }
00314 
00315   return (CPPReader *)cpp;}
00316 
00317 BadChannelReader *SVTV1P0_Reader::getBadChannelReader(int wafer)
00318 {
00319   if (ercpy->verbose) cout << "getSVT_BC_SR" << endl;
00320   return NULL;
00321 }
00322 
00323 BadChannelReader *SVTV1P0_Reader::getBadChannelReader(int barrel, int ladder, int wafer)
00324 {
00325   if (ercpy->verbose) cout << "getSVT_BC_SR" << endl;
00326   return NULL;
00327 }
00328 
00329 ConfigReader *SVTV1P0_Reader::getConfigReader(int wafer)
00330 {
00331   if (ercpy->verbose) cout << "getSVT_CR_SR" << endl;
00332   return NULL;
00333 }
00334 
00335 ConfigReader *SVTV1P0_Reader::getConfigReader(int barrel, int ladder, int wafer)
00336 {
00337   if (ercpy->verbose) cout << "getSVT_CR_SR" << endl;
00338   return NULL;
00339 }
00340 
00341 SVTV1P0_ANODK_SR *SVTV1P0_Reader::getANODKReader()
00342 {
00343   //  cout << "GetANODKReader" << endl;
00344   
00345   //JS: can't do that anymore. The SVTP bank length is now 58, just like TPC
00346   // so the length has no relation to the number of sectors anymore.
00347   //int maxSector = pBankSVTP->header.BankLength/sizeof(Pointer)*2;
00348 
00349   int maxSector = 4;
00350   SVTV1P0_ANODK_SR *p;
00351   p = anodk;
00352   if(p == NULL)
00353   {
00354     p = new SVTV1P0_ANODK_SR(this);
00355     if(!p->initialize(maxSector))
00356     {
00357       //      if (ercpy->verbose) cout << "Error Reading ANODK banks" 
00358       //           << ": " << errstr() << endl;
00359       delete p;
00360       return NULL;
00361     }
00362   }
00363   anodk = p;
00364   return p;
00365 }
00366 
00367 SVTV1P0_Reader::SVTV1P0_Reader(EventReader *er, classname(Bank_SVTP) *psvt)
00368 {
00369   pBankSVTP = psvt; // copy pointer into class variable
00370   ercpy = er; // squirrel away pointer eventreader for our friends
00371 
00372   if (!pBankSVTP->test_CRC()) ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,"SVTP");
00373   if (pBankSVTP->swap() < 0) ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,"SVTP");
00374   pBankSVTP->header.CRC = 0;
00375   anodk = NULL;
00376 }
00377 
00378 SVTV1P0_Reader::~SVTV1P0_Reader()
00379 {
00380   //  cout << "SVT destructor" << endl;
00381   
00382   // Delete Sector Readers buffers (The actual readers are deleted by client)
00383   
00384   // Delete ANODK's
00385   if(anodk != NULL) delete anodk;
00386 }
00387 
00388 int SVTV1P0_Reader::MemUsed()
00389 {
00390   return 0;
00391 }
00392 
00393 // -----------------------------------------------------
00394 // Here are the bank retrieval functions
00395 // ---- These NAVIGATE to the raw banks
00396 // ----------------------------------------------------- 
00397 
00398 classname(Bank_SVTSECP) *SVTV1P0_Reader::getBankSVTSECP(int hypersector)
00399 {
00400   //printf("getbankSVTSECP %d\n",hypersector);
00401 
00402   if((hypersector < 1 ) || (hypersector > 4))
00403   {
00404     char str0[40];
00405     sprintf(str0,"getBankSVTSECP(hs %d)",hypersector);
00406     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00407     return NULL;
00408   }
00409   hypersector--; //convert to internal represenation
00410 
00411   if((!pBankSVTP->HyperSector[hypersector].offset) ||
00412      (!pBankSVTP->HyperSector[hypersector].length))
00413   {
00414     char str0[40];
00415     sprintf(str0,"getBankSVTSECP(hs %d)",hypersector+1);
00416     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0);
00417     return NULL;
00418   }
00419 
00420   classname(Bank_SVTSECP) *ptr = (classname(Bank_SVTSECP) *)
00421                       (((INT32 *)pBankSVTP) + 
00422                         pBankSVTP->HyperSector[hypersector].offset);
00423 
00424   if(strncmp(ptr->header.BankType,"SVTSECP",7)) {
00425     char str0[40];
00426     sprintf(str0,"getBankSVTSECP(hs %d)",hypersector+1);
00427     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return NULL; 
00428   }
00429 
00430   if(!ptr->test_CRC()) { 
00431     char str0[40];
00432     sprintf(str0,"getBankSVTSECP(hs %d)",hypersector+1);
00433     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00434   }
00435   if(ptr->swap() < 0) { 
00436     char str0[40];
00437     sprintf(str0,"getBankSVTSECP(hs %d)",hypersector+1);
00438     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00439   }
00440   ptr->header.CRC = 0;
00441  
00442   return ptr;
00443 }
00444 
00445 classname(Bank_SVTRBP) *SVTV1P0_Reader::getBankSVTRBP(int interleaved_rb, 
00446                                            classname(Bank_SVTSECP) *secp)
00447 {
00448   int hypersector = secp->header.BankId;
00449   // interleaved_rb counts from 1 to 12 
00450   if ((interleaved_rb < 1) || (interleaved_rb > 12))
00451   {
00452     char str0[40];
00453     sprintf(str0,"getBankSVTRBP(sec %d rb %d )",hypersector,interleaved_rb);
00454     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00455     return NULL;
00456   }
00457 
00458   //convert to internal representation:
00459   interleaved_rb--;
00460 
00461   //printf("getBankSVTRBP RB: %d\n",interleaved_rb);
00462    //   secp->print();
00463 
00464   if ((!secp->RcvBoard[interleaved_rb].offset) ||
00465       (!secp->RcvBoard[interleaved_rb].length) )
00466   { 
00467     //    pERROR(ERR_BANK); 
00468     return NULL; 
00469   }
00470 
00471   classname(Bank_SVTRBP) *ptr = (classname(Bank_SVTRBP) *)
00472                      (((INT32 *)secp) + 
00473                       secp->RcvBoard[interleaved_rb].offset);
00474 
00475   if(strncmp(ptr->header.BankType,"SVTRBP",6)) {
00476     char str0[40];
00477     sprintf(str0,"getBankSVTRBP(sec %d rb %d )",hypersector,interleaved_rb);
00478     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00479   }
00480   if(!ptr->test_CRC()) {
00481     char str0[40];
00482     sprintf(str0,"getBankSVTRBP(sec %d rb %d )",hypersector,interleaved_rb);
00483     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00484   }
00485   if(ptr->swap() < 0) {
00486     char str0[40];
00487     sprintf(str0,"getBankSVTRBP(sec %d rb %d )",hypersector,interleaved_rb);
00488     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00489   }
00490   ptr->header.CRC = 0;
00491 
00492   mSCAZero = (int)ptr->FiberHeader[16];
00493   mTimeZero = (int)ptr->FiberHeader[17];
00494 
00495   return ptr;
00496 }
00497 
00498 classname(Bank_SVTMZP) *SVTV1P0_Reader::getBankSVTMZP(int mz, classname(Bank_SVTRBP) *rbp)
00499 {
00500   // mezzanine counts from 1 to 3
00501   int rb = rbp->header.BankId;
00502   if ((mz < 1) || (mz > 3))
00503   {
00504     char str0[40];
00505     sprintf(str0,"getBankSVTMZP(rb %d  mz %d )",rb,mz);
00506     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00507     return NULL;
00508   }
00509 
00510   // convert to internal representation
00511   mz--;
00512 
00513   if ((!rbp->Mz[mz].offset) || (!rbp->Mz[mz].length))
00514   { 
00515     char str0[40];
00516     sprintf(str0,"getBankSVTMZP(rb %d  mz %d )",rb,mz+1);
00517     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00518     return NULL; 
00519   }
00520 
00521   classname(Bank_SVTMZP) *ptr = (classname(Bank_SVTMZP) *)
00522                      (((INT32 *)rbp) +
00523                       rbp->Mz[mz].offset);
00524 
00525   if(strncmp(ptr->header.BankType,"SVTMZP",6)) {
00526     char str0[40];
00527     sprintf(str0,"getBankSVTMZP(rb %d  mz %d )",rb,mz+1);
00528     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00529   }
00530   if(!ptr->test_CRC()) {
00531     char str0[40];
00532     sprintf(str0,"getBankSVTMZP(rb %d  mz %d )",rb,mz+1);
00533     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00534   }
00535   if(ptr->swap() < 0) { 
00536     char str0[40];
00537     sprintf(str0,"getBankSVTMZP(rb %d  mz %d )",rb,mz+1);
00538     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00539   }
00540   ptr->header.CRC = 0;
00541 
00542 //    printf("getBankSVTMZP Mezz: %d\n",mz);
00543 //    ptr->print();
00544 
00545   return ptr;
00546 }
00547 
00548 classname(Bank_SVTMZP) *SVTV1P0_Reader::getBankSVTMZP(int hypersector, int rb, int mz)
00549 {
00550   //printf("getBankSVTMZP for hypersector %d, rcb %d, mz %d\n",hypersector,rb,mz);
00551 
00552   if ((hypersector < 1) || (hypersector > SVT_HYPERSECTORS))
00553   {
00554     char str0[40];
00555     sprintf(str0,"getBankSVTMZP(sec %d, rb %d, mz %d )",hypersector,rb,mz);
00556     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00557     return NULL;
00558   }
00559 
00560   if ((rb < 1) || (rb > 6))
00561   {
00562     char str0[40];
00563     sprintf(str0,"getBankSVTMZP(sec %d, rb %d, mz %d )",hypersector,rb,mz);
00564     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00565     return NULL;
00566   }
00567 
00568   if ((mz < 1) || (mz > 3))
00569   {
00570     char str0[40];
00571     sprintf(str0,"getBankSVTMZP(sec %d, rb %d, mz %d )",hypersector,rb,mz);
00572     ercpy->fprintError(ERR_BAD_ARG,__FILE__,__LINE__,str0);
00573     return NULL;
00574   }
00575 
00576   // convert to internal representation:
00577   hypersector--;
00578 
00579   // use odd slots 1 and 3
00580   classname(Bank_SVTSECP) *secp = getBankSVTSECP(2*(hypersector/2)+1);
00581   if(!secp) return NULL;
00582 
00583   classname(Bank_SVTRBP) *rbp;
00584   if (hypersector%2)             // internal hypersector odd -> hypersector even -> rb = 7 to 12 
00585     {
00586       rbp = getBankSVTRBP(rb + 6, secp);
00587     }
00588   else                           // internal hypersector even -> hypersector odd -> rb = 1 to 6 
00589     {
00590       rbp = getBankSVTRBP(rb, secp);
00591     }
00592   if(!rbp) return NULL;
00593 
00594   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(mz,rbp);
00595 
00596   return mzp;
00597 }
00598 
00599 classname(Bank_SVTADCD) *SVTV1P0_Reader::getBankSVTADCD(int hypersector, int rb, int mz)
00600 {
00601   errnum = 0;
00602   errstr0[0] = '\0';
00603 
00604   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00605   if(!mzp) return NULL;
00606 
00607 //   printf(" hypersector: %d  RB: %d  MZ: %d\n", hypersector, rb, mz);
00608 //   mzp->print();
00609 
00610   if((!mzp->SVTADCD.offset) || (!mzp->SVTADCD.length))
00611   { 
00612     char str0[40];
00613     sprintf(str0,"getBankSVTADCD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00614     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00615     return NULL; 
00616   }
00617 
00618   classname(Bank_SVTADCD) *ptr = (classname(Bank_SVTADCD) *)
00619                       (((INT32 *)mzp) +
00620                        mzp->SVTADCD.offset);
00621 
00622   if(strncmp(ptr->header.BankType,"SVTADCD",7)) {
00623     char str0[40];
00624     sprintf(str0,"getBankSVTADCD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00625     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00626   }
00627   if(!ptr->test_CRC()) { 
00628     char str0[40];
00629     sprintf(str0,"getBankSVTADCD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00630     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00631   }
00632   if(ptr->swap() < 0) { 
00633     char str0[40];
00634     sprintf(str0,"getBankSVTADCD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00635     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00636   }
00637   ptr->header.CRC = 0;
00638 
00639   return ptr;
00640 }
00641 
00642 classname(Bank_SVTSEQD) *SVTV1P0_Reader::getBankSVTSEQD(int hypersector, int rb, int mz)
00643 {
00644   errnum = 0;
00645   errstr0[0] = '\0';
00646 
00647 
00648   //printf("get mzp\n");
00649   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00650   if(!mzp) return NULL;
00651 
00652   //printf("mzp hypersector: %d  RB: %d  MZ: %d\n", hypersector, rb, mz);
00653   //mzp->print();
00654   
00655 
00656   if((!mzp->SVTSEQD.offset) || (!mzp->SVTSEQD.length))
00657   { 
00658     char str0[40];
00659     sprintf(str0,"getBankSVTSEQD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00660     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00661     return NULL; 
00662   }
00663 
00664   classname(Bank_SVTSEQD) *ptr = (classname(Bank_SVTSEQD) *)
00665                       (((INT32 *)mzp) +
00666                        mzp->SVTSEQD.offset);
00667 
00668 
00669   if(strncmp(ptr->header.BankType,"SVTSEQD",7)) {
00670     char str0[40];
00671     sprintf(str0,"getBankSVTSEQD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00672     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00673   }
00674   if(!ptr->test_CRC()) { 
00675     char str0[40];
00676     sprintf(str0,"getBankSVTSEQD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00677     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00678   }
00679   if(ptr->swap() < 0) { 
00680     char str0[40];
00681     sprintf(str0,"getBankSVTSEQD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00682     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00683   }
00684   ptr->header.CRC = 0;
00685   return ptr;}
00686 
00687 classname(Bank_SVTADCX) *SVTV1P0_Reader::getBankSVTADCX(int hypersector, int rb, int mz)
00688 {
00689   errnum = 0;
00690   errstr0[0] = '\0';
00691 
00692   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00693   if(!mzp) return NULL;
00694 
00695 //   printf(" hypersector: %d  RB: %d  MZ: %d\n", hypersector, rb, mz);
00696 //   mzp->print();
00697 
00698   if((!mzp->SVTADCX.offset) || (!mzp->SVTADCX.length))
00699   { 
00700     char str0[40];
00701     sprintf(str0,"getBankSVTADCX(sec %d rb %d  mz %d )",hypersector,rb,mz);
00702     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00703     return NULL; 
00704   }
00705 
00706   classname(Bank_SVTADCX) *ptr = (classname(Bank_SVTADCX) *)
00707                       (((INT32 *)mzp) +
00708                        mzp->SVTADCX.offset);
00709 
00710   if(strncmp(ptr->header.BankType,"SVTADCX",7)) {
00711     char str0[40];
00712     sprintf(str0,"getBankSVTADCX(sec %d rb %d  mz %d )",hypersector,rb,mz);
00713     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00714   }
00715   if(!ptr->test_CRC()) {
00716     char str0[40];
00717     sprintf(str0,"getBankSVTADCX(sec %d rb %d  mz %d )",hypersector,rb,mz);
00718     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00719   }
00720   if(ptr->swap() < 0) {
00721     char str0[40];
00722     sprintf(str0,"getBankSVTADCX(sec %d rb %d  mz %d )",hypersector,rb,mz);
00723     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00724   }
00725   ptr->header.CRC = 0;
00726 
00727   return ptr;}
00728 
00729 classname(Bank_SVTANODK) *SVTV1P0_Reader::getBankSVTANODK(int hypersector, int rb, int mz)
00730 {
00731   //  cout << "getBankSVTANODK" << endl;
00732   errnum = 0;
00733   errstr0[0] = '\0';
00734 
00735   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00736   if(!mzp) return NULL;
00737 
00738 //   printf(" hypersector: %d  RB: %d  MZ: %d\n", hypersector, rb, mz);
00739 //   mzp->print();
00740 
00741   if((!mzp->SVTANODK.offset) || (!mzp->SVTANODK.length))
00742   { 
00743     char str0[40];
00744     sprintf(str0,"getBankSVTANODK(sec %d rb %d  mz %d )",hypersector,rb,mz);
00745     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00746     return NULL; 
00747   }
00748 
00749   classname(Bank_SVTANODK) *ptr = (classname(Bank_SVTANODK) *)
00750                       (((INT32 *)mzp) +
00751                        mzp->SVTANODK.offset);
00752 
00753   if(strncmp(ptr->header.BankType,"SVTANODK",7)) {
00754     char str0[40];
00755     sprintf(str0,"getBankSVTANODK(sec %d rb %d  mz %d )",hypersector,rb,mz);
00756     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00757   }
00758   if(!ptr->test_CRC()) {
00759     char str0[40];
00760     sprintf(str0,"getBankSVTANODK(sec %d rb %d  mz %d )",hypersector,rb,mz);
00761     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00762   }
00763   if(ptr->swap() < 0) {
00764     char str0[40];
00765     sprintf(str0,"getBankSVTANODK(sec %d rb %d  mz %d )",hypersector,rb,mz);
00766     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00767   }
00768   ptr->header.CRC = 0;
00769 
00770   return ptr;
00771 };
00772 
00773 classname(Bank_SVTCPPR) *SVTV1P0_Reader::getBankSVTCPPR(int hypersector, int rb, int mz)
00774 {
00775   errnum = 0;
00776   errstr0[0] = '\0';
00777   
00778   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00779   if(!mzp) return NULL;
00780 
00781   if((!mzp->SVTCPPR.offset) || (!mzp->SVTCPPR.length))
00782   { 
00783     char str0[40];
00784     sprintf(str0,"getBankSVTCPPR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00785     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00786     return NULL; 
00787   }
00788 
00789   classname(Bank_SVTCPPR) *ptr = (classname(Bank_SVTCPPR) *)
00790                       (((INT32 *)mzp) +
00791                         mzp->SVTCPPR.offset);
00792 
00793   if(strncmp(ptr->header.BankType,"SVTCPPR",7)) {
00794     char str0[40];
00795     sprintf(str0,"getBankSVTCPPR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00796     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00797   }
00798   if(!ptr->test_CRC()) {
00799     char str0[40];
00800     sprintf(str0,"getBankSVTCPPR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00801     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00802   }
00803   if(ptr->swap() < 0) { 
00804     char str0[40];
00805     sprintf(str0,"getBankSVTCPPR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00806     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00807   }
00808   ptr->header.CRC = 0;
00809 
00810   return ptr;       
00811 }
00812 
00813 classname(Bank_SVTADCR) *SVTV1P0_Reader::getBankSVTADCR(int hypersector, int rb, int mz)
00814 {
00815   //printf("getBankSVTADCR for hypersector %d, rcb %d, mz %d\n",hypersector,rb,mz);
00816 
00817   errnum = 0;
00818   errstr0[0] = '\0';
00819   
00820   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00821   if(!mzp) return NULL;
00822 
00823   if((!mzp->SVTADCR.offset) || (!mzp->SVTADCR.length))
00824   { 
00825     char str0[40];
00826     sprintf(str0,"getBankSVTADCR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00827     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00828     return NULL; 
00829   }
00830 
00831   classname(Bank_SVTADCR) *ptr = (classname(Bank_SVTADCR) *)
00832                       (((INT32 *)mzp) +
00833                         mzp->SVTADCR.offset);
00834 
00835   if(strncmp(ptr->header.BankType,"SVTADCR",7)) {
00836     char str0[40];
00837     sprintf(str0,"getBankSVTADCR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00838     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00839   }
00840   if(!ptr->test_CRC()) {
00841     char str0[40];
00842     sprintf(str0,"getBankSVTADCR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00843     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00844   }
00845   if(ptr->swap() < 0) {
00846     char str0[40];
00847     sprintf(str0,"getBankSVTADCR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00848     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00849   }
00850   ptr->header.CRC = 0;
00851 
00852   return ptr;       
00853 }
00854 
00855 classname(Bank_SVTMZCLD) *SVTV1P0_Reader::getBankSVTMZCLD(int hypersector, int rb, int mz)
00856 {
00857   errnum = 0;
00858   errstr0[0] = '\0';
00859   
00860   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00861   if(!mzp) return NULL;
00862 
00863   if((!mzp->SVTMZCLD.offset) || (!mzp->SVTMZCLD.length))
00864   { 
00865     char str0[40];
00866     sprintf(str0,"getBankSVTMZCLD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00867     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00868     return NULL; 
00869   }
00870 
00871   classname(Bank_SVTMZCLD) *ptr = (classname(Bank_SVTMZCLD) *)
00872                       (((INT32 *)mzp) +
00873                         mzp->SVTMZCLD.offset);
00874 
00875   if(strncmp(ptr->header.BankType,"SVTMZCLD",8)) {
00876     char str0[40];
00877     sprintf(str0,"getBankSVTMZCLD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00878     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00879   }
00880   if(!ptr->test_CRC()) { 
00881     char str0[40];
00882     sprintf(str0,"getBankSVTMZCLD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00883     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00884   }
00885   if(ptr->swap() < 0) { 
00886     char str0[40];
00887     sprintf(str0,"getBankSVTMZCLD(sec %d rb %d  mz %d )",hypersector,rb,mz);
00888     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00889   }
00890   ptr->header.CRC = 0;
00891 
00892   return ptr;       
00893 }
00894 
00895 
00896 classname(Bank_SVTCFGR) *SVTV1P0_Reader::getBankSVTCFGR(int hypersector, int rb, int mz)
00897 {
00898   return NULL;
00899 }
00900 
00901 classname(Bank_SVTPEDR) *SVTV1P0_Reader::getBankSVTPEDR(int hypersector, int rb, int mz)
00902 {
00903   errnum = 0;
00904   errstr0[0] = '\0';
00905   
00906   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00907   if(!mzp) return NULL;
00908 
00909   if((!mzp->SVTPEDR.offset) || (!mzp->SVTPEDR.length))
00910   { 
00911     char str0[40];
00912     sprintf(str0,"getBankSVTPEDR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00913     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00914     return NULL; 
00915   }
00916 
00917   classname(Bank_SVTPEDR) *ptr = (classname(Bank_SVTPEDR) *)
00918                       (((INT32 *)mzp) +
00919                         mzp->SVTPEDR.offset);
00920 
00921   if(strncmp(ptr->header.BankType,"SVTPEDR",7)) {
00922     char str0[40];
00923     sprintf(str0,"getBankSVTPEDR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00924     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00925   }
00926   if(!ptr->test_CRC()) { 
00927     char str0[40];
00928     sprintf(str0,"getBankSVTPEDR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00929     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00930   }
00931   if(ptr->swap() < 0) { 
00932     char str0[40];
00933     sprintf(str0,"getBankSVTPEDR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00934     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00935   }
00936   ptr->header.CRC = 0;
00937 
00938   return ptr;       
00939 }
00940 
00941 
00942 classname(Bank_SVTRMSR) *SVTV1P0_Reader::getBankSVTRMSR(int hypersector, int rb, int mz)
00943 {
00944   errnum = 0;
00945   errstr0[0] = '\0';
00946   
00947   classname(Bank_SVTMZP) *mzp = getBankSVTMZP(hypersector, rb, mz);
00948   if(!mzp) return NULL;
00949 
00950   if((!mzp->SVTRMSR.offset) || (!mzp->SVTRMSR.length))
00951   { 
00952     char str0[40];
00953     sprintf(str0,"getBankSVTRMSR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00954     ercpy->fprintError(INFO_MISSING_BANK,__FILE__,__LINE__,str0); 
00955     return NULL; 
00956   }
00957 
00958   classname(Bank_SVTRMSR) *ptr = (classname(Bank_SVTRMSR) *)
00959                       (((INT32 *)mzp) +
00960                         mzp->SVTRMSR.offset);
00961 
00962   if(strncmp(ptr->header.BankType,"SVTRMSR",7)) {
00963     char str0[40];
00964     sprintf(str0,"getBankSVTRMSR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00965     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__,str0); return NULL; 
00966   }
00967   if(!ptr->test_CRC()) { 
00968     char str0[40];
00969     sprintf(str0,"getBankSVTRMSR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00970     ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return NULL; 
00971   }
00972   if(ptr->swap() < 0) { 
00973     char str0[40];
00974     sprintf(str0,"getBankSVTRMSR(sec %d rb %d  mz %d )",hypersector,rb,mz);
00975     ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return NULL; 
00976   }
00977   ptr->header.CRC = 0;
00978 
00979   return ptr;       
00980 }
00981 
00982 classname(Bank_SVTGAINR) *SVTV1P0_Reader::getBankSVTGAINR(int hypersector, int rb, int mz)
00983 {
00984   return NULL;
00985 }
00986 
00987 classname(Bank_SVTBADR) *SVTV1P0_Reader::getBankSVTBADR(int hypersector, int rb, int mz)
00988 {
00989   return NULL;
00990 }
00991