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