oncsSub_idtpcfeev2.cc

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file oncsSub_idtpcfeev2.cc

#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;
}