#include <SiStripRawToClustersLazyUnpacker.h>

Inheritance diagram for sistrip::RawToClustersLazyUnpacker:

Public Types
typedef edm::DetSet < SiStripCluster >	DetSet

Public Types inherited from edm::LazyUnpacker< SiStripCluster >
typedef std::vector < SiStripCluster >	record_type

Public Member Functions
virtual void	fill (const uint32_t &, record_type &)

	RawToClustersLazyUnpacker (const SiStripRegionCabling &, StripClusterizerAlgorithm &, SiStripRawProcessingAlgorithms &, const FEDRawDataCollection &, bool=false)

virtual	~RawToClustersLazyUnpacker ()

Public Member Functions inherited from edm::LazyUnpacker< SiStripCluster >
virtual	~LazyUnpacker ()

Private Member Functions
	RawToClustersLazyUnpacker ()
	private default constructor More...

Private Attributes
std::vector< sistrip::FEDBuffer * >	buffers_
	FED event cache. More...

StripClusterizerAlgorithm *const	clusterizer_
	clusterizer algorithm More...

bool	dump_
	dump frequency More...

const FEDRawDataCollection *	raw_
	raw data More...

SiStripRawProcessingAlgorithms *const	rawAlgos_
	raw processing algorithms More...

RawToDigiUnpacker	rawToDigi_
	raw-to-digi More...

const SiStripRegionCabling::Cabling *	regions_
	cabling More...

Detailed Description

Definition at line 19 of file SiStripRawToClustersLazyUnpacker.h.

Member Typedef Documentation

typedef edm::DetSet<SiStripCluster> sistrip::RawToClustersLazyUnpacker::DetSet

Definition at line 23 of file SiStripRawToClustersLazyUnpacker.h.

Constructor & Destructor Documentation

sistrip::RawToClustersLazyUnpacker::RawToClustersLazyUnpacker	(	const SiStripRegionCabling &	regioncabling,
		StripClusterizerAlgorithm &	clustalgo,
		SiStripRawProcessingAlgorithms &	rpAlgos,
		const FEDRawDataCollection &	data,
		bool	dump = `false`
	)

Definition at line 7 of file SiStripRawToClustersLazyUnpacker.cc.

References buffers_.

                                                                                                                                                                                                                             :
 
     raw_(&data),
     regions_(&(regioncabling.getRegionCabling())),
     clusterizer_(&clustalgo),
     rawAlgos_(&rpAlgos),
     buffers_(),
     rawToDigi_(0,0,0,0,0,0,0,0),
     dump_(dump)
   {
     buffers_.assign(1024,static_cast<sistrip::FEDBuffer*>(0));
   }

sistrip::RawToClustersLazyUnpacker::~RawToClustersLazyUnpacker ( )

virtual

Definition at line 20 of file SiStripRawToClustersLazyUnpacker.cc.

References buffers_.

                                                         {
 
     std::vector< sistrip::FEDBuffer*>::iterator ibuffer = buffers_.begin();
     for (; ibuffer!=buffers_.end(); ibuffer++) {
       if (*ibuffer) delete *ibuffer;
     }
   }

sistrip::RawToClustersLazyUnpacker::RawToClustersLazyUnpacker ( )

private

private default constructor

Member Function Documentation

void sistrip::RawToClustersLazyUnpacker::fill	(	const uint32_t &	index,
		record_type &	record
	)

virtual

Implements edm::LazyUnpacker< SiStripCluster >.

Definition at line 28 of file SiStripRawToClustersLazyUnpacker.cc.

