SpectralExecutionerBase

Spectral executioners

In general, executioners determine the type of solve for finite element problems. In spectral solvers, the executioner is also responsible for actually** solving the system. SpectralExecutionerBase is an base class which holds a pointer to an FFTProblem and initializes an FEProblem.

The executioner has helper methods such as kVectorMultiply which may be called, e.g., to obtain spatial derivatives in the reciprocal space by child classes.

The spectral solve application developer will need to inherit from this class and provide appropriate explicit or implicit algorithm to obtain each step's solution.

::execute for computing spatial derivatives

The execute method is pure virtual and handles the numerical time stepping, the forward and inverse discrete Fourier transforms through FFTWBufferBase.

Input Parameters

time0System time
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:System time
verboseFalseSet to true to print additional information
Default:False
C++ Type:bool
Controllable:No
Description:Set to true to print additional information

Optional Parameters

accept_on_max_fixed_point_iterationFalseTrue to treat reaching the maximum number of fixed point iterations as converged.
Default:False
C++ Type:bool
Controllable:No
Description:True to treat reaching the maximum number of fixed point iterations as converged.
auto_advanceFalseWhether to automatically advance sub-applications regardless of whether their solve converges, for transient executioners only.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to automatically advance sub-applications regardless of whether their solve converges, for transient executioners only.
custom_abs_tol1e-50The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on postprocessor defined by the custom_pp residual.
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on postprocessor defined by the custom_pp residual.
custom_ppPostprocessor for custom fixed point convergence check.
C++ Type:PostprocessorName
Unit:(no unit assumed)
Controllable:No
Description:Postprocessor for custom fixed point convergence check.
custom_rel_tol1e-08The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the postprocessor defined by custom_pp residual.
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the postprocessor defined by custom_pp residual.
direct_pp_valueFalseTrue to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between fixed point iterations.
Default:False
C++ Type:bool
Controllable:No
Description:True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between fixed point iterations.
disable_fixed_point_residual_norm_checkFalseDisable the residual norm evaluation thus the three parameters fixed_point_rel_tol, fixed_point_abs_tol and fixed_point_force_norms.
Default:False
C++ Type:bool
Controllable:No
Description:Disable the residual norm evaluation thus the three parameters fixed_point_rel_tol, fixed_point_abs_tol and fixed_point_force_norms.
fixed_point_abs_tol1e-50The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
fixed_point_algorithmpicardThe fixed point algorithm to converge the sequence of problems.
Default:picard
C++ Type:MooseEnum
Options:picard, secant, steffensen
Controllable:No
Description:The fixed point algorithm to converge the sequence of problems.
fixed_point_force_normsFalseForce the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existence of active MultiApps with those execute_on flags, default: false.
Default:False
C++ Type:bool
Controllable:No
Description:Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existence of active MultiApps with those execute_on flags, default: false.
fixed_point_max_its1Specifies the maximum number of fixed point iterations.
Default:1
C++ Type:unsigned int
Controllable:No
Description:Specifies the maximum number of fixed point iterations.
fixed_point_min_its1Specifies the minimum number of fixed point iterations.
Default:1
C++ Type:unsigned int
Controllable:No
Description:Specifies the minimum number of fixed point iterations.
fixed_point_rel_tol1e-08The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
multiapp_fixed_point_convergenceName of the Convergence object to use to assess convergence of the MultiApp fixed point solve. If not provided, a default Convergence will be constructed internally from the executioner parameters.
C++ Type:ConvergenceName
Controllable:No
Description:Name of the Convergence object to use to assess convergence of the MultiApp fixed point solve. If not provided, a default Convergence will be constructed internally from the executioner parameters.
relaxation_factor1Fraction of newly computed value to keep.Set between 0 and 2.
Default:1
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Fraction of newly computed value to keep.Set between 0 and 2.
transformed_postprocessorsList of main app postprocessors to transform during fixed point iterations
C++ Type:std::vector<PostprocessorName>
Unit:(no unit assumed)
Controllable:No
Description:List of main app postprocessors to transform during fixed point iterations
transformed_variablesList of main app variables to transform during fixed point iterations
C++ Type:std::vector<std::string>
Controllable:No
Description:List of main app variables to transform during fixed point iterations

