SiStripDigiToRaw.cc

Go to the documentation of this file.

#include "SiStripDigiToRaw.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "DataFormats/FEDRawData/interface/FEDHeader.h"
#include "DataFormats/FEDRawData/interface/FEDTrailer.h"
#include "DataFormats/SiStripDigi/interface/SiStripDigi.h"
#include "DataFormats/SiStripDigi/interface/SiStripRawDigi.h"
#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "FWCore/Utilities/interface/CRC16.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "EventFilter/SiStripRawToDigi/interface/SiStripFEDBuffer.h"
#include <iostream>
#include <iomanip>
#include <sstream>
#include <vector>

namespace sistrip {

  // -----------------------------------------------------------------------------
  DigiToRaw::DigiToRaw( FEDReadoutMode mode, 
            bool useFedKey ) : 
    mode_(mode),
    useFedKey_(useFedKey),
    bufferGenerator_()
  {
    if ( edm::isDebugEnabled() ) {
      LogDebug("DigiToRaw")
    << "[sistrip::DigiToRaw::DigiToRaw]"
    << " Constructing object...";
    }
    bufferGenerator_.setReadoutMode(mode_);
  }

  // -----------------------------------------------------------------------------
  DigiToRaw::~DigiToRaw() {
    if ( edm::isDebugEnabled() ) {
      LogDebug("DigiToRaw")
    << "[sistrip::DigiToRaw::~DigiToRaw]"
    << " Destructing object...";
    }
  }

  // -----------------------------------------------------------------------------
  void DigiToRaw::createFedBuffers( edm::Event& event,
                    edm::ESHandle<SiStripFedCabling>& cabling,
                    edm::Handle< edm::DetSetVector<SiStripDigi> >& collection,
                    std::unique_ptr<FEDRawDataCollection>& buffers ) { 
    createFedBuffers_(event, cabling, collection, buffers, true);
  }
  
  void DigiToRaw::createFedBuffers( edm::Event& event,
                    edm::ESHandle<SiStripFedCabling>& cabling,
                    edm::Handle< edm::DetSetVector<SiStripRawDigi> >& collection,
                    std::unique_ptr<FEDRawDataCollection>& buffers ) { 
    createFedBuffers_(event, cabling, collection, buffers, false);
  }

  //with copy of headers from initial raw data collection (raw->digi->raw)
  void DigiToRaw::createFedBuffers( edm::Event& event,
                    edm::ESHandle<SiStripFedCabling>& cabling,
                    edm::Handle<FEDRawDataCollection> & rawbuffers,
                    edm::Handle< edm::DetSetVector<SiStripDigi> >& collection,
                    std::unique_ptr<FEDRawDataCollection>& buffers ) { 
    createFedBuffers_(event, cabling, rawbuffers, collection, buffers, true);
  }
  
  void DigiToRaw::createFedBuffers( edm::Event& event,
                    edm::ESHandle<SiStripFedCabling>& cabling,
                    edm::Handle<FEDRawDataCollection> & rawbuffers,
                    edm::Handle< edm::DetSetVector<SiStripRawDigi> >& collection,
                    std::unique_ptr<FEDRawDataCollection>& buffers ) { 
    createFedBuffers_(event, cabling, rawbuffers, collection, buffers, false);
  }




  template<class Digi_t>
  void DigiToRaw::createFedBuffers_( edm::Event& event,
                     edm::ESHandle<SiStripFedCabling>& cabling,
                     edm::Handle< edm::DetSetVector<Digi_t> >& collection,
                     std::unique_ptr<FEDRawDataCollection>& buffers,
                     bool zeroSuppressed) {

    edm::Handle<FEDRawDataCollection> rawbuffers;
    //CAMM initialise to some dummy empty buffers??? Or OK like this ?
    createFedBuffers_(event,cabling,rawbuffers,collection,buffers,zeroSuppressed);

  }

