StRoot: RTS/src/DAQ_TRG/trg_reader.cxx Source File

00001 #include <stdio.h>
00002 #include <string.h>
00003 #include <arpa/inet.h>
00004 
00005 #include <rtsLog.h>
00006 
00007 #define TRG_VERSION 0x32
00008 
00009 #include <daqFormats.h>
00010 #include <rts.h>
00011 #include <rtsSystems.h>
00012 
00013 
00014 
00015 #include "daq_trg.h"
00016 
00017 extern int trgReader12(char *trgd, struct trg_t *trg) ;
00018 extern int trgReader20(char *trgd, struct trg_t *trg) ;
00019 extern int trgReader21(char *trgd, struct trg_t *trg) ; // 
00020 extern int trgReader22(char *trgd, struct trg_t *trg) ;    // 
00021 extern int trgReader30(char *trgd, struct trg_t *trg);
00022 extern int trgReader32(char *trgd, struct trg_t *trg);     // called by trgReader10   2007 updates....
00023 extern int trgReader10(char *trgd, struct trg_t *trg);
00024 
00025 // navigates to the start of the raw trigger data i.e. DATAP->TRGP->TRGD->data
00026 
00027 char *trg_find_raw(char *m, int *bytes)
00028 {
00029         struct TRGP *trgp ;
00030         struct TRGD *trgd ;
00031         struct DATAP *datap ;
00032         int len, off ;
00033         int swapit ;
00034 
00035         *bytes = 0 ;
00036 
00037         if(m == 0) return 0 ;
00038         datap = (struct DATAP *) m ;
00039 
00040         swapit = 0 ;
00041         if(datap->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swapit = 1 ;
00042 
00043 
00044         len = qswap32(swapit, datap->det[TRG_ID].len);
00045         if(len == 0) return 0 ;
00046         len *= 4 ;
00047 
00048         off = qswap32(swapit, datap->det[TRG_ID].off);
00049         if(off == 0) return 0 ;
00050 
00051         LOG(DBG,"Trg raw len %d (0x%x), off %d(0x%x)",len,len,off,off,0) ;
00052 
00053         trgp = (struct TRGP *)((u_int *) m + off) ;
00054         if(checkBank(trgp->bh.bank_type,"TRGP") < 0) {  // wrong bank!
00055                 return 0 ;                              
00056         }
00057 
00058         swapit = 0 ;
00059         if(trgp->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swapit = 1 ;
00060 
00061 
00062         if(trgp->trgData.len == 0) return 0 ;   // no raw data but so far OK, I guess
00063         if(trgp->trgData.off == 0) return 0 ;
00064 
00065         off = qswap32(swapit, trgp->trgData.off);
00066         
00067         trgd = (struct TRGD *) ((u_int *)trgp + off) ;
00068 
00069 
00070         swapit = 0 ;
00071         if(trgd->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swapit = 1;
00072         
00073         // check misc. things
00074         if(checkBank(trgd->bh.bank_type,"TRGD") < 0) {
00075           return 0 ;
00076         }
00077         
00078         len = qswap32(swapit, trgd->bh.length) ;
00079 
00080         len -= 10 ;     // skip the DAQ bank header ;
00081 
00082         *bytes = len*4 ;        // we want bytes
00083 
00084         LOG(DBG,"Returning pointer to raw trigger data of %d bytes", *bytes) ;
00085 
00086         return (char *) &(trgd->desc) ; // points to the start of trigger descriptor
00087 
00088 }       
00089 
00090 // read the Trigger RAW data
00091 int trg_reader(char *m, struct trg_t *trg, u_int driver, u_int evp_daqbits)
00092 {
00093         struct TRGP *trgp  ;
00094         struct TRGD *trgd ;
00095         struct DATAP *datap ;
00096         int len, off ;
00097         int trgp_banks ;
00098 
00099         int swapdatap=0;
00100         int swaptrgp=0;
00101         int swaptrgid=0;
00102         int swaptrgd=0;
00103 
00104         // zap all first
00105         memset(trg,0,sizeof(trg_t)) ;
00106 
00107         trg->mode = 0 ;
00108         trg->max_channels = 240 * 128 * 6 ;
00109         trg->channels = 0 ;
00110         trg->trgc = NULL ;
00111 
00112         // Tonko: FY09... this is very ugly...
00113         trg->daqbits = evp_daqbits;   // ugly hack...
00114 
00115         if(m == NULL) return 0 ;
00116 
00117         datap = (struct DATAP *) m ;
00118         if(datap->bh.byte_order != DAQ_RAW_FORMAT_ORDER) 
00119           swapdatap = 1;
00120 
00121 
00122         len = qswap32(swapdatap, datap->det[TRG_ID].len);
00123         if(len == 0) return 0 ;
00124         len *= 4 ;
00125 
00126         off = qswap32(swapdatap, datap->det[TRG_ID].off);
00127         if(off == 0) return 0 ;
00128 
00129         LOG(DBG,"Trg raw len %d (0x%x), off %d(0x%x)",len,len,off,off,0) ;
00130 
00131         trgp = (struct TRGP *)((u_int *)m+off) ;
00132         if(checkBank(trgp->bh.bank_type,"TRGP") < 0) {  // wrong bank!
00133                 return 0 ;                              
00134         }
00135 
00136         if(trgp->bh.byte_order != DAQ_RAW_FORMAT_ORDER)
00137           swaptrgp = 1;
00138 
00139         if(trgp->bh.token == 0) {
00140                 LOG(ERR,"Token 0 - skipping...",0,0,0,0,0) ;
00141                 return 0 ;
00142         }
00143 
00144         // number of banks present in TGRP: 1 for TRGD only (old), 2 for TRGD & TRGID (new)
00145         trgp_banks = qswap32(swaptrgp, trgp->bh.length);
00146 
00147         trgp_banks = (trgp_banks - 10)/2 ;
00148 
00149 
00150         LOG(DBG,"TRGP bytes %d, TRGD off:len 0x%X:%d (banks %d)",
00151             qswap32(swaptrgp, trgp->bh.length)*4,
00152             qswap32(swaptrgp, trgp->trgData.off),
00153             qswap32(swaptrgp, trgp->trgData.len),
00154             trgp_banks) ;
00155 
00156         // new: TRGID
00157         if(trgp_banks >= 2) {
00158           if(trgp->trgId.len && trgp->trgId.off) {
00159             int off = qswap32(swaptrgp, trgp->trgId.off);
00160             struct TRGID *trgid = (struct TRGID *)((char *)trgp + 4*off) ;
00161 
00162             if(trgid->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swaptrgid = 1;
00163             
00164             if(checkBank(trgid->bh.bank_type,CHAR_TRGID) >= 0) {
00165               int i ;
00166           
00167               for(i=0;i<32;i++) {
00168                 if(evp_daqbits & (1 << i)) {
00169                   LOG(DBG,"TRGID %d: bit %2d is 0x%02X [%u dec]",i,i,
00170                       qswap32(swaptrgid, trgid->triggerId[i]),
00171                       qswap32(swaptrgid, trgid->triggerId[i]), 0);  
00172                   trg->offline_id[i] = qswap32(swaptrgid, trgid->triggerId[i]);
00173                  }
00174                 
00175               }
00176             }
00177           }
00178         }
00179 
00180         if(trgp->trgData.len == 0) return 0 ;   // no raw data but so far OK, I guess
00181         if(trgp->trgData.off == 0) return 0 ;
00182 
00183         off = qswap32(swaptrgp, trgp->trgData.off);
00184         trgd = (struct TRGD *) ((char *)trgp + 4*off) ;
00185 
00186         if(trgd->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swaptrgd = 1;
00187         
00188         // check misc. things
00189         if(checkBank(trgd->bh.bank_type,"TRGD") < 0) {
00190           return 0 ;
00191         }
00192         
00193         LOG(DBG,"TRGD len %d",
00194             qswap32(swaptrgd, trgd->bh.length),0,0,0) ;
00195 
00196         if(qswap32(swaptrgd, trgd->bh.length) == 10) return 0 ; // no trigger data - just bh
00197 
00198         
00199         trg->trgc = (u_char *) trgd ;
00200 
00201         u_char trg_version = trgd->desc.TrgDataFmtVer ;
00202 
00203 
00204         switch(trg_version) {
00205         case 0x12 :     // pre Jan 2002
00206         case 0x13 :     // pre Jan 2002
00207                 LOG(NOTE,"TRG: version 0x%02X supported...",trg_version,0,0,0,0) ;
00208                 trgReader12((char *)trgd, trg) ;
00209                 break;
00210         case 0x20 :     // 2002-2003
00211                 LOG(NOTE,"TRG: version 0x%02X supported...",trg_version,0,0,0,0) ;
00212                 trgReader20((char *)trgd, trg) ;
00213                 break ;
00214         case 0x21 :     // 2003-2004
00215                 LOG(NOTE,"TRG: version 0x%02X supported...",trg_version,0,0,0,0) ;
00216                 trgReader21((char *)trgd, trg) ;
00217                 break ;
00218         case 0x22 :     // Nov 2004 - BBC extended
00219                 LOG(NOTE,"TRG: version 0x%02X supported...",trg_version,0,0,0,0) ;
00220                 trgReader22((char *)trgd, trg) ;
00221                 break ;
00222         case 0x30 :   // 30/31 same but for vpd order which was always wrong 
00223         case 0x31 :   // in 30
00224           LOG(NOTE, "TRG: version 0x%02X supported", trg_version,0,0,0,0);
00225           trgReader30((char *)trgd, trg);
00226           break;
00227 
00228         case 0x10 :
00229           LOG(NOTE, "TRG: version 0x%02X supported, ", trg_version, 0,0,0,0);
00230 
00231           trgReader10((char *)trgd,trg);
00232           break;
00233         
00234         default :
00235                 LOG(ERR,"Can't read Trigger Format Version 0x%02X!",trg_version,0,0,0,0) ;
00236                 return 0 ;
00237         }
00238 
00239 
00240         return len ;
00241 }
00242 
00243