subdomain_array.h

Go to the documentation of this file.

#ifndef SUBDOMAIN_ARRAY_T_H
#define SUBDOMAIN_ARRAY_T_H
 
// STL includes
#include <limits>
#include <algorithm>
 
// Wx includes
#include "lib/wxany.h"
 
// Wm includes
#include "lib/wmdomain.h"
#include "basis/basis.h"
#include "array/array.h"
#include "dfem/array/patch_array.h"
#include "lib/wmunstructuredpatch.h"
 
namespace wxm
{
namespace dfem
{
namespace array
{
 
class subdomain_array_t
{
public:
    typedef std::map<int, patch_array_t*> patch_array_map_t;
 
    subdomain_array_t(const WmDomain& domain,
                      const std::string& subdomain_name,
                      bool is_virtual,
                      const WxRange& element_range);
 
    virtual ~subdomain_array_t();
 
    void fill(const real& value);
 
    virtual void dump(WxIoBase& io,
                      WxIoNodeType& group_node,
                      bool include_ghost_elements = false) const;
 
    virtual void load(WxIoBase& io,
                      const WxIoNodeType& group_node,
                      bool include_ghost_elements = false);
 
    patch_array_t& patch_array(const int patch_index);
 
    const patch_array_t& patch_array(const int patch_index) const;
 
    //    /**
    //     * @brief Returns the subdomain name associated with this array
    //     * @return Subdomain name
    //     */
    //    const std::string & subdomain_name() const {return _subdomain_name;}
 
    friend std::ostream& operator<<(std::ostream& stream,
                                    const wxm::dfem::array::subdomain_array_t& array)
    {
        stream << "Array for subdomain '" << array._subdomain_name << "':\n";
        for (auto& patch_array_pair : array._patch_array_map)
        {
            const int patch_index = patch_array_pair.first;
            const wxm::dfem::array::patch_array_t& patch_array =
                *(patch_array_pair.second);
            stream << "Patch index '" << patch_index << "' : ";
            stream << patch_array << "\n";
        }
        return stream;
    }
 
    const std::string& name() const
    {
        return _subdomain_name;
    }
 
    bool is_virtual() const
    {
        return is_virtual_;
    }
 
protected:
    const WmDomain& _domain;
 
    std::string _subdomain_name;
 
    patch_array_map_t _patch_array_map;
 
    const WxRange& _element_range;
 
    WxRange _global_range;
 
    int _mesh_id;
 
    bool is_virtual_;
 
private:
    subdomain_array_t();
 
    subdomain_array_t(const subdomain_array_t& other);
 
    subdomain_array_t& operator=(const subdomain_array_t& other);
};
 
} // namespace array
} // namespace dfem
} // namespace wxm
 
#endif // SUBDOMAIN_ARRAY_T_H