  template<class Digi_t>
  void DigiToRaw::createFedBuffers_( edm::Event& event,
                     edm::ESHandle<SiStripFedCabling>& cabling,
                     edm::Handle<FEDRawDataCollection> & rawbuffers,
                     edm::Handle< edm::DetSetVector<Digi_t> >& collection,
                     std::unique_ptr<FEDRawDataCollection>& buffers,
                     bool zeroSuppressed) {
    try {
      
      //set the L1ID to use in the buffers
      bufferGenerator_.setL1ID(0xFFFFFF & event.id().event());
      auto fed_ids = cabling->fedIds();

      //copy header if valid rawbuffers handle
      if (rawbuffers.isValid()){
    if ( edm::isDebugEnabled() ) {
      edm::LogWarning("DigiToRaw")
        << "[sistrip::DigiToRaw::createFedBuffers_]"
        << " Valid raw buffers, getting headers from them..."
        << " Number of feds: " << fed_ids.size() << " between "
        << *(fed_ids.begin()) << " and " << *(fed_ids.end());
    }
    
    const FEDRawDataCollection& rawDataCollection = *rawbuffers;

    for ( auto ifed = fed_ids.begin(); ifed != fed_ids.end(); ++ifed ) {
      const FEDRawData& rawfedData = rawDataCollection.FEDData(*ifed);

      if ( edm::isDebugEnabled() ) {
        edm::LogWarning("DigiToRaw")
          << "[sistrip::DigiToRaw::createFedBuffers_]"
          << "Fed " << *ifed << " : size of buffer = " << rawfedData.size();
      }
      
      //need to construct full object to copy full header
      std::unique_ptr<const sistrip::FEDBuffer> fedbuffer;
      //std::unique_ptr<const sistrip::FEDBufferBase> bufferBase;
      try {
        fedbuffer.reset(new sistrip::FEDBuffer(rawfedData.data(),rawfedData.size(),true));
        //bufferBase.reset(new sistrip::FEDBufferBase(rawfedData.data(),rawfedData.size()));
      } catch (const cms::Exception& e) {
        edm::LogWarning("DigiToRaw") << "[sistrip::DigiToRaw::createFedBuffers_]"
              << " Invalid raw data, cannot get buffer..."
              << std::endl;
      }
      
      if ( edm::isDebugEnabled() ) {
        edm::LogWarning("DigiToRaw")
          << "[sistrip::DigiToRaw::createFedBuffers_]"
          << " Original header type: " << fedbuffer->headerType();
      }

      bufferGenerator_.setHeaderType(FEDHeaderType::HEADER_TYPE_FULL_DEBUG);
      //fedbuffer->headerType());
      bufferGenerator_.daqHeader() = fedbuffer->daqHeader();
      bufferGenerator_.daqTrailer() = fedbuffer->daqTrailer();
      
      bufferGenerator_.trackerSpecialHeader() = fedbuffer->trackerSpecialHeader();
      bufferGenerator_.setReadoutMode(mode_);

      if ( edm::isDebugEnabled() ) {
        std::ostringstream debugStream;
        if(ifed==fed_ids.begin()){  bufferGenerator_.trackerSpecialHeader().print(std::cout); std::cout << std::endl;}
        bufferGenerator_.trackerSpecialHeader().print(debugStream);
        edm::LogWarning("DigiToRaw")
          << "[sistrip::DigiToRaw::createFedBuffers_]"
          << " Tracker special header apveAddress: " << static_cast<int>(bufferGenerator_.trackerSpecialHeader().apveAddress())
          << " - event type = " << bufferGenerator_.getDAQEventType()
          << " - buffer format = " << bufferGenerator_.getBufferFormat() << "\n"
          << " - SpecialHeader bufferformat " << bufferGenerator_.trackerSpecialHeader().bufferFormat()
          << " - headertype " << bufferGenerator_.trackerSpecialHeader().headerType()
          << " - readoutmode " << bufferGenerator_.trackerSpecialHeader().readoutMode()
          << " - apvaddrregister " << std::hex << static_cast<int>(bufferGenerator_.trackerSpecialHeader().apvAddressErrorRegister())
          << " - feenabledregister " << std::hex << static_cast<int>(bufferGenerator_.trackerSpecialHeader().feEnableRegister())
          << " - feoverflowregister " << std::hex << static_cast<int>(bufferGenerator_.trackerSpecialHeader().feOverflowRegister())
          << " - statusregister " << bufferGenerator_.trackerSpecialHeader().fedStatusRegister() << "\n"
          << " SpecialHeader: " << debugStream.str();
      }

      std::unique_ptr<FEDFEHeader> tempFEHeader(fedbuffer->feHeader()->clone());
      FEDFullDebugHeader* fedFeHeader = dynamic_cast<FEDFullDebugHeader*>(tempFEHeader.get());
      if ( edm::isDebugEnabled() ) {
        std::ostringstream debugStream;
        if(ifed==fed_ids.begin()){  std::cout << "FEHeader before transfer: " << std::endl;fedFeHeader->print(std::cout);std::cout  <<std::endl;}
        fedFeHeader->print(debugStream);
        edm::LogWarning("DigiToRaw")
          << "[sistrip::DigiToRaw::createFedBuffers_]"
          << " length of original feHeader: " << fedFeHeader->lengthInBytes() << "\n"
          << debugStream.str();
      }
          //status registers
          (bufferGenerator_.feHeader()).setBEStatusRegister(fedFeHeader->beStatusRegister());
          (bufferGenerator_.feHeader()).setDAQRegister2(fedFeHeader->daqRegister2());
          (bufferGenerator_.feHeader()).setDAQRegister(fedFeHeader->daqRegister());
          for(uint8_t iFE=1; iFE<6; iFE++) {
            (bufferGenerator_.feHeader()).set32BitReservedRegister(iFE,fedFeHeader->get32BitWordFrom(fedFeHeader->feWord(iFE)+10));
          }

          std::vector<bool> feEnabledVec;
      feEnabledVec.resize(FEUNITS_PER_FED,true);
      for (uint8_t iFE = 0; iFE < FEUNITS_PER_FED; iFE++) {
            feEnabledVec[iFE]=fedbuffer->trackerSpecialHeader().feEnabled(iFE);  
            (bufferGenerator_.feHeader()).setFEUnitMajorityAddress(iFE,fedFeHeader->feUnitMajorityAddress(iFE));
        for (uint8_t iFEUnitChannel = 0; iFEUnitChannel < FEDCH_PER_FEUNIT; iFEUnitChannel++) {
          (bufferGenerator_.feHeader()).setChannelStatus(iFE,iFEUnitChannel,fedFeHeader->getChannelStatus(iFE,iFEUnitChannel));
        }//loop on channels
      }//loop on fe units
          bufferGenerator_.setFEUnitEnables(feEnabledVec);

      if ( edm::isDebugEnabled() ) {
        std::ostringstream debugStream;
        if(ifed==fed_ids.begin()){  std::cout << "\nFEHeader after transfer: " << std::endl;bufferGenerator_.feHeader().print(std::cout); std::cout << std::endl;}
        bufferGenerator_.feHeader().print(debugStream);
        edm::LogWarning("DigiToRaw")
          << "[sistrip::DigiToRaw::createFedBuffers_]"
          << " length of feHeader: " << bufferGenerator_.feHeader().lengthInBytes() << "\n"
          << debugStream.str();
      }
          auto conns = cabling->fedConnections(*ifed);
          
          //for special mode premix raw, data is zero-suppressed but not converted to 8 bit
          //zeroSuppressed here means converted to 8 bit...
          if (mode_ == READOUT_MODE_PREMIX_RAW) zeroSuppressed=false;
          FEDStripData fedData(zeroSuppressed);
          
          
          for (auto iconn = conns.begin() ; iconn != conns.end(); iconn++ ) {
            
            // Determine FED key from cabling
            uint32_t fed_key = ( ( iconn->fedId() & sistrip::invalid_ ) << 16 ) | ( iconn->fedCh() & sistrip::invalid_ );
            
            // Determine whether DetId or FED key should be used to index digi containers
            uint32_t key = ( useFedKey_ || mode_ == READOUT_MODE_SCOPE ) ? fed_key : iconn->detId();
            
            // Check key is non-zero and valid
            if ( !key || ( key == sistrip::invalid32_ ) ) { continue; }
            
            // Determine APV pair number (needed only when using DetId)
            uint16_t ipair = ( useFedKey_ || mode_ == READOUT_MODE_SCOPE ) ? 0 : iconn->apvPairNumber();
            
            FEDStripData::ChannelData& chanData = fedData[iconn->fedCh()];

            // Find digis for DetID in collection
            if (!collection.isValid()){
              if ( edm::isDebugEnabled() ) {
                edm::LogWarning("DigiToRaw") 
            << "[DigiToRaw::createFedBuffers] " 
            << "digis collection is not valid...";
              }
              break;
            }
            typename std::vector< edm::DetSet<Digi_t> >::const_iterator digis = collection->find( key );
            if (digis == collection->end()) { continue; } 

            typename edm::DetSet<Digi_t>::const_iterator idigi, digis_begin(digis->data.begin());
            for ( idigi = digis_begin; idigi != digis->data.end(); idigi++ ) {
              
              if ( STRIP(idigi, digis_begin) < ipair*256 ||
             STRIP(idigi, digis_begin) > ipair*256+255 ) { continue; }
              const unsigned short strip = STRIP(idigi, digis_begin) % 256;
              
              if ( strip >= STRIPS_PER_FEDCH ) {
                if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "[sistrip::DigiToRaw::createFedBuffers]"
               << " strip >= strips_per_fedCh";
            edm::LogWarning("DigiToRaw") << ss.str();
                }
                continue;
              }
              
              // check if value already exists
              if ( edm::isDebugEnabled() ) {
                const uint16_t value = 0;//chanData[strip];
                if ( value && value != (*idigi).adc() ) {
            std::stringstream ss; 
            ss << "[sistrip::DigiToRaw::createFedBuffers]" 
               << " Incompatible ADC values in buffer!"
               << "  FedId/FedCh: " << *ifed << "/" << iconn->fedCh()
               << "  DetStrip: " << STRIP(idigi, digis_begin)
               << "  FedChStrip: " << strip
               << "  AdcValue: " << (*idigi).adc()
               << "  RawData[" << strip << "]: " << value;
            edm::LogWarning("DigiToRaw") << ss.str();
                }
              }
              
              // Add digi to buffer
              chanData[strip] = (*idigi).adc();
            }
          }
          // if ((*idigi).strip() >= (ipair+1)*256) break;
          
          if ( edm::isDebugEnabled() ) {
            edm::LogWarning("DigiToRaw") 
              << "DigiToRaw::createFedBuffers] " 
              << "Almost at the end...";
          }
          //create the buffer
          FEDRawData& fedrawdata = buffers->FEDData( *ifed );
          bufferGenerator_.generateBuffer(&fedrawdata,fedData,*ifed);

          if ( edm::isDebugEnabled() ) {
            std::ostringstream debugStream;
            bufferGenerator_.feHeader().print(debugStream);
            edm::LogWarning("DigiToRaw")
              << "[sistrip::DigiToRaw::createFedBuffers_]"
              << " length of final feHeader: " << bufferGenerator_.feHeader().lengthInBytes() << "\n"
              << debugStream.str();
          }
    }//loop on fedids
    if ( edm::isDebugEnabled() ) {
      edm::LogWarning("DigiToRaw")
        << "[sistrip::DigiToRaw::createFedBuffers_]"
        << "end of first loop on feds";
    }

      }//end of workflow for copying header, below is workflow without copying header
      else{     
        if ( edm::isDebugEnabled() ) {
          edm::LogWarning("DigiToRaw")
            << "[sistrip::DigiToRaw::createFedBuffers_]"
            << "Now getting the digis..."
            << " Number of feds: " << fed_ids.size() << " between "
            << *(fed_ids.begin()) << " and " << *(fed_ids.end());
        }

        for ( auto ifed = fed_ids.begin(); ifed != fed_ids.end(); ++ifed ) {
          
          auto conns = cabling->fedConnections(*ifed);
          
          //for special mode premix raw, data is zero-suppressed but not converted to 8 bit
          //zeroSuppressed here means converted to 8 bit...
          if (mode_ == READOUT_MODE_PREMIX_RAW) zeroSuppressed=false;
          FEDStripData fedData(zeroSuppressed);
          
          
          for (auto iconn = conns.begin() ; iconn != conns.end(); iconn++ ) {
            
            // Determine FED key from cabling
            uint32_t fed_key = ( ( iconn->fedId() & sistrip::invalid_ ) << 16 ) | ( iconn->fedCh() & sistrip::invalid_ );
            
            // Determine whether DetId or FED key should be used to index digi containers
            uint32_t key = ( useFedKey_ || mode_ == READOUT_MODE_SCOPE ) ? fed_key : iconn->detId();
            
            // Check key is non-zero and valid
            if ( !key || ( key == sistrip::invalid32_ ) ) { continue; }
            
            // Determine APV pair number (needed only when using DetId)
            uint16_t ipair = ( useFedKey_ || mode_ == READOUT_MODE_SCOPE ) ? 0 : iconn->apvPairNumber();
            
            FEDStripData::ChannelData& chanData = fedData[iconn->fedCh()];

            // Find digis for DetID in collection
            if (!collection.isValid()){
              if ( edm::isDebugEnabled() ) {
                edm::LogWarning("DigiToRaw") 
            << "[DigiToRaw::createFedBuffers] " 
            << "digis collection is not valid...";
              }
              break;
            }
            typename std::vector< edm::DetSet<Digi_t> >::const_iterator digis = collection->find( key );
            if (digis == collection->end()) { continue; } 

            typename edm::DetSet<Digi_t>::const_iterator idigi, digis_begin(digis->data.begin());
            for ( idigi = digis_begin; idigi != digis->data.end(); idigi++ ) {
              
              if ( STRIP(idigi, digis_begin) < ipair*256 ||
             STRIP(idigi, digis_begin) > ipair*256+255 ) { continue; }
              const unsigned short strip = STRIP(idigi, digis_begin) % 256;
              
              if ( strip >= STRIPS_PER_FEDCH ) {
                if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "[sistrip::DigiToRaw::createFedBuffers]"
               << " strip >= strips_per_fedCh";
            edm::LogWarning("DigiToRaw") << ss.str();
                }
                continue;
              }
              
              // check if value already exists
              if ( edm::isDebugEnabled() ) {
                const uint16_t value = 0;//chanData[strip];
                if ( value && value != (*idigi).adc() ) {
            std::stringstream ss; 
            ss << "[sistrip::DigiToRaw::createFedBuffers]" 
               << " Incompatible ADC values in buffer!"
               << "  FedId/FedCh: " << *ifed << "/" << iconn->fedCh()
               << "  DetStrip: " << STRIP(idigi, digis_begin)
               << "  FedChStrip: " << strip
               << "  AdcValue: " << (*idigi).adc()
               << "  RawData[" << strip << "]: " << value;
            edm::LogWarning("DigiToRaw") << ss.str();
                }
              }
              
              // Add digi to buffer
              chanData[strip] = (*idigi).adc();
            }
          }
          // if ((*idigi).strip() >= (ipair+1)*256) break;
          
          if ( edm::isDebugEnabled() ) {
            edm::LogWarning("DigiToRaw") 
              << "DigiToRaw::createFedBuffers] " 
              << "Almost at the end...";
          }
          //create the buffer
          FEDRawData& fedrawdata = buffers->FEDData( *ifed );
          bufferGenerator_.generateBuffer(&fedrawdata,fedData,*ifed);

          if ( edm::isDebugEnabled() ) {
            std::ostringstream debugStream;
            bufferGenerator_.feHeader().print(debugStream);
            edm::LogWarning("DigiToRaw")
              << "[sistrip::DigiToRaw::createFedBuffers_]"
              << " length of final feHeader: " << bufferGenerator_.feHeader().lengthInBytes() << "\n"
              << debugStream.str();
          }
        }//loop on feds
      }//end if-else for copying header
    }//try
    catch (const std::exception& e) {
      if ( edm::isDebugEnabled() ) {
    edm::LogWarning("DigiToRaw") 
      << "DigiToRaw::createFedBuffers] " 
      << "Exception caught : " << e.what();
      }
    }
  
  }

  inline uint16_t DigiToRaw::STRIP(const edm::DetSet<SiStripDigi>::const_iterator& it, const edm::DetSet<SiStripDigi>::const_iterator& begin) const {return it->strip();}
  inline uint16_t DigiToRaw::STRIP(const edm::DetSet<SiStripRawDigi>::const_iterator& it, const edm::DetSet<SiStripRawDigi>::const_iterator& begin) const {return it-begin;}

}