ElementalOperation.h

Go to the documentation of this file.

#ifndef ELEMENTALOPERATION
#define ELEMENTALOPERATION

#include <vector>
#include <iostream>

#include <cstdlib>

#include "AuxDefs.h"
#include "Element.h"
#include "Material.h"


class Residue
{
 public:
  Residue() {}
  virtual ~Residue() {}
  Residue(const Residue &NewEl) {}
  virtual Residue * clone() const = 0;

  virtual const std::vector<size_t> & getFields() const = 0;


  virtual size_t  getFieldDof(size_t fieldnumber) const = 0;


  virtual bool getVal(const MatDouble &argval, MatDouble& funcval ) const = 0;

  virtual const Element& getElement () const = 0;

  virtual const SimpleMaterial& getMaterial () const = 0;


  

  static bool assemble(std::vector<Residue *> &ResArray, 
                       const LocalToGlobalMap & L2G,
                       const VecDouble  & Dofs,
                       VecDouble&  ResVec);
};


class BaseResidue: public Residue {

protected:
  const Element& element;
  const SimpleMaterial& material;
  const std::vector<size_t>& fieldsUsed;


  BaseResidue (const Element& element, const SimpleMaterial& material, const std::vector<size_t>& fieldsUsed)
  : element (element), material (material), fieldsUsed (fieldsUsed) {
  }

  BaseResidue (const BaseResidue& that) : element (that.element), material (that.material)
  , fieldsUsed (that.fieldsUsed) {

  }

public:
  virtual const Element& getElement () const {
    return element;
  }

  virtual const std::vector<size_t>& getFields () const {
    return fieldsUsed;
  }

  virtual const SimpleMaterial& getMaterial () const {
    return material;
  }

  virtual size_t getFieldDof (size_t fieldNum) const {
    return element.getDof (fieldsUsed[fieldNum]);
  }

};




class DResidue: public BaseResidue {
 public: 
  DResidue (const Element& element, const SimpleMaterial& material, const std::vector<size_t>& fieldsUsed)
  : BaseResidue(element, material, fieldsUsed) {}

  DResidue(const DResidue &NewEl): BaseResidue(NewEl) {}

  virtual DResidue * clone() const = 0;
 

  virtual bool getDVal(const MatDouble& argval, MatDouble& funcval,
                       FourDVecDouble& dfuncval) const = 0;

  
  static bool consistencyTest(const DResidue & DRes,  
                              const std::vector<size_t> & DofPerField,
                              const MatDouble &argval);

  //  DResidue. This should have been possible through polymorphism.
  

  static bool assemble(std::vector<DResidue *> &DResArray, 
                       const LocalToGlobalMap & L2G,
                       const VecDouble  & Dofs,
                       VecDouble&  ResVec,
                       MatDouble&  DResMat);
};



#endif

---