MOOSE Newsletter November 2018

MOOSE Development Workflow

We have slightly modified the way MOOSE changes are submitted+merged on GitHub. In general, nothing should change from the workflow you are use to. From now on, all pull requests will be into the "next" branch instead of "devel". We've changed the default github branch for MOOSE to be "next" - so it will be automatically selected when you create new pull requests. The "devel" branch still exists and has the exact meaning as before, and you should still branch from "devel" when working on changes to MOOSE.

Automatic Differentiation

Making use of the MetaPhysicL package, MOOSE now has forward mode automatic differentiation (AD) capabilities. Where this capability is perhaps most useful is in Jacobian computation, as demonstrated in classes inherited from ADKernel. These derivative classes only have to override the computeQpResidual method; the Jacobian is computed automatically by carrying derivatives through the residual computation. The ADKernel and ADMaterial classes have been designed such that derivative computation is only conducted during the Jacobian computation phase; while computing the residual, derivative computations are not carried out, saving substantial expense.

More documentation will be added as AD percolates through the framework (e.g. addition of ADInterfaceKernel, ADDGKernel, ADIntegratedBC, ADNodalBC). For now the best documentation is the existing tests. Some example input files include: (test/tests/materials/ad_material/ad_material.i), (test/tests/kernels/ad_coupled_convection/ad_coupled_convection.i), and (test/tests/kernels/ad_simple_diffusion/ad_simple_diffusion.i). For examples of writing ADKernels, see (test/include/kernels/ADCoupledConvection.h), (test/include/kernels/ADMatDiffusionTest.h) headers and (test/src/kernels/ADCoupledConvection.C), (test/src/kernels/ADMatDiffusionTest.C) source files. An example of an ADMaterial can be found in (test/include/materials/ADCoupledMaterial.h), (test/src/materials/ADCoupledMaterial.C).

Moving forward, the idea is for application developers to be able to develop entire apps without writing a single Jacobian statement, having confidence that the automatically computed Jacobians are accurate. This has the potential to decrease application development time by order(s) of magnitude. In terms of computing performance, note that presently AD Jacobians are indeed slower to compute than hand-coded Jacobians, but they parallelize extremely well.

Relationship Manager System Evolution

In October, the Relationship Manager system gained several new capabilities

Grain Tracker Enhancements

The GrainTracker continues to be improved upon, with robustness enhancements and new functionality in several areas. The GrainTracker has been updated to utilize the latest improvements added to the Relationship Manager system. The GrainTracker now creates separate Geometric and Algebraic Relationship Managers to ensure the proper amount of solution information is necessary in distributed simulations for stitching together separate grain regions.

Other Grain Tracker enhancements added in October:

The GrainTracker has been enhanced to support "melt pool" simulations where the simulation may begin with zero grains. Previously the GrainTracker only supported simulations that began with a non-zero number of grains.
The GrainTracker no longer uses a recursive discovery method for identifying individual grain regions on each processor. Modern Linux and Mac operating system default to fairly small stack sizes (only a few Megabytes). If the GrainTracker is used on finer meshes or with larger grains, it was possible to run out of stack space creating a difficult to understand segmentation fault. Rather than require users to adjust stack spaces to use this common capability, the recursive algorithm was simply replaced with an iterative one, which allows for much larger recursive exploration of features.
Handles degenerative bounding boxes (e.g. 2D bounding boxes in 3D) for more robust fast intersection checking.
Additional algorithmic checks for difficult tracking cases involving nucleation and evolution in close proximity (e.g. more tracking robustness).

Vector Initial Conditions

Initial conditions can now be supplied for vector variables. Currently, only VectorConstantIC exists (see (framework/include/ics/VectorConstantIC.h), (framework/src/ics/VectorConstantIC.C), (test/tests/ics/vector_constant_ic/vector_constant_ic.i)), but more can be easily added by overriding the value method.

Action Refactor

The MaterialOutputAction object and related objects were refactored and made simplier. Previously these tasks were designed as meta-actions. However, it was discovered that these Actions could be simplified by being converted into normal MooseObjectActions (more direct).

New Enhancements

Enable Mac OS 10.14 (Mojave) support and debugging through code signing (entitlements)
CSVDiffer.py (CSVDiff Tester) can now compare a subset of columns (more enhancements coming)
Migrate to the improved RandomIC in all tests (remove all deprecated tests from the framework and modules)
Don't update the "failed tests" list when running only failed tests (–failed-tests).

Bug Fixes

