Merge pull request #73 from Argonne-National-Laboratory/moose_fixes

Moose fixes

.github/workflows/test.yml

@@ -1,55 +1,46 @@
-name: tests
+name: run-deer-tests
 
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-  # We don't update deer all that often, but it is still of interest to know ASAP if a MOOSE update has broken deer
-  schedule:
-    - cron: '0 0 * * *'
-
-  # Allows you to run this workflow manually from the Actions tab
-  workflow_dispatch:
+on: [push, pull_request]
 
 jobs:
-      tests-linux:
-            runs-on: ubuntu-latest
-            strategy:
-                  matrix:
-                        btype: [opt, dbg]
-            steps:
-            - uses: actions/checkout@v2
-              with:
-                    submodules: recursive
-            - name: Setup build system
-              run: | 
-                  sudo apt update 
-                  sudo apt install build-essential cmake libblas-dev liblapack-dev mpich libmpich-dev python3-dev
-            - name: Compile neml
-              run: |
-                  cd neml
-                  if [[ "${{ matrix.btype }}" == "opt" ]]; then type="Release"; elif [[ "${{ matrix.btype }}" == "dbg" ]]; then type="Debug"; fi
-                  cmake -DCMAKE_BUILD_TYPE=$type .
-                  make -j 2
-            - name: Compile extra MOOSE packages
-              env:
-                    MOOSE_DIR: ${{github.workspace}}/moose
-              run:  |
-                  git clone https://github.com/idaholab/moose.git $MOOSE_DIR
-                  cd $MOOSE_DIR/scripts
-                  export MOOSE_JOBS=2
-                  ./update_and_rebuild_petsc.sh
-                  ./update_and_rebuild_libmesh.sh
-            - name: Compile code
-              env:
-                    MOOSE_DIR: ${{github.workspace}}/moose
-              run: |
-                    export MOOSE_DIR=$PWD/moose
-                    make -j 2 METHOD=${{ matrix.btype }}
-            - name: Test code
-              env:
-                    MOOSE_DIR: ${{github.workspace}}/moose
-                    LD_LIBRARY_PATH: $LD_LIBRARY_PATH:${{github.workspace}}/neml/lib
-              run: if [[ "${{ matrix.btype }}" == "opt" ]]; then ./run_tests --opt; elif [[ "${{ matrix.btype }}" == "dbg" ]]; then ./run_tests --dbg; fi
+  tests-linux:
+    name: Run tests on linux
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        btype: [opt, dbg]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Setup build system
+        run: | 
+          sudo apt update 
+          sudo apt install build-essential cmake libblas-dev liblapack-dev mpich libmpich-dev python3-dev
+      - name: Compile neml
+        run: |
+          cd neml
+          if [[ "${{ matrix.btype }}" == "opt" ]]; then type="Release"; elif [[ "${{ matrix.btype }}" == "dbg" ]]; then type="Debug"; fi
+          cmake -DCMAKE_BUILD_TYPE=$type -DUSE_OPENMP=OFF .
+          make -j 2
+      - name: Compile extra MOOSE packages
+        env:
+          MOOSE_DIR: ${{github.workspace}}/moose
+        run:  |
+          git clone https://github.com/idaholab/moose.git $MOOSE_DIR
+          cd $MOOSE_DIR/scripts
+          export MOOSE_JOBS=2
+          ./update_and_rebuild_petsc.sh
+          METHOD=${{matrix.btype}} ./update_and_rebuild_libmesh.sh
+          ./update_and_rebuild_wasp.sh
+      - name: Compile code
+        env:
+          MOOSE_DIR: ${{github.workspace}}/moose
+        run: |
+          export MOOSE_DIR=$PWD/moose
+          make -j 2 METHOD=${{ matrix.btype }}
+      - name: Test code
+        env:
+          MOOSE_DIR: ${{github.workspace}}/moose
+          LD_LIBRARY_PATH: $LD_LIBRARY_PATH:${{github.workspace}}/neml/lib
+        run: if [[ "${{ matrix.btype }}" == "opt" ]]; then ./run_tests --opt; elif [[ "${{ matrix.btype }}" == "dbg" ]]; then ./run_tests --dbg; fi

.gitignore

@@ -19,3 +19,4 @@ build
 *.csv
 *.previous_test_results.json
 *~
