CartesianTimeInterp.H

Go to the documentation of this file.

 
#ifndef _CARTESIAN_TIMEINTERP_H_
#define _CARTESIAN_TIMEINTERP_H_
 
#include <vector>
#include "CartesianGrid.H"
#include "Gas.H"
#include "GasData.H"
 
namespace criptic {
  namespace gas {
 
    class CartesianTimeInterp : public Gas {
 
    public:
      
      CartesianTimeInterp(const ParmParser& pp,
              const Geometry& geom_,
              const IdxType nBB,
              const int nGhost = 1);
      
      virtual ~CartesianTimeInterp();
      
      virtual void frame(const RealVec &x,
             const Real t,
             RealVec& v,
             TNBBasis& tnb) const override {
    // Convert position to cell coordinates
    SIdxVec iv;
    RealVec f;
    gasOld->posToIdx(x, iv, f);
 
    // Get weight factor
    Real w = (t - tSlice[tPtr-1]) / (tSlice[tPtr] - tSlice[tPtr-1]);
 
    // Interpolate v, B, and grad B in space and time
    v = (1 - w) * gasOld->interpVec(iv, f, CartesianGrid::vxIdx) +
      w * gasNew->interpVec(iv, f, CartesianGrid::vxIdx);
    RealVec B = (1 - w) * gasOld->interpVec(iv, f, CartesianGrid::BxIdx) +
      w * gasNew->interpVec(iv, f, CartesianGrid::BxIdx);
    RealTensor2 gradB =
      (1 - w) * gasOld->interpGradVector(iv, f, CartesianGrid::BxIdx) +
      w * gasNew->interpGradVector(iv, f, CartesianGrid::BxIdx);
    
    // Compute TNB basis vectors
    tnb = TNBVectors(B, gradB);
      }
 
      virtual GasData gasData(const RealVec &x,
                  const Real t) const override {
    GasData gdOld = gasOld->gasData(x, t);
    GasData gdNew = gasNew->gasData(x, t);
    Real w = (t - tSlice[tPtr-1]) / (tSlice[tPtr] - tSlice[tPtr-1]);
    return (1 - w) * gdOld + w * gdNew;
      }
      
      virtual Real dxGhost() const override {
    return gasOld->dxGhost();
      }
 
      virtual void updateState(const Real t,
                   Real& tNext) override;
 
      virtual void loadData(const IdxType idx,
                CartesianGrid *g) = 0;
     
    protected:
 
      // Data
      std::vector<Real> tSlice;  
      IdxType tPtr;              
    private:
      
      // Data
      int verbosity;             
      CartesianGrid *gasOld;     
      CartesianGrid *gasNew;     
      bool dataLoaded;           
    };
  }
}
 
 
#endif
// _CARTESIAN_TIMEINTERP_H_