gsPde.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsPde/gsBoundaryConditions.h>
#include <gsCore/gsMultiPatch.h>
#include <gsCore/gsPiecewiseFunction.h>
 
namespace gismo
{
 
 
template<class T>
class gsPde
{
protected:
    gsPde()
    {
    }
public:
    typedef memory::shared_ptr<gsPde> Ptr;
    typedef memory::unique_ptr<gsPde> uPtr;
    
    gsPde(const gsMultiPatch<T> &domain, const gsBoundaryConditions<T> &bc)
        : m_domain(domain), m_boundary_conditions(bc)
    {}
 
    virtual ~gsPde() 
    { }
    
    gsMultiPatch<T>       & domain() {return m_domain;}
 
    const gsMultiPatch<T> & domain() const {return m_domain;}
 
    gsMultiPatch<T>       & patches() {return m_domain;}
 
    const gsMultiPatch<T> & patches() const {return m_domain;}
 
    gsBoundaryConditions<T> &boundaryConditions() {return m_boundary_conditions;}
 
    const gsBoundaryConditions<T> &boundaryConditions() const {return m_boundary_conditions;}
 
    const gsBoundaryConditions<T> & bc() const {return m_boundary_conditions;}
 
    // Is the associated linear system symmetric?
    // TODO: Remove, because it depends on the method and the used
    // discretization and test spaces whether the resulting linear system
    // is symmetric or not. Hence, the isSymmetric()-Flag does not
    // make too much sense in the specification of the PDE.
    //
    // As of now, the function still remains, because it is called
    // by some other functions.
    virtual bool isSymmetric() const {gsWarn<<"Function is gsPde::isSymmetric should not be used!!"; return false;}
 
    virtual std::ostream &print(std::ostream &os) const = 0;
 
    const gsVector<unsigned> & unknownDim() const
    {
        return m_unknownDim;
    }
 
    int numUnknowns() const
    {
        return m_unknownDim.size();
    }
 
    virtual int numRhs() const
    {
        return 1;
    }
    GISMO_DEPRECATED
    int fieldDim(index_t field_id = 0)
    {
        GISMO_ASSERT(field_id<numUnknowns(),"Asked for size of an Unknown field for this PDE type");
        return m_unknownDim[field_id];
    }
    
    GISMO_DEPRECATED bool solutionGiven(index_t field_id = 0) const
    { GISMO_UNUSED(field_id); return false;}
    
    const std::vector<gsFunction<T>*> &solutions() const
    { GISMO_ERROR("Deprecated"); }
    
    gsFunction<T>* solution(index_t field_id = 0) const
    { GISMO_UNUSED(field_id); return NULL; }
    
    GISMO_DEPRECATED
    short_t dim() const
    {
        return m_domain.dim();
    }
 
    virtual gsPde<T>* restrictToPatch(unsigned) const{GISMO_NO_IMPLEMENTATION}
 
protected:
    gsVector<unsigned>                 m_unknownDim;
 
    gsMultiPatch<T>                       m_domain;
    gsBoundaryConditions<T>               m_boundary_conditions;
 
}; // class gsPde
 
template<class T>
std::ostream &operator<<(std::ostream &os, const gsPde<T>& pde)
{
    return pde.print(os);
}
 
} // namespace gismo