AdolOps.cpp

Go to the documentation of this file.

/**
 * @file AdolCElasticOps.cpp
 * @author your name (you@domain.com)
 * @brief 
 * @date 2026-03-26
 * 
 * @copyright Copyright (c) 2026
 * 
 */
 
#include <MoFEM.hpp>
 
using namespace MoFEM;
 
#include "AdolCOps.hpp"
 
namespace AdolCOps {
 
struct ADolCDataImpl : public ADolCData {
  using MatrixPtr = ADolCData::MatrixPtr;
 
  struct Data {
    Data() = default;
    Data(const std::string &data_name,
         const MatrixDouble &data_value = MatrixDouble(), int data_shift = 0)
        : name(data_name), data(data_value), shift(data_shift) {}
 
    std::string name;
    mutable MatrixDouble data;
    mutable int shift = 0;
  };
 
  struct DataSequence_mi_tag;
  struct DataName_mi_tag;
 
  using DataContainer = boost::multi_index::multi_index_container<
 
      Data,
 
      boost::multi_index::indexed_by<
 
          boost::multi_index::sequenced<
              boost::multi_index::tag<DataSequence_mi_tag>>,
 
          boost::multi_index::hashed_unique<
              boost::multi_index::tag<DataName_mi_tag>,
              boost::multi_index::member<Data, std::string, &Data::name>>>>;
 
  auto &getDataCommonByName() {
    return boost::multi_index::get<DataName_mi_tag>(dataCommon);
  }
 
  auto &getDataActiveByName() {
    return boost::multi_index::get<DataName_mi_tag>(dataActive);
  }
 
  auto &getDataDependentByName() {
    return boost::multi_index::get<DataName_mi_tag>(dataDependent);
  }
 
  auto &getDataDependentDerivativesByName() {
    return boost::multi_index::get<DataName_mi_tag>(dataDependentDerivatives);
  }
 
  std::pair<bool, MatrixPtr>
  insertCommonData(const std::string &name,
                   const MatrixDouble &data = MatrixDouble(),
                   int shift = 0) override {
    auto insert_ret = getDataCommonByName().insert(Data{name, data, shift});
    if (!insert_ret.second)
      return {false, MatrixPtr()};
    return {true, boost::shared_ptr<MatrixDouble>(this->shared_from_this(),
                                                  &insert_ret.first->data)};
  }
 
  std::pair<bool, MatrixPtr>
  insertActiveData(const std::string &name,
                   const MatrixDouble &data = MatrixDouble(),
                   int shift = 0) override {
    auto insert_ret = getDataActiveByName().insert(Data{name, data, shift});
    if (!insert_ret.second)
      return {false, MatrixPtr()};
    return {true, boost::shared_ptr<MatrixDouble>(this->shared_from_this(),
                                                  &insert_ret.first->data)};
  }
 
  std::pair<bool, MatrixPtr>
  insertDependentData(const std::string &name,
                      const MatrixDouble &data = MatrixDouble(),
                      int shift = 0) override {
    auto insert_ret = getDataDependentByName().insert(Data{name, data, shift});
    if (!insert_ret.second)
      return {false, MatrixPtr()};
    return {true, boost::shared_ptr<MatrixDouble>(this->shared_from_this(),
                                                  &insert_ret.first->data)};
  }
 
  std::pair<bool, MatrixPtr>
  insertDependentDerivativesData(const std::string &name,
                                 const MatrixDouble &data = MatrixDouble(),
                                 int shift = 0) override {
    auto insert_ret =
        getDataDependentDerivativesByName().insert(Data{name, data, shift});
    if (!insert_ret.second)
      return {false, MatrixPtr()};
    return {true, boost::shared_ptr<MatrixDouble>(this->shared_from_this(),
                                                  &insert_ret.first->data)};
  }
 
  MatrixPtr getCommonDataPtr(const std::string &name) override {
    auto &data_by_name = getDataCommonByName();
    auto it = data_by_name.find(name);
    if (it == data_by_name.end()) {
      CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                        "Common data with name " + name + " not found");
      return MatrixPtr();
    }
    return boost::shared_ptr<MatrixDouble>(this->shared_from_this(), &it->data);
  }
 
