StManParsetKeys.h

Go to the documentation of this file.

// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DPPP_STMANPARSETKEYS_H
#define DPPP_STMANPARSETKEYS_H
 
#include "common/ParameterSet.h"
 
#include <sstream>
#include <string>
 
#include <casacore/casa/Containers/Record.h>
 
#include <boost/algorithm/string/case_conv.hpp>
 
namespace dp3 {
namespace base {
 
enum class SiscoMode { Full, Diagonal, StokesI };
 
inline SiscoMode GetSiscoMode(const std::string& mode_str) {
  const std::string lowercase_str = boost::to_lower_copy(mode_str);
  if (lowercase_str == "" || lowercase_str == "full")
    return SiscoMode::Full;
  else if (lowercase_str == "diagonal")
    return SiscoMode::Diagonal;
  else if (lowercase_str == "stokes_i")
    return SiscoMode::StokesI;
  else
    throw std::runtime_error("Invalid mode specified for Sisco: " + mode_str);
}
 
inline std::string ToString(SiscoMode mode) {
  switch (mode) {
    case SiscoMode::Full:
      return "full";
    case SiscoMode::Diagonal:
      return "diagonal";
    case SiscoMode::StokesI:
      return "stokes_i";
  }
  assert(false);
  return {};
}
 
struct StManParsetKeys {
  std::string storage_manager_name;
  unsigned int dysco_data_bit_rate;
  unsigned int dysco_weight_bit_rate;
  std::string dysco_distribution;
  double dysco_dist_truncation;
  std::string dysco_normalization;
  int sisco_deflate_level;
  int sisco_predict_level;
  SiscoMode sisco_mode;
 
  explicit StManParsetKeys(const common::ParameterSet& parset,
                           const std::string& prefix) {
    storage_manager_name = boost::to_lower_copy(parset.getString(
        prefix + "storagemanager",
        parset.getString(prefix + "storagemanager.name", std::string())));
    if (storage_manager_name == "dysco") {
      dysco_data_bit_rate =
          parset.getInt(prefix + "storagemanager.databitrate", 10);
      dysco_weight_bit_rate =
          parset.getInt(prefix + "storagemanager.weightbitrate", 12);
      dysco_distribution = parset.getString(
          prefix + "storagemanager.distribution", "TruncatedGaussian");
      dysco_dist_truncation =
          parset.getDouble(prefix + "storagemanager.disttruncation", 2.5);
      dysco_normalization =
          parset.getString(prefix + "storagemanager.normalization", "AF");
    }
    if (storage_manager_name == "sisco") {
      sisco_deflate_level =
          parset.getInt(prefix + "storagemanager.deflate_level", 9);
      sisco_predict_level =
          parset.getInt(prefix + "storagemanager.predict_level", 2);
      sisco_mode = GetSiscoMode(
          parset.getString(prefix + "storagemanager.sisco_mode", ""));
    }
  }
 
  std::string_view GetStorageManagerClassName() const {
    if (storage_manager_name == "stokes_i")
      return "StokesIStMan";
    else if (storage_manager_name == "dysco")
      return "DyscoStMan";
    else if (storage_manager_name == "sisco")
      return "SiscoStMan";
    else if (!storage_manager_name.empty())
      throw std::runtime_error("Unknown storage manager specified: " +
                               storage_manager_name);
    else
      return {};
  }
 
  casacore::Record GetSpecification() const {
    if (storage_manager_name == "dysco")
      return GetDyscoSpec();
    else if (storage_manager_name == "sisco")
      return GetSiscoSpec();
    else
      return casacore::Record();
  }
 
  casacore::Record GetSiscoSpec() const {
    casacore::Record result;
    result.define("deflate_level", sisco_deflate_level);
    result.define("predict_level", sisco_predict_level);
    result.define("stokes_i", sisco_mode == SiscoMode::StokesI);
    result.define("diagonal", sisco_mode == SiscoMode::Diagonal);
    return result;
  }
 
  casacore::Record GetDyscoSpec() const {
    casacore::Record dyscoSpec;
    dyscoSpec.define("distribution", dysco_distribution);
    dyscoSpec.define("normalization", dysco_normalization);
    dyscoSpec.define("distributionTruncation", dysco_dist_truncation);
    unsigned int data_bit_rate = dysco_data_bit_rate;
    if (data_bit_rate == 0) data_bit_rate = 16;
    dyscoSpec.define("dataBitCount", data_bit_rate);
    unsigned int weight_bit_rate = dysco_weight_bit_rate;
    if (weight_bit_rate == 0) weight_bit_rate = 16;
    dyscoSpec.define("weightBitCount", weight_bit_rate);
    return dyscoSpec;
  }
};
 
inline std::string GetCompressionString(const StManParsetKeys& st_man_keys) {
  std::ostringstream str;
  if (st_man_keys.storage_manager_name == "dysco") {
    str << "  Compressed:     yes (Dysco)\n"
        << "   Data bitrate:  " << st_man_keys.dysco_data_bit_rate << '\n'
        << "   Weight bitrate:" << st_man_keys.dysco_weight_bit_rate << '\n'
        << "   Dysco mode:    " << st_man_keys.dysco_normalization << ' '
        << st_man_keys.dysco_distribution << '('
        << st_man_keys.dysco_dist_truncation << ")\n";
  } else if (st_man_keys.storage_manager_name == "sisco") {
    str << "  Compressed:     yes (Sisco)\n"
        << "   Predict level: " << st_man_keys.sisco_predict_level << '\n'
        << "   Deflate level: " << st_man_keys.sisco_deflate_level << '\n'
        << "   Sisco mode:    " << ToString(st_man_keys.sisco_mode) << '\n';
  } else if (st_man_keys.storage_manager_name == "stokes_i") {
    str << "  Compressed:     yes (Stokes I)\n";
  } else {
    str << "  Compressed:     no\n";
  }
  return str.str();
}
 
}  // namespace base
}  // namespace dp3
#endif