b2super_element_properties.H

//------------------------------------------------------------------------
// b2super_element_properties.H --
//
// written by doreille
//
// Copyright (c) 2010-2012 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 B2SUPER_ELEMENT_PROPERTIES_H_
#define B2SUPER_ELEMENT_PROPERTIES_H_
 
#include "model/b2element.H"
#include "utils/b2linear_algebra.H"
 
namespace b2000 {
 
class SuperElementProperty : virtual public ElementProperty {
public:
    virtual size_t get_number_of_nodes() { return nb_nodes; }
 
    virtual size_t get_number_of_internal_dof() { return nb_internal_dof; }
 
    virtual size_t get_number_of_external_dof() { return nb_external_dof; }
 
    virtual std::pair<size_t, size_t> get_interface_reduction_internal_dof() {
        return std::pair<size_t, size_t>(
              nb_internal_dof - nb_interface_reduction_internal_dof, nb_internal_dof);
    }
 
    virtual int get_order() { return d_value_d_dof.size() - 1; }
 
    virtual void get_value(
          b2linalg::Vector<double>& value_, const std::vector<bool>& d_value_d_dof_flags,
          std::vector<b2linalg::Matrix<double, b2linalg::Mpacked> >& d_value_d_dof_) {
        if (!value_.is_null()) {
            if (!value.empty()) {
                value_ = value;
            } else {
                value_.resize(nb_external_dof + nb_internal_dof);
                value_.set_zero();
            }
        }
        if (!d_value_d_dof_.empty()) {
            for (size_t i = 0; i != d_value_d_dof_flags.size(); ++i) {
                if (d_value_d_dof_flags[i]) {
                    if (d_value_d_dof.size() <= i || d_value_d_dof[i].size1() == 0) {
                        d_value_d_dof_[i].resize(nb_external_dof + nb_internal_dof);
                        d_value_d_dof_[i].set_zero();
                    } else {
                        d_value_d_dof_[i] = d_value_d_dof[i];
                    }
                }
            }
        }
    }
 
    virtual int face_field_order(const int face_id, const std::string& field_name) {
        std::pair<int, Element*> face = get_face(face_id);
        return face.second->face_field_order(face.first, field_name);
    }
 
    virtual bool face_field_linear_on_dof(const int face_id, const std::string& field_name) {
        std::pair<int, Element*> face = get_face(face_id);
        return face.second->face_field_linear_on_dof(face.first, field_name);
    }
 
    virtual int face_field_polynomial_sub_face(
          const int face_id, const std::string& field_name,
          b2linalg::Matrix<double, b2linalg::Mrectangle>& sub_nodes,
          std::vector<Element::Triangle>& sub_faces) {
        std::pair<int, Element*> face = get_face(face_id);
        return face.second->face_field_polynomial_sub_face(
              face.first, field_name, sub_nodes, sub_faces);
    }
 
    virtual void face_geom(
          const int face_id,
          const b2linalg::Vector<double, b2linalg::Vdense_constref>& internal_coor,
          b2linalg::Vector<double>& geom,
          b2linalg::Matrix<double, b2linalg::Mrectangle>& d_geom_d_icoor) {
        std::pair<int, Element*> face = get_face(face_id);
        face.second->face_geom(face.first, internal_coor, geom, d_geom_d_icoor);
    }
 
    virtual void face_field_value(
          const int face_id, const std::string& field_name,
          const b2linalg::Vector<double, b2linalg::Vdense_constref>& internal_coor,
          const b2linalg::Matrix<double, b2linalg::Mrectangle_constref>& dof, const double time,
          b2linalg::Vector<double, b2linalg::Vdense>& value,
          b2linalg::Matrix<double, b2linalg::Mrectangle>& d_value_d_icoor,
          b2linalg::Index& dof_numbering,
          b2linalg::Matrix<double, b2linalg::Mrectangle>& d_value_d_dof,
          b2linalg::Index& d_value_d_dof_dep_col) {
        UnimplementedError() << THROW;
    }
 
protected:
    size_t nb_nodes;
    size_t nb_external_dof;
    size_t nb_internal_dof;
    size_t nb_interface_reduction_internal_dof;
    b2linalg::Vector<double> value;
    std::vector<b2linalg::Matrix<double, b2linalg::Mpacked> > d_value_d_dof;
 
    std::pair<int, Element*>& get_face(const int face_id) {
        if (face_id > ssize_t(list_faces.size())) {
            Exception() << "Unknown face id " << face_id << " in element property "
                        << get_object_name() << THROW;
        }
        return list_faces[face_id - 1];
    }
    std::vector<std::pair<int, Element*> > list_faces;
};
 
}  // namespace b2000
 
#endif /* B2SUPER_ELEMENT_PROPERTIES_H_ */