fitsDataRecorder.ipp

Go to the documentation of this file.

 
// Note this is a template implementation file and should not be included directly.
// The typical header protection macro is not added to avoid it showing up in Doxygen API
// documentation.
#pragma once
 
#include <ciiException.hpp>
#include <fitsio.h>
#include <longnam.h>
 
#include <rtctk/componentFramework/fitsColumnFormat.hpp>
#include <rtctk/componentFramework/recordingTypeTraits.hpp>
#include <rtctk/componentFramework/recordingUtils.hpp>
#include <rtctk/componentFramework/typeTraits.hpp>
 
#include <complex>
#include <cstddef>
#include <filesystem>
#include <fmt/core.h>
#include <fmt/format.h>
#include <functional>
#include <limits>
#include <memory>
#include <type_traits>
#include <vector>
 
namespace {
template <class T>
struct FitsDataTypeValue {
    static_assert(true, "invalid data for fits writer");
};
 
template <>
struct FitsDataTypeValue<unsigned char> {
    static constexpr int DTYPE = TBYTE;
};
 
template <>
struct FitsDataTypeValue<signed char> {
    static constexpr int DTYPE = TSBYTE;
};
 
template <>
struct FitsDataTypeValue<bool> {
    static constexpr int DTYPE = TLOGICAL;
};
 
// The following check will prevent the code from building and producing a binary that silently
// corrupts the data. If ever the code needs to be built on a platform where the size of the boolean
// type is different from char, the implementation will need to be modified to correctly handle
// this.
static_assert(sizeof(bool) == sizeof(char),
              "Cfitsio uses 'char' for TLOGICAL internally. Therefore the sizes of 'bool' and "
              "'char' must match for this implementation to work.");
 
// not supported by write_cols
// template <>
// struct FitsDataTypeValue<std::string> {
//     static constexpr int DTYPE = TSTRING;
// };
 
// not supported by write_cols
// template <>
// struct FitsDataTypeValue<char*> {
//     static constexpr int DTYPE = TSTRING;
// };
 
template <>
struct FitsDataTypeValue<unsigned short> {
    static constexpr int DTYPE = TUSHORT;
};
 
template <>
struct FitsDataTypeValue<signed short> {
    static constexpr int DTYPE = TSHORT;
};
 
template <>
struct FitsDataTypeValue<unsigned int> {
    static constexpr int DTYPE = TUINT;
};
 
template <>
struct FitsDataTypeValue<int> {
    static constexpr int DTYPE = TINT;
};
 
template <>
struct FitsDataTypeValue<unsigned long> {
    static constexpr int DTYPE = TULONG;
};
 
template <>
struct FitsDataTypeValue<long> {
    static constexpr int DTYPE = TLONG;
};
 
template <>
struct FitsDataTypeValue<float> {
    static constexpr int DTYPE = TFLOAT;
};
 
template <>
struct FitsDataTypeValue<unsigned long long> {
    static constexpr int DTYPE = TULONGLONG;
};
 
template <>
struct FitsDataTypeValue<long long> {
    static constexpr int DTYPE = TLONGLONG;
};
 
template <>
struct FitsDataTypeValue<double> {
    static constexpr int DTYPE = TDOUBLE;
};
 
template <>
struct FitsDataTypeValue<std::complex<float>> {
    static constexpr int DTYPE = TCOMPLEX;
};
 
template <>
struct FitsDataTypeValue<std::complex<double>> {
    static constexpr int DTYPE = TDBLCOMPLEX;
};
 
template <typename data>
void TableWriterHelper(fitsfile* fptr, int colnum, long firstrow, std::vector<data>& input);
 
template <typename data>
void TableWriterHelper(fitsfile* fptr, int colnum, long firstrow, std::vector<data>& input);
 
void ThrowOnBadStatus(int status, const std::string& message) {
    if (status) {
        std::array<char, 80> err_text;
        fits_get_errstatus(status, err_text.data());
        std::string buffer;
        std::array<char, 80> fits_buffer;
        while (fits_read_errmsg(fits_buffer.data())) {
            buffer += fits_buffer.data();
        }
        CII_THROW(rtctk::componentFramework::FitsDataRecorderFitsError,
                  fmt::format("{} {}: {}", message, err_text.data(), buffer));
    }
}
 
}  // namespace
 