+*.yaml

Makefile

@@ -29,7 +29,7 @@ ALL_MODULES         := no
 CHEMICAL_REACTIONS  := no
 CONTACT             := yes
 FLUID_PROPERTIES    := no
-HEAT_CONDUCTION     := yes
+HEAT_TRANSFER       := yes
 MISC                := no
 NAVIER_STOKES       := no
 PHASE_FIELD         := no

include/postprocessors/CZMAreaRatioPostprocessor.h

@@ -23,6 +23,5 @@ class CZMAreaRatioPostprocessor : public CZMAreaPostprocessor
 
   CZMAreaRatioPostprocessor(const InputParameters & parameters);
 
-protected:
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const override;
 };

include/postprocessors/CZMStrainComponent.h

@@ -26,7 +26,8 @@ class CZMStrainComponent : public CZMAreaRatioPostprocessor
 
   virtual void initialize() override;
   virtual void execute() override;
-  virtual Real getValue() override;
+  virtual void finalize() override;
+  virtual PostprocessorValue getValue() const override;
   virtual void threadJoin(const UserObject & y) override;
 
 protected:

include/postprocessors/ElementExtremeVectorMaterialProperty.h

@@ -17,8 +17,9 @@ class ElementExtremeVectorMaterialProperty : public ElementPostprocessor
 
   virtual void initialize() override;
   virtual void execute() override;
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const;
   virtual void threadJoin(const UserObject & y) override;
+  virtual void finalize() override;
 
 protected:
   virtual void computeQpValue();
@@ -27,6 +28,6 @@ class ElementExtremeVectorMaterialProperty : public ElementPostprocessor
   unsigned int _index;
 
   ExtremeType _type;
-  Real _value;
+  PostprocessorValue _value;
   unsigned int _qp;
 };

include/postprocessors/MaterialTensorIntegralInterfaceScaled.h

@@ -24,7 +24,7 @@ class MaterialTensorIntegralInterfaceScaledTempl : public InterfaceIntegralPostp
   static InputParameters validParams();
 
   MaterialTensorIntegralInterfaceScaledTempl(const InputParameters & parameters);
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const;
 
 protected:
   virtual Real computeQpIntegral();

include/postprocessors/MaterialTensorIntegralScaled.h

@@ -22,7 +22,7 @@ class MaterialTensorIntegralScaledTempl : public MaterialTensorIntegralTempl<is_
   static InputParameters validParams();
 
   MaterialTensorIntegralScaledTempl(const InputParameters & parameters);
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const override;
 
 protected:
   const PostprocessorValue & _scaling_factor_PP;

include/postprocessors/MultiplyPostprocessor.h

@@ -25,7 +25,7 @@ class MultiplyPostprocessor : public GeneralPostprocessor
 
   virtual void initialize() override;
   virtual void execute() override;
-  virtual PostprocessorValue getValue() override;
+  virtual PostprocessorValue getValue() const;
 
 protected:
   const PostprocessorValue & _value1;

include/postprocessors/RankTwoTensorInvariantPostprocessor.h

@@ -29,7 +29,7 @@ class RankTwoTensorInvariantPostprocessor : public GeneralPostprocessor
   /// we don't need to override finalize because we are working with
   /// postprocessors values. Therefore the values this PP will get, have already
   /// be summed/averaged among processes/threads.
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const;
 
 protected:
   const PostprocessorName _rank_two_tensor_base_name;
@@ -44,7 +44,7 @@ class RankTwoTensorInvariantPostprocessor : public GeneralPostprocessor
   std::vector<std::vector<const PostprocessorValue *>> _pps_values;
 
   /// the calculated invariant value to be returned
-  Real _invariant;
+  PostprocessorValue _invariant;
 
   /// the map between postprocessor names and tensorial components
   const std::map<std::pair<int, int>, std::string> tensor_map = {{std::make_pair(0, 0), "xx"},

include/postprocessors/SideExtremePostprocessor.h

@@ -17,12 +17,13 @@ class SideExtremePostprocessor : public SidePostprocessor
 
   virtual void initialize() override;
   virtual void execute() override;
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const;
   virtual void threadJoin(const UserObject & y) override;
+  virtual void finalize() override;
 
 protected:
   unsigned int _qp;
-  Real _curr_value;
+  PostprocessorValue _curr_value;
   const VariableValue & _u;
   const ExtremeType _type;
 };

