b2boundary_condition.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2boundary_condition.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2016
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef B2BOUNDARY_CONDITION_H_
#define B2BOUNDARY_CONDITION_H_
 
#include "b2ppconfig.h"
#include "utils/b2linear_algebra.H"
#include "utils/b2object.H"
#include "utils/b2type.H"
 
namespace b2000 {
 
class Model;
class Case;
class SolverHints;
 
class NaturalBoundaryCondition : public Object {
public:
    virtual void set_model(Model& model) = 0;
 
    virtual void set_case(Case& case_) = 0;
 
    virtual void set_subcase_id(const int subcase_id_) = 0;
 
    enum Type {
        none = 0,
 
        constant = 1,
 
        conservative = 2,
 
        noconservative = 3
    };
 
    virtual Type get_type() const = 0;
 
    typedef ObjectTypeIncomplete<NaturalBoundaryCondition> type_t;
    static type_t type;
};
 
template <typename T, typename MATRIX_TYPE = b2linalg::Msym_compressed_col_update_inv>
class TypedNaturalBoundaryCondition : public virtual NaturalBoundaryCondition {
public:
    virtual void get_nonlinear_value(
          const b2linalg::Vector<T, b2linalg::Vdense_constref>& dof, double time,
          EquilibriumSolution equilibrium_solution, b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, MATRIX_TYPE>& d_value_d_dof,
          b2linalg::Vector<T, b2linalg::Vdense_ref> d_value_d_time, SolverHints* solver_hints) {
        TypeError() << THROW;
    }
 
    virtual void get_linear_value(
          b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, MATRIX_TYPE>& d_value_d_dof, double time = 1) {
        get_nonlinear_value(
              b2linalg::Vector<T, b2linalg::Vdense_constref>::null, 0, false, value, d_value_d_dof,
              b2linalg::Vector<T, b2linalg::Vdense_ref>::null, 0);
    }
 
    virtual void save_nonlinear_value(
          const std::string& name, const b2linalg::Vector<T, b2linalg::Vdense_constref>& dof,
          double time = 0) {
        TypeError() << THROW;
    }
 
    virtual void save_linear_value(const std::string& name) { TypeError() << THROW; }
 
    typedef TypedNaturalBoundaryCondition typed_base_t;
};
 
class EssentialBoundaryCondition : public Object {
public:
    virtual void set_model(Model& model) = 0;
 
    virtual void set_case(Case& case_) = 0;
 
    enum Type {
        none = 0,
 
        constant_value = 1,
 
        constant_derivative = 2,
 
        noconstant_derivative = 3
    };
 
    virtual Type get_type() const = 0;
 
    virtual size_t get_size(const bool linear) = 0;
 
    typedef ObjectTypeIncomplete<EssentialBoundaryCondition> type_t;
    static type_t type;
};
 
template <typename T>
class TypedEssentialBoundaryCondition : public virtual EssentialBoundaryCondition {
public:
    virtual void get_nonlinear_value(
          const b2linalg::Vector<T, b2linalg::Vdense_constref>& dof, double time,
          EquilibriumSolution equilibrium_solution, b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, b2linalg::Mcompressed_col>& d_value_d_dof_trans,
          b2linalg::Vector<T, b2linalg::Vdense_ref> d_value_d_time, SolverHints* solver_hints) {
        TypeError() << THROW;
    }
 
    virtual void get_linear_value(
          b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, b2linalg::Mcompressed_col>& d_value_d_dof_trans, double time = 1) {
        get_nonlinear_value(
              b2linalg::Vector<T, b2linalg::Vdense_constref>::null, 0, false, value,
              d_value_d_dof_trans, b2linalg::Vector<T, b2linalg::Vdense_ref>::null, 0);
    }
 
    typedef TypedEssentialBoundaryCondition typed_base_t;
};
 
class ModelReductionBoundaryCondition : public Object {
public:
    virtual void set_model(Model& model) = 0;
 
    virtual void set_case(Case& case_) = 0;
 
    enum Type {
        none = 0,
 
        const_value = 1,
 
        const_derivative = 2,
 
        noconstant_derivative_constant_struct = 3
    };
 
    virtual Type get_type() const = 0;
 
    typedef ObjectTypeIncomplete<ModelReductionBoundaryCondition> type_t;
    static type_t type;
};
 
template <typename T>
class TypedModelReductionBoundaryCondition : public virtual ModelReductionBoundaryCondition {
public:
    virtual size_t get_size(
          const bool linear, const b2linalg::Vector<T, b2linalg::Vdense_constref>& dof,
          double time) = 0;
 
    virtual void get_nonlinear_value(
          const b2linalg::Vector<T, b2linalg::Vdense_constref>& dof, double time,
          EquilibriumSolution equilibrium_solution, b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, b2linalg::Mcompressed_col>& d_value_d_dof_trans,
          b2linalg::Matrix<T, b2linalg::Mrectangle_ref> d_value_d_time, SolverHints* solver_hints) {
        TypeError() << THROW;
    }
 
    virtual void get_linear_value(
          b2linalg::Vector<T, b2linalg::Vdense_ref> value,
          b2linalg::Matrix<T, b2linalg::Mcompressed_col>& d_value_d_dof_trans, double time = 1) {
        get_nonlinear_value(
              b2linalg::Vector<T, b2linalg::Vdense_constref>::null, 0, true, value,
              d_value_d_dof_trans, b2linalg::Matrix<T, b2linalg::Mrectangle_ref>::null, 0);
    }
 
    virtual void get_nonlinear_inverse_value(
          const b2linalg::Matrix<T, b2linalg::Mrectangle_constref>& value, double time,
          b2linalg::Matrix<T, b2linalg::Mrectangle_ref> dof) = 0;
 
    typedef TypedModelReductionBoundaryCondition typed_base_t;
};
 
}  // namespace b2000
 
#endif  // B2BOUNDARY_CONDITION_H_