distributed_variable.h

Go to the documentation of this file.

#ifndef DISTRIBUTED_VARIABLE_T_H
#define DISTRIBUTED_VARIABLE_T_H
 
// Wm includes
#include "dfem/array/patch_array.h"
#include "dfem/array/subdomain_array.h"
#include "lib/wmunstructuredpatch.h"
#include "lib/wxmsgbase.h"
#include "variable/distributed_variable.h"
#include "variable/variable.h"
 
#include <map>
 
namespace wxm
{
namespace dfem
{
namespace variable
{
 
class distributed_component_t
{
public:
    distributed_component_t(const WmDomain& domain,
                            const std::vector<std::string>& subdomain_names,
                            const std::vector<std::string>& virtual_subdomains,
                            const WxRange& element_range);
 
    ~distributed_component_t();
 
    void fill(const real& value);
 
    wxm::dfem::array::patch_array_t& patch_array(const int patch_index);
 
    const wxm::dfem::array::patch_array_t& patch_array(const int patch_index) const;
 
    bool has_patch_array(const int patch_index) const;
 
    void dump(WxIoBase& io, WxIoNodeType& group_node) const;
 
    void load(WxIoBase& io, const WxIoNodeType& group_node);
 
    array::subdomain_array_t* get_subdomain_array(const std::string& subdomain);
 
protected:
    // This is a quick lookup map used with the patch_array_function
    typedef std::map<int, wxm::dfem::array::patch_array_t*> patch_array_map_t;
    typedef std::map<std::string, wxm::dfem::array::subdomain_array_t*>
        subdomain_arrays_t;
 
    patch_array_map_t _patch_array_map;
    subdomain_arrays_t _subdomain_arrays;
 
    const WmDomain& _domain;
    const std::vector<std::string>& _subdomain_names;
    const std::vector<std::string>& virtual_subdomains_;
    WxRange _element_range;
 
private:
};
 
class distributed_variable_t : public wxm::variable::distributed_variable_t
{
public:
    distributed_variable_t(const WmConstOpaquePtr& parentPointer);
 
    ~distributed_variable_t() override;
 
    void setup(const WxCryptSet& wxc) override;
 
    void swap(wxm::variable::variable_t& otherVar) override;
 
    bool check_compatible(const wxm::variable::variable_t& var) const override;
 
    wxm::array::patch_array_t& patch_array(const int component_index,
                                           const int patch_index) override;
 
    const wxm::array::patch_array_t& patch_array(const int component_index,
                                                 const int patch_index) const override;
 
    bool has_patch_array(const int component_index, const int patch_index) const override;
 
    void fill(const std::vector<real>& values) override;
 
    void dump(WxIoBase& io, WxIoNodeType& group_node) const override;
 
    void load(WxIoBase& io, const WxIoNodeType& group_node) override;
 
    void load_subdomain_data(WxIoBase& io,
                             int component_index,
                             const std::string& subdomain,
                             WxIoNodeType comp_group) override;
 
protected:
    typedef std::vector<distributed_component_t*> component_arrays_t;
 
    component_arrays_t _component_arrays;
 
    WxRange _element_range;
 
    wxm::basis::basis_t* _basis;
 
private:
    distributed_variable_t();
 
    distributed_variable_t(const distributed_variable_t& other);
 
    distributed_variable_t& operator=(const distributed_variable_t& other);
};
} // namespace variable
} // namespace dfem
} // namespace wxm
 
#endif // DISTRIBUTED_VARIABLE_T_H