outputDeck.h

Go to the documentation of this file.

/*
 * -------------------------------------------
 * Copyright (c) 2021 - 2026 Prashant K. Jha
 * -------------------------------------------
 * PeriDEM https://github.com/prashjha/PeriDEM
 *
 * Distributed under the Boost Software License, Version 1.0. (See accompanying
 * file LICENSE)
 */
 
#ifndef INP_OUTPUTDECK_H
#define INP_OUTPUTDECK_H
 
#include "deckField.h"
#include "util/io.h"
#include "util/json.h"
#include "util/vecMethods.h"
#include <stdexcept>
#include <string>
#include <vector>
 
namespace inp {
  struct OutputDeck {
    std::string d_outFormat;
 
    std::string d_path;
 
    std::vector<std::string> d_outTags;
 
    size_t d_dtOut;
 
    size_t d_dtOutOld;
 
    size_t d_debug;
 
    bool d_performFEOut;
 
    std::string d_compressType;
 
    std::string d_outCriteria;
 
    size_t d_dtOutCriteria;
 
    std::vector<double> d_outCriteriaParams;
 
    bool d_performOut;
 
    size_t d_dtTestOut;
 
    std::string d_tagPPFile;
 
    bool d_pvdCollection;
 
    OutputDeck(const json& j = json({}))
      : d_outFormat("vtu"), d_path("./"), d_dtOut(0), d_dtOutOld(0), d_debug(0),
        d_performFEOut(true), d_dtOutCriteria(0), d_performOut(true),
        d_dtTestOut(0), d_tagPPFile(""), d_pvdCollection(false) {
 
      readFromJson(j);
    };
 
 
    OutputDeck(std::string outFormat,
        std::string path = "./",
        std::vector<std::string> outTags = {"Displacement"},
                size_t outputInterval = 1,
                size_t debug = 2,
                bool performFEOut = true,
                std::string compressType = "zlib",
                bool performOut = true,
        size_t dtTestOut = 1,
        std::string tagPPFile = "",
        bool pvdCollection = false)
      : d_outFormat(outFormat), d_path(path),
        d_dtOut(outputInterval), d_dtOutOld(outputInterval), d_dtOutCriteria(outputInterval),
        d_debug(debug),
        d_performFEOut(performFEOut), d_compressType(compressType),
        d_performOut(performOut), d_dtTestOut(dtTestOut), d_tagPPFile(tagPPFile),
        d_pvdCollection(pvdCollection), d_outTags(outTags){};
 
    static json getExampleJson(const std::string &) = delete;
    static json getExampleJson(const char *) = delete;
 
    static const std::vector<Field<OutputDeck>> &fields() {
      static const std::vector<Field<OutputDeck>> f = {
          field(&OutputDeck::d_path, "Path", std::string("./"),
                "Directory the output is written to"),
          field(&OutputDeck::d_performOut, "Perform_Out", true,
                "Write output at all"),
          field(&OutputDeck::d_outTags, "Tags", std::vector<std::string>(),
                "Fields written at each output step"),
          field(&OutputDeck::d_dtOut, "Output_Interval", size_t(1),
                "Steps between outputs", {{}, size_t(1), {}}),
          field(&OutputDeck::d_debug, "Debug", size_t(2),
                "How much is written to the log"),
          field(&OutputDeck::d_performFEOut, "Perform_FE_Out", true,
                "Write the finite element mesh as well as the nodes"),
          field(&OutputDeck::d_compressType, "Compress_Type",
                std::string("zlib"), "Compression used in the output files"),
          field(&OutputDeck::d_outFormat, "File_Format", std::string("vtu"),
                "Output file format"),
          field(&OutputDeck::d_dtTestOut, "Test_Output_Interval", size_t(1),
                "Steps between post-processing outputs"),
          field(&OutputDeck::d_tagPPFile, "Tag_PP", std::string(),
                "Suffix of the post-processing file"),
          // Absent unless a collection is asked for, which is how the decks
          // in the repository were written.
          field<OutputDeck, bool>(&OutputDeck::d_pvdCollection,
                                  "PVD_Collection", false,
                                  "Write a PVD file indexing the time steps",
                                  {}, [](const bool &v) { return v; }),
      };
      return f;
    }
 
    static json getExampleJson(const json &given = json::object()) {
      return applyGiven(given, fields(), {"Output_Criteria"});
    }
 
    void readFromJson(const json &j) {
      if (j.empty())
        return ;
 
      readFields(*this, j, fields());
 
      // An empty path names the working directory.
      if (d_path.empty())
        d_path = "./";
 
      // Both follow the output interval until the criteria block changes one.
      d_dtOutOld = d_dtOut;
      d_dtOutCriteria = d_dtOut;
 
      if (j.contains("Output_Criteria")) {
        d_outCriteria = j.at("Output_Criteria").value("Type", std::string(""));
        d_dtOutCriteria = j.at("Output_Criteria").value("New_Interval", size_t(1));
        d_outCriteriaParams = j.at("Output_Criteria").value("Parameters", std::vector<double>());
        if (d_dtOutCriteria < 1)
          throw std::runtime_error(
              "Output_Criteria.New_Interval must be >= 1 (use 1 to write every step).");
      }
    }
 
    std::string printStr(int nt = 0, int lvl = 0) const {
      auto tabS = util::io::getTabS(nt);
      std::ostringstream oss;
      oss << tabS << "------- OutputDeck --------" << std::endl << std::endl;
      printFields(*this, oss, fields(), tabS);
      oss << tabS << "Output_Interval before the criteria = " << d_dtOutOld
          << std::endl;
      oss << tabS << "Output_Criteria.Type = " << d_outCriteria << std::endl;
      oss << tabS << "Output_Criteria.New_Interval = " << d_dtOutCriteria
          << std::endl;
      oss << tabS << "Output_Criteria.Parameters = "
          << util::io::printStr<double>(d_outCriteriaParams, 0) << std::endl;
      oss << tabS << std::endl;
 
      return oss.str();
    }
 
    void print(int nt = 0, int lvl = 0) const { std::cout << printStr(nt, lvl); }
  };
 
} // namespace inp
 
#endif // INP_OUTPUTDECK_H