apfPartition.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_PARTITION_H
#define APF_PARTITION_H

#include "apfMesh2.h"

namespace apf {

class Splitter
{
  public:
    virtual ~Splitter() {}
    virtual Migration* split(MeshTag* weights, double tolerance,
                             int multiple) = 0;
};

class Balancer
{
  public:
    virtual ~Balancer() {}
    virtual void balance(MeshTag* weights, double tolerance) = 0;
};

struct Remap
{
  virtual int operator()(int n) = 0;
};

struct Divide : public Remap
{
  Divide(int n):by(n) {}
  int operator()(int n) {return n / by;}
private:
  int by;
};

struct Multiply : public Remap
{
  Multiply(int n):by(n) {}
  int operator()(int n) {return n * by;}
private:
  int by;
};

struct Modulo : public Remap
{
  Modulo(int n):by(n) {}
  int operator()(int n) {return n % by;}
private:
  int by;
};

struct Unmodulo : public Remap
{
  Unmodulo(int original, int factor)
  {
    offset = (original / factor) * factor;
  }
  int operator()(int n) {return n + offset;}
private:  
  int offset;
};

struct Round : public Remap
{
  Round(int n):factor(n) {}
  int operator()(int n) {return (n / factor) * factor;}
private:
  int factor;
};

struct Expand : public Remap
{
  Expand(int nin, int nout):
    quotient(nout / nin),
    remainder(nout % nin)
  {}
  int operator()(int in)
  {
    if (in < remainder)
      return in * quotient + in;
    return in * quotient + remainder;
  }
  bool shouldOutBeIn(int out)
  {
    if (out < remainder * (quotient + 1))
      return out % (quotient + 1) == 0;
    return (out - remainder * (quotient + 1)) % quotient == 0;
  }
private:
  int quotient;
  int remainder;
};

struct Contract : public Remap
{
  Contract(int nin, int nout):
    quotient(nout / nin),
    remainder(nout % nin)
  {}
  int operator()(int out)
  {
    if (out < remainder * (quotient + 1))
      return out / (quotient + 1);
    return (out - remainder * (quotient + 1)) / quotient + remainder;
  }
  bool isValid(int out)
  {
    if (out < remainder * (quotient + 1))
      return out % (quotient + 1) == 0;
    return (out - remainder * (quotient + 1)) % quotient == 0;
  }
private:
  int quotient;
  int remainder;
};

void remapPartition(apf::Mesh2* m, Remap& remap);

}

#endif