mlsdc_impl.hpp

Go to the documentation of this file.

#include "pfasst/controller/mlsdc.hpp"

#include <algorithm>
using namespace std;

#include "pfasst/logging.hpp"


namespace pfasst
{
  template<typename time>
  void MLSDC<time>::perform_sweeps(size_t level)
  {
    auto sweeper = this->get_level(level);
    ML_CVLOG(1, "Controller", "on level " << level + 1 << "/" << this->nlevels());
    for (size_t s = 0; s < this->nsweeps[level]; s++) {
      if (predict) {
        sweeper->predict(initial & predict);
        sweeper->post_predict();
        predict = false;
      } else {
        sweeper->sweep();
        sweeper->post_sweep();
      }
    }
  }

  template<typename time>
  void MLSDC<time>::setup()
  {
    this->nsweeps.resize(this->nlevels());
    fill(this->nsweeps.begin(), this->nsweeps.end(), 1);
    for (auto leviter = this->coarsest(); leviter <= this->finest(); ++leviter) {
      leviter.current()->set_controller(this);
      leviter.current()->setup(leviter != this->finest());
    }
  }

  template<typename time>
  void MLSDC<time>::set_nsweeps(vector<size_t> nsweeps)
  {
    this->nsweeps = nsweeps;
  }

  template<typename time>
  void MLSDC<time>::run()
  {
    for (; this->get_time() < this->get_end_time(); this->advance_time()) {
      predict = true;
      initial = true;
      converged = false;

      for (this->set_iteration(0);
           this->get_iteration() < this->get_max_iterations() && !converged;
           this->advance_iteration()) {
        cycle_v(this->finest());
        initial = false;
      }

      perform_sweeps(this->finest().level);

      for (auto l = this->finest(); l >= this->coarsest(); --l) {
        l.current()->post_step();
      }

      if (this->get_time() + this->get_step_size() < this->get_end_time()) {
        this->get_finest()->advance();
      }
    }
  }

  template<typename time>
  typename MLSDC<time>::LevelIter MLSDC<time>::cycle_down(typename MLSDC<time>::LevelIter level_iter)
  {
    auto fine = level_iter.current();
    auto crse = level_iter.coarse();
    auto trns = level_iter.transfer();

    perform_sweeps(level_iter.level);

    if (level_iter == this->finest() && fine->converged()) {
      converged = true;
      return level_iter;
    }

    ML_CVLOG(1, "Controller", "Cycle down onto level " << level_iter.level << "/" << this->nlevels());
    trns->restrict(crse, fine, initial);
    trns->fas(this->get_step_size(), crse, fine);
    crse->save();

    return level_iter - 1;
  }

  template<typename time>
  typename MLSDC<time>::LevelIter MLSDC<time>::cycle_up(typename MLSDC<time>::LevelIter level_iter)
  {
    auto fine = level_iter.current();
    auto crse = level_iter.coarse();
    auto trns = level_iter.transfer();

    ML_CVLOG(1, "Controller", "Cycle up onto level " << level_iter.level + 1 << "/" << this->nlevels());
    trns->interpolate(fine, crse);

    if (level_iter < this->finest()) {
      perform_sweeps(level_iter.level);
    }

    return level_iter + 1;
  }

  template<typename time>
  typename MLSDC<time>::LevelIter MLSDC<time>::cycle_bottom(typename MLSDC<time>::LevelIter level_iter)
  {
    perform_sweeps(level_iter.level);
    return level_iter + 1;
  }

  template<typename time>
  typename MLSDC<time>::LevelIter MLSDC<time>::cycle_v(typename MLSDC<time>::LevelIter level_iter)
  {
    if (level_iter.level == 0) {
      level_iter = cycle_bottom(level_iter);
    } else {
      level_iter = cycle_down(level_iter);
      if (converged) {
        return level_iter;
      }
      level_iter = cycle_v(level_iter);
      level_iter = cycle_up(level_iter);
    }
    return level_iter;
  }
}  // ::pfasst