Fixed Point Iterations 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.
outputsVector of output names where you would like to restrict the output of variables(s) associated with this object
C++ Type:std::vector<OutputName>
Controllable:No
Description:Vector of output names where you would like to restrict the output of variables(s) associated with this object

Advanced Parameters

max_xfem_update4294967295Maximum number of times to update XFEM crack topology in a step due to evolving cracks
Default:4294967295
C++ Type:unsigned int
Controllable:No
Description:Maximum number of times to update XFEM crack topology in a step due to evolving cracks
update_xfem_at_timestep_beginFalseShould XFEM update the mesh at the beginning of the timestep
Default:False
C++ Type:bool
Controllable:No
Description:Should XFEM update the mesh at the beginning of the timestep

Xfem Fixed Point Iterations Parameters

Restart Parameters

Child Objects

(include/executioners/SpectralExecutionerLinearElastic.h)
(include/executioners/SpectralExecutionerDiffusion.h)
(test/include/executioners/TestSpectralExecutioner.h)

References

No citations exist within this document.

(include/executioners/SpectralExecutionerLinearElastic.h)

/**********************************************************************/
/*                     DO NOT MODIFY THIS HEADER                      */
/* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
/*                                                                    */
/*            Copyright 2017 Battelle Energy Alliance, LLC            */
/*                        ALL RIGHTS RESERVED                         */
/**********************************************************************/

#pragma once

#include "SpectralExecutionerBase.h"

// System includes
#include <string>

// Forward declarations
class InputParameters;

/**
 * Executioner for linear elastic deformation spectral solver.
 */
class SpectralExecutionerLinearElastic : public SpectralExecutionerBase
{
public:
  static InputParameters validParams();

  SpectralExecutionerLinearElastic(const InputParameters & parameters);
  /**
   * Algorithm for incremental solution using forward/backward transforms of Green's function.
   */
  virtual void execute() final;

protected:
  /// Time step
  const Real _dt;

  /// Number of steps
  const unsigned int _nsteps;

  /// Reference Young's modulus
  const Real _young_modulus;

  /// Poisson ratio
  const Real _poisson_ratio;

  /// Initial strain tensor
  RankTwoTensor _initial_strain_tensor;

  /// Average factor to obtain homogeneous material
  const Real _average_factor;

  /// User-prescribed error for fixed iteration solver
  const Real _solver_error;

  /// Current time
  Real _t_current;

private:
  /**
   * Helper function to get the linear elastic problem Green's function.
   * @param gamma_hat Linear elastic Green operator in Fourier space
   * @param elasticity_tensor Elasticity tensor used to replace Gamma for some frequencies
   */
  void getGreensFunction(FFTBufferBase<RankFourTensor> & gamma_hat,
                         const RankFourTensor & elasticity_tensor);

  /**
   * Compute initial stress based on homogeneous strain and space-varying elasticity tensor.
   * @param epsilon_buffer Small strain FFT buffer
   * @param elastic_buffer Space-varying elasticity tensor FFT buffer
   */
  FFTBufferBase<RankTwoTensor> &
  getInitialStress(FFTBufferBase<RankTwoTensor> & epsilon_buffer,
                   const FFTBufferBase<RankFourTensor> & elastic_buffer);
  /**
   * Initialize epsilon buffer with homogeneous/global strain.
   * @param epsilon_buffer Small strain FFT buffer
   */
  void fillOutEpsilonBuffer(FFTBufferBase<RankTwoTensor> & epsilon_buffer);

  /**
   * Initialize epsilon buffer with homogeneous/global strain.
   * @param epsilon_buffer Small strain FFT buffer
   */
  void advanceReciprocalEpsilon(FFTBufferBase<RankTwoTensor> & epsilon_buffer,
                                const FFTBufferBase<RankTwoTensor> & stress_buffer,
                                const FFTBufferBase<RankFourTensor> & gamma_hat);
  /**
   * Update real stress buffer for current iteration.
   * @param epsilon_buffer Small strain FFT buffer
   * @param stress_buffer Stress FFT buffer
   * @param elastic_tensor Small strain FFT buffer
   */
  void updateRealSigma(const FFTBufferBase<RankTwoTensor> & epsilon_buffer,
                       FFTBufferBase<RankTwoTensor> & stress_buffer,
                       const FFTBufferBase<RankFourTensor> & elastic_tensor);

