app-bholger/gfem/gfemSpaceFast.h

Go to the documentation of this file.

#pragma once

#include <vector>
#include <map>
#include <iostream>
#include "limits"
#include "formula/elementFormulaRCP.hh"
#include "space/space.hh"
#include "geometry/mesh.hh"
#include "hp2D/quad.hh"
#include "gfemControl.h"
#include "gfemSpace.h"
#include "gfemQuadFast.h"



namespace concepts {
namespace gfem {

class GfemSpaceFast : public concepts::SpaceOnCells<Real> 
{
public:
  typedef hp2D::Quad<Real> hpQuad;
  typedef StlVectorScan<ElementWithCell<Real> > Scan;
  typedef StlVectorScan<GfemQuadFast > ScanGfem;
  typedef StlVectorScan<hpQuad > ScanOrdinary;

  const static bool NO_SCALE_RES = GfemControl<0>::NO_SCALE_RES;
  const static bool USE_SCALE_RES = GfemControl<0>::USE_SCALE_RES;


  GfemSpaceFast(Mesh2& msh, const Unitcell& uc, const GfemSpaceParams& params,
      const concepts::BoundaryConditions& bc);

  virtual ~GfemSpaceFast();

  void rebuild();

  virtual uint dim() const {
    return dim_; 
  }

  int getDim() {
    return dim();
  }

  int getDimGfem() const {
    return dimGfem;
  }

  int getDimOverl() const {
    return dimOverl;
  }

  int genVertDof(GfemControlVert ctrl);

  virtual uint nelm() const {
    return elems.size();    
  }

  void clear();

  int getNelm() const {
    return elems.size();
  }

  int getNelmGfem() const {
    return elemGfemSubs.size(); 
  }

  int getNelmOrdinary() const {
    return elemGfemSubs.size();  
  }

  virtual Scan* scan() const {
    return new Scan(elems, elems.begin());
  }


  ScanOrdinary* scanOrdinary() const {
    return new ScanOrdinary(elemOrdinarySubs, elemOrdinarySubs.begin());
  }

  ScanGfem* scanGfem() const {
    return new ScanGfem(elemGfemSubs, elemGfemSubs.begin());
  }


  void assignVertexDofs(const concepts::Quad& cell_t, const GfemOverlapCondition& overc,
        concepts::TColumn<Real>*& T1);

  void assignEdgeDofs(const concepts::Quad& cell_t, const GfemOverlapCondition& overc,
        concepts::TColumn<Real>*& T1);

  void assignInnerDofs(const concepts::Quad& cell_t, const GfemOverlapCondition& overc,
        concepts::TColumn<Real>*& T1);

  bool isVertexDof(const concepts::Connector2& cntr, uint i) const;

  bool isEdgeDof(const concepts::Connector2& cntr, uint i) const;

  bool isInnerDof(const concepts::Connector2& quad) const;

  void verbosePrint();

  void recomputeShapefunctions();

  void registerFormula(const RCP<const concepts::ElementFormula<Cmplx> >& formula, 
      GfemUCQuad::EvalMode mode = GfemUCQuad::EVAL_ON_MICRO) 
  {
    if(dim() == 0) {
      throw ExceptionBase(__FILE__, __LINE__, __FUNCTION__, "need to rebuild space first");
    }
    if(isMicroStructureMesh()) {
      ucQ->registerFormula(formula, mode);
    } else {
      printf("no microstructure mesh2 ...\n");
    }
  }

protected:
  virtual std::ostream& info(std::ostream& os) const;

  int allocDofs(int numDofs);

  bool isMicroStructureMesh() {
    return microStructureMesh;
  }
private:

  void processMesh(const Quad2d& quad);
  
  void processMicro(const Quad2d& quad);

  void processOverlap(const Quad2d& cell);

  void processBC(const Quad2d& quad);

  concepts::Mesh2& mesh;
  bool microStructureMesh;

  RCP<GfemUCQuad> ucQ;
  std::vector< ElementWithCell<Real>* > elems; 
  std::vector< GfemQuadFast* > elemGfemSubs; 
  std::vector< hpQuad* > elemOrdinarySubs; 
  typedef std::map< int, GfemControl<0> > ControlVert;
  typedef std::map< int, GfemControl<1> > ControlEdge;
  typedef std::map< int, GfemControl<2> > ControlCell;
  ControlVert controlVert;  
  ControlEdge controlEdge;  
  ControlCell controlCell;  

  int n_elem;
  int n_gfem;
  int n_ordinary;
  int dim_;
  int dimGfem;
  int dimOverl;

  GfemSpaceParams params;
  BoundaryConditions bc;
  const Unitcell& uc;

  //TODO: work here map of control informations
};

} // namespace
} // namespace