MaterialPropertyStorage.h File Reference

Go to the source code of this file.

Classes
class	MaterialPropertyStorage
	Stores the stateful material properties computed by materials. More...
struct	MaterialPropertyStorage::PropRecord
	Basic structure for storing information about a property. More...

Namespaces
	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.

Functions
void	dataStore (std::ostream &stream, MaterialPropertyStorage &storage, void *context)
void	dataLoad (std::istream &stream, MaterialPropertyStorage &storage, void *context)
void	dataStore (std::ostream &stream, MaterialPropertyStorage::PropRecord &record, void *context)
void	dataLoad (std::istream &stream, MaterialPropertyStorage::PropRecord &record, void *context)

Function Documentation

dataLoad() [1/2]

void dataLoad	(	std::istream &	stream,
		MaterialPropertyStorage &	storage,
		void *	context
	)

Definition at line 644 of file MaterialPropertyStorage.C.

Referenced by dataLoad().

{
  storage._restartable_map.clear();

  const auto & registry = storage.getMaterialPropertyRegistry();

  std::vector<std::string> from_prop_ids_to_names;
  dataLoad(stream, from_prop_ids_to_names, nullptr);

  decltype(storage._stateful_prop_id_to_prop_id) from_stateful_prop_id_to_prop_id;
  dataLoad(stream, from_stateful_prop_id_to_prop_id, nullptr);

  decltype(storage._prop_records) from_prop_records;
  dataLoad(stream, from_prop_records, nullptr);

  decltype(storage.numStates()) num_states;
  dataLoad(stream, num_states, nullptr);

  {
    // Build maps of material object -> properties and property -> material objects
    const auto build_maps = [](const auto & prop_records, const auto & ids_to_names)
    {
      std::map<std::string, std::set<std::string>> object_to_props, prop_to_objects;
      for (const auto i : index_range(prop_records))
        if (prop_records[i] && prop_records[i]->stateful())
        {
          const auto & prop = ids_to_names[i];
          for (const auto & declarer : (*prop_records[i]).declarers)
          {
            object_to_props[declarer].insert(prop);
            prop_to_objects[prop].insert(declarer);
          }
        }

      return std::make_pair(std::move(object_to_props), std::move(prop_to_objects));
    };
    // Maps for the current stateful properties
    const std::vector<std::string> prop_ids_to_names(registry.idsToNamesBegin(),
                                                     registry.idsToNamesEnd());
    const auto [object_to_props, prop_to_objects] =
        build_maps(storage._prop_records, prop_ids_to_names);
    // Maps for the stored stateful properties
    const auto [from_object_to_props, from_prop_to_objects] =
        build_maps(from_prop_records, from_prop_ids_to_names);

    // Enforce our stateful requirements
    for (const auto & [object, props] : object_to_props)
    {
      const auto find_from_object = from_object_to_props.find(object);

      // We have a material object that was stored with the same name that
      // had stateful material properties. Here, we enforce that the stateful
      // properties stored match exactly the ones that we have declared in
      // the new run
      if (find_from_object != from_object_to_props.end())
      {
        const auto & from_props = find_from_object->second;
        if (props != from_props)
        {
          std::stringstream error;
          error << "The stateful material properties in " << object
                << " that are being restarted do not match the stored properties in the same "
                   "material object from the checkpoint.\n\n";
          error << "Checkpointed stateful properties:\n";
          for (const auto & prop : from_props)
            error << " - " << prop << "\n";
          error << "\nCurrent stateful properties:\n";
          for (const auto & prop : props)
            error << " - " << prop << "\n";
          mooseError(error.str());
        }
      }
      // We're recovering and we haven't found a stateful material object. We require a
      // one-to-one stateful mapping when recovering
      else if (storage._recovering)
      {
        mooseError("The ",
                   object,
                   " was stored in restart but no longer exists. This is not supported when "
                   "recovering stateful material properties.");
      }
    }

    // We can easily support this, but have chosen not to due to ambiguity and we
    // don't yet know how to express this ambiguity. Just removing this error
    // _should_ make it work without issue because to_stateful_ids below for this
    // property will be an empty optional, which means simply don't load it. Or,
    // we could load it into the new property.
    for (const auto & [from_prop, from_objects] : from_prop_to_objects)
      if (const auto find_objects = prop_to_objects.find(from_prop);
          find_objects != prop_to_objects.end())
        for (const auto & object : find_objects->second)
          if (!from_objects.count(object))
            mooseError(
                "The stateful material property '",
                from_prop,
                "' was declared in ",
                object,
                " but was not declared in that object on checkpoint.\n\nThis is not currently "
                "supported due to ambiguity.\n\nPlease contact the development team on "
                "GitHub if you desire this capability.");
  }

  std::vector<std::optional<unsigned int>> to_stateful_ids(from_stateful_prop_id_to_prop_id.size());

  auto & to_prop_records = storage._prop_records;

  // Mark everything as not restored in the event that we call this again
  for (auto & record_ptr : to_prop_records)
    if (record_ptr)
      record_ptr->restored = false;

  // Fill the mapping from previous ID to current stateful ID
  for (const auto from_stateful_id : index_range(from_stateful_prop_id_to_prop_id))
  {
    const auto from_prop_id = from_stateful_prop_id_to_prop_id[from_stateful_id];

    mooseAssert(from_prop_id < from_prop_records.size(), "Invalid record map");
    mooseAssert(from_prop_records[from_prop_id], "Not set");
    const auto & from_record = *from_prop_records[from_prop_id];
    mooseAssert(from_record.stateful(), "Not stateful");

    mooseAssert(from_prop_id < from_prop_ids_to_names.size(), "Invalid ID map");
    const auto & name = from_prop_ids_to_names[from_prop_id];

    if (const auto query_to_prop_id = registry.queryID(name))
    {
      const auto to_prop_id = *query_to_prop_id;

      mooseAssert(to_prop_id < to_prop_records.size(), "Invalid record map");
      mooseAssert(to_prop_records[to_prop_id], "Not set");
      auto & to_record = *to_prop_records[to_prop_id];

      if (to_record.stateful())
      {
        if (from_record.type != to_record.type)
          mooseError(
              "The type for the restarted stateful material property '", name, "' does not match");

        // I'm not sure if we need to enforce this one, but I don't want to think
        // about it deeply so we'll just make it an error until someone complains
        // we have time to think
        if (from_record.state != to_record.state)
          mooseError("The number of states for the restarted stateful material property '",
                     name,
                     "' do not match.\n\n",
                     "Checkpointed states: ",
                     from_record.state,
                     "\nCurrent states: ",
                     to_record.state);

        const auto to_stateful_id = storage.getPropRecord(to_prop_id).stateful_id;
        mooseAssert(to_stateful_id != invalid_uint, "Not stateful");

        to_stateful_ids[from_stateful_id] = to_stateful_id;

        // Mark that we're going to restore this property
        to_record.restored = true;
        mooseAssert(storage.isRestoredProperty(name), "Restored mismatch");

        if (storage._recovering)
          mooseAssert(from_stateful_id == to_stateful_id, "Does not have direct mapping");
      }
    }
  }

  // Load the properties
  for (const auto state : make_range(num_states))
  {
    std::size_t num_elems;
    dataLoad(stream, num_elems, nullptr);

    for (std::size_t i_elem = 0; i_elem < num_elems; ++i_elem)
    {
      const Elem * elem;
      dataLoad(stream, elem, context);
      mooseAssert(elem, "Null element");

      std::size_t num_sides;
      dataLoad(stream, num_sides, nullptr);

      for (std::size_t i_side = 0; i_side < num_sides; ++i_side)
      {
        unsigned int side;
        dataLoad(stream, side, nullptr);

        std::size_t num_props;
        dataLoad(stream, num_props, nullptr);
        mooseAssert(num_props <= to_stateful_ids.size(), "Missized map");

        std::size_t num_q_points;
        dataLoad(stream, num_q_points, nullptr);

        // Avoid multiple map lookups for entries pertaining to [elem, side]
        MaterialPropertyStorage::RestartableMapType::mapped_type * restart_entry = nullptr;
        MaterialProperties * in_place_entry = nullptr;

        // Load each stateful property
        for (const auto from_stateful_id : make_range(num_props))
        {
          // Load the binary data, which lets us choose in a moment whether
          // or not to load it in place or to cache it to load later
          std::stringstream data;
          dataLoad(stream, data, nullptr);
          data.seekg(0, std::ios::beg);

          // We have a property to load into
          if (const auto to_stateful_id_ptr = to_stateful_ids[from_stateful_id])
          {
            const auto to_stateful_id = *to_stateful_id_ptr;

            // Load the data directly into _storage
            if (storage._restart_in_place)
            {
              if (!in_place_entry)
                in_place_entry = &storage.setProps(elem, side, state);

              dataLoad(data, (*in_place_entry)[to_stateful_id], nullptr);
            }
            // Properties aren't initialized, so load the data into
            // _restartable_map to be loaded later in initStatefulProps()
            else
            {
              if (!restart_entry)
                restart_entry = &storage._restartable_map[std::make_pair(elem, side)];

              auto & mat_entry = (*restart_entry)[to_stateful_id];
              if (state >= mat_entry.size())
                mat_entry.resize(state + 1);

              mat_entry[state] = std::move(data);
            }
          }
        }
      }
    }
  }
}

