state_vector.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2024 - 2026 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include "multicomponent_vector.h"
 
#include <tuple>
#include <vector>
 
namespace ryujin
{
#ifndef DOXYGEN
  /* Forward declaration */
  template <int dim, typename Number>
  class OfflineData;
#endif
 
  namespace Vectors
  {
    template <typename Number>
    using ScalarHostVector = dealii::LinearAlgebra::distributed::Vector<Number>;
 
 
    template <typename Number>
    using ScalarVector = MultiComponentVector<Number, 1>;
 
 
    template <typename Number, unsigned int problem_dim, unsigned int prec_dim>
    using StateVector = std::tuple<
        MultiComponentVector<Number, problem_dim> /*U*/,
        MultiComponentVector<Number, prec_dim> /*precomputed values*/,
        std::vector<ScalarVector<Number>> /*parabolic state*/>;
 
 
    template <typename Number, int prob_dim, int prec_dim, typename OfflineData>
    void debug_poison_invalid_values(
        StateVector<Number, prob_dim, prec_dim> &state_vector [[maybe_unused]],
        const OfflineData &offline_data [[maybe_unused]])
    {
#ifdef DEBUG
 
      auto &[U, prec, V] = state_vector;
 
      /* Ensure that the state vector is resident on the host memory space. */
      if constexpr (have_separate_memory_spaces) {
        U.template move_to_memory_space<dealii::MemorySpace::Host>();
        prec.template move_to_memory_space<dealii::MemorySpace::Host>();
      }
 
      constexpr auto nan = std::numeric_limits<Number>::signaling_NaN();
 
      const unsigned int n_owned = offline_data.n_locally_owned();
      const unsigned int n_relevant = offline_data.n_locally_relevant();
      const auto &partitioner = offline_data.scalar_partitioner();
 
      const auto U_view = U.view();
      const auto prec_view = prec.view();
 
      for (unsigned int i = 0; i < n_owned; ++i) {
        prec_view.write_tensor(dealii::Tensor<1, prec_dim, Number>() * nan, i);
 
        if (!offline_data.affine_constraints().is_constrained(
                partitioner->local_to_global(i)))
          continue;
        U_view.write_tensor(dealii::Tensor<1, prob_dim, Number>() * nan, i);
      }
 
      for (unsigned int i = n_owned; i < n_relevant; ++i) {
        prec_view.write_tensor(dealii::Tensor<1, prec_dim, Number>() * nan, i);
 
        U_view.write_tensor(dealii::Tensor<1, prob_dim, Number>() * nan, i);
      }
#endif
    }
 
  } // namespace Vectors
} // namespace ryujin