sPhenix code displayed by LXR master/​online_distribution/​newbasic/​oncsSub_idfnalmwpc.cc	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-03 08:20:47

 #include "oncsSub_idfnalmwpc.h"
 #include <cstring>
 
 // for ntohl and ntohs
 #include <arpa/inet.h>
 
 
 using namespace std;
 
 oncsSub_idfnalmwpc::oncsSub_idfnalmwpc(subevtdata_ptr data)
   :oncsSubevent_w4 (data)
 {
   n_tdcs = 0;
   length= 0;
   _decoded = 0;
   
   // initialize all to 0
   memset (&spillinfo, 0 , sizeof(spillinfo) );
   memset (tsh, 0 , MAXNROFTDCS * sizeof(TDCspillheader) );
   
 
 }
   
 
 int *oncsSub_idfnalmwpc::decode ( int *nwout)
 {
 
   if ( _decoded) return 0;
 
   _decoded = 1;
 
   int i;
 
   int *d = (int *) &SubeventHdr->data;  // here begins the payload
 
   tdcmask = d[0];
   
   // count the number of "on" bits = number of TDCs
   n_tdcs=0;
   for ( i = 0; i < MAXNROFTDCS; i++)
     {
       if ( (1<< i) & tdcmask ) n_tdcs++;
     }
 
   // unsigned short *xx = (unsigned short *)&d[1];
   // for ( i = 0; i < 300; i++)
   //   {
   //     cout << setw(5) << i << hex << setw(8) << ntohs(*xx++) << dec << endl;
   //   }
   // cout << endl;
 
 
   int length = ntohl ( d[1] );
   spillinfo.spillwords = length; // in 16bit units
 
   //we now subtract 2 to remove the header length
   length -= 2;
 
   //  dlength is the remaining payload length without the 
   //  length word in 16bit units - we subtract 8 bytes for the mask and length
   int dlength = 2 * ( getLength()-getPadding() ) -4 ; 
 
   // length is the length of the entire spill stucture without the length 
   // in 16bit words; we do a consistency check
   if (length  > dlength ) return 0;
   
   short *s = ( short *) &d[2];
   int pos = 0;
   
   short v;
 
   spillinfo.spillcounter = ntohs ( s[pos++]);
   
   v =  ntohs ( s[pos++]);
   spillinfo.year  = ( v>> 8 ) & 0xff;
   spillinfo.month =  v & 0xff;
 
   v =  ntohs ( s[pos++]);
   spillinfo.day = ( v>> 8 ) & 0xff;
   spillinfo.hour = v & 0xff;
 
   v =  ntohs ( s[pos++]);
   spillinfo.minute = ( v>> 8 ) & 0xff;
   spillinfo.second = v & 0xff;
 
   spillinfo.triggercount = ntohs ( s[pos++]);
   spillinfo.TDC_Status_Bits = ntohs ( s[pos++]);
   spillinfo.Spill_Link_Status_Bits = ntohs ( s[pos++]);
 
   //  cout << " triggers = " << spillinfo.triggercount << endl;
 
   TDCEvent *te {nullptr};
 
 
   // we now push, up front, one event structure on the vector
   // for each trigger so we know that we have one for each event
   for ( i = 0; i< spillinfo.triggercount; i++)
     {
       te = new TDCEvent;
       TDCEventVector.push_back ( te);
     }
 
   
   for ( i = 0; i< n_tdcs; i++)
     {
       tsh[i].spillwords = ntohs ( s[pos++]);
       tsh[i].TDC = ntohs ( s[pos++]) -1;
       tsh[i].spilltriggercount = ntohs ( s[pos++]);
       tsh[i].spillstatus = ntohs ( s[pos++]);
     }
 
   int old_trigger_number = -1;
 
 
   while (pos < length)
     {
       short spillheaderlength = ntohs ( s[pos]);
       short tdcindex = ntohs ( s[pos+1]) - 1; // the controller counts like fortran
       if ( tdcindex >= MAXNROFTDCS ) // sanity check
     {
       cout << __LINE__ << " " << __FILE__ 
            << " wrong TDC index " << tdcindex << " pos= " << pos << endl;
     }
 
       // cout << __LINE__ << " " << __FILE__ 
       //       << " TDC Event header at pos " << pos << endl;
 
       // for ( i = 0 ; i < 8; i++)
       //    {
       //      cout << "  " << i << "  " << ntohs ( s[pos+i] ) << endl;
       //    }
 
       pos++;
 
       v = ntohs ( s[pos +2] ) -1;
       //      cout << "   trigger number " << v << endl;
 
       if (  v <0 || v >= spillinfo.triggercount )
     {
       cout << __LINE__ << " " << __FILE__ 
            << " wrong Trigger number " << v << " pos= " << pos << endl;
       return 0;
     }
 
  
       // we are only interested in this TDC if it has data (the header length is 8) 
       // (and passes the sanity check) 
       if ( spillheaderlength > 8 && tdcindex < MAXNROFTDCS )
     {
       // we are lookin ahead two words to get the 
       // trigger number. If this is different from the one
       // we had before, we are done with the old event, and start 
       // a new one. (intially we see -1, so it's always different).
       // as a reminder - w.r.t. "pos":
       // +0 TDC#
       // +1 event status
       // +2 "ordinal trigger number"
       // +3 trigger type
       // +4 800MHz event time stamp (12 bits)
       // +5 event time stamp (100Mhz) upper 16
       // +6 event time stamp (100Mhz) lower 16
       // +7 here start the hits
 
       if ( v != old_trigger_number )  // ok, new event/trigger, so we get the next TDCEvent
         {
           old_trigger_number = v;
           te = TDCEventVector[v];
           te->trigger_nr = v;
           te->evt_timestamp = ntohs (s[pos+4]); 
           te->local_ts_upper = ntohs (s[pos+5]); 
           te->local_ts_lower = ntohs (s[pos+6]); 
 
           // quick sanity check: bits 3...11 of 
           // the timstamp must be equal to the 
           // 9 lsb's of te->local_ts_lower
 
           // cout << " time stamps " << hex 
           //       << ( ( te->evt_timestamp>>3) &0x1ff ) << "  " 
           //       << ( te->local_ts_lower & 0x1ff) << dec << endl;
 
 
           // now we construct the long 35 bit 800MHz time stamp 
           // cout << "time stamps "  << hex 
           //       << te->evt_timestamp << " " 
           //       <<  te->local_ts_upper << " " 
           //       <<  te->local_ts_lower << dec << endl;
 
           te->absolute_time = te->local_ts_upper;
           te->absolute_time <<= 16;
           te->absolute_time += te->local_ts_lower;
           te->absolute_time <<= 3;
           te->absolute_time += ( te->evt_timestamp &0x3);
           // and we clear the TDCData structures
           memset ( te->td, 0, MAXNROFTDCS * sizeof( TDCData) );
           
           // we are done with filling in the new event "header" structure
           // now we fill in the TCDData structure. some of this 
           // is redundant to the header info, that's why we kept "pos" frozen
         }
           
       te->td[tdcindex].words = spillheaderlength;
       te->td[tdcindex].TDC = tdcindex;
       te->td[tdcindex].EventStatus =ntohs (s[pos+1]); 
       te->td[tdcindex].triggertype =ntohs (s[pos+3]); 
 
       // this may look redundant with the code above, but is actually
       // per TDC info - the abve was per event. Should match, and we fill it in
       // so the user can perform a sanity check
       te->td[tdcindex].evt_timestamp  = ntohs (s[pos+4]); 
       te->td[tdcindex].local_ts_upper = ntohs (s[pos+5]); 
       te->td[tdcindex].local_ts_lower = ntohs (s[pos+6]); 
 
       // now we construct the long 35 bit 800MHz time stamp 
       te->td[tdcindex].absolute_time = te->td[tdcindex].local_ts_upper;
       te->td[tdcindex].absolute_time <<= 16;
       te->td[tdcindex].absolute_time += te->td[tdcindex].local_ts_lower;
       te->td[tdcindex].absolute_time <<= 3;
       te->td[tdcindex].absolute_time += ( te->td[tdcindex].evt_timestamp &0x7);
 
       // at long last, the business end of this TDC - the TDC hit 
       int xpos = pos+7;  // that's where the hits start
       for ( i = 0; i < te->td[tdcindex].words -8; i++)  // so many hits, header is 8 long
         {
           te->td[tdcindex].hits++;  // this is the same as the TDCHitlist.size()
 
           TDC_hit *th = new TDC_hit;
           te->td[tdcindex].TDCHitlist.push_back ( th );
 
           short h = ntohs ( s[xpos+i]);  // this is now the TDC word
           th->wire = ( h >> 10) & 0x3f;  // upper bits are "wire"
           th->timestamp = h & 0x3ff;     // lower 10 bits are "timestamp"
           
         }
       pos += spillheaderlength-1;  // -1 because we stepped "pos" one position in already
     }
       else
     {
       //  short tdc = ntohs(s[pos]);
       //  cout << " skipping TDC " << tdc << " words = " << l << " pos = " << pos << endl;
       pos+= 7;
     }
       
 
     }
 
   return 0;
 }
 
 
 int oncsSub_idfnalmwpc::iValue(const int ich,const char *what)
 {
 
   decode (0);
   if ( strcmp(what,"NTDCS") == 0 )
   {
     return n_tdcs;
   }
 
   else if ( strcmp(what,"TRIGGERCOUNT") == 0 )
   {
     return spillinfo.triggercount;
   }
 
   else if ( strcmp(what,"SPILLCOUNTER") == 0 )
   {
     return spillinfo.spillcounter;
   }
 
   else if ( strcmp(what,"TDCSTATUSBITS") == 0 )
   {
     return   spillinfo.TDC_Status_Bits;
   }
 
   else if ( strcmp(what,"LINKSTATUSBITS") == 0 )
   {
     return spillinfo.Spill_Link_Status_Bits;
   }
 
   else if ( strcmp(what,"MONTH") == 0 )
   {
     return spillinfo.month;
   }
 
   else if ( strcmp(what,"DAY") == 0 )
   {
     return spillinfo.day;
   }
 
   else if ( strcmp(what,"YEAR") == 0 )
   {
     return spillinfo.year;
   }
 
   else if ( strcmp(what,"HOUR") == 0 )
   {
     return spillinfo.hour;
   }
 
   else if ( strcmp(what,"MINUTE") == 0 )
   {
     return spillinfo.minute;
   }
 
   else if ( strcmp(what,"SECOND") == 0 )
   {
     return spillinfo.second;
   }
 
   return 0;
 
 }
 
 
 int oncsSub_idfnalmwpc::iValue(const int trigger ,const int tdc, const int index)
 {
   decode (0);
   if ( trigger < 0 || (unsigned int ) trigger >= TDCEventVector.size()) return 0;
   if ( tdc < 0 || tdc >= n_tdcs) return 0;
   if ( index < 0 || index >= TDCEventVector[trigger]->td[tdc].hits) return 0;
 
   return TDCEventVector[trigger]->td[tdc].TDCHitlist[index]->wire;
 }
 
 int oncsSub_idfnalmwpc::iValue(const int trigger ,const int tdc, const char *what)
 {
   decode (0);
   if ( trigger < 0 || (unsigned int )trigger >= TDCEventVector.size()) return 0;
   if ( tdc < 0 || tdc >= n_tdcs) return 0;
 
 
   if ( strcmp(what,"HITS") == 0 )
   {
     if ( (unsigned int ) trigger >= TDCEventVector.size() )
       {
     cout << __LINE__ << " " << __FILE__ << " wrong trigger " <<  trigger << " max " << TDCEventVector.size() << endl;
     return 0;
       }
 
     return TDCEventVector[trigger]->td[tdc].hits;
   }
   else if ( strcmp(what,"TDC") == 0 )
   {
     return TDCEventVector[trigger]->td[tdc].TDC;
   }
 
   return 0;
 }
 
 int oncsSub_idfnalmwpc::iValue(const int trigger ,const int tdc, const int index, const char *what)
 {
   decode (0);
   if ( trigger < 0 || (unsigned int )trigger >= TDCEventVector.size()) return 0;
   if ( tdc < 0 || tdc >= n_tdcs) return 0;
   if ( index < 0 || index >= TDCEventVector[trigger]->td[tdc].hits) return 0;
 
 
   if ( strcmp(what,"WIRE") == 0 )
   {
     return iValue(trigger, tdc, index);
   }
 
   else if ( strcmp(what,"TIMESTAMP") == 0 )
   {
     return TDCEventVector[trigger]->td[tdc].TDCHitlist[index]->timestamp;
   }
 
   
   return 0;
 }
 
 
 
 void  oncsSub_idfnalmwpc::dump ( OSTREAM& os )
 {
 
   decode (0);
   identify(os);
 
   int j, k, l;
 
 
   os << " Date         " << iValue(0, "MONTH") 
      << "/"              << iValue(0,"DAY") 
      << "/20"            << iValue(0,"YEAR")  
      << " "              << iValue(0,"HOUR")
      << ":"              << iValue(0,"MINUTE") 
      << ":"              << iValue(0,"SECOND") << endl;
   
   os << " Spill Counter " << iValue(0,"SPILLCOUNTER") << endl;
   
   int tc = iValue(0,"TRIGGERCOUNT");
 
   os << " Trigger Count " << tc  << endl;
   os << " TDC Status Bits " <<  hex << iValue(0,"TDCSTATUSBITS") << dec << endl;
   os << " Link Status bits " << hex << iValue(0,"LINKSTATUSBITS") << dec << endl;
 
   for ( k = 0; k < tc; k++)
     {
 
       os << " new event " 
      << "      trg#     tdc     hit    wire  timestamp" << endl;
 
       for ( l = 0; l < iValue(0,"NTDCS"); l++)
     {
       int hits =iValue ( k, l, "HITS"); 
       if ( hits)
         {
           int tdc = iValue(k,l,"TDC");
 
           for ( j = 0; j < hits; j++)
         {
           os << "              " << setw(6) << k 
              << setw(8) <<  tdc  << setw(8) << j 
              <<  setw (8)  << iValue(k,l,j)
              << setw(8)  << iValue(k,l,j,"TIMESTAMP")  << endl;
         }
         }
     }
     }
   os << endl;
   
   
   
 }
 
 oncsSub_idfnalmwpc::~oncsSub_idfnalmwpc()
 {
   
 
   int l;
   unsigned int i,k;
   TDCEvent *te;
 
   for ( k = 0; k< TDCEventVector.size() ; k++)
     {
       te = TDCEventVector[k];
 
       for ( l = 0; l < n_tdcs; l++)
     {
       for  ( i = 0; i < te->td[l].TDCHitlist.size() ; i++)
         {
           delete te->td[l].TDCHitlist[i];
         }
     }
       delete te;
     }
 }
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team