dataLoad() [2/2]

void dataLoad	(	std::istream &	stream,
		MaterialPropertyStorage::PropRecord &	record,
		void *	context
	)

Definition at line 893 of file MaterialPropertyStorage.C.

{
  dataLoad(stream, record.declarers, nullptr);
  dataLoad(stream, record.type, nullptr);
  dataLoad(stream, record.stateful_id, nullptr);
  dataLoad(stream, record.state, nullptr);
}

dataStore() [1/2]

void dataStore	(	std::ostream &	stream,
		MaterialPropertyStorage &	storage,
		void *	context
	)

Definition at line 581 of file MaterialPropertyStorage.C.

Referenced by dataStore().

{
  // Store the material property ID -> name map for mapping back
  const auto & registry = storage.getMaterialPropertyRegistry();
  std::vector<std::string> ids_to_names(registry.idsToNamesBegin(), registry.idsToNamesEnd());
  dataStore(stream, ids_to_names, nullptr);

  // Store the stateful ID -> property ID map for mapping back
  dataStore(stream, storage._stateful_prop_id_to_prop_id, nullptr);

  // Store the prop -> record map
  dataStore(stream, storage._prop_records, nullptr);

  // Store the number of states
  auto num_states = storage.numStates();
  dataStore(stream, num_states, nullptr);

  // Store every property
  for (const auto state : storage.stateIndexRange())
  {
    std::size_t num_elems = storage.setProps(state).size();
    dataStore(stream, num_elems, nullptr);

    for (auto & elem_side_map_pair : storage.setProps(state))
    {
      const Elem * elem = elem_side_map_pair.first;
      mooseAssert(elem, "Null element");
      dataStore(stream, elem, context);

      auto & side_map = elem_side_map_pair.second;
      std::size_t num_sides = side_map.size();
      dataStore(stream, num_sides, nullptr);

      for (auto & [side, props] : side_map)
      {
        dataStore(stream, side, nullptr);

        std::size_t num_props = props.size();
        dataStore(stream, num_props, nullptr);
        mooseAssert(num_props > 0, "No properties");

        std::size_t n_q_points = 0;
        for (const auto & entry : props)
          if (entry.size() > n_q_points)
            n_q_points = entry.size();
        dataStore(stream, n_q_points, nullptr);

        // Here we actually store a stringstream of the data instead of the data directly, because
        // upon load we don't know if we can load it immediately into place or if we need to cache
        // it to load later. We also store it as skippable so that we can support not loading a
        // property if it no longer exists in restart
        for (auto & entry : props)
        {
          std::stringstream out;
          dataStore(out, entry, nullptr);
          dataStore(stream, out, nullptr);
        }
      }
    }
  }
}

dataStore() [2/2]

void dataStore	(	std::ostream &	stream,
		MaterialPropertyStorage::PropRecord &	record,
		void *	context
	)

Definition at line 884 of file MaterialPropertyStorage.C.

{
  dataStore(stream, record.declarers, nullptr);
  dataStore(stream, record.type, nullptr);
  dataStore(stream, record.stateful_id, nullptr);
  dataStore(stream, record.state, nullptr);
}