raw Namespace Reference

Raw data description. More...

Classes
class	AuxDetDigit
class	BeamInfo
class	DAQHeader
class	ExternalTrigger
class	OpDetPulse
class	OpDetWaveform
class	RawDigit
	Collection of charge vs time digitized from a single readout channel. More...
class	RDTimeStamp
class	Trigger

Typedefs
typedef enum raw::_compress	Compress_t
typedef enum raw::_auxdettype	AuxDetType_t
typedef int	TDCtick_t
	Type representing a TDC tick. More...
typedef unsigned int	ChannelID_t
	Type representing the ID of a readout channel. More...
typedef long long	TriggerTimeStamp_t
	type of trigger time stamp More...
typedef short	ADC_Count_t
typedef unsigned int	Channel_t
typedef double	TimeStamp_t
	us since 1970, based on TimeService More...

Enumerations
enum	_compress {   kNone, kHuffman, kZeroSuppression, kZeroHuffman,   kDynamicDec, kFibonacci }
enum	_auxdettype { kUnknownAuxDet, kScintillator, kTimeOfFlight, kCherenkov }

Functions
constexpr bool	isValidChannelID (raw::ChannelID_t channel)
std::ostream &	operator<< (std::ostream &os, const raw::BeamInfo &o)
bool	operator< (const OpDetWaveform &lhs, const OpDetWaveform &rhs)
void	Compress (std::vector< short > &adc, raw::Compress_t compress)
	Compresses a raw data buffer. More...
void	Compress (std::vector< short > &adc, raw::Compress_t compress, int &nearestneighbor)
void	Compress (std::vector< short > &adc, raw::Compress_t compress, unsigned int &zerothreshold)
void	Compress (std::vector< short > &adc, raw::Compress_t compress, unsigned int &zerothreshold, int &nearestneighbor)
void	Compress (const boost::circular_buffer< std::vector< short >> &adcvec_neighbors, std::vector< short > &adc, raw::Compress_t compress, unsigned int &zerothreshold, int &nearestneighbor)
void	Compress (std::vector< short > &adc, raw::Compress_t compress, unsigned int &zerothreshold, int pedestal, int &nearestneighbor, bool fADCStickyCodeFeature)
void	Compress (const boost::circular_buffer< std::vector< short >> &adcvec_neighbors, std::vector< short > &adc, raw::Compress_t compress, unsigned int &zerothreshold, int pedestal, int &nearestneighbor, bool fADCStickyCodeFeature)
void	ZeroSuppression (std::vector< short > &adc, unsigned int &zerothreshold)
void	ZeroSuppression (std::vector< short > &adc, unsigned int &zerothreshold, int &nearestneighbor)
void	ZeroSuppression (std::vector< short > &adc, unsigned int &zerothreshold, int pedestal, int &nearestneighbor, bool fADCStickyCodeFeature)
void	ZeroSuppression (const boost::circular_buffer< std::vector< short >> &adcvec_neighbors, std::vector< short > &adc, unsigned int &zerothreshold, int &nearestneighbor)
void	ZeroSuppression (const boost::circular_buffer< std::vector< short >> &adcvec_neighbors, std::vector< short > &adc, unsigned int &zerothreshold, int pedestal, int &nearestneighbor, bool fADCStickyCodeFeature)
void	ZeroUnsuppression (const std::vector< short > &adc, std::vector< short > &uncompressed)
void	ZeroUnsuppression (const std::vector< short > &adc, std::vector< short > &uncompressed, int pedestal)
void	Uncompress (const std::vector< short > &adc, std::vector< short > &uncompressed, raw::Compress_t compress)
	Uncompresses a raw data buffer. More...
void	Uncompress (const std::vector< short > &adc, std::vector< short > &uncompressed, int pedestal, raw::Compress_t compress)
void	CompressHuffman (std::vector< short > &adc)
void	UncompressHuffman (const std::vector< short > &adc, std::vector< short > &uncompressed)
int	ADCStickyCodeCheck (const short adc_value, const int pedestal, bool fADCStickyCodeFeature)
void	add_to_sequence_terminate (std::vector< bool > array, std::vector< bool > &cmp)
void	CompressFibonacci (std::vector< short > &wf, std::function< void(int, std::vector< std::vector< bool >> &)> add_to_table)
void	UncompressFibonacci (const std::vector< short > &adc, std::vector< short > &uncompressed, std::function< int(std::vector< bool > &)> decode_table_chunk)
void	fibonacci_encode_table (int end, std::vector< std::vector< bool >> &table)
short	fibonacci_decode (std::vector< bool > &chunk)

Variables
constexpr ChannelID_t	InvalidChannelID = std::numeric_limits<ChannelID_t>::max()
	ID of an invalid channel. More...
const unsigned int	onemask

Detailed Description

Raw data description.

Raw data description and utilities.

Typedef Documentation

typedef short raw::ADC_Count_t

Definition at line 20 of file OpDetWaveform.h.

typedef enum raw::_auxdettype raw::AuxDetType_t

typedef unsigned int raw::Channel_t

Definition at line 21 of file OpDetWaveform.h.

typedef unsigned int raw::ChannelID_t

Type representing the ID of a readout channel.

Definition at line 28 of file RawTypes.h.

typedef enum raw::_compress raw::Compress_t

typedef int raw::TDCtick_t

Type representing a TDC tick.

Definition at line 25 of file RawTypes.h.

typedef double raw::TimeStamp_t

us since 1970, based on TimeService

Definition at line 22 of file OpDetWaveform.h.

typedef long long raw::TriggerTimeStamp_t

type of trigger time stamp

Definition at line 13 of file ExternalTrigger.h.

Enumeration Type Documentation

enum raw::_auxdettype

Enumerator
kUnknownAuxDet	no idea
kScintillator	Scintillator paddle.
kTimeOfFlight	Time of flight.
kCherenkov	Cherenkov counter.

Definition at line 17 of file RawTypes.h.

                           {
    kUnknownAuxDet, 
    kScintillator,  
    kTimeOfFlight,  
    kCherenkov      
  } AuxDetType_t;

enum raw::_compress

Enumerator
kNone	no compression
kHuffman	Huffman Encoding.
kZeroSuppression	Zero Suppression algorithm.
kZeroHuffman	Zero Suppression followed by Huffman Encoding.
kDynamicDec	Dynamic decimation.
kFibonacci	Fibonacci encoding.

Definition at line 8 of file RawTypes.h.

                         {
    kNone,            
    kHuffman,         
    kZeroSuppression, 
    kZeroHuffman,     
    kDynamicDec,      
    kFibonacci        
  } Compress_t;