include/postprocessors/TimeDerivativePostprocessor.h

@@ -26,11 +26,11 @@ class TimeDerivativePostprocessor : public GeneralPostprocessor
 
   virtual void initialize() override;
   virtual void execute() override;
-  virtual Real getValue() override;
+  virtual PostprocessorValue getValue() const;
 
 protected:
   /// cumulative sum of the post-processor value
-  Real _rate;
+  PostprocessorValue _rate;
 
   /// current post-processor value
   const PostprocessorValue & _pps_value;

src/actions/CZMStrainAction.C

@@ -34,9 +34,10 @@ CZMStrainAction::validParams()
 
 CZMStrainAction::CZMStrainAction(const InputParameters & params)
   : Action(params),
-    _block(getParam<std::vector<SubdomainName>>("block")),
-    _boundary(getParam<std::vector<BoundaryName>>("boundary")),
-
+    _block(params.isParamValid("block") ? getParam<std::vector<SubdomainName>>("block")
+                                        : std::vector<SubdomainName>()),
+    _boundary(params.isParamValid("boundary") ? getParam<std::vector<BoundaryName>>("boundary")
+                                              : std::vector<BoundaryName>()),
     _scaled(!getParam<PostprocessorName>("bulk_volume_PP").empty()),
     _bulk_volume_PP(_scaled ? getParam<PostprocessorName>("bulk_volume_PP") : "czm_strain_V0"),
     _area_ratio_PP("czm_area_ratio"),

src/actions/RankTwoTensorIntegralAction.C

