/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/DataFormats/FEDRawData/interface/DaqData.h

Go to the documentation of this file.

#ifndef FEDRawData_DaqData_h
#define FEDRawData_DaqData_h

#include <typeinfo>  
#include <vector>  
#include <map>
#include <string>
#include <cmath>
   
template <class Format>
class DaqData {

 public:

  DaqData(std::vector<unsigned int> & v) : size_(0), buffer_(0), nobjects_(0) {

    try {

      if (v.size() == 0)  throw string("DaqData: empty input data vector provided: ");     

      int Nfields = Format::getNumberOfFields();
      if (v.size()%Nfields != 0)  throw string("DaqData: ERROR. You must provide a number of input values compatibles with the requested format: ");


      int ObjSize = Format::getFieldLastBit(Nfields-1)+1;
      nobjects_ = v.size()/Nfields;
      //      cout<<"Going to create "<<nobjects_<< " objects of type "<<typeid(Format).name()<<endl;

      
      size_ = (int) ceil(((double)(ObjSize*nobjects_))/8);
      buffer_= new  char[size_];      
      //   cout<<"The buffer will be "<<size_ <<" bytes long"<<endl; 

      std::vector<unsigned int>::iterator vit = v.begin();
      char * p = buffer_;
      int bitsalreadyfilled = 0;

      int Totbytes=1;

      for(int i=0; i<nobjects_; i++) {

        //additional bytes necessary to accomodate the current object
        int Nbytes = (int) ceil((double)(Format::getFieldLastBit(Nfields-1)+1-8+bitsalreadyfilled)/8); 

        if ((Totbytes+=Nbytes)  > size_) throw string("Exceeded allocated buffer size");
        
        compressObject(p, vit, bitsalreadyfilled);

        // cout<<"Successfully compressed object "<< i <<endl; 
          
        data_.insert(std::pair< int, std::vector<unsigned int> >(i,std::vector<unsigned int>(vit-Nfields,vit) ));

        //the second term is necessary in the case the last byte has been fully used 
        p+=(Nbytes+(8-bitsalreadyfilled)/8) ;
        Totbytes+=(8-bitsalreadyfilled)/8 ;
      }
      if(bitsalreadyfilled==0) Totbytes--;

      /*
       cout << "Compression successful. "<< Totbytes<<" bytes compressed in total"<< endl;
       cout<< "Buffer pointer: "<<hex<< buffer_<< dec << "Size of buffer= "<< size_<<endl;
      for(int i=0; i<nobjects_; i++) {
        cout << "Object # "<< i << " fields: " <<endl;
        for(int j=0; j<Format::getNumberOfFields(); j++) cout << getValue(j,i) <<endl;
      }
      */

    }

    catch (std::string s){

      cout<<"DaqData - Exception caught: " << s <<endl;
      cout<<"Object compression failed! No data has been constructed for format: "<< string(typeid(Format).name())<<endl; 
      
    }

  }


