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);

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 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