---

SiStripRawToDigiUnpacker Class Reference

Takes collection of FEDRawData as input and creates digis. More...

#include <EventFilter/SiStripRawToDigi/interface/SiStripRawToDigiUnpacker.h>

List of all members.

Public Types
typedef edm::DetSetVector < SiStripDigi >	Digis
typedef edm::DetSetVector < SiStripRawDigi >	RawDigis
Public Member Functions
void	createDigis (const SiStripFedCabling &, const FEDRawDataCollection &, SiStripEventSummary &, RawDigis &scope_mode, RawDigis &virgin_raw, RawDigis &proc_raw, Digis &zero_suppr)
	Creates digis.
void	locateStartOfFedBuffer (const uint16_t &fed_id, const FEDRawData &input, FEDRawData &output)
	Removes any data appended prior to FED buffer and reorders 32-bit words if swapped.
void	quiet (bool)
	SiStripRawToDigiUnpacker (int16_t appended_bytes, int16_t fed_buffer_dump_freq, int16_t fed_event_dump_freq, int16_t trigger_fed_id, bool using_fed_key)
void	triggerFed (const FEDRawDataCollection &, SiStripEventSummary &, const uint32_t &event)
	~SiStripRawToDigiUnpacker ()
Private Member Functions
void	cleanupWorkVectors ()
void	dumpRawData (uint16_t fed_id, const FEDRawData &, std::stringstream &)
	Dumps raw data to stdout (NB: payload is byte-swapped, headers/trailer are not).
sistrip::FedBufferFormat	fedBufferFormat (const uint16_t &register_value)
sistrip::FedReadoutMode	fedReadoutMode (const uint16_t &register_value)
void	handleException (std::string method_name, std::string extra_info="")
	Catches all possible exceptions and rethrows them as cms::Exception's that are caught by the framework.
void	physicalOrder (uint16_t &readout_order, uint16_t &physical_order)
void	readoutOrder (uint16_t &physical_order, uint16_t &readout_order)
	SiStripRawToDigiUnpacker ()
	Private default constructor.
void	updateEventSummary (const Fed9U::Fed9UEvent *const, SiStripEventSummary &)
Private Attributes
uint32_t	event_
int16_t	fedBufferDumpFreq_
Fed9U::Fed9UEvent *	fedEvent_
int16_t	fedEventDumpFreq_
bool	first_
int16_t	headerBytes_
bool	once_
std::vector< SiStripRawDigi >	proc_work_digis_
std::vector < DetSet_SiStripDig_registry >	proc_work_registry_
bool	quiet_
std::vector< SiStripRawDigi >	scope_work_digis_
std::vector < DetSet_SiStripDig_registry >	scope_work_registry_
int16_t	triggerFedId_
bool	useFedKey_
std::vector< SiStripRawDigi >	virgin_work_digis_
std::vector < DetSet_SiStripDig_registry >	virgin_work_registry_
std::vector< SiStripDigi >	zs_work_digis_
std::vector < DetSet_SiStripDig_registry >	zs_work_registry_
Friends
class	SiStripRawToClustersLazyUnpacker
class	SiStripRawToClustersModule
Classes
struct	DetSet_SiStripDig_registry

---

Detailed Description

Takes collection of FEDRawData as input and creates digis.

Definition at line 29 of file SiStripRawToDigiUnpacker.h.

---

Member Typedef Documentation

typedef edm::DetSetVector<SiStripDigi> SiStripRawToDigiUnpacker::Digis

Definition at line 45 of file SiStripRawToDigiUnpacker.h.

typedef edm::DetSetVector<SiStripRawDigi> SiStripRawToDigiUnpacker::RawDigis

Definition at line 46 of file SiStripRawToDigiUnpacker.h.

---

Constructor & Destructor Documentation

SiStripRawToDigiUnpacker::SiStripRawToDigiUnpacker	(	int16_t	appended_bytes,
		int16_t	fed_buffer_dump_freq,
		int16_t	fed_event_dump_freq,
		int16_t	trigger_fed_id,
		bool	using_fed_key
	)

Definition at line 28 of file SiStripRawToDigiUnpacker.cc.

References fedEvent_, edm::isDebugEnabled(), LogTrace, and sistrip::mlRawToDigi_.

                                                                          :
  headerBytes_( appended_bytes ),
  fedBufferDumpFreq_( fed_buffer_dump_freq ),
  fedEventDumpFreq_( fed_event_dump_freq ),
  triggerFedId_( trigger_fed_id ),
  useFedKey_( using_fed_key ),
  fedEvent_(0),
  event_(0),
  once_(true),
  first_(true),
  quiet_(true)
{
  if ( edm::isDebugEnabled() ) {
    LogTrace(mlRawToDigi_)
      << "[SiStripRawToDigiUnpacker::"<<__func__<<"]"
      <<" Constructing object...";
  }
  fedEvent_ = new Fed9U::Fed9UEvent();
}

SiStripRawToDigiUnpacker::~SiStripRawToDigiUnpacker

(

)

Definition at line 54 of file SiStripRawToDigiUnpacker.cc.

References fedEvent_, edm::isDebugEnabled(), LogTrace, and sistrip::mlRawToDigi_.

                                                    {
  if ( edm::isDebugEnabled() ) {
    LogTrace(mlRawToDigi_)
      << "[SiStripRawToDigiUnpacker::"<<__func__<<"]"
      << " Destructing object...";
  }
  if ( fedEvent_ ) { delete fedEvent_; }
}

SiStripRawToDigiUnpacker::SiStripRawToDigiUnpacker

(

)

[private]

Private default constructor.

---

Member Function Documentation

void SiStripRawToDigiUnpacker::cleanupWorkVectors

(

)

[private]

Definition at line 595 of file SiStripRawToDigiUnpacker.cc.

References proc_work_digis_, proc_work_registry_, scope_work_digis_, scope_work_registry_, virgin_work_digis_, virgin_work_registry_, zs_work_digis_, and zs_work_registry_.

Referenced by createDigis().

                                                  {
  // Clear working areas and registries
  zs_work_registry_.clear();      zs_work_digis_.clear();
  virgin_work_registry_.clear();  virgin_work_digis_.clear();
  proc_work_registry_.clear();    proc_work_digis_.clear();
  scope_work_registry_.clear();   scope_work_digis_.clear();
}

void SiStripRawToDigiUnpacker::createDigis	(	const SiStripFedCabling &	cabling,
		const FEDRawDataCollection &	buffers,
		SiStripEventSummary &	summary,
		RawDigis &	scope_mode,
		RawDigis &	virgin_raw,
		RawDigis &	proc_raw,
		Digis &	zero_suppr
	)

Creates digis.

Definition at line 65 of file SiStripRawToDigiUnpacker.cc.

References addr, sistrip::APV_LATENCY, cleanupWorkVectors(), SiStripFedCabling::connections(), edmNew::copy(), FEDRawData::data(), dumpRawData(), end, event_, Exception, sistrip::FED_CABLING, sistrip::FED_PROC_RAW, sistrip::FED_SCOPE_MODE, sistrip::FED_VIRGIN_RAW, sistrip::FED_ZERO_SUPPR, sistrip::FED_ZERO_SUPPR_LITE, fedBufferDumpFreq_, FEDRawDataCollection::FEDData(), fedEvent_, fedEventDumpFreq_, fedReadoutMode(), SiStripFedCabling::feds(), sistrip::FINE_DELAY, first_, FEDNumbering::getSiStripFEDIds(), handleException(), i, iggi_31X_cfg::input, sistrip::invalid32_, sistrip::invalid_, edm::isDebugEnabled(), SiStripEventSummary::isSet(), it, getDQMSummary::key, len, locateStartOfFedBuffer(), LogTrace, min, sistrip::mlRawToDigi_, mode, n, output(), proc_work_digis_, proc_work_registry_, quiet_, readoutOrder(), SiStripEventSummary::runType(), scope_work_digis_, scope_work_registry_, FEDRawData::size(), python::multivaluedict::sort(), ss, strip(), edm::DetSetVector< T >::swap(), triggerFedId_, sistrip::UNDEFINED_FED_READOUT_MODE, useFedKey_, SiStripEventSummary::valid(), virgin_work_digis_, virgin_work_registry_, width, zs_work_digis_, and zs_work_registry_.