  DaqData(const unsigned char * ptr, 
          int sizeinbytes) : size_(0), buffer_(0), nobjects_(0) {


    try {

      if (sizeinbytes==0) throw std::string("Buffer size is zero");

      int Nfields = Format::getNumberOfFields();
      int ObjSize = Format::getFieldLastBit(Nfields-1)+1;
      nobjects_ = (sizeinbytes*8)/ObjSize;

      // cout<<"Going to create "<<nobjects_<< " objects of type "<<typeid(Format).name()<<endl;
      // cout<<"The buffer will be "<<size_ <<" bytes long"<<endl;      

      if ((sizeinbytes*8)%ObjSize != 0) {
        cout<<"DaqData: there will be  " << (sizeinbytes*8)%ObjSize <<" meaningless bits at the end of the buffer"<<endl;
      }

      //     buffer_ = new char[sizeinbytes];
      //     memmove(buffer_,ptr,sizeinbytes);

      //      char * p = buffer_;

      const unsigned char * p = ptr;
      int bitsalreadyfilled = 0;
      
      int Totbytes=1;

      for(int i=0; i<nobjects_; i++) {

        std::vector<unsigned int> objdata;
        objdata.reserve(Nfields);

        //additional bytes necessary to accomodate the current object
        int Nbytes = (int) ceil((double)(Format::getFieldLastBit(Nfields-1)+1-8+bitsalreadyfilled)/8); 


        if ((Totbytes+=Nbytes) > sizeinbytes) throw std::string("Exceeded allocated buffer size");

        
        uncompressObject(p, objdata, bitsalreadyfilled);
     
        //      cout<<"Successfully uncompressed object "<< i <<endl; 
        data_.insert(std::pair< int, std::vector<unsigned int> >(i,objdata) );

        //the second term is necessary in the case the last byte has been fully used 
        p+= (Nbytes + (8-bitsalreadyfilled)/8);
        Totbytes+= (8-bitsalreadyfilled)/8;

      }

      if(bitsalreadyfilled==0) Totbytes--;

      /*
      cout << "Uncompression succeeded. "<< Totbytes<<" bytes uncompressed in total"<< endl;
      cout<< "Buffer pointer: "<<hex<< buffer_<< dec<< "Size of buffer= "<< size_<<endl;

      for(int i=0; i<nobjects_; i++) {
        cout << "Object # "<< i << " fields: " <<endl;
        for(int j=0; j<Format::getNumberOfFields(); j++) cout << getValue(j,i) <<endl;
      }
      */

    }
    catch (std::string s){

      std::cout<<"DaqData - Exception caught: " << s <<std::endl;
      std::cout<<"Object uncompression failed! No data has been constructed for format: "<<std::string(typeid(Format).name())<<endl; 
      
    }

  }


  DaqData(const DaqData & a) {

    size_ = a.Size();
    buffer_ = new char[size_];
    memmove(buffer_,a.Buffer(),size_);    
    nobjects_ = a.Nobjects();

    for(int i=0; i<nobjects_; i++) {
      std::vector<unsigned int> vec;
      for(int j=0; j<Format::getNumberOfFields(); j++) vec.push_back(a.getValue(j,i)); 
      data_.insert(std::pair< int, std::vector<unsigned int> >(i, vec));
    }

  }


  ~DaqData(){

    // cout<<"Deleting DaqData of type "<<typeid(Format).name()<<endl;
    if (buffer_!=0) delete [] buffer_;

  };


  char * Buffer() const {return buffer_;}

  int Size() const {return size_;}

  int Nobjects() const {
    return nobjects_;
    /*    cout<<"Nobjects()"<<endl;
    int Nfields = Format::getNumberOfFields();
    return size_/(Format::getFieldLastBit(Nfields-1)+1);
    */
  }

  unsigned int getValue(int indfield, int indobj=0) const {
    
    if (indobj<nobjects_ && indfield < Format::getNumberOfFields()) {
      std::map < int, std::vector<unsigned int> >::const_iterator it = data_.find(indobj);
      if (it != data_.end()) return ((*it).second)[indfield];
      else {
        cout<<"DaqData - Strange: object should exist but was not found "<<endl;
        return 0;
      }
    }
    else  cout<<"DaqData - Non existent field or object"<<endl;
    return 0;

  }

 private:

