StandardAVI.h

Go to the documentation of this file.

#ifndef _STANDARD_AVI_H_
#define _STANDARD_AVI_H_

#include "AVI.h"

class StandardAVI: public AVI {
public:
  typedef double (*BCFunc) (int, int, double);

  enum BCImposedType {
    ZERO, ONE, TWO
  };


    StandardAVI(
        const LocalToGlobalMap& L2G, 
        const DResidue& MyRes, 
        const VecDouble& MassVec, 
        size_t globalIdx,
        const MatBool& IFlag, 
        const MatDouble& IVal,
        const double delta, 
        const double time) 

      : AVI (),
        operation (MyRes),
        globalIdx (globalIdx),
        imposedFlags (IFlag),
        imposedValues (IVal), 
        delta (delta),
        timeStamp (time) {

        init(L2G, MassVec);


        imposedTypes = std::vector< std::vector<BCImposedType> > (IFlag.size (), std::vector<BCImposedType> ());

        for (size_t f = 0; f < IFlag.size (); ++f) {

          for (size_t a = 0; a < IFlag[f].size (); ++f) {
            if (!IFlag[f][a]) {
              imposedTypes[f].push_back (StandardAVI::ONE);

            } else {
              imposedTypes[f].push_back (StandardAVI::ZERO);
            }
          }
        }
    }

    StandardAVI(
        const LocalToGlobalMap& L2G, 
        const DResidue& MyRes, 
        const VecDouble& MassVec, 
        size_t globalIdx,
        const std::vector<std::vector<BCImposedType> >& IType, 
        const std::vector<BCFunc>& bcfunc_vec,
        const double delta, 
        const double time)

    :   AVI (),
        operation (MyRes),
        globalIdx (globalIdx),
        imposedTypes (IType),
        delta (delta),
        timeStamp (time) {

        init (L2G, MassVec);


        if(imposedFlags.size() != IType.size()) {
            imposedFlags.resize(IType.size());
        }

        if(imposedValues.size() != IType.size()) {
            imposedValues.resize(IType.size());
        }

        if(imposedTypes.size() != IType.size()) {
            imposedTypes.resize(IType.size());
        }

        for(size_t f = 0;f < IType.size();f++){
            if(imposedFlags[f].size() != IType[f].size()) {
                imposedFlags[f].resize(IType[f].size());
            }

            if(imposedValues[f].size() != IType[f].size()) {
                imposedValues[f].resize(IType[f].size());
            }

            if(imposedTypes[f].size() != IType[f].size()) {
                imposedTypes[f].resize(IType[f].size());
            }

            for(size_t a = 0;a < IType[f].size();a++){
                if(IType[f][a] !=  StandardAVI::ZERO){
                    imposedFlags[f][a] = false;
                }else{
                    imposedFlags[f][a] = true;
                }
                imposedValues[f][a] = 0.0;
                imposedTypes[f][a] = IType[f][a];
            }

        }

        for(size_t a = 0;a < bcfunc_vec.size();a++){
            avi_bc_func.push_back(bcfunc_vec[a]);
        }
    }

    
  StandardAVI (const StandardAVI& that) :
    AVI (that),
    operation (that.operation),
    MMdiag (that.MMdiag),
    globalIdx (that.globalIdx),
    avi_bc_func (that.avi_bc_func),
    imposedTypes (that.imposedTypes),
    imposedFlags (that.imposedFlags),
    imposedValues (that.imposedValues),
    nfields (that.nfields),
    delta (that.delta),
    timeStamp (that.timeStamp) {

      setTimeStep ();
    }

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

  double getTimeStep () const {
    return timeStep;
  }

  double getTimeStamp () const {
    return timeStamp;
  }

  bool setTimeStamp (double timeval) {
    assert (timeval >= 0.0);
    timeStamp = timeval;
    return true;
  }
  ;


  virtual double getNextTimeStamp () const { return getTimeStamp() + getTimeStep();}
  virtual void incTimeStamp () { setTimeStamp(getNextTimeStamp()); }

  virtual const DResidue& getOperation () const { return operation; }

