StRoot: StDaqLib/TRG/code2008.cxx Source File

00001 // This is 2008 specific code for restoring packed(zero suppressed) trigger 
00002 // data from daq file to full size trigger structure, and byte swap if needed.
00003 
00004 #include <assert.h>
00005 #include "trgStructures2008.h"
00006 #include "TRG_Reader.hh"
00007 using namespace OLDEVP;
00008 
00009 int TRG_Reader::UnpackTrg2008(Bank_TRGP *pTRGP){
00010   int returnValue,npre,npost,swap,res;
00011   
00012   if ( ! pTRGP){
00013     printf("TRG_Reader::UnpackTrg2008 - not pTRGP\n");
00014     return -1;
00015   }
00016 
00017   assert(pTRGP->header.ByteOrder==0x01020304 ||
00018          pTRGP->header.ByteOrder==0x04030201);
00019   if(pTRGP->header.ByteOrder==0x04030201) {
00020     swap=1;
00021     returnValue=0;
00022   }else{
00023     swap=1;
00024     returnValue=pTRGP->header.swap();
00025   }
00026   if(pTRGP->header.ByteOrder!=0x04030201){
00027     printf("TRG_Reader::UnpackTrg2008: Swap Header error %s %d.\n",__FILE__,__LINE__);    
00028     assert(0);
00029   }
00030   printf("TRG_Reader::UnpackTrg2008: Token from Bank=%d\n",pTRGP->header.Token);
00031 
00032   //Get lengthes
00033   // int size_bank = pTRGP->header.BankLength * 4;
00034   int size_off  = pTRGP->theData.offset * 4;
00035   int size_head = sizeof(pTRGP->header);
00036   int size_trg  = sizeof(TrgDataType2008);
00037   int size_desc = sizeof(EvtDescData2008);
00038   int size_sum  = sizeof(TrgSumData2008);
00039   int size_raw  = sizeof(RawTrgDet2008);
00040   //  printf("TRG_Reader::UnpackTrg2008: offset, header, trg, desc, sum, raw = %d %d %d %d %d %d\n",
00041   //     ,size_off,size_head,size_trg,size_desc,size_sum,size_raw);
00042   
00043   // New TrgTowerTrnfer structure and find trigger data itself
00044   char* cttt = (char*)pTRGP + size_off + size_head;
00045   TrgTowerTrnfer2008* ttt=(TrgTowerTrnfer2008*)cttt;
00046   if(swap){
00047     res=Swap2008_TrgTowerTrnfer(cttt);
00048     if(res<0) {
00049       printf("TRG_Reader::UnpackTrg2008: Swap TrgTowerTrnfer error %s %d.\n",__FILE__,__LINE__);
00050       return -1;
00051     }
00052   }
00053   int offset = ttt->OffsetBlock[y8TRG_INDEX].offset;
00054   int length = ttt->OffsetBlock[y8TRG_INDEX].length;
00055   printf("TRG_Reader::UnpackTrg2008: TrgTowerTrnfer byet_version=0x%x offset=%d length=%d\n",
00056          ttt->byteCount_Version,offset,length);
00057   if(length<=0) {
00058     printf("TRG_Reader::UnpackTrg2008: No Trigger Data %s %d.\n",__FILE__,__LINE__);
00059     return 0;
00060   }
00061   char* trg_version = (char*)pTRGP + size_off + size_head + offset + 3;
00062   printf("TRG_Reader::UnpackTrg2008: trg_version = 0x%x\n",*trg_version);
00063   if(*trg_version != 0x32) {
00064     printf("TRG_Reader::UnpackTrg2008: Trigger version error %s %d.\n",*trg_version,__FILE__,__LINE__);
00065     return -1;    
00066   }
00067 
00068   //Create memory space for unpacked trigger bank
00069   if(pBankUnp!=0) delete[] pBankUnp;
00070   int sizeUnp = size_off + size_head + size_trg;
00071   pBankUnp = new char[sizeUnp];  
00072   char *trgd = pBankUnp + size_off + size_head; //pointer for trgdata
00073   TrgDataType2008* p=(TrgDataType2008*)trgd;
00074   
00075   //Copy Header, EvtDesc and TrgSum and byte swap
00076   memcpy(pBankUnp, pTRGP, size_off+size_head);
00077   memcpy(pBankUnp+size_off+size_head, (char*)pTRGP+size_off+size_head+offset, size_desc+size_sum);
00078   if(swap){
00079     res=Swap2008_DescSum(trgd);
00080   }
00081   npre  = p->EvtDesc.npre;
00082   npost = p->EvtDesc.npost;
00083   printf("TRG_Reader::UnpackTrg2008: TCUdataBytes = %d Token = %d Npre/Npost=%d/%d\n",
00084          p->EvtDesc.TCUdataBytes, p->EvtDesc.TrgToken, npre,npost);
00085   if(swap && res<0) {
00086     printf("TRG_Reader::UnpackTrg2008: Swap DescSum error %s %d.\n",__FILE__,__LINE__);
00087     return -1;
00088   }
00089 
00090   if(p->EvtDesc.TrgToken>4096) {
00091     printf("TRG_Reader::UnpackTrg2008: Found Token beyond 4096\n");
00092     assert(0);
00093   }
00094   if(npre>5 || npre<0 || npost>5 || npost<0) {
00095     printf("TRG_Reader::UnpackTrg2008: Trigger data has more than 5 pre/post\n");
00096     assert(0);
00097   }
00098 
00099   //Set pointers for daq data and new unpacked data
00100   char* p_daq = (char *)pTRGP    + size_off + size_head + size_desc + size_sum + offset;
00101   char* p_unp = (char *)pBankUnp + size_off + size_head + size_desc + size_sum;
00102   
00103   //Zero out all raw data memory before copying partial data
00104   memset(p_unp, 0, 11*size_raw);
00105   
00106   //Loop over # of crossings available and copy
00107   for(int i=0; i<1+npre+npost; i++){
00108     unsigned short *nbytes = (unsigned short *)p_daq;
00109     if(swap) pTRGD->swapHerb2bytes(nbytes,1); //byte swap for # of bytes
00110     int n = *nbytes;
00111     //printf("TRG_Reader::UnpackTrg2008: Nprepost=%d   RawDat Size=%d (byte) [%d]\n",i,n,size_raw);
00112     if(swap){
00113       //printf("-> Swapping on %p\n",pTRGD);
00114       pTRGD->swapHerb2bytes(nbytes,1); //swap back so that later whole things will swap correctly
00115     }
00116 
00117     if (n>size_raw){
00118       printf("**********************************************************************************\n");
00119       printf("TRG_Reader::UnpackTrg2008\n");
00120       printf("\tWARNING! TrgRaw bank has improper reported size %d > %d\n",n,size_raw);
00121       printf("\tSkipping event\n");
00122       printf("**********************************************************************************\n");
00123       return -1;
00124     }
00125 
00126     //printf("-> Doing memcpy to %p from %p\n",p_unp,p_daq);
00127     memcpy(p_unp, p_daq, n);
00128 
00129     p_daq += n; 
00130     p_unp += size_raw;
00131   }
00132     
00133   //Byte Swap (if needed) for all raw data section
00134   //printf("-> Checking if swap is necessary\n");
00135   if(swap){
00136     //printf("-> Swap2008_Raw on %p\n",trgd);
00137     res = Swap2008_Raw(trgd);
00138     if(res<0){
00139       printf("TRG_Reader::UnpackTrg2008: Swap RawData error %s %d.\n",__FILE__,__LINE__);
00140       return -1;
00141     }
00142   }
00143   
00144   //Switch bank pointer to fully restored data
00145   //printf("-> pBankTRGP set to (Bank_TRGP *) %p\n",pBankUnp);
00146   pBankTRGP = (Bank_TRGP *)pBankUnp; 
00147   
00148   return 0;
00149 };
00150 
00151 int TRG_Reader::Swap2008_TrgTowerTrnfer(char *ptr){
00152   TrgTowerTrnfer2008* p = (TrgTowerTrnfer2008 *)ptr;
00153   pTRGD->swapHerb4bytes(&(p->byteCount_Version),1);
00154   pTRGD->swapHerb4bytes(&(p->OffsetBlock[0].offset),2 * y8MAX_OFFSET);
00155   return 0;
00156 };
00157 
00158 int TRG_Reader::Swap2008_DescSum(char *ptr){
00159   TrgDataType2008* p=(TrgDataType2008*)ptr;
00160 
00161   pTRGD->swapHerb2bytes(&(p->EvtDesc.TCUdataBytes),1);
00162   pTRGD->swapHerb4bytes(&(p->EvtDesc.bunchXing_hi),1);
00163   pTRGD->swapHerb4bytes(&(p->EvtDesc.bunchXing_lo),1);
00164   pTRGD->swapHerb2bytes(&(p->EvtDesc.actionWdDetectorBitMask),1);
00165   pTRGD->swapHerb2bytes(&(p->EvtDesc.TrgToken),1);
00166   pTRGD->swapHerb2bytes(&(p->EvtDesc.addBits),1);
00167   pTRGD->swapHerb2bytes(&(p->EvtDesc.DSMInput),1);
00168   pTRGD->swapHerb2bytes(&(p->EvtDesc.externalBusy),1);
00169   pTRGD->swapHerb2bytes(&(p->EvtDesc.modifiedBusyStatus),1);
00170   pTRGD->swapHerb2bytes(&(p->EvtDesc.physicsWord),1);
00171   pTRGD->swapHerb2bytes(&(p->EvtDesc.TriggerWord),1);
00172   pTRGD->swapHerb2bytes(&(p->EvtDesc.DSMAddress),1);
00173   pTRGD->swapHerb2bytes(&(p->EvtDesc.contaminationBusyStatus),1);
00174   pTRGD->swapHerb2bytes(&(p->EvtDesc.npre),1);
00175   pTRGD->swapHerb2bytes(&(p->EvtDesc.npost),1);
00176   pTRGD->swapHerb2bytes(&(p->EvtDesc.dummy),1);
00177 
00178   pTRGD->swapHerb2bytes(&(p->TrgSum.TrgSumBytes),1);
00179   pTRGD->swapHerb2bytes(&(p->TrgSum.TrgSumHeader),1);
00180   pTRGD->swapHerb4bytes(&(p->TrgSum.L1Sum[0]),2);
00181   pTRGD->swapHerb4bytes(&(p->TrgSum.L2Sum[0]),2);
00182   pTRGD->swapHerb2bytes(&(p->TrgSum.L0SumBytes),1);
00183   pTRGD->swapHerb2bytes(&(p->TrgSum.L0SumHeader),1);
00184   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.MTD[0]),8);
00185   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.VPD[0]),8); 
00186   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.CPA[0]),16);
00187   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.CTB[0]),8);
00188   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.lastDSM[0]),8);
00189   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.VTX[0]),8);
00190   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.EMC[0]),8);
00191   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.BCdata[0]),16);
00192   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.specialTriggers[0]),8);
00193   pTRGD->swapHerb2bytes(&(p->TrgSum.DSMdata.FPD[0]),8);
00194   pTRGD->swapHerb2bytes(&(p->TrgSum.L1SumBytes),1);
00195   pTRGD->swapHerb2bytes(&(p->TrgSum.L1SumHeader),1);
00196   pTRGD->swapHerb4bytes(&(p->TrgSum.L1Result[0]),32);
00197   pTRGD->swapHerb2bytes(&(p->TrgSum.L2SumBytes),1);
00198   pTRGD->swapHerb2bytes(&(p->TrgSum.L2SumHeader),1);
00199   pTRGD->swapHerb4bytes(&(p->TrgSum.L2Result[0]),64);
00200 
00201   int npre  = p->EvtDesc.npre;
00202   int npost = p->EvtDesc.npost;
00203   if(npre<0 || npre>5 || npost<0 || npost>5) return -1;
00204 
00205   return 0;
00206 };
00207   
00208 int TRG_Reader::Swap2008_Raw(char *ptr) {
00209   int numToSwap,i;
00210   TrgDataType2008* p=(TrgDataType2008*)ptr;
00211 
00212   numToSwap=1+p->EvtDesc.npost+p->EvtDesc.npre;
00213 
00214   for(i=0;i<numToSwap;i++) { // loop over NPRE, NPOST as well
00215     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].RawDetBytes),1);
00216     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].CTBdataBytes),1);
00217     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].MIXdataBytes),1);
00218     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].MIXfiller),1);
00219     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].BEMCdataBytes),1);
00220     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].BEMCfiller),1);
00221     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].BEMClayer1[0]),48);
00222     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].EEMCdataBytes),1);
00223     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].EEMCfiller),1);
00224     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].EEMClayer1[0]),16);
00225     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].FPDdataBytes),1);
00226     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].FPDfiller),1);
00227     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].FPDEastNSLayer1[0]),8);
00228     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].BBCdataBytes),1);
00229     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].BBCfiller),1);
00230     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].BBClayer1[0]),16);
00231     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].ZDClayer1[0]),8);
00232     pTRGD->swapHerb2bytes(&(p->rawTriggerDet[i].QQTdataBytes),1);
00233     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].QQTfiller),1);
00234     pTRGD->swapHerb4bytes(&(p->rawTriggerDet[i].QQTdata[0]),1600);
00235     int nqt = p->rawTriggerDet[i].QQTdataBytes/4;
00236     int ac10 = p->rawTriggerDet[i].QQTdata[nqt-1];
00237     printf("NQTdata = %d, Last word check = 0x%x (should be ac10)\n",nqt,ac10);
00238     if(nqt>0 && ac10 != 0xAC10){
00239       printf("Last word of QT data is not 0xAC10 but 0x%x\n ",ac10);
00240       return -1; 
00241     }
00242   }
00243   return 0;
00244 };
00245 
00255 void TRG_Reader::SanityCheck2008(char *ptr, int check_s=1) { 
00256   unsigned short x;
00257   TrgDataType2008* p=(TrgDataType2008*)ptr;
00258 
00259   x=p->TrgSum.L1SumBytes; assert(x==0x0084||x==0x8400);
00260   x=p->TrgSum.L2SumBytes; assert(x==0x0084||x==0x8400);
00261 
00262   if (check_s){
00263     assert( p->rawTriggerDet[0].RawDetHeader[0]  =='R');   
00264     assert( p->rawTriggerDet[0].RawDetHeader[1]  =='D');   
00265     assert( p->rawTriggerDet[0].CTBdataHeader[0] =='C');   
00266     assert( p->rawTriggerDet[0].CTBdataHeader[1] =='T');   
00267     assert( p->rawTriggerDet[0].BEMCdataHeader[0]=='E'); 
00268     assert( p->rawTriggerDet[0].BEMCdataHeader[1]=='M');  
00269   } else {
00270     cout << "TRG_Reader::SanityCheck2008 : Data position sanity check is disabled" << endl;
00271   }
00272 };