b2node.H

Go to the documentation of this file.

//------------------------------------------------------------------------
// b2node.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012,2017
//     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 __B2NODE_H__
#define __B2NODE_H__
 
#include <utility>
#include <vector>
 
#include "b2ppconfig.h"
#include "model/b2degrees_of_freedom.H"
#include "model/b2referential.H"
#include "utils/b2exception.H"
#include "utils/b2linear_algebra.H"
#include "utils/b2module.H"
#include "utils/b2object.H"
#include "utils/b2type.H"
 
namespace b2000 {
 
class Node : public DegreesOfFreedom {
public:
    Node() : id(0), object_name("???") {}
 
    size_t get_id() const { return id; }
 
    void set_id(size_t id_) { id = id_; }
 
    const std::string& get_object_name() const override { return object_name; }
 
    void set_object_name(const std::string& name) { object_name = name; }
 
    virtual void init() {}
 
    virtual int get_number_of_coor() const = 0;
 
    virtual void set_coor(const double* coor) = 0;
 
    virtual void set_coor(const b2000::csda<double>* coor) = 0;
 
    template <typename T>
    std::pair<int, const T*> get_coor() const;
 
    virtual std::pair<int, const double*> get_coor_double() const = 0;
 
    virtual std::pair<int, const b2000::csda<double>*> get_coor_csda() const = 0;
 
    virtual double* get_coor(double* c) const = 0;
 
    virtual b2000::csda<double>* get_coor(b2000::csda<double>* c) const = 0;
 
    static double* get_coor_s(double* c, const Node* node) { return node->get_coor(c); }
 
    static b2000::csda<double>* get_coor_s(b2000::csda<double>* c, const Node* node) {
        return node->get_coor(c);
    }
 
    virtual void set_weight(const double& weight) = 0;
 
    virtual void set_weight(const b2000::csda<double>& weight) = 0;
 
    virtual double get_weight() const = 0;
 
    virtual b2000::csda<double> get_weight_csda() const = 0;
 
    static size_t* get_global_dof_numbering_s(size_t* index, const Node* node) {
        return node->get_global_dof_numbering(index);
    }
 
    virtual void get_common_dofs(const Node& node, std::vector<std::pair<int, int> >& cdofs) const {
        UnimplementedError() << THROW;
    }
 
    virtual bool is_subnode(const Node* node) const { return true; }
 
    typedef ObjectTypeIncomplete<Node> type_t;
 
    virtual type_t* get_object_type() { return &type; }
 
    static type_t type;
    static double one;
 
private:
    size_t id;
    std::string object_name;
 
    std::pair<int, const double*> get_coor_py() { return get_coor_double(); }
 
    void set_coor_py(std::pair<int, const double*> coor) {
        if (coor.first != get_number_of_coor()) { Exception() << THROW; }
        set_coor(coor.second);
    }
};
 
template <>
inline std::pair<int, const double*> Node::get_coor<double>() const {
    return get_coor_double();
}
 
template <>
inline std::pair<int, const b2000::csda<double>*> Node::get_coor<b2000::csda<double> >() const {
    return get_coor_csda();
}
 
template <typename DOF_TYPE>
class TypedNode : public Node {
public:
    virtual void get_d_gdof_d_ldof(
          const Transformation3D<double>& ltog,
          b2linalg::Matrix<double, b2linalg::Mcompressed_col>& m) const = 0;
 
    virtual void get_d_gdof_d_ldof(
          const Transformation3D<b2000::csda<double> >& ltog,
          b2linalg::Matrix<b2000::csda<double>, b2linalg::Mcompressed_col>& m) const = 0;
 
    static DOF_TYPE* get_dof_s(const DOF_TYPE* global_dof, DOF_TYPE* local_dof, const Node* node) {
        return node->get_dof(global_dof, local_dof);
    }
};
 
struct NodeListNull {
    template <typename NODE>
    static double* get_coor(double* coor, NODE** node) {
        return coor;
    }
    template <typename NODE>
    static size_t get_number_of_dof(NODE** node_) {
        return 0;
    }
    template <typename NODE>
    static size_t* get_global_dof_numbering(size_t* index, NODE** node) {
        return index;
    }
    template <typename NODE, typename DOF_TYPE>
    static DOF_TYPE* get_dof(const DOF_TYPE* global_dof, DOF_TYPE* local_dof, NODE** node) {
        return local_dof;
    }
};
 
template <typename NODE_TYPE, typename NODE_LIST = NodeListNull>
struct NodeList {
    typedef typename NODE_TYPE::value_type value_type;
 
    template <typename NODE>
    static double* get_coor(double* coor, NODE** node) {
        coor = NODE_TYPE::get_coor_s(coor, *node);
        return NODE_LIST::get_coor(coor, ++node);
    }
 
    template <typename NODE>
    static b2000::csda<double>* get_coor(b2000::csda<double>* coor, NODE** node) {
        coor = NODE_TYPE::get_coor_s(coor, *node);
        return NODE_LIST::get_coor(coor, ++node);
    }
 
    template <typename NODE>
    static size_t get_number_of_dof(NODE** node) {
        const size_t tmp = NODE_TYPE::get_number_of_dof_s(*node);
        return tmp + NODE_LIST::get_number_of_dof(++node);
    }
    template <typename NODE>
    static size_t* get_global_dof_numbering(size_t* index, NODE** node) {
        index = NODE_TYPE::get_global_dof_numbering_s(index, *node);
        return NODE_LIST::get_global_dof_numbering(index, ++node);
    }
 
    template <typename NODE, typename DOF_TYPE>
    static DOF_TYPE* get_dof(const DOF_TYPE* global_dof, DOF_TYPE* local_dof, NODE** node) {
        local_dof = NODE_TYPE::get_dof_s(global_dof, local_dof, *node);
        return NODE_LIST::get_dof(global_dof, local_dof, ++node);
    }
};
 
namespace node {
extern Module module;
}
 
}  // namespace b2000
 
#endif