CycleBuilder.h

Go to the documentation of this file.

/***************************************************************************
 *  ThunderEgg, a library for solvers on adaptively refined block-structured
 *  Cartesian grids.
 *
 *  Copyright (c) 2020-2021 Scott Aiton
 *
 *  This program 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.
 *
 *  This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
 ***************************************************************************/
 
#ifndef THUNDEREGG_GMG_CYCLEBUILDER_H
#define THUNDEREGG_GMG_CYCLEBUILDER_H
 
#include <ThunderEgg/GMG/FMGCycle.h>
#include <ThunderEgg/GMG/Level.h>
#include <ThunderEgg/GMG/VCycle.h>
#include <ThunderEgg/GMG/WCycle.h>
#include <ThunderEgg/RuntimeError.h>
namespace ThunderEgg::GMG {
template<int D>
class CycleBuilder
{
private:
  bool has_finest = false;
  bool has_coarsest = false;
  CycleOpts opts;
 
  std::shared_ptr<Level<D>> finest_level;
  std::shared_ptr<Level<D>> prev_level;
 
public:
  explicit CycleBuilder(const CycleOpts& opts_in)
    : opts(opts_in)
  {}
  void addFinestLevel(const Operator<D>& op,
                      const Smoother<D>& smoother,
                      const Restrictor<D>& restrictor)
  {
    if (has_finest) {
      throw RuntimeError("addFinestLevel was already called");
    }
    has_finest = true;
 
    finest_level = std::make_shared<Level<D>>();
    finest_level->setOperator(op);
    finest_level->setSmoother(smoother);
    finest_level->setRestrictor(restrictor);
 
    prev_level = finest_level;
  }
  void addIntermediateLevel(const Operator<D>& op,
                            const Smoother<D>& smoother,
                            const Restrictor<D>& restrictor,
                            const Interpolator<D>& interpolator)
  {
    if (!has_finest) {
      throw RuntimeError("addFinestLevel has not been called yet");
    }
    if (has_coarsest) {
      throw RuntimeError("addCoarsestLevel has been called");
    }
 
    auto new_level = std::make_shared<Level<D>>();
    new_level->setOperator(op);
    new_level->setSmoother(smoother);
    new_level->setInterpolator(interpolator);
    new_level->setRestrictor(restrictor);
 
    prev_level->setCoarser(new_level);
 
    prev_level = new_level;
  }
  void addCoarsestLevel(const Operator<D>& op,
                        Smoother<D>& smoother,
                        const Interpolator<D>& interpolator)
  {
    if (!has_finest) {
      throw RuntimeError("addFinestLevel has not been called yet");
    }
    if (has_coarsest) {
      throw RuntimeError("addCoarsestLevel has already been called");
    }
    has_coarsest = true;
 
    auto new_level = std::make_shared<Level<D>>();
    new_level->setOperator(op);
    new_level->setSmoother(smoother);
    new_level->setInterpolator(interpolator);
 
    prev_level->setCoarser(new_level);
  }
  std::shared_ptr<Cycle<D>> getCycle() const
  {
    if (!has_coarsest) {
      throw RuntimeError("addCoarsestLevel has not been called");
    }
    std::shared_ptr<Cycle<D>> cycle;
    if (opts.cycle_type == "V") {
      cycle.reset(new VCycle<D>(*finest_level, opts));
    } else if (opts.cycle_type == "W") {
      cycle.reset(new WCycle<D>(*finest_level, opts));
    } else if (opts.cycle_type == "F") {
      cycle.reset(new FMGCycle<D>(*finest_level, opts));
    } else {
      throw RuntimeError("Unsupported Cycle type: " + opts.cycle_type);
    }
    return cycle;
  }
};
extern template class CycleBuilder<2>;
extern template class CycleBuilder<3>;
} // namespace ThunderEgg::GMG
 
#endif