StRoot: StDaqLib/SVT/SVTV1P0_ZS

00001 /***************************************************************************
00002  *      
00003  * $Id: SVTV1P0_ZS_SR.cxx,v 1.8 2007/12/24 06:04:28 fine Exp $
00004  *      
00005  * Author: J. Schambach
00006  *      
00007  ***************************************************************************
00008  *      
00009  * Description: SVT Zero Suppressed Reader
00010  *      
00011  ***************************************************************************
00012  *      
00013  * $Log: SVTV1P0_ZS_SR.cxx,v $
00014  * Revision 1.8  2007/12/24 06:04:28  fine
00015  * introduce OLDEVP namespace to allow ole and new EVP library concurrently
00016  *
00017  * Revision 1.7  2007/08/07 19:44:10  perev
00018  * Gene scalers added
00019  *
00020  * Revision 1.6  2007/01/04 21:27:51  jml
00021  * zero suppressed reader no longer uses adcx, only seqd.  Fixes bug from early 2005
00022  *
00023  * Revision 1.5  2003/09/02 17:55:33  perev
00024  * gcc 3.2 updates + WarnOff
00025  *
00026  * Revision 1.4  2003/02/20 21:39:45  ward
00027  * Remove voluminous warning message.
00028  *
00029  * Revision 1.3  2001/05/14 16:07:36  jschamba
00030  * corrected mezzanine and transition board evaluation in constructors
00031  *
00032  * Revision 1.2  2001/04/18 19:47:25  ward
00033  * StDaqLib/SVT stuff from Jo Schambach.
00034  *
00035  * Revision 1.1  2000/06/06 18:08:31  jml
00036  * Initial version of SVT Readers (author: marcello munholz, helen caines)
00037  *
00038  *      
00039  **************************************************************************/
00040 #include <Stiostream.h>
00041 
00042 #include "StDaqLib/GENERIC/EventReader.hh"
00043 #include "SVTV1P0.hh"
00044 // 
00045 using namespace OLDEVP;
00046 SVTV1P0_ZS_SR::SVTV1P0_ZS_SR(int w, SVTV1P0_Reader *det)
00047 {
00048   int w1;
00049   int numberOfLadders[3] = {8,12,16};
00050   int numberOfWafers[3] = {4,6,7};
00051   /*
00052    * The relationship between waferIndex (w [0..215]) and the triplet
00053    * (barrel[1..3], ladder[1..8,12,16], wafer[1..4,6,7]) is as follows:
00054    * w = 0 is wafer = 1, ladder = 1, barrel = 1
00055    * w = 1 is wafer = 2, ladder = 1, barrel = 1
00056    * ...
00057    * w = 4 is wafer = 1, ladder = 2, barrel = 1
00058    * ...
00059    * w = 32 is wafer = 1, ladder = 1, barrel = 2
00060    * ...
00061    * w = 215 is wafer = 7, ladder = 16, barrel = 3
00062    */
00063 
00064   if (w < (numberOfWafers[0] * numberOfLadders[0])) {
00065     barrel = 1;
00066     ladder = w/numberOfWafers[0] + 1;
00067     wafer = w%numberOfWafers[0] + 1;
00068   }
00069   else if( (w1 = w - numberOfWafers[0]*numberOfLadders[0]) <
00070            (numberOfWafers[1] * numberOfLadders[1])) {
00071     barrel = 2;
00072     ladder = w1/numberOfWafers[1] + 1;
00073     wafer = w1%numberOfWafers[1] + 1;
00074   }
00075   else {
00076     w1 = w - numberOfWafers[0]*numberOfLadders[0]
00077       - numberOfWafers[1]*numberOfLadders[1];
00078     barrel = 3;
00079     ladder = w1/numberOfWafers[2] + 1;
00080     wafer = w1%numberOfWafers[2] + 1;
00081   }
00082 
00083   detector = det;
00084 
00085   // Now determine the hypersector, receiver board and mezzanine for this wafer
00086   switch (barrel) {
00087   case 1: 
00088     {
00089       const int mezzIndex[] = {1,2,2,1};
00090       if (wafer > 2) hyperSector = 1;
00091       else hyperSector = 3;
00092       rcb = (ladder-1)/2 + ladder;
00093       mezz = mezzIndex[wafer-1];
00094       transitionBoard = 2;
00095       break;
00096     }
00097   case 2:
00098     {
00099       const int mezzIndex[3][6] = { {1,1,3,3,1,1},
00100                                     {1,2,3,3,2,1},
00101                                     {2,2,3,3,2,2} };
00102       if (wafer > 3) hyperSector = 1;
00103       else hyperSector = 3;
00104       rcb = (ladder+2)/3;
00105       rcb *= 3;
00106       mezz = mezzIndex[(ladder-1)%3][wafer-1];
00107       transitionBoard = (ladder-1)%3 + 1;
00108       break;
00109     }
00110   case 3: 
00111     {
00112       const int mezzIndex[] = {2,2,3,3,3,1,1};
00113       if (wafer > (4-(ladder%2))) hyperSector = 1;
00114       else hyperSector = 3;
00115       rcb = (ladder-1)/4 + (ladder+1)/2;
00116       if (ladder%2) { //odd ladders 
00117         mezz = mezzIndex[wafer-1];
00118         if (hyperSector == 1) transitionBoard = 1;
00119         else transitionBoard = 3;
00120       }
00121       else { //even ladders
00122         mezz = mezzIndex[7-wafer];
00123         if (hyperSector == 1) transitionBoard = 3;
00124         else transitionBoard = 1;
00125       }
00126       break;
00127     }
00128   }
00129 
00130   if (rcb > 6) {
00131     hyperSector++;
00132     rcb -= 6;
00133   }
00134     
00135   /*
00136     printf("barrel %d, ladder %d, wafer %d hs %d rcb %d, mezz %d tb %d\n", 
00137     barrel, ladder, wafer, hyperSector, rcb, mezz, transitionBoard);
00138   */
00139 
00140   // NULLS in banks array
00141   adcd_p = (classname(Bank_SVTADCD) *)NULL;
00142   adcx_p = (classname(Bank_SVTADCX) *)NULL;
00143   seqd_p = (classname(Bank_SVTSEQD) *)NULL;
00144 
00145   for (int ii=0; ii<SVT_HYBRIDS; ii++) HybridSpacePts[ii] = 0;
00146 }
00147 
00148 SVTV1P0_ZS_SR::SVTV1P0_ZS_SR(int b, int l, int w, SVTV1P0_Reader *det)
00149 {
00150   barrel = b;
00151   ladder = l;
00152   wafer = w;
00153   detector = det;
00154 
00155   // Now determine the hypersector, receiver board and mezzanine for this wafer
00156   switch (barrel) {
00157   case 1: 
00158     {
00159       const int mezzIndex[] = {1,2,2,1};
00160       if (wafer > 2) hyperSector = 1;
00161       else hyperSector = 3;
00162       rcb = (ladder-1)/2 + ladder;
00163       mezz = mezzIndex[wafer-1];
00164       transitionBoard = 2;
00165       break;
00166     }
00167   case 2:
00168     {
00169       const int mezzIndex[3][6] = { {1,1,3,3,1,1},
00170                                     {1,2,3,3,2,1},
00171                                     {2,2,3,3,2,2} };
00172       if (wafer > 3) hyperSector = 1;
00173       else hyperSector = 3;
00174       rcb = (ladder+2)/3;
00175       rcb *= 3;
00176       mezz = mezzIndex[(ladder-1)%3][wafer-1];
00177       transitionBoard = (ladder-1)%3 + 1;
00178       break;
00179     }
00180   case 3: 
00181     {
00182       const int mezzIndex[] = {2,2,3,3,3,1,1};
00183       if (wafer > (4-(ladder%2))) hyperSector = 1;
00184       else hyperSector = 3;
00185       rcb = (ladder-1)/4 + (ladder+1)/2;
00186       if (ladder%2) { //odd ladders 
00187         mezz = mezzIndex[wafer-1];
00188         if (hyperSector == 1) transitionBoard = 1;
00189         else transitionBoard = 3;
00190       }
00191       else { //even ladders
00192         mezz = mezzIndex[7-wafer];
00193         if (hyperSector == 1) transitionBoard = 3;
00194         else transitionBoard = 1;
00195       }
00196       break;
00197     }
00198   }
00199 
00200   if (rcb > 6) {
00201     hyperSector++;
00202     rcb -= 6;
00203   }
00204     
00205   // NULLS in banks array
00206   adcd_p = (classname(Bank_SVTADCD) *)NULL;
00207   adcx_p = (classname(Bank_SVTADCX) *)NULL;
00208   seqd_p = (classname(Bank_SVTSEQD) *)NULL;
00209 
00210   for (int ii=0; ii<SVT_HYBRIDS; ii++) HybridSpacePts[ii] = 0;
00211 }
00212 
00213 int SVTV1P0_ZS_SR::initialize()
00214 {
00215 //   printf("zs init\n");
00216 //   fflush(stdout);
00217 
00218   for (int hyb=0; hyb<SVT_HYBRIDS; hyb++) {
00219     for (int anode=0; anode<SVT_ANODES; anode++) {
00220       Anode_array[hyb][anode].nseq = 0;
00221       Anode_array[hyb][anode].seq = (Sequence *)0;
00222     }
00223   }
00224 
00225   // printf("Looking for ADCD, ADCX, and SEQD banks...\n");
00226   adcd_p = detector->getBankSVTADCD(hyperSector, rcb, mezz);
00227   if ((void *)adcd_p != NULL) {
00228     if (detector->ercpy->verbose) printf("found ADCD RB%d MZ%d\n",rcb,mezz);
00229     fflush(stdout);
00230   }
00231 
00232   seqd_p = detector->getBankSVTSEQD(hyperSector, rcb, mezz);
00233 
00234   if ((void *)seqd_p != NULL) {
00235     if (detector->ercpy->verbose) printf("found SEQD RB%d MZ%d\n",rcb,mezz);
00236     fflush(stdout);
00237   }
00238 
00239   if((adcd_p == NULL) || (seqd_p == NULL)) {  // perfectly valid, just no data...
00240     return TRUE;
00241   }
00242 
00243 //   printf("got banks  (adcd_p = 0x%x seqd = 0x%x)\n",adcd_p,seqd_p);
00244 //   fflush(stdout);
00245 
00246   // number of entries in SVTSEQD bank
00247   int banklen = seqd_p->header.BankLength - (sizeof(Bank_Header)/4);
00248   int numseq = (4*banklen)/sizeof(short);
00249 
00250   // now loop through the hybrids of this wafer
00251   for (int hybrid=1; hybrid<=SVT_HYBRIDS; hybrid++) {
00252     INT32 hybridID = 
00253       hybrid | 
00254       (wafer << 2) |
00255       (transitionBoard << 5);
00256     int i;
00257 
00258     int adcd_offset = 0;
00259     int seqd_offset = 0;
00260     int found = 0;
00261     for(i=0;i<numseq;i++) {
00262       unsigned short x = seqd_p->sequence[i];
00263 
00264       if(x & 0x8000) {    // This is an index entry...
00265 //      printf("[%d] index %d/%d\n",
00266 //             i,(x & 0x7fff)/256,(x&0x7fff)%256);
00267 //      fflush(stdout);
00268 
00269         if((x & 0x7fff) / 256 == hybridID) {
00270           found = 1;
00271           seqd_offset = i;
00272           break;
00273         }
00274       }
00275       else {              // This is a sequence entry...
00276 //      printf("[%d] seq %d %d %d\n",
00277 //             i,
00278 //             (x & 0x7fc0)>>6, 
00279 //             x & 0x20, 
00280 //             x & 0x1f);
00281 //      fflush(stdout);
00282 
00283         adcd_offset += x & 0x1f;   // in adc counts...
00284       }
00285     }
00286 
00287 
00288 
00289  //    printf("hybridID = %d  found = %d  adcd_off = %d,  seqd_off = %d\n",
00290 //         hybridID, found, adcd_offset, seqd_offset);
00291 //     fflush(stdout);
00292    
00293 
00294     if(!found) continue;
00295 
00296 
00297     /********************************************/
00298     // go through the SEQD twice:
00299     // First:  malloc the Sequence arrays needed
00300     // Second: fill in the Sequence structs
00301     /********************************************/
00302     i = seqd_offset;
00303     int anode = -1, oldtb=0;
00304     while (i < numseq) { 
00305       if (seqd_p->sequence[i] & 0x8000) { // index descriptor
00306         anode = (seqd_p->sequence[i])& 0xff;
00307         INT32 seq_hybridID = (seqd_p->sequence[i]>>8)& 0x7f;
00308 
00309         if (seq_hybridID != hybridID) break; //start of the next hybrid
00310         if (anode == 255) break;
00311         oldtb=0;
00312       }
00313       else { // sequence descriptor
00314         unsigned short work = seqd_p->sequence[i];
00315         int tb = (work>>6) & 0xff;
00316 //      int len = work & 0x1f;
00317         int last = work & 0x20;
00318 
00319         if(oldtb > tb) {
00320           printf("Time bins are messed up old=%d, new=%d\n",oldtb,tb);
00321         }
00322 
00323         oldtb = tb;
00324 
00325         Anode_array[hybrid-1][anode-1].nseq++;
00326         if(last) {
00327           char *t = (char *)malloc(Anode_array[hybrid-1][anode-1].nseq *
00328                            sizeof(Sequence));
00329       
00330           Anode_array[hybrid-1][anode-1].seq = (Sequence *)t;
00331 
00332           if(!t) {
00333             printf("Failed to malloc() sequence structures\n");
00334             fflush(stdout);
00335             return FALSE;
00336           }
00337 
00338           anode++;
00339           oldtb = 0;
00340         }
00341       }
00342       i++;
00343     }
00344 
00345 //     printf("pass1 done\n");
00346 //     fflush(stdout);
00347 
00348     /************************************************************/
00349     /* Now process SVTSEQD again to fill in the sequence arrays */
00350     /************************************************************/
00351     
00352     u_char *adc_locn = (u_char *)&(adcd_p->ADC[adcd_offset]);
00353     i = seqd_offset;
00354     int anode_seq = 0;
00355     while (i < numseq) {
00356       if (seqd_p->sequence[i] & 0x8000) { // index element
00357         anode = (seqd_p->sequence[i])& 0xff;
00358         INT32 seq_hybridID = (seqd_p->sequence[i]>>8)& 0x7f;
00359 
00360         if (anode == 255) break; // anode 255 is the last word as a filler
00361         if (seq_hybridID != hybridID) break; //start of the next hybrid
00362 
00363         anode_seq = 0;
00364       } // ...if (seqd_p->sequence[i] < 0
00365       else { // sequence descriptor element
00366         unsigned short work = seqd_p->sequence[i];
00367         int tb = (work>>6) & 0xff;
00368         int len = work & 0x1f;
00369         int last = work & 0x20;
00370 
00371         Anode_array[hybrid-1][anode-1].seq[anode_seq].startTimeBin = tb;
00372         Anode_array[hybrid-1][anode-1].seq[anode_seq].Length = len;
00373         Anode_array[hybrid-1][anode-1].seq[anode_seq].FirstAdc = adc_locn;
00374         adc_locn +=len;
00375         anode_seq++;
00376 
00377       
00378         if(last) { //last sequence ?
00379           anode++;    // default to next pad in this padrow
00380           anode_seq = 0;
00381         }
00382       }   
00383       i++;
00384     }
00385 
00386 //     printf("pass 2 done\n");
00387 //     fflush(stdout);
00388   }
00389 
00390   return TRUE;
00391 }
00392 
00393 SVTV1P0_ZS_SR::~SVTV1P0_ZS_SR()
00394 {
00395   // free memory allocated for Sequence arrays
00396   for (int hyb=0; hyb<SVT_HYBRIDS; hyb++) {
00397     for (int anode=0; anode<SVT_ANODES; anode++) {
00398       void *memaddr = Anode_array[hyb][anode].seq;
00399       if (memaddr) free (memaddr);
00400     }
00401     if (HybridSpacePts[hyb]) 
00402       free(HybridSpacePts[hyb]);
00403   }
00404 }
00405 
00406 int SVTV1P0_ZS_SR::getPadList(int Hybrid, u_char **anodeList)
00407 {
00408   if ((Hybrid < 1) || (Hybrid > 2)) return -1;
00409 
00410   // fill in hybrid anode list
00411   int anode, nanode=0;
00412   for (anode=1; anode<241; anode++) {
00413     if (Anode_array[Hybrid-1][anode-1].nseq) 
00414       anodelist[Hybrid-1][nanode++] = anode;
00415   }
00416 
00417   *anodeList = &anodelist[Hybrid-1][0];
00418 
00419   return nanode;
00420 }
00421 
00422 int SVTV1P0_ZS_SR::getSequences(int Hybrid, int Anode, int *nSeq, 
00423                                 Sequence **SeqData)
00424 {
00425   *nSeq = Anode_array[Hybrid-1][Anode-1].nseq; // number of sequences this anode
00426   *SeqData = Anode_array[Hybrid-1][Anode-1].seq; // pass back pointer to Sequence array
00427   return 0;
00428 }
00429 
00430 int SVTV1P0_ZS_SR::getFeeSequences(int Fee, int Pin, int *nSeq, 
00431                                 Sequence **SeqData)
00432 {
00433   return 0;
00434 }
00435 
00436 
00437 // Read the clusters (space points) found in the mezzanine cluster-finder
00438 int SVTV1P0_ZS_SR::getSpacePts(int Hybrid, int *nSpacePts, SpacePt **SpacePts)
00439 {
00440   classname(Bank_SVTMZCLD) *cld;
00441 //  int numSpPts = 0; 
00442   INT32 hybridID =
00443     Hybrid | 
00444     (wafer << 2) |
00445     (transitionBoard << 5);
00446 
00447   *nSpacePts = 0;
00448   *SpacePts = HybridSpacePts[Hybrid-1];
00449 
00450   // make sure the array is empty to begin with
00451   if (HybridSpacePts[Hybrid-1]) 
00452     free(HybridSpacePts[Hybrid-1]);
00453   
00454   cld = detector->getBankSVTMZCLD(hyperSector, rcb, mezz);
00455 
00456   if (cld == (classname(Bank_SVTMZCLD) *)NULL) {
00457     // SVTMZCLD bank doesn't exist
00458     if (detector->ercpy->verbose) {
00459       printf("SVTMZCLD for HS %d, Receiver %d, Mezz %d does not exist\n",
00460              hyperSector, rcb, mezz);
00461       fflush(stdout);
00462     }
00463   }
00464   else { // SVTMZCLD bank exists
00465     int numHybrids = cld->NumHybrids;
00466     if (numHybrids > 0) { // are there any entries?
00467       int *ptr = (int *)&cld->stuff;
00468       int i = 0;
00469       while (i < numHybrids) {
00470         INT32 cld_hybridID = *ptr++;
00471         int nsp = *ptr++; // number of space points this hybrid
00472         if (cld_hybridID == hybridID) { // found the right hybrid
00473           if (detector->ercpy->verbose) 
00474             cout << "Barrel " << barrel <<"ladder " << ladder <<"wafer "
00475                  << wafer << " hybrid " << Hybrid << ": found " 
00476                  << nsp << " space pts" << endl;
00477   
00478           HybridSpacePts[Hybrid-1] = (SpacePt *)malloc(nsp *sizeof(struct SpacePt));
00479           if (HybridSpacePts[Hybrid] == NULL) {
00480             cout << "failed to malloc() Space Point structures " << endl;
00481             return FALSE;
00482           }
00483           // now fill in the spacepoints
00484           for (int isp=0; isp<nsp; isp++, ptr+=2) {
00485             HybridSpacePts[Hybrid-1][isp] = *(SpacePt *)ptr;
00486           }
00487           *nSpacePts = nsp;
00488           break;
00489         }
00490         ptr += 2*nsp; // move pointer over spacepoints for this hybrid
00491         i++;
00492       } // ...while (int i < numHybrids
00493     }   // ...if (cld->NumHybrids > 0
00494   }     // ...else { SVTMZCLD bank exists
00495   
00496   return TRUE;
00497 }
00498 
00499 
00500 int SVTV1P0_ZS_SR::MemUsed()
00501 {
00502   return 0;
00503 }
00504
StDaqLib/SVT/SVTV1P0_ZS_SR.cxx
