st_venant_wall_bnd.h

Go to the documentation of this file.

 
#ifndef D3F_ST_VENANT_WALL_BND_H
#define D3F_ST_VENANT_WALL_BND_H
 
#include "common/common.h"
#include "lib_disc/spatial_disc/user_data/linker/linker.h"
 
namespace ug {
namespace d3f {
 
template<int dim>
class StVenantWallBndDir : public StdDataLinker<StVenantWallBndDir<dim>, number, dim> {
    typedef CplUserData<number, dim>      TNumberData;
    typedef CplUserData<MathVector<dim>, dim> TVectorData;
 
public:
    explicit StVenantWallBndDir(SmartPtr<TVectorData> downstreamvec) 
        : m_downStreamVec(downstreamvec) {}
 
    virtual void operator()(number& value, const MathVector<dim>& globIP, number time, int si) const {
        evaluate(value, globIP, time, si);
    }
 
    template<int refDim>
    void operator()(number vValue[],
                    const MathVector<dim> vGlobIP[],
                    number time, int si,
                    GridObject* elem,
                    const MathVector<dim> vCornerCoords[],
                    const MathVector<refDim> vLocIP[],
                    const size_t nip,
                    LocalVector* u,
                    const MathMatrix<refDim, dim>* vJT = NULL) const 
    {
        evaluate<refDim>(vValue, vGlobIP, time, si, elem, vCornerCoords, vLocIP, nip, u, vJT);
    }
 
    void evaluate(number& value, const MathVector<dim>& globIP, number time, int si) const {
        UG_THROW("StVenantWallBndDir: Solution, element and local IPs required for evaluation.");
    }
 
    template <int refDim>
    void evaluate(number vValue[],
                  const MathVector<dim> vGlobIP[],
                  number time, int si,
                  GridObject* elem,
                  const MathVector<dim> vCornerCoords[],
                  const MathVector<refDim> vLocIP[],
                  const size_t nip,
                  LocalVector* u,
                  const MathMatrix<refDim, dim>* vJT = NULL) const
    {
        if (nip < 1) return;
 
        MathVector<dim> downStreamVec[nip];
        MathVector<dim> elemNormal;
 
        // Calculate the element normal (direction of the edge)
        if (VecDistanceSq(vCornerCoords[1], vGlobIP[0]) < SMALL) {
            elemNormal = vCornerCoords[1];
            elemNormal -= vCornerCoords[0];
        } else {
            elemNormal = vCornerCoords[0];
            elemNormal -= vCornerCoords[1];
        }
        VecNormalize(elemNormal, elemNormal);
 
        // Get the downstream reference vector from user data
        (*m_downStreamVec)(downStreamVec, vGlobIP, time, si, elem, vCornerCoords, vLocIP, nip, u, vJT);
 
        // Compute the alignment (dot product)
        for (size_t ip = 0; ip < nip; ++ip) {
            vValue[ip] = VecDot(downStreamVec[ip], elemNormal);
        }
    }
 
    template <int refDim>
    void eval_and_deriv(number vValue[],
                        const MathVector<dim> vGlobIP[],
                        number time, int si,
                        GridObject* elem,
                        const MathVector<dim> vCornerCoords[],
                        const MathVector<refDim> vLocIP[],
                        const size_t nip,
                        LocalVector* u,
                        bool bDeriv,
                        int s,
                        std::vector<std::vector<number>> vvvDeriv[],
                        const MathMatrix<refDim, dim>* vJT = NULL) const
    {
        evaluate<refDim>(vValue, vGlobIP, time, si, elem, vCornerCoords, vLocIP, nip, u, vJT);
        // Derivative is zero as downstream reference is typically constant or externally defined.
    }
 
    bool requires_grid_fct() const { return true; }
 
private:
    SmartPtr<TVectorData> m_downStreamVec;
};
 
} // namespace d3f
} // namespace ug
 
#endif // D3F_ST_VENANT_WALL_BND_H