maSize.h

Go to the documentation of this file.

/****************************************************************************** 
 
  Copyright 2013 Scientific Computation Research Center, 
      Rensselaer Polytechnic Institute. All rights reserved.
  
  The LICENSE file included with this distribution describes the terms
  of the SCOREC Non-Commercial License this program is distributed under.
 
*******************************************************************************/
#ifndef MA_SIZE_H
#define MA_SIZE_H
 
#include <apf.h>
#include "maMesh.h"
 
namespace ma {
 
typedef apf::Matrix3x3 Matrix;
 
class SizeField
{
  public:
    virtual ~SizeField();
    virtual double measure(Entity* e) = 0;
    virtual bool shouldSplit(Entity* edge) = 0;
    virtual bool shouldCollapse(Entity* edge) = 0;
    virtual void interpolate(
        apf::MeshElement* parent,
        Vector const& xi,
        Entity* newVert) = 0;
    virtual void getTransform(
        apf::MeshElement* e,
        Vector const& xi,
        Matrix& t) = 0;
    virtual double getWeight(Entity* e) = 0;
    virtual void onRefine(
        Entity* parent,
        EntityArray& newEntities);
    virtual void onCavity(
        EntityArray& oldElements,
        EntityArray& newEntities);
    virtual int getTransferDimension();
    virtual bool hasNodesOn(int dimension);
};
 
struct IdentitySizeField : public SizeField
{
  IdentitySizeField(Mesh* m);
  double measure(Entity* e);
  bool shouldSplit(Entity*);
  bool shouldCollapse(Entity*);
  void interpolate(
      apf::MeshElement* parent,
      Vector const& xi,
      Entity* newVert);
  void getTransform(
          apf::MeshElement*,
          Vector const&,
          Matrix& t);
  double getWeight(Entity*);
  Mesh* mesh;
 
};
 
struct UniformRefiner : public IdentitySizeField
{
  UniformRefiner(Mesh* m):
    IdentitySizeField(m)
  {
  }
  bool shouldSplit(Entity*)
  {
    return true;
  }
};
 
class AnisotropicFunction
{
  public:
    virtual ~AnisotropicFunction();
    virtual void getValue(Entity* vert, Matrix& r, Vector& h) = 0;
};
 
class IsotropicFunction
{
  public:
    virtual ~IsotropicFunction();
    virtual double getValue(Entity* vert) = 0;
};
 
SizeField* makeSizeField(Mesh* m, apf::Field* sizes, apf::Field* frames,
    bool logInterpolation = false);
SizeField* makeSizeField(Mesh* m, AnisotropicFunction* f,
    bool logInterpolation = false);
SizeField* makeSizeField(Mesh* m, apf::Field* size);
SizeField* makeSizeField(Mesh* m, IsotropicFunction* f);
 
double getAverageEdgeLength(Mesh* m);
double getMaximumEdgeLength(Mesh* m, SizeField* sf = 0);
 
}
 
#endif