apfMesh2.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 APF_MESH2_H
#define APF_MESH2_H

#include "apfMesh.h"
#include <set>

namespace apf {

class Mesh2 : public Mesh
{
  public:
    virtual void setRemotes(MeshEntity* e, Copies& remotes) = 0;
    virtual void addRemote(MeshEntity* e, int p, MeshEntity* r) = 0;

// seol
    virtual void addGhost(MeshEntity* e, int p, MeshEntity* r) = 0;
    virtual void deleteGhost(MeshEntity* e) = 0;

    virtual void setResidence(MeshEntity* e, Parts& residence) = 0;
    virtual void setParam(MeshEntity* e, Vector3 const& p) = 0;
    virtual void increment(MeshIterator* it) = 0;
    virtual bool isDone(MeshIterator* it) = 0;
    virtual MeshEntity* deref(MeshIterator* it) = 0;
    void setPoint(MeshEntity* e, int node, Vector3 const& p);
    virtual void setPoint_(MeshEntity* e, int node, Vector3 const& p) = 0;
    MeshEntity* createVertex(ModelEntity* c, Vector3 const& point,
        Vector3 const& param);
    void requireUnfrozen()
    {
      if (hasFrozenFields)
        unfreezeFields(this);
    }
    virtual MeshEntity* createVert_(ModelEntity* c) = 0;
    MeshEntity* createVert(ModelEntity* c)
    {
      requireUnfrozen();
      return createVert_(c);
    }
    virtual MeshEntity* createEntity_(int type, ModelEntity* c,
        MeshEntity** down) = 0;
    MeshEntity* createEntity(int type, ModelEntity* c, MeshEntity** down)
    {
      requireUnfrozen();
      return createEntity_(type,c,down);
    }
    virtual void destroy_(MeshEntity* e) = 0;
    void destroy(MeshEntity* e)
    {
      requireUnfrozen();
      destroy_(e);
    }
    virtual void setModelEntity(MeshEntity* e, ModelEntity* c) = 0;
    virtual void addMatch(MeshEntity* e, int peer, MeshEntity* match) = 0;
    virtual void clearMatches(MeshEntity* e) = 0;
    virtual void clear_() = 0;
    virtual void acceptChanges() = 0;
};

void migrate(Mesh2* m, Migration* plan);

void migrateSilent(Mesh2* m, Migration* plan);

void setMigrationLimit(size_t maxElements);

class Field;

void displaceMesh(Mesh2* m, Field* d, double factor=1.0);

class BuildCallback
{
  public:
    virtual void call(MeshEntity* e) = 0;
};

MeshEntity* makeOrFind(
    Mesh2* m,
    ModelEntity* c,
    int type,
    MeshEntity** down,
    BuildCallback* cb = 0,
    bool* p_made = 0);

MeshEntity* buildElement(
    Mesh2* m,
    ModelEntity* c,
    int type,
    MeshEntity** verts,
    BuildCallback* cb = 0);

MeshEntity* buildOneElement(
    Mesh2* m,
    ModelEntity* c,
    int type,
    Vector3 const* points);

void initResidence(Mesh2* m, int dim);

void stitchMesh(Mesh2* m);

void clear(Mesh2* m);

void packDataClone(Mesh2* m, int to);
void unpackDataClone(Mesh2* m);

// common functions for migration/ghosting/distribution
typedef std::vector<MeshEntity*> EntityVector;
void packParts(int to, Parts& parts);
void unpackParts(Parts& parts);
void moveEntities(
    Mesh2* m,
    EntityVector senders[4]);
void updateMatching(
    Mesh2* m,
    EntityVector affected[4],
    EntityVector senders[4]);
void deleteOldEntities(
    Mesh2* m,
    EntityVector affected[4]);
void reduceMatchingToSenders(
    Mesh2* m,
    EntityVector senders[4]);
void getSenders(Mesh2* m,EntityVector affected[4],EntityVector senders[4]);
void split(Copies& remotes, Parts& parts, Parts& newParts);

// seol
void packEntity(Mesh2* m, int to, MeshEntity* e, DynamicArray<MeshTag*>& tags, bool ghosting=false);
void unpackRemotes(Mesh2* m, MeshEntity* e);
void unpackTags(Mesh2* m, MeshEntity* e, DynamicArray<MeshTag*>& tags);
void unpackCommon(Mesh2* m, MeshEntity*& sender, ModelEntity*& c, Parts& residence);
MeshEntity* unpackVertex(Mesh2* m, ModelEntity* c);
MeshEntity* unpackNonVertex(Mesh2* m,int type, ModelEntity* c);

}//namespace apf

#endif