PlainTensorBuffer

Generic TensorBuffer object.

A PlainTensorBuffer holds a plain vanilla torch::Tensor and is interpreted as a buffer of scalar values.

Overview

Generic N-dimensional tensor buffer for scalar, vector, or user-defined data not tied to an LBM stencil. Optional "map_to_aux_variable" enables fast projection onto a matching mesh variable.

Example Input File Syntax

[TensorBuffers<<<{"href": "../../syntax/TensorBuffers/index.html"}>>>]
  [grad_sq]
  []
[]

Input Parameters

map_from_aux_variableSync the given AuxVariable to the buffer contents
C++ Type:std::vector<AuxVariableName>
Unit:(no unit assumed)
Controllable:No
Description:Sync the given AuxVariable to the buffer contents
map_to_aux_variableSync the given AuxVariable to the buffer contents
C++ Type:std::vector<AuxVariableName>
Unit:(no unit assumed)
Controllable:No
Description:Sync the given AuxVariable to the buffer contents
reciprocalFalseIs this a reciprocal space tensor?
Default:False
C++ Type:bool
Controllable:No
Description:Is this a reciprocal space tensor?
value_dimensionsOptional value dimensions
C++ Type:std::vector<long>
Controllable:No
Description:Optional value dimensions

Optional Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

Child Objects

(include/tensor_buffers/LBMTensorBuffer.h)

(test/tests/gradient/gradient_square.i)

[Domain]
  dim = 3
  nx = 40
  ny = 40
  nz = 40
  xmax = ${fparse pi*2}
  ymax = ${fparse pi*4}
  zmax = ${fparse pi*6}
  mesh_mode = DUMMY
  device_names = cpu
[]

[TensorBuffers]
  [s]
  []
  [grad_sq]
  []
  [c2]
  []
  [diff]
  []
[]

[TensorComputes]
  [Initialize]
    [sin]
      type = ParsedCompute
      buffer = s
      extra_symbols = true
      expression = 'sin(x)+sin(y)+sin(z)'
    []
    [cos2]
      type = ParsedCompute
      buffer = c2
      extra_symbols = true
      expression = 'cos(x)^2+cos(y)^2+cos(z)^2'
    []
    [grad_sq]
      type = FFTGradientSquare
      buffer = grad_sq
      input = s
    []
    [diff]
      type = ParsedCompute
      buffer = diff
      inputs = 'grad_sq c2'
      expression = 'abs(grad_sq - c2)'
    []
  []
[]

[Postprocessors]
  [diff]
    type = TensorIntegralPostprocessor
    buffer = diff
  []
[]

[Problem]
  type = TensorProblem
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  csv = true
[]

(test/tests/real_space/laplacian.i)

[Domain]
  dim = 2
  nx = 80
  ny = 60
  parallel_mode = REAL_SPACE
  periodic_directions = 'X Y'
  xmin = -1
  ymin = -1
  xmax = 1
  ymax = 1
[]

[TensorBuffers]
  [u]
    type = PlainTensorBuffer
  []
  [u_gold]
    type = PlainTensorBuffer
  []
  [lap]
    type = PlainTensorBuffer
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = ParsedCompute
      buffer = u
      expression = 'sin(pi*(x+0.5))*sin(pi*(y+0.5))'
      extra_symbols = true
    []
    [lap_gold_ic]
      type = ParsedCompute
      buffer = lap_gold
      #expression = '0'
      expression = '-2*pi*pi*sin(pi*(x+0.5))*sin(pi*(y+0.5))'
      extra_symbols = true
      expand = REAL
    []
  []
  [Solve]
    [lap_compute]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = lap
    []
    [diff]
      type = ParsedCompute
      buffer = diff
      expression = 'abs(lap - lap_gold)'
      inputs = 'lap lap_gold'
    []
  []
[]

[Postprocessors]
  [max_error]
    type = TensorExtremeValuePostprocessor
    buffer = diff
    value_type = MAX
  []
[]

[TensorOutputs]
  active = ''
  [lap]
    type = XDMFTensorOutput
    buffer = 'lap lap_gold diff'
    enable_hdf5 = true
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(test/tests/real_space/laplacian3d.i)

[Domain]
  dim = 3
  nx = 30
  ny = 24
  nz = 17
  parallel_mode = REAL_SPACE
  periodic_directions = 'X Y Z'
  xmin = -1
  ymin = -1
  zmin = -1
  xmax = 1
  ymax = 1
  zmax = 1
[]

[TensorBuffers]
  [u]
    type = PlainTensorBuffer
  []
  [u_gold]
    type = PlainTensorBuffer
  []
  [lap]
    type = PlainTensorBuffer
  []
[]

[TensorComputes]
  [Initialize]
    [u_ic]
      type = ParsedCompute
      buffer = u
      expression = 'sin(pi*(x+0.5))*sin(pi*(y+0.5))*sin(pi*(z+0.5))'
      extra_symbols = true
    []
    [lap_gold_ic]
      type = ParsedCompute
      buffer = lap_gold
      #expression = '0'
      expression = '-3*pi*pi*sin(pi*(x+0.5))*sin(pi*(y+0.5))*sin(pi*(z+0.5))'
      extra_symbols = true
      expand = REAL
    []
  []
  [Solve]
    [lap_compute]
      type = FiniteDifferenceLaplacian
      input = u
      buffer = lap
    []
    [diff]
      type = ParsedCompute
      buffer = diff
      expression = 'abs(lap - lap_gold)'
      inputs = 'lap lap_gold'
    []
  []
[]

[Postprocessors]
  [max_error]
    type = TensorExtremeValuePostprocessor
    buffer = diff
    value_type = MAX
  []
[]

[TensorOutputs]
  # active = ''
  [lap]
    type = XDMFTensorOutput
    buffer = 'lap lap_gold diff'
    enable_hdf5 = true
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Outputs]
  [out]
    type = CSV
  []
[]

(include/tensor_buffers/LBMTensorBuffer.h)

/**********************************************************************/
/*                     DO NOT MODIFY THIS HEADER                      */
/*            Marlin, a Fourier spectral solver for MOOSE             */
/*                                                                    */
/*            Copyright 2024 Battelle Energy Alliance, LLC            */
/*                        ALL RIGHTS RESERVED                         */
/**********************************************************************/

#pragma once

#include "PlainTensorBuffer.h"

class LatticeBoltzmannStencilBase;
class LatticeBoltzmannProblem;

/**
 * Tensor wrapper for LBM tensors
 */
class LBMTensorBuffer : public PlainTensorBuffer
{
public:
  static InputParameters validParams();

  LBMTensorBuffer(const InputParameters & parameters);

  void init() override;

  void readTensorFromFile(const std::vector<int64_t> &);
  void readTensorFromHdf5();

protected:
  const std::string _buffer_type;
  LatticeBoltzmannProblem & _lb_problem;
  const LatticeBoltzmannStencilBase & _stencil;
};

Overview
Example Input File Syntax
Input Parameters
Input Files
Child Objects