StressWork.h

Go to the documentation of this file.

#ifndef STRESSWORK
#define STRESSWORK

#include <vector>
#include <algorithm>

#include <cassert>

#include "Galois/Runtime/PerCPU.h"

#include "ElementalOperation.h"
#include "AuxDefs.h"

class StressWork:  public DResidue {
protected:
  enum GetValMode {
    VAL,
    DVAL,
  };

  bool getDValIntern(const MatDouble &argval, MatDouble& funcval, FourDVecDouble& dfuncval, const GetValMode& mode) const;

private:

  struct StressWorkTmpVec {
    static const size_t MAT_SIZE = SimpleMaterial::MAT_SIZE;

    std::vector<size_t> nDof;
    std::vector<size_t> nDiv;

    MatDouble DShape;
    MatDouble IntWeights;

    VecDouble A;
    VecDouble F;
    VecDouble P;

    StressWorkTmpVec ()
      : A (MAT_SIZE * MAT_SIZE, 0.0),
        F (MAT_SIZE, 0.0),
        P (MAT_SIZE, 0.0) {}

    explicit StressWorkTmpVec (size_t Dim)
      : nDof(Dim), 
        nDiv(Dim),
        DShape(Dim), 
        IntWeights(Dim),
        A (MAT_SIZE * MAT_SIZE, 0.0),
        F (MAT_SIZE, 0.0),
        P (MAT_SIZE, 0.0) {}
    


  };

  typedef GaloisRuntime::PerCPU<StressWorkTmpVec> PerCPUtmpVecTy;

  static PerCPUtmpVecTy perCPUtmpVec;

public:
  StressWork(const Element& IElm, const SimpleMaterial &SM, const std::vector<size_t>& fieldsUsed)
    : DResidue (IElm, SM, fieldsUsed) {

    assert (fieldsUsed.size() > 0 && fieldsUsed.size () <= 3);

  }

  virtual ~StressWork() {}


  StressWork(const StressWork & SW) : DResidue (SW) {}


  virtual StressWork * clone() const {
    return new StressWork(*this);
  }


  VecDouble getIntegrationWeights(size_t fieldnumber) const {
    return BaseResidue::element.getIntegrationWeights(fieldnumber);
  }

  bool getDVal(const MatDouble &argval, MatDouble& funcval, FourDVecDouble& dfuncval) const {
    return getDValIntern (argval, funcval, dfuncval, DVAL);
  }

  bool getVal(const MatDouble &argval, MatDouble& funcval) const {
    FourDVecDouble d;
    return getDValIntern(argval, funcval, d, VAL);
  }

};

#endif

---