Referenced by SiStripRawToDigiModule::produce().

                                                                {
  // Clear working areas and registries
  cleanupWorkVectors();
  
  // Check if FEDs found in cabling map and event data
  if ( edm::isDebugEnabled() ) {
    if ( cabling.feds().empty() ) {
      edm::LogWarning(mlRawToDigi_)
        << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
        << " No FEDs found in cabling map!";
      // Check which FED ids have non-zero size buffers
      std::pair<int,int> fed_range = FEDNumbering::getSiStripFEDIds();
      std::vector<uint16_t> feds;
      for ( uint16_t ifed = static_cast<uint16_t>(fed_range.first);
            ifed < static_cast<uint16_t>(fed_range.second); ifed++ ) {
        if ( ifed != triggerFedId_ && 
             buffers.FEDData( static_cast<int>(ifed) ).size() ) {
          feds.push_back(ifed);
        }
      }
      LogTrace(mlRawToDigi_)
        << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
        << " Found " << feds.size() << " FED buffers with non-zero size!";
    }
  }

  // Flag for EventSummary update using DAQ register  
  bool first_fed = true;
  
  // Retrieve FED ids from cabling map and iterate through 
  std::vector<uint16_t>::const_iterator ifed = cabling.feds().begin();
  for ( ; ifed != cabling.feds().end(); ifed++ ) {

    //if ( *ifed == triggerFedId_ ) { continue; }
    
    // Retrieve FED raw data for given FED 
    const FEDRawData& input = buffers.FEDData( static_cast<int>(*ifed) );
    
    // Some debug on FED buffer size
    if ( edm::isDebugEnabled() ) {
      if ( first_ && input.data() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " Found FED id " 
           << std::setw(4) << std::setfill(' ') << *ifed 
           << " in FEDRawDataCollection"
           << " with non-zero pointer 0x" 
           << std::hex
           << std::setw(8) << std::setfill('0') 
           << reinterpret_cast<uint32_t*>( const_cast<uint8_t*>(input.data()))
           << std::dec
           << " and size " 
           << std::setw(5) << std::setfill(' ') << input.size()
           << " chars";
        LogTrace(mlRawToDigi_) << ss.str();
      } 
    }
    
    // Dump of FEDRawData to stdout
    if ( edm::isDebugEnabled() ) {
      if ( fedBufferDumpFreq_ && !(event_%fedBufferDumpFreq_) ) {
        std::stringstream ss;
        dumpRawData( *ifed, input, ss );
        edm::LogVerbatim(mlRawToDigi_) << ss.str();
      }
    }
    
    // Handle 32-bit swapped data (and locate start of FED buffer within raw data)
    FEDRawData output; 
    locateStartOfFedBuffer( *ifed, input, output );
    
    // Recast data to suit Fed9UEvent
    Fed9U::u32* data_u32 = reinterpret_cast<Fed9U::u32*>( const_cast<unsigned char*>( output.data() ) );
    Fed9U::u32  size_u32 = static_cast<Fed9U::u32>( output.size() / 4 ); 

    // Check on FEDRawData pointer
    if ( !data_u32 ) {
      if ( edm::isDebugEnabled() ) {
        edm::LogWarning(mlRawToDigi_)
          << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
          << " NULL pointer to FEDRawData for FED id " << *ifed;
      }
      continue;
    }   
    
    // Check on FEDRawData size
    if ( !size_u32 ) {
      if ( edm::isDebugEnabled() ) {
        edm::LogWarning(mlRawToDigi_)
          << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
          << " FEDRawData has zero size for FED id " << *ifed;
      }
      continue;
    }
    
    // Initialise Fed9UEvent using present FED buffer
    try {
      fedEvent_->Init( data_u32, 0, size_u32 ); 
      //fedEvent_->checkEvent();
    } catch(...) { 
      handleException( __func__, "Problem when creating Fed9UEvent" ); 
      continue;
    } 
   
    // Check if EventSummary ("trigger FED info") needs updating
    if ( first_fed ) {
      //updateEventSummary( fedEvent_, summary ); //@@ temporarily suppress statements from SiStripEventSummary!
      first_fed = false;
    }
    
    // Check to see if EventSummary info is set
    if ( edm::isDebugEnabled() ) {
      if ( !quiet_ && !summary.isSet() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " EventSummary is not set correctly!"
           << " Missing information from both \"trigger FED\" and \"DAQ registers\"!";
        edm::LogWarning(mlRawToDigi_) << ss.str();
      }
    }
    
    // Check to see if event is to be analyzed according to EventSummary
    if ( !summary.valid() ) { 
      if ( edm::isDebugEnabled() ) {
        LogTrace(mlRawToDigi_)
          << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
          << " EventSummary is not valid: skipping...";
      }
      continue; 
    }
    
    // Retrive readout mode
    sistrip::FedReadoutMode mode = sistrip::UNDEFINED_FED_READOUT_MODE;
    try {
      mode = fedReadoutMode( static_cast<unsigned int>( fedEvent_->getSpecialTrackerEventType() ) );
    } catch(...) { handleException( __func__, "Problem extracting readout mode from Fed9UEvent" ); } 
    
    // Retrive run type
    sistrip::RunType runType_ = summary.runType();
    if( runType_ == sistrip::APV_LATENCY || runType_ == sistrip::FINE_DELAY ) { useFedKey_ = false; } //@@ force!
     
    // Dump of FED buffer
    if ( edm::isDebugEnabled() ) {
      if ( fedEventDumpFreq_ && !(event_%fedEventDumpFreq_) ) {
        std::stringstream ss;
        fedEvent_->dump( ss );
        edm::LogVerbatim(mlRawToDigi_) << ss.str();
      }
    }
    
    // Iterate through FED channels, extract payload and create Digis
    const std::vector<FedChannelConnection>& conns = cabling.connections(*ifed);
    std::vector<FedChannelConnection>::const_iterator iconn = conns.begin();
    for ( ; iconn != conns.end(); iconn++ ) {

      // Check if FedId is valid
      if ( !iconn->isConnected() ) { continue; }
      
      // Check DetId is valid (if to be used as key)
      if ( !useFedKey_ && ( !iconn->detId() || iconn->detId() == sistrip::invalid32_ ) ) { continue; }

      // Retrieve channel using Fed9UAddress 
      uint16_t channel = iconn->fedCh();
      uint16_t iunit = channel / 12;
      uint16_t ichan = channel % 12;
      uint16_t chan  = 12 * iunit + ichan;
      try {
        Fed9U::Fed9UAddress addr;
        addr.setFedChannel( static_cast<unsigned char>( channel ) );
        iunit = addr.getFedFeUnit();
        ichan = addr.getFeUnitChannel();
        chan  = 12*( addr.getFedFeUnit() ) + addr.getFeUnitChannel();
      } catch(...) { 
        handleException( __func__, "Problem using Fed9UAddress" ); 
      } 
      
      // Determine whether FED key is inferred from cabling or channel loop
      uint32_t fed_key = 0;
      if ( summary.runType() == sistrip::FED_CABLING ) {
        fed_key = ( ( *ifed & sistrip::invalid_ ) << 16 ) | ( chan & sistrip::invalid_ );
      } else { 
        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 == sistrip::FED_SCOPE_MODE ) ? fed_key : iconn->detId();
      
      // Determine APV std::pair number (needed only when using DetId)
      uint16_t ipair = ( useFedKey_ || mode == sistrip::FED_SCOPE_MODE ) ? 0 : iconn->apvPairNumber();

      if ( mode == sistrip::FED_SCOPE_MODE ) {
        
        std::vector<uint16_t> samples; 
        try { 
          samples = fedEvent_->feUnit( iunit ).channel( ichan ).getSamples();
        } catch(...) { 
          std::stringstream sss;
          sss << "Problem accessing SCOPE_MODE data for FedId/FeUnit/FeChan: " 
              << *ifed << "/" << iunit << "/" << ichan;
          handleException( __func__, sss.str() ); 
        } 
        
        if ( !samples.empty() ) { 
          DetSet_SiStripDig_registry regItem(key, 0, scope_work_digis_.size(), samples.size());
          for ( uint16_t i = 0, n = samples.size(); i < n; i++ ) {
            scope_work_digis_.push_back(  SiStripRawDigi( samples[i] ) );
          }
          scope_work_registry_.push_back( regItem );
        }
        
      } else if ( mode == sistrip::FED_VIRGIN_RAW ) {

        std::vector<uint16_t> samples; 
        try {
          samples = fedEvent_->channel( iunit, ichan ).getSamples();
        } catch(...) { 
          std::stringstream sss;
          sss << "Problem accessing VIRGIN_RAW data for FED id/ch: " 
              << *ifed << "/" << ichan;
          handleException( __func__, sss.str() ); 
        } 
        
        if ( !samples.empty() ) { 
          DetSet_SiStripDig_registry regItem(key, 256*ipair, virgin_work_digis_.size(), samples.size());
          uint16_t physical;
          uint16_t readout; 
          for ( uint16_t i = 0, n = samples.size(); i < n; i++ ) {
            physical = i%128;
            readoutOrder( physical, readout );                 // convert index from physical to readout order
            (i/128) ? readout=readout*2+1 : readout=readout*2; // un-multiplex data
            virgin_work_digis_.push_back(  SiStripRawDigi( samples[readout] ) );
          }
          virgin_work_registry_.push_back( regItem );
        }

      } else if ( mode == sistrip::FED_PROC_RAW ) {

        std::vector<uint16_t> samples; 
        try {
          samples = fedEvent_->channel( iunit, ichan ).getSamples();
        } catch(...) { 
          std::stringstream sss;
          sss << "Problem accessing PROC_RAW data for FED id/ch: " 
              << *ifed << "/" << ichan;
          handleException( __func__, sss.str() ); 
        } 

        if ( !samples.empty() ) { 
          DetSet_SiStripDig_registry regItem(key, 256*ipair, proc_work_digis_.size(), samples.size());
          for ( uint16_t i = 0, n = samples.size(); i < n; i++ ) {
            proc_work_digis_.push_back(  SiStripRawDigi( samples[i] ) );
          }
          proc_work_registry_.push_back( regItem );
        }

      } else if ( ( mode == sistrip::FED_ZERO_SUPPR ) || 
                  ( mode == sistrip::FED_ZERO_SUPPR_LITE ) ) { 

        DetSet_SiStripDig_registry regItem(key, 0, zs_work_digis_.size(), 0);

        int fed9uIterOffset = (mode == sistrip::FED_ZERO_SUPPR ? 7 : 2); // offset to start decoding from
        try{ 
          bool corrupt = false;
#ifdef USE_PATCH_TO_CATCH_CORRUPT_FED_DATA
          int16_t last_strip = -1;
          uint16_t strips = useFedKey_ ? 256 : 256 * iconn->nApvPairs();
#endif
          Fed9U::Fed9UEventIterator fed_iter = const_cast<Fed9U::Fed9UEventChannel&>(fedEvent_->channel( iunit, ichan )).getIterator();
          Fed9U::Fed9UEventIterator i = fed_iter + fed9uIterOffset; 
          while ( i.size() > 0 && !corrupt ) {
            unsigned char first_strip = *i++; // first strip of cluster
            unsigned char width = *i++;       // cluster width in strips 
            uint16_t istr = 0; 
            while ( istr < width && !corrupt ) {
              uint16_t strip = ipair*256 + first_strip + istr;
#ifdef USE_PATCH_TO_CATCH_CORRUPT_FED_DATA
              if ( !( strip < strips && strip > last_strip ) ) { // check for corrupt FED data
                //              if ( edm::isDebugEnabled() ) {
                //                std::stringstream ss;
                //                ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
                //                   << " Corrupt FED data found for FED id " << *ifed
                //                   << " and channel " << iconn->fedCh()
                //                   << "!  present strip: " << strip
                //                   << "  last strip: " << last_strip
                //                   << "  detector strips: " << strips;
                //                edm::LogWarning(mlRawToDigi_) << ss.str();
                //              }
                corrupt = true; 
                break;
              } 
              last_strip = strip;
#endif
              zs_work_digis_.push_back( SiStripDigi( strip, static_cast<uint16_t>(*i) ) );
              *i++; // Iterate to next sample
              istr++;
            }
          }
        } catch(...) { 
          std::stringstream sss;
          sss << "Problem accessing ZERO_SUPPR data for FED id/ch: " 
              << *ifed << "/" << ichan;
          handleException( __func__, sss.str() ); 
        } 

        regItem.length = zs_work_digis_.size() - regItem.index;
        if (regItem.length > 0) {
            regItem.first = zs_work_digis_[regItem.index].strip();
            zs_work_registry_.push_back(regItem);
        }
      } else { // Unknown readout mode! => assume scope mode
        
        if ( edm::isDebugEnabled() ) {
          std::stringstream ss;
          ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
             << " Unknown FED readout mode (" << mode
             << ")! Assuming SCOPE MODE..."; 
          edm::LogWarning(mlRawToDigi_) << ss.str();
        }
        
        std::vector<uint16_t> samples; 
        try {
          samples = fedEvent_->feUnit( iunit ).channel( ichan ).getSamples();
        } catch(...) { 
          std::stringstream sss;
          sss << "Problem accessing data (UNKNOWN FED READOUT MODE) for FED id/ch: " 
              << *ifed << "/" << ichan;
          handleException( __func__, sss.str() ); 
        } 

        if ( !samples.empty() ) { 
          DetSet_SiStripDig_registry regItem(key, 0, scope_work_digis_.size(), samples.size());
          for ( uint16_t i = 0, n= samples.size(); i < n; i++ ) {
            scope_work_digis_.push_back(  SiStripRawDigi( samples[i] ) );
          }
          scope_work_registry_.push_back( regItem );

          if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "Extracted " << samples.size() 
               << " SCOPE MODE digis (samples[0] = " << samples[0] 
               << ") from FED id/ch " 
               << iconn->fedId() << "/" << iconn->fedCh();
            //LogTrace(mlRawToDigi_) << ss.str();
          }
        } else {
          if ( edm::isDebugEnabled() ) {
            edm::LogWarning(mlRawToDigi_)
              << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
              << " No SM digis found!"; 
          }
        }

      }

    } // channel loop
  } // fed loop

  if ( ! zs_work_registry_.empty() ) {
        std::sort( zs_work_registry_.begin(), zs_work_registry_.end() );
        std::vector< edm::DetSet<SiStripDigi> > sorted_and_merged;
        sorted_and_merged.reserve(  std::min(zs_work_registry_.size(), size_t(17000)) );

        bool errorInData = false;
        std::vector<DetSet_SiStripDig_registry>::iterator it = zs_work_registry_.begin(), it2 = it+1, end = zs_work_registry_.end();
        while (it < end) {
            sorted_and_merged.push_back( edm::DetSet<SiStripDigi>(it->detid) );
            std::vector<SiStripDigi> & digis = sorted_and_merged.back().data;
            // first count how many digis we have
            size_t len = it->length;
            for (it2 = it+1; (it2 != end) && (it2->detid == it->detid); ++it2) { len += it2->length; }
            // reserve memory 
            digis.reserve(len);
            // push them in
            for (it2 = it+0; (it2 != end) && (it2->detid == it->detid); ++it2) {
                digis.insert( digis.end(), & zs_work_digis_[it2->index], & zs_work_digis_[it2->index + it2->length] );
            }
            it = it2;
        }
        // check sorting
        if (!__gnu_cxx::is_sorted( sorted_and_merged.begin(), sorted_and_merged.end() )) {
            // this is an error in the code: i DID sort it already!
            throw cms::Exception("Bug Found") << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ <<"\n";
        }
        std::vector< edm::DetSet<SiStripDigi> >::iterator iii = sorted_and_merged.begin();
        std::vector< edm::DetSet<SiStripDigi> >::iterator jjj = sorted_and_merged.end(); 
        for ( ; iii != jjj; ++iii ) { 
            if ( ! __gnu_cxx::is_sorted( iii->begin(), iii->end() ) ) {
                // this might be an error in the data, if the raws from one FED are not sorted
                iii->clear(); errorInData = true;
            }
        }
        if (errorInData) { edm::LogWarning("CorruptData") << "Some modules contained corrupted ZS raw data, and have been skipped in unpacking\n"; }
        // make output DetSetVector
        edm::DetSetVector<SiStripDigi> zero_suppr_dsv( sorted_and_merged, true ); 
        zero_suppr.swap( zero_suppr_dsv );
  } 

  // Populate final DetSetVector container with VR data 
  if ( !virgin_work_registry_.empty() ) {
      std::sort( virgin_work_registry_.begin(), virgin_work_registry_.end() );

      std::vector< edm::DetSet<SiStripRawDigi> > sorted_and_merged;
      sorted_and_merged.reserve( std::min(virgin_work_registry_.size(), size_t(17000)) );

      bool errorInData = false;
      std::vector<DetSet_SiStripDig_registry>::iterator it = virgin_work_registry_.begin(), it2, end = virgin_work_registry_.end();
      while (it < end) {
          sorted_and_merged.push_back( edm::DetSet<SiStripRawDigi>(it->detid) );
          std::vector<SiStripRawDigi> & digis = sorted_and_merged.back().data;

          bool isDetOk = true; 
          // first count how many digis we have
          int maxFirstStrip = it->first;
          for (it2 = it+1; (it2 != end) && (it2->detid == it->detid); ++it2) { 
              if (it2->first <= maxFirstStrip) { isDetOk = false; continue; } // duplicated APV or data corruption. DO NOT 'break' here!
              maxFirstStrip = it2->first;                           
          }
          if (!isDetOk) { errorInData = true; it = it2; continue; } // skip whole det
          // make room for 256 * (max_apv_pair + 1) Raw Digis
          digis.resize(maxFirstStrip + 256);
          // push them in
          for (it2 = it+0; (it2 != end) && (it2->detid == it->detid); ++it2) {
              if (it->length != 256)  { isDetOk = false; continue; } // data corruption. DO NOT 'break' here
              std::copy( & virgin_work_digis_[it2->index], & virgin_work_digis_[it2->index + it2->length], & digis[it2->first] );
          }
          if (!isDetOk) { errorInData = true; digis.clear(); it = it2; continue; } // skip whole det
          it = it2;
      }
      if (errorInData) { edm::LogWarning("CorruptData") << "Some modules contained corrupted virgin raw data, and have been skipped in unpacking\n"; }
      // check sorting
      if ( !__gnu_cxx::is_sorted( sorted_and_merged.begin(), sorted_and_merged.end()  ) ) {
          // this is an error in the code: i DID sort it already!
          throw cms::Exception("Bug Found") << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ <<"\n";
      }
      // make output DetSetVector
      edm::DetSetVector<SiStripRawDigi> virgin_raw_dsv( sorted_and_merged, true ); 
      virgin_raw.swap( virgin_raw_dsv );
  } 
  
  // Populate final DetSetVector container with PR data 
  if ( !proc_work_registry_.empty() ) {
      std::sort( proc_work_registry_.begin(), proc_work_registry_.end() );

      std::vector< edm::DetSet<SiStripRawDigi> > sorted_and_merged;
      sorted_and_merged.reserve( std::min(proc_work_registry_.size(), size_t(17000)) );

      bool errorInData = false;
      std::vector<DetSet_SiStripDig_registry>::iterator it = proc_work_registry_.begin(), it2 = it+1, end = proc_work_registry_.end();
      while (it < end) {
          sorted_and_merged.push_back( edm::DetSet<SiStripRawDigi>(it->detid) );
          std::vector<SiStripRawDigi> & digis = sorted_and_merged.back().data;
          bool isDetOk = true; 
          // first count how many digis we have
          int maxFirstStrip = it->first;
          for (it2 = it+1; (it2 != end) && (it2->detid == it->detid); ++it2) { 
              if (it2->first <= maxFirstStrip) { isDetOk = false; continue; } // duplicated APV or data corruption. DO NOT 'break' here!
              maxFirstStrip = it2->first; 
          }
          if (!isDetOk) { errorInData = true; it = it2; continue; } // skip whole det
          // make room for 256 * (max_apv_pair + 1) Raw Digis
          digis.resize(maxFirstStrip + 256);
          // push them in
          for (it2 = it+0; (it2 != end) && (it2->detid == it->detid); ++it2) {
              if (it->length != 256)  { isDetOk = false; continue; } // data corruption. DO NOT 'break' here
              std::copy( & proc_work_digis_[it2->index], & proc_work_digis_[it2->index + it2->length], & digis[it->first] );
          }
          if (!isDetOk) { errorInData = true; digis.clear(); it = it2; continue; } // skip whole det
          it = it2;
      }
      if (errorInData) { edm::LogWarning("CorruptData") << "Some modules contained corrupted processed raw data, and have been skipped in unpacking\n"; }
      // check sorting
      if ( !__gnu_cxx::is_sorted( sorted_and_merged.begin(), sorted_and_merged.end()  ) ) {
          // this is an error in the code: i DID sort it already!
          throw cms::Exception("Bug Found") << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ <<"\n";
      }
      // make output DetSetVector
      edm::DetSetVector<SiStripRawDigi> proc_raw_dsv( sorted_and_merged, true ); 
      proc_raw.swap( proc_raw_dsv );
  } 
  
  // Populate final DetSetVector container with SM data 
  if ( !scope_work_registry_.empty() ) {
      std::sort( scope_work_registry_.begin(), scope_work_registry_.end() );

      std::vector< edm::DetSet<SiStripRawDigi> > sorted_and_merged;
      sorted_and_merged.reserve( scope_work_registry_.size() );

      bool errorInData = false;
      std::vector<DetSet_SiStripDig_registry>::iterator it, end;
      for (it = scope_work_registry_.begin(), end = scope_work_registry_.end() ; it != end; ++it) {
          sorted_and_merged.push_back( edm::DetSet<SiStripRawDigi>(it->detid) );
          std::vector<SiStripRawDigi> & digis = sorted_and_merged.back().data;
          digis.insert( digis.end(), & scope_work_digis_[it->index], & scope_work_digis_[it->index + it->length] );

          if ( (it +1 != end) && (it->detid == (it+1)->detid) ) {
              errorInData = true; 
              // let's skip *all* the detsets for that key, as we don't know which is the correct one!
              do { ++it; } while ( ( it+1 != end) && (it->detid == (it+1)->detid) );
              //throw cms::Exception("Duplicate Key") << "Duplicate key " << it->detid << " found in scope mode.\n"; 
          }
      }
      if (errorInData) { edm::LogWarning("CorruptData") << "Some fed keys contained corrupted scope mode data, and have been skipped in unpacking\n"; }
      // check sorting
      if ( !__gnu_cxx::is_sorted( sorted_and_merged.begin(), sorted_and_merged.end()  ) ) {
          // this is an error in the code: i DID sort it already!
          throw cms::Exception("Bug Found") << "Container must be already sorted!\nat " << __FILE__ << ", line " << __LINE__ <<"\n";
      }
      // make output DetSetVector
      edm::DetSetVector<SiStripRawDigi> scope_mode_dsv( sorted_and_merged, true ); 
      scope_mode.swap( scope_mode_dsv );

  } 

  // Increment event counter
  event_++;
  
  if ( first_ ) { first_ = false; }

  // final cleanup, just in case
  cleanupWorkVectors();
}

