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

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

 #include "oncsSub_idtpcfeev2.h"
 
 #include <string.h>
 #include <stdint.h>
 
 #define coutfl cout << __FILE__<< "  " << __LINE__ << " "
 #define cerrfl cerr << __FILE__<< "  " << __LINE__ << " "
 
 using namespace std;
 
 oncsSub_idtpcfeev2::oncsSub_idtpcfeev2(subevtdata_ptr data)
   :oncsSubevent_w2 (data)
 {
 
  _is_decoded = 0;
  
  for ( int i = 0; i < MAX_FEECOUNT; i++)
    {
      _max_samples[i] = 0;
      _lowest_bx[i] = 0;
      _highest_bx[i] = 0;
    }
 }
 
 
 oncsSub_idtpcfeev2::~oncsSub_idtpcfeev2()
 {
   // for (int fee = 0; fee < MAX_FEECOUNT; fee++)
   //   {
   //     delete fee_data[fee];
   //   }
 
 }
 
 
 #define HEADER_LENGTH 9
 
 int oncsSub_idtpcfeev2::tpc_decode ()
 {
 
   if (_is_decoded ) return 0;
   _is_decoded = 1;
 
   unsigned int payload_length = 2 * (getLength() - SEVTHEADERLENGTH - getPadding() );
   
   unsigned int index = 0;
   
 
   unsigned short *buffer = ( unsigned short *)  &SubeventHdr->data;
 
 
 //   for (int fee = 0; fee < MAX_FEECOUNT; fee++)
 //     {
 //       fee_data[fee] = new std::vector<unsigned short>();
 //     }
   
   while (buffer[index] != 0xfeee && buffer[index+1] != 0xba5e)
     {
       index += 2;
     }
   
   unsigned short word_count;
   unsigned short link_count;
   unsigned short link_enabled;
     
     
   int locked[16];
   for (int a = 0; a < 16; a++) locked[a] = 0;
 
 
   while ( index < payload_length)
     {
 
       if (buffer[index] == 0xfeee && buffer[index+1] == 0xba5e)
     {
       
       word_count = (buffer[index+2] >> 4) + 1;
       link_count = buffer[index+2] & 0xf;
       link_enabled = buffer[index+3];
       
         // cout << __FILE__<< "  " << __LINE__ << " feeeba5e index at " << index
         //   << " word2 " << hex << buffer[index+2] << dec
         //   << " wordcount " << word_count
         //   << " link_count " << link_count
         //   << " link_enabled 0x" << hex << link_enabled << dec
         //   << endl;
         
       unsigned short offset_table[16] = {0};
         
       int offset_idx = 0;
       for  ( int bitcnt = 0 ; bitcnt < 16; bitcnt++)
         {
           if ( (link_enabled & (1 << bitcnt)) != 0)
         {
           offset_table[offset_idx] = bitcnt;
           // coutfl << "link_enabled " << hex << link_enabled << dec
           //     << " offset table " << offset_idx << " value " << bitcnt << endl;
           offset_idx++;
         }
         }
       
       int idx;
       int link;
         
       //        for (idx = index + 4; idx < index + 4 +  word_count * link_count ; idx++)
       for (index += 4, idx=0; idx < word_count * link_count ; idx++, index++)
         {
           link = offset_table[idx % link_count];
           if (locked[link])
         {
           //coutfl << "pushing idx " << idx << " value " << hex << buffer[index] << dec << " into " << link << endl;
           fee_data[link].push_back(buffer[index]);
         }
           else if (buffer[index] == 0xfeed)
         {
           locked[link] = 1;
           //coutfl << "pushing idx " << idx << " value " << hex << buffer[index] << dec << " into " << link << " ** locking" << endl;
           fee_data[link].push_back(buffer[index]);
         }
         }
         
         // cout << __FILE__<< "  " << __LINE__ << " index " << index << " vector sizes " << fee_data[0].size()  << "  " << fee_data[1].size() << endl;
 
     }
       else
       {
         cout << __FILE__<< "  " << __LINE__ << " corrupted FEE data missing 0xfeee 0xba5e marker. Stop further decoding "<< endl;
         break;
       }
 
     }
 
   // here we are done unraveling the initil data structure.
   // We have now MAX_FEECOUNT * MAX_FEECHANNELS per-channel data structures in hand
 
   // first pass...
   
   for ( int fee = 0; fee < MAX_FEECOUNT; fee++)
     {
 
       unsigned int record_len  = 0;
       //unsigned int packet_type;
       unsigned int channel;
       unsigned int sampa_addr;
       unsigned int bx_count;
 
       unsigned int old_bxcount = 0;
       unsigned int first_bx = 0xffffff;
       unsigned int rollover_offset = 0;
       
       for ( index = 0; index < fee_data[fee].size(); index += record_len + 2 )
     {
       if (index >=  fee_data[fee].size() - HEADER_LENGTH) continue;
       
       if ( fee_data[fee].at(index) != 0xfeed)
           {
         //  cerr << __FILE__<< "  " << __LINE__ << " FEE " << fee << " not starting with feed at " << index << " size " <<  fee_data[fee].size() << endl;
         while (index < fee_data[fee].size() - HEADER_LENGTH &&  fee_data[fee].at(index) != 0xfeed   )  index++;
           }
       
         if (index >=  fee_data[fee].size() - HEADER_LENGTH) continue;
         
         record_len  = fee_data[fee].at(index+1);
         if ( index + record_len + 2  >= fee_data[fee].size()) break;
         
         //packet_type = fee_data[fee].at(index+2);
         channel     = fee_data[fee].at(index+3)  & 0x1f;
         sampa_addr  = (fee_data[fee].at(index+3) >> 5) & 0xf;
         bx_count    = (fee_data[fee].at(index+4)  << 4) | (fee_data[fee].at(index+5) & 0xf);
 
         
         //      coutfl << " bx " << bx_count << " delta to previous bx " << bx_count - old_bxcount << endl;
         if ( bx_count < old_bxcount )
           {
         rollover_offset += 0x100000;
         //      coutfl << " bx " << bx_count << " delta to previous bx " << bx_count - old_bxcount << " rollover " << hex << rollover_offset << endl;
           }
         old_bxcount = bx_count;
 
         if ( first_bx == 0xffffff )
           {
         first_bx = bx_count;
           }
         
         // if ( record_len != 0x88)
         //   {
         //  cerrfl << "wrong record length " << record_len << " fee " << fee << " channel " << channel << endl;
         //  //continue;
         //   }
        
         unsigned short crc_value = crc16( fee, index, record_len+1);
         if ( index + record_len +1  >= fee_data[fee].size() )
           {
         cerrfl << "index out of range " << index + record_len + 1 << "  " << fee_data[fee].size() << " record_len " << record_len  << endl;
           }
         else
           {
         if ( crc_value != fee_data[fee].at(index + record_len +1) )
           {
         // cout << __FILE__<< "  " << __LINE__ << " FEE " << fee
         //      << " crc mismatch, index = " << index
         //      << " sampa address " << sampa_addr << " channel " << channel
         //      << " crc = " << hex << crc_value << " value " << fee_data[fee].at(index + record_len +1) << dec <<  endl;
             continue;
           }
           }
         
         if ( channel >= 32 || sampa_addr > 7 )
           {
         cout << __FILE__<< "  " << __LINE__ << " FEE " << fee
              << " illegal value, sampa address " << sampa_addr << " channel " << channel << endl;
         continue;
           }
         
         unsigned int fee_channel = sampa_addr * 32 + channel;
     
         for  ( unsigned int s = HEADER_LENGTH; s < record_len +1; s++) 
           {
             if ( index +s >= fee_data[fee].size() )
               {
             cerrfl << "index out of range " << index +s << "  " << fee_data[fee].size() << " record_len " << record_len  << endl;
               }
             else
               {
             tpc_sample x = { bx_count + s -HEADER_LENGTH + rollover_offset - first_bx,
                      bx_count,
                      fee_data[fee].at(index + s ) };
             fee_samples[fee][fee_channel].push_back(x);
               }
           }
 
     }
     }
 
 
     
          
     // now, what is the max sample length per FEE?
     unsigned int  maxvectorsize;
     for ( int fee = 0; fee < MAX_FEECOUNT; fee++)
       {
     maxvectorsize = 0;
     for ( int ch = 0; ch < MAX_FEECHANNELS; ch++)
       {
         if ( fee_samples[fee][ch].size() > maxvectorsize ) maxvectorsize = fee_samples[fee][ch].size();
         unsigned int s = fee_samples[fee][ch].size();
         if ( s > 0 )
           {
         if ( fee_samples[fee][ch].at(0).bx_time < _lowest_bx[fee] ) _lowest_bx[fee] = fee_samples[fee][ch].at(0).bx_time;
         if ( fee_samples[fee][ch].at(s-1).bx_time > _highest_bx[fee] ) _highest_bx[fee] = fee_samples[fee][ch].at(s-1).bx_time;
           }
       }
     _max_samples[fee] = maxvectorsize;
       }
 
       
     return 0;
 }
     
 
 
 int oncsSub_idtpcfeev2::iValue(const int fee, const int sample)
 {
   tpc_decode();
   
   return 0;
 }
 
 int oncsSub_idtpcfeev2::iValue(const int fee, const int ch, const int sample)
 {
   tpc_decode();
   if ( fee > MAX_FEECOUNT ||
        ch < 0 || ch >= MAX_FEECHANNELS ||
        sample < 0 || (unsigned int) sample >= fee_samples[fee][ch].size() ) return 0;
   
   //  if ( sample >= fee_samples[fee][ch].size() ) return 0;
   return fee_samples[fee][ch].at(sample).adc;
 
 }
 
 int oncsSub_idtpcfeev2::iValue(const int fee, const int ch, const int sample, const char *what)
 {
   tpc_decode();
 
   if ( fee > MAX_FEECOUNT ||
        ch < 0 || ch >= MAX_FEECHANNELS ||
        sample < 0 || (unsigned int) sample >= fee_samples[fee][ch].size() ) return 0;
 
 
   if ( strcmp(what,"BXRAW") == 0 )
     {
       return fee_samples[fee][ch].at(sample).bx_time_raw;
     }
   else if ( strcmp(what,"BX") == 0 )
     {
       return fee_samples[fee][ch].at(sample).bx_time;
     }
   return 0;
 }
 
 int oncsSub_idtpcfeev2::iValue(const int fee, const int ch, const char *what)
 {
 
   tpc_decode();
 
   if ( strcmp(what,"NR_SAMPLES") == 0 )  // say if a FEE has been seen at all
   {
     if ( fee > MAX_FEECOUNT || ch < 0 || ch >= MAX_FEECHANNELS )  return 0;
     return  fee_samples[fee][ch].size();
 
   }
 
   return 0;
 }
   
 
 int oncsSub_idtpcfeev2::iValue(const int n, const char *what)
 {
 
   tpc_decode();
 
   if ( strcmp(what,"MAX_SAMPLES") == 0 )
   {
     if ( n < 0 || n >= MAX_FEECOUNT ) return 0;
     
     return _max_samples[n];
   }
 
   else if ( strcmp(what,"IS_PRESENT") == 0 )  // say if a FEE has been seen at all
   {
     if ( n < 0 || n >= MAX_FEECOUNT ) return 0;
     
     if (_max_samples[n] > 0) return 1;
     return 0;
   }
 
   else if ( strcmp(what,"LOWEST_BX") == 0 )  // say if a FEE has been seen at all
   {
     if ( n < 0 || n >= MAX_FEECOUNT ) return 0;
     
     return _lowest_bx[n];
   }
 
   else if ( strcmp(what,"HIGHEST_BX") == 0 )  // say if a FEE has been seen at all
   {
     if ( n < 0 || n >= MAX_FEECOUNT ) return 0;
     
     return _highest_bx[n];
   }
 
   else if ( strcmp(what,"MAX_FEECOUNT") == 0 )
   {
     return MAX_FEECOUNT;
   }
 
 
   else if ( strcmp(what,"BROKEN") == 0 )
   {
     return _broken;
   }
 
 
   return 0;
 
 }
 
 void  oncsSub_idtpcfeev2::dump ( OSTREAM& os )
 {
   identify(os);
 
   os << "Samples:       ";
   for ( int i = 0 ; i < iValue(0,"MAX_FEECOUNT"); i++)
     {
       os << setw(9) << iValue(i,"MAX_SAMPLES") << " ";
     }
   os << std::endl;
 
   os << "Lowest BX:      ";
   for ( int i = 0 ; i < iValue(0,"MAX_FEECOUNT"); i++)
     {
       os << setw(9) << (unsigned int) iValue(i,"LOWEST_BX") << " ";
     }
   os << std::endl;
 
   os << "Highest BX:     ";
   for ( int i = 0 ; i < iValue(0,"MAX_FEECOUNT"); i++)
     {
       os << setw(9) << (unsigned int) iValue(i,"HIGHEST_BX") << " ";
     }
   os << std::endl;
 
   
   const int dwidth = 16;  // how many colums to display
  
   for ( int fee = 0; fee < iValue(0,"MAX_FEECOUNT") ; fee++)
     {
       for ( int chblock = 0; chblock < MAX_FEECHANNELS ; chblock+=dwidth)
     {
       if ( iValue (fee,"IS_PRESENT") )
         {
           cout << "       +++++++++++++++ FEE " << fee << "   channels " << chblock << " through " << chblock + dwidth << " ++++++++" << endl;
           
           // print ithe smaple numbers
           os << setw(3) << "nrs" << " | " ;
           for ( int ch = chblock; ch < chblock + dwidth; ch++)
         {
           os << setw(10) <<  iValue(fee,ch,  "NR_SAMPLES") << "  " ;
         }
           
           os << endl;
 
           
           for ( int s = 0; s < iValue(fee, "MAX_SAMPLES"); s++)
         {
           
           os << setw(3) << s << " | " ;
           for ( int ch = chblock; ch < chblock + dwidth; ch++)
             {
               os << setw(6) << hex << iValue(fee,ch,s, "BX") << " " << setw(4) << iValue(fee,ch,s) << dec << " ";
               
             }
           
           os << endl;
         }
           os << endl;
         }
     }
   
     }
 }
 
 unsigned short oncsSub_idtpcfeev2::reverseBits(const unsigned short x) const
 {
   unsigned short n = x;  
   n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa);
   n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc);
   n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0);
   n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00);
   //n = (n >> 16) & 0x0000ffff | (n << 16) & 0xffff0000;
   return n;
 }
 
 
 
 unsigned short oncsSub_idtpcfeev2::crc16(const unsigned int fee, const unsigned int index, const int  l) const 
 {
   int len = l;
   int i = index;
   unsigned short crc = 0xffff;
     
   while (len--)
     {
       unsigned short x = fee_data[fee].at(i++);
       //      cout << "in crc " << hex << x << dec << endl;
       crc ^= reverseBits( x);
       for (unsigned short k = 0; k < 16; k++)
     {
       crc = crc & 1 ? (crc >> 1) ^ 0xa001 : crc >> 1;
     }
       }
   crc = reverseBits(crc);
   return crc;
 }
 

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