wmfunctionapplicator.h

Go to the documentation of this file.

#ifndef WMFUNCTIONAPPLICATOR_H
#define WMFUNCTIONAPPLICATOR_H
 
// Wm includes
#include "hostactions/wmhostaction.h"
//#include "lib/wmvariableparser.h"
#include "variable/distributed_variable.h"
 
// STL includes
#include <vector>
 
class WmICFunction;
class WmFunctionApplicator;
 
class WmFunctionApplicator : public WmHostAction
{
public:
    class applicator_t;
 
    class applicator_t
    {
    public:
        class components_t
        {
        public:
            class component_t
            {
            public:
                friend class components_t;
 
                component_t() : _component_index(-1), _variable(NULL)
                {
                }
 
                wxm::array::patch_array_t& patch_array(const int patch_index)
                {
                    return _variable->patch_array(_component_index, patch_index);
                }
 
                const wxm::array::patch_array_t& patch_array(const int patch_index) const
                {
                    return _variable->patch_array(_component_index, patch_index);
                }
 
            protected:
                int _component_index;
 
                std::string _variable_name;
 
                wxm::variable::distributed_variable_t* _variable;
            };
 
            typedef std::vector<component_t> component_list_t;
 
            components_t() : _parent_solver(NULL)
            {
            }
 
            ~components_t()
            {
                // Everything that components_t owns is deleted automatically
            }
 
            void set_parent_solver(const WmSolverBase& solver)
            {
                _parent_solver = &solver;
            }
 
            int num_components() const
            {
                return _components.size();
            }
 
            void setup(const WxCryptSet& wxc, const std::string& field_name);
 
            wxm::array::patch_array_t& patch_array(const int patch_index,
                                                   const int component_index)
            {
                return _components[component_index].patch_array(patch_index);
            }
 
            const wxm::array::patch_array_t& patch_array(const int patch_index,
                                                         const int component_index) const
            {
                return _components[component_index].patch_array(patch_index);
            }
 
            bool exists_on(const std::string& subdomain_name) const
            {
                for (const component_t& component : _components)
                {
                    if (!component._variable->on_subdomain(subdomain_name))
                    {
                        return false;
                    }
                }
                return true;
            }
 
        protected:
            void parse_variable_name(const std::string& variable_name_set);
 
            const WmSolverBase* _parent_solver;
 
            component_list_t _components;
        };
 
        enum
        {
            WMFUNCTIONAPPLICATOR_MODAL = 1,
            WMFUNCTIONAPPLICATOR_NODAL = 2,
            WMFUNCTIONAPPLICATOR_FV = 3,
            WMFUNCTIONAPPLICATOR_NODAL_KINETIC = 4,
        };
 
        applicator_t(WmFunctionApplicator* parent);
 
        ~applicator_t();
 
        void setup(const WxCryptSet& wxc);
 
        void apply(const WmUnstructuredPatch& patch);
 
        //      /**
        //       * Grabs the components used by this applicator
        //       *
        //       * @return list of components
        //       */
 
        //      const WmVariableParser::componentList_t & getComponents() const {return
        //_args;}
 
    protected:
        WmFunctionApplicator* _parent;
 
        int _spatialScheme;
 
        int _spatialOrder;
 
        std::string _basisSetName;
 
        components_t _components;
 
        WmICFunction* _function;
 
        // Kinetic Piece -> phase space basis order
        std::string _phase_space_order;
 
        // Kinetic Piece -> number of elements in velocity space
        std::vector<int> _vspace_nelems;
 
        // Kinetic Piece -> number of dimensions in velocity space
        int _vspace_dims;
 
        // Kinetic Piece -> minimum v value in each velocity space dimension (vector)
        std::vector<real> _vspace_minimums;
 
        // Kinetic Piece -> delta v in each velocity space dimension (vector)
        std::vector<real> _vspace_dv;
    };
 
    typedef std::vector<WmICFunction*> functions_t;
    typedef std::vector<applicator_t*> applicators_t;
 
    WmFunctionApplicator(const WmConstOpaquePtr& parent_solver);
 
    ~WmFunctionApplicator();
 
    void setup(const WxCryptSet& wxc);
 
    virtual void typeCheck();
 
    WxStepperStatus step();
 
    bool needsDomain() const
    {
        return false;
    }
 
private:
    WmICFunction* has_function(const std::string& name);
 
    const WmDomain& _domain;
 
    applicators_t _applicators;
    functions_t _functions;
};
 
#endif // WMFUNCTIONAPPLICATOR_H