RecompressRawDigits_module.cc

Go to the documentation of this file.

// LArSoft libraries
#include "lardataobj/RawData/RawDigit.h"
#include "lardataobj/RawData/raw.h" // raw::Compress(), raw::Uncompress()
#include "larcoreobj/SimpleTypesAndConstants/RawTypes.h" // raw::Compress_t

// framework libraries
#include "art/Framework/Core/EDProducer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h" // art::ValidHandle
#include "canvas/Utilities/InputTag.h"
#include "canvas/Utilities/Exception.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/types/Atom.h"
#include "fhiclcpp/types/Table.h"

// C/C++ standard libraries
#include <vector>
#include <string>
#include <algorithm> // std::transform()
#include <memory> // std::make_unique()
#include <cctype> // std::toupper()


namespace raw {
  
  class RecompressRawDigits: public art::EDProducer {
      public:
    
    struct Config {
      
      using Name    = fhicl::Name;
      using Comment = fhicl::Comment;
      
      fhicl::Atom<art::InputTag> rawDigitLabel{
        Name("rawDigitLabel"),
        Comment("input tag for the original raw::RawDigit collection")
        };
      
      fhicl::Atom<std::string> compressionType{
        Name("compressionType"),
        Comment("compression mode code (e.g. \"kHuffman\")")
        };
      
      fhicl::Atom<std::string> instanceName{
        Name("instanceName"),
        Comment("instance name for the output data product (none by default)"),
        std::string() // default
        };
      
    }; // Config
    
    
    using Parameters = art::EDProducer::Table<Config>;
    
    
    explicit RecompressRawDigits(Parameters const& config)
      : fRawDigitLabel(config().rawDigitLabel())
      , fCompressionType(parseCompressionType(config().compressionType()))
      , fInstanceName(config().instanceName())
      {
        produces<std::vector<raw::RawDigit>>(fInstanceName);
      }
    
    
    virtual void produce(art::Event& event) override;
    
    
    static raw::RawDigit recompress
      (raw::RawDigit const& digit, Compress_t newFormat, bool force = false);

    
    static raw::Compress_t parseCompressionType(std::string spec);
    
    
      private:
    art::InputTag fRawDigitLabel; 
    raw::Compress_t fCompressionType; 
    std::string fInstanceName; 
    
    
  }; // class RecompressRawDigits
  
  
} // namespace raw




//------------------------------------------------------------------------------
//---  implementation
//------------------------------------------------------------------------------
namespace {
  std::string toupper(std::string s) {
    // act directly on s (which is a copy of the original);
    // explicit cast is needed to pick which std::toupper() to use
    std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) std::toupper);
    return s;
  } // raw::RecompressRawDigits::toupper()
} // local namespace


//------------------------------------------------------------------------------
void raw::RecompressRawDigits::produce(art::Event& event) {
  
  //
  // prepare input and output container
  //
  auto oldRawDigitHandle
    = event.getValidHandle<std::vector<raw::RawDigit>>(fRawDigitLabel);
  
  auto newRawDigits = std::make_unique<std::vector<raw::RawDigit>>();
  
  //
  // create a new compressed raw digit for each existing one
  //
  std::set<raw::Compress_t> formats;
  for (raw::RawDigit const& oldDigits: *oldRawDigitHandle) {
    
    // keep track of all the formats
    formats.insert(oldDigits.Compression());
    
    // recompress the digit, and put it into the future data product
    newRawDigits->emplace_back(recompress(oldDigits, fCompressionType));
    
  } // for oldDigits
  
  //
  // store the new digits into the event
  //
  event.put(std::move(newRawDigits), fInstanceName);
  
} // raw::RecompressRawDigits::produce()



//------------------------------------------------------------------------------
raw::RawDigit raw::RecompressRawDigits::recompress
  (raw::RawDigit const& digit, Compress_t newFormat, bool force /* = false */)
{
  
  if ((newFormat == digit.Compression()) && !force) 
    return digit; // return a copy
  
  // uncompress the data
  raw::RawDigit::ADCvector_t ADCs(digit.Samples());
  raw::Uncompress(digit.ADCs(), ADCs, digit.Compression());    
  
  // compress the data (it happens in place)
  raw::Compress(ADCs, newFormat);
  
  // we force a copy in a buffer sized just big enough to host the data;
  // in case the buffer is already of the right size (as it happens when
  // newFormat specifies no compression), then no copy happens
  ADCs.shrink_to_fit();
  
  // create a new digit with the new buffer
  return raw::RawDigit{
    digit.Channel(),
    digit.Samples(),
    std::move(ADCs),
    newFormat
    };
  
} // raw::RecompressRawDigits::recompress()


//------------------------------------------------------------------------------
raw::Compress_t raw::RecompressRawDigits::parseCompressionType(std::string spec)
{
  std::string SPEC(toupper(spec));
  
  if ((SPEC == "NONE"           ) || (SPEC == "KNONE"           )) return raw::kNone           ;
  if ((SPEC == "HUFFMAN"        ) || (SPEC == "KHUFFMAN"        )) return raw::kHuffman        ;
  if ((SPEC == "ZEROSUPPRESSION") || (SPEC == "KZEROSUPPRESSION")) return raw::kZeroSuppression;
  if ((SPEC == "ZEROHUFFMAN"    ) || (SPEC == "KZEROHUFFMAN"    )) return raw::kZeroHuffman    ;
  if ((SPEC == "DYNAMICDEC"     ) || (SPEC == "KDYNAMICDEC"     )) return raw::kDynamicDec     ;
  
  // if a valid one triggers this error, it needs to be added above
  throw art::Exception(art::errors::Configuration)
    << "Unrecognized compression type: '" << spec << "'\n";
  
} // raw::RecompressRawDigits::parseCompressionType()


//------------------------------------------------------------------------------
DEFINE_ART_MODULE(raw::RecompressRawDigits)



//------------------------------------------------------------------------------