void SiStripRawToDigiUnpacker::dumpRawData	(	uint16_t	fed_id,
		const FEDRawData &	buffer,
		std::stringstream &	ss
	)			[private]

Dumps raw data to stdout (NB: payload is byte-swapped, headers/trailer are not).

Definition at line 958 of file SiStripRawToDigiUnpacker.cc.

References FEDRawData::data(), empty, lat::endl(), i, sistrip::invalid32_, FEDRawData::size(), tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, and tmp7.

Referenced by createDigis().

                                                                  {
  ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
     << " Dump of buffer for FED id " <<  fed_id << std::endl
     << " Buffer contains " << buffer.size()
     << " bytes (NB: payload is byte-swapped)" << std::endl;
  uint32_t* buffer_u32 = reinterpret_cast<uint32_t*>( const_cast<unsigned char*>( buffer.data() ) );
  unsigned int empty = 0;

  if ( 0 ) { 

    ss << "Byte->   4 5 6 7 0 1 2 3\n";
    for ( uint32_t i = 0; i < buffer.size()/8; i++ ) {
      unsigned int temp0 = buffer_u32[i*2] & sistrip::invalid32_;
      unsigned int temp1 = buffer_u32[i*2+1] & sistrip::invalid32_;
      if ( !temp0 && !temp1 ) { empty++; }
      else { 
        if ( empty ) { 
          ss << "        [ empty  words ]" << std::endl; 
          empty = 0; 
        }
        ss << std::dec
           << std::setfill(' ')  << std::setw(6) << i*8 << ": " 
           << std::hex 
           << std::setfill('0') << std::setw(8) << temp0 
           << std::setfill('0') << std::setw(8) << temp1 
           << std::dec
           << std::endl;
      }
    }

  } else {
    
    ss << "  Byte |  <---- Byte order ----<  | Byte" << std::endl;
    ss << "  cntr |  7  6  5  4  3  2  1  0  | cntr" << std::endl;
    for ( uint32_t i = 0; i < buffer.size()/8; i++ ) {
      //if ( i>=20 && ((i+4)<(buffer.size()/8)) ) { continue; }
      uint16_t tmp0 = buffer.data()[i*8+0] & 0xFF;
      uint16_t tmp1 = buffer.data()[i*8+1] & 0xFF;
      uint16_t tmp2 = buffer.data()[i*8+2] & 0xFF;
      uint16_t tmp3 = buffer.data()[i*8+3] & 0xFF;
      uint16_t tmp4 = buffer.data()[i*8+4] & 0xFF;
      uint16_t tmp5 = buffer.data()[i*8+5] & 0xFF;
      uint16_t tmp6 = buffer.data()[i*8+6] & 0xFF;
      uint16_t tmp7 = buffer.data()[i*8+7] & 0xFF;
      if ( !tmp0 && !tmp1 && !tmp2 && !tmp3 &&
           !tmp4 && !tmp5 && !tmp6 && !tmp7 ) { empty++; }
      else { 
        if ( empty ) { 
          ss << "         [.." 
             << std::dec << std::setfill('.') << std::setw(4) << empty 
             << " null words....]" << std::endl; 
          empty = 0; 
        }
        ss << std::dec
           << std::setfill(' ')  << std::setw(6) << i*8+7 << " : " 
           << std::hex 
           << std::setfill('0') << std::setw(2) << tmp7 << " " 
           << std::setfill('0') << std::setw(2) << tmp6 << " " 
           << std::setfill('0') << std::setw(2) << tmp5 << " " 
           << std::setfill('0') << std::setw(2) << tmp4 << " " 
           << std::setfill('0') << std::setw(2) << tmp3 << " " 
           << std::setfill('0') << std::setw(2) << tmp2 << " " 
           << std::setfill('0') << std::setw(2) << tmp1 << " " 
           << std::setfill('0') << std::setw(2) << tmp0 
           << std::dec
           << " :" << std::setfill(' ')  << std::setw(6) << i*8 
           << std::endl;
      }
    }

  }
  ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
     << " End of FED buffer";
}