  void uncompressObject(const  unsigned char * ptr, 
                        std::vector<unsigned int> & objdata, 
                        int & bitsalreadyfilled) {

    int Nfields = Format::getNumberOfFields();

    int bitstoaccomodate=Format::getFieldLastBit(0)+1; // of current field

    int ifield = 0;
    unsigned int value = 0; 

    while (ifield < Nfields) {

      if(bitstoaccomodate > 8 - bitsalreadyfilled ) {

        // cout<<"can't complete value from current byte"<<endl;
        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

        //1)The syntax below could be faster. 
        //  To be checked as soon as time available(check started with prog test4.C) .
        //2)check if all cast to unsigned int are really necessary(done, they are not).
        //3)Instead of using pow(2,1;2;3;4;5..), a faster enum could be used
        //Lower all bits but those not yet read
        //value += ( (*ptr & ((unsigned int)pow(2.,8-bitsalreadyfilled)-1)) << bitstoaccomodate + bitsalreadyfilled - 8 ) ;
        //              if(bitstoaccomodate > 8) value += ( ((((unsigned int)(*ptr)) << bitsalreadyfilled) & 0xff) << (bitstoaccomodate - 8) );
        //      else value += ( ((((unsigned int)(*ptr)) << bitsalreadyfilled) & 0xff) >> (8 - bitstoaccomodate) );


        if(bitstoaccomodate > 8) value += ( ( (*ptr << bitsalreadyfilled) & 0xff ) << (bitstoaccomodate - 8) );
        else value += ( ( (*ptr << bitsalreadyfilled) & 0xff) >> (8 - bitstoaccomodate) );
        

        // cout<< "value: "<< hex << value << " - " << dec <<  value<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) << " - " << dec << (unsigned int)(*ptr) << endl;


        ptr++;
        bitstoaccomodate -= (8-bitsalreadyfilled);
        bitsalreadyfilled = 0;

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;
        
      } 

      else if(bitstoaccomodate < (8 - bitsalreadyfilled) && bitstoaccomodate >0){
        // cout<<"value can be completed from current byte, which still contain info"<<endl;

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

        //1)The syntax below could be faster. 
        //  To be checked as soon as time available.
        //2)check if all cast to unsigned int are really necessary.
        //3)Instead of using pow(2,1;2;3;4;5..), a faster enum could be used
        //Lower all bits but those not yet read
        //value += (*ptr & ((unsigned int)pow(2.,8-bitsalreadyfilled)-1)) >> (8 - bitstoaccomodate - bitsalreadyfilled);

        value += ( ( (*ptr << bitsalreadyfilled) & 0xff ) >> (8 - bitstoaccomodate) ) ;

        // cout<< "value: "<< hex << value << " - " << dec <<  value<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) << " - " << dec << (unsigned int)(*ptr) << endl;


        objdata.push_back(value);
        value = 0;
        bitsalreadyfilled+=bitstoaccomodate;

        // cout<<"Field completed"<<endl;

        if(ifield==Nfields-1) return;
       
        // cout<<"Uncompressing new Field"<<endl;

        ifield++;
        bitstoaccomodate=Format::getFieldLastBit(ifield)-Format::getFieldLastBit(ifield-1); 
        
        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

      }

      else if(bitstoaccomodate == (8 - bitsalreadyfilled) && bitstoaccomodate >0){
        // cout<<"value can be completed from what left in current byte"<<endl; 
        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

        //1)The syntax below could be faster. 
        //  To be checked as soon as time available.
        //2)check if all cast to unsigned int are really necessary.
        //3)Instead of using pow(2,1;2;3;4;5..), a faster enum could be used
        //Lower all bits but those not yet read
        //      value += *ptr & ((unsigned int)pow(2.,8-bitsalreadyfilled)-1);

        value += ( ( (*ptr << bitsalreadyfilled) & 0xff ) >> (8 - bitstoaccomodate) ) ;

        // cout<< "value: "<< hex << value << " - " << dec <<  value<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) << " - " << dec << (unsigned int)(*ptr) << endl;


        objdata.push_back(value);
        value = 0;
        bitsalreadyfilled=0;

        // cout<<"Field completed"<<endl;

        if(ifield==Nfields-1) return;

        // cout<<"Uncompressing new Field"<<endl;

        ptr++;
        ifield++;
        bitstoaccomodate=Format::getFieldLastBit(ifield)-Format::getFieldLastBit(ifield-1);     

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

      }
      else throw std::string(" unexpected situation during uncompression");

    } //end of cycle over fields
    
  }




