app-bholger/gfem/gfemControl.h

Go to the documentation of this file.

#pragma once

#include "gfemQuad.h"
#include "space/space.hh"
#include "geometry/mesh.hh"
#include "hp2D/quad.hh"
#include <vector>
#include <new>
#include <iostream>
#include "limits"

namespace concepts {
namespace gfem {

template<uint dim>
struct GfemControl : public concepts::AdaptiveControlTag /*, public OutputOperator*/ {
  using AdaptiveControlTag::tagInfo;
  const static bool NO_SCALE_RES = false;
  const static bool USE_SCALE_RES = true;

  GfemControl(tagInfo tag = NO_TAG)
    : AdaptiveControlTag((uchar)tag)
    , firstGDof(UNSET_DOF)
    , firstOverlapDof(UNSET_DOF)
    , numDofs(0)
    , uc(NULL)
    , scaleResolution(NO_SCALE_RES)
    , overlapping(false)
  { 
    for(uint i=0; i < dim; ++i) {
      if(dim == 1) {
        Ps[i] = std::numeric_limits<int>::max(); // ready for pmin rule
      } else {
        Ps[i] = -1; // ready for pmax rule
      }
    }
  }

  ~GfemControl()
  {
    if(uc) {
      delete uc;
      uc = NULL;
    }
  }
    
  GfemControl(const GfemControl& other) 
  {
    //new(this) (NO_TAG); // FIXME: is NO_TAG correct?
    new(this) GfemControl( (tagInfo)other.data_);

    if(uc) {
      setMicroStruct(*uc, other.scaleResolution);
    }

    setPs(other.getPs());
    firstGDof = other.firstGDof;
    firstOverlapDof = other.firstOverlapDof;
    numDofs = other.numDofs;
    overlapping = other.overlapping;
  }

  private:
    GfemControl& operator=(const GfemControl& other);

  public:

  void setMicroStruct(const Unitcell& uc, bool scaleRes) {
    if(this->uc)
      delete this->uc;
    this->uc = new UnitcellMask(uc);
    scaleResolution = scaleRes;
  }

  bool hasMicroStructure() const {
    return uc != NULL;
  }

  bool hasScaleRes() const {
    return scaleResolution == USE_SCALE_RES;
  }

  const int* getPs() const {
    return Ps;
  }

  void setPs(const int* ps) {
    for(uint i=0; i < dim; ++i) {
      Ps[i] = ps[i];
    }
  }

  void minPs(const int* ps) {
    for(uint i=0; i < dim; ++i) {
      Ps[i] = min(ps[i], Ps[i]);
    }
  }

  bool hasDof() const {
    return firstGDof != UNSET_DOF; 
  }

  int getGdof(int num) const {
    assert(num < numDofs);
    return firstGDof + num;
  }

  int getNumDofs() const {
    return numDofs;
  }

  bool isOverlap() const {
    return overlapping;
  }

  void setOverlap(bool overlap) {
    overlapping = overlap;
  }

  void setGdof(int dof, int numDofs = 1) {
    assert(firstGDof == UNSET_DOF || firstGDof == dof);
    assert(this->numDofs == 0);
    assert(numDofs > 0);
    firstGDof = dof;
    this->numDofs = numDofs;
    takeIn();
  }

  int& getFirstOverlapDof() const {
    return firstOverlapDof;
  }

  const UnitcellMask* getUC() const {
    return uc;
  }
  
  UnitcellMask* getUC() {
    return uc;
  }

  static const int UNSET_DOF = -1;
private:
  int firstGDof;
  int firstOverlapDof;
  int numDofs;

  // macro polynomial degrees in each direction
  int Ps[dim];

  UnitcellMask* uc; 
  bool scaleResolution; 
  bool overlapping;

  //friend std::ostream& operator<< <>(std::ostream& os, const GfemControl<dim>& c);
};

typedef GfemControl<0> GfemControlVert;
typedef GfemControl<1> GfemControlEdge;
typedef GfemControl<2> GfemControlCell;

template<uint dim>
inline std::ostream& operator<<(std::ostream& os, const GfemControl<dim>& c)
{
  os << (AdaptiveControlTag)c;
  if(c.hasDof()) {
    assert(c.getNumDofs() > 0);
    os << " gdof=" << c.getGdof(0) << " .. " << c.getGdof(c.getNumDofs()-1); 
  }
  if(dim > 0) {
    const int* Ps = c.getPs();
    os << " Ps: ";
    for(int i=0; i < (int)dim; ++i) {
      os << Ps[i] << " ";
    }
  }
  if(c.hasMicroStructure()) {
    os << " with micro structure.";
    if(c.hasScaleRes()) {
      os << " (scale res)";
    }
  } else {
    //os << " without micro structure.";
  }
  if(c.isOverlap()) {
    os << " (overlapping)";
  }
  return os;
}

} // namespace
} // namespace