sistrip::FedBufferFormat SiStripRawToDigiUnpacker::fedBufferFormat

(

const uint16_t &

register_value

)

[inline, private]

Definition at line 143 of file SiStripRawToDigiUnpacker.h.

References sistrip::APV_ERROR_FORMAT, sistrip::FULL_DEBUG_FORMAT, sistrip::UNDEFINED_FED_BUFFER_FORMAT, and sistrip::UNKNOWN_FED_BUFFER_FORMAT.

                                                                                                 {
  if      ( (register_value&0xF) == 0x1 ) { return sistrip::FULL_DEBUG_FORMAT; }
  else if ( (register_value&0xF) == 0x2 ) { return sistrip::APV_ERROR_FORMAT; }
  else if ( (register_value&0xF) == 0x0 ) { return sistrip::UNDEFINED_FED_BUFFER_FORMAT; }
  else                                    { return sistrip::UNKNOWN_FED_BUFFER_FORMAT; }
}

sistrip::FedReadoutMode SiStripRawToDigiUnpacker::fedReadoutMode

(

const uint16_t &

register_value

)

[inline, private]

Definition at line 150 of file SiStripRawToDigiUnpacker.h.

References sistrip::FED_PROC_RAW, sistrip::FED_SCOPE_MODE, sistrip::FED_VIRGIN_RAW, sistrip::FED_ZERO_SUPPR, sistrip::FED_ZERO_SUPPR_LITE, and sistrip::UNKNOWN_FED_READOUT_MODE.