@@ -40,12 +40,13 @@ RankTwoTensorIntegralAction::RankTwoTensorIntegralAction(const InputParameters &
   : Action(params),
     _mp_names(getParam<std::vector<MaterialPropertyName>>("rank_two_tensor")),
     _use_displaced_mesh(getParam<bool>("use_displaced_mesh")),
-    _block(getParam<std::vector<SubdomainName>>("block")),
-    _boundary(getParam<std::vector<BoundaryName>>("boundary")),
-
+    _block(params.isParamValid("block") ? getParam<std::vector<SubdomainName>>("block")
+                                        : std::vector<SubdomainName>()),
+    _boundary(params.isParamValid("boundary") ? getParam<std::vector<BoundaryName>>("boundary")
+                                              : std::vector<BoundaryName>()),
     _scaled(isParamValid("scaling_factor_PP")),
     _scaling_factor_PP(_scaled ? getParam<PostprocessorName>("scaling_factor_PP") : ""),
-    _PP_type(_boundary.size() == 0
+    _PP_type(!params.isParamValid("boundary")
                  ? (_scaled ? "MaterialTensorIntegralScaled" : "MaterialTensorIntegral")
                  : "MaterialTensorIntegralInterfaceScaled"),
     _base_out_name(getParam<std::vector<PostprocessorName>>("base_out_names"))

src/auxkernels/EffectiveStressAux.C

@@ -19,7 +19,7 @@ EffectiveStressAux::validParams()
   params.addClassDescription("Compute an effective stress");
   params.addParam<MooseEnum>(
       "effective_stress_type", EffectiveStressTools::scalarOptions(), "Type of scalar output");
-  params.addParam<std::vector<Real>>("params_vector", "Vector of effective stress parameters");
+  params.addParam<std::vector<Real>>("params_vector", {}, "Vector of effective stress parameters");
   return params;
 }
 

src/auxkernels/IPFColoring.C

@@ -116,11 +116,12 @@ std::vector<Point>
 project_ipf(std::vector<Real> q, Point sd, std::string crystal_sym, std::string sample_sym)
 {
   // Setup sample direction
-  neml::Vector d({sd(0), sd(1), sd(2)});
+  std::vector<Real> temp = {sd(0), sd(1), sd(2)};
+  neml::Vector d(&temp[0]);
   d.normalize();
 
   // Setup orientation
-  neml::Orientation qa(q);
+  neml::Orientation qa(&q[0]);
   neml::Orientation qo = qa.inverse(); // The following assumes a passive rotation
 
   // Get crystal and sample symmetry operations

src/materials/EffectiveStressInterfaceMaterial.C

@@ -24,7 +24,7 @@ EffectiveStressInterfaceMaterial::validParams()
   params.addParam<MooseEnum>("interface_value_type",
                              InterfaceValueTools::InterfaceAverageOptions(),
                              "Type of scalar output");
-  params.addParam<std::vector<Real>>("params_vector", "Vector of effective stress parameters");
+  params.addParam<std::vector<Real>>("params_vector", {}, "Vector of effective stress parameters");
   params.addRequiredParam<MaterialPropertyName>("effective_stress_mp_name",
                                                 "the name of the calcualte effective stress");
   params.addParam<bool>("stateful", false, "If true make the material property stateful");

src/materials/EffectiveStressMaterial.C

@@ -21,7 +21,7 @@ EffectiveStressMaterial::validParams()
   params.addRequiredParam<MooseEnum>("effective_stress_type",
                                      EffectiveStressTools::scalarOptions(),
                                      "Type of effective stress to be computed");
-  params.addParam<std::vector<Real>>("params_vector", "Vector of effective stress parameters");
+  params.addParam<std::vector<Real>>("params_vector", {}, "Vector of effective stress parameters");
   params.addRequiredParam<MaterialPropertyName>("effective_stress_mp_name",
                                                 "The name of the new  material_property");
   params.addParam<bool>("stateful", false, "If true make the material property stateful");

src/postprocessors/CZMAreaRatioPosptocessor.C

@@ -24,9 +24,8 @@ CZMAreaRatioPostprocessor::CZMAreaRatioPostprocessor(const InputParameters & par
 {
 }
 
-Real
-CZMAreaRatioPostprocessor::getValue()
+PostprocessorValue
+CZMAreaRatioPostprocessor::getValue() const
 {
-  _integral_value = CZMAreaPostprocessor::getValue() / _interface_primary_area;
-  return _integral_value;
+  return CZMAreaPostprocessor::getValue() / _interface_primary_area;
 }

src/postprocessors/CZMStrainComponent.C

@@ -50,16 +50,17 @@ CZMStrainComponent::initialize()
   _normalized_strain_component = 0;
 }
 
-Real
-CZMStrainComponent::getValue()
+PostprocessorValue
+CZMStrainComponent::getValue() const
 {
-  _integral_value = CZMAreaRatioPostprocessor::getValue();
-  gatherSum(_normalized_strain_component);
-
-  _normalized_strain_component =
-      _normalized_strain_component / (_initial_bulk_volume_pp * _integral_value);
+  return _normalized_strain_component /
+         (_initial_bulk_volume_pp * CZMAreaRatioPostprocessor::getValue());
+}
 
-  return _normalized_strain_component;
+void
+CZMStrainComponent::finalize()
+{
+  gatherSum(_normalized_strain_component);
 }
 
 void

src/postprocessors/ElementExtremeVectorMaterialProperty.C

@@ -66,8 +66,14 @@ ElementExtremeVectorMaterialProperty::computeQpValue()
   }
 }
 
-Real
-ElementExtremeVectorMaterialProperty::getValue()
+PostprocessorValue
+ElementExtremeVectorMaterialProperty::getValue() const
+{
+  return _value;
+}
+
+void
+ElementExtremeVectorMaterialProperty::finalize()
 {
   switch (_type)
   {
@@ -78,8 +84,6 @@ ElementExtremeVectorMaterialProperty::getValue()
       gatherMin(_value);
       break;
   }
-
-  return _value;
 }
 
 void

src/postprocessors/MaterialTensorIntegralInterfaceScaled.C

@@ -60,14 +60,12 @@ MaterialTensorIntegralInterfaceScaledTempl<is_ad>::computeQpIntegral()
 }
 
 template <bool is_ad>
-Real
-MaterialTensorIntegralInterfaceScaledTempl<is_ad>::getValue()
+PostprocessorValue
+MaterialTensorIntegralInterfaceScaledTempl<is_ad>::getValue() const
 {
-  _integral_value = InterfaceIntegralPostprocessor::getValue();
   if (_scaling_factor_PP)
-    _integral_value /= *_scaling_factor_PP;
-
-  return _integral_value;
+    return InterfaceIntegralPostprocessor::getValue() / *_scaling_factor_PP;
+  return InterfaceIntegralPostprocessor::getValue();
 }
 
 template class MaterialTensorIntegralInterfaceScaledTempl<false>;