Function Documentation

int raw::ADCStickyCodeCheck	(	const short	adc_value,
		const int	pedestal,
		bool	fADCStickyCodeFeature
	)

Definition at line 1153 of file raw.cxx.

References util::abs(), and onemask.

Referenced by ZeroSuppression().

  {

    int adc_return_value = std::abs(adc_value - pedestal);

    if (!fADCStickyCodeFeature) { return adc_return_value; }
    // if DUNE 35t ADC sticky code feature is enabled in simulation, skip over ADC codes with LSBs of 0x00 or 0x3f
    unsigned int sixlsbs = adc_value & onemask;

    if ((sixlsbs == onemask || sixlsbs == 0) && std::abs(adc_value - pedestal) < 64) {
      adc_return_value =
        0; //set current adc value to zero if its LSBs are at sticky values and if it is within one MSB cell (64 ADC counts) of the pedestal value
    }
    return adc_return_value;
  }

void raw::add_to_sequence_terminate ( std::vector< bool >  array, std::vector< bool > &  cmp  )

inline

Definition at line 1169 of file raw.cxx.

Referenced by CompressFibonacci().

  {
    cmp.insert(cmp.end(), array.begin(), array.end());
    cmp.push_back(1);
  }

void raw::Compress	(	std::vector< short > &	adc,
		raw::Compress_t	compress
	)

Compresses a raw data buffer.

Parameters

adc	buffer with uncompressed data
compress	type of compression to be applied

This function dispatches the compression to the function appropriate for the specified compression type. The resulting compressed data replaces the input buffer content, which is lost. Compression is expected to reduce the size of the data, so that there is in principle no need for reallocation of the input buffer, adc, to store the result.

Definition at line 19 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

Referenced by detsim::SimWireAna::analyze(), and detsim::SimWire::produce().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroHuffman) {
      unsigned int zerothreshold = 5;
      ZeroSuppression(adc, zerothreshold);
      CompressHuffman(adc);
    }
    else if (compress == raw::kZeroSuppression) {
      unsigned int zerothreshold = 5;
      ZeroSuppression(adc, zerothreshold);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	std::vector< short > &	adc,
		raw::Compress_t	compress,
		int &	nearestneighbor
	)

Definition at line 39 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroHuffman) {
      unsigned int zerothreshold = 5;
      ZeroSuppression(adc, zerothreshold, nearestneighbor);
      CompressHuffman(adc);
    }
    else if (compress == raw::kZeroSuppression) {
      unsigned int zerothreshold = 5;
      ZeroSuppression(adc, zerothreshold, nearestneighbor);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	std::vector< short > &	adc,
		raw::Compress_t	compress,
		unsigned int &	zerothreshold
	)

Definition at line 60 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);

    else if (compress == raw::kZeroSuppression)
      ZeroSuppression(adc, zerothreshold);
    else if (compress == raw::kZeroHuffman) {
      ZeroSuppression(adc, zerothreshold);
      CompressHuffman(adc);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	std::vector< short > &	adc,
		raw::Compress_t	compress,
		unsigned int &	zerothreshold,
		int &	nearestneighbor
	)

Definition at line 78 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroSuppression)
      ZeroSuppression(adc, zerothreshold, nearestneighbor);
    else if (compress == raw::kZeroHuffman) {
      ZeroSuppression(adc, zerothreshold, nearestneighbor);
      CompressHuffman(adc);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	const boost::circular_buffer< std::vector< short >> &	adcvec_neighbors,
		std::vector< short > &	adc,
		raw::Compress_t	compress,
		unsigned int &	zerothreshold,
		int &	nearestneighbor
	)

Definition at line 99 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroSuppression)
      ZeroSuppression(adcvec_neighbors, adc, zerothreshold, nearestneighbor);
    else if (compress == raw::kZeroHuffman) {
      ZeroSuppression(adcvec_neighbors, adc, zerothreshold, nearestneighbor);
      CompressHuffman(adc);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	std::vector< short > &	adc,
		raw::Compress_t	compress,
		unsigned int &	zerothreshold,
		int	pedestal,
		int &	nearestneighbor,
		bool	fADCStickyCodeFeature
	)

