sPhenix code displayed by LXR master/​online_distribution/​newbasic/​oncsSub_iddreamv0.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_iddreamv0.h"
 #include <string.h>
 #include <iostream>
 #include <iomanip>
 #include <vector>
 
 #include <arpa/inet.h>  // for htons
 
 
 using namespace std;
 
 oncsSub_iddreamv0::oncsSub_iddreamv0(subevtdata_ptr data)
   :oncsSubevent_w4 (data)
 {
 
   _is_decoded = 0;
   
 
   swapped_array = 0;
 }
 
 oncsSub_iddreamv0::~oncsSub_iddreamv0()
 {
 
   if (swapped_array) delete [] swapped_array; 
 
   std::map <int,  FEU_decoded_data *>::iterator it;
       
   for ( it=feu_map.begin() ; it != feu_map.end(); ++it)
     {
       FEU_decoded_data *fd = it->second;
       delete fd;
     }
 }
 
 
 int oncsSub_iddreamv0::iValue ( const int i,const char * what)
 {
   int nw;
   decode (&nw);
 
   
   if ( strcmp(what,"NR_FEU") == 0 )
     {
       return feu_map.size();
     }
 
   if ( strcmp(what,"FEU_ID") == 0 )
     {
       unsigned ii = i;
       if ( ii >= feu_map.size() ) return 0;
       
       std::map <int,  FEU_decoded_data *>::const_iterator it = feu_map.begin();
       
       for ( int k =0; k < i; k++) ++it;
     
       FEU_decoded_data *fd = it->second;
       
       //      cout << __FILE__ << " " << __LINE__ << " returning feu_id= " << fd->_feu_id  << endl;
 
       return fd->_feu_id;
     }
 
   
   FEU_decoded_data * fd = feu_map[i];
   if ( !fd ) return 0;
 
   if ( strcmp(what,"SAMPLES") == 0 )
     {
       return fd->_nr_samples+1; 
     }
 
   if ( strcmp(what,"NR_DREAM") == 0 )
     {
       return fd->_nr_dreams; 
     }
   
   if ( strcmp(what,"PEDSUBTRACTED") == 0 )
     {
       return  fd->_feu_P; 
     }
 
   if ( strcmp(what,"COMMONNOISE") == 0 )
     {
       return  fd->_feu_C; 
     }
   
   if ( strcmp(what,"ZEROSUPPRESSED") == 0 )
     {
       return  fd->_feu_Z; 
     }
 
 
   
   return 0;
 }
 
 
 int oncsSub_iddreamv0::iValue(const int feu_id, const int dreamchip, const char *what)
 {
   
   
   if ( dreamchip < 0 || dreamchip > 7) return 0;
 
   FEU_decoded_data * fd = feu_map[feu_id];
   if ( !fd ) return 0;
   
   
   if ( strcmp(what,"DREAM_ENABLED") == 0 )
     {
       return fd->_dream_enabled[dreamchip];
     }
   
 
   return 0;
 }
 
 
 int oncsSub_iddreamv0::iValue(const int channel, const int sample)
 {
   //  int dream = channel/64;
   //int ch = channel%64;
   //return iValue(dream,ch,sample);
   return 0;
 }
 
 
 int oncsSub_iddreamv0::iValue(const int feu_id, const int channel, const int sample)
 {
 
   int nw;
   decode (&nw);
 
   FEU_decoded_data * fd = feu_map[feu_id];
   if ( !fd ) return 0;
   
   int dreamchip = channel/64;
   int ch = channel%64;
 
   
   if (! fd->_dream_enabled[dreamchip]) return 0;
 
   if ( dreamchip < 0 || dreamchip >=8 ) return 0;
   if ( sample < 0 || sample > 254) return 0;
 
   return fd->samples[dreamchip][ch][sample];
 }
 
 
 void  oncsSub_iddreamv0::dump ( OSTREAM& os )
 {
   identify(os);
   int i;
   int nw;
   decode (&nw);
 
   os << "Nr of FEUs:         " << setw(4) << iValue(0,"NR_FEU") <<endl;
   for ( i = 0; i < iValue(0,"NR_FEU"); i++)
     {
       int id = iValue(i,"FEU_ID");
       os << "FEU_ID:              " << setw(4) << i << setw(4) << id << endl;
       os << " DreamChips:         " << setw(4) << iValue(id,"NR_DREAM") << "  enabled:  ";
       for (int dream = 0; dream < 8; dream++)
     {
       if ( iValue(id, dream,"DREAM_ENABLED") )
         {
           os << " 1 ";
         }
       else
         {
           os << " X ";
         }
     }
       os << endl;
       os << " Nr of samples:      " << setw(4) << iValue(id,"SAMPLES") <<endl;
       os << " Pedestal subtracted " << setw(4) << iValue(id,"PEDSUBTRACTED") <<endl;
       os << " Zero suppressed     " << setw(4) << iValue(id,"ZEROSUPPRESSED") <<endl;
       os << " Common Noise supp.  " << setw(4) << iValue(id,"COMMONNOISE") <<endl;
       
   
       for (int dream = 0; dream < 8; dream++)
     {
       if ( iValue(id,dream,"DREAM_ENABLED") )
         {
           os << "                                      ---- Dream chip " << dream << " ---- " << endl;
           os << " ch-> " ;
           for (int channel = 0; channel < 32; channel ++)
         {
           os << setw(5) << channel;
         }
           os << endl;
           os << "smple|" ;
           for (int channel = 32; channel < 64; channel ++)
         {
           os << setw(5) << channel;
         }
           os << endl;
       
           os << "-----+-" ;
           for (int channel = 0; channel < 32; channel ++)
         {
           os << "----+";
         }
           os << endl;
       
           for (int sample = 0; sample < iValue(id,"SAMPLES"); sample ++)
         {
           os << setw(4) << sample << " |";
           
           for (int channel = 0; channel < 32; channel ++)
             {
               int xx = iValue(id, dream*64 + channel, sample);
               os << setw(5) << xx;
             }
           os << endl;
           os << "    - ";
           for (int channel = 32; channel < 64; channel ++)
             {
               os << setw(5) << iValue(id, dream*64 +channel, sample);
             }
           os << endl;
         }
           os << endl;
         }
     }
       
     }
 }
 
 int *oncsSub_iddreamv0::decode ( int *nwout)
 {
   if ( _is_decoded) return 0;
   _is_decoded = 1;  // mark this as done already
   
 
 
   unsigned short *d = (unsigned short *) &SubeventHdr->data;  // here begins the payload
   int dlength =  2 * (getLength()-4 - getPadding() );
 
   swapped_array = new unsigned short[dlength];
 
   int array_position = 0;
   for ( int i = 0; i < dlength; i++)
     {
       if (  d[i] == 0xaabb &&  d[i+1] == 0xccdd )
     {
       int len    = ntohs(d[i+3]) /2;
       //      cout << __FILE__ << " " << __LINE__ << " new packet, feu_id= " << feu_id << " len = " << len << endl;
       i+=4;
       for ( int k = 0; k < len; k++)
         {
           swapped_array[array_position++] = ntohs(d[i+k]);
         }
       i+= len-1;
     }
     }
 
   int arraylength = array_position;
 
   int status = decode_payload(swapped_array, arraylength);
   if (status) cerr << __FILE__ << " " << __LINE__ << " error status from decode_payload " << status << endl;
 
   *nwout = 0;
   return 0;
 }
 
   
 int oncsSub_iddreamv0::decode_payload ( unsigned short *d, const int size) 
 {
 
   FEU_decoded_data *fd = 0;
 
   int nwpacket_index = 0;  // this is supposed to point to the network packet start
   int index = 0;
   int feu_index = 0;
   int dream_index = 0;
   int dream_data_length = 0;
 
 
   int event_id;
   int time_stamp;
 
   int sample_id =-1;
   int fine_tstp; 
   int old_eventid = -1;
 
   int dream_id;
   int feu_id;
   
   while ( nwpacket_index + 4 < size)
     {
 
       feu_index = nwpacket_index;
       
       // skip leading 0's
       while ( d[feu_index] == 0 ) feu_index++;
 
       // FEU header
       index = feu_index;  
       if ( (d[index] & 0x7000) == 0x6000)  // word 0 
     {
       feu_id = d[index] & 0xff;
       
       // do we know this FEU?
       if ( ! feu_map.count(feu_id) )
         {
           //          cout << __FILE__ << " " << __LINE__ << " new feu_id= " << feu_id << " added" << endl;
           feu_map[feu_id] = fd = new FEU_decoded_data;
           fd->_feu_id = feu_id;
           fd->_feu_P = 0;
           fd->_feu_C = 0;
           fd->_feu_Z = 0;
           fd->_nr_samples = 0;
           fd->_nr_dreams = 0;
           memset (fd->samples, 0,  8*64*255*sizeof(int) );
           memset (fd->cellids, 0,  8*64*sizeof(unsigned long long) );
         }
       else
         {
           fd = feu_map[feu_id];
         }
 
       fd->_feu_P  = ( d[index] >>  8) & 0x1;
       fd->_feu_C  = ( d[index] >>  9) & 0x1;
       fd->_feu_Z  = ( d[index] >> 10) & 0x1;
 
     }  // word 0
       
       index = feu_index+1;                  // word 1
       if ( (d[index] & 0x7000) == 0x6000)
     {
       event_id = d[index] & 0xfff;
       if ( old_eventid < 0)
         {
           old_eventid  = event_id;
         }
       else
         {
           if (old_eventid  != event_id)  cerr << __FILE__ << " " << __LINE__ << " feu eventid= " << event_id << " others " << old_eventid << endl;
         }
     }
       
       index = feu_index+2;                  // word 2
       if ( (d[index] & 0x7000) == 0x6000)
     {
       time_stamp = d[index] & 0xfff;
     }
       
       index = feu_index+3;                  // word 3
       if ( (d[index] & 0x7000) == 0x6000)
     {
       sample_id = ( d[index]>> 3) & 0x1ff;
       if ( sample_id > fd->_nr_samples) fd->_nr_samples = sample_id;  // and update the max sample nr as needed
       fine_tstp = ( d[index]) & 0x7;
     }
       //      cout << __FILE__ << " " << __LINE__ <<  " FEU id " << feu_id << " event id " << event_id << " sample id " <<  sample_id << " maxsample " << fd->_nr_samples << endl;
 
       time_stamp = ( time_stamp<<3)  | fine_tstp;
 
       index = feu_index+4 ;
       if (  (d[index] & 0x6000) == 0x6000 )  // do we have the optional header?
     {
       //      cout << __FILE__ << " " << __LINE__ <<  " skipping opt  header event id " << event_id << " sample id " <<  sample_id << endl;
       index += 4;      // skip if so
     }
       
       // done with FEU hdr -----
 
 
       // We will maintain dream_index as the index to the deam chip data start 
 
       
       dream_index = index;
       int done_with_this_feu = 0;
 
       if ( fd->_feu_Z )   // zero_suppressed data
     {
       //  cout << __FILE__ << " " << __LINE__ << "  " << hex << (d[index] & 0x7fff) << dec << endl;
       while( ( d[index] & 0x6000) != 0x6000 )  // test if x11x == end marker
         {
           dream_id = ( d[index] >> 6 ) & 0x7;
           int channel_id =    d[index]  & 0x3f;
           int channel_value = d[index+1] & 0xfff;
 
           // cout << __FILE__ << " " << __LINE__ << "  " << hex << (d[index] & 0x7fff) << dec
           //       << " dreamchip " << setw(5) << dream_id
           //       << " channel id " << setw(5) << channel_id
           //       << " channel val " << setw(5) << channel_value << endl;
 
           fd->samples[dream_id][channel_id][sample_id] = channel_value;
 
           if ( ! fd->_dream_enabled[dream_id] ) fd->_nr_dreams++;          // this is a dream id we hadn't seen before
           fd->_dream_enabled[dream_id] = 1;                           // mark it as "seen"
           index += 2;
         }
       //      cout << __FILE__ << " " << __LINE__ << "  " << hex << (d[index] & 0x7fff) << dec << endl;
       index += 2;
 
       nwpacket_index = dream_index = index;
     }
       
       else   // not Zero-suppressed data 
     {
 
       while( ! done_with_this_feu)
         {
           // first, we figure out where it ends. It should end 74 words in, but we better check.
           // we first check that dream_index + 68 has a dream header tag, and that +73 shows the same
           // dream id as our header here. 
           
           if ( ( d[dream_index + 68 ] & 0x6000) == 0x4000 )
         {
           dream_id = (d[dream_index+3] >> 9) & 0x7;
           int trailer_dream_id = (d[dream_index+73] >> 9) & 0x7;
           //          cout << __FILE__ << " " << __LINE__ << " dream_id= " << dream_id   <<  " trailer_dream_id= " << trailer_dream_id << endl;
           
           if (  dream_id == trailer_dream_id )   // all ok
             {
               dream_data_length = 74;
             }
           else
             {
               return -1;
             }
           
           if ( ! fd->_dream_enabled[dream_id] ) fd->_nr_dreams++;          // this is a dream id we hadn't seen before
           fd->_dream_enabled[dream_id] = 1;                           // mark it as "seen"
           if ( sample_id > fd->_nr_samples) fd->_nr_samples = sample_id;  // and update the max sample nr as needed
           
           decode_dream( fd, &d[dream_index], dream_data_length, sample_id);
           
           dream_index += dream_data_length;
           
         }
           else
         {
           // cout << __FILE__ << " " << __LINE__ << " FEU trailer reached " << endl;
           nwpacket_index = dream_index + 2;
           //  cout << __FILE__ << " " << __LINE__ << " EoE " <<  (( d[dream_index] >> 11) & 1) << " length  "  << (d[dream_index] & 0x7ff) <<dec << endl;
           done_with_this_feu = 1;
         }
         }
     }
     }
   return 0;
 }
 
 int oncsSub_iddreamv0::decode_dream( FEU_decoded_data *fd, unsigned short *d, const int size, const unsigned int sample_nr)
 {
   unsigned long long cell_id;
   unsigned long long trigger_id;
 
   unsigned int dream_id;
 
   
   dream_id = (d[3] >> 9) & 0x7;
 
   if ( dream_id >=8) return -1;       // can have only 0...7
   if ( sample_nr >= 254 ) return -2;  // sample id 0...255 max
 
   trigger_id =  (d[0] & 0xfff) << 24;
   trigger_id |= (d[1] & 0xfff) << 12;
   trigger_id |= (d[2] & 0xfff);
 
   cell_id =  (d[70] & 0xfff) << 24;
   cell_id |= (d[71] & 0xfff) << 12;
   cell_id |= (d[72] & 0xfff);
 
   
   fd->cellids [dream_id][sample_nr] = cell_id; 
 
   
   for ( int i = 0; i < 64; i++)
     {
       fd->samples[dream_id][i][sample_nr] = d[4+i] & 0xfff; 
     }
 
   return 0;
 }
 

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