SDDSWriter.h

Go to the documentation of this file.

//
// Class SDDSWriter
//   This class is the base class for all SDDS writers.
//
// Copyright (c) 2019, Matthias Frey, Paul Scherrer Institut, Villigen PSI, Switzerland
//                     Christof Metzger-Kraus, Open Sourcerer
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef OPAL_SDDS_WRITER_H
#define OPAL_SDDS_WRITER_H

#include <fstream>
#include <iomanip>
#include <map>
#include <ostream>
#include <queue>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include <filesystem>
#include "Structure/SDDSColumn.h"
#include "Structure/SDDSColumnSet.h"

template <class T, unsigned Dim>
class PartBunchBase;

class SDDSWriter {

public:
    // order: text, content
    typedef std::pair<std::string, std::string> desc_t;

    // order: name, type, description
    typedef std::tuple<std::string,
                       std::string,
                       std::string> param_t;

    // order: mode, no row counts
    typedef std::pair<std::string, size_t> data_t;

    // order: name, type, unit, description
    typedef std::tuple<std::string,
                       std::string,
                       std::string,
                       std::string> cols_t;

    SDDSWriter(const std::string& fname, bool restart);

    virtual ~SDDSWriter() { };

    virtual void write(PartBunchBase<double, 3>* /*beam*/) { };

    void rewindLines(size_t numberOfLines);

    void replaceVersionString();

    double getLastValue(const std::string& column);

    bool exists() const;

protected:
    void addDescription(const std::string& text,
                        const std::string& content);

    template<typename T>
    void addParameter(const std::string& name,
                      const std::string& type,
                      const std::string& desc,
                      const T& value);

    void addDefaultParameters();

    void addColumn(const std::string& name,
                   const std::string& type,
                   const std::string& unit,
                   const std::string& desc);

    void addInfo(const std::string& mode,
                 const size_t& no_row_counts);

    void writeRow();

    void open();

    void close();

    void writeHeader();

    template<typename T>
    std::string toString(const T& val);

    std::string fname_m;

    std::ios_base::openmode mode_m;

    SDDSColumnSet columns_m;

    /* The columns of the SDDS file need to be
     * added only once.
     */
    bool hasColumns() const;

private:
    void writeDescription();

    void writeParameters();

    void writeColumns();

    void writeInfo();

    std::ofstream os_m;

    std::string indent_m;

    desc_t desc_m;
    std::queue<param_t> params_m;
    std::queue<std::string> paramValues_m;
    data_t info_m;

    static constexpr
    unsigned int precision_m = 15;
};


inline
bool SDDSWriter::exists() const {
    return std::filesystem::exists(fname_m);
}


inline
void SDDSWriter::addDescription(const std::string& text,
                                const std::string& content) {
    desc_m = std::make_pair(text, content);
}


template<typename T>
void SDDSWriter::addParameter(const std::string& name,
                              const std::string& type,
                              const std::string& desc,
                              const T& value) {
    params_m.push(std::make_tuple(name, type, desc));
    std::stringstream ss;
    ss << value;
    paramValues_m.push(ss.str());
}


inline
void SDDSWriter::addInfo(const std::string& mode,
                         const size_t& no_row_counts) {
    info_m = std::make_pair(mode, no_row_counts);
}


inline
void SDDSWriter::writeRow() {
    columns_m.writeRow(os_m);
}


template<typename T>
std::string SDDSWriter::toString(const T& val) {
    std::ostringstream ss;
    ss.precision(precision_m);
    ss << val;
    return ss.str();
}


inline
bool SDDSWriter::hasColumns() const {
    return columns_m.hasColumns();
}

#endif