Avoid unnecessary data structure copies (multiple) in SystemBase
Explicitly set the current subdomain in ElementalVariableValue postprocessor (avoid assertion)
Avoid duplicate runs of mesh adaptivity and mesh modifiers when running MOOSE using a pre-split mesh fixes (https://github.com/idaholab/moose/issues/12084 and https://github.com/idaholab/moose/issues/12304)

(test/tests/materials/ad_material/ad_material.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 4
  ny = 4
[]

[Variables]
  [./u]
    initial_condition = 1
  [../]
[]

[Kernels]
  [./diff]
    type = ADMatDiffusionTest
    variable = u
    prop_to_use = 'AdAd'
    ad_mat_prop = ad_diffusivity
    regular_mat_prop = regular_diffusivity
  [../]
[]

[BCs]
  [./left]
    type = DirichletBC
    variable = u
    preset = false
    boundary = left
    value = 0
  [../]
  [./right]
    type = DirichletBC
    variable = u
    preset = false
    boundary = right
    value = 1
  [../]
[]

[Materials]
  [./ad_coupled_mat]
    type = ADCoupledMaterial
    coupled_var = u
    ad_mat_prop = ad_diffusivity
    regular_mat_prop = regular_diffusivity
  [../]
[]

[Executioner]
  type = Steady

  solve_type = 'Newton'

  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'

  l_tol = 1e-10
  nl_rel_tol = 1e-9
[]

[Outputs]
  exodus = true
[]

(test/tests/kernels/ad_coupled_convection/ad_coupled_convection.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 4
  ny = 4
[]

[Variables]
  [./u]
  [../]
  [./v]
  [../]
[]

[Kernels]
  [./diff]
    type = ADDiffusion
    variable = u
  [../]
  [./convection]
    type = ADCoupledConvection
    variable = u
    velocity_vector = v
  [../]
  [./diff_v]
    type = ADDiffusion
    variable = v
  [../]
[]

[BCs]
  [./left]
    type = DirichletBC
    variable = u
    boundary = left
    value = 0
  [../]
  [./right]
    type = DirichletBC
    variable = u
    boundary = right
    value = 1
  [../]
  [./left_v]
    type = DirichletBC
    variable = v
    boundary = left
    value = 0
  [../]
  [./right_v]
    type = DirichletBC
    variable = v
    boundary = right
    value = 1
  [../]
[]

[Preconditioning]
  [./smp]
    type = SMP
    full = true
  [../]
[]

[Executioner]
  type = Steady

  solve_type = 'Newton'

  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'

  l_tol = 1e-10
  nl_rel_tol = 1e-9
  nl_max_its = 2
[]

[Outputs]
  exodus = true
[]

(test/tests/kernels/ad_simple_diffusion/ad_simple_diffusion.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 10
  ny = 10
[]

[Variables]
  [./u]
  [../]
[]

[Kernels]
  [./diff]
    type = ADDiffusion
    variable = u
  [../]
[]

[BCs]
  [./left]
    type = DirichletBC
    variable = u
    boundary = left
    value = 0
  [../]
  [./right]
    type = DirichletBC
    variable = u
    boundary = right
    value = 1
  [../]
[]

[Preconditioning]
  [./smp]
    type = SMP
    full = true
  [../]
[]

[Executioner]
  type = Steady

  # Preconditioned JFNK (default)
  solve_type = 'Newton'


  petsc_options_iname = '-pc_type -pc_hypre_type'
  petsc_options_value = 'hypre boomeramg'

  l_tol = 1e-10
  nl_rel_tol = 1e-9
  nl_max_its = 1
[]

[Outputs]
  exodus = true
[]

(test/include/kernels/ADCoupledConvection.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "ADKernel.h"

/**
 * Define the ADKernel for a convection operator that looks like:
 *
 * grad_some_var dot u'
 */
class ADCoupledConvection : public ADKernel
{
public:
  static InputParameters validParams();

  ADCoupledConvection(const InputParameters & parameters);

protected:
  virtual ADReal computeQpResidual() override;

private:
  const ADVariableGradient & _velocity_vector;

  const Real & _scale;
};

(test/include/kernels/ADMatDiffusionTest.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "ADKernel.h"
#include "MaterialProperty.h"

class ADMatDiffusionTest : public ADKernel
{
public:
  static InputParameters validParams();

  ADMatDiffusionTest(const InputParameters & parameters);

protected:
  virtual ADReal computeQpResidual();

  const ADMaterialProperty<Real> & _ad_diff_from_ad_prop;
  const MaterialProperty<Real> & _regular_diff_from_regular_prop;
  const MooseEnum _prop_to_use;
};

(test/src/kernels/ADCoupledConvection.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ADCoupledConvection.h"

registerMooseObject("MooseTestApp", ADCoupledConvection);

InputParameters
ADCoupledConvection::validParams()
{
  InputParameters params = ADKernel::validParams();
  params.addParam<Real>("scale", 1, "Scaling coefficient");
  params.addRequiredCoupledVar("velocity_vector", "Velocity Vector for the Convection ADKernel");
  return params;
}

ADCoupledConvection::ADCoupledConvection(const InputParameters & parameters)
  : ADKernel(parameters),
    _velocity_vector(adCoupledGradient("velocity_vector")),
    _scale(getParam<Real>("scale"))
{
}

ADReal
ADCoupledConvection::computeQpResidual()
{
  return _scale * _test[_i][_qp] * _velocity_vector[_qp] * _grad_u[_qp];
}

(test/src/kernels/ADMatDiffusionTest.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ADMatDiffusionTest.h"

registerMooseObject("MooseTestApp", ADMatDiffusionTest);

InputParameters
ADMatDiffusionTest::validParams()
{
  InputParameters params = ADKernel::validParams();
  params.addParam<MaterialPropertyName>(
      "ad_mat_prop", "ad_diffusivity", "the name of the AD material property we are going to use");
  params.addParam<MaterialPropertyName>("regular_mat_prop",
                                        "regular_diffusivity",
                                        "the name of the AD material property we are going to use");
  MooseEnum prop_to_use("AdAd  RegReg", "AdAd");
  params.addParam<MooseEnum>("prop_to_use",
                             prop_to_use,
                             "What type of property to use. The prefix indicates the getter type "
                             "in the kernel; the suffix indicates the declaration type in the "
                             "material.");
  return params;
}

ADMatDiffusionTest::ADMatDiffusionTest(const InputParameters & parameters)
  : ADKernel(parameters),
    _ad_diff_from_ad_prop(getADMaterialProperty<Real>("ad_mat_prop")),
    _regular_diff_from_regular_prop(getMaterialProperty<Real>("regular_mat_prop")),
    _prop_to_use(getParam<MooseEnum>("prop_to_use"))
{
  // check whether our has APIs work

  if (!hasADMaterialProperty<Real>("ad_mat_prop") &&
      !defaultADMaterialProperty<Real>(deducePropertyName("ad_mat_prop")))
    mooseError("It should be impossible to get an AD property without erroring and simultaneously "
               "be neither able to retrieve the property with 'hasADMaterialProperty' nor through "
               "a default property");
  if (!hasMaterialProperty<Real>("regular_mat_prop") &&
      !defaultMaterialProperty<Real>(deducePropertyName("regular_mat_prop")))
    mooseError(
        "It should be impossible to get a regular property without erroring and simultaneously "
        "be neither able to retrieve the property with 'hasMaterialProperty' nor through "
        "a default property");
}

ADReal
ADMatDiffusionTest::computeQpResidual()
{
  if (_prop_to_use == "AdAd")
    return _ad_diff_from_ad_prop[_qp] * _grad_test[_i][_qp] * _grad_u[_qp];
  else if (_prop_to_use == "RegReg")
    return _regular_diff_from_regular_prop[_qp] * _grad_test[_i][_qp] * _grad_u[_qp];
  else
    mooseError("Oops");
}

(test/include/materials/ADCoupledMaterial.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "Material.h"

/**
 * A material that couples a material property
 */
class ADCoupledMaterial : public Material
{
public:
  static InputParameters validParams();

  ADCoupledMaterial(const InputParameters & parameters);

protected:
  virtual void computeQpProperties();

  ADMaterialProperty<Real> & _ad_mat_prop;
  MaterialProperty<Real> & _regular_mat_prop;

  const ADVariableValue & _coupled_var;
};

(test/src/materials/ADCoupledMaterial.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "ADCoupledMaterial.h"

registerMooseObject("MooseTestApp", ADCoupledMaterial);

InputParameters
ADCoupledMaterial::validParams()
{
  InputParameters params = Material::validParams();
  params.addRequiredCoupledVar("coupled_var", "A coupledvariable");
  params.addRequiredParam<MaterialPropertyName>("ad_mat_prop",
                                                "Name of the ad property this material defines");
  params.addRequiredParam<MaterialPropertyName>(
      "regular_mat_prop", "Name of the regular property this material defines");
  return params;
}

ADCoupledMaterial::ADCoupledMaterial(const InputParameters & parameters)
  : Material(parameters),
    _ad_mat_prop(declareADProperty<Real>(getParam<MaterialPropertyName>("ad_mat_prop"))),
    _regular_mat_prop(declareProperty<Real>(getParam<MaterialPropertyName>("regular_mat_prop"))),
    _coupled_var(adCoupledValue("coupled_var"))
{
}

// Note that the structure of the two (uncommented) methods below are for testing purposes only;
// e.g. this material demonstrates that you get bad convergence when you drop the derivative
// information from the coupled variable. A production version of this material would look like
// this:
//
// // void
// ADCoupledMaterial::computeQpProperties()
// {
//   _ad_mat_prop[_qp] = 4.0 * _coupled_var[_qp];
// }

void
ADCoupledMaterial::computeQpProperties()
{
  _regular_mat_prop[_qp] = 4.0 * MetaPhysicL::raw_value(_coupled_var[_qp]);
  _ad_mat_prop[_qp] = 4.0 * _coupled_var[_qp];
}

(framework/include/ics/VectorConstantIC.h)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "VectorInitialCondition.h"

// System includes
#include <string>

class InputParameters;

namespace libMesh
{
class Point;
}

/**
 * VectorConstantIC just returns a constant value.
 */
class VectorConstantIC : public VectorInitialCondition
{
public:
  static InputParameters validParams();

  VectorConstantIC(const InputParameters & parameters);

  virtual RealVectorValue value(const Point & p) override;

protected:
  const Real _x_value;
  const Real _y_value;
  const Real _z_value;
};

(framework/src/ics/VectorConstantIC.C)

// This file is part of the MOOSE framework
// https://www.mooseframework.org
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#include "VectorConstantIC.h"
#include "libmesh/point.h"

registerMooseObject("MooseApp", VectorConstantIC);

InputParameters
VectorConstantIC::validParams()
{
  InputParameters params = VectorInitialCondition::validParams();
  params.addRequiredParam<Real>("x_value", "The x value to be set in IC");
  params.addParam<Real>("y_value", 0, "The y value to be set in IC");
  params.addParam<Real>("z_value", 0, "The z value to be set in IC");

  params.addClassDescription("Sets constant component values for a vector field variable.");
  return params;
}

VectorConstantIC::VectorConstantIC(const InputParameters & parameters)
  : VectorInitialCondition(parameters),
    _x_value(getParam<Real>("x_value")),
    _y_value(getParam<Real>("y_value")),
    _z_value(getParam<Real>("z_value"))
{
}

RealVectorValue
VectorConstantIC::value(const Point & /*p*/)
{
  return {_x_value, _y_value, _z_value};
}

(test/tests/ics/vector_constant_ic/vector_constant_ic.i)

[Mesh]
  type = GeneratedMesh
  dim = 3
  nx = 2
  ny = 2
  nz = 2
[]

[Problem]
  solve = false
  kernel_coverage_check = false
[]

[Variables]
  [./A]
    family = LAGRANGE_VEC
    order = FIRST
  [../]
[]

[ICs]
  [./A]
    type = VectorConstantIC
    variable = A
    x_value = 2
    y_value = 3
    z_value = 4
  [../]
[]

[Executioner]
  type = Steady
  solve_type = 'NEWTON'
[]

[Outputs]
  exodus = true
[]

MOOSE Development Workflow
Automatic Differentiation
Relationship Manager System Evolution
Grain Tracker Enhancements
Vector Initial Conditions
Action Refactor
New Enhancements
Bug Fixes

Install MOOSE

New Users

Examples and Tutorials

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools

INL Applications and Remote Access

MOOSE Development Workflow

Automatic Differentiation

Relationship Manager System Evolution

Grain Tracker Enhancements

Vector Initial Conditions

Action Refactor

New Enhancements

Bug Fixes

MOOSE Newsletter (November 2018)

MOOSE Development Workflow

Automatic Differentiation

Relationship Manager System Evolution

Grain Tracker Enhancements

Vector Initial Conditions

Action Refactor

New Enhancements

Bug Fixes

(test/tests/materials/ad_material/ad_material.i)

(test/tests/kernels/ad_coupled_convection/ad_coupled_convection.i)

(test/tests/kernels/ad_simple_diffusion/ad_simple_diffusion.i)

(test/include/kernels/ADCoupledConvection.h)

(test/include/kernels/ADMatDiffusionTest.h)

(test/src/kernels/ADCoupledConvection.C)

(test/src/kernels/ADMatDiffusionTest.C)

(test/include/materials/ADCoupledMaterial.h)

(test/src/materials/ADCoupledMaterial.C)

(framework/include/ics/VectorConstantIC.h)

(framework/src/ics/VectorConstantIC.C)

(test/tests/ics/vector_constant_ic/vector_constant_ic.i)