Referenced by createDigis(), and SiStripRawToClustersLazyUnpacker::fill().

                                                                                               {
  if      ( ((register_value>>1)&0x7) == 0x0 ) { return sistrip::FED_SCOPE_MODE; }
  else if ( ((register_value>>1)&0x7) == 0x1 ) { return sistrip::FED_VIRGIN_RAW; }
  else if ( ((register_value>>1)&0x7) == 0x3 ) { return sistrip::FED_PROC_RAW; }
  else if ( ((register_value>>1)&0x7) == 0x5 ) { return sistrip::FED_ZERO_SUPPR; }
  else if ( ((register_value>>1)&0x7) == 0x6 ) { return sistrip::FED_ZERO_SUPPR_LITE; }
  else                                         { return sistrip::UNKNOWN_FED_READOUT_MODE; }
}

void SiStripRawToDigiUnpacker::handleException	(	std::string	method_name,
		std::string	extra_info = ""
	)			[private]

Catches all possible exceptions and rethrows them as cms::Exception's that are caught by the framework.

Definition at line 1037 of file SiStripRawToDigiUnpacker.cc.

References e, lat::endl(), exception, edm::isDebugEnabled(), sistrip::mlRawToDigi_, and ss.

Referenced by createDigis(), and SiStripRawToClustersLazyUnpacker::fill().

                                                                       { // throw (cms::Exception) {
  method_name = "SiStripRawToDigiUnpacker::" + method_name;
  try {
    throw; // rethrow caught exception to be dealt with below
  } 
  catch ( const cms::Exception& e ) { 
    //throw e; // rethrow cms::Exception to be caught by framework
  }
  catch ( const ICUtils::ICException& e ) {
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss;
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
         << " Caught ICUtils::ICException exception!" << std::endl;
      if ( extra_info != "" ) { 
        ss << " Information: " << extra_info << std::endl;
      }
      ss << " Caught ICUtils::ICException in ["
         << method_name << "] with message:" << std::endl 
         << e.what();
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }
    //throw cms::Exception(mlRawToDigi_) << ss.str();
  }
  catch ( const std::exception& e ) {
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss;
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
         << " Caught std::exception!" << std::endl;
      if ( extra_info != "" ) { 
        ss << " Information: " << extra_info << std::endl;
      }
      ss << " Caught std::exception in ["
         << method_name << "] with message:" << std::endl 
         << e.what();
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }
    //throw cms::Exception(mlRawToDigi_) << ss.str();
  }
  catch (...) {
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss;
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
         << " Caught unknown exception!" << std::endl;
      if ( extra_info != "" ) { 
        ss << " Information: " << extra_info << std::endl;
      }
      ss << "Caught unknown exception in ["
         << method_name << "]" << std::endl;
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }
    //throw cms::Exception(mlRawToDigi_) << ss.str();
  }
}

