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