namespace rtctk::componentFramework {
 
template <class... T>
FitsRecorder<T...>::FitsRecorder(const ColumnDescription& columns,
                                 const std::array<bool, sizeof...(T)>& disabled,
                                 const std::string& extension_name)
    : DataRecorder<T...>(columns, disabled)
    , m_fits_handle(nullptr, &CloseFits)
    , m_extension_name(extension_name)
    , m_row_index(1)
    , m_column_length{(FitsColumnFormat<T>::COUNT)...} {
    // Initialize cfitsio before any other cfitsio functions are called. This must be called
    // before using cfitsio in a multithreaded environment. Calling it multiple times is safe.
    fits_init_cfitsio();
}
 
template <class... T>
void FitsRecorder<T...>::Open(const std::filesystem::path& file) {
    m_row_index = 1;
    fitsfile* filepointer;
    int status{0};
    fits_create_diskfile(&filepointer, file.c_str(), &status);
    ThrowOnBadStatus(status, "Error in fits_open_diskfile");
    m_fits_handle.reset(filepointer);
    std::vector<std::string> column_names{}, column_units{}, column_forms{};
    column_names.reserve(sizeof...(T));
    column_units.reserve(sizeof...(T));
    column_forms.reserve(sizeof...(T));
    for (auto column : this->m_column_description) {
        column_names.push_back(std::string{column.name});
        column_units.push_back(std::string{column.unit});
    }
    GetFITSTFormWithLength<T...>(column_forms, this->m_column_length);
    auto iter = DataRecorder<T...>::m_disabled_fields.rbegin();
    for (int i = sizeof...(T) - 1; iter != DataRecorder<T...>::m_disabled_fields.rend(); iter++) {
        if (*iter) {
            column_names.erase(std::next(column_names.begin(), i));
            column_units.erase(std::next(column_units.begin(), i));
            column_forms.erase(std::next(column_forms.begin(), i));
        }
        i--;
    }
    // fits expects char*
    std::vector<char*> column_names_fits;
    std::vector<char*> column_units_fits;
    std::vector<char*> column_forms_fits;
    column_names_fits.reserve(column_names.size());
    column_units_fits.reserve(column_units.size());
    column_forms_fits.reserve(column_forms.size());
    for (auto& column_name : column_names) {
        column_names_fits.push_back(column_name.data());
    }
    for (auto& column_unit : column_units) {
        column_units_fits.push_back(column_unit.data());
    }
    for (auto& column_form : column_forms) {
        column_forms_fits.push_back(column_form.data());
    }
    fits_create_tbl(m_fits_handle.get(),
                    BINARY_TBL,
                    0,
                    column_names_fits.size(),
                    column_names_fits.data(),
                    column_forms_fits.data(),
                    column_units_fits.data(),
                    "RECORDING",
                    &status);
 
    ThrowOnBadStatus(status, "error in fits_create_tbl");
}
 
template <class... T>
void FitsRecorder<T...>::SetColumnLength(size_t column, size_t length) {
    if (m_fits_handle != nullptr) {
        CII_THROW(RtctkException, "FitsRecorder: Setting ColumnLength after Open not allowed");
    }
    if (sizeof...(T) <= column) {
        CII_THROW(InvalidArgumentException, "column index out of bounds");
    }
    if (length >= 4294967296) {
        CII_THROW(InvalidArgumentException,
                  fmt::format("length({}) must be less than 2^32", length));
    }
    m_column_length[column] = length;
}
 
template <class... T>
void FitsRecorder<T...>::SetColumnLength(const std::tuple<T...>& data) {
    auto set_column_lengths = [this](const auto& first, const auto&... args) {
        long column = 0;
        auto set_column_length = [this, &column](const auto& x) {
            // dynamically sized types
            if constexpr (IS_DYNAMIC_SPAN_TYPE<std::decay_t<decltype(x)>> or
                          IS_VECTOR_TYPE<std::decay_t<decltype(x)>> or
                          IS_MATRIX_BUFFER_TYPE<std::decay_t<decltype(x)>>) {
                this->SetColumnLength(column, x.size());
            }
            column++;
        };
        set_column_length(first);
        (set_column_length(args), ...);
    };
    std::apply(set_column_lengths, data);
}
 
// template <class... T>
// void FitsRecorder<T...>::Write(const gsl::span<const std::tuple<T...>>) {
 
// }
 
// template <class... T>
// void FitsRecorder<T...>::Write(const std::tuple<T...>& data) {
//     this->Write(gsl::span(&data, 1));
// }
 
template <class... T>
void FitsRecorder<T...>::Write(const std::tuple<T...>& data) {
    auto write = [this](const auto& first, const auto&... args) {
        long fits_column = 1;
        long element = 0;
        auto write_elem = [this, &fits_column, &element](const auto& x) {
            if (this->m_disabled_fields[element]) {
                element += 1;
                return;
            }
            int status{0};
            // dynamically sized types
            if constexpr (IS_DYNAMIC_SPAN_TYPE<std::decay_t<decltype(x)>> or
                          IS_VECTOR_TYPE<std::decay_t<decltype(x)>> or
                          IS_MATRIX_BUFFER_TYPE<std::decay_t<decltype(x)>>) {
                if (not m_column_length[element].has_value()) {
                    CII_THROW(InvalidArgumentException,
                              fmt::format("dynamic sized type given, but length not given for {}",
                                          this->m_column_description[element].name));
                } else if (x.size() != m_column_length[element]) {
                    CII_THROW(InvalidArgumentException,
                              "data size does not match configured length");
                }
                std::vector<typename std::decay_t<decltype(x)>::value_type> copy(
                    x.data(), x.data() + m_column_length[element].value());
                fits_write_col(m_fits_handle.get(),
                               FitsDataTypeValue<typename decltype(copy)::value_type>::DTYPE,
                               fits_column,
                               m_row_index,
                               1,
                               copy.size(),
                               copy.data(),
                               &status);
                ThrowOnBadStatus(status, "Error writing to binary table");
                // This case is for writing statically sized types
            } else if constexpr (IS_STD_ARRAY_TYPE<std::decay_t<decltype(x)>> or
                                 IS_STATIC_SPAN_TYPE<std::decay_t<decltype(x)>>) {
                std::vector<typename std::decay_t<decltype(x)>::value_type> copy(
                    x.data(), x.data() + x.size());
                fits_write_col(m_fits_handle.get(),
                               FitsDataTypeValue<typename decltype(copy)::value_type>::DTYPE,
                               fits_column,
                               m_row_index,
                               1,
                               copy.size(),
                               copy.data(),
                               &status);
                ThrowOnBadStatus(status, "Error writing to binary table");
                // This is for writing strings
            } else if constexpr (std::is_same_v<std::decay_t<decltype(x)>, std::string>) {
                std::string copy{x};
                char* char_string = copy.data();
                fits_write_col(m_fits_handle.get(),
                               TSTRING,
                               fits_column,
                               m_row_index,
                               1,
                               1,
                               &char_string,
                               &status);
                ThrowOnBadStatus(status, "Error writing to binary table");
                // for scalar values
            } else {
                // need to copy since cfitsio wants a non-const type
                std::decay_t<decltype(x)> copy{x};
                fits_write_col(m_fits_handle.get(),
                               FitsDataTypeValue<decltype(copy)>::DTYPE,
                               fits_column,
                               m_row_index,
                               1,
                               1,
                               &copy,
                               &status);
                ThrowOnBadStatus(status, "Error writing to binary table");
            }
            fits_column += 1;
            element += 1;
        };
        write_elem(first);
        (write_elem(args), ...);
    };
    std::apply(write, data);
    m_row_index += 1;
}
 
template <class... T>
void FitsRecorder<T...>::Close() {
    m_fits_handle.reset(nullptr);
}
 
template <class... T>
void FitsRecorder<T...>::CloseFits(fitsfile* pointer) {
    int status{0};
    fits_close_file(pointer, &status);
    ThrowOnBadStatus(status, "Error closing file");
}
 
}  // namespace rtctk::componentFramework