Definition at line 121 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroSuppression)
      ZeroSuppression(adc, zerothreshold, pedestal, nearestneighbor, fADCStickyCodeFeature);
    else if (compress == raw::kZeroHuffman) {
      ZeroSuppression(adc, zerothreshold, pedestal, nearestneighbor, fADCStickyCodeFeature);
      CompressHuffman(adc);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::Compress	(	const boost::circular_buffer< std::vector< short >> &	adcvec_neighbors,
		std::vector< short > &	adc,
		raw::Compress_t	compress,
		unsigned int &	zerothreshold,
		int	pedestal,
		int &	nearestneighbor,
		bool	fADCStickyCodeFeature
	)

Definition at line 144 of file raw.cxx.

References CompressFibonacci(), CompressHuffman(), kFibonacci, kHuffman, kZeroHuffman, kZeroSuppression, and ZeroSuppression().

  {
    if (compress == raw::kHuffman)
      CompressHuffman(adc);
    else if (compress == raw::kZeroSuppression)
      ZeroSuppression(
        adcvec_neighbors, adc, zerothreshold, pedestal, nearestneighbor, fADCStickyCodeFeature);
    else if (compress == raw::kZeroHuffman) {
      ZeroSuppression(
        adcvec_neighbors, adc, zerothreshold, pedestal, nearestneighbor, fADCStickyCodeFeature);
      CompressHuffman(adc);
    }
    else if (compress == raw::kFibonacci) {
      CompressFibonacci(adc);
    }

    return;
  }

void raw::CompressFibonacci

(

std::vector< short > &

wf

)

Definition at line 1175 of file raw.cxx.

References add_to_sequence_terminate(), d, util::empty(), and util::end().

Referenced by Compress().

  {

    std::vector<std::vector<bool>> table;
    add_to_table(100, table);

    std::vector<short> comp_short;
    // First numbers are not encoded (size and baseline)
    assert(not empty(wf));

    unsigned int size_short = sizeof(wf[0]) * 8 - 1; // assuming we don't encode over the sign bits
    unsigned int max_2_short =
      (1 << (size_short *
             2)); //this number is then: 1,073,741,824 (i.e. almost 9min of data at 2MHz)
    size_t wf_size = wf.size();

    if (wf_size > max_2_short) {
      throw cet::exception("raw")
        << "WOW! You are trying to compress a " << wf_size << " long waveform"
        << " in a vector of shorts.\nUnfortunately, the encoded waveform needs to store the size"
        << " of the wavefom (in its first number) and " << wf_size
        << " is bigger than the maximum\n"
        << " number you can encode with 2 shorts (" << max_2_short << ").\n"
        << " Bailing out disgracefully to avoid massive trouble.\n";
    }

    short high = (wf_size >> (sizeof(short) * 8 - 1));
    short low = wf_size % ((std::numeric_limits<short>::max() + 1));
    comp_short.push_back(high);
    comp_short.push_back(low);
    comp_short.push_back(*wf.begin());

    // The format we are working with
    std::vector<bool> cmp;
    cmp.reserve(wf.size() * sizeof(wf[0]) * 8);

    // The input is changed to be the difference between ticks
    std::vector<short> diff;
    diff.reserve(wf.size());
    // Fibonacci number are positive, so need a way to get negative number
    // We use the ZigZag approach (even numbers are positive, odd are negative)
    std::adjacent_difference(
      wf.begin(), wf.end(), std::back_inserter(diff), [](const short& it1, const short& it2) {
        short d = it1 - it2;
        if (d > 0)
          d = 2 * d;
        else
          d = -2 * d + 1;
        return d;
      });

    // Start from 1 to avoid the first number
    for (size_t iSample = 1; iSample < diff.size(); ++iSample) {

      short d = diff[iSample];
      if ((unsigned)d < table.size()) { add_to_sequence_terminate(table[d], cmp); }
      else { // catch if the table is too small...
        int end = d + 1;
        // use the user provided function to fill the table
        add_to_table(end, table);
        // and add again to the sequence
        add_to_sequence_terminate(table[d], cmp);
      }
    }

    // Now convert all this to a vector of short and it's just another day in paradise for larsoft
    size_t n_vector = cmp.size();

    // Create a bitset of the size of the short to simplify things
    std::bitset<8 * sizeof(short)> this_encoded;
    // Set the bitset to match the stream
    size_t bit_counter = 0;

    for (size_t it = 0; it < n_vector; ++it) {

      if (bit_counter >= 8 * sizeof(short)) {
        short comp_s = (short)this_encoded.to_ulong();
        comp_short.push_back(comp_s);
        bit_counter = 0;
        this_encoded.reset();
      }

      if (cmp[it]) this_encoded.set(bit_counter);

      bit_counter++;
    }

    // Deal with the last part
    short comp_s = (short)this_encoded.to_ulong();
    comp_short.push_back(comp_s);

    wf = comp_short;

    return;
  }

void raw::CompressHuffman

(

std::vector< short > &

adc

)

Definition at line 818 of file raw.cxx.

Referenced by Compress().

  {
    std::vector<short> const orig_adc(std::move(adc));

    // diffs contains the difference between an element of adc and the previous
    // one; the first entry is never used.
    std::vector<short> diffs;
    diffs.reserve(orig_adc.size());
    std::adjacent_difference(orig_adc.begin(), orig_adc.end(), std::back_inserter(diffs));

    // prepare adc for the new data; we kind-of-expect the size,
    // so we pre-allocate it; we might want to shrink-to-fit at the end
    adc.clear();
    adc.reserve(orig_adc.size());
    // now loop over the diffs and do the Huffman encoding
    adc.push_back(orig_adc.front());
    unsigned int curb = 15U;

    std::bitset<16> bset;
    bset.set(15);

    for (size_t i = 1U; i < diffs.size(); ++i) {

      switch (diffs[i]) {
      // if the difference is 0, check to see what the next 3 differences are
      case 0: {
        if (i < diffs.size() - 3) {
          // if next 3 are also 0, set the next bit to be 1
          if (diffs[i + 1] == 0 && diffs[i + 2] == 0 && diffs[i + 3] == 0) {
            if (curb > 0) {
              --curb;
              bset.set(curb);
              i += 3;
              continue;
            }
            else {
              adc.push_back(bset.to_ulong());

              // reset the bitset to be ready for the next word
              bset.reset();
              bset.set(15);
              bset.set(14); // account for the fact that this is a zero diff
              curb = 14;
              i += 3;
              continue;
            } // end if curb is not big enough to put current difference in bset
          }   // end if next 3 are also zero
          else {
            // 0 diff is encoded as 01, so move the current bit one to the right
            if (curb > 1) {
              curb -= 2;
              bset.set(curb);
              continue;
            } // end if the current bit is large enough to set this one
            else {
              adc.push_back(bset.to_ulong());
              // reset the bitset to be ready for the next word
              bset.reset();
              bset.set(15);
              bset.set(13); // account for the fact that this is a zero diff
              curb = 13;
              continue;
            } // end if curb is not big enough to put current difference in bset
          }   // end if next 3 are not also 0
        }     // end if able to check next 3
        else {
          // 0 diff is encoded as 01, so move the current bit one to the right
          if (curb > 1) {
            curb -= 2;
            bset.set(curb);
            continue;
          } // end if the current bit is large enough to set this one
          else {
            adc.push_back(bset.to_ulong());
            // reset the bitset to be ready for the next word
            bset.reset();
            bset.set(15);
            bset.set(13); // account for the fact that this is a zero diff
            curb = 13;
            continue;
          } // end if curb is not big enough to put current difference in bset
        }   // end if not able to check the next 3
        break;
      } // end if current difference is zero
      case 1: {
        if (curb > 2) {
          curb -= 3;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(12); // account for the fact that this is a +1 diff
          curb = 12;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = 1
      case -1: {
        if (curb > 3) {
          curb -= 4;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(11); // account for the fact that this is a -1 diff
          curb = 11;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = -1
      case 2: {
        if (curb > 4) {
          curb -= 5;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(10); // account for the fact that this is a +2 diff
          curb = 10;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = 2
      case -2: {
        if (curb > 5) {
          curb -= 6;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(9); // account for the fact that this is a -2 diff
          curb = 9;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = -2
      case 3: {
        if (curb > 6) {
          curb -= 7;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(8); // account for the fact that this is a +3 diff
          curb = 8;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = 3
      case -3: {
        if (curb > 7) {
          curb -= 8;
          bset.set(curb);
        }
        else {
          adc.push_back(bset.to_ulong());
          // reset the bitset to be ready for the next word
          bset.reset();
          bset.set(15);
          bset.set(7); // account for the fact that this is a -3 diff
          curb = 7;
        } // end if curb is not big enough to put current difference in bset
        break;
      } // end if difference = -3
      default: {
        // if the difference is too large that we have to put the entire adc value in:
        // put the current value into the adc vec unless the current bit is 15, then there
        // were multiple large difference values in a row
        if (curb != 15) { adc.push_back(bset.to_ulong()); }

        bset.reset();
        bset.set(15);
        curb = 15;

        // put the current adcvalue in adc, with its bit 15 set to 0
        if (orig_adc[i] > 0)
          adc.push_back(orig_adc[i]);
        else {
          std::bitset<16> tbit(-orig_adc[i]);
          tbit.set(14);
          adc.push_back(tbit.to_ulong());
        }
        break;
      } // if |difference| > 3
      } // switch diff[i]
    }   // end loop over differences

    //write out the last bitset
    adc.push_back(bset.to_ulong());

    // this would reduce global memory usage,
    // at the cost of a new allocation and copy
    //  adc.shrink_to_fit();

  } // CompressHuffman()

short raw::fibonacci_decode

(

std::vector< bool > &

chunk

)

Definition at line 1368 of file raw.cxx.

  {
    std::vector<int> FibNumbers = {1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987};

    if (chunk.size() > FibNumbers.size()) {
      for (int i = FibNumbers.size(); i <= (int)chunk.size(); ++i) {
        FibNumbers.push_back(FibNumbers.at(i - 1) + FibNumbers.at(i - 2));
      }
    }
    short decoded = 0;
    for (size_t it = 0; it < chunk.size(); ++it) {
      if (chunk[it]) decoded += FibNumbers[it];
    }
    return decoded;
  }

void raw::fibonacci_encode_table	(	int	end,
		std::vector< std::vector< bool >> &	table
	)

Definition at line 1321 of file raw.cxx.

References util::empty(), util::end(), and lar::dump::vector().

  {
    if ((int)table.size() > end) return;

    std::map<int, int> fibn; // no need for this to be static
    fibn[0] = 0;
    fibn[1] = 1;
    fibn[2] = 1;

    // if the table was empty, fill it
    if (empty(table)) {
      table.push_back(
        std::vector<
          bool>()); // we need this one so that the index of the vector is the same as the number we want to encode
      table.push_back({true});
      table.push_back({false, true});
    }

    if ((int)table.size() > end) return;

    // start at the third fibonacci number
    for (int i = 2; fibn.rbegin()->second < end; ++i) {
      fibn[i] = fibn[i - 1] + fibn[i - 2];
    }

    for (int i = table.size(); i <= end; ++i) {
      int current_number = i;
      std::vector<bool> seq; // the final sequence of numbers
      while (current_number > 0) {
        // find the biggest fibonacci number that is smaller than the current number
        for (auto fib = fibn.rbegin(); fib != fibn.rend(); ++fib) {
          if (fib->second <= current_number) {
            // if this is the first number, create the vector
            if (!seq.size()) seq = std::vector<bool>(fib->first - 1, false);
            // fill the sequence
            seq[fib->first - 2] = true;
            // subtract the current number
            current_number -= fib->second;
            break;
          }
        }
      }

      table.push_back(seq);
    }
  }

constexpr bool raw::isValidChannelID ( raw::ChannelID_t  channel )

inline

Returns whether the specified channel ID is valid

Note

This does not mean that channel exists in the current geometry.

Definition at line 35 of file RawTypes.h.

References InvalidChannelID.

Referenced by geo::DumpChannelMap::beginRun(), geo::ChannelMapStandardAlg::ChannelToROP(), lariov::SimpleChannelStatus::FillGoodChannels(), evd::RawDataDrawer::FillTQHisto(), geo::ChannelMapAlg::HasChannel(), and lariov::SimpleChannelStatus::IsPresent().

  {
    return channel != InvalidChannelID;
  }

bool raw::operator< ( const OpDetWaveform &  lhs, const OpDetWaveform &  rhs  )

inline

Definition at line 60 of file OpDetWaveform.h.

References raw::OpDetWaveform::ChannelNumber(), and raw::OpDetWaveform::TimeStamp().

  {
    // Sort by channel, then time
    if (lhs.ChannelNumber() < rhs.ChannelNumber()) return true;
    if (lhs.ChannelNumber() > rhs.ChannelNumber()) return false;

    return (lhs.TimeStamp() < rhs.TimeStamp());
  }

std::ostream& raw::operator<<	(	std::ostream &	os,
		const raw::BeamInfo &	o
	)

Definition at line 110 of file BeamInfo.cxx.

References raw::BeamInfo::GetDataMap(), raw::BeamInfo::GetMilliSeconds(), raw::BeamInfo::GetNumberOfDevices(), raw::BeamInfo::GetRecordType(), and raw::BeamInfo::GetSeconds().

  {

    os << "Record type:" << o.GetRecordType() << std::endl;
    ;
    os << "Timestamp: " << o.GetSeconds() << "\t" << o.GetMilliSeconds() << std::endl;
    os << "Number of Devices: " << o.GetNumberOfDevices() << std::endl;

    const std::map<std::string, std::vector<double>> dm = o.GetDataMap();
    std::map<std::string, std::vector<double>>::const_iterator it = dm.begin();
    while (it != dm.end()) {
      os << it->first << ": ";
      for (size_t i = 0; i < it->second.size(); i++)
        os << it->second[i] << ", ";
      os << std::endl;
      it++;
    }

    return os;
  }

void raw::Uncompress	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed,
		raw::Compress_t	compress
	)

Uncompresses a raw data buffer.

Parameters

adc	compressed buffer
uncompressed	buffer to be filled with uncompressed data
compress	type of compression in the adc buffer

This function dispatches the uncompression to the correct uncompress function according to compression type in compress.

The uncompressed buffer must be already allocated with enough space to store the full inflated adc data. Uncompressing raw::RawDigit can be done as follows:

std::vector<ADC_t> uncompressed(digit.Samples(), 0);
raw::Uncompress(digit.ADC(), uncompressed, digit.ADC());

Definition at line 744 of file raw.cxx.

References kFibonacci, kHuffman, kNone, kZeroHuffman, kZeroSuppression, tmp, UncompressFibonacci(), UncompressHuffman(), and ZeroUnsuppression().

Referenced by detsim::SimWireAna::analyze(), nnet::WaveformDenoiseTest::analyze(), nnet::NoiseWaveformDump::analyze(), nnet::RawWaveformDump::analyze(), nnet::RawWaveformClnSigDump::analyze(), evdb_tool::DrawRawHist::Fill(), filter::ADCFilter::filter(), detsim::DumpRawDigits::PrintRawDigit(), wc::CellTree::processRaw(), hit::RawHitFinder::produce(), caldata::CalWire::produce(), caldata::CalWireT962::produce(), nnet::WaveformRoiFinder::produce(), and evd::details::RawDigitInfo_t::UncompressData().

  {
    if (compress == raw::kHuffman)
      UncompressHuffman(adc, uncompressed);
    else if (compress == raw::kZeroSuppression) {
      ZeroUnsuppression(adc, uncompressed);
    }
    else if (compress == raw::kZeroHuffman) {
      std::vector<short> tmp(2 * adc[0]);
      UncompressHuffman(adc, tmp);
      ZeroUnsuppression(tmp, uncompressed);
    }
    else if (compress == raw::kNone) {
      for (unsigned int i = 0; i < adc.size(); ++i)
        uncompressed[i] = adc[i];
    }
    else if (compress == raw::kFibonacci) {
      UncompressFibonacci(adc, uncompressed);
    }
    else {
      throw cet::exception("raw") << "raw::Uncompress() does not support compression #"
                                  << ((int)compress);
    }
    return;
  }

void raw::Uncompress	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed,
		int	pedestal,
		raw::Compress_t	compress
	)

Definition at line 774 of file raw.cxx.

References kFibonacci, kHuffman, kNone, kZeroHuffman, kZeroSuppression, tmp, UncompressFibonacci(), UncompressHuffman(), and ZeroUnsuppression().

  {
    if (compress == raw::kHuffman)
      UncompressHuffman(adc, uncompressed);
    else if (compress == raw::kZeroSuppression) {
      ZeroUnsuppression(adc, uncompressed, pedestal);
    }
    else if (compress == raw::kZeroHuffman) {
      std::vector<short> tmp(2 * adc[0]);
      UncompressHuffman(adc, tmp);
      ZeroUnsuppression(tmp, uncompressed, pedestal);
    }
    else if (compress == raw::kNone) {
      for (unsigned int i = 0; i < adc.size(); ++i)
        uncompressed[i] = adc[i];
    }
    else if (compress == raw::kFibonacci) {
      UncompressFibonacci(adc, uncompressed);
    }
    else {
      throw cet::exception("raw") << "raw::Uncompress() does not support compression #"
                                  << ((int)compress);
    }
    return;
  }

void raw::UncompressFibonacci	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed,
		std::function< int(std::vector< bool > &)>	decode_table_chunk
	)

Definition at line 1272 of file raw.cxx.

Referenced by Uncompress().

  {

    // First compressed sample is the size
    size_t n_samples = (adc[0] << (sizeof(short) * 8 - 1)) + adc[1];
    // The second compressed sample is the first uncompressed sample
    uncompressed.push_back(adc[2]);

    // The thing that we want to decode (rather than jumbled short vector)
    std::vector<bool> comp;

    for (size_t i = 3; i < adc.size(); ++i) {

      std::bitset<8 * sizeof(short)> this_encoded(adc[i]);
      for (size_t i2 = 0; i2 < this_encoded.size(); ++i2) {
        comp.push_back(this_encoded[i2]);
      }
    }

    // The bit which has to be decoded ("chunk")
    std::vector<bool> current_number;
    for (size_t it = 0; it < comp.size(); ++it) {
      current_number.push_back(comp[it]);
      // If we have at least 2 numbers in the current chunk
      // and if the last 2 number are one
      // and if we are not at the end
      if ((current_number.size() >= 2 && it >= 1 && comp[it - 1] == 1 && comp[it] == 1) ||
          it == comp.size() - 1) {
        current_number.pop_back();
        short zigzag_number = decode_table_chunk(current_number);

        short decoded = 0;
        if (zigzag_number % 2 == 0)
          decoded = zigzag_number / 2;
        else
          decoded = -(zigzag_number - 1) / 2;
        short baseline = uncompressed.back();

        uncompressed.push_back(baseline + decoded);

        current_number.clear();
        if (uncompressed.size() == n_samples) break;
      }
    }
    return;
  }

void raw::UncompressHuffman	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed
	)

Definition at line 1026 of file raw.cxx.

Referenced by Uncompress().

  {

    //the first entry in adc is a data value by construction
    uncompressed[0] = adc[0];

    unsigned int curu = 1;
    short curADC = uncompressed[0];

    // loop over the entries in adc and uncompress them according to the
    // encoding scheme above the CompressHuffman method
    for (unsigned int i = 1; i < adc.size() && curu < uncompressed.size(); ++i) {

      std::bitset<16> bset(adc[i]);

      int numu = 0;

      //check the 15 bit to see if this entry is a full data value or not
      if (!bset.test(15)) {
        curADC = adc[i];
        if (bset.test(14)) {
          bset.set(14, false);
          curADC = -1 * bset.to_ulong();
        }
        uncompressed[curu] = curADC;

        ++curu;
      }
      else {

        int b = 14;
        int lowestb = 0;

        // ignore any padding with zeros in the lower order bits
        while (!bset.test(lowestb) && lowestb < 15)
          ++lowestb;

        if (lowestb > 14) {
          mf::LogWarning("raw.cxx")
            << "encoded entry has no set bits!!! " << i << " "
            << bset.to_string<char, std::char_traits<char>, std::allocator<char>>();
          continue;
        }

        while (b >= lowestb) {

          // count the zeros between the current bit and the next on bit
          int zerocnt = 0;
          while (!bset.test(b - zerocnt) && b - zerocnt > lowestb)
            ++zerocnt;

          b -= zerocnt;

          if (zerocnt == 0) {
            for (int s = 0; s < 4; ++s) {
              uncompressed[curu] = curADC;
              ++curu;
              ++numu;
              if (curu > uncompressed.size() - 1) break;
            }
            --b;
          }
          else if (zerocnt == 1) {
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 2) {
            curADC += 1;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 3) {
            curADC -= 1;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 4) {
            curADC += 2;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 5) {
            curADC -= 2;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 6) {
            curADC += 3;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }
          else if (zerocnt == 7) {
            curADC -= 3;
            uncompressed[curu] = curADC;
            ++curu;
            ++numu;
            --b;
          }

          if (curu > uncompressed.size() - 1) break;

        } // end loop over bits

        if (curu > uncompressed.size() - 1) break;

      } // end if this entry in the vector is encoded

    } // end loop over entries in adc

    return;
  }

void raw::ZeroSuppression	(	std::vector< short > &	adc,
		unsigned int &	zerothreshold
	)

Definition at line 171 of file raw.cxx.

References util::abs().

Referenced by Compress().

  {
    const int adcsize = adc.size();
    const int zerothresholdsigned = zerothreshold;

    std::vector<short> zerosuppressed(adc.size());
    int maxblocks = adcsize / 2 + 1;
    std::vector<short> blockbegin(maxblocks);
    std::vector<short> blocksize(maxblocks);

    unsigned int nblocks = 0;
    unsigned int zerosuppressedsize = 0;

    int blockcheck = 0;

    for (int i = 0; i < adcsize; ++i) {
      int adc_current_value = std::abs(adc[i]);

      if (adc_current_value > zerothresholdsigned) {

        if (blockcheck == 0) {

          blockbegin[nblocks] = i;
          blocksize[nblocks] = 0;
          blockcheck = 1;
        }

        zerosuppressed[zerosuppressedsize] = adc[i];
        zerosuppressedsize++;
        blocksize[nblocks]++;

        if (i == adcsize - 1) nblocks++;
      }

      if (adc_current_value <= zerothresholdsigned && blockcheck == 1) {
        zerosuppressed[zerosuppressedsize] = adc[i];
        zerosuppressedsize++;
        blocksize[nblocks]++;
        nblocks++;
        blockcheck = 0;
      }
    }

    adc.resize(2 + nblocks + nblocks + zerosuppressedsize);

    adc[0] = adcsize; //fill first entry in adc with length of uncompressed vector
    adc[1] = nblocks;

    for (unsigned int i = 0; i < nblocks; ++i)
      adc[i + 2] = blockbegin[i];

    for (unsigned int i = 0; i < nblocks; ++i)
      adc[i + nblocks + 2] = blocksize[i];

    for (unsigned int i = 0; i < zerosuppressedsize; ++i)
      adc[i + nblocks + nblocks + 2] = zerosuppressed[i];
  }

void raw::ZeroSuppression	(	std::vector< short > &	adc,
		unsigned int &	zerothreshold,
		int &	nearestneighbor
	)

Definition at line 232 of file raw.cxx.

References util::abs().

  {

    const int adcsize = adc.size();
    const int zerothresholdsigned = zerothreshold;

    std::vector<short> zerosuppressed(adcsize);
    int maxblocks = adcsize / 2 + 1;
    std::vector<short> blockbegin(maxblocks);
    std::vector<short> blocksize(maxblocks);

    int nblocks = 0;
    int zerosuppressedsize = 0;

    int blockstartcheck = 0;
    int endofblockcheck = 0;

    for (int i = 0; i < adcsize; ++i) {
      int adc_current_value = std::abs(adc[i]);

      if (blockstartcheck == 0) {
        if (adc_current_value > zerothresholdsigned) {
          if (nblocks > 0) {
            if ((i - nearestneighbor) <= (blockbegin[nblocks - 1] + blocksize[nblocks - 1] + 1)) {

              nblocks--;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
            else {
              blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
          }
          else {
            blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
            blocksize[nblocks] = i - blockbegin[nblocks] + 1;
            blockstartcheck = 1;
          }
        }
      }
      else if (blockstartcheck == 1) {
        if (adc_current_value > zerothresholdsigned) {
          blocksize[nblocks]++;
          endofblockcheck = 0;
        }
        else {
          if (endofblockcheck < nearestneighbor) {
            endofblockcheck++;
            blocksize[nblocks]++;
          }
          //block has ended
          else if (i + 2 < adcsize) { //check if end of adc vector is near
            if (std::abs(adc[i + 1]) <= zerothresholdsigned &&
                std::abs(adc[i + 2]) <= zerothresholdsigned) {
              endofblockcheck = 0;
              blockstartcheck = 0;
              nblocks++;
            }
          }

        } // end else
      }   // end if blockstartcheck == 1
    }     // end loop over adc size

    if (blockstartcheck == 1) { // we reached the end of the adc vector with the block still going
      ++nblocks;
    }

    for (int i = 0; i < nblocks; ++i)
      zerosuppressedsize += blocksize[i];

    adc.resize(2 + nblocks + nblocks + zerosuppressedsize);
    zerosuppressed.resize(2 + nblocks + nblocks + zerosuppressedsize);

    int zerosuppressedcount = 0;
    for (int i = 0; i < nblocks; ++i) {
      //zerosuppressedsize += blocksize[i];
      for (int j = 0; j < blocksize[i]; ++j) {
        zerosuppressed[zerosuppressedcount] = adc[blockbegin[i] + j];
        zerosuppressedcount++;
      }
    }

    adc[0] = adcsize; //fill first entry in adc with length of uncompressed vector
    adc[1] = nblocks;
    for (int i = 0; i < nblocks; ++i) {
      adc[i + 2] = blockbegin[i];
      adc[i + nblocks + 2] = blocksize[i];
    }

    for (int i = 0; i < zerosuppressedsize; ++i)
      adc[i + nblocks + nblocks + 2] = zerosuppressed[i];

    // for(int i = 0; i < 2 + 2*nblocks + zerosuppressedsize; ++i)
    //   std::cout << adc[i] << std::endl;
    //adc.resize(2+nblocks+nblocks+zerosuppressedsize);
  }

void raw::ZeroSuppression	(	std::vector< short > &	adc,
		unsigned int &	zerothreshold,
		int	pedestal,
		int &	nearestneighbor,
		bool	fADCStickyCodeFeature
	)

Definition at line 336 of file raw.cxx.

References ADCStickyCodeCheck().

  {

    const int adcsize = adc.size();
    const int zerothresholdsigned = zerothreshold;

    std::vector<short> zerosuppressed(adcsize);
    int maxblocks = adcsize / 2 + 1;
    std::vector<short> blockbegin(maxblocks);
    std::vector<short> blocksize(maxblocks);

    int nblocks = 0;
    int zerosuppressedsize = 0;

    int blockstartcheck = 0;
    int endofblockcheck = 0;

    for (int i = 0; i < adcsize; ++i) {
      int adc_current_value = ADCStickyCodeCheck(adc[i], pedestal, fADCStickyCodeFeature);

      if (blockstartcheck == 0) {
        if (adc_current_value > zerothresholdsigned) {
          if (nblocks > 0) {
            if (i - nearestneighbor <= blockbegin[nblocks - 1] + blocksize[nblocks - 1] + 1) {
              nblocks--;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
            else {
              blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
          }
          else {
            blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
            blocksize[nblocks] = i - blockbegin[nblocks] + 1;
            blockstartcheck = 1;
          }
        }
      }
      else if (blockstartcheck == 1) {
        if (adc_current_value > zerothresholdsigned) {
          blocksize[nblocks]++;
          endofblockcheck = 0;
        }
        else {
          if (endofblockcheck < nearestneighbor) {
            endofblockcheck++;
            blocksize[nblocks]++;
          }
          //block has ended
          else if (i + 2 < adcsize) { //check if end of adc vector is near
            if (ADCStickyCodeCheck(adc[i + 1], pedestal, fADCStickyCodeFeature) <=
                  zerothresholdsigned &&
                ADCStickyCodeCheck(adc[i + 2], pedestal, fADCStickyCodeFeature) <=
                  zerothresholdsigned) {
              endofblockcheck = 0;
              blockstartcheck = 0;
              nblocks++;
            }
          }
        } // end else
      }   // end if blockstartcheck == 1
    }     // end loop over adc size

    if (blockstartcheck == 1) { // we reached the end of the adc vector with the block still going
      ++nblocks;
    }

    for (int i = 0; i < nblocks; ++i)
      zerosuppressedsize += blocksize[i];

    adc.resize(2 + nblocks + nblocks + zerosuppressedsize);
    zerosuppressed.resize(2 + nblocks + nblocks + zerosuppressedsize);

    int zerosuppressedcount = 0;
    for (int i = 0; i < nblocks; ++i) {
      //zerosuppressedsize += blocksize[i];
      for (int j = 0; j < blocksize[i]; ++j) {
        zerosuppressed[zerosuppressedcount] = adc[blockbegin[i] + j];
        zerosuppressedcount++;
      }
    }

    adc[0] = adcsize; //fill first entry in adc with length of uncompressed vector
    adc[1] = nblocks;
    for (int i = 0; i < nblocks; ++i) {
      adc[i + 2] = blockbegin[i];
      adc[i + nblocks + 2] = blocksize[i];
    }

    for (int i = 0; i < zerosuppressedsize; ++i)
      adc[i + nblocks + nblocks + 2] = zerosuppressed[i];

    // for(int i = 0; i < 2 + 2*nblocks + zerosuppressedsize; ++i)
    //   std::cout << adc[i] << std::endl;
    //adc.resize(2+nblocks+nblocks+zerosuppressedsize);
  }

void raw::ZeroSuppression	(	const boost::circular_buffer< std::vector< short >> &	adcvec_neighbors,
		std::vector< short > &	adc,
		unsigned int &	zerothreshold,
		int &	nearestneighbor
	)

Definition at line 444 of file raw.cxx.

References util::abs().

  {

    const int adcsize = adc.size();
    const int zerothresholdsigned = zerothreshold;

    std::vector<short> zerosuppressed(adcsize);
    const int maxblocks = adcsize / 2 + 1;
    std::vector<short> blockbegin(maxblocks);
    std::vector<short> blocksize(maxblocks);

    int nblocks = 0;
    int zerosuppressedsize = 0;

    int blockstartcheck = 0;
    int endofblockcheck = 0;

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

      //find maximum adc value among all neighboring channels within the nearest neighbor channel distance

      int adc_current_value = 0;

      for (boost::circular_buffer<std::vector<short>>::const_iterator adcveciter =
             adcvec_neighbors.begin();
           adcveciter != adcvec_neighbors.end();
           ++adcveciter) {
        const std::vector<short>& adcvec_current = *adcveciter;
        const int adcvec_current_single = std::abs(adcvec_current[i]);

        if (adc_current_value < adcvec_current_single) {
          adc_current_value = adcvec_current_single;
        }
      }
      if (blockstartcheck == 0) {
        if (adc_current_value > zerothresholdsigned) {
          if (nblocks > 0) {
            if (i - nearestneighbor <= blockbegin[nblocks - 1] + blocksize[nblocks - 1] + 1) {
              nblocks--;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
            else {
              blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
          }
          else {
            blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
            blocksize[nblocks] = i - blockbegin[nblocks] + 1;
            blockstartcheck = 1;
          }
        }
      }
      else if (blockstartcheck == 1) {
        if (adc_current_value > zerothresholdsigned) {
          blocksize[nblocks]++;
          endofblockcheck = 0;
        }
        else {
          if (endofblockcheck < nearestneighbor) {
            endofblockcheck++;
            blocksize[nblocks]++;
          }
          //block has ended
          else if (i + 2 < adcsize) { //check if end of adc vector is near
            if (std::abs(adc[i + 1]) <= zerothresholdsigned &&
                std::abs(adc[i + 2]) <= zerothresholdsigned) {
              endofblockcheck = 0;
              blockstartcheck = 0;
              nblocks++;
            }
          }

        } // end else
      }   // end if blockstartcheck == 1
    }     // end loop over adc size

    if (blockstartcheck == 1) { // we reached the end of the adc vector with the block still going
      ++nblocks;
    }

    for (int i = 0; i < nblocks; ++i)
      zerosuppressedsize += blocksize[i];

    adc.resize(2 + nblocks + nblocks + zerosuppressedsize);
    zerosuppressed.resize(2 + nblocks + nblocks + zerosuppressedsize);

    int zerosuppressedcount = 0;
    for (int i = 0; i < nblocks; ++i) {
      //zerosuppressedsize += blocksize[i];
      for (int j = 0; j < blocksize[i]; ++j) {
        zerosuppressed[zerosuppressedcount] = adc[blockbegin[i] + j];
        zerosuppressedcount++;
      }
    }

    adc[0] = adcsize; //fill first entry in adc with length of uncompressed vector
    adc[1] = nblocks;
    for (int i = 0; i < nblocks; ++i) {
      adc[i + 2] = blockbegin[i];
      adc[i + nblocks + 2] = blocksize[i];
    }

    for (int i = 0; i < zerosuppressedsize; ++i)
      adc[i + nblocks + nblocks + 2] = zerosuppressed[i];

    // for(int i = 0; i < 2 + 2*nblocks + zerosuppressedsize; ++i)
    //   std::cout << adc[i] << std::endl;
    //adc.resize(2+nblocks+nblocks+zerosuppressedsize);
  }

void raw::ZeroSuppression	(	const boost::circular_buffer< std::vector< short >> &	adcvec_neighbors,
		std::vector< short > &	adc,
		unsigned int &	zerothreshold,
		int	pedestal,
		int &	nearestneighbor,
		bool	fADCStickyCodeFeature
	)

Definition at line 565 of file raw.cxx.

References util::abs(), and ADCStickyCodeCheck().

  {

    const int adcsize = adc.size();
    const int zerothresholdsigned = zerothreshold;

    std::vector<short> zerosuppressed(adcsize);
    const int maxblocks = adcsize / 2 + 1;
    std::vector<short> blockbegin(maxblocks);
    std::vector<short> blocksize(maxblocks);

    int nblocks = 0;
    int zerosuppressedsize = 0;

    int blockstartcheck = 0;
    int endofblockcheck = 0;

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

      //find maximum adc value among all neighboring channels within the nearest neighbor channel distance

      int adc_current_value = ADCStickyCodeCheck(adc[i], pedestal, fADCStickyCodeFeature);

      for (boost::circular_buffer<std::vector<short>>::const_iterator adcveciter =
             adcvec_neighbors.begin();
           adcveciter != adcvec_neighbors.end();
           ++adcveciter) {
        const std::vector<short>& adcvec_current = *adcveciter;
        const int adcvec_current_single = std::abs(adcvec_current[i] - pedestal);

        if (adc_current_value < adcvec_current_single) {
          adc_current_value = adcvec_current_single;
        }
      }
      if (blockstartcheck == 0) {
        if (adc_current_value > zerothresholdsigned) {
          if (nblocks > 0) {
            if (i - nearestneighbor <= blockbegin[nblocks - 1] + blocksize[nblocks - 1] + 1) {
              nblocks--;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
            else {
              blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
              blocksize[nblocks] = i - blockbegin[nblocks] + 1;
              blockstartcheck = 1;
            }
          }
          else {
            blockbegin[nblocks] = (i - nearestneighbor > 0) ? i - nearestneighbor : 0;
            blocksize[nblocks] = i - blockbegin[nblocks] + 1;
            blockstartcheck = 1;
          }
        }
      }
      else if (blockstartcheck == 1) {
        if (adc_current_value > zerothresholdsigned) {
          blocksize[nblocks]++;
          endofblockcheck = 0;
        }
        else {
          if (endofblockcheck < nearestneighbor) {
            endofblockcheck++;
            blocksize[nblocks]++;
          }
          //block has ended

          else if (i + 2 < adcsize) { //check if end of adc vector is near
            if (ADCStickyCodeCheck(adc[i + 1], pedestal, fADCStickyCodeFeature) <=
                  zerothresholdsigned &&
                ADCStickyCodeCheck(adc[i + 2], pedestal, fADCStickyCodeFeature) <=
                  zerothresholdsigned) {
              endofblockcheck = 0;
              blockstartcheck = 0;
              nblocks++;
            }
          }

        } // end else
      }   // end if blockstartcheck == 1
    }     // end loop over adc size

    if (blockstartcheck == 1) { // we reached the end of the adc vector with the block still going
      ++nblocks;
    }

    for (int i = 0; i < nblocks; ++i)
      zerosuppressedsize += blocksize[i];

    adc.resize(2 + nblocks + nblocks + zerosuppressedsize);
    zerosuppressed.resize(2 + nblocks + nblocks + zerosuppressedsize);

    int zerosuppressedcount = 0;
    for (int i = 0; i < nblocks; ++i) {
      //zerosuppressedsize += blocksize[i];
      for (int j = 0; j < blocksize[i]; ++j) {
        zerosuppressed[zerosuppressedcount] = adc[blockbegin[i] + j];
        zerosuppressedcount++;
      }
    }

    adc[0] = adcsize; //fill first entry in adc with length of uncompressed vector
    adc[1] = nblocks;
    for (int i = 0; i < nblocks; ++i) {
      adc[i + 2] = blockbegin[i];
      adc[i + nblocks + 2] = blocksize[i];
    }

    for (int i = 0; i < zerosuppressedsize; ++i)
      adc[i + nblocks + nblocks + 2] = zerosuppressed[i];

    // for(int i = 0; i < 2 + 2*nblocks + zerosuppressedsize; ++i)
    //   std::cout << adc[i] << std::endl;
    //adc.resize(2+nblocks+nblocks+zerosuppressedsize);
  }

void raw::ZeroUnsuppression	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed
	)

Definition at line 688 of file raw.cxx.

Referenced by Uncompress().

  {
    const int lengthofadc = adc[0];
    const int nblocks = adc[1];

    uncompressed.resize(lengthofadc);
    for (int i = 0; i < lengthofadc; ++i) {
      uncompressed[i] = 0;
    }

    int zerosuppressedindex = nblocks * 2 + 2;

    for (int i = 0; i < nblocks; ++i) { //loop over each nonzero block of the compressed vector

      for (int j = 0; j < adc[2 + nblocks + i]; ++j) { //loop over each block size

        //set uncompressed value
        uncompressed[adc[2 + i] + j] = adc[zerosuppressedindex];
        zerosuppressedindex++;
      }
    }

    return;
  }

void raw::ZeroUnsuppression	(	const std::vector< short > &	adc,
		std::vector< short > &	uncompressed,
		int	pedestal
	)

Definition at line 715 of file raw.cxx.

  {
    const int lengthofadc = adc[0];
    const int nblocks = adc[1];

    uncompressed.resize(lengthofadc);
    for (int i = 0; i < lengthofadc; ++i) {
      uncompressed[i] = pedestal;
    }

    int zerosuppressedindex = nblocks * 2 + 2;

    for (int i = 0; i < nblocks; ++i) { //loop over each nonzero block of the compressed vector

      for (int j = 0; j < adc[2 + nblocks + i]; ++j) { //loop over each block size

        //set uncompressed value
        uncompressed[adc[2 + i] + j] = adc[zerosuppressedindex];
        zerosuppressedindex++;
      }
    }

    return;
  }

Variable Documentation

constexpr ChannelID_t raw::InvalidChannelID = std::numeric_limits<ChannelID_t>::max()

ID of an invalid channel.

Definition at line 31 of file RawTypes.h.

Referenced by nnet::WaveformDenoiseTest::analyze(), nnet::NoiseWaveformDump::analyze(), nnet::RawWaveformDump::analyze(), nnet::RawWaveformClnSigDump::analyze(), evd::details::RawDigitInfo_t::Channel(), geo::ChannelMapStandardAlg::FirstChannelInROP(), isValidChannelID(), geo::GeometryCore::NearestChannel(), geo::ChannelMapStandardAlg::PlaneWireToChannel(), hit::FFTHitFinder::produce(), caldata::CalWire::produce(), caldata::CalWireT962::produce(), hit::DPRawHitFinder::produce(), img::DataProviderAlg::resizeView(), nnet::TrainingDataAlg::setEventData(), and geo::GeometryCore::View().

const unsigned int raw::onemask

Initial value:

=
    0x003f

Definition at line 129 of file raw.h.

Referenced by ADCStickyCodeCheck().