crv.h

Go to the documentation of this file.

/*
 * Copyright 2015 Scientific Computation Research Center
 *
 * This work is open source software, licensed under the terms of the
 * BSD license as described in the LICENSE file in the top-level directory.
 */
 
#ifndef CRV_H
#define CRV_H
 
#include "apfMesh2.h"
#include "apfShape.h"
#include <ma.h>
#include <mth.h>
#include <stdio.h>
#include <vector>
 
namespace crv {
 
static unsigned const MAX_ORDER = 19;
 
void setOrder(const int order);
int getOrder();
void setBlendingOrder(const int type, const int b);
int getBlendingOrder(const int type);
 
int countNumberInvalidElements(apf::Mesh2* m);
 
void interpolatingToBezier(apf::Mesh2* m);
 
class MeshCurver
{
  public:
    MeshCurver(apf::Mesh2* m, int P) : m_mesh(m), m_order(P) {};
    virtual ~MeshCurver() {};
    virtual bool run() = 0;
 
    void snapToInterpolate(int dim);
 
    void synchronize();
 
  protected:
    apf::Mesh2* m_mesh;
    int m_order;
};
 
class InterpolatingCurver : public MeshCurver
{
  public:
    InterpolatingCurver(apf::Mesh2* m, int P) : MeshCurver(m,P) {};
    virtual ~InterpolatingCurver() {};
    virtual bool run();
 
};
 
class BezierCurver : public MeshCurver
{
  public:
    BezierCurver(apf::Mesh2* m, int P, int B) : MeshCurver(m,P)
    {
      setBlendingOrder(apf::Mesh::TYPES,B);
    };
 
    virtual bool run();
    void convertInterpolatingToBezier();
};
 
class GregoryCurver : public BezierCurver
{
  public:
    GregoryCurver(apf::Mesh2* m, int P, int B)
    : BezierCurver(m,P,B) {};
    virtual bool run();
    void setCubicEdgePointsUsingNormals();
    void setInternalPointsLocally();
};
 
ma::Input* configureShapeCorrection(
    ma::Mesh* m, ma::SizeField* f=0,
    ma::SolutionTransfer* s=0);
 
void adapt(ma::Input* in);
 
void adapt(const ma::Input* in);
 
void stats(ma::Input* in,
    std::vector<double> &edgeLengths,
    std::vector<double> &linearQualities,
    std::vector<double> &curvedQualities,
    bool inMetric=true);
 
 
apf::FieldShape* getBezier(int order);
apf::FieldShape* getGregory();
 
double getQuality(apf::Mesh* m,apf::MeshEntity* e);
 
int checkValidity(apf::Mesh* m, apf::MeshEntity* e,
    int algorithm = 2);
class Quality
{
public:
/*  \brief three options for algorithm:
   * 0 - subdivision
   * 1 - elevation
   * 2 - subdivision, using matrices */
  Quality(apf::Mesh* m, int algorithm_);
  virtual ~Quality() {};
  virtual double getQuality(apf::MeshEntity* e) = 0;
  virtual int checkValidity(apf::MeshEntity* e) = 0;
protected:
  apf::Mesh* mesh;
  int algorithm;
  int order;
};
Quality* makeQuality(apf::Mesh* m, int algorithm = 2);
 
double interpolationError(apf::Mesh* m, apf::MeshEntity* e, int n);
 
void writeCurvedVtuFiles(apf::Mesh* m, int type, int n, const char* prefix);
 
void writeCurvedWireFrame(apf::Mesh* m, int n, const char* prefix);
 
void writeControlPointVtuFiles(apf::Mesh* m, const char* prefix);
void writeInterpolationPointVtuFiles(apf::Mesh* m, const char* prefix);
 
int getTriNodeIndex(int P, int i, int j);
int getTetNodeIndex(int P, int i, int j, int k);
 
void fail(const char* why) __attribute__((noreturn));
 
}
 
#endif