  size_t getFieldDof (size_t fieldnumber) const {
    return operation.getFieldDof (fieldnumber);
  }
  ;

  const std::vector<size_t>& getFields () const {
    return operation.getFields ();
  }
  ;

  const ElementGeometry& getGeometry () const {
    return operation.getElement ().getGeometry ();
  }
  ;

  const Element& getElement () const {
    return operation.getElement ();
  }
  ;

  bool getForceField (const MatDouble& argval, MatDouble& forcefield) const {
    operation.getVal (argval, forcefield);
    return (true);
  }
  ;


  size_t getGlobalIndex (void) const {
    return (globalIdx);
  }
  ;

  virtual void computeLocalTvec (MatDouble& tnew) const;

  virtual bool vbInit (
    const MatDouble& q,
    const MatDouble& v,
    const MatDouble& vb,
    const MatDouble& ti,
    const MatDouble& tnew,
    MatDouble& qnew,
    MatDouble& vbinit,
    MatDouble& forcefield,
    MatDouble& funcval,
    MatDouble& deltaV
    ) const;


  virtual bool update (const MatDouble& q,
    const MatDouble& v,
    const MatDouble& vb,
    const MatDouble& ti,
    const MatDouble& tnew,
    MatDouble& qnew,
    MatDouble& vnew,
    MatDouble& vbnew,
    MatDouble& forcefield,
    MatDouble& funcval,
    MatDouble& deltaV
    ) const ;

  bool gather (
      const LocalToGlobalMap& L2G,
      const VecDouble& Qval,
      const VecDouble& Vval,
      const VecDouble& Vbval,
      const VecDouble& Tval,
      MatDouble& q,
      MatDouble& v,
      MatDouble& vb,
      MatDouble& ti
  ) const;

  bool assemble (const LocalToGlobalMap& L2G,
      const MatDouble& qnew,
      const MatDouble& vnew,
      const MatDouble& vbnew,
      const MatDouble& tnew,
      VecDouble& Qval,
      VecDouble& Vval,
      VecDouble& Vbval,
      VecDouble& Tval,
      VecDouble& LUpdate) const;

protected:
  virtual void setTimeStep (double epsilon = 1.0) {
     timeStep = epsilon * delta * (operation.getElement ().getGeometry ().getInRadius ()) / operation.getMaterial ().getSoundSpeed ();

   };

  virtual void computeDeltaV (const MatDouble& funcval, MatDouble& DeltaV) const;

  virtual bool getImposedValues (const GlobalElementIndex& ElementIndex,
      const LocalToGlobalMap& L2G, size_t field, size_t dof,
      double& qvalue, double& vvalue) const;

  void roundTimeStep (double min_ts) {
    char val[80], val2[80];
    sprintf (val, "%0.3e", min_ts / 1000.);
    double cut_off = strtod (val, NULL);
    strncpy (val2, val, 5);
    cut_off = cut_off / strtod (val2, NULL);
    timeStep = floor (timeStep / cut_off) * cut_off;
  }
  ;

  
private:
  // disabling assignment
  StandardAVI& operator = (const StandardAVI& that) {
    return *this;
  }

  void init(const LocalToGlobalMap& L2G, const VecDouble& MassVec) {
         nfields = operation.getFields().size();
         setTimeStep();
         setDiagVals(MassVec, L2G, globalIdx); //set the diagonal values of the Mass Matrix
     }


  void setDiagVals (const VecDouble& MassVec, const LocalToGlobalMap& L2G,
      const GlobalElementIndex& elem_index);

  void setBCs (const MatBool&IFlag,
      const MatDouble& IVal);





  const DResidue&  operation;
  MatDouble MMdiag;

  size_t globalIdx;
  // MatDouble forcefield;

  std::vector<BCFunc> avi_bc_func;
  std::vector<std::vector<BCImposedType> > imposedTypes;
  MatBool imposedFlags;
  MatDouble imposedValues;

  size_t nfields;
  double delta; // safety factor in time step computation
  double timeStamp;
  double timeStep;



};

#endif // _STANDARD_AVI_H_

---