dyscostman.h

Go to the documentation of this file.

#ifndef DYSCO_STORAGE_MANAGER_H
#define DYSCO_STORAGE_MANAGER_H
 
#include <casacore/tables/DataMan/DataManager.h>
 
#include <casacore/casa/Containers/Record.h>
 
#include <cstdint>
#include <fstream>
#include <memory>
#include <mutex>
#include <vector>
 
#include "dyscodistribution.h"
#include "dysconormalization.h"
#include "threadgroup.h"
#include "uvector.h"
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
extern "C" {
#endif
void register_dyscostman();
#ifndef DOXYGEN_SHOULD_SKIP_THIS
}
#endif
 
namespace dyscostman {
 
class DyscoStManColumn;
 
class DyscoStMan : public casacore::DataManager {
 public:
  DyscoStMan(unsigned dataBitRate, unsigned weightBitRate,
             const casacore::String &name = "DyscoStMan");
 
  void SetGaussianDistribution() { _distribution = GaussianDistribution; }
 
  void SetUniformDistribution() { _distribution = UniformDistribution; }
 
  void SetStudentsTDistribution(double nu) {
    _distribution = StudentsTDistribution;
    _studentTNu = nu;
  }
 
  void SetTruncatedGaussianDistribution(double truncationSigma) {
    _distribution = TruncatedGaussianDistribution;
    _distributionTruncation = truncationSigma;
  }
 
  void SetNormalization(Normalization normalization) {
    _normalization = normalization;
  }
 
  void SetStaticSeed(bool staticSeed) { _staticSeed = staticSeed; }
 
  DyscoStMan(const casacore::String &name, const casacore::Record &spec);
 
  DyscoStMan(const DyscoStMan &source);
 
  ~DyscoStMan();
 
  DyscoStMan &operator=(const DyscoStMan &source) = delete;
 
  virtual casacore::DataManager *clone() const final override {
    return new DyscoStMan(*this);
  }
 
  virtual casacore::String dataManagerType() const final override {
    return "DyscoStMan";
  }
 
  virtual casacore::String dataManagerName() const final override {
    return _name;
  }
 
  virtual casacore::Record dataManagerSpec() const final override;
 
  uint getNRow() const { return _nRow; }
 
  virtual casacore::Bool canAddRow() const final override { return true; }
 
  virtual casacore::Bool canRemoveRow() const final override { return true; }
 
  virtual casacore::Bool canAddColumn() const final override { return true; }
 
  virtual casacore::Bool canRemoveColumn() const final override { return true; }
 
  static casacore::DataManager *makeObject(const casacore::String &name,
                                           const casacore::Record &spec) {
    return new DyscoStMan(name, spec);
  }
 
  static void registerClass();
 
 protected:
  uint64_t nBlocksInFile() const {
    std::lock_guard<std::mutex> lock(_mutex);
    return _nBlocksInFile;
  }
 
  size_t nRowsInBlock() const { return _rowsPerBlock; }
 
  size_t nAntennae() const { return _antennaCount; }
 
  size_t getBlockIndex(uint64_t row) const { return row / _rowsPerBlock; }
 
  size_t getRowWithinBlock(uint64_t row) const { return row % _rowsPerBlock; }
 
  uint64_t getRowIndex(size_t block) const {
    return uint64_t(block) * uint64_t(_rowsPerBlock);
  }
 
  bool areOffsetsInitialized() const { return _rowsPerBlock != 0; }
 
  void initializeRowsPerBlock(size_t rowsPerBlock, size_t antennaCount,
                              bool writeToHeader);
 
 private:
  friend class DyscoStManColumn;
 
  const static unsigned short VERSION_MAJOR, VERSION_MINOR;
 
  void readCompressedData(size_t blockIndex, const DyscoStManColumn *column,
                          unsigned char *dest, size_t size);
 
  void writeCompressedData(size_t blockIndex, const DyscoStManColumn *column,
                           const unsigned char *data, size_t size);
 
  void readHeader();
 
  void writeHeader();
 
  void makeEmpty();
 
  void setFromSpec(const casacore::Record &spec);
 
  size_t getFileOffset(size_t blockIndex) const {
    return _blockSize * blockIndex + _headerSize;
  }
 
  // Flush and optionally fsync the data.
  // The AipsIO stream represents the main table file and can be
  // used by virtual column engines to store SMALL amounts of data.
  virtual casacore::Bool flush(casacore::AipsIO &,
                               casacore::Bool doFsync) final override;
 
  // Let the storage manager create files as needed for a new table.
  // This allows a column with an indirect array to create its file.
  virtual void create64(casacore::rownr_t nRow) final override;
 
  // Open the storage manager file for an existing table.
  // Return the number of rows in the data file.
  virtual casacore::rownr_t open64(casacore::rownr_t nRow, casacore::AipsIO &) final override;
 
  // Create a column in the storage manager on behalf of a table column.
  // The caller will NOT delete the newly created object.
  // Create a scalar column.
  virtual casacore::DataManagerColumn *makeScalarColumn(
      const casacore::String &name, int dataType,
      const casacore::String &dataTypeID) final override;
 
  // Create a direct array column.
  virtual casacore::DataManagerColumn *makeDirArrColumn(
      const casacore::String &name, int dataType,
      const casacore::String &dataTypeID) final override;
 
  // Create an indirect array column.
  virtual casacore::DataManagerColumn *makeIndArrColumn(
      const casacore::String &name, int dataType,
      const casacore::String &dataTypeID) final override;
 
  virtual casacore::rownr_t resync64(casacore::rownr_t nRow) final override;
 
  virtual void deleteManager() final override;
 
  // Prepare the columns, let the data manager initialize itself further.
  // Prepare is called after create/open has been called for all
  // columns. In this way one can be sure that referenced columns
  // are read back and partly initialized.
  virtual void prepare() final override;
 
  // Reopen the storage manager files for read/write.
  virtual void reopenRW() final override;
 
  // Add rows to the storage manager.
  virtual void addRow64(casacore::rownr_t nrrow) final override;
 
  // Delete a row from all columns.
  virtual void removeRow64(casacore::rownr_t rowNr) final override;
 
  // Do the final addition of a column.
  virtual void addColumn(casacore::DataManagerColumn *) final override;
 
  // Remove a column from the data file.
  virtual void removeColumn(casacore::DataManagerColumn *) final override;
 
  uint64_t _nRow;
  uint64_t _nBlocksInFile;
  uint32_t _rowsPerBlock;
  uint32_t _antennaCount;
  uint32_t _blockSize;
 
  unsigned _headerSize;
  mutable std::mutex _mutex;
  std::unique_ptr<std::fstream> _fStream;
 
  std::string _name;
  unsigned _dataBitCount;
  unsigned _weightBitCount;
  DyscoDistribution _distribution;
  Normalization _normalization;
  double _studentTNu, _distributionTruncation;
  bool _staticSeed;
 
  std::vector<std::unique_ptr<DyscoStManColumn>> _columns;
};
 
}  // namespace dyscostman
 
#endif