  MatrixPtr getActiveDataPtr(const std::string &name) override {
    auto &data_by_name = getDataActiveByName();
    auto it = data_by_name.find(name);
    if (it == data_by_name.end()) {
      CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                        "Active data with name " + name + " not found");
      return MatrixPtr();
    }
    return boost::shared_ptr<MatrixDouble>(this->shared_from_this(), &it->data);
  }
 
  MatrixPtr getDependentDataPtr(const std::string &name) override {
    auto &data_by_name = getDataDependentByName();
    auto it = data_by_name.find(name);
    if (it == data_by_name.end()) {
      CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                        "Dependent data with name " + name + " not found");
      return MatrixPtr();
    }
    return boost::shared_ptr<MatrixDouble>(this->shared_from_this(), &it->data);
  }
 
  MatrixPtr getDependentDerivativesDataPtr(const std::string &name) override {
    auto &data_by_name = getDataDependentDerivativesByName();
    auto it = data_by_name.find(name);
    if (it == data_by_name.end()) {
      CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                        "Dependent derivatives data with name " + name +
                            " not found");
      return MatrixPtr();
    }
    return boost::shared_ptr<MatrixDouble>(this->shared_from_this(), &it->data);
  }
 
  MoFEMErrorCode
  setActiveContinuousVector(std::vector<double> &active_variables) override {
    return setContinuousVector(dataActive, active_variables);
  }
 
  MoFEMErrorCode setDependentContinuousVector(
      std::vector<double> &dependent_variables) override {
    return setContinuousVector(dataDependent, dependent_variables);
  }
 
  MoFEMErrorCode setDependentDerivativesContinuousVector(
      std::vector<double> &dependent_variables_derivatives) override {
    return setContinuousVector(dataDependentDerivatives,
                               dependent_variables_derivatives);
  }
 
  MoFEMErrorCode getActiveContinuousVector(
      const std::vector<double> &active_variables) override {
    return getContinuousVector(dataActive, active_variables);
  }
 
  MoFEMErrorCode getDependentContinuousVector(
      const std::vector<double> &dependent_variables) override {
    return getContinuousVector(dataDependent, dependent_variables);
  }
 
  MoFEMErrorCode getDependentDerivativesContinuousVector(
      const std::vector<double> &dependent_variables_derivatives) override {
    return getContinuousVector(dataDependentDerivatives,
                               dependent_variables_derivatives);
  }
 
private:
  MoFEMErrorCode setContinuousVector(DataContainer &data_container,
                                     std::vector<double> &variables) {
    MoFEMFunctionBeginHot;
 
    auto &data_by_sequence =
        boost::multi_index::get<DataSequence_mi_tag>(data_container);
 
    int nb_variables = 0;
    for (const auto &d : data_by_sequence)
      nb_variables += d.data.data().size();
 
    variables.resize(nb_variables);
 
    int shift = 0;
    for (const auto &d : data_by_sequence) {
      d.shift = shift;
      for (auto it = d.data.data().begin(); it != d.data.data().end();
           ++it, ++shift)
        variables[shift] = *it;
    }
 
    MoFEMFunctionReturnHot(0);
  }
 
  MoFEMErrorCode getContinuousVector(DataContainer &data_container,
                                     const std::vector<double> &variables) {
    MoFEMFunctionBeginHot;
 
    auto &data_by_sequence =
        boost::multi_index::get<DataSequence_mi_tag>(data_container);
 
    int nb_variables = 0;
    for (const auto &d : data_by_sequence)
      nb_variables += d.data.data().size();
 
    if (variables.size() != static_cast<size_t>(nb_variables)) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
              "Inconsistent size of continuous vector");
    }
 
    int shift = 0;
    for (const auto &d : data_by_sequence) {
      d.shift = shift;
      for (auto it = d.data.data().begin(); it != d.data.data().end();
           ++it, ++shift)
        *it = variables[shift];
    }
 
    MoFEMFunctionReturnHot(0);
  }
 
  DataContainer dataCommon;
  DataContainer dataActive;
  DataContainer dataDependent;
  DataContainer dataDependentDerivatives;
};
 
boost::shared_ptr<ADolCData> createADolCDataPtr() {
  return boost::make_shared<ADolCDataImpl>();
}
 
} // namespace AdolCOps