void SiStripRawToDigiUnpacker::locateStartOfFedBuffer	(	const uint16_t &	fed_id,
		const FEDRawData &	input,
		FEDRawData &	output
	)

Removes any data appended prior to FED buffer and reorders 32-bit words if swapped.

Pattern matches to find DAQ header: DAQ header, 4 MSB, BEO1, with value 0x5 DAQ header, 4 LSB, Hx$$, with value 0x8 (or 0x0) DAQ trailer, 4 MSB, EOE, with value 0xA

Definition at line 731 of file SiStripRawToDigiUnpacker.cc.

References FEDRawData::data(), lat::endl(), headerBytes_, edm::isDebugEnabled(), iter, LogTrace, sistrip::mlRawToDigi_, offset, FEDRawData::resize(), FEDRawData::size(), and ss.

Referenced by SiStripFEDRawDataCheck::analyze(), createDigis(), and SiStripRawToClustersLazyUnpacker::fill().

                                                                            {
  
  // Check size of input buffer
  if ( input.size() < 24 ) { 
    output.resize( input.size() ); // Return UNadjusted buffer start position and size
    memcpy( output.data(), input.data(), input.size() );
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss; 
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "] "
         << "Input FEDRawData with FED id " << fed_id 
         << " has size " << input.size();
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }
    return;
  } 
  
  // Iterator through buffer to find DAQ header 
  bool found = false;
  uint16_t ichar = 0;
  while ( ichar < input.size()-16 && !found ) {
    uint16_t offset = headerBytes_ < 0 ? ichar : headerBytes_; // Negative value means use "search mode" to find DAQ header
    uint32_t* input_u32   = reinterpret_cast<uint32_t*>( const_cast<unsigned char*>( input.data() ) + offset );
    uint32_t* fed_trailer = reinterpret_cast<uint32_t*>( const_cast<unsigned char*>( input.data() ) + input.size() - 8 );

    /*

      Some info on FED buffer 32-bit word swapping. Table below
      indicates if data are swapped relative to "old" VME format (as
      orignally expected by Fed9UEvent)

      | SWAPPED?    |         DATA FORMAT       |
      | (wrt "OLD") | OLD (0xED)  | NEW (0xC5)  |
      |             | VME | SLINK | VME | SLINK |
      -------------------------------------------
      | DAQ HEADER  |  N  |   Y   |  Y  |   Y   |
      | TRK HEADER  |  N  |   Y   |  N  |   N   |
      | PAYLOAD     |  N  |   Y   |  N  |   N   |
      | DAQ TRAILER |  N  |   Y   |  Y  |   Y   |

      So, in code, we check in code order of bytes in DAQ header/trailer only:
      -> if "old_vme_header",           then old format read out via vme, so do nothing.
      -> else if "old_slink_header",    then data mapy be wwapped, so check additionally the TRK header:
      --> if "old_slink_payload",       then old format read out via slink, so swap all data;
      --> else if "new_buffer_format",  then new format, handled internally by Fed9UEvent, so do nothing.

     */
    
    bool old_vme_header = 
      ( input_u32[0]    & 0xF0000000 ) == 0x50000000 &&
      ( fed_trailer[0]  & 0xF0000000 ) == 0xA0000000 && 
      ( (fed_trailer[0] & 0x00FFFFFF)*0x8 ) == (input.size() - offset);
    
    bool old_slink_header = 
      ( input_u32[1]    & 0xF0000000 ) == 0x50000000 &&
      ( fed_trailer[1]  & 0xF0000000 ) == 0xA0000000 &&
      ( (fed_trailer[1] & 0x00FFFFFF)*0x8 ) == (input.size() - offset);

    bool old_slink_payload = ( input_u32[3] & 0xFF000000 ) == 0xED000000;
    
    bool new_buffer_format = ( input_u32[2] & 0xFF000000 ) == 0xC5000000;
    
    if ( old_vme_header )  {
      
      // Found DAQ header at byte position 'offset'
      found = true;
      output.resize( input.size()-offset );
      memcpy( output.data(),         // target
              input.data()+offset,   // source
              input.size()-offset ); // nbytes
      if ( headerBytes_ < 0 ) {
        if ( edm::isDebugEnabled() ) {
          std::stringstream ss;
          ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]" 
             << " Buffer for FED id " << fed_id 
             << " has been found at byte position " << offset
             << " with a size of " << input.size()-offset << " bytes."
             << " Adjust the configurable 'AppendedBytes' to " << offset;
          LogTrace(mlRawToDigi_) << ss.str();
        }
      }
      
    } else if ( old_slink_header ) {
      
      if ( old_slink_payload ) {
      
        // Found DAQ header (with MSB and LSB 32-bit words swapped) at byte position 'offset' 
        found = true;
        output.resize( input.size()-offset );
        uint32_t* output_u32 = reinterpret_cast<uint32_t*>( const_cast<unsigned char*>( output.data() ) );
        uint16_t iter = offset; 
        while ( iter < output.size() / sizeof(uint32_t) ) {
          output_u32[iter] = input_u32[iter+1];
          output_u32[iter+1] = input_u32[iter];
          iter+=2;
        }
        if ( headerBytes_ < 0 ) {
          if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]" 
               << " Buffer (with MSB and LSB 32-bit words swapped) for FED id " << fed_id 
               << " has been found at byte position " << offset
               << " with a size of " << output.size() << " bytes."
               << " Adjust the configurable 'AppendedBytes' to " << offset;
            LogTrace(mlRawToDigi_) << ss.str();
          }
        }

      } else if ( new_buffer_format ) {
        
        // Found DAQ header at byte position 'offset'
        found = true;
        output.resize( input.size()-offset );
        memcpy( output.data(),         // target
                input.data()+offset,   // source
                input.size()-offset ); // nbytes
        if ( headerBytes_ < 0 ) {
          if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]" 
               << " Buffer for FED id " << fed_id 
               << " has been found at byte position " << offset
               << " with a size of " << input.size()-offset << " bytes."
               << " Adjust the configurable 'AppendedBytes' to " << offset;
            LogTrace(mlRawToDigi_) << ss.str();
          }
        }
        
      } else { headerBytes_ < 0 ? found = false : found = true; }
    } else { headerBytes_ < 0 ? found = false : found = true; }
    ichar++;
  }      
  
  // Check size of output buffer
  if ( output.size() == 0 ) { 
    
    // Did not find DAQ header after search => return buffer with NULL size
    output.resize( 0 ); //@@ NULL SIZE!
    memcpy( output.data(), input.data(), 0 ); //@@ NULL SIZE!
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss;
      if ( headerBytes_ < 0 ) {
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " DAQ header not found within buffer for FED id: " << fed_id;
      } else {
        uint32_t* input_u32 = reinterpret_cast<uint32_t*>( const_cast<unsigned char*>( input.data() ) );
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " DAQ header not found at expected location for FED id: " << fed_id << std::endl
           << " First 64-bit word of buffer is 0x"
           << std::hex 
           << std::setfill('0') << std::setw(8) << input_u32[0] 
           << std::setfill('0') << std::setw(8) << input_u32[1] 
           << std::dec << std::endl
           << " Adjust 'AppendedBytes' configurable to '-1' to activate 'search mode'";
      }
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }
    
  } else if ( output.size() < 24 ) { // Found DAQ header after search, but too few words
    
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss; 
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
         << " Unexpected buffer size! FEDRawData with FED id " << fed_id 
         << " has size " << output.size();
      edm::LogWarning(mlRawToDigi_) << ss.str();
    }

  } 
  
}