  void compressObject(const unsigned char * ptr, std::vector<unsigned int>::iterator & vit, int & bitsalreadyfilled) {

    int Nfields = Format::getNumberOfFields();

    int bitstoaccomodate=Format::getFieldLastBit(0)+1; // of current field
    
    if (*vit > pow(2.,bitstoaccomodate)-1) throw string("The value is too large to fit in the field ");
 
    int ifield = 0;

    //Lower all bits but those already filled
    *ptr &= 0xff + 1 - (unsigned int)pow(2.,8-bitsalreadyfilled);

    while (ifield < Nfields) {


      if(bitstoaccomodate > 8 - bitsalreadyfilled ) {

        // cout<<"Field cannot be compressed from what left in current byte"<<endl;
        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

        *ptr += (((*vit) >> (bitstoaccomodate - (8 - bitsalreadyfilled))) & 0xff);
        // cout<< "value: "<< hex << *vit <<" - " << dec <<  *vit<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) <<" - "<< dec << (unsigned int)(*ptr) << endl;


        bitstoaccomodate -= (8-bitsalreadyfilled);
        bitsalreadyfilled = 0;
        ptr++;
        *ptr &= 0xff + 1 - (unsigned int)pow(2.,8-bitsalreadyfilled);

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

      } 

      else if(bitstoaccomodate < (8 - bitsalreadyfilled) && bitstoaccomodate >0){

        // cout<<"Field can be compressed in the current byte, which will not be completely filled"<<endl;

        *ptr += ( (((*vit) << 8-bitstoaccomodate) & 0xff) >> (bitsalreadyfilled) );

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;
        // cout<< "value: "<< hex << *vit <<" - " << dec <<  *vit<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) <<" - "<< dec << (unsigned int)(*ptr) << endl;

        vit++;
        bitsalreadyfilled+=bitstoaccomodate;

        // cout<<"Field completed"<<endl;

        if(ifield==Nfields-1) return;

        // cout<<"Compressing new Field"<<endl;
       
        ifield++;
        bitstoaccomodate=Format::getFieldLastBit(ifield)-Format::getFieldLastBit(ifield-1); 
        if (*vit > pow(2.,bitstoaccomodate)-1) throw string("The value is too large to fit in the field ");

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

      }

      else if(bitstoaccomodate == (8 - bitsalreadyfilled) && bitstoaccomodate >0){

        // cout<<"Field can be compressed in the current byte, which will be completely filled"<<endl;


        *ptr += ( (((*vit) << 8-bitstoaccomodate) & 0xff) >> (bitsalreadyfilled) );

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;
        // cout<< "value: "<< hex << *vit <<" - " << dec <<  *vit<< endl;
        // cout<< "byte: "<< hex << (unsigned int)(*ptr) <<" - "<< dec << (unsigned int)(*ptr) << endl;

        vit++;
        bitsalreadyfilled=0;

        // cout<<"Field completed"<<endl;

        if(ifield==Nfields-1) return;

        // cout<<"Compressing new Field"<<endl;

        ptr++;
        *ptr &= 0xff + 1 - (unsigned int)pow(2.,8-bitsalreadyfilled);

        ifield++;
        bitstoaccomodate=Format::getFieldLastBit(ifield)-Format::getFieldLastBit(ifield-1);     

        if (*vit > pow(2.,bitstoaccomodate)-1) throw string("The value is too large to fit in the field ");

        // cout <<"bitstoaccomodate= "<<bitstoaccomodate<<" bitsalreadyfilled= "<<bitsalreadyfilled<<" ifield="<< ifield<<" Nfields="<<Nfields<<endl;

      }
      else throw string(" unexpected situation during compression");

    } //end of cycle over fields
    
  }


 private:

  std::map < int, std::vector<unsigned int> > data_;

  int size_;
  unsigned char * buffer_;
  int nobjects_;

