gsFlowTerms.h

Go to the documentation of this file.

 
#pragma once
#include <gismo.h>
 
namespace gismo
{
 
template <class T>
class gsFlowTerm
{
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsFlowTerm> Ptr; 
    typedef memory::unique_ptr<gsFlowTerm> uPtr;
 
 
protected: // *** Class members ***
 
    unsigned m_geoFlags, m_testFunFlags, m_shapeFunFlags; // evaluation flags
    gsVector<T> m_coeff;
 
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm()
    {
        m_geoFlags = 0;
        m_testFunFlags = 0;
        m_shapeFunFlags = 0;
    }
 
    virtual ~gsFlowTerm()
    {}
 
 
public: // *** Member functions ***
 
    virtual void assemble(const gsMapData<T>& mapData, const gsVector<T>& quWeights, const std::vector< gsMatrix<T> >& testFunData, const std::vector< gsMatrix<T> >& shapeFunData, gsMatrix<T>& localMat)
    { GISMO_NO_IMPLEMENTATION }
 
    virtual void assemble(const gsMapData<T>& mapData, const gsVector<T>& quWeights, const std::vector< gsMatrix<T> >& testFunData, const std::vector< gsMatrix<T> >& shapeFunData, std::vector< gsMatrix<T> >& localMat)
    { GISMO_NO_IMPLEMENTATION }
 
    void updateEvalFlags(unsigned& geoFlags, unsigned& testFunFlags, unsigned& shapeFunFlags)
    { 
        geoFlags |= m_geoFlags;
        testFunFlags |= m_testFunFlags;
        shapeFunFlags |= m_shapeFunFlags;
    }
 
 
protected: // *** Member functions ***
 
    void setConstCoeff(T value)
    {
        m_coeff.resize(1);
        m_coeff << value;
    }
 
    virtual void evalCoeff(const gsMapData<T>& mapData)
    { setConstCoeff(1.0); }
 
    virtual gsVector<T> getCoeffGeoMapProduct(const gsMapData<T>& mapData);
 
};
 
// ===================================================================================================================
 
template <class T>
class gsFlowTermNonlin : public gsFlowTerm<T>
{
 
public: // *** Smart pointers ***
 
    typedef memory::shared_ptr<gsFlowTermNonlin> Ptr; 
    typedef memory::unique_ptr<gsFlowTermNonlin> uPtr;
 
public: // *** Type definitions ***
 
    typedef gsFlowTerm<T> Base;
 
 
protected: // *** Class members ***
 
    gsField<T> m_currentSolU;
    bool m_isCurrentSolSet;
    gsMatrix<T> m_solUVals;
 
 
public: // *** Constructor/destructor ***
 
    gsFlowTermNonlin()
    { }
 
 
public: // *** Member functions ***
 
    void setCurrentSolution(std::vector<gsField<T> >& solutions)
    { 
        m_currentSolU = solutions.front();
        m_isCurrentSolSet = true;
    }
 
    void setCurrentSolution(gsField<T>& solution)
    { 
        m_currentSolU = solution;
        m_isCurrentSolSet = true;
    }
 
 
protected: // *** Member functions ***
 
    virtual void computeCoeffSolU(const gsMapData<T>& mapData)
    { 
        GISMO_ASSERT(m_isCurrentSolSet, "No velocity solution set in gsFlowTermNonlin.");
 
        m_solUVals.resize(mapData.dim.first, mapData.points.cols());
        m_solUVals = m_currentSolU.value(mapData.points, mapData.patchId);
    }
 
};
 
// ===================================================================================================================
// ===================================================================================================================
 
template <class T>
class gsFlowTerm_ValVal : public gsFlowTerm<T>
{
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm_ValVal()
    {
        this->m_geoFlags = NEED_MEASURE;
        this->m_testFunFlags = NEED_VALUE;
        this->m_shapeFunFlags = NEED_VALUE;
    }
 
 
public: // *** Member functions ***
 
    virtual void assemble(const gsMapData<T>& mapData, const gsVector<T>& quWeights, const std::vector< gsMatrix<T> >& testFunData, const std::vector< gsMatrix<T> >& shapeFunData, gsMatrix<T>& localMat);
 
};
 
// ===================================================================================================================
 
template <class T>
class gsFlowTerm_TimeDiscr : public gsFlowTerm_ValVal<T>
{
 
protected: // *** Class members ***
 
    real_t m_timeStep;
 
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm_TimeDiscr(real_t timeStep) :
    m_timeStep(timeStep)
    { }
 
 
protected: // *** Member functions ***
 
    virtual void evalCoeff(const gsMapData<T>& mapData0)
    { this->setConstCoeff(1./m_timeStep); }
 
};
 
// ===================================================================================================================
 
template <class T>
class gsFlowTerm_GradGrad : public gsFlowTerm<T>
{
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm_GradGrad()
    {
        this->m_geoFlags = NEED_MEASURE | NEED_GRAD_TRANSFORM;
        this->m_testFunFlags = NEED_DERIV;
        this->m_shapeFunFlags = NEED_DERIV;
    }
 
 
public: // *** Member functions ***
 
    virtual void assemble(const gsMapData<T>& mapData, const gsVector<T>& quWeights, const std::vector< gsMatrix<T> >& testFunData, const std::vector< gsMatrix<T> >& shapeFunData, gsMatrix<T>& localMat);
 
};
 
// ===================================================================================================================
 
template <class T>
class gsFlowTerm_Diffusion : public gsFlowTerm_GradGrad<T>
{
 
protected: // *** Class members ***
 
    real_t m_viscosity;
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm_Diffusion(real_t viscosity) :
    m_viscosity(viscosity)
    { }
 
 
protected: // *** Member functions ***
 
    virtual void evalCoeff(const gsMapData<T>& mapData)
    { this->setConstCoeff(m_viscosity); }
 
};
 
// ===================================================================================================================
// ===================================================================================================================
 
template <class T>
class gsFlowTerm_rhs : public gsFlowTerm<T>
{
 
protected: // *** Class members ***
 
    const gsFunction<T>* m_pRhsFun;
    gsMatrix<T> m_rhsVals;
 
public: // *** Constructor/destructor ***
 
    gsFlowTerm_rhs(const gsFunction<T>* pRhsFun)
    {
        this->m_geoFlags = NEED_VALUE | NEED_MEASURE;
        this->m_testFunFlags = NEED_VALUE;
        m_pRhsFun = pRhsFun;
    }
 
 
public: // *** Member functions ***
 
    virtual void assemble(const gsMapData<T>& mapData, const gsVector<T>& quWeights, const std::vector< gsMatrix<T> >& testFunData, const std::vector< gsMatrix<T> >& shapeFunData, gsMatrix<T>& localMat);
 
};
 
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsFlowTerms.hpp)
#endif