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;
/* Desired length bounds in metric space to replace hard coded values. Right now
these values are const, since we are not sure it is worth while to have the user,
modify these in addition to desired length. Future testing in need because Li's 
thesis describes there might be utility to having the user modify them */
const double MAXLENGTH = 1.5;
const double MINLENGTH = .5;
const double MAXLENGTHRATIO = 1.2;
 
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