/* $Id: elements2mc.h,v 1.2 1996/10/04 15:06:38 roitzsch Exp $ */

#ifndef ELEMENTS2MC_H
#define ELEMENTS2MC_H

#include "elements2.h"


//-------------------------------------------------------------------------

			// Linear MC-Triangle:


class MCTriangle : public Triangle
{

  public:

    MCTriangle(Material* material, int nComp);
    virtual ~MCTriangle() { }

    virtual int NoOfBaseNodes()const { return 3; }
    virtual int NoOfNodes()    const { return noOfNodes; }

    virtual int NodesOnPoint() const { return nComp; }
    

    //------------------- the special routines  ----------------------

    virtual void assembleConstEllip(const PATCH& elem, Matrix<Real>& A, 
				    const Jacobian& Jac, 
				    const Matrix<Bool>* pattern) const
	    { MCConstEllip2(elem, A, Jac, pattern, nComp, Node); } 

    virtual void assembleConstConvec(const PATCH& elem, Matrix<Real>& A, 
				     const Jacobian& Jac, 
				     const Matrix<Bool>* pattern) const
	    { MCConstConvec2(elem, A, Jac, pattern, nComp, Node); }

    //-------------------------------------------------------------------

    virtual Bool assembleEllip(const PATCH& patch, Matrix<Real>& A, 
			       const Jacobian& Jac, 
			       const Matrix<Bool>* pattern) const
	    { return MCEllip(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleConvec (const PATCH& patch, Matrix<Real>& A, 
				 const Jacobian& Jac, 
				 const Matrix<Bool>* pattern) const
	    { return MCConvec(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleMass (const PATCH& patch, Matrix<Real>& A, 
			       const Jacobian& Jac, 
			       const Matrix<Bool>* pattern) const
	    { return MCMass(patch, A, Jac, pattern, nComp, Node); }

   virtual  Bool assembleLumpedMass(const PATCH& patch, Matrix<Real>& A, 
				    const Jacobian& Jac, 
				    const Matrix<Bool>* pattern) const
	    { return MCLumpedMass(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleSource(const PATCH& patch, Vector<Real>& b, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern,
				Real time=0.0) const
	    { return MCSource(patch, b, Jac, pattern, nComp, Node, time); }

    virtual void assembleL2Norm(const PATCH& patch, Matrix<Real>& A, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern) const
	    { MCL2Norm(patch, A, Jac, pattern, nComp, Node); }

    virtual void assembleLNorm (const PATCH& patch, Vector<Real>& b, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern) const
	    { MCLNorm(patch, b, Jac, pattern, nComp, Node); }

		   
  protected:

    const 	int nComp, noOfNodes;
    Matrix<int> Node;

    MCTriangle(int /*nComp0*/) : Triangle(), nComp(0), noOfNodes(0), Node(1,1) { }		
};
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------


		// -- quadratic hierarchical element:


class HQuadMCTriangle : public HQuadTriangle
{

  public:

    HQuadMCTriangle(Material* material, int nComp);

    virtual int NoOfBaseNodes() const { return 6; }
    virtual int NoOfNodes()     const { return noOfNodes; }

    virtual int NodesOnPoint() const { return nComp; }
    virtual int NodesOnEdge()  const { return nComp; }

  protected:

    int nComp, noOfNodes;
    Matrix<int> Node;

    HQuadMCTriangle(int /*nComp0*/): HQuadTriangle(), nComp(0), noOfNodes(0), 
    								  Node(1,1) { }

    virtual void setPatterns();


    //------------------- the special routines  ----------------------

    virtual void assembleConstEllip(const PATCH& elem, Matrix<Real>& A, 
				    const Jacobian& Jac, 
				    const Matrix<Bool>* pattern) const
	    { MCConstEllip2(elem, A, Jac, pattern, nComp, Node); } 

     virtual void assembleConstConvec(const PATCH& elem, Matrix<Real>& A, 
				     const Jacobian& Jac, 
				     const Matrix<Bool>* pattern) const
	    { MCConstConvec2(elem, A, Jac, pattern, nComp, Node); }

    //-------------------------------------------------------------------

    virtual Bool assembleEllip(const PATCH& patch, Matrix<Real>& A, 
			       const Jacobian& Jac, 
			       const Matrix<Bool>* pattern) const
	    { return MCEllip(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleConvec (const PATCH& patch, Matrix<Real>& A, 
				 const Jacobian& Jac, 
				 const Matrix<Bool>* pattern) const
	    { return MCConvec(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleMass (const PATCH& patch, Matrix<Real>& A, 
			       const Jacobian& Jac, 
			       const Matrix<Bool>* pattern) const
	    { return MCMass(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleLumpedMass(const PATCH& patch, Matrix<Real>& A, 
				    const Jacobian& Jac, 
				    const Matrix<Bool>* pattern) const
	    { return MCLumpedMass(patch, A, Jac, pattern, nComp, Node); }

    virtual Bool assembleSource(const PATCH& patch, Vector<Real>& b, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern,
				Real time=0.0) const
	    { return MCSource(patch, b, Jac, pattern, nComp, Node, time); }

    virtual void assembleL2Norm(const PATCH& patch, Matrix<Real>& A, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern) const
	    { MCL2Norm(patch, A, Jac, pattern, nComp, Node); }

    virtual void assembleLNorm (const PATCH& patch, Vector<Real>& b, 
				const Jacobian& Jac, 
				const Matrix<Bool>* pattern) const
	    { MCLNorm(patch, b, Jac, pattern, nComp, Node); }
};

#endif