event.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2010 - 2019 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.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