wdg6.h

// -*-C++-*-
// ==========================================================================
// Module libfe
// File wdg6.h
// Declaration of class Wedge6
//
// Inheritance:
// ------------
// Element
// ---> Element_Unstructured
//      ---> Element_Unstructured_3D
//           ---> Wedge6
// ==========================================================================

#ifndef __WDG6_H
#define __WDG6_H

class FELIB Wedge6: public Element_Unstructured_3D {
public:

    Wedge6 () { Node = new int[nNode()]; };
    Wedge6 (const Wedge6 &el);
    ~Wedge6 () { delete []Node; }

    Element *Copy();

    void Initialise (const NodeList& nlist);

    BYTE Type (void) const { return ELID_WDG6; }
    unsigned long GetCaps () const { return 0; }
    int nNode (void) const { return 6; }
    int nSide (void) const { return 5; }
    int nSideNode (int side) const;
    int SideNode (int side, int node) const;

    Point Local (const NodeList& nlist, const Point& glob) const;
    Point NodeLocal (int node) const;
    RVector DirectionCosine (int side, RDenseMatrix& jacin);
    const RVector &LNormal (int side) const;
    bool LContains (const Point& loc, bool pad = true) const;

    RVector LocalShapeF (const Point &loc) const;
    RDenseMatrix LocalShapeD (const Point &loc) const;

    double IntF (int i) const
    { ERROR_UNDEF; return 0; }

    RSymMatrix IntFF () const;
    // Return integral over element of product of shape functions:
    // FF = Int_el { F_i(r) F_j(r) } dr

    double IntFF (int i, int j) const;
    // Return a single element of IntFF

    double IntFFF (int i, int j, int k) const
    {
        ERROR_UNDEF;
    return 0.0; // dummy
    }
    // returns a single element of integral over element of product of three
    // shape functions:
    // IntFFF = Int_el { F_i(r) * F_j(r) * F_k(r) } dr

    void IntFFF (double &iii, double &iij, double &ijk) const
    { ERROR_UNDEF; }
    // returns the values of the FFF tensor for:
    //   all indices equal (iii)
    //   two indices equal (iij)
    //   all indices different (ijk)

    RSymMatrix IntPFF (const RVector& P) const
    {
        ERROR_UNDEF;
    return RSymMatrix(); // dummy
    }
    // Returns integral over element of product of two shape functions and a
    // function P defined on nodes:
    // PFF = Int_el { P(r) F_i(r) F_J(r) } dr
    // Vector P contains the complete nodal solution for the mesh

    double IntPFF (int i, int j, const RVector& P) const
    {
        ERROR_UNDEF;
    return 0.0; // dummy
    }
    // Returns a single element of IntPFF

    double IntFDD (int i, int j, int k) const
    {
        ERROR_UNDEF;
    return 0.0; // dummy
    }
    // returns a single element of integral over element:
    // IntFDD = Int_el { F_i(r) * D_j(r) * D_k(r) } dr
    // IntFDD = IntDD/3 ? CHECK THIS IS REALLY CORRECT!

    RSymMatrix IntPDD (const RVector& P) const
    {
        ERROR_UNDEF;
    return RSymMatrix(); // dummy
    }
    // Returns integral over element of product of two shape derivatives and a
    // function P defined in nodal basis:
    // PDD = Int_el { P(r) D_i(r) D_j(r) } dr
    // Vector P contains the complete nodal solution for the mesh

    double IntPDD (int i, int j, const RVector &P) const
    {
        ERROR_UNDEF;
    return 0.0; // dummy
    }
    // Returns a single element of IntPDD

    double BndIntFFSide (int i, int j, int sd)
    { ERROR_UNDEF; return 0; }

    RSymMatrix BndIntPFF (const RVector &P) const
    {
        ERROR_UNDEF;
    return RSymMatrix(); // dummy
    }

    double BndIntPFF (int i, int j, const RVector &P) const
    {
        ERROR_UNDEF;
    return 0.0; // dummy
    }
    // Returns a single element of BndIntPFF

    int GlobalIntersection (const NodeList &nlist, const Point &p1,
        const Point &p2, Point **list);
    // same as 'Intersection' but p1 and p2 given in global coords
    // The return list however is still in local coords
 
    int Intersection (const Point &p1, const Point &p2, Point** pi);
    // creates a list of points where the line defined by p1 and p2 intersects
    // the element (in local coordinates) or starts/ends within the element.
    // Returns the length of the list

protected:

    double ComputeSize (const NodeList &nlist) const;
    RSymMatrix ComputeIntDD (const NodeList &nlist) const;
    // Returns integral over element of product of shape derivatives:
    // DD = Int_el { D_i(r) D_j(r) } dr

    RSymMatrix ComputeBndIntFF (const NodeList& nlist) const
    {
        ERROR_UNDEF;
    return RSymMatrix(); // dummy
    }
    // Returns line integral of product of two shape functions along sides of
    // the element which belong to the mesh boundary
    // If the element does not contain any boundary sides then the returned
    // matrix is empty.

private:

    int QuadRule (const double **wght, const Point **absc) const;
    // calculates abscissae and weights for numerical quadrature rules on
    // standard element, return number of points

    int BndQuadRule (int, double**, Point**, double*)
    { return 0; }
    // not implemented

#ifdef UNDEF
    double UnitLength (Point& /*loc*/, Matrix& geom, int side);
    // returns the unit length along the specified element side; used for line
    // integrations

    void ConvLineQuadrature (Point** absc, double* labsc, int nqp, int side,
        double* coeff);
    // forms line integration rule along side from equivalent 1d integration
    // rule
#endif

    RSymMatrix ComputeIntFF (const NodeList &nlist) const;
    // Returns integral over element of product of shape functions:
    // FF = Int_el { F_i(r) F_j(r) } dr

    RSymMatrix intff;
    // stores integral over element of product of shape functions
    // Int_el { F_i(r) F_j(r) } dr
    // set by Initialise
};

#endif // !__WDG6_H