unique_distributed_variable.h

Go to the documentation of this file.

#pragma once
 
// Wm includes
#include "dfem/array/unique_patch_array.h"
#include "dfem/array/unique_subdomain_array.h"
#include "variable/distributed_variable.h"
 
namespace wxm
{
namespace dfem
{
namespace variable
{
 
class UniqueDistributedComponent
{
public:
    UniqueDistributedComponent(const WmDomain& domain,
                               const std::vector<std::string>& subdomain_names,
                               const std::vector<std::string>& virtual_subdomains,
                               const WxRange& element_range);
 
    ~UniqueDistributedComponent();
 
    void fill(const real& value);
 
    wxm::dfem::array::UniquePatchArray& patch_array(const int patch_index);
 
    const wxm::dfem::array::UniquePatchArray& 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);
 
    wxm::dfem::array::UniqueSubdomainArray*
    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::UniquePatchArray*> patch_array_map_t;
    typedef std::map<std::string, wxm::dfem::array::UniqueSubdomainArray*>
        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 UniqueDistributedVariable : public wxm::variable::distributed_variable_t
{
public:
    UniqueDistributedVariable(const WmConstOpaquePtr& parentPointer);
 
    ~UniqueDistributedVariable() override;
 
    void setup(const WxCryptSet& wxc) override;
 
    void fill(const std::vector<real>& values) override;
 
    void swap(variable_t& other) override;
 
    bool check_compatible(const variable_t& other) const override;
 
    void dump(WxIoBase& io, WxIoNodeType& group_node) const override;
 
    void load(WxIoBase& io, const WxIoNodeType& group_node) 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 load_subdomain_data(WxIoBase& io,
                             int component_index,
                             const std::string& subdomain,
                             WxIoNodeType comp_group) override;
 
protected:
    typedef std::vector<UniqueDistributedComponent*> component_arrays_t;
 
    component_arrays_t _component_arrays;
 
    WxRange _element_range;
 
private:
    UniqueDistributedVariable();
 
    UniqueDistributedVariable(const UniqueDistributedVariable& other);
 
    UniqueDistributedVariable& operator=(const UniqueDistributedVariable& other);
};
 
} // namespace variable
} // namespace dfem
} // namespace wxm