  /**
   * Initialize space-varying elastic coefficient tensor.
   * @param ratio_buffer Initial condition ratio to distribute material's stiffnesses
   * @param index_buffer Real or integer buffer assigning index to each cell
   * @param elastic_tensor_buffer Space-varying elastic coefficient tensor
   */
  void filloutElasticTensor(const FFTBufferBase<Real> & ratio_buffer,
                            FFTBufferBase<Real> & index_buffer,
                            FFTBufferBase<RankFourTensor> & elastic_tensor_buffer);
  /**
   * Convergence check base on global equilibrium.
   * @param stress Stress tensor for convergence check
   */
  bool hasStressConverged(const FFTBufferBase<RankTwoTensor> & stress);
};

(include/executioners/SpectralExecutionerDiffusion.h)

/**********************************************************************/
/*                     DO NOT MODIFY THIS HEADER                      */
/* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
/*                                                                    */
/*            Copyright 2017 Battelle Energy Alliance, LLC            */
/*                        ALL RIGHTS RESERVED                         */
/**********************************************************************/

#pragma once

#include "SpectralExecutionerBase.h"

// System includes
#include <string>

// Forward declarations
class InputParameters;

/**
 * Executioner for diffusion spectral solver.
 */
class SpectralExecutionerDiffusion : public SpectralExecutionerBase
{
public:
  static InputParameters validParams();

  SpectralExecutionerDiffusion(const InputParameters & parameters);
  /**
   * Algorithm for incremental solution using forward/backward transforms of Green's function.
   */
  virtual void execute() final;
  /**
   * Algorithm for explicit diffusion solve through finite differences.
   */
  virtual void executeExplicit();
  /**
   * Algorithm for non-incremental numerical integration.
   */
  virtual void executeTotalDiffusion();

protected:
  /// Generic diffusion coefficient
  const Real _diff_coeff;

  /// Time step
  const Real _dt;

  /// Number of steps
  const unsigned int _nsteps;

  /// Current time
  Real _t_current;

private:
  /**
   * Helper function to advance diffusion step in an explicit finite difference sense.
   */
  void advanceDiffusionStep(FFTBufferBase<Real> & inOut, const Real diff_coeff);
  /**
   * Helper function to advance diffusion step in a total fashion --no increments.
   */
  void advanceDiffusionStepTotal(const FFTBufferBase<Real> & in,
                                 FFTBufferBase<Real> & out,
                                 const Real D,
                                 const Real time);
  /**
   * Helper function to get the diffusion equation Green's function corresponding to one time step.
   */
  void getGreensFunction(FFTBufferBase<Real> & greens, Real time, const Real D);
  /**
   * Helper function to multiply a buffer by a real number.
   */
  void scalarMultiplyBuffer(FFTBufferBase<Real> & u, const FFTBufferBase<Real> & greens);
};

(test/include/executioners/TestSpectralExecutioner.h)

/**********************************************************************/
/*                     DO NOT MODIFY THIS HEADER                      */
/* MAGPIE - Mesoscale Atomistic Glue Program for Integrated Execution */
/*                                                                    */
/*            Copyright 2017 Battelle Energy Alliance, LLC            */
/*                        ALL RIGHTS RESERVED                         */
/**********************************************************************/

#ifndef TESTSPECTRALEXECUTIONER_H
#define TESTSPECTRALEXECUTIONER_H

#include "SpectralExecutionerBase.h"
#include "FFTWBufferBase.h"
#include "FFTProblem.h"

// System includes
#include <string>

// Forward declarations
class InputParameters;

/**
 * FFT Executioner base class.
 */
class TestSpectralExecutioner : public SpectralExecutionerBase
{
public:
  static InputParameters validParams();

  TestSpectralExecutioner(const InputParameters & parameters);
  virtual void execute() override;

};


#endif

Spectral executioners
:: execute for computing spatial derivatives
Input Parameters
Child Objects
References