value_by_id_impl.h

Go to the documentation of this file.

/* 
 * SPDX-FileCopyrightText: 2025 Gesellschaft fuer Anlagen- und Reaktorsicherheit gGmbH
 * SPDX-License-Identifier: EUPL-1.2
 * SPDX-FileContributor: Dmitry Logashenko
 * SPDX-FileContributor: Goethe Universität Frankfurt
 * SPDX-FileType: SOURCE
 * 
 * This file is part of d3f++.
 * d3f++ is an extension for UG4. Licensing information and citation requirements of UG4 are provided in LICENSES/UG4-LGPL_2.1
 */
 
 
 
#include "common/util/file_util.h"
 
namespace ug {
namespace d3f {
 
template <typename TIdManager>
number ValueById<TIdManager>::interpolate
(
  number x, number y,
  number t 
) const
{
  if (m_numCols < 1)
    UG_THROW ("ValueById: No data read yet!");
  
  int ident;
  if (! this->get_id_by_pnt (x, y, ident))
    return m_default_value;
  if (ident < 0 || ident >= (int) m_data.size () || ! m_assigned[ident])
    UG_THROW ("ValueById: Inquired id " << ident << " not assigned!");
    
  size_t col = size_t (floor (t / m_interval)) % m_numCols;
  return m_data [ident * m_numCols + col];
}
 
template <typename TIdManager>
void ValueById<TIdManager>::append_value
(
  long ident, 
  std::vector<number>& val 
)
{
  if (ident < 0)
    UG_THROW ("ValueById: Id < 0 not supported!");
    
  if (m_numCols < 1) // still no data in the object
  {
    m_data.clear (); m_assigned.clear ();
    m_numCols = val.size ();
    size_t init_size = ident + 1;
    m_data.resize (init_size * m_numCols);
    m_assigned.resize (init_size, false);
  }
  else
  {
    if (val.size () != m_numCols)
      UG_THROW ("ValueById: Data length should be equal for all Id's!");
    
    if ((size_t) ident >= m_assigned.size ())
    {
      size_t new_size = ident + 1;
      m_data.resize (new_size * m_numCols);
      m_assigned.resize (new_size, false);
    }
    else if (m_assigned[ident])
      UG_THROW ("ValueById: Redefining value for id " << ident);
  }
  
  for (size_t col = 0; col < m_numCols; col++)
    m_data[ident * m_numCols + col] = val[col];
  m_assigned[ident] = true;
}
 
template <typename TIdManager>
void ValueById<TIdManager>::load_values_from (std::istream & input)
{
  size_t num_lines = 0;
  size_t num_data_lines = 0;
  std::string input_line;
  std::vector<number> values;
  
  m_numCols = 0; // to clear the data
  
  try
  {
    while (! input.eof ())
    {
      long ident;
    
      num_lines++;
      if (input.fail ())
        UG_THROW ("ValueById: Could not load the points from the file!");
      std::getline (input, input_line);
      if (input_line.length () == 0)
        continue;
    
      const char * str = input_line.c_str ();
      char * end_ptr;
      while (*str && std::isspace (*str)) str++;
      if (*str == '#')
        continue; // this is a comment
      ident = std::strtol (str, &end_ptr, 10);
      if (end_ptr == str)
        UG_THROW ("ValueById: Failed to parse the identifier.\n");
      str = end_ptr;
    
      while (*str && std::isspace (*str)) str++;
      values.clear ();
      while (*str && *str != '#')
      {
        number v = std::strtod (str, &end_ptr);
        if (end_ptr == str)
          UG_THROW ("ValueById: Failed to parse a value.\n");
        values.push_back (v);
        str = end_ptr;
        while (*str && std::isspace (*str)) str++;
      }
    
      append_value (ident, values);
      num_data_lines++;
    }
  }
  UG_CATCH_THROW ("ValueById: Error in line no. " << num_lines << ": '" << input_line << "'\n");
  
  UG_LOG
  (
    "ValueById: " << num_lines << " lines read from the file"
    " (" << num_data_lines << " data lines with " << m_numCols << " values per line).\n"
  );
}
 
template <typename TIdManager>
void ValueById<TIdManager>::load_values_from (const char * file_name)
{
  std::string fullFileName = FindFileInStandardPaths(file_name);
  UG_COND_THROW (fullFileName.empty(), "ValueById: Coulnd't locate file '" << file_name);
 
  std::ifstream input (fullFileName.c_str(), std::ifstream::in);
 
  if (input.fail ())
    UG_THROW ("ValueById: Failed to open data file '" << fullFileName << "' for input!");
  UG_LOG ("ValueById: Reading data from '" << fullFileName << "'\n");
  load_values_from (input);
}
 
} // namespace d3f
} // end namespace ug
 
/* End of File */