Shared observation history stacking and factor-expansion logic for libtorch-based controls and trainers. More...

#include <LibtorchObservationHistoryHelper.h>

Public Member Functions
	LibtorchObservationHistoryHelper (unsigned int input_timesteps)
	Build an observation-history helper for libtorch inputs.

unsigned int	inputTimesteps () const
	Return the number of timesteps stacked into each flattened input.

void	initializeHistory (const std::vector< Real > &observation, std::vector< std::vector< Real > > &old_observations) const
	Fill the history buffer with copies of the current observation.

void	advanceHistory (const std::vector< Real > &observation, std::vector< std::vector< Real > > &old_observations) const
	Advance the history buffer by inserting the latest observation.

std::vector< Real >	expandObservationFactors (const std::vector< Real > &observation_factors) const
	Repeat per-observation-entry factors across all stacked timesteps.

std::vector< Real >	stackCurrentObservation (const std::vector< Real > &observation, const std::vector< std::vector< Real > > &old_observations) const
	Flatten the current observation together with its stored history.

std::vector< Real >	stackTrajectoryObservation (const std::vector< std::vector< Real > > &component_trajectories, unsigned int time_index) const
	Flatten one time slice of observation-component trajectories with causal history.

Private Member Functions
void	validateTrajectoryShape (const std::vector< std::vector< Real > > &component_trajectories) const
	Check that all observation-component trajectories have a consistent shape.

Private Attributes
const unsigned int	_input_timesteps
	Number of timesteps stacked into each flattened observation.

Detailed Description

Shared observation history stacking and factor-expansion logic for libtorch-based controls and trainers.

Definition at line 22 of file LibtorchObservationHistoryHelper.h.

Constructor & Destructor Documentation

◆ LibtorchObservationHistoryHelper()

LibtorchObservationHistoryHelper::LibtorchObservationHistoryHelper ( unsigned int input_timesteps )

Build an observation-history helper for libtorch inputs.

Parameters

input_timesteps Number of timesteps to stack into each flattened input.

Definition at line 19 of file LibtorchObservationHistoryHelper.C.

  : _input_timesteps(input_timesteps)
{
  if (_input_timesteps == 0)
    mooseError("Observation history requires at least one input timestep.");
}

Member Function Documentation

◆ advanceHistory()

void LibtorchObservationHistoryHelper::advanceHistory	(	const std::vector< Real > &	observation,
		std::vector< std::vector< Real > > &	old_observations
	)		const

Advance the history buffer by inserting the latest observation.

Parameters

observation	Current observation.
old_observations	History buffer ordered from newest to oldest.

Definition at line 48 of file LibtorchObservationHistoryHelper.C.

{
  if (old_observations.empty())
    return;
 
  std::rotate(old_observations.rbegin(), old_observations.rbegin() + 1, old_observations.rend());
  old_observations[0] = observation;
}

Referenced by LibtorchNeuralNetControl::execute().

◆ expandObservationFactors()

std::vector< Real > LibtorchObservationHistoryHelper::expandObservationFactors ( const std::vector< Real > & observation_factors ) const

Repeat per-observation-entry factors across all stacked timesteps.

Parameters

observation_factors Per-entry factors for one observation vector.

Definition at line 59 of file LibtorchObservationHistoryHelper.C.

{
  if (observation_factors.empty())
    return {};
 
  std::vector<Real> expanded;
  expanded.reserve(observation_factors.size() * _input_timesteps);
 
  for (const auto lag : make_range(_input_timesteps))
  {
    libmesh_ignore(lag);
    expanded.insert(expanded.end(), observation_factors.begin(), observation_factors.end());
  }
 
  return expanded;
}

Referenced by LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), and LibtorchNeuralNetControl::prepareInputTensor().

◆ initializeHistory()

void LibtorchObservationHistoryHelper::initializeHistory	(	const std::vector< Real > &	observation,
		std::vector< std::vector< Real > > &	old_observations
	)		const

Fill the history buffer with copies of the current observation.

Parameters

observation	Current observation.
old_observations	History buffer that stores previous observations.

Definition at line 41 of file LibtorchObservationHistoryHelper.C.

{
  old_observations.assign(_input_timesteps - 1, observation);
}

Referenced by LibtorchNeuralNetControl::execute().

◆ inputTimesteps()

unsigned int LibtorchObservationHistoryHelper::inputTimesteps ( ) const

inline

Return the number of timesteps stacked into each flattened input.

Definition at line 34 of file LibtorchObservationHistoryHelper.h.

34{ return _input_timesteps; }

◆ stackCurrentObservation()

std::vector< Real > LibtorchObservationHistoryHelper::stackCurrentObservation	(	const std::vector< Real > &	observation,
		const std::vector< std::vector< Real > > &	old_observations
	)		const

Flatten the current observation together with its stored history.

Parameters

observation	Current observation.
old_observations	History buffer ordered from newest to oldest.

Definition at line 78 of file LibtorchObservationHistoryHelper.C.

{
  const auto expected_history_size = _input_timesteps - 1;
  if (old_observations.size() != expected_history_size)
    mooseError("Observation history must contain ",
               expected_history_size,
               " stored entries, but got ",
               old_observations.size(),
               ".");
 
  std::vector<Real> stacked;
  stacked.reserve(observation.size() * _input_timesteps);
 
  stacked.insert(stacked.end(), observation.begin(), observation.end());
 
  for (const auto & history_entry : old_observations)
  {
    if (history_entry.size() != observation.size())
      mooseError("Observation history entries must have the same size as the current "
                 "observation.");
    stacked.insert(stacked.end(), history_entry.begin(), history_entry.end());
  }
 
  return stacked;
}

Referenced by LibtorchNeuralNetControl::prepareInputTensor().

◆ stackTrajectoryObservation()

std::vector< Real > LibtorchObservationHistoryHelper::stackTrajectoryObservation	(	const std::vector< std::vector< Real > > &	component_trajectories,
		unsigned int	time_index
	)		const

Flatten one time slice of observation-component trajectories with causal history.

This uses [component][time] because the trainer receives reporter data one observation component at a time, so keeping that layout avoids building an extra transposed [time][component] container before stacking.

Parameters

component_trajectories	Observation trajectories indexed as [component][time].
time_index	Time index to stack.

Definition at line 107 of file LibtorchObservationHistoryHelper.C.

{
  validateTrajectoryShape(component_trajectories);
 
  if (component_trajectories.empty())
    return {};
 
  const auto trajectory_size = component_trajectories.front().size();
  if (time_index >= trajectory_size)
    mooseError("Requested observation time index is out of range.");
 
  std::vector<Real> stacked;
  stacked.reserve(component_trajectories.size() * _input_timesteps);
 
  for (const auto lag : make_range(_input_timesteps))
  {
    const auto source_index = time_index > lag ? time_index - lag : 0;
    for (const auto component_i : make_range(component_trajectories.size()))
      stacked.push_back(component_trajectories[component_i][source_index]);
  }
 
  return stacked;
}

◆ validateTrajectoryShape()

void LibtorchObservationHistoryHelper::validateTrajectoryShape ( const std::vector< std::vector< Real > > & component_trajectories ) const

private

Check that all observation-component trajectories have a consistent shape.

Definition at line 28 of file LibtorchObservationHistoryHelper.C.

{
  if (component_trajectories.empty())
    return;
 
  const auto trajectory_size = component_trajectories.front().size();
  for (const auto & trajectory : component_trajectories)
    if (trajectory.size() != trajectory_size)
      mooseError("Observation trajectories must all have the same number of timesteps.");
}