domainsubdivision.hpp

Go to the documentation of this file.

/*
 * domainsubdivision.hpp
 *
 * Created on: 27 Sep 2012
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_DOMAINSUBDIVISION_HPP
#define SCHNEK_DOMAINSUBDIVISION_HPP

#include "boundary.hpp"

#include <memory>

namespace schnek {

template<class GridType>
class DomainSubdivision {
  public:
    enum {Rank = GridType::Rank};

    typedef typename GridType::IndexType LimitType;
    typedef typename GridType::value_type value_type;
    typedef typename GridType::CheckingPolicyType CheckingPolicyType;
    typedef typename GridType::StoragePolicyType StoragePolicyType;

    //typedef Grid<unsigned char, 1, GridAssertCheck, LazyArrayGridStorage> BufferType;
    typedef Grid<unsigned char, 1, GridAssertCheck> BufferType;

    typedef Range<int, Rank> DomainType;
    typedef Boundary<Rank> BoundaryType;
    typedef std::shared_ptr<BoundaryType> pBoundaryType;

  protected:
    pBoundaryType bounds;
  public:

    DomainSubdivision() {}

    virtual ~DomainSubdivision() {}

    int getDelta() { return bounds->getDelta(); }

    virtual void init(const LimitType &low, const LimitType &high, int delta) = 0;

    void init(const DomainType &domain, int delta)
    {
      init(domain.getLo(), domain.getHi(), delta);
    }

    void init(const GridType &grid, int delta)
    {
      init(grid.getLo(), grid.getHi(), delta);
    }

    void init(const LimitType &size, int delta)
    {
      LimitType sizem(size);
      for (size_t i=0; i<Rank; ++i) --sizem[i];
      init(LimitType(0), sizem, delta);
    }

    virtual const DomainType &getGlobalDomain() const = 0;

    const DomainType &getDomain() const { return bounds->getDomain(); }
    const LimitType &getLo() const {return bounds->getDomain().getLo();}
    const LimitType &getHi() const {return bounds->getDomain().getHi();}

    DomainType getInnerDomain() const { return bounds->getInnerDomain(); }
    LimitType getInnerLo() const {return bounds->getInnerDomain().getLo();}
    LimitType getInnerHi() const {return bounds->getInnerDomain().getHi();}


    template<typename T, template<size_t> class CheckingPolicy>
    Range<T, Rank, CheckingPolicy> getInnerExtent(const Range<T, Rank, CheckingPolicy> &globalExtent) const
    {
      const DomainType &globalGridSize = this->getGlobalDomain();
      typename Range<T, Rank, CheckingPolicy>::LimitType localDomainMin, localDomainMax;
      for (size_t i=0; i<Rank; ++i)
      {
        const T &lo = globalExtent.getLo()[i];
        T dx = (globalExtent.getHi()[i]-lo) / (T)(globalGridSize.getHi()[i] - globalGridSize.getLo()[i] + 1);
        localDomainMin[i] = lo + this->getInnerLo()[i]*dx;
        localDomainMax[i] = lo + (this->getInnerHi()[i] + 1)*dx;
      }
      return Range<T, Rank, CheckingPolicy>(localDomainMin,localDomainMax);
    }

    template<typename T, template<size_t> class CheckingPolicy>
    Range<T, Rank, CheckingPolicy> getInnerExtent(const Array<T, Rank, CheckingPolicy> &globalExtent) const
    {
      return this->getInnerExtent(
          Range<T, Rank, CheckingPolicy>(Array<T, Rank, CheckingPolicy>(0), globalExtent));
    }

    virtual void exchange(GridType &grid, size_t dim) = 0;

    virtual void accumulate(GridType &grid, size_t dim) = 0;

    virtual void exchangeData(size_t dim, int orientation, BufferType &in, BufferType &out) = 0;

    virtual double avgReduce(double) const = 0;

    virtual int avgReduce(int) const = 0;

    virtual double sumReduce(double) const = 0;

    virtual int sumReduce(int) const = 0;

    virtual double maxReduce(double) const = 0;

    virtual int maxReduce(int) const = 0;

    virtual double minReduce(double) const = 0;

    virtual int minReduce(int) const = 0;


    virtual bool master() const = 0;

    virtual int procnum() const = 0;

    virtual int procCount() const = 0;

    virtual int getUniqueId() const = 0;

    virtual bool isBoundLo(size_t dim) = 0;

    virtual bool isBoundHi(size_t dim) = 0;

    void exchange(GridType &grid) {
      for (size_t i=0; i<Rank; ++i) exchange(grid,i);
    }

    void accumulate(GridType &grid) {
      for (size_t i=0; i<Rank; ++i) accumulate(grid,i);
    }
};

template<class GridType>
class SerialSubdivision : public DomainSubdivision<GridType>
{
  public:
    typedef typename Boundary<GridType::Rank>::LimitType LimitType;
    typedef typename GridType::value_type value_type;
    typedef typename DomainSubdivision<GridType>::DomainType DomainType;
    typedef typename DomainSubdivision<GridType>::BoundaryType BoundaryType;
    typedef typename DomainSubdivision<GridType>::BufferType BufferType;

  private:
    LimitType Low;

    LimitType High;
  public:
    using DomainSubdivision<GridType>::init;
    using DomainSubdivision<GridType>::exchange;

    SerialSubdivision();

    ~SerialSubdivision();

    void init(const LimitType &low, const LimitType &high, int delta);

    const DomainType &getGlobalDomain() const { return this->bounds->getDomain(); }

    void exchange(GridType &grid, size_t dim);

    void accumulate(GridType &grid, size_t dim);

    void exchangeData(size_t dim, int orientation, BufferType &in, BufferType &out);

    double avgReduce(double val) const { return val; }

    int avgReduce(int val) const { return val; }

    double maxReduce(double val) const { return val; }

    int maxReduce(int val) const { return val; }

    double minReduce(double val) const { return val; }

    int minReduce(int val) const { return val; }

    double sumReduce(double val) const { return val; }

    int sumReduce(int val) const { return val; }

    bool master() const { return true; }

    int procnum() const { return 0; }

    int procCount() const { return 1; }

    int getUniqueId() const { return 0; }

    bool isBoundLo(size_t) { return true; }

    bool isBoundHi(size_t) { return true; }

};


//DomainSubdivision

} // namespace schnek

#include "domainsubdivision.t"

#endif // SCHNEK_DOMAINSUBDIVISION_HPP