void SiStripRawToDigiUnpacker::physicalOrder	(	uint16_t &	readout_order,
		uint16_t &	physical_order
	)			[inline, private]

Definition at line 136 of file SiStripRawToDigiUnpacker.h.

                                                                         {
  physical_order = ( (32 * (readout_order%4)) +
                     (8 * static_cast<uint16_t>(static_cast<float>(readout_order)/4.0)) -
                     (31 * static_cast<uint16_t>(static_cast<float>(readout_order)/16.0)) );
}

void SiStripRawToDigiUnpacker::quiet

(

bool

quiet

)

[inline]

Definition at line 159 of file SiStripRawToDigiUnpacker.h.

References quiet_.

{ quiet_ = quiet; }

void SiStripRawToDigiUnpacker::readoutOrder	(	uint16_t &	physical_order,
		uint16_t &	readout_order
	)			[inline, private]

Definition at line 129 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

                                                                       {
  readout_order = ( 4*((static_cast<uint16_t>((static_cast<float>(physical_order)/8.0)))%4) +
                    static_cast<uint16_t>(static_cast<float>(physical_order)/32.0) +
                    16*(physical_order%8) );
}

void SiStripRawToDigiUnpacker::triggerFed	(	const FEDRawDataCollection &	buffers,
		SiStripEventSummary &	summary,
		const uint32_t &	event
	)

Definition at line 605 of file SiStripRawToDigiUnpacker.cc.

References SiStripEventSummary::bx(), SiStripEventSummary::commissioningInfo(), fedt_struct::conscheck, FEDRawData::data(), lat::endl(), SiStripEventSummary::event(), FEDRawDataCollection::FEDData(), TFHeaderDescription::getBunchCrossing(), TFHeaderDescription::getFedEventNumber(), header, edm::isDebugEnabled(), SiStripEventSummary::isSet(), FEDNumbering::lastFEDId(), LogTrace, sistrip::mlRawToDigi_, once_, FEDRawData::size(), ss, pyDBSRunClass::temp, SiStripEventSummary::triggerFed(), and triggerFedId_.

Referenced by SiStripRawToDigiModule::produce().

                                                                   {
  
  // Pointer to data (recast as 32-bit words) and number of 32-bit words
  uint32_t* data_u32 = 0;
  uint32_t  size_u32 = 0;
  
  if ( triggerFedId_ < 0 ) { // Search mode
    
    uint16_t ifed = 0;
    while ( triggerFedId_ < 0 && 
            ifed < 1 + FEDNumbering::lastFEDId() ) {
      const FEDRawData& trigger_fed = buffers.FEDData( ifed );
      if ( trigger_fed.data() && trigger_fed.size() ) {
        uint8_t*  temp = const_cast<uint8_t*>( trigger_fed.data() );
        data_u32 = reinterpret_cast<uint32_t*>( temp ) + sizeof(fedh_t)/sizeof(uint32_t) + 1;
        size_u32 = trigger_fed.size()/sizeof(uint32_t) - sizeof(fedh_t)/sizeof(uint32_t) - 1;
        fedt_t* fed_trailer = reinterpret_cast<fedt_t*>( temp + trigger_fed.size() - sizeof(fedt_t) );
        if ( fed_trailer->conscheck == 0xDEADFACE ) { 
          triggerFedId_ = ifed; 
          if ( edm::isDebugEnabled() ) {
            std::stringstream ss;
            ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
               << " Search mode for 'trigger FED' activated!"
               << " Found 'trigger FED' info with id " << triggerFedId_;
            LogTrace(mlRawToDigi_) << ss.str();
          }
        }
      }
      ifed++;
    }
    if ( triggerFedId_ < 0 ) {
      triggerFedId_ = 0;
      if ( edm::isDebugEnabled() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " Search mode for 'trigger FED' activated!"
           << " 'Trigger FED' info not found!";
        edm::LogWarning(mlRawToDigi_) << ss.str();
      }
    }
    
  } else if ( triggerFedId_ > 0 ) { // "Trigger FED" id given in .cfg file
    
    const FEDRawData& trigger_fed = buffers.FEDData( triggerFedId_ );
    if ( trigger_fed.data() && trigger_fed.size() ) {
      uint8_t*  temp = const_cast<uint8_t*>( trigger_fed.data() );
      data_u32 = reinterpret_cast<uint32_t*>( temp ) + sizeof(fedh_t)/sizeof(uint32_t) + 1;
      size_u32 = trigger_fed.size()/sizeof(uint32_t) - sizeof(fedh_t)/sizeof(uint32_t) - 1;
      fedt_t* fed_trailer = reinterpret_cast<fedt_t*>( temp + trigger_fed.size() - sizeof(fedt_t) );
      if ( fed_trailer->conscheck != 0xDEADFACE ) { 
        if ( edm::isDebugEnabled() ) {
          edm::LogWarning(mlRawToDigi_) 
            << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
            << " Unexpected stamp found in DAQ trailer (ie, not 0xDEADFACE)!"
            << " Buffer appears not to contain 'trigger FED' data!";
        }
        triggerFedId_ = 0; 
      }
    }
      
  } else { 
    triggerFedId_ = 0; 
    data_u32 = 0;
    size_u32 = 0;
  }
  
  // Populate summary object with commissioning information
  if ( triggerFedId_ > 0 ) { 

    // Some checks
    if ( !data_u32 ) {
      if ( edm::isDebugEnabled() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " NULL pointer to 'trigger FED' data";
        edm::LogWarning(mlRawToDigi_) << ss.str();
      }
      return;
    } 
    if ( size_u32 < sizeof(TFHeaderDescription)/sizeof(uint32_t) ) {
      if ( edm::isDebugEnabled() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " Unexpected 'Trigger FED' data size [32-bit words]: " << size_u32;
        edm::LogWarning(mlRawToDigi_) << ss.str();
      }
      return;
    }
    
    // Write event-specific data to event
    TFHeaderDescription* header = (TFHeaderDescription*) data_u32;
    summary.event( static_cast<uint32_t>( header->getFedEventNumber()) );
    summary.bx( static_cast<uint32_t>( header->getBunchCrossing()) );
    
    // Write commissioning information to event 
    uint32_t hsize = sizeof(TFHeaderDescription)/sizeof(uint32_t);
    uint32_t* head = &data_u32[hsize];
    summary.commissioningInfo( head, event );
    summary.triggerFed( triggerFedId_ );
    
  }

  // Some debug
  if ( summary.isSet() && once_ ) {
    if ( edm::isDebugEnabled() ) {
      std::stringstream ss;
      ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
         << " EventSummary built from \"trigger FED\":" 
         << std::endl << summary;
      LogTrace(mlRawToDigi_) << ss.str();
    }
    once_ = false;
  }
  
}

void SiStripRawToDigiUnpacker::updateEventSummary	(	const Fed9U::Fed9UEvent * const	fed,
		SiStripEventSummary &	summary
	)			[private]

Definition at line 906 of file SiStripRawToDigiUnpacker.cc.

References SiStripEventSummary::commissioningInfo(), lat::endl(), SiStripEventSummary::fedReadoutMode(), sistrip::invalid32_, sistrip::invalid_, edm::isDebugEnabled(), SiStripEventSummary::isSet(), LogTrace, sistrip::mlRawToDigi_, once_, ss, SiStripEventSummary::triggerFed(), and triggerFedId_.

                                                                                  {
  
  // Retrieve contents of DAQ registers
  //@@ uint16_t trigger_type = sistrip::invalid_;
  uint16_t readout_mode = sistrip::invalid_;
  uint32_t daq1 = sistrip::invalid32_;
  uint32_t daq2 = sistrip::invalid32_;
  
  if ( fed ) {
    //@@ trigger_type = static_cast<uint16_t>( fed->?????() ); 
    readout_mode = static_cast<uint16_t>( fed->getEventType() ); 
    daq1 = static_cast<uint32_t>( fed->getDaqRegister() ); 
    daq2 = static_cast<uint32_t>( fed->getDaqRegisterTwo() ); 
  }
  
  // If FED DAQ registers contain info, update (and possibly overwrite) EventSummary 
  if ( daq1 != 0 && daq1 != sistrip::invalid32_ ) {
    
    summary.triggerFed( triggerFedId_ );
    summary.fedReadoutMode( readout_mode );
    summary.commissioningInfo( daq1, daq2 );
    
    if ( summary.isSet() && once_ ) {
      if ( edm::isDebugEnabled() ) {
        std::stringstream ss;
        ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
           << " EventSummary built from FED DAQ registers:"
           << std::endl << summary;
        LogTrace(mlRawToDigi_) << ss.str();
      }
      once_ = false;
    }
  }
  //@@ below needed to set run type in PHYSICS 
//   } else if ( trigger_type == ??? ) { 
//     summary.runType( sistrip::PHYSICS );
//     std::stringstream ss;
//     ss << "[SiStripRawToDigiUnpacker::" << __func__ << "]"
//        << " EventSummary built from 'Event Type' field in DAQ header:"
//        << std::endl << summary;
//     LogTrace(mlRawToDigi_) << ss.str();
//     once_ = false;
//   }
  
}

---

Friends And Related Function Documentation

friend class SiStripRawToClustersLazyUnpacker [friend]

Definition at line 32 of file SiStripRawToDigiUnpacker.h.

friend class SiStripRawToClustersModule [friend]

Definition at line 31 of file SiStripRawToDigiUnpacker.h.

---

Member Data Documentation

uint32_t SiStripRawToDigiUnpacker::event_ [private]

Definition at line 98 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

int16_t SiStripRawToDigiUnpacker::fedBufferDumpFreq_ [private]

Definition at line 91 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

Fed9U::Fed9UEvent* SiStripRawToDigiUnpacker::fedEvent_ [private]

Definition at line 96 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis(), SiStripRawToDigiUnpacker(), and ~SiStripRawToDigiUnpacker().

int16_t SiStripRawToDigiUnpacker::fedEventDumpFreq_ [private]

Definition at line 92 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

bool SiStripRawToDigiUnpacker::first_ [private]

Definition at line 102 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

int16_t SiStripRawToDigiUnpacker::headerBytes_ [private]

Definition at line 90 of file SiStripRawToDigiUnpacker.h.

Referenced by locateStartOfFedBuffer().

bool SiStripRawToDigiUnpacker::once_ [private]

Definition at line 100 of file SiStripRawToDigiUnpacker.h.

Referenced by triggerFed(), and updateEventSummary().

std::vector<SiStripRawDigi> SiStripRawToDigiUnpacker::proc_work_digis_ [private]

Definition at line 123 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

std::vector<DetSet_SiStripDig_registry> SiStripRawToDigiUnpacker::proc_work_registry_ [private]

Definition at line 121 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

bool SiStripRawToDigiUnpacker::quiet_ [private]

Definition at line 104 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis(), and quiet().

std::vector<SiStripRawDigi> SiStripRawToDigiUnpacker::scope_work_digis_ [private]

Definition at line 123 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

std::vector<DetSet_SiStripDig_registry> SiStripRawToDigiUnpacker::scope_work_registry_ [private]

Definition at line 120 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

int16_t SiStripRawToDigiUnpacker::triggerFedId_ [private]

Definition at line 93 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis(), triggerFed(), and updateEventSummary().

bool SiStripRawToDigiUnpacker::useFedKey_ [private]

Definition at line 94 of file SiStripRawToDigiUnpacker.h.

Referenced by createDigis().

std::vector<SiStripRawDigi> SiStripRawToDigiUnpacker::virgin_work_digis_ [private]

Definition at line 123 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

std::vector<DetSet_SiStripDig_registry> SiStripRawToDigiUnpacker::virgin_work_registry_ [private]

Definition at line 119 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

std::vector<SiStripDigi> SiStripRawToDigiUnpacker::zs_work_digis_ [private]

Definition at line 122 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

std::vector<DetSet_SiStripDig_registry> SiStripRawToDigiUnpacker::zs_work_registry_ [private]

Definition at line 118 of file SiStripRawToDigiUnpacker.h.

Referenced by cleanupWorkVectors(), and createDigis().

---

The documentation for this class was generated from the following files:

• EventFilter/SiStripRawToDigi/interface/SiStripRawToDigiUnpacker.h
• EventFilter/SiStripRawToDigi/src/SiStripRawToDigiUnpacker.cc

---