b2domain.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2domain.H --
//
//
// written by Mathias Doreille
//            Thomas Blome <thomas.blome@dlr.de>
//
// Copyright (c) 2004-2012,2017 SMR Engineering & Development SA
//                              2502 Bienne, Switzerland
//
// Copyright (c) 2023 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//                    Linder Höhe, 51147 Köln
//
// 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 __B2DOMAIN_H__
#define __B2DOMAIN_H__
 
#include <complex>
#include <functional>
#include <string>
#include <vector>
 
#include "b2ppconfig.h"
#include "model/b2element.H"
#include "utils/b2csda.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2object.H"
 
namespace b2000 {
 
class Model;
class Case;
class Node;
class Element;
 
template <typename T>
class TypedElement;
 
class Domain : public Object {
public:
    class NodeIterator {
    public:
        virtual ~NodeIterator() {}
 
        virtual Node* next() = 0;
    };
 
    class ElementIterator {
    public:
        virtual ~ElementIterator() {}
 
        virtual Element* next() = 0;
    };
 
    class NodeConnectivityIterator : public NodeIterator {
    public:
        virtual Node* next(std::vector<Element*>& connectivity) = 0;
    };
 
    struct AdjacentElement {
        Element* element;
 
        /* A vector containing node-internal ID's of nodes
         * connecting to the element.*/
        std::vector<int> internal_node_id_list;
    };
 
    using type_t = ObjectTypeIncomplete<Domain>;
    using node_iterator = std::unique_ptr<NodeIterator>;
    using node_connectivity_iterator = std::unique_ptr<NodeConnectivityIterator>; 
    using element_iterator = std::unique_ptr<ElementIterator>;
 
    virtual void set_model(Model& model) = 0;
 
    virtual void set_case(Case& case_) = 0;
 
    virtual void set_subcase_id(const int subcase_id_) = 0;
 
    virtual size_t get_number_of_dof() const = 0;
 
    virtual size_t get_number_of_elements() const = 0;
 
    virtual size_t get_number_of_elements_and_subelements() const = 0;
 
    virtual size_t get_number_of_nodes() const = 0;
 
    virtual const std::vector<Element::VariableInfo> get_value_info() const = 0;
 
    virtual b2linalg::SparseMatrixConnectivityType get_dof_connectivity_type() const = 0;
 
    virtual bool have_temperature() const = 0;
 
    virtual node_iterator get_node_iterator() = 0;
 
    virtual node_connectivity_iterator get_node_connectivity_iterator();
 
    template <typename T>
    const T* get_node_local_referential(const Node& node) const {
        return 0;
    }
 
    virtual const double* get_node_local_referential_double(const Node& node) const = 0;
 
    virtual const b2000::csda<double>* get_node_local_referential_csda(const Node& node) const = 0;
 
    virtual Node* get_node(const std::string& node_name);
 
    virtual void get_slave_node(std::vector<std::pair<const Node*, const Node*>>& slave_node) = 0;
 
    virtual element_iterator get_element_iterator() = 0;
 
    virtual Element* get_element(const std::string& element_name);
 
    virtual void get_adjacent_elements(
          const Node* node, std::vector<AdjacentElement>& adjacent_elements) {
        return get_adjacent_elements(
              std::pair<int, const Node* const*>(1, &node), adjacent_elements);
    }
 
    virtual void get_adjacent_elements(
          std::pair<int, const Node* const*> node_list,
          std::vector<AdjacentElement>& adjacent_elements) = 0;
 
    virtual void get_elements_of_same_type_near(
          const Element* e, double dist, std::vector<Element*>& element_list) = 0;
    virtual void set_dof(const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& dof) = 0;
 
    void set_dof(const b2linalg::Vector<double, b2linalg::Vdense_constref>& dof) {
        set_dof(b2linalg::Matrix<double, b2linalg::Mrectangle_constref>(dof));
    }
 
    virtual void set_dof(
          const b2linalg::Matrix<b2000::csda<double>, b2linalg::Mrectangle_constref>& dof) = 0;
 
    void set_dof(const b2linalg::Vector<b2000::csda<double>, b2linalg::Vdense_constref>& dof) {
        if (dof.is_null()) {
            set_dof(b2linalg::Matrix<b2000::csda<double>, b2linalg::Mrectangle_constref>::null);
        } else {
            set_dof(b2linalg::Matrix<b2000::csda<double>, b2linalg::Mrectangle_constref>(dof));
        }
    }
 
    virtual void set_dof(
          const b2linalg::Matrix<std::complex<double>, b2linalg::Mrectangle_constref>& dof) = 0;
 
    void set_dof(const b2linalg::Vector<std::complex<double>, b2linalg::Vdense_constref>& dof) {
        if (dof.is_null()) {
            set_dof(b2linalg::Matrix<std::complex<double>, b2linalg::Mrectangle_constref>::null);
        } else {
            set_dof(b2linalg::Matrix<std::complex<double>, b2linalg::Mrectangle_constref>(dof));
        }
    }
 
    virtual const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& get_dof(double) = 0;
 
    virtual const b2linalg::Matrix<b2000::csda<double>, b2linalg::Mrectangle_constref>& get_dof(
          b2000::csda<double>) = 0;
 
    virtual const b2linalg::Matrix<std::complex<double>, b2linalg::Mrectangle_constref>& get_dof(
          std::complex<double>) = 0;
 
    virtual const std::pair<std::map<std::string, size_t>, b2linalg::Index>& get_dof_field() {
        UnimplementedError() << THROW;
        static std::pair<std::map<std::string, size_t>, b2linalg::Index> null;
        return null;
    }
 
    virtual void save_state(const std::string& state_id) = 0;
 
    virtual void load_state(const std::string& state_id) = 0;
 
    virtual void save_field(
          const std::string& name_id,
          const b2linalg::Vector<double, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual void save_field(
          const std::string& name_id,
          const b2linalg::Vector<b2000::csda<double>, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual void save_field(
          const std::string& name_id,
          const b2linalg::Vector<std::complex<double>, b2linalg::Vdense_constref>& dof) = 0;
 
    virtual Element* get_parent_element_and_nodes_mapping(
          Domain& parent_domain, const Element& element,
          b2linalg::Matrix<double>& parent_nodes_internal_coor) {
        UnimplementedError() << THROW;
        return nullptr;
    }
 
    virtual Element* get_parent_element_mapping(
          Domain& parent_domain, const Node& node, b2linalg::Vector<double>& parent_internal_coor) {
        UnimplementedError() << THROW;
        return nullptr;
    }
 
    std::vector<std::reference_wrapper<Element>>& GetElementContainer() {
        if (domain_element_container_.size() == 0) { FillElementContainer(); }
        return domain_element_container_;
    }
 
    void FillElementContainer() {
        auto i = get_element_iterator();
        for (Element* element = i->next(); element != 0; element = i->next()) {
            domain_element_container_.push_back(std::ref(*element));
        }
    }
 
    static type_t type;
 
private:
    // Container holding reference wrappers to all elements of this domain
    std::vector<std::reference_wrapper<Element>> domain_element_container_{};
};
 
template <>
inline const double* Domain::get_node_local_referential<double>(const Node& node) const {
    return get_node_local_referential_double(node);
}
 
template <>
inline const b2000::csda<double>* Domain::get_node_local_referential<b2000::csda<double>>(
      const Node& node) const {
    return get_node_local_referential_csda(node);
}
 
}  // namespace b2000
 
#endif /* __B2DOMAIN_H__ */