SpECTRE Documentation Coverage Report
Current view: top level - IO/Observer - ObservationId.hpp Hit Total Coverage
Commit: 9e4176f904ee1c51f05efc42ff1e485357699444 Lines: 6 26 23.1 %
Date: 2024-03-28 23:18:37
Legend: Lines: hit not hit

          Line data    Source code
       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <boost/functional/hash.hpp>
       7             : #include <cstddef>
       8             : #include <functional>
       9             : #include <iosfwd>
      10             : #include <limits>
      11             : #include <string>
      12             : #include <type_traits>
      13             : 
      14             : #include "Utilities/PrettyType.hpp"
      15             : 
      16             : /// \cond
      17             : namespace PUP {
      18             : class er;
      19             : }  // namespace PUP
      20             : /// \endcond
      21             : 
      22             : namespace observers {
      23             : /// \cond
      24             : class ObservationId;
      25             : /// \endcond
      26             : 
      27             : /// Used as a key in maps to keep track of how many elements have registered.
      28           1 : class ObservationKey {
      29             :  public:
      30           0 :   ObservationKey() = default;
      31             : 
      32           0 :   explicit ObservationKey(std::string tag);
      33             : 
      34             :   // NOLINTNEXTLINE(google-runtime-references)
      35           0 :   void pup(PUP::er& p);
      36             : 
      37           0 :   size_t key() const { return key_; }
      38             : 
      39           0 :   const std::string& tag() const;
      40             : 
      41             :  private:
      42           0 :   size_t key_{0};
      43           0 :   std::string tag_{};
      44             : };
      45             : 
      46           0 : bool operator==(const ObservationKey& lhs, const ObservationKey& rhs);
      47           0 : bool operator!=(const ObservationKey& lhs, const ObservationKey& rhs);
      48             : 
      49           0 : std::ostream& operator<<(std::ostream& os, const ObservationKey& t);
      50             : 
      51             : /*!
      52             :  * \ingroup ObserversGroup
      53             :  * \brief A unique identifier for an observation representing the type of
      54             :  * observation and the instance (e.g. time) at which the observation occurs.
      55             :  *
      56             :  * The ObservationId is used to uniquely identify an observation inside our H5
      57             :  * subfiles that can be agreed upon across the system. That is, it does not
      58             :  * depend on hardware rounding of floating points because it is an integral. One
      59             :  * example would be a `Time` for output observed every `N` steps in a global
      60             :  * time stepping evolution. Another example could be having a counter class for
      61             :  * dense output observations that increments the counter for each observation
      62             :  * but has a value equal to the physical time.
      63             :  *
      64             :  * The constructor takes a `double` representing the current "time" at which we
      65             :  * are observing. For an evolution this could be the physical time, while for an
      66             :  * elliptic solve this could be a combination of nonlinear and linear iteration.
      67             :  *
      68             :  * A specialization of `std::hash` is provided to allow using `ObservationId`
      69             :  * as a key in associative containers.
      70             :  */
      71           1 : class ObservationId {
      72             :  public:
      73           0 :   ObservationId() = default;
      74             :   /*!
      75             :    * \brief Construct from a value and a string tagging the observation
      76             :    *
      77             :    * The tag is a unique string used to identify the particular observation.
      78             :    */
      79           1 :   ObservationId(double t, std::string tag);
      80             : 
      81           0 :   ObservationId(double t, ObservationKey key);
      82             : 
      83             :   /// Hash used to distinguish between ObservationIds of different
      84             :   /// types and subtypes. This hash does not contain any information about the
      85             :   /// `Id` or its value.
      86           1 :   const ObservationKey& observation_key() const { return observation_key_; }
      87             : 
      88             :   /// Hash distinguishing different ObservationIds, including
      89             :   /// the value of the `Id`.
      90           1 :   size_t hash() const { return combined_hash_; }
      91             : 
      92             :   /// The simulation "time".
      93           1 :   double value() const { return value_; }
      94             : 
      95             :   // NOLINTNEXTLINE(google-runtime-references)
      96           0 :   void pup(PUP::er& p);
      97             : 
      98             :  private:
      99           0 :   ObservationKey observation_key_{};
     100           0 :   size_t combined_hash_{0};
     101           0 :   double value_{std::numeric_limits<double>::signaling_NaN()};
     102             : };
     103             : 
     104           0 : bool operator==(const ObservationId& lhs, const ObservationId& rhs);
     105           0 : bool operator!=(const ObservationId& lhs, const ObservationId& rhs);
     106             : 
     107           0 : std::ostream& operator<<(std::ostream& os, const ObservationId& t);
     108             : }  // namespace observers
     109             : 
     110             : namespace std {
     111             : template <>
     112             : struct hash<observers::ObservationId> {
     113             :   size_t operator()(const observers::ObservationId& t) const {
     114             :     return t.hash();
     115             :   }
     116             : };
     117             : 
     118             : template <>
     119             : struct hash<observers::ObservationKey> {
     120             :   size_t operator()(const observers::ObservationKey& t) const {
     121             :     return t.key();
     122             :   }
     123             : };
     124             : }  // namespace std

Generated by: LCOV version 1.14