apfNumbering.h

Go to the documentation of this file.

/*
 * Copyright 2011 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 APFNUMBERING_H
#define APFNUMBERING_H

#include "apf.h"
#include "apfDynamicArray.h"
#include "apfMesh.h"

namespace apf {

typedef NumberingOf<long> GlobalNumbering;

Numbering* createNumbering(Field* f);

Numbering* createNumbering(
    Mesh* mesh,
    const char* name,
    FieldShape* shape,
    int components);

void destroyNumbering(Numbering* n);

void fix(Numbering* n, MeshEntity* e, int node, int component, bool fixed);

bool isFixed(Numbering* n, MeshEntity* e, int node, int component);

bool isNumbered(Numbering* n, MeshEntity* e, int node, int component);

void number(Numbering* n, MeshEntity* e, int node, int component, int number);

int getNumber(Numbering* n, MeshEntity* e, int node, int component);

Field* getField(Numbering* n);

FieldShape* getShape(Numbering* n);
const char* getName(Numbering* n);

bool isPrintable(Numbering* f);
Mesh* getMesh(Numbering* n);
int countComponents(Numbering* n);

int getElementNumbers(Numbering* n, MeshEntity* e, NewArray<int>& numbers);

int countFixed(Numbering* n);

void synchronize(Numbering * n, Sharing* shr = 0, bool delete_shr = false);

Numbering* numberOwnedDimension(Mesh* mesh, const char* name, int dim, Sharing* shr = 0);
Numbering* numberOverlapDimension(Mesh* mesh, const char* name, int dim);
Numbering* numberElements(Mesh* mesh, const char* name);
Numbering* numberOverlapNodes(
    Mesh* mesh,
    const char* name,
    FieldShape* s = 0);
Numbering* numberOwnedNodes(
    Mesh* mesh,
    const char* name,
    FieldShape* s = 0,
    Sharing* shr = 0);
int countNodes(Numbering* n);
int countNodes(GlobalNumbering* n);

struct Node
{
  Node():entity(0),node(0) {}
  Node(MeshEntity* e, int n):entity(e),node(n) {}
  MeshEntity* entity;
  int node;
};

void getNodes(Numbering* n, DynamicArray<Node>& nodes);

void getNodesOnClosure(
    Mesh* m,
    ModelEntity* me,
    DynamicArray<Node>& on,
    FieldShape* sh = 0);

GlobalNumbering* createGlobalNumbering(
    Mesh* mesh,
    const char* name,
    FieldShape* shape,
    int components=1);

GlobalNumbering* createGlobalNumbering(Field* f);

FieldShape* getShape(GlobalNumbering* n);
const char* getName(GlobalNumbering* n);
bool isPrintable(GlobalNumbering* f);
Mesh* getMesh(GlobalNumbering* n);
int countComponents(GlobalNumbering* n);
void number(GlobalNumbering* n, MeshEntity* e, int node, long number);
void number(GlobalNumbering* n, Node node, long number, int component=0);
long getNumber(GlobalNumbering* n, Node node, int component=0);
long getNumber(GlobalNumbering* n, MeshEntity* e, int node, int component=0);
int getElementNumbers(GlobalNumbering* n, MeshEntity* e,
    NewArray<long>& numbers);
Field* getField(GlobalNumbering* n);

GlobalNumbering* makeGlobal(Numbering* n, bool destroy=true);

void synchronize(GlobalNumbering* n, Sharing* shr = 0);

void destroyGlobalNumbering(GlobalNumbering* n);

void getNodes(GlobalNumbering* n, DynamicArray<Node>& nodes);

MeshTag* reorder(Mesh* mesh, const char* name);

void globalize(Numbering* n);

int naiveOrder(Numbering * num, Sharing * sharing = NULL);
// Exposing capital version for legacy API purposes
inline int NaiveOrder(Numbering * num) { return naiveOrder(num); }

int adjReorder(Numbering * num, Sharing * sharing = NULL);
// Exposing capital version for legacy API purposes
inline int AdjReorder(Numbering * num) { return adjReorder(num); }

void setNumberingOffset(Numbering * num, int off, Sharing * sharing = NULL);
// Exposing capital version for legacy API purposes
inline void SetNumberingOffset(Numbering * num, int off) { setNumberingOffset(num,off); }

}

#endif