Blockstructured Adaptive Mesh Refinement in object-oriented C++

---

       

---

ClpIntegrator1.h

Go to the documentation of this file.

#ifndef AMROC_CLP_INTEGRATOR1_H
#define AMROC_CLP_INTEGRATOR1_H

#include "ClpIntegratorBase.h"

#ifndef ClpIntegratorName
#define ClpIntegrator(dim)      name2(ClpIntegrator,dim)
#define ClpIntegratorName
#endif

template <class VectorType, class AuxVectorType>
class ClpIntegrator(1) : public ClpIntegratorBase(1)<VectorType,AuxVectorType> {
  typedef typename VectorType::InternalDataType DataType;
  typedef ClpIntegratorBase(1)<VectorType,AuxVectorType> base_type;
  typedef GridData(1)<VectorType> vec_grid_data_type;
  typedef GridFunction(1)<VectorType> vec_grid_fct_type;  
  typedef GridData(DIM_1)<VectorType>    ld_vec_grid_data_type;
  typedef GridData(DIM_1)<AuxVectorType> ld_aux_grid_data_type;

public:
  ClpIntegrator(1)(const int equ, const int wv, const int gh) : 
      base_type(equ, wv, gh) {}

  //------------------------------------------------------------------
  // Solve Riemann problems. Copy left and right data into appropriate
  // format for normal_flux_func(). Note that left state has to shifted
  // one element. This is done in copySlice().
  //------------------------------------------------------------------                      
  virtual void ComputeRP(ld_vec_grid_data_type& LeftState, ld_aux_grid_data_type& auxl, 
                         ld_vec_grid_data_type& RightState, ld_aux_grid_data_type& auxr, 
                         ld_vec_grid_data_type& NewState, const int& direction) {

    AllocError::SetTexts("ClpIntegrator(1)","calculate_Riemann_Problem(): work");
    Coords ex = LeftState.extents();
    int maxm = LeftState.extents(0) + 1;
    int nghosts = 0;
    DataType* wave = new DataType[maxm*NEqUsed()*NWaves()];
    DataType* s = new DataType[maxm*NWaves()];
    DataType* LeftStateSl  = new DataType[maxm*NEqUsed()];
    DataType* RightStateSl = new DataType[maxm*NEqUsed()];
    DataType* auxlSl = new DataType[maxm*NAux()];
    DataType* auxrSl = new DataType[maxm*NAux()];

    AllocError::SetTexts("ClpIntegrator(1)","calculate_Riemann_Problem(): fluctuations");
    DataType* apdqSl = new DataType[(NewState.bbox().size()+1)*NEqUsed()];
    DataType* amdqSl = new DataType[(NewState.bbox().size()+1)*NEqUsed()];

    copySlice(LeftStateSl, LeftState, NEqUsed(), 1);
    copySlice(RightStateSl, RightState, NEqUsed(), 0);
        
    copyAuxSlice(auxlSl, auxl, NAux(), 1);
    copyAuxSlice(auxrSl, auxr, NAux(), 0);

    (*normal_flux_func)(maxm, NEqUsed(), NWaves(), nghosts, maxm,
                        LeftStateSl, RightStateSl,
                        NAux(), auxlSl, auxrSl, wave, s, amdqSl, apdqSl);

    addSlices(NewState, apdqSl, amdqSl, NEqUsed(), 1);
    
    delete [] LeftStateSl; delete [] RightStateSl;
    delete [] auxlSl; delete [] auxrSl;
    delete [] apdqSl; delete [] amdqSl;
    delete [] wave;
    delete [] s;
  }

  virtual double ComputeGrid(vec_grid_data_type& StateVec, 
                             vec_grid_data_type* Flux[], DataType* aux,
                             double dt, DCoords& dx) {
    
    AllocError::SetTexts("ClpIntegrator(1)","calculate_time_step(): work");
    Coords ex = StateVec.extents();
    int mx = ex(0)-2*NGhosts();
    int msl = 0;
#ifdef EXTENDED_INTEGRATOR
    msl = 4;
#endif  
    int mwork = (mx + 2*NGhosts()) * ((NEqUsed()+1)*NWaves() + (3+msl)*NEqUsed()+ NAux() + 1);      
    DataType* work = new DataType[mwork];
     
    int wave = 0;
    int s    = wave + (mx+2*NGhosts())*NEqUsed()*NWaves();
    int amdq =    s + (mx+2*NGhosts())*NWaves();
    int apdq = amdq + (mx+2*NGhosts())*NEqUsed();
    int dtdx = apdq + (mx+2*NGhosts())*NEqUsed();
    int aux1 = dtdx + (mx+2*NGhosts());
    int q1   = aux1 + (mx+2*NGhosts())*NAux();
    int next = q1 + (mx+2*NGhosts())*NEqUsed();
    int mwork1 = mwork - next;
    double cfl = 0.0;

    // The ghostcells must remain untouched during integration!
    f_step(mx,NEquations(),NEqUsed(),
           NAux(),NWaves(),NGhosts(),mx,
           StateVec.data(),
           aux,dx(0),dt,method,mthlim,cfl, 
           Flux[0]->data(),Flux[1]->data(),
           &(work[wave]),&(work[s]),
           &(work[amdq]),&(work[apdq]),
           &(work[dtdx]),&(work[aux1]),&(work[q1]),
           &(work[next]),mwork1,
           normal_flux_func);

    delete [] work;    
    return cfl;
  }

private:
  void copySlice(DataType* target, const ld_vec_grid_data_type &source, 
                 const int meqn, const int move) {
    const BBox& bbox = source.bbox();
    for (int m=0; m<meqn; m++) {
      if (move) target++;
      BeginFastIndex1(tgt, bbox, target, DataType);
      for_1 (k, bbox, bbox.stepsize()) 
        FastIndex1(tgt, k) = source(k)(m);
      end_for
      EndFastIndex1(tgt);
      if (!move) target++;
      target = &(target[bbox.size()]);
    }
  }

  void copyAuxSlice(DataType* target, const ld_aux_grid_data_type &source, 
                    const int meqn, const int move) {
    const BBox& bbox = source.bbox();
    for (int m=0; m<meqn; m++) {
      if (move) target++;
      BeginFastIndex1(tgt, bbox, target, DataType);
      for_1 (k, bbox, bbox.stepsize()) 
        FastIndex1(tgt, k) = source(k)(m);
      end_for
      EndFastIndex1(tgt);
      if (!move) target++;
      target = &(target[bbox.size()]);
    }
  }

  void addSlices(ld_vec_grid_data_type &target,
                 DataType* source1, DataType* source2, 
                 const int meqn, const int move) {
    const BBox& bbox = target.bbox();
    for (int m=0; m<meqn; m++) {
      if (move) { source1++; source2++; } 
      BeginFastIndex1(src1, bbox, source1, const DataType);
      BeginFastIndex1(src2, bbox, source2, const DataType);
      for_1 (k, bbox, bbox.stepsize()) 
        target(k)(m) = FastIndex1(src1, k) + FastIndex1(src2, k);
      end_for
      EndFastIndex1(src1);
      EndFastIndex1(src2);
      if (!move) { source1++; source2++; } 
      source1 = &(source1[bbox.size()]);
      source2 = &(source2[bbox.size()]);
    }
  }
};



#endif

---

Quickstart     Users Guide     Programmers Reference     Installation      Examples     Download

---

AMROC Main      Home      Contact

last update: 06/01/04