app-bholger/gfem/gfemOverlapCondition.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <assert.h>

namespace concepts {
namespace gfem {

struct GfemOverlapCondition {
  GfemOverlapCondition()
  {
    for(int i=0; i < 4; ++i) {
      stateVert[i] = 0;
      stateEdge[i] = 0;
    }
    optimize();
  }

  void disableVertex(int i) {
    stateVert[i] = 1;
    optimize();
  }

  void disableEdge(int i, int pEdge) {
    assert(pEdge > 0);
    stateEdge[i] = pEdge;
    optimize();
  }

  bool vertDisabled(int i) const {
    return stateVert[i] > 0;
  }

  int vertP(int i) const {
    return (stateVert[i] != 0 ? 1:0);
  }

  bool edgeDisabled(int i) const {
    return stateEdge[i] != 0;
  }

  int edgeP(int i) const {
    return stateEdge[i];
  }

  int edgeDofs(int i) const {
    return edgeP(i) - 1;
  }

  void optimize() {
    for(int i=0; i < 4; ++i) {
      if(edgeDisabled(i)) {
        #if 0
        stateVert[ i     ] = -1;
        stateVert[(i+1)%4] = -1;
        #endif
      }
    }
    n_disabledVert = 0;
    n_disabledEdges = 0;
    n_vertPs = 0;
    maxP = 1;
    for(int i=0; i < 4; ++i) {
      if(vertDisabled(i))
        ++n_disabledVert;
      if(edgeDisabled(i))
        ++n_disabledEdges;

      n_vertPs += vertP(i); 

      cum_disabledEdge[i] = (i > 0 ? cum_disabledEdge[i-1] : 0);
      if(edgeDisabled(i))
        cum_disabledEdge[i] += edgeP(i)-1;
      maxP = std::max(edgeP(i), maxP);
    }
  }

  int nMicro() const {
    //return n_disabledVert + n_disabledEdges;
    return nDofs();
  }

  int nDofs() const {
    return n_disabledVert + cum_disabledEdge[3];
  }

  void print() const;

  int nVertDofs() const {
    return n_disabledVert;
  }

  int nEdgeDofs() const {
    return cum_disabledEdge[3];
  }

  int disabledVertDof(int i_vert) const {
    int i_t = 0;
    for(int i=0; i < i_vert; ++i) {
      if(stateVert[i] != 0) {
        ++i_t;
      }
    }
    return i_t;
  }

  int disabledVertIdx(int i_t) const {
    for(int i=0; i < 4; ++i) {
      if(stateVert[i] != 0) {
        if(i_t == 0)
          return i;
        --i_t;
      }
    }
    assert(false);
    return -1;
  }

#if 0
  int cumEdgeDisabled(int i) const {
    return cum_disabledEdge[i];
  }
#endif

private:
  int n_disabledVert;
  int n_vertPs; 
  int n_disabledEdges;
  int maxP;
  int cum_disabledEdge[4];
  int stateVert[4];
  int stateEdge[4];
};

} // namespace
} // namespace