gsFlowBndEvaluators.h

Go to the documentation of this file.

 
#pragma once
#include <gsIncompressibleFlow/src/gsFlowSolverParams.h>
 
 
namespace gismo
{
 
template<class T>
class gsFlowBndEvaluator
{
 
protected: // *** Class members ***
    
    const gsFlowSolverParams<T>& m_params;
    std::vector< std::pair<int, boxSide> > m_bndPart;
    gsField<T> m_velocityField;
    gsField<T> m_pressureField;
    gsMapData<T> m_mapData;
    index_t m_unkID; // the index of variable, from which the quantitiy is computed (0 - velocity, 1 - pressure)
    T m_quantValue; // the resulting integral value
 
 
public: // *** Constructor/destructor ***
 
    gsFlowBndEvaluator(const gsFlowSolverParams<T>& params):
    m_params(params)
    {
        initMembers();
    }
 
    gsFlowBndEvaluator(const gsFlowSolverParams<T>& params, const std::vector< std::pair<int, boxSide> >& bndPart):
    m_params(params), m_bndPart(bndPart)
    {
        initMembers();
    }
 
 
protected: // *** Member functions ***
 
    void initMembers()
    {
        m_unkID = 0;
        m_mapData.flags = 0;
        m_quantValue = 0.0;
    }
 
    virtual void evalOnElement(index_t patchID, boxSide side, const gsMatrix<T>& quNodes, const gsVector<T>& quWeights)
    { GISMO_NO_IMPLEMENTATION }
 
    void evalOnPatchSide(index_t patchID, boxSide side);
 
 
public: // *** Member functions ***
 
    void evaluate()
    {
        m_quantValue = 0.0;
 
        for(size_t i = 0; i < m_bndPart.size(); i++)
            evalOnPatchSide(m_bndPart[i].first, m_bndPart[i].second);
    }
 
 
public: // *** Getters/setters ***
 
    void setVelocityField(const gsField<T>& velocity)
    { m_velocityField = velocity; }
 
    void setPressureField(const gsField<T>& pressure)
    { m_pressureField = pressure; }
 
    void setSolutionFields(const gsField<T>& velocity, const gsField<T>& pressure)
    {
        m_velocityField = velocity;
        m_pressureField = pressure;
    }
 
    void setBndPart(const std::vector< std::pair<int, boxSide> >& bndPart)
    { m_bndPart = bndPart; }
 
    T getValue()
    { return m_quantValue; }
 
 
}; // gsFlowBndEvaluator
 
 
// ===================================================================================================================
 
 
template<class T>
class gsFlowBndEvaluator_flowRate : public gsFlowBndEvaluator<T>
{
 
public:
    typedef gsFlowBndEvaluator<T> Base;
 
 
protected: // *** Base class members ***
    
    using Base::m_unkID;
    using Base::m_mapData;
    using Base::m_quantValue;
    using Base::m_velocityField;
 
 
public: // *** Constructor/destructor ***
 
    gsFlowBndEvaluator_flowRate(const gsFlowSolverParams<T>& params):
    Base(params)
    {
        initMembers();
    }
 
    gsFlowBndEvaluator_flowRate(const gsFlowSolverParams<T>& params, const std::vector< std::pair<int, boxSide> >& bndPart):
    Base(params, bndPart)
    {
        initMembers();
    }
 
 
protected: // *** Member functions ***
 
    void initMembers()
    {
        m_unkID = 0;
        m_mapData.flags = NEED_VALUE | NEED_OUTER_NORMAL;
        m_quantValue = 0.0;
    }
 
    virtual void evalOnElement(index_t patchID, boxSide side, const gsMatrix<T>& quNodes, const gsVector<T>& quWeights);
 
}; // gsFlowBndEvaluator_flowRate
 
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsFlowBndEvaluators.hpp)
#endif