StRoot: StDaqLib/SSD/SSD_Reader.cxx Source File

00001 #include "SSD_Reader.hh"
00002 #include "StDaqLib/EVP/ssdReader.h"
00003 
00004 #include <assert.h>
00005 #include <math.h>
00006 
00007 static unsigned short log8to10_table[256] = {
00008     0,    1,    2,    3,    4,    5,    6,    7,
00009     8,    9,   10,   11,   12,   13,   14,   15,
00010    16,   17,   18,   19,   20,   21,   22,   23,
00011    24,   25,   26,   27,   28,   29,   30,   31,
00012    32,   33,   34,   35,   36,   37,   38,   39,
00013    40,   41,   42,   43,   44,   45,   46,   47,
00014    48,   49,   50,   51,   52,   53,   54,   55,
00015    56,   57,   58,   59,   60,   61,   62,   63,
00016    64,   65,   66,   67,   68,   69,   70,   71,
00017    72,   73,   74,   75,   76,   77,   78,   79,
00018    80,   81,   82,   83,   84,   85,   86,   87,
00019    88,   89,   90,   91,   92,   93,   94,   95,
00020    96,   97,   98,   99,  100,  101,  102,  103,
00021   104,  105,  106,  107,  108,  110,  112,  114,
00022   116,  118,  120,  122,  124,  127,  129,  131,
00023   133,  136,  138,  140,  143,  145,  147,  150,
00024   152,  155,  158,  160,  163,  166,  168,  171,
00025   174,  177,  180,  182,  185,  188,  192,  195,
00026   198,  201,  204,  208,  211,  214,  218,  221,
00027   225,  228,  232,  236,  240,  243,  247,  251,
00028   255,  259,  263,  267,  271,  275,  280,  284,
00029   288,  293,  297,  302,  306,  311,  316,  321,
00030   325,  330,  335,  341,  346,  351,  356,  362,
00031   367,  373,  379,  384,  390,  396,  402,  408,
00032   414,  420,  427,  433,  439,  446,  452,  459,
00033   466,  473,  480,  487,  494,  502,  509,  517,
00034   525,  532,  540,  548,  556,  564,  573,  581,
00035   589,  598,  607,  615,  624,  634,  643,  652,
00036   662,  672,  681,  691,  701,  711,  722,  732,
00037   743,  753,  764,  775,  786,  798,  809,  821,
00038   833,  845,  857,  870,  882,  895,  907,  920,
00039   934,  947,  961,  975,  989, 1003, 1017, 1023 };
00040 
00041 // #include <mapPad.h>
00042 // #include <mapTime.h>
00043 
00044 using namespace OLDEVP;
00045 
00046 int SSD_Reader::ssdData(int  ladder,
00047                         char eastWest,
00048                         int  channel,
00049                         int &data,
00050                         int &ped,
00051                         int &noise) {
00052 
00053   int cnt=0,strip,pad,i,det,pos,mtime,time,daqLadder;
00054   static unsigned int cache1[12288];
00055   static unsigned int cache2[12288];
00056   static int daqLadderInit=-1;
00057 
00058   data = -1; ped  = -1; noise= -1;
00059 
00060   // Set daqLadder.
00061   daqLadder = SSDDaqLadder(eastWest,ladder);
00062 
00063 
00064   
00065   // For speed, we cache the data for one ladder.  Adapted from Boucham's special.C.
00066   if(daqLadderInit!=daqLadder) {
00067     daqLadderInit=daqLadder;
00068     for(i=0;i<12288;i++) { cache1[i]=0; cache2[i]=0; } // This is necessary -- not all members are reset if ssd.mode==0.
00069     if(ssd.mode==0) { // real data
00070       pos=0;
00071       for(time=0;time<192;time++) { // Though "time" is not used explicitly, it's involved in incrementeing "pos".
00072         for(pad=0;pad<64;pad++) {
00073           if (!ssd.counts[daqLadder][pad]) continue;
00074           for(mtime=0;mtime<ssd.counts[daqLadder][pad];mtime++) {
00075             if (time==ssd.strip[daqLadder][pad][mtime])
00076             {
00077               det=pos/768; strip=pos%768;
00078               assert(pos>=0&&pos<12288);
00079               cache1[pos]=log8to10_table[ssd.adc[daqLadder][pad][mtime]];
00080               cnt++;
00081             } // if(time
00082           }   // for(mtime
00083           pos++;
00084         }     // for(pad
00085       }       // for(time
00086     } else if(ssd.mode==1) { // pedestal data
00087       pos=0;
00088       for(time=0;time<192;time++) {
00089         for(pad=0;pad<64;pad++) {
00090           cache1[pos]=ssd.adc[daqLadder][pad][time];
00091           cache2[pos]=ssd.strip[daqLadder][pad][time]; // "strip"s role in ped data is completely different than in real data.
00092           pos++;
00093         }
00094       }
00095     } else {
00096       assert(0); // unknown value of ssd.mode
00097     }
00098   }         // if(daqLadderInit ...
00099 
00100   if(ssd.mode==0) {
00101     data=cache1[channel];
00102   } else if(ssd.mode==1) {
00103     ped=cache1[channel];
00104     noise=cache2[channel];
00105   } else {
00106     assert(0); // unknown value of ssd.mode
00107   }
00108 
00109   return ssd.mode ;
00110 } 
00111 
00112 SSD_Reader::SSD_Reader(EventReader *er) {
00113 
00114   //static int call=0;
00115 
00116   char *datap; // ,ew;
00117 
00118   datap=er->getDATAP(); 
00119   if (datap) {
00120 
00121   unsigned int UTime = er->getEventInfo().UnixTime;
00122   struct tm *time=gmtime((time_t*) &UTime);
00123 
00124   //LDate = (((1900+time->tm_year)*100 + 1 + time->tm_mon)*100 + time->tm_mday)*100;
00125   //LDate = yyyymmdd
00126   //year 2005 = 105 
00127   //month : starts from 0
00128   LDate = (1900+time->tm_year)*10000 + (1 + time->tm_mon)*100 + time->tm_mday;
00129   LTime = (time->tm_hour*100 + time->tm_min)*100 + time->tm_sec;
00130   //cout << "year=" << time->tm_year << " month = " << time->tm_mon << " day=" << time->tm_mday << endl;
00131 #ifndef NEW_DAQ_READER_DAQLIB
00132      OLDEVP::ssdReader(datap); // call the "event pool" code
00133   }
00134 #else
00135   else {
00136      daqReader *rdr=er->getDaqReader(); assert(rdr);
00137      ::ssdReader((char*)rdr); // call the "event pool" code
00138   }
00139 #endif
00140 }
00141 
00142 int SSD_Reader::SSDDaqLadder(char eastWest, int ladder)
00143 {
00144   int daqLadder=-1;
00145   //cout <<"LDate ="   << LDate << endl;
00146   if ( (LDate < 20040731) && (LTime < 1)){
00147     // Year4 data format stops on July 31st 2004 
00148     // cout << "SSD_Reader::SSDDaqLadder : Year4 data " << endl;
00149     switch(eastWest) {
00150     case 'E':
00151       switch(ladder) {
00152       case   1: daqLadder=38; break;
00153       case   2: daqLadder=36; break;
00154       case   3: daqLadder=39; break;
00155       case   9: daqLadder=29; break;
00156       case  10: daqLadder=26; break;
00157       case  11: daqLadder=28; break;
00158       case  12: daqLadder=23; break;
00159       case  13: daqLadder=20; break;
00160       case  19: daqLadder=30; break;
00161       case  20: daqLadder=33; break;
00162       }
00163       break;
00164       
00165     case 'W':
00166       switch(ladder) {
00167       case   1: daqLadder=18; break;
00168       case   2: daqLadder=16; break;
00169       case   3: daqLadder=19; break;
00170       case   9: daqLadder= 9; break;
00171       case  10: daqLadder= 6; break;
00172       case  11: daqLadder= 8; break;
00173       case  12: daqLadder= 3; break;
00174       case  13: daqLadder= 0; break;
00175       case  19: daqLadder=10; break;
00176       case  20: daqLadder=13; break;
00177       }
00178       break;
00179     default: assert(0); // Someone called this function with a bad value of eastWest.
00180     } 
00181   }
00182   if ((LDate >= 20040731) && (LDate <= 20050731))
00183     {
00184       // Year 2005 data format post July 31st 2004
00185       //cout << "SSD_Reader::SSDDaqLadder : Year5 data " << endl;
00186       switch(eastWest) {
00187       case 'E':
00188         switch(ladder) {
00189         case   1: daqLadder=27; break;
00190         case   2: daqLadder=29; break;
00191         case   3: daqLadder=26; break;
00192         case   4: daqLadder=28; break;
00193         case   5: daqLadder=25; break;
00194         case   6: daqLadder=22; break;
00195         case   7: daqLadder=24; break;
00196         case   8: daqLadder=21; break;
00197         case   9: daqLadder=23; break;
00198         case  10: daqLadder=20; break;
00199         case  11: daqLadder=30; break;
00200         case  12: daqLadder=33; break;
00201         case  13: daqLadder=31; break;
00202         case  14: daqLadder=34; break;
00203         case  15: daqLadder=32; break;
00204         case  16: daqLadder=35; break;
00205         case  17: daqLadder=38; break;
00206         case  18: daqLadder=36; break;
00207         case  19: daqLadder=39; break;
00208         case  20: daqLadder=37; break;
00209         }
00210         break;
00211         
00212       case 'W':
00213         switch(ladder) {
00214         case   1: daqLadder=7; break;
00215         case   2: daqLadder=9; break;
00216         case   3: daqLadder=6; break;
00217         case   4: daqLadder=8; break;
00218         case   5: daqLadder=5; break;
00219         case   6: daqLadder=2; break;
00220         case   7: daqLadder=4; break;
00221         case   8: daqLadder=1; break;
00222         case   9: daqLadder=3; break;
00223         case  10: daqLadder=0; break;
00224         case  11: daqLadder=10; break;
00225         case  12: daqLadder=13; break;
00226         case  13: daqLadder=11; break;
00227         case  14: daqLadder=14; break;
00228         case  15: daqLadder=12; break;
00229         case  16: daqLadder=15; break;
00230         case  17: daqLadder=18; break;
00231         case  18: daqLadder=16; break;
00232         case  19: daqLadder=19; break;
00233         case  20: daqLadder=17; break;
00234         }
00235         break;
00236       default: assert(0); // Someone called this function with a bad value of eastWest.
00237       }
00238     }
00239   if(LDate > 20060731) {
00240     // Year 2007 data format post July 31st 2006
00241     //cout << "SSD_Reader::SSDDaqLadder : Year7 data " << endl;
00242     switch(eastWest) {
00243     case 'E':
00244       switch(ladder) {
00245       case   1: daqLadder=27; break;
00246       case   2: daqLadder=29; break;
00247       case   3: daqLadder=26; break;
00248       case   4: daqLadder=28; break;
00249       case   5: daqLadder=25; break;
00250       case   6: daqLadder=22; break;
00251       case   7: daqLadder=24; break;
00252       case   8: daqLadder=21; break;
00253       case   9: daqLadder=23; break;
00254       case  10: daqLadder=20; break;
00255       case  11: daqLadder=30; break;
00256       case  12: daqLadder=33; break;
00257       case  13: daqLadder=31; break;
00258       case  14: daqLadder=34; break;
00259       case  15: daqLadder=32; break;
00260       case  16: daqLadder=35; break;
00261       case  17: daqLadder=38; break;
00262       case  18: daqLadder=36; break;
00263       case  19: daqLadder=39; break;
00264       case  20: daqLadder=37; break;
00265       }
00266       break;
00267       
00268     case 'W':
00269       switch(ladder) {
00270       case   1: daqLadder=17; break;
00271       case   2: daqLadder=19; break;
00272       case   3: daqLadder=16; break;
00273       case   4: daqLadder=18; break;
00274       case   5: daqLadder=15; break;
00275       case   6: daqLadder=12; break;
00276       case   7: daqLadder=14; break;
00277       case   8: daqLadder=11; break;
00278       case   9: daqLadder=13; break;
00279       case  10: daqLadder=10; break;
00280       case  11: daqLadder=0; break;
00281       case  12: daqLadder=3; break;
00282       case  13: daqLadder=1; break;
00283       case  14: daqLadder=4; break;
00284       case  15: daqLadder=2; break;
00285       case  16: daqLadder=5; break;
00286       case  17: daqLadder=8; break;
00287       case  18: daqLadder=6; break;
00288       case  19: daqLadder=9; break;
00289      case  20: daqLadder=7; break;
00290       }
00291       break;
00292     default: assert(0); // Someone called this function with a bad value of eastWest.
00293     }  
00294   }
00295   // Check ladder and eastWest args.  Also check completeness of above switches.
00296   assert(daqLadder>=0 && daqLadder < 40); 
00297   return daqLadder;
00298 }