StRoot: StDaqLib/PMD/PMD_Reader.cxx Source File

00001 /***************************************************************************
00002  * Author: Susanta and Subhasis 
00003  *
00004  * Description: Description : Reads PMD Raw and Pedestals Data and fills PMD Specific Bank.
00005  *              PMD has been taken as Extended Detector as defined by Tonko.
00006  *              Designed based on Event Pool Reader of PMD ( Ref: Tonko )
00007  **************************************************************************/
00008 
00009 #include "PMD_Reader.hh"
00010 #include <assert.h>
00011 #define MAX_ADC 0xFFF 
00012 
00013 using namespace OLDEVP;
00014 
00015 int PMD_Reader::ProcessEvent(const Bank_PMDP * PmdPTR)
00016 {
00017      int sec, type, ret;
00018       unsigned int Token;
00019       Token=PmdPTR->header.Token;
00020       printf("PMD Token = %d\n", Token);
00021        
00022       mThePmd.mode = 0;
00023       mThePmd.channels = 0;
00024       mThePmd.max_channels = 2*PMD_CRAMS_MAX*2*PMD_CRAMS_CH_MAX ;  
00025       
00026 
00027    for(sec=0; sec<2; sec++) {
00028       if(PmdPTR->sec[sec].length == 0) continue;           
00029       Bank_PMDSECP *secp = (Bank_PMDSECP *)(((INT32 *)PmdPTR) + PmdPTR->sec[sec].offset);
00030   //    cout << "in Process Event==>"<<secp->header.BankType << endl;
00031       if(strncmp(secp->header.BankType,"PMDSECP",7))
00032       {
00033         char str0[40];
00034         cout<<" PMDSECP error in header name**"<<endl;
00035         sprintf(str0,"Not PMDSECP");
00036         ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return 0;
00037       }
00038 
00039       if(!secp->test_CRC())
00040       {
00041         char str0[40];
00042         cout<<"error in CRC**"<<endl;
00043         sprintf(str0,"Not PMDSECP");
00044         ercpy->fprintError(ERR_CRC,__FILE__,__LINE__,str0); return 0;
00045        }
00046       if(secp->swap() < 0)
00047       {
00048        char str0[40];
00049        cout<<"error in swap**"<<endl;
00050        sprintf(str0," PMDSECP");
00051        ercpy->fprintError(ERR_SWAP,__FILE__,__LINE__,str0); return 0;
00052       }
00053      secp->swap();  // Swapping is required to get the offset
00054      for( type=0; type < 4; type ++) {
00055            //  cout<<"sec="<< sec <<"type" <<type << "length="<<secp->type[type].length << endl;
00056              if(secp->type[type].length ==0 ) continue;
00057              switch(type){
00058                      case PMD_ADCD_N :
00059                          {
00060                            // cout<<"adcd off=" << secp->type[type].offset << endl;
00061                             Bank_PMDADCD *adcd = (Bank_PMDADCD *)(((INT32 *)secp) + secp->type[type].offset);
00062                             //cout << "in Process Event==>"<<adcd->header.BankType << endl;
00063                             if(strncmp(adcd->header.BankType,"PMDADCD",7))
00064                            {
00065                               char str0[40];
00066                               cout<<" PMDADCD error in header name**"<<endl;
00067                               sprintf(str0,"Not PMDADCD");
00068                               ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return 0;
00069                             }
00070                             ret = adcReader(sec, adcd);
00071                             if(ret) mThePmd.channels += ret;
00072                            //  printf("after adcReader ret=%d\n", ret);
00073                          }
00074                          break; 
00075                         case PMD_PEDR_N :
00076                                 {
00077                               // cout<<"sec"<<sec<<"type="<< type<<"pedr off=" << secp->type[type].offset << endl;
00078                                   Bank_PMDPEDR *pedr = (Bank_PMDPEDR *)(((INT32 *)secp) + secp->type[type].offset);
00079                                 //  cout << "in Process Event==>"<<pedr->header.BankType << endl;
00080                                   if(strncmp(pedr->header.BankType,"PMDPEDR",7))
00081                                   {
00082                                     char str0[40];
00083                                     cout<<" PMDPEDR error in header name**"<<endl;
00084                                     sprintf(str0,"Not PMDPEDR");
00085                                     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return 0;
00086                                   }
00087                                   ret = pedReader(sec, type, pedr);
00088                                   if(ret) mThePmd.channels += ret;
00089                                   mThePmd.mode = 1;
00090                                 }
00091                                   break;
00092 
00093                         case PMD_RMSR_N :
00094                                 {
00095                                  //cout<<"sec"<<sec<<"type="<< type<<"rmsr off=" << secp->type[type].offset << endl;
00096                                   Bank_PMDPEDR *rmsr = (Bank_PMDPEDR *)(((INT32 *)secp) + secp->type[type].offset);
00097                            //       cout << "in Process Event==>"<<pedr->header.BankType << endl;
00098                                   if(strncmp(rmsr->header.BankType,"PMDRMSR",7))
00099                                   {
00100                                     char str0[40];
00101                                     cout<<" PMDRMSR error in header name**"<<endl;
00102                                     sprintf(str0,"Not PMDRMSR");
00103                                     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return 0;
00104                                   }
00105                                   ret = pedReader(sec, type, rmsr);
00106                                   if(ret) mThePmd.channels += ret;
00107                                   mThePmd.mode = 1;
00108                                 }
00109 
00110                                   break;
00111                         case PMD_THRR_N :
00112                                 {
00113                                   Bank_PMDPEDR *thrr = (Bank_PMDPEDR *)(((INT32 *)secp) + secp->type[type].offset);
00114                            //       cout << "in Process Event==>"<<pedr->header.BankType << endl;
00115                                   if(strncmp(thrr->header.BankType,"PMDTHRR",7))
00116                                   {
00117                                     char str0[40];
00118                                     cout<<" PMDTHRR error in header name**"<<endl;
00119                                     sprintf(str0,"Not PMDTHRR");
00120                                     ercpy->fprintError(ERR_BAD_HEADER,__FILE__,__LINE__, str0); return 0;
00121                                   }
00122                                   ret = pedReader(sec, type, thrr);
00123                                   if(ret) mThePmd.channels += ret;
00124                                   mThePmd.mode = 1;
00125                                 }
00126                                   break;
00127                 }
00128            }
00129       }
00130       return 1;
00131 }
00132 
00133 
00134 int PMD_Reader::adcReader(int sec, Bank_PMDADCD *adcd)
00135 {
00136  adcd->swap();
00137  int items = adcd->header.BankLength -(INT32)sizeof(Bank_Header)/4 ;
00138 
00139  unsigned int *datum ;
00140  unsigned int j ;
00141  unsigned int cram, blk ;
00142  unsigned int ch_num ;
00143  unsigned int ch ;
00144 
00145  if(items <= 0) return 0 ;
00146                   
00147                   
00148  datum = (unsigned int *)adcd->data ;
00149                           
00150  ch_num = 0 ;
00151                                                   
00152 //printf("PMD sec %d: items %d\n",sec,items) ;
00153 // 
00154  unsigned int *end_datum = datum + items ;
00155        
00156  for(end_datum=datum+items;datum<end_datum;) {
00157      unsigned int tmp = *datum ;
00158      datum++ ;
00159 
00160      cram = (tmp & 0xFF000000) >> 24 ;
00161      blk = (tmp & 0x00FF0000) >> 16 ;
00162      ch = (tmp & 0x0000FFFF) ;
00163                            
00164      mThePmd.no_of_channels_in_cram_blk[sec][cram][blk] = ch;
00165 
00166     if(cram >= PMD_CRAMS_MAX) {
00167         printf("PMD: Bad Cram number %d\n",cram) ;
00168         return 0 ;
00169     }
00170                                                                                  
00171     if((blk != 0) && (blk != 1)) {
00172        printf("PMD: Bad Block %d in Cram %d\n",blk,cram) ;
00173        return 0 ;
00174      }
00175                                                                                                                                                          
00176     if(ch > PMD_CRAMS_CH_MAX) {
00177           printf("PMD: too many channels in Cram %d, Block %d: %d\n",cram,blk,ch) ;
00178           return 0 ;
00179     }
00180 
00181     for(j=0;j<ch;j++) {
00182           unsigned int val ;
00183 
00184           val = (*datum) ;
00185           datum++ ;
00186                                                          
00187           if(val & 0x40000000) {
00188             unsigned int channel = (val & 0x7ff000) >> 12 ;
00189             val &= 0xFFF ;
00190 //          printf("        %4d: %4d == %4d\n",j,channel,val) ;
00191                 if(channel >= PMD_CRAMS_CH_MAX) {
00192                    printf("PMD: channel too big in Cram %d, Block %d: %d\n",cram,blk,channel) ;
00193                    return 0 ;
00194                 }
00195              mThePmd.adc[sec][cram][blk][channel] = val ;
00196              ch_num++ ;
00197          }
00198        }        
00199  }
00200 return ch_num ;
00201  
00202 }
00203 
00204 
00205 
00206 PMD_Reader::PMD_Reader(EventReader *er, Bank_PMDP *pPMDP)
00207 {
00208   pBankPMDP = pPMDP; //copy into class data member for use by other methods
00209   ercpy = er; // squirrel away pointer eventreader for our friends
00210   printf(" This PMD_Reader in ctor , %s. \n", __FILE__ );
00211   
00212   pBankPMDP->header.BankType[7]=0;
00213    cout<<"header bank type "<<pBankPMDP->header.BankType<<endl;
00214   if (!pBankPMDP->test_CRC())  {
00215     printf("CRC error in PMDP: %s %d\n",__FILE__,__LINE__) ;
00216   }
00217   
00218   if (pBankPMDP->swap() < 0) {
00219     printf("swap error in PMDP: %s %d\n",__FILE__,__LINE__) ;
00220   }
00221   
00222   pBankPMDP->header.CRC = 0;
00223   
00224   //do whatever else needs to be done
00225     int Token = pBankPMDP->header.Token;
00226   Bank_DATAP *dp = (Bank_DATAP *)ercpy->getDATAP(); 
00227   if(Token !=dp->header.Token){
00228     printf("Token mismatch between global %d and PMD %d\n",dp->header.Token,Token);
00229   }
00230 
00231  for(int sec=0; sec < 2; sec++){
00232         for(int cram=0; cram<PMD_CRAMS_MAX; cram++){
00233                 for(int blk=0; blk < 2; blk ++){
00234                         for(int channel=0; channel<PMD_CRAMS_CH_MAX; channel++){
00235                                 mThePmd.adc[sec][cram][blk][channel] = 0;
00236                                 mThePmd.ped[sec][cram][blk][channel] = 0;
00237                                 mThePmd.rms[sec][cram][blk][channel] = 0;
00238                                 mThePmd.thr[sec][cram][blk][channel] = 0;
00239                         }
00240                 }
00241         }
00242  }
00243 //  mTheRichArray.ByteSwapped = 0x04030201;  // This is to signal Endianness if struct is saved
00244   
00245   
00246   ProcessEvent(pBankPMDP);    // switch locations in little endian machines
00247   
00248  }
00249 Bank_DATA PMD_Reader::getPMD_ADC()
00250 {
00251         return mThePmd;
00252 }
00253 
00254 int PMD_Reader::NPMDHits()
00255 {
00256  /* if(mPmdPresent)
00257     {
00258       if(strncmp(mTheTowerAdcR.BankType,"TOWRADCR",8))
00259       {
00260         cout<<"EMC_Reader::NTowerHits() -> error in header"<<endl;
00261         return 0;
00262       }
00263     
00264     int nhits=mThePmdAdcD.NPPMDHits;
00265 */
00266     int nhits = 10;
00267     return nhits;
00268 //    }
00269     //else return 0;
00270 }
00271 
00272 int PMD_Reader::NCPVHits()
00273 {
00274  /* if(mPmdPresent)
00275     {
00276       if(strncmp(mTheTowerAdcR.BankType,"TOWRADCR",8))
00277       {
00278         cout<<"EMC_Reader::NTowerHits() -> error in header"<<endl;
00279         return 0;
00280       }
00281     
00282     int nhits=mThePmdAdcD.NPPMDHits;
00283 */
00284     int nhits = 10;
00285     return nhits;
00286 //    }
00287     //else return 0;
00288 }
00289 
00290 int PMD_Reader::pedReader(int sec, int type, Bank_PMDPEDR *pedr)
00291 {
00292       pedr->swap();
00293       int items = pedr->header.BankLength -(INT32)sizeof(Bank_Header)/4 ;
00294       printf("intem = %d, 1st=%d, 3nd=%d\n", items, pedr->header.BankLength, (INT32)sizeof(Bank_Header)/4);
00295         unsigned int *datum ;
00296         int cram, blk, ch ;
00297         int ch_num ;
00298         int valid ;
00299 
00300         if(items <= 0) return 0 ;
00301 
00302         datum = (unsigned int *)pedr->data ;
00303 
00304         ch_num = 0 ;
00305 
00306         //printf("PMD sec %d: items %d\n",sec,items) ;
00307 
00308         unsigned int *end_datum = datum + items ;
00309 
00310         for(end_datum=datum+items;datum<end_datum;) {
00311                 int channel ;
00312                 unsigned int tmp = (*datum) ;
00313                 datum++ ;
00314 
00315                 cram = (tmp & 0x7F00) >> 8 ;
00316                 blk = (tmp & 0x00FF)  ;
00317 
00318                 valid = tmp & 0x8000 ;
00319 
00320 
00321                 ch = PMD_CRAMS_CH_MAX ;
00322 
00323                 if(!valid) {
00324                         //printf("Datum not valid at %d == 0x%04X",end_datum, tmp) ;
00325 
00326                         datum += ch ;
00327                         continue ;
00328                 }
00329 
00330 
00331                 if(cram >= PMD_CRAMS_MAX) {
00332                         printf("PMD: Bad CRAM number %d",cram) ;
00333                         return 0 ;
00334                 }
00335 
00336                 if((blk != 0) && (blk != 1)) {
00337                         printf("PMD: Bad Block %d in CRAM %d",blk,cram) ;
00338                         return 0 ;
00339                 }
00340 
00341 
00342                 //fflush(stdout) ;
00343                 
00344                 for(channel=0;channel<ch;channel++) {
00345                         unsigned int val ;
00346 
00347                         val = (*datum) ;
00348                         datum++ ;
00349 
00350 
00351                         //printf("        %4d == %4d (0x%04X)\n",channel,val,val) ;
00352 
00353                         switch(type) {
00354                         case PMD_PEDR_N :
00355                                 mThePmd.ped[sec][cram][blk][channel] = val;
00356                                 break ;
00357                         case PMD_RMSR_N :
00358                                 mThePmd.rms[sec][cram][blk][channel] = val ;
00359                                 break ;
00360                         case PMD_THRR_N :
00361                                 mThePmd.thr[sec][cram][blk][channel] = val ;
00362                                 break ;
00363                         }
00364                         ch_num++ ;
00365                                         
00366                 }
00367         }
00368 
00369         return ch_num ;
00370 }