StRoot: StDaqLib/SVT/SVTV1P0_ADCR

00001 /***************************************************************************
00002  *      
00003  * $Id: SVTV1P0_ADCR_SR.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: // SVT ADC Raw Reader
00010  *      
00011  ***************************************************************************
00012  *
00013  * $Log: SVTV1P0_ADCR_SR.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  2003/09/02 17:55:33  perev
00018  * gcc 3.2 updates + WarnOff
00019  *
00020  * Revision 1.3  2001/05/10 15:19:08  jschamba
00021  * unscrambling of Format = 2 data was done each time initialize was called. Rewrite header
00022  * to indicate Format = 0 after unscrambling prevents this.
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)
00029  *
00030  *
00031  **************************************************************************/
00032 #include <Stiostream.h>
00033 
00034 
00035 #include "StDaqLib/GENERIC/EventReader.hh"
00036 #include "SVTV1P0.hh"
00037 
00038 //==================== ADC Raw  Reader =============================
00039 
00040 using namespace OLDEVP;
00041 
00042 SVTV1P0_ADCR_SR::SVTV1P0_ADCR_SR(int w, SVTV1P0_Reader *det)
00043 {
00044   //  cout << "Constructing SVTV1P0_ADCR_SR" << endl;
00045   barrel = 0;
00046   ladder = 0;
00047   wafer = w; 
00048   detector = det;
00049 
00050   // NULLS in banks array
00051   banks = (classname(Bank_SVTADCR) *)NULL;
00052 }
00053 
00054 SVTV1P0_ADCR_SR::SVTV1P0_ADCR_SR(int b, int l, int w, SVTV1P0_Reader *det)
00055 {
00056   //  cout << "Constructing SVTV1P0_ADCR_SR" << endl;
00057   barrel = b;
00058   ladder = l;
00059   wafer = w; 
00060   detector = det;
00061 
00062   // NULLS in banks array
00063   banks = (classname(Bank_SVTADCR) *)NULL;
00064 }
00065 
00066 int SVTV1P0_ADCR_SR::initialize()
00067 {
00068   // get a sector reader for ANODK
00069   anodkr = detector->getANODKReader();
00070   if (!anodkr) return FALSE;
00071 
00072   int hypersector, rcb, mz;
00073 
00074   ANODK_entry ent;
00075   // store pointers to the ADCR banks
00076   int hybrid = 1; // both hybrids are in same bank
00077   if (barrel)
00078     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00079   else
00080     anodkr->get(wafer, hybrid, &ent);
00081   
00082   hypersector = ent.hypersector;
00083   rcb = ent.rb;
00084   mz = ent.mz;
00085   
00086   /*
00087     printf("SVTV1P0_ADCR_SR::wafer = %d, hybrid = %d, hypersector = %d, rcb = %d, mz = %d\n",
00088     wafer,hybrid,hypersector,rcb,mz);
00089   */
00090 
00091   if ((hypersector) && (rcb) && (mz)) {
00092     banks = detector->getBankSVTADCR(hypersector,rcb,mz);
00093     
00094     if (banks) {
00095       // check the format number for different raw data formats:
00096       if (banks->header.FormatNumber == 2) {
00097         // new format of raw data, need to convert it:
00098         u_char *adc_old = (u_char *)banks->ADC;
00099         u_char adc_new[6][256][128];
00100         for (hybrid=0; hybrid<6; hybrid++) {
00101           u_char *ptr0   = adc_old + hybrid*128*256;
00102           u_char *ptr64  = adc_old + hybrid*128*256 + 1;
00103           u_char *ptr128 = adc_old + hybrid*128*256 + 2;
00104           u_char *ptr192 = adc_old + hybrid*128*256 + 3;
00105           for (int anode=0; anode<64; anode++)
00106             for (int tb=0; tb<128; tb++) {
00107               adc_new[hybrid][anode][tb]     = *ptr0;
00108               adc_new[hybrid][anode+64][tb]  = *ptr64;
00109               adc_new[hybrid][anode+128][tb] = *ptr128;
00110               adc_new[hybrid][anode+192][tb] = *ptr192;
00111               ptr0+=4; ptr64+=4; ptr128+=4; ptr192+=4;
00112             }
00113         }
00114         memcpy((void *)adc_old, (const void *)adc_new, 6*256*128);
00115         // since this now looks like unscrambled (format 0) data
00116         // change the format number in the header to 0
00117         banks->header.FormatNumber = 0;
00118       } // ...if (banks->header.FormatNumber == 2
00119     }   // ...if (banks
00120   }
00121   else
00122     return FALSE;
00123   
00124   return TRUE;
00125 }
00126 
00127 SVTV1P0_ADCR_SR::~SVTV1P0_ADCR_SR()
00128 {
00129   //  cout << "Deleting SVTV1P0_ADCR_SR" << endl;
00130 }
00131 
00132 int SVTV1P0_ADCR_SR::getPadList(int hybrid, u_char **anodeList)
00133 {
00134   // Construct the anodelist array for this PadRow
00135   int i;
00136   ANODK_entry ent;
00137 
00138   // Fill in padrows
00139   int j=0;
00140   for(i=1; i<=SVT_ANODES; i++)
00141   {
00142     if (barrel)
00143       anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00144     else
00145       anodkr->get(wafer, hybrid, &ent);
00146 
00147     if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) continue;
00148     anodelist[hybrid-1][j++] = i;
00149   }
00150           // confusing syntax but correct
00151   *anodeList = &anodelist[hybrid-1][0];
00152   return j;
00153 }
00154 
00155 int SVTV1P0_ADCR_SR::getSequences(int hybrid, int Anode, int *nArray, 
00156                                   u_char **Array)
00157 {
00158   ANODK_entry ent;
00159   if (barrel)
00160     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00161   else
00162     anodkr->get(wafer, hybrid, &ent);
00163 
00164   if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) 
00165   {
00166     *nArray = 0;
00167     *Array = NULL;
00168     spERROR(ERR_BANK);
00169     return -1;
00170   }
00171   
00172   int offset = (ent.offset * anodkr->getADCBytes() * SVT_MZANODES) + 
00173     (anodkr->getADCBytes() * (Anode-1));
00174   *nArray = anodkr->getADCBytes();
00175 
00176   //  printf("Offset = %d\n",offset);
00177   // printf("array coord:  rb=%d,  mz=%d\n",ent.rb,ent.mz);
00178 
00179   if (banks != NULL) 
00180     {
00181       *Array = (((u_char *)banks->ADC) + offset);
00182       //      cout << "SVTV1P0_ADCR_SR::Array = " << *Array << endl;
00183       return 1;
00184     }
00185 
00186   return 0;
00187 }
00188 
00189 int SVTV1P0_ADCR_SR::MemUsed()
00190 {
00191   return 0;
00192 }
00193 
00194 //==================== Pedestal Reader ===========================
00195 
00196 SVTV1P0_PEDR_SR::SVTV1P0_PEDR_SR(int w, SVTV1P0_Reader *det)
00197 {
00198   //  cout << "Constructing SVTV1P0_PEDR_SR" << endl;
00199   barrel = 0;
00200   ladder = 0;
00201   wafer = w; 
00202   detector = det;
00203 
00204   // NULLS in banks array
00205   banks = (classname(Bank_SVTPEDR) *)NULL;
00206   numEvents = 0;
00207 }
00208 
00209 SVTV1P0_PEDR_SR::SVTV1P0_PEDR_SR(int b, int l, int w, SVTV1P0_Reader *det)
00210 {
00211   //  cout << "Constructing SVTV1P0_PEDR_SR" << endl;
00212   barrel = b;
00213   ladder = l;
00214   wafer = w; 
00215   detector = det;
00216 
00217   // NULLS in banks array
00218   banks = (classname(Bank_SVTPEDR) *)NULL;
00219   numEvents = 0;
00220 }
00221 
00222 int SVTV1P0_PEDR_SR::initialize()
00223 {
00224   // get a sector reader for ANODK
00225   anodkr = detector->getANODKReader();
00226   if (!anodkr) return FALSE;
00227 
00228   int hypersector, rcb, mz;
00229 
00230   ANODK_entry ent;
00231   // store pointers to the PEDR banks
00232   int hybrid = 1; // both hybrids are in same bank
00233   if (barrel)
00234     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00235   else
00236     anodkr->get(wafer, hybrid, &ent);
00237   
00238   hypersector = ent.hypersector;
00239   rcb = ent.rb;
00240   mz = ent.mz;
00241   
00242   banks = detector->getBankSVTPEDR(hypersector,rcb,mz);    
00243 
00244   if (banks != NULL) { 
00245     numEvents = banks->NumEvents;
00246     // check the format number for different raw data formats:
00247     if (banks->header.FormatNumber == 2) {
00248       // new format of raw data, need to convert it:
00249       u_char *adc_old = (u_char *)banks->pedestal;
00250       u_char adc_new[6][256][128];
00251       for (hybrid=0; hybrid<6; hybrid++) {
00252         u_char *ptr0   = adc_old + hybrid*128*256;
00253         u_char *ptr64  = adc_old + hybrid*128*256 + 1;
00254         u_char *ptr128 = adc_old + hybrid*128*256 + 2;
00255         u_char *ptr192 = adc_old + hybrid*128*256 + 3;
00256         for (int anode=0; anode<64; anode++)
00257           for (int tb=0; tb<128; tb++) {
00258             adc_new[hybrid][anode][tb]     = *ptr0;
00259             adc_new[hybrid][anode+64][tb]  = *ptr64;
00260             adc_new[hybrid][anode+128][tb] = *ptr128;
00261             adc_new[hybrid][anode+192][tb] = *ptr192;
00262             ptr0+=4; ptr64+=4; ptr128+=4; ptr192+=4;
00263           }
00264       }
00265       memcpy((void *)adc_old, (const void *)adc_new, 6*256*128);
00266       // since this now looks like unscrambled (format 0) data
00267       // change the format number in the header to 0
00268       banks->header.FormatNumber = 0;
00269     } // ...if (banks->header.FormatNumber == 2
00270   }   // ...if (banks != NULL
00271 
00272   return TRUE;
00273 }
00274 
00275 SVTV1P0_PEDR_SR::~SVTV1P0_PEDR_SR()
00276 {
00277   //  cout << "Deleting SVTV1P0_PEDR_SR" << endl;
00278 }
00279 
00280 int SVTV1P0_PEDR_SR::getPadList(int hybrid, u_char **anodeList)
00281 {
00282   // Construct the anodelist array for this PadRow
00283   int i;
00284   ANODK_entry ent;
00285 
00286   // Fill in padrows
00287   int j=0;
00288   for(i=1; i<=SVT_ANODES; i++)
00289   {
00290     if (barrel)
00291       anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00292     else
00293       anodkr->get(wafer, hybrid, &ent);
00294 
00295     if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) continue;
00296     anodelist[hybrid-1][j++] = i;
00297   }
00298           // confusing syntax but correct
00299   *anodeList = &anodelist[hybrid-1][0];
00300   return j;
00301 }
00302 
00303 int SVTV1P0_PEDR_SR::getSequences(int hybrid, int Anode, int *nArray, 
00304                                   u_char **Array)
00305 {
00306   ANODK_entry ent;
00307   if (barrel)
00308     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00309   else
00310     anodkr->get(wafer, hybrid, &ent);
00311 
00312   if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) 
00313   {
00314     *nArray = 0;
00315     *Array = NULL;
00316     spERROR(ERR_BANK);
00317     return -1;
00318   }
00319   
00320   int offset = (ent.offset * anodkr->getPEDBytes() * SVT_MZANODES) + 
00321     (anodkr->getPEDBytes() * (Anode-1));
00322   *nArray = anodkr->getPEDBytes();
00323 
00324   if (banks != NULL) {
00325     //      printf("Offset = %d\n",offset);
00326     //      printf("array coord:  rb=%d,  mz=%d\n",ent.rb,ent.mz);
00327     *Array = (((u_char *)banks->pedestal) + offset);
00328     return 1;
00329   }
00330   return 0;
00331 }
00332 
00333 int SVTV1P0_PEDR_SR::getNumberOfEvents()
00334 {
00335   return numEvents;
00336 }
00337 
00338 int SVTV1P0_PEDR_SR::MemUsed()
00339 {
00340   return 0;
00341 }
00342 
00343 
00344 //==================== RMS  Reader =============================
00345 
00346 SVTV1P0_PRMS_SR::SVTV1P0_PRMS_SR(int w, SVTV1P0_Reader *det)
00347 {
00348   //  cout << "Constructing SVTV1P0_PRMS_SR" << endl;
00349   barrel = 0;
00350   ladder = 0;
00351   wafer = w; 
00352   detector = det;
00353 
00354   // NULLS in banks array
00355   banks = (classname(Bank_SVTRMSR) *)NULL;
00356   numEvents = 0;
00357 
00358 }
00359 
00360 SVTV1P0_PRMS_SR::SVTV1P0_PRMS_SR(int b, int l, int w, SVTV1P0_Reader *det)
00361 {
00362   //  cout << "Constructing SVTV1P0_PRMS_SR" << endl;
00363   barrel = b;
00364   ladder = l;
00365   wafer = w; 
00366   detector = det;
00367 
00368   // NULLS in banks array
00369   banks = (classname(Bank_SVTRMSR) *)NULL;
00370   numEvents = 0;
00371 }
00372 
00373 int SVTV1P0_PRMS_SR::initialize()
00374 {
00375   // get a sector reader for ANODK
00376   anodkr = detector->getANODKReader();
00377   if (!anodkr) return FALSE;
00378 
00379   int hypersector, rcb, mz;
00380 
00381   ANODK_entry ent;
00382   // store pointers to the ADCR banks
00383   int hybrid = 1;
00384   if (barrel)
00385     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00386   else
00387     anodkr->get(wafer, hybrid, &ent);
00388   
00389   hypersector = ent.hypersector;
00390   rcb = ent.rb;
00391   mz = ent.mz;
00392   
00393   banks = detector->getBankSVTRMSR(hypersector,rcb,mz);    
00394   
00395   if (banks != NULL) { 
00396     numEvents = banks->NumEvents;
00397 
00398     // check the format number for different raw data formats:
00399     if (banks->header.FormatNumber == 2) {
00400       // new format of raw data, need to convert it:
00401       u_char *adc_old = (u_char *)banks->pedRMSt16;
00402       u_char adc_new[6][256][128];
00403       for (hybrid=0; hybrid<6; hybrid++) {
00404         u_char *ptr0   = adc_old + hybrid*128*256;
00405         u_char *ptr64  = adc_old + hybrid*128*256 + 1;
00406         u_char *ptr128 = adc_old + hybrid*128*256 + 2;
00407         u_char *ptr192 = adc_old + hybrid*128*256 + 3;
00408         for (int anode=0; anode<64; anode++)
00409           for (int tb=0; tb<128; tb++) {
00410             adc_new[hybrid][anode][tb]     = *ptr0;
00411             adc_new[hybrid][anode+64][tb]  = *ptr64;
00412             adc_new[hybrid][anode+128][tb] = *ptr128;
00413             adc_new[hybrid][anode+192][tb] = *ptr192;
00414             ptr0+=4; ptr64+=4; ptr128+=4; ptr192+=4;
00415           }
00416       }
00417       memcpy((void *)adc_old, (const void *)adc_new, 6*256*128);
00418       // since this now looks like unscrambled (format 0) data
00419       // change the format number in the header to 0
00420       banks->header.FormatNumber = 0;
00421     } // ...if (banks->header.FormatNumber == 2
00422   }   // ...if (banks !=NULL
00423 
00424   return TRUE;
00425 }
00426 
00427 SVTV1P0_PRMS_SR::~SVTV1P0_PRMS_SR()
00428 {
00429   //  cout << "Deleting SVTV1P0_PRMS_SR" << endl;
00430 }
00431 
00432 int SVTV1P0_PRMS_SR::getPadList(int hybrid, u_char **anodeList)
00433 {
00434   // Construct the anodelist array for this PadRow
00435   int i;
00436   ANODK_entry ent;
00437 
00438   // Fill in padrows
00439   int j=0;
00440   for(i=1; i<=SVT_ANODES; i++)
00441   {
00442     if (barrel)
00443       anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00444     else
00445       anodkr->get(wafer, hybrid, &ent);
00446 
00447     if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) continue;
00448     anodelist[hybrid-1][j++] = i;
00449   }
00450           // confusing syntax but correct
00451   *anodeList = &anodelist[hybrid-1][0];
00452   return j;
00453 }
00454 
00455 int SVTV1P0_PRMS_SR::getSequences(int hybrid, int Anode, int *nArray, 
00456                                   u_char **Array)
00457 {
00458   ANODK_entry ent;
00459   if (barrel)
00460     anodkr->get(barrel, ladder, wafer, hybrid, &ent);
00461   else
00462     anodkr->get(wafer, hybrid, &ent);
00463 
00464   if((ent.mz == 0) || (ent.rb == 0) || (ent.hypersector == 0)) 
00465   {
00466     *nArray = 0;
00467     *Array = NULL;
00468     spERROR(ERR_BANK);
00469     return -1;
00470   }
00471   
00472   int offset = (ent.offset * anodkr->getRMSBytes() * SVT_MZANODES) + 
00473     (anodkr->getRMSBytes() * (Anode-1));
00474   *nArray = anodkr->getRMSBytes();
00475 
00476   if (banks != NULL)
00477     {
00478       // printf("Offset = %d\n",offset);
00479       // printf("array coord:  rb=%d,  mz=%d\n",ent.rb,ent.mz);
00480       *Array = (((u_char *)banks->pedRMSt16) + offset);
00481       return 1;
00482     }
00483   return 0;
00484 }
00485 
00486 int SVTV1P0_PRMS_SR::getNumberOfEvents()
00487 {
00488   return numEvents;
00489 }
00490 
00491 int SVTV1P0_PRMS_SR::MemUsed()
00492 {
00493   return 0;
00494 }
00495 
00496
StDaqLib/SVT/SVTV1P0_ADCR_SR.cxx
