b2solution.H

Go to the documentation of this file.

 
 
#ifndef __B2SOLUTION_H__
#define __B2SOLUTION_H__
 
#include <string>
 
#include "b2ppconfig.h"
#include "utils/b2csda.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2object.H"
#include "utils/b2rtable.H"
#include "utils/b2type.H"
 
namespace b2000 {
 
class Model;
class Element;
class Node;
class Case;
 
namespace solution {
extern Module module;
}
 
class GradientContainer : public Object {
public:
    ~GradientContainer() override {}
 
    struct FieldDescription {
        std::string name;
 
        std::string components_name;
 
        std::string description;
 
        int domain_ndim;
 
        int nb_comp;
 
        int tensor_order;
 
        int tensor_size;
 
        bool tensor_symmetric;
 
        const std::type_info& elem_type;
    };
 
    struct InternalElementPosition {
        double r;
        double s;
        double t;
        int layer;
    };
 
    virtual bool set_current_element(const Element& e) = 0;
 
    virtual void set_current_position(
          const InternalElementPosition& pos, const double volume = 0) = 0;
 
    virtual void set_current_volume(const double volume) = 0;
 
    virtual double get_element_volume() { return 0; }
 
    virtual void set_field_value(const FieldDescription& descr, const int* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_field_value(const FieldDescription& descr, const double* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_field_value(const FieldDescription& descr, const b2000::csda<double>* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_field_value(const FieldDescription& descr, const std::complex<double>* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_failure_index(const double failure_index) { UnimplementedError() << THROW; }
 
    struct DiscreteInternalElementPosition {
        int object_dim;  // 0 -> node; 1 -> edge; 2 -> face; 3 -> volume
        int id;          // -1 -> the position is the element itself
    };
 
    virtual void set_current_discrete_position(const DiscreteInternalElementPosition& pos) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_discrete_value(const FieldDescription& descr, const int* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_discrete_value(const FieldDescription& descr, const double* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_discrete_value(
          const FieldDescription& descr, const b2000::csda<double>* value) {
        UnimplementedError() << THROW;
    }
 
    virtual void set_discrete_value(
          const FieldDescription& descr, const std::complex<double>* value) {
        UnimplementedError() << THROW;
    }
 
    virtual bool compute_field_value(const std::string& name) const { return false; }
};
 
class Solution : public Object {
public:
    using type_t = ObjectTypeIncomplete<Solution>;
    using gradient_container = std::shared_ptr<GradientContainer>;
 
    virtual void set_model(Model& model) = 0;
 
    virtual void set_case(Case& case_) = 0;
 
    virtual void set_subcase_id(int subcase_id_) = 0;
 
    virtual bool is_need_refinement() const { return false; }
 
    virtual void set_need_refinement() {}
 
    virtual gradient_container get_gradient_container() = 0;
 
    virtual void terminate_case(bool success, const RTable& attributes) = 0;
 
    virtual void set_value(const std::string& key, bool value) {}
    virtual void set_value(const std::string& key, int value) {}
    virtual void set_value(const std::string& key, double value) {}
    virtual void set_value(const std::string& key, std::string& value) {}
 
    virtual void set_system_null_space(
          const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& nks, bool normalize = true,
          const std::string suffix = "NS") {
        UnimplementedError() << THROW;
    }
 
    virtual void set_system_null_space(
          const b2linalg::Matrix<b2000::csda<double>, b2linalg::Mrectangle_constref>& nks,
          bool normalize = true, const std::string suffix = "NS") {
        UnimplementedError() << THROW;
    }
 
    virtual void set_system_null_space(
          const b2linalg::Matrix<std::complex<double>, b2linalg::Mrectangle_constref>& nks,
          bool normalize = true, const std::string suffix = "NS") {
        UnimplementedError() << THROW;
    }
 
    static type_t type;
};
 
template <typename DOF_TYPE>
class SolutionStaticLinear : public virtual Solution {
public:
    virtual bool compute_dof() const = 0;
 
    virtual void set_dof(const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual void get_dof(b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_ref> dof) = 0;
 
    virtual bool compute_natural_boundary_condition() const = 0;
 
    virtual void set_natural_boundary_condition(
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual bool compute_constraint_value() const = 0;
 
    virtual void set_constraint_value(
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
};
 
class SolutionIterative : public virtual Solution {
public:
    virtual void new_cycle(bool end_of_stage = false) = 0;
 
    // virtual void set_subcase_id(int subcase_id_) {
    //     UnimplementedError() << THROW;
    // }
 
    virtual void terminate_cycle(double time, double dtime, const RTable& attributes) = 0;
 
    virtual void terminate_stage(bool success = true) = 0;
 
    virtual size_t get_cycle_id() = 0;
 
    virtual size_t get_subcycle_id() = 0;
 
    virtual std::string get_domain_state_id() = 0;
};
 
template <typename DOF_TYPE>
class SolutionStaticNonlinear : public virtual SolutionIterative {
public:
    virtual void set_dof(
          double time, const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& nbc,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& residue,
          bool unconverged_subcycle = false) = 0;
 
    virtual void set_equilibrium(
          double time, const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual void get_dof(double& time, b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_ref> dof) = 0;
};
 
template <typename DOF_TYPE>
class SolutionFreeVibration : public virtual Solution {
public:
    // virtual void set_subcase_id(int subcase_id_) {
    //     UnimplementedError() << THROW;
    // }
 
    virtual void which_modes(
          int& number_of_mode, char which[3], DOF_TYPE& sigma_min, DOF_TYPE& sigma_max) const = 0;
    virtual void set_mode(
          int mode, DOF_TYPE eigenvalue,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& eigenvector) = 0;
 
    virtual void set_modes(
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& eigenvalue,
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle_increment_constref>& eigenvector) {
        for (size_t i = 0; i != eigenvalue.size(); ++i) {
            set_mode(int(i), eigenvalue[i], eigenvector[i]);
        }
    }
};
 
template <typename DOF_TYPE>
class SolutionLinearisedPrebuckling : public virtual SolutionStaticLinear<DOF_TYPE> {
public:
    virtual void which_modes(int& number_of_mode, char which[3], DOF_TYPE& sigma) const = 0;
 
    virtual void set_mode(
          int mode, DOF_TYPE eigenvalue,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& eigenvector) = 0;
 
    virtual void set_modes(
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& eigenvalue,
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle_increment_constref>& eigenvector) {
        for (size_t i = 0; i != eigenvalue.size(); ++i) {
            set_mode(int(i), eigenvalue[i], eigenvector[i]);
        }
    };
};
 
template <typename DOF_TYPE>
class SolutionTaylorExpansionsBuckling : public virtual Solution {
public:
    // virtual void set_subcase_id(int subcase_id_) {
    //     UnimplementedError() << THROW;
    // }
 
    virtual void which_modes(int& number_of_mode, char which[3], DOF_TYPE& sigma) const = 0;
 
    virtual void set_path(
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle_constref>& path,
          const b2linalg::Vector<double, b2linalg::Vdense_constref>& time) = 0;
 
    virtual void set_solution(
          const int mode, const double cc, const double cci,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof, const double time,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& nbc,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& residue,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& eigenvector) = 0;
};
 
template <typename DOF_TYPE>
class SolutionDynamicNonlinear : public virtual SolutionIterative {
public:
    virtual void set_solution(
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle_constref>& dof, const double time,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& nbc,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& residue,
          bool unconverged_subcycle = false) = 0;
};
 
template <typename DOF_TYPE, typename MATRIX_FORMAT>
class SolutionModelReduction : public virtual Solution {
public:
    // virtual void set_subcase_id(int subcase_id_) {
    //     UnimplementedError() << THROW;
    // }
 
    virtual void get_interface_dof(b2linalg::Index& interface_dof) = 0;
 
    virtual void set_reduction(
          const size_t nb_interface_dof,
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle>& basis,
          std::vector<b2linalg::Matrix<DOF_TYPE, MATRIX_FORMAT> >& reduced_matrix) = 0;
};
 
class SolutionBeamCrossSection : public virtual Solution {
public:
    // virtual void set_subcase_id(int subcase_id_) {
    //     UnimplementedError() << THROW;
    // }
 
    virtual void set_solution(
          const double neutral_point[2], const double inertia_mass, const double inertia_point[2],
          const double inertia_moment[3],
          const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& dof,
          const b2linalg::Matrix<double> strain[7], const b2linalg::Matrix<double> stress[7],
          const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& constitutive_matrix,
          const b2linalg::Vector<double, b2linalg::Vdense_constref>& constant_load) = 0;
};
 
// monolithic
template <typename DOF_TYPE>
class SolutionMonolithic : public virtual SolutionIterative {
public:
    // virtual bool compute_dof() const = 0;
 
    virtual void set_dof(const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    // virtual void get_dof(b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_ref> dof) = 0;
 
    // virtual bool compute_natural_boundary_condition() const = 0;
 
    virtual void set_natural_boundary_condition(
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual bool compute_constraint_value() const = 0;
 
    // virtual void set_constraint_value(
    //       const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual void set_solution(
          const b2linalg::Matrix<DOF_TYPE, b2linalg::Mrectangle_constref>& dof, const double time,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& nbc,
          const b2linalg::Vector<DOF_TYPE, b2linalg::Vdense_constref>& residue,
          bool unconverged_subcycle = false) = 0;
};
 
}  // namespace b2000
#endif