#include <LarsoftHuffmanCompressService.h>

Inheritance diagram for LarsoftHuffmanCompressService:

Public Member Functions
	LarsoftHuffmanCompressService (bool useBlock, bool useHuffman, int logLevel)

	LarsoftHuffmanCompressService (fhicl::ParameterSet const &pset, art::ActivityRegistry &)

int	compress (AdcCountVector &sigs, const AdcFilterVector &keep, AdcCount offset, raw::Compress_t &comp) const

std::ostream &	print (std::ostream &out=std::cout, std::string prefix=" ") const

Public Member Functions inherited from AdcCompressService
virtual	~AdcCompressService ()=default

Private Member Functions
void	block (const AdcCountVector &oldsigs, const AdcFilterVector &keep, AdcCountVector &newsigs) const

Private Attributes
bool	m_UseBlock

bool	m_UseHuffman

int	m_LogLevel

Detailed Description

Definition at line 34 of file LarsoftHuffmanCompressService.h.

Constructor & Destructor Documentation

LarsoftHuffmanCompressService::LarsoftHuffmanCompressService	(	bool	useBlock,
		bool	useHuffman,
		int	logLevel
	)

Definition at line 40 of file LarsoftHuffmanCompressService_service.cc.

41 : m_UseBlock(useBlock), m_UseHuffman(useHuffman), m_LogLevel(logLevel) { }

LarsoftHuffmanCompressService::m_UseHuffman

bool m_UseHuffman

Definition: LarsoftHuffmanCompressService.h:62

LarsoftHuffmanCompressService::m_LogLevel

int m_LogLevel

Definition: LarsoftHuffmanCompressService.h:63

LarsoftHuffmanCompressService::m_UseBlock

bool m_UseBlock

Definition: LarsoftHuffmanCompressService.h:61

LarsoftHuffmanCompressService::LarsoftHuffmanCompressService	(	fhicl::ParameterSet const &	pset,
		art::ActivityRegistry &
	)

Member Function Documentation

void LarsoftHuffmanCompressService::block	(	const AdcCountVector &	oldsigs,
		const AdcFilterVector &	keep,
		AdcCountVector &	newsigs
	)		const

private

Definition at line 112 of file LarsoftHuffmanCompressService_service.cc.

                                                                                                 {
   const unsigned int adcsize = sigsin.size();
   std::vector<short> zerosuppressed(sigsin.size());
   unsigned int maxblocks = adcsize/2 + 1;
   std::vector<short> blockbegin(maxblocks);
   std::vector<short> blocksize(maxblocks);
   unsigned int nblocks = 0;
   unsigned int zerosuppressedsize = 0;
   bool inblock = false;
   for ( unsigned int i=0; i<adcsize; ++i ) {
     if ( keep[i] ) {
       if ( ! inblock ) {
         blockbegin[nblocks] = i;
         blocksize[nblocks] = 0;
         inblock = true;
       }
       zerosuppressed[zerosuppressedsize] = sigsin[i];
       ++zerosuppressedsize;
       ++blocksize[nblocks];
       if ( i == adcsize-1 ) ++nblocks;
     } else if ( inblock ) {
       //zerosuppressed[zerosuppressedsize] = sigsin[i];
       //++zerosuppressedsize;
       //++blocksize[nblocks];
       ++nblocks;
       inblock = false;
     }
   }
   sigsout.resize(2+nblocks+nblocks+zerosuppressedsize);
   sigsout[0] = adcsize; //fill first entry in adc with length of uncompressed vector
   sigsout[1] = nblocks;
   for ( unsigned int i=0; i<nblocks; ++i ) sigsout[i+2] = blockbegin[i];
   for ( unsigned int i=0; i<nblocks; ++i ) sigsout[i+nblocks+2] = blocksize[i];
   for ( unsigned int i=0; i<zerosuppressedsize; ++i ) sigsout[i+nblocks+nblocks+2] = zerosuppressed[i];
 }

int LarsoftHuffmanCompressService::compress	(	AdcCountVector &	sigs,
		const AdcFilterVector &	keep,
		AdcCount	offset,
		raw::Compress_t &	comp
	)		const

virtual

Implements AdcCompressService.

Definition at line 62 of file LarsoftHuffmanCompressService_service.cc.

                                     {
   const string myname = "LarsoftHuffmanCompressService::compress: ";
   if ( keep.size() != sigs.size() ) {
     cout << "ERROR: Filter and ADC have different sizes: " << keep.size()
          << " != " << sigs.size() << endl;
     return 1;
   }
   AdcCountVector newsigs;
   comp = raw::kNone;
   logsigs(sigs, m_LogLevel, 6, myname + "Before compression");
   logsigs(keep, m_LogLevel, 6, myname + "Filter");
   if ( m_LogLevel > 1 ) {
     int nkeep = 0;
     for ( bool val : keep ) if ( val ) ++nkeep;
     cout << myname << "Keeping " << nkeep << "/" << keep.size() << " ticks" << endl;
   }
   if  ( m_UseBlock ) {
     block(sigs, keep, newsigs);
     sigs = newsigs;
     comp = raw::kZeroSuppression;
   } else {
     ReplaceCompressService repsvc;
     repsvc.compress(sigs, keep, offset, comp);
   }
   if  ( m_UseHuffman ) {
     raw::CompressHuffman(sigs);
     if ( m_UseBlock ) comp = raw::kZeroHuffman;
     else              comp = raw::kHuffman;
   }
   logsigs(sigs, m_LogLevel, 5, myname + "After compression");
   return 0;
 }

ostream & LarsoftHuffmanCompressService::print	(	std::ostream &	out = `std::cout`,
		std::string	prefix = `" "`
	)		const

virtual

Implements AdcCompressService.

Definition at line 98 of file LarsoftHuffmanCompressService_service.cc.

                                                                                {
   out << prefix << "LarsoftHuffmanCompressService";
   return out;
 }