event.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2010 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------


#ifndef dealii_event_h
#define dealii_event_h

#include <deal.II/base/config.h>

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

DEAL_II_NAMESPACE_OPEN

namespace Algorithms
{
  class Event
  {
  public:
    static Event
    assign(const std::string &name);

    //      static Event find(const std::string& name);

    Event();

    void
    clear();

    void
    all();

    Event &
    operator+=(const Event &event);

    Event &
    operator-=(const Event &event);

    bool
    test(const Event &event) const;

    bool
    any() const;

    template <class OS>
    void
    print(OS &os) const;

    template <class OS>
    static void
    print_assigned(OS &os);

  private:
    bool all_true;

    std::vector<bool> flags;

    // TODO: This static field must be guarded by a mutex to be thread-safe!
    static std::vector<std::string> names;
  };

  namespace Events
  {
    extern const Event initial;

    extern const Event remesh;

    extern const Event bad_derivative;

    extern const Event new_time;

    extern const Event new_timestep_size;
  } // namespace Events


  //----------------------------------------------------------------------//


  inline bool
  Event::any() const
  {
    if (all_true)
      return true;
    return std::find(flags.begin(), flags.end(), true) != flags.end();
  }


  inline bool
  Event::test(const Event &event) const
  {
    // First, test all_true in this
    if (all_true)
      return true;

    const unsigned int n     = flags.size();
    const unsigned int m     = event.flags.size();
    const unsigned int n_min = (n < m) ? n : m;

    // Now, if all_true set in the
    // other, then all must be true
    // in this
    if (event.all_true)
      {
        // Non existing flags are
        // always assumed false
        if (m > n)
          return false;

        // Test all flags separately
        // and return false if one is
        // not set
        return std::find(flags.begin(), flags.end(), false) == flags.end();
      }

    // Finally, compare each flag
    // separately
    for (unsigned int i = 0; i < n_min; ++i)
      if (event.flags[i] && !flags[i])
        return false;
    for (unsigned int i = n_min; i < m; ++i)
      if (event.flags[i])
        return false;
    return true;
  }



  inline Event &
  Event::operator+=(const Event &event)
  {
    all_true |= event.all_true;
    if (all_true)
      return *this;

    if (flags.size() < event.flags.size())
      flags.resize(event.flags.size());
    for (unsigned int i = 0; i < event.flags.size(); ++i)
      flags[i] = flags[i] || event.flags[i];

    return *this;
  }


  inline Event &
  Event::operator-=(const Event &event)
  {
    if (!event.any())
      return *this;

    all_true = false;
    if (event.all_true)
      {
        std::fill(flags.begin(), flags.end(), false);
        return *this;
      }

    if (flags.size() < event.flags.size())
      flags.resize(event.flags.size());
    for (unsigned int i = 0; i < event.flags.size(); ++i)
      if (event.flags[i])
        flags[i] = false;

    return *this;
  }


  template <class OS>
  inline void
  Event::print(OS &os) const
  {
    if (all_true)
      os << " ALL";

    for (unsigned int i = 0; i < flags.size(); ++i)
      if (flags[i])
        os << ' ' << names[i];
  }


  template <class OS>
  inline void
  Event::print_assigned(OS &os)
  {
    for (unsigned int i = 0; i < names.size(); ++i)
      os << i << '\t' << names[i] << std::endl;
  }


  template <class OS>
  OS &
  operator<<(OS &o, const Event &e)
  {
    e.print(o);
    return o;
  }
} // namespace Algorithms

DEAL_II_NAMESPACE_CLOSE

#endif