  /* Old implementation of compress
 
  //assumes a correct number of objects has been sent. Alignment to the byte
  int compressObject(unsigned char * p, vector<unsigned int>::iterator & vit, int & bitsalreadyfilled){
 
    int Nfields = Format::getNumberOfFields();
    int Nbytes = (int) (ceil((double)(Format::getFieldLastBit(Nfields-1)+1)/8));
 
    unsigned int indfield=0; // index of current field
    unsigned int bitstoaccomodate=Format::getFieldLastBit(indfield)+1; // of current field

    //Here there should be a check on the size of the first value against the available bits

    for (int ibyte = 0; ibyte < Nbytes ; ibyte++){

      //      int bitsalreadyfilled = 0; // of current byte

      if(bitstoaccomodate>8-bitsalreadyfilled) {
        cout<<"More than available bits to accomodate"<<endl;

        *p = ( (*vit) >> (bitstoaccomodate - 8) ) & 0xff;
        cout<< "value: "<< hex << *vit << dec <<  *vit<< endl;
        cout<< "byte: "<< hex << *p << dec << *p << endl;

        bitstoaccomodate -= 8;
        p++;
        bitsalreadyfilled = 0;     
      } 

      else if(bitstoaccomodate<=8-bitsalreadyfilled && bitstoaccomodate>0){

        cout<<"bits to accomodate less than available"<<endl;

        unsigned int bytevalue=0;

        // First, put the bits of the current object in the current byte
        
        bytevalue += ( (*vit) << ( 8 - bitstoaccomodate ) ) & 0xff;
        cout<< "value: "<< hex << *vit << dec <<  *vit<< endl;
        cout<< "byte: "<< hex << bytevalue << dec << bytevalue << endl;


        bitsalreadyfilled = bitstoaccomodate;
        indfield++;

        if (indfield>=Nfields)  return 0;
       
        vit++;

        //Here there should be a check on the size of the current value against the left available bits

        if(bitsalreadyfilled==8) {
          bitstoaccomodate=Format::getFieldLastBit(indfield)-Format::getFieldLastBit(indfield-1);
          p++;
          continue;
        }

        //This is the case of remaining fields and space left in the byte
      
        //Compute the last field that can be treated for this byte
        int lastfield=indfield;
        int ntotbits=bitsalreadyfilled+Format::getFieldLastBit(indfield)-Format::getFieldLastBit(indfield-1);
        while(ntotbits < 8 && lastfield<Nfields )  {
          lastfield++;
          ntotbits+=Format::getFieldLastBit(lastfield)-Format::getFieldLastBit(lastfield-1);
        }

        // First, fit fields, if there are, that for sure fully fit into the current byte leaving at least one free bit
        for(; indfield < lastfield  ; indfield++) {
          bitsalreadyfilled += Format::getFieldLastBit(indfield)-Format::getFieldLastBit(indfield-1);
          
          bytevalue += ((*vit)<<(8-bitsalreadyfilled)) ;
          cout<< "value: "<< hex << *vit << dec <<  *vit<< endl;
          cout<< "byte: "<< hex << bytevalue << dec << bytevalue << endl;
          
          if(indfield<Nfields-1) {
            vit++;
            //Here there should be a check on the size of the current value against the left available bits.
          }
          else return 0;
        }

        //Special treatment of last field having at least some space in the byte. At this point it should always be indfield==lastfield 
        
        int lastfieldbits=Format::getFieldLastBit(indfield)-Format::getFieldLastBit(indfield-1);
        bitstoaccomodate = lastfieldbits - (8-bitsalreadyfilled);
        
        bytevalue += ((*vit) >> (lastfieldbits - (8-bitsalreadyfilled))) ; 
        cout<< "value: "<< hex << *vit << dec <<  *vit<< endl;
        cout<< "byte: "<< hex << bytevalue << dec << bytevalue << endl;
        
        *p=bytevalue;
        
        //Treatment of the case in which the last field fits too in the current byte
        if (bitstoaccomodate==0) {

          if (indfield < Nfields-1) {

            indfield++;
            vit++;

            //Here there should be a check on the size of the current value against the left available bits.
            
            bitstoaccomodate=Format::getFieldLastBit(indfield)-Format::getFieldLastBit(indfield-1);
          }
          else return 0;
        }
        p++;
      }
      else{
        cout<<"DaqData - ERROR: unexpected situation"<<endl;
      }
    } //end of cycle over bytes
  
    return 0;

  }

*/



};


#endif