References sistrip::FEDZSChannelUnpacker::adc(), sistrip::FEDRawChannelUnpacker::adc(), edm::DetSet< T >::begin(), buffers_, sistrip::FEDBufferBase::channel(), sistrip::FEDBuffer::channelGood(), clusterizer_, FEDRawData::data(), sistrip::FEDBuffer::doChecks(), dump_, sistrip::RawToDigiUnpacker::dumpRawData(), edm::DetSet< T >::end(), FEDRawDataCollection::FEDData(), sistrip::FEDZSChannelUnpacker::hasData(), sistrip::FEDRawChannelUnpacker::hasData(), sistrip::invalid32_, edm::isDebugEnabled(), SiStripRegionCabling::layer(), LogTrace, sistrip::mlRawToCluster_, sistrip::mlRawToDigi_, mode, sistrip::FEDRawChannelUnpacker::procRawModeUnpacker(), raw_, rawAlgos_, rawToDigi_, sistrip::READOUT_MODE_PROC_RAW, sistrip::READOUT_MODE_VIRGIN_RAW, sistrip::READOUT_MODE_ZERO_SUPPRESSED, sistrip::READOUT_MODE_ZERO_SUPPRESSED_LITE, sistrip::FEDBufferBase::readoutMode(), record, SiStripRegionCabling::region(), sistrip::FEDZSChannelUnpacker::sampleNumber(), FEDRawData::size(), StripClusterizerAlgorithm::stripByStripAdd(), StripClusterizerAlgorithm::stripByStripBegin(), StripClusterizerAlgorithm::stripByStripEnd(), SiStripRegionCabling::subdet(), SiStripRawProcessingAlgorithms::subtractorCMN, SiStripRawProcessingAlgorithms::subtractorPed, SiStripRawProcessingAlgorithms::suppressor, sistrip::FEDRawChannelUnpacker::virginRawModeUnpacker(), cms::Exception::what(), sistrip::FEDZSChannelUnpacker::zeroSuppressedLiteModeUnpacker(), and sistrip::FEDZSChannelUnpacker::zeroSuppressedModeUnpacker().

                                                                                  {
 
     // Get region, subdet and layer from element-index
     uint32_t region = SiStripRegionCabling::region(index);
     uint32_t subdet = static_cast<uint32_t>(SiStripRegionCabling::subdet(index));
     uint32_t layer = SiStripRegionCabling::layer(index);
  
     // Retrieve cabling for element
     const SiStripRegionCabling::ElementCabling& element = (*regions_)[region][subdet][layer];
   
     // Loop dets
     SiStripRegionCabling::ElementCabling::const_iterator idet = element.begin();
     for (;idet!=element.end();idet++) {
     
       // If det id is null or invalid continue.
       if ( !(idet->first) || (idet->first == sistrip::invalid32_) || !clusterizer_->stripByStripBegin(idet->first)) { continue; }
     
       // Loop over apv-pairs of det
       std::vector<FedChannelConnection>::const_iterator iconn = idet->second.begin();
       for (;iconn!=idet->second.end();iconn++) {
         const uint16_t fedId = iconn->fedId();
       
     // If fed id is null or connection is invalid continue
     if ( !fedId || !iconn->isConnected() ) { continue; }    
       
     // If Fed hasnt already been initialised, extract data and initialise
         FEDBuffer* buffer = buffers_[fedId];
     if (!buffer) {
     
       // Retrieve FED raw data for given FED
           const FEDRawData& rawData = raw_->FEDData( static_cast<int>(fedId) );
     
       // Check on FEDRawData pointer
       if ( !rawData.data() ) {
             if (edm::isDebugEnabled()) {
               edm::LogWarning(sistrip::mlRawToCluster_)
                 << "[sistrip::RawToClustersLazyGetter::" 
                 << __func__ 
                 << "]"
                 << " NULL pointer to FEDRawData for FED id " 
                 << fedId;
             }
         continue;
       } 
     
       // Check on FEDRawData size
       if ( !rawData.size() ) {
         if (edm::isDebugEnabled()) {
               edm::LogWarning(sistrip::mlRawToCluster_)
                 << "[sistrip::RawToClustersLazyGetter::" 
                 << __func__ << "]"
                 << " FEDRawData has zero size for FED id " 
                 << fedId;
             }
         continue;
       }
     
       // construct FEDBuffer
       try {
             buffers_[fedId] = buffer = new sistrip::FEDBuffer(rawData.data(),rawData.size());
             if (!buffer->doChecks()) throw cms::Exception("FEDBuffer") << "FED Buffer check fails for FED ID" << fedId << ".";
           }
       catch (const cms::Exception& e) { 
             if (edm::isDebugEnabled()) {
               edm::LogWarning(sistrip::mlRawToCluster_) 
                 << "Exception caught when creating FEDBuffer object for FED " << fedId << ": " << e.what();
             }
         if ( buffer ) { delete buffer; }
         buffers_[fedId] = 0;
         continue;
       }
 
       // dump of FEDRawData to stdout
       if ( dump_ ) {
         std::stringstream ss;
         rawToDigi_.dumpRawData( fedId, rawData, ss );
         LogTrace(mlRawToDigi_) 
           << ss.str();
       }
         }
 
     // check channel
         const uint8_t fedCh = iconn->fedCh();
     if (!buffer->channelGood(fedCh)) {
           if (edm::isDebugEnabled()) {
             std::ostringstream ss;
             ss << "Problem unpacking channel " << fedCh << " on FED " << fedId;
             edm::LogWarning(sistrip::mlRawToCluster_) << ss.str();
           }
           continue;
         }
       
     // Determine APV std::pair number
     uint16_t ipair = iconn->apvPairNumber();
 
         const sistrip::FEDReadoutMode mode = buffer->readoutMode();
     if (mode == sistrip::READOUT_MODE_ZERO_SUPPRESSED ) { 
     
           try {
         // create unpacker
         sistrip::FEDZSChannelUnpacker unpacker = sistrip::FEDZSChannelUnpacker::zeroSuppressedModeUnpacker(buffer->channel(fedCh));
         
         // unpack
         while (unpacker.hasData()) {
           clusterizer_->stripByStripAdd(unpacker.sampleNumber()+ipair*256,unpacker.adc(),record);
           unpacker++;
         }
           } catch (const cms::Exception& e) {
             if (edm::isDebugEnabled()) {
               std::ostringstream ss;
               ss << "Unordered clusters for channel " << fedCh << " on FED " << fedId << ": " << e.what();
               edm::LogWarning(sistrip::mlRawToCluster_) << ss.str();
             }
             continue;
           }
     }
 
     else if (mode == sistrip::READOUT_MODE_ZERO_SUPPRESSED_LITE ) { 
     
           try {
             // create unpacker
             sistrip::FEDZSChannelUnpacker unpacker = sistrip::FEDZSChannelUnpacker::zeroSuppressedLiteModeUnpacker(buffer->channel(fedCh));
 
             // unpack
             while (unpacker.hasData()) {
               clusterizer_->stripByStripAdd(unpacker.sampleNumber()+ipair*256,unpacker.adc(),record);
               unpacker++;
             }
           } catch (const cms::Exception& e) {
             if (edm::isDebugEnabled()) {
               std::ostringstream ss;
               ss << "Unordered clusters for channel " << fedCh << " on FED " << fedId << ": " << e.what();
               edm::LogWarning(sistrip::mlRawToCluster_) << ss.str();
             }                                               
             continue;
           }
     }
 
     else if (mode == sistrip::READOUT_MODE_VIRGIN_RAW ) {
 
       // create unpacker
       sistrip::FEDRawChannelUnpacker unpacker = sistrip::FEDRawChannelUnpacker::virginRawModeUnpacker(buffer->channel(fedCh));
 
       // unpack
       std::vector<int16_t> digis;
       while (unpacker.hasData()) {
         digis.push_back(unpacker.adc());
         unpacker++;
       }
 
       //process raw
       uint32_t id = iconn->detId();
       rawAlgos_->subtractorPed->subtract( id, ipair*256, digis);
       rawAlgos_->subtractorCMN->subtract( id, digis);
       edm::DetSet<SiStripDigi> zsdigis(id);
       rawAlgos_->suppressor->suppress( digis, zsdigis);
       for( edm::DetSet<SiStripDigi>::const_iterator it = zsdigis.begin(); it!=zsdigis.end(); it++) {
         clusterizer_->stripByStripAdd( it->strip(), it->adc(), record);
       }
     }
 
     else if (mode == sistrip::READOUT_MODE_PROC_RAW ) {
 
       // create unpacker
       sistrip::FEDRawChannelUnpacker unpacker = sistrip::FEDRawChannelUnpacker::procRawModeUnpacker(buffer->channel(fedCh));
 
       // unpack
       std::vector<int16_t> digis;
       while (unpacker.hasData()) {
         digis.push_back(unpacker.adc());
         unpacker++;
       }
 
       //process raw
       uint32_t id = iconn->detId();
       rawAlgos_->subtractorCMN->subtract( id, digis);
       edm::DetSet<SiStripDigi> zsdigis(id);
       rawAlgos_->suppressor->suppress( digis, zsdigis);
       for( edm::DetSet<SiStripDigi>::const_iterator it = zsdigis.begin(); it!=zsdigis.end(); it++) {
         clusterizer_->stripByStripAdd( it->strip(), it->adc(), record);
       }
     }
 
     else {
       edm::LogWarning(sistrip::mlRawToCluster_)
         << "[sistrip::RawToClustersLazyGetter::" 
         << __func__ << "]"
         << " FEDRawData readout mode "
         << mode
         << " from FED id "
         << fedId 
         << " not supported."; 
       continue;
     }
       }
       clusterizer_->stripByStripEnd(record);
     }
   }