app-bholger/gfem/gfemDofIteratorFast.h

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <assert.h>
#include "gfemOverlapCondition.h"
#include "unitcell.h"
#include "hp2D/quadFunctions.hh"

namespace concepts {
namespace gfem {

struct GfemDofIteratorFast 
{
  GfemDofIteratorFast(const GfemOverlapCondition& overC, const Unitcell& uc
      , const int p_macro[2])
    : overC(overC)
    , uc(uc)
    , i_t(0)
    , i_macroX(0)
    , i_macroY(0)
    , i_micro(0)
  { 
    this->p_macro[0] = p_macro[0];
    this->p_macro[1] = p_macro[1];
  }

  void print() const;

  GfemDofIteratorFast& operator++() 
  {
    #if 0
    ++i_macroY;
    if(i_macroY > nMacroY()) {
      i_macroY = 0;
      ++i_macroX;
      if(i_macroX > nMacroX()) {
        i_macroX = 0;
      }
    }
    #endif

    ++i_t;
    update(i_t);

    return *this;
  }

  void updateLdof(int i_micro, int i_macroX, int i_macroY) {
    int i_macro = i_macroY * nMacroX() + i_macroX;
    i_t = i_macro * numUC() + i_micro;

    //assert(i_t <= nDofs());
  }

  void updateLdof(int i_vert) {
    i_t = overC.disabledVertDof(i_vert);
  }

  void updateLdof(int i_edge, int i_shape) {
    assert(i_shape < overC.edgeDofs(i_edge) );

    i_t = overC.nVertDofs();

    for(int i=0; i < i_edge; ++i)
      if(overC.edgeDisabled(i))
        i_t += overC.edgeDofs(i);

    i_t += i_shape;
  }

  bool update(int i_t) {
    this->i_t = i_t;
#if 0
    if(i_t < overC.nDofs()) {
      i_micro = i_t;
      i_macroX = -1;
      i_macroY = -1;

      return true;
    }
    i_t -= overC.nDofs();
#endif

    int i_macro = i_t / numUC();
    i_micro = i_t % numUC();

    i_macroY = i_macro / nMacroX();
    i_macroX = i_macro % nMacroX();

    assert(i_macroX >= 0);
    assert(i_macroY >= 0);

    return i_macroY < nMacroY(); 
  }

  void updateVertMacro(int i_vert) 
  {
    uint ll[2];
    hp2D::QuadFunctions::vertexIndex(i_vert, ll);

    i_macroX = ll[0];
    i_macroY = ll[1];
  }
 
  void updateEdgeMacro(int i_edge, int i_t) 
  {
    uint pIndex = 0, qIndex = 0;
    uint ll[2];
    hp2D::QuadFunctions::edgeOrientation(i_edge, pIndex, qIndex);
    hp2D::QuadFunctions::edgeIndex(i_edge, qIndex, ll);

    ll[pIndex] = i_t + 2;

    i_macroX = ll[0];
    i_macroY = ll[1];
  }
 
  void setPMax(int p_max[2]) {
    p_macro[0] = p_max[0];
    p_macro[1] = p_max[1];
  }

  int numUC() const {
    return uc.size();
  }

  int nMicro() const {
    return numUC();
  }
  int pMacroX() const {
    return p_macro[0];
  }

  int pMacroY() const {
    return p_macro[1];
  }

  int nMacroX() const {
    return p_macro[0]+1;
  }

  int nMacroY() const {
    return p_macro[1]+1;
  }

  bool isFinished() const {
    return i_t >= numLdofs();
  }

  int nDofs() const {
    return numLdofs();
  }

  int numLdofs() const {
    return nMacroX() * nMacroY() * numUC();
  }

//private:
  
  const GfemOverlapCondition& overC;
  const Unitcell& uc;
  int i_t;
  int i_macroX;
  int i_macroY;
  int i_micro;
  int p_macro[2];
};

} // namespace
} // namespace