model.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <iganet.h>
#include <webapps_config.hpp>
 
namespace iganet {
 
enum class io {
  scalar = 0,               
  scalarfield = 1,          
  vectorfield = 2,          
  scalarfield_boundary = 3, 
  vectorfield_boundary = 4  
};
 
struct IndexOutOfBoundsException : public std::exception {
  const char *what() const throw() { return "Index is out of bounds"; }
};
 
struct InvalidModelException : public std::exception {
  const char *what() const throw() { return "Invalid model name"; }
};
 
struct InvalidModelAttributeException : public std::exception {
  const char *what() const throw() { return "Invalid model attribute"; }
};
 
class ModelAddPatch {
public:
  virtual void addPatch(const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("addpatch")};
  }
};
 
class ModelRemovePatch {
public:
  virtual void removePatch(const std::string &patch,
                           const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("removepatch")};
  }
};  
  
class ModelComputeError {
public:
  virtual nlohmann::json computeError(const nlohmann::json &json) const = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("computeL1error"),
                       std::string("computeL2error"),
                       std::string("computeH1error")};
  }
};
 
class ModelElevate {
public:
  virtual void elevate(const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("elevate")};
  }
};
 
class ModelEval {
public:
  virtual nlohmann::json eval(const std::string &patch,
                              const std::string &component,
                              const nlohmann::json &json) const = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("eval")};
  }
};
 
class ModelIncrease {
public:
  virtual void increase(const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("increase")};
  }
};
 
class ModelRefine {
public:
  virtual void refine(const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("refine")};
  }
};
 
class ModelReparameterize {
public:
  virtual void reparameterize(const std::string &patch, const nlohmann::json &json) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("reparameterize")};
  }
};
 
class ModelSerialize {
public:
  virtual void load(const nlohmann::json &json) = 0;
 
  virtual nlohmann::json save() const = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("load"), std::string("save")};
  }
};
 
class ModelXML {
public:
  virtual void importXML(const std::string &patch,
                         const std::string &component,
                         const nlohmann::json &json,
                         int id) = 0;
 
  virtual void importXML(const std::string &patch,
                         const std::string &component,
                         const pugi::xml_node &xml,
                         int id) = 0;
 
  virtual nlohmann::json exportXML(const std::string &patch,
                                   const std::string &component,
                                   int id) = 0;
 
  virtual pugi::xml_node &exportXML(const std::string &patch,
                                    const std::string &component,
                                    pugi::xml_node &root,
                                    int id) = 0;
 
  // @brief Returns model capabilities
  std::vector<std::string> getCapabilities() const {
    return std::vector{std::string("exportxml"), std::string("importxml")};
  }
};
 
template <typename T> class Model {
public:
  Model(){};
 
  virtual ~Model(){};
 
  virtual std::string getName() const = 0;
 
  virtual std::string getDescription() const = 0;
 
  virtual nlohmann::json getOptions() const = 0;
 
  virtual nlohmann::json getInputs() const = 0;
 
  virtual nlohmann::json getOutputs() const = 0;
 
  virtual nlohmann::json getParameters() const = 0;
 
  virtual nlohmann::json getModel() const {
 
    nlohmann::json json;
    json["name"] = getName();
    json["description"] = getDescription();
 
    json["options"] = getOptions();
    json["capabilities"] = getCapabilities();
    json["inputs"] = getInputs();
    json["outputs"] = getOutputs();
    json["parameters"] = getParameters();
 
    return json;
  }
 
  virtual nlohmann::json getCapabilities() const {
 
    auto json = nlohmann::json::array();
 
    json.push_back("create");
    json.push_back("remove");
 
    if (auto m = dynamic_cast<const ModelAddPatch *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
    
    if (auto m = dynamic_cast<const ModelComputeError *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelElevate *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelEval *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelIncrease *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelRefine *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelRemovePatch *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
    
    if (auto m = dynamic_cast<const ModelReparameterize *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelSerialize *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    if (auto m = dynamic_cast<const ModelXML *>(this))
      for (auto const &capability : m->getCapabilities())
        json.push_back(capability);
 
    return json;
  }
 
  virtual nlohmann::json to_json(const std::string &patch,
                                 const std::string &component,
                                 const std::string &attribute) const {
 
    return "{ INVALID REQUEST }";
  }
 
  virtual nlohmann::json updateAttribute(const std::string &patch,
                                         const std::string &component,
                                         const std::string &attribute,
                                         const nlohmann::json &json) {
 
    return "{ INVALID REQUEST }";
  }
};
 
} // namespace iganet