From 9d152804b25eff476e3449eef52d47e0f8504eab Mon Sep 17 00:00:00 2001 From: roozbeh Date: Mon, 19 Apr 2021 09:17:47 -0400 Subject: [PATCH] Fatigue, porous flow, multi-phase flow, and more - benchmark pressurized fracture added - fatigue benchmark problem added - documentation files added #98 - tutorial example for hydraulic fracturing is ready --- .gitignore | 1 + .../soil_desiccation/dimensionless_curve.py | 44 ++ .../source/kernels/ADAnisotropicDiffusion.md | 11 + .../source/kernels/ADPoroMechanicsCoupling.md | 11 + .../kernels/ADPorousFlowTimeDerivative.md | 11 + .../kernels/ADSPFPressureTimeDerivative.md | 11 + .../kernels/ADSPFVolStrTimeDerivative.md | 11 + .../source/materials/ADComputeCrackOpening.md | 20 + .../materials/ADComputeFluidMobility.md | 19 + .../source/materials/ADComputePorosity.md | 20 + include/diracKernel/DiracSource.h | 42 ++ include/ics/PhasefieldShapes.h | 28 ++ include/kernels/ADAnisotropicDiffusion.h | 24 ++ include/kernels/ADPoroMechanicsCoupling.h | 27 ++ include/kernels/ADPorousFlowTimeDerivative.h | 24 ++ include/kernels/ADSPFPressureTimeDerivative.h | 20 + include/kernels/ADSPFVolStrTimeDerivative.h | 23 + include/materials/ADComputeCrackOpening.h | 30 ++ include/materials/ADComputeFluidMobility.h | 44 ++ include/materials/ADComputePorosity.h | 29 ++ include/materials/DegradationBase.h | 47 ++ scripts/fixup_headers.py | 32 +- scripts/install-format-hook.sh | 26 -- src/diracKernel/DiracSource.C | 74 ++++ src/ics/PhasefieldShapes.C | 243 +++++++++++ src/kernels/ADAnisotropicDiffusion.C | 32 ++ src/kernels/ADPoroMechanicsCoupling.C | 35 ++ src/kernels/ADPorousFlowTimeDerivative.C | 37 ++ src/kernels/ADSPFPressureTimeDerivative.C | 28 ++ src/kernels/ADSPFVolStrTimeDerivative.C | 33 ++ src/materials/ADComputeCrackOpening.C | 39 ++ src/materials/ADComputeFluidMobility.C | 67 +++ src/materials/ADComputePorosity.C | 49 +++ tutorials/hydraulic_fracturing_SPF/fracture.i | 180 ++++++++ .../hydraulic_fracturing_SPF/gold/results.e | Bin 0 -> 1072440 bytes .../hydraulic_fracturing_SPF/poromechanics.i | 403 ++++++++++++++++++ tutorials/hydraulic_fracturing_SPF/run.sh | 1 + tutorials/hydraulic_fracturing_SPF/tests | 8 + unit/include/raccoonUnitApp.h | 17 +- unit/src/raccoonUnitApp.C | 16 +- 40 files changed, 1753 insertions(+), 64 deletions(-) create mode 100644 benchmarks/soil_desiccation/dimensionless_curve.py create mode 100644 doc/content/source/kernels/ADAnisotropicDiffusion.md create mode 100644 doc/content/source/kernels/ADPoroMechanicsCoupling.md create mode 100644 doc/content/source/kernels/ADPorousFlowTimeDerivative.md create mode 100644 doc/content/source/kernels/ADSPFPressureTimeDerivative.md create mode 100644 doc/content/source/kernels/ADSPFVolStrTimeDerivative.md create mode 100644 doc/content/source/materials/ADComputeCrackOpening.md create mode 100644 doc/content/source/materials/ADComputeFluidMobility.md create mode 100644 doc/content/source/materials/ADComputePorosity.md create mode 100644 include/diracKernel/DiracSource.h create mode 100644 include/ics/PhasefieldShapes.h create mode 100644 include/kernels/ADAnisotropicDiffusion.h create mode 100644 include/kernels/ADPoroMechanicsCoupling.h create mode 100644 include/kernels/ADPorousFlowTimeDerivative.h create mode 100644 include/kernels/ADSPFPressureTimeDerivative.h create mode 100644 include/kernels/ADSPFVolStrTimeDerivative.h create mode 100644 include/materials/ADComputeCrackOpening.h create mode 100644 include/materials/ADComputeFluidMobility.h create mode 100644 include/materials/ADComputePorosity.h create mode 100644 include/materials/DegradationBase.h delete mode 100755 scripts/install-format-hook.sh create mode 100644 src/diracKernel/DiracSource.C create mode 100644 src/ics/PhasefieldShapes.C create mode 100644 src/kernels/ADAnisotropicDiffusion.C create mode 100644 src/kernels/ADPoroMechanicsCoupling.C create mode 100644 src/kernels/ADPorousFlowTimeDerivative.C create mode 100644 src/kernels/ADSPFPressureTimeDerivative.C create mode 100644 src/kernels/ADSPFVolStrTimeDerivative.C create mode 100644 src/materials/ADComputeCrackOpening.C create mode 100644 src/materials/ADComputeFluidMobility.C create mode 100644 src/materials/ADComputePorosity.C create mode 100644 tutorials/hydraulic_fracturing_SPF/fracture.i create mode 100644 tutorials/hydraulic_fracturing_SPF/gold/results.e create mode 100755 tutorials/hydraulic_fracturing_SPF/poromechanics.i create mode 100755 tutorials/hydraulic_fracturing_SPF/run.sh create mode 100644 tutorials/hydraulic_fracturing_SPF/tests diff --git a/.gitignore b/.gitignore index 63c09531bf3..49a92ef99d5 100644 --- a/.gitignore +++ b/.gitignore @@ -82,6 +82,7 @@ temp_print_trace.* *.json *.bak *.processor.* +*.directory .clang_complete .failed_tests compile_commands.json diff --git a/benchmarks/soil_desiccation/dimensionless_curve.py b/benchmarks/soil_desiccation/dimensionless_curve.py new file mode 100644 index 00000000000..5224e48080b --- /dev/null +++ b/benchmarks/soil_desiccation/dimensionless_curve.py @@ -0,0 +1,44 @@ +#* This file is part of the RACCOON application +#* being developed at Dolbow lab at Duke University +#* http://dolbow.pratt.duke.edu + +import os +import math +import csv +import sys +import matplotlib.pyplot as plt + +E = 4 +nu = 0.2 +Gc = 8e-4 +mu = E / 2 / (1 + nu) +m = 5 +b = 0.1 +h = math.sqrt(mu / m / b) + +D_stars = [] +l_star_bars = [] +for n in range(220): + with open("count/out_feature_volumes_" + "{:04d}".format(n + 1) + ".csv") as csv_file: + csv_reader = csv.reader(csv_file, delimiter=',') + next(csv_reader) + + volumes = [] + for row in csv_reader: + volumes.append(float(row[0])) + + total_volume = sum(volumes) + scale = 10000 / total_volume + + sigma = (n + 1) / 1000 + D_star = math.sqrt((1 - nu * nu) * h / E / Gc) * sigma + D_stars.append(D_star) + + l_star_bar = 0 + for volume in volumes: + l_star_bar += math.sqrt(scale * volume) / h + l_star_bar /= len(volumes) + l_star_bars.append(l_star_bar) + +plt.semilogy(D_stars, l_star_bars) +plt.show() diff --git a/doc/content/source/kernels/ADAnisotropicDiffusion.md b/doc/content/source/kernels/ADAnisotropicDiffusion.md new file mode 100644 index 00000000000..149b767b444 --- /dev/null +++ b/doc/content/source/kernels/ADAnisotropicDiffusion.md @@ -0,0 +1,11 @@ +# ADAnisotropicDiffusion + +!syntax description /Kernels/ADAnisotropicDiffusion + +## Example Input File Syntax + +!syntax parameters /Kernels/ADAnisotropicDiffusion + +!syntax inputs /Kernels/ADAnisotropicDiffusion + +!syntax children /Kernels/ADAnisotropicDiffusion diff --git a/doc/content/source/kernels/ADPoroMechanicsCoupling.md b/doc/content/source/kernels/ADPoroMechanicsCoupling.md new file mode 100644 index 00000000000..fd85765c670 --- /dev/null +++ b/doc/content/source/kernels/ADPoroMechanicsCoupling.md @@ -0,0 +1,11 @@ +# ADPoroMechanicsCoupling + +!syntax description /Kernels/ADPoroMechanicsCoupling + +## Example Input File Syntax + +!syntax parameters /Kernels/ADPoroMechanicsCoupling + +!syntax inputs /Kernels/ADPoroMechanicsCoupling + +!syntax children /Kernels/ADPoroMechanicsCoupling diff --git a/doc/content/source/kernels/ADPorousFlowTimeDerivative.md b/doc/content/source/kernels/ADPorousFlowTimeDerivative.md new file mode 100644 index 00000000000..7bccb29b6c8 --- /dev/null +++ b/doc/content/source/kernels/ADPorousFlowTimeDerivative.md @@ -0,0 +1,11 @@ +# ADPorousFlowTimeDerivative + +!syntax description /Kernels/ADPorousFlowTimeDerivative + +## Example Input File Syntax + +!syntax parameters /Kernels/ADPorousFlowTimeDerivative + +!syntax inputs /Kernels/ADPorousFlowTimeDerivative + +!syntax children /Kernels/ADPorousFlowTimeDerivative diff --git a/doc/content/source/kernels/ADSPFPressureTimeDerivative.md b/doc/content/source/kernels/ADSPFPressureTimeDerivative.md new file mode 100644 index 00000000000..043463be74a --- /dev/null +++ b/doc/content/source/kernels/ADSPFPressureTimeDerivative.md @@ -0,0 +1,11 @@ +# ADSPFPressureTimeDerivative + +!syntax description /Kernels/ADSPFPressureTimeDerivative + +## Example Input File Syntax + +!syntax parameters /Kernels/ADSPFPressureTimeDerivative + +!syntax inputs /Kernels/ADSPFPressureTimeDerivative + +!syntax children /Kernels/ADSPFPressureTimeDerivative diff --git a/doc/content/source/kernels/ADSPFVolStrTimeDerivative.md b/doc/content/source/kernels/ADSPFVolStrTimeDerivative.md new file mode 100644 index 00000000000..88639821d79 --- /dev/null +++ b/doc/content/source/kernels/ADSPFVolStrTimeDerivative.md @@ -0,0 +1,11 @@ +# ADSPFVolStrTimeDerivative + +!syntax description /Kernels/ADSPFVolStrTimeDerivative + +## Example Input File Syntax + +!syntax parameters /Kernels/ADSPFVolStrTimeDerivative + +!syntax inputs /Kernels/ADSPFVolStrTimeDerivative + +!syntax children /Kernels/ADSPFVolStrTimeDerivative diff --git a/doc/content/source/materials/ADComputeCrackOpening.md b/doc/content/source/materials/ADComputeCrackOpening.md new file mode 100644 index 00000000000..389fa3f5ec7 --- /dev/null +++ b/doc/content/source/materials/ADComputeCrackOpening.md @@ -0,0 +1,20 @@ +# ADComputeCrackOpening + +!syntax description /Materials/ADComputeCrackOpening + +## Overview + +Crack opening calculation is accomplished using the gradient of damage variable, $\boldsymbol{\nabla}d$, which is used to define the unit vector perpendicular to the crack plane as $\bold{n}^d = \boldsymbol{\nabla}d/|\boldsymbol{\nabla}d|$. The crack opening field is then calculated as + +\begin{equation} +\varw_n = h^{el} \left(\bold{n}^d \cdot \boldsymbol{\epsilon} \cdot \bold{n}^d\right), +\end{equation} +where $h^{el}$ is the edge length of the current element. + +## Example Input File Syntax + +!syntax parameters /Materials/ADComputeCrackOpening + +!syntax inputs /Materials/ADComputeCrackOpening + +!syntax children /Materials/ADComputeCrackOpening diff --git a/doc/content/source/materials/ADComputeFluidMobility.md b/doc/content/source/materials/ADComputeFluidMobility.md new file mode 100644 index 00000000000..2af923fada4 --- /dev/null +++ b/doc/content/source/materials/ADComputeFluidMobility.md @@ -0,0 +1,19 @@ +# ADComputeFluidMobility + +!syntax description /Materials/ADComputeFluidMobility + +## Overview + +\begin{equation} + \boldsymbol{\lambda} = \frac{\bold{k}}{\mu} + d^{\xi}\frac{\bold{k}^d}{\mu}, +\end{equation} +where +in which $\xi$ is an exponent used to localize the increased permeability along the fracture. $\bold{k}/\mu$ is the fluid mobility in intact bulk porous solid, while $\bold{k}^d/\mu$ is the additional permeability in the damaged domain. + +## Example Input File Syntax + +!syntax parameters /Materials/ADComputeFluidMobility + +!syntax inputs /Materials/ADComputeFluidMobility + +!syntax children /Materials/ADComputeFluidMobility diff --git a/doc/content/source/materials/ADComputePorosity.md b/doc/content/source/materials/ADComputePorosity.md new file mode 100644 index 00000000000..991e2c4933b --- /dev/null +++ b/doc/content/source/materials/ADComputePorosity.md @@ -0,0 +1,20 @@ +# ADComputePorosity + +!syntax description /Materials/ADComputePorosity + +## Overview + +This equation calculates porosity evolution in porous solids in terms of variation of fluid pressure and solid volumetric strain: + +\begin{equation} + \phi = \phi_0 + \frac{p}{M} + \alpha \epsilon_v, +\end{equation} +where $\phi$ is the solid porosity; $\phi_0$ is the initial solid porosity; $M$ is biot's modulus; $\alpha$ is the Biot’s coefficient; and $\epsilon_v$ is the solid volumetric strain. + +## Example Input File Syntax + +!syntax parameters /Materials/ADComputePorosity + +!syntax inputs /Materials/ADComputePorosity + +!syntax children /Materials/ADComputePorosity diff --git a/include/diracKernel/DiracSource.h b/include/diracKernel/DiracSource.h new file mode 100644 index 00000000000..a983193efb6 --- /dev/null +++ b/include/diracKernel/DiracSource.h @@ -0,0 +1,42 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +// Moose Includes +#include "DiracKernel.h" + +class DiracSource : public DiracKernel +{ +public: + static InputParameters validParams(); + DiracSource(const InputParameters & parameters); + + virtual void addPoints() override; + virtual Real computeQpResidual() override; + +protected: + /// position of the dirac source + Point _point; + + /// numbe of dimensions + int _dim; + Real _fL; + + /// list of parameters for the source equation + Real _t1; + Real _tRT; + Real _tL; + Real _tP; + Real _p0; + Real _d1; + Real _upcoeff; + Real _downcoeff; + + /// fluid density + Real _rho; + + /// number of acoustic shots + Real _num_shots; +}; diff --git a/include/ics/PhasefieldShapes.h b/include/ics/PhasefieldShapes.h new file mode 100644 index 00000000000..ca72257989f --- /dev/null +++ b/include/ics/PhasefieldShapes.h @@ -0,0 +1,28 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +// MOOSE Includes +#include "InitialCondition.h" + +/** + * PhasefieldShapes just returns a constant value. + */ +class PhasefieldShapes : public InitialCondition +{ +public: + static InputParameters validParams(); + PhasefieldShapes(const InputParameters & parameters); + + virtual Real value(const Point & p); + +private: + Real _epsilon; + std::vector _centers_tips; + std::vector _shapes; + std::vector _gradients; + std::vector _gradient_values; + Real _fluid_phase; +}; diff --git a/include/kernels/ADAnisotropicDiffusion.h b/include/kernels/ADAnisotropicDiffusion.h new file mode 100644 index 00000000000..398b390b6f5 --- /dev/null +++ b/include/kernels/ADAnisotropicDiffusion.h @@ -0,0 +1,24 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "ADKernel.h" + +class ADAnisotropicDiffusion : public ADKernel +{ +public: + static InputParameters validParams(); + + ADAnisotropicDiffusion(const InputParameters & parameters); + +protected: + virtual ADReal computeQpResidual() override; + + /// gradient of the coupled variable + const ADVariableGradient & _grad_v; + + /// fluid mobility tensor + const ADMaterialProperty & _fluid_mob; +}; diff --git a/include/kernels/ADPoroMechanicsCoupling.h b/include/kernels/ADPoroMechanicsCoupling.h new file mode 100644 index 00000000000..efb21cc69b0 --- /dev/null +++ b/include/kernels/ADPoroMechanicsCoupling.h @@ -0,0 +1,27 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "ADKernel.h" + +class ADPoroMechanicsCoupling : public ADKernel +{ +public: + static InputParameters validParams(); + + ADPoroMechanicsCoupling(const InputParameters & parameters); + +protected: + virtual ADReal computeQpResidual(); + + /// biot coefficient + const ADMaterialProperty & _coefficient; + + /// fluid pore pressure + const ADVariableValue & _porepressure; + + /// component integer + unsigned int _component; +}; diff --git a/include/kernels/ADPorousFlowTimeDerivative.h b/include/kernels/ADPorousFlowTimeDerivative.h new file mode 100644 index 00000000000..addb67188fa --- /dev/null +++ b/include/kernels/ADPorousFlowTimeDerivative.h @@ -0,0 +1,24 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "ADTimeKernel.h" + +class ADPorousFlowTimeDerivative : public ADTimeKernel +{ +public: + static InputParameters validParams(); + + ADPorousFlowTimeDerivative(const InputParameters & parameters); + +protected: + virtual ADReal computeQpResidual() override; + + const ADMaterialProperty & _porosity; + const MaterialProperty & _porosity_old; + + const ADVariableValue & _S; + const ADVariableValue & _S_dot; +}; diff --git a/include/kernels/ADSPFPressureTimeDerivative.h b/include/kernels/ADSPFPressureTimeDerivative.h new file mode 100644 index 00000000000..0a2ad83a78f --- /dev/null +++ b/include/kernels/ADSPFPressureTimeDerivative.h @@ -0,0 +1,20 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "ADTimeDerivative.h" + +class ADSPFPressureTimeDerivative : public ADTimeDerivative +{ +public: + static InputParameters validParams(); + + ADSPFPressureTimeDerivative(const InputParameters & parameters); + +protected: + virtual ADReal precomputeQpResidual() override; + + const MaterialProperty & _M; +}; diff --git a/include/kernels/ADSPFVolStrTimeDerivative.h b/include/kernels/ADSPFVolStrTimeDerivative.h new file mode 100644 index 00000000000..eea975a0b80 --- /dev/null +++ b/include/kernels/ADSPFVolStrTimeDerivative.h @@ -0,0 +1,23 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "ADTimeKernel.h" + +class ADSPFVolStrTimeDerivative : public ADTimeKernel +{ +public: + static InputParameters validParams(); + + ADSPFVolStrTimeDerivative(const InputParameters & parameters); + +protected: + virtual ADReal computeQpResidual() override; + + const ADMaterialProperty & _strain; + const MaterialProperty & _strain_old; + + const ADMaterialProperty & _alpha; +}; diff --git a/include/materials/ADComputeCrackOpening.h b/include/materials/ADComputeCrackOpening.h new file mode 100644 index 00000000000..70ec0073e61 --- /dev/null +++ b/include/materials/ADComputeCrackOpening.h @@ -0,0 +1,30 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "Material.h" +#include "RankTwoTensorForward.h" + +class ADComputeCrackOpening : public Material +{ +public: + static InputParameters validParams(); + + ADComputeCrackOpening(const InputParameters & parameters); + +protected: + virtual void computeQpProperties() override; + + /// crack opneing + ADMaterialProperty & _wn; + + /// damage and gradient of damage + const ADVariableValue & _d; + const ADVariableGradient & _grad_d; + + /// strain tensor at current and previous time step + const ADMaterialProperty & _strain; + const MaterialProperty & _strain_old; +}; diff --git a/include/materials/ADComputeFluidMobility.h b/include/materials/ADComputeFluidMobility.h new file mode 100644 index 00000000000..56e25c1ade2 --- /dev/null +++ b/include/materials/ADComputeFluidMobility.h @@ -0,0 +1,44 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "Material.h" +#include "RankTwoTensorForward.h" + +class ADComputeFluidMobility : public Material +{ +public: + static InputParameters validParams(); + + ADComputeFluidMobility(const InputParameters & parameters); + +protected: + ADRankTwoTensor computeMatrixMob(); + ADRankTwoTensor computeFractureMob(); + + virtual void computeQpProperties() override; + + /// fluid mobility tensor + ADMaterialProperty & _fluid_mob; + + /// crack opneing + const ADMaterialProperty & _wn; + + /// damage variable + const ADVariableValue & _d; + const ADVariableGradient & _grad_d; + + /// fluid phase viscosity + const ADMaterialProperty & _eta; + + /// intrinsic permeability of the porous domain + const ADMaterialProperty & _K; + + /// damage exponent in crack fluid mobility + const Real & _mob_eps; + + /// initial crack opening value + const Real & _wcr; +}; diff --git a/include/materials/ADComputePorosity.h b/include/materials/ADComputePorosity.h new file mode 100644 index 00000000000..9294fcb3ecb --- /dev/null +++ b/include/materials/ADComputePorosity.h @@ -0,0 +1,29 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "Material.h" + +class ADComputePorosity : public Material +{ +public: + static InputParameters validParams(); + + ADComputePorosity(const InputParameters & parameters); + +protected: + virtual void initQpStatefulProperties() override; + virtual void computeQpProperties() override; + + const ADVariableValue & _porepressure; + const ADMaterialProperty & _strain; + + ADMaterialProperty & _porosity; + const MaterialProperty & _porosity_old; + const Real _initial_porosity; + + const ADMaterialProperty & _alpha; + const ADMaterialProperty & _M; +}; diff --git a/include/materials/DegradationBase.h b/include/materials/DegradationBase.h new file mode 100644 index 00000000000..82e8a56866b --- /dev/null +++ b/include/materials/DegradationBase.h @@ -0,0 +1,47 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#pragma once + +#include "Material.h" +#include "DerivativeMaterialPropertyNameInterface.h" + +template +class DegradationBaseTempl : public Material, public DerivativeMaterialPropertyNameInterface +{ +public: + static InputParameters validParams(); + + DegradationBaseTempl(const InputParameters & parameters); + +protected: + virtual void initQpStatefulProperties() override { computeQpProperties(); } + virtual void computeQpProperties() override; + virtual void computeDegradation() = 0; + virtual void postComputeDegradation(); + + /// coupled damage variable + const GenericVariableValue & _d; + + /// last converged damage variable + const VariableValue & _d_old; + + /// name of degradation + const MaterialPropertyName _g_name; + + /// degradation + GenericMaterialProperty & _g; + + /// degradation derivative + GenericMaterialProperty & _dg_dd; + + /// residual degradation + const Real & _eta; + + /// whether to lag the degradation + const bool _lag; +}; + +typedef DegradationBaseTempl DegradationBase; +typedef DegradationBaseTempl ADDegradationBase; diff --git a/scripts/fixup_headers.py b/scripts/fixup_headers.py index 2d8c060163a..2648cb1e9a0 100644 --- a/scripts/fixup_headers.py +++ b/scripts/fixup_headers.py @@ -1,4 +1,4 @@ -# This script checks and can optionally update MOOSE source files. +# This script checks and can optionally update RACCOON source files. # You should always run this script without the "-u" option # first to make sure there is a clean dry run of the files that should # be updated @@ -9,7 +9,7 @@ import shutil from optparse import OptionParser -global_ignores = ['contrib', '.svn', '.git', 'libmesh'] +global_ignores = ['moose', '.git'] unified_header = """\ //* This file is part of the RACCOON application @@ -32,8 +32,10 @@ def fixupHeader(): if ignore in dirnames: dirnames.remove(ignore) - # print dirpath - # print dirnames + print(dirpath) + print(dirnames) + print(filenames) + print("====================================================") for file in filenames: suffix = os.path.splitext(file) if (suffix[-1] == '.C' or suffix[-1] == '.h') and not global_options.python_only: @@ -54,12 +56,13 @@ def checkAndUpdateCPlusPlus(filename): header = unified_header # Check (exact match only) - if (string.find(text, header) == -1 or global_options.force == True): + if (text.find(header) == -1 or global_options.force): # print the first 10 lines or so of the file - if global_options.update == False: # Report only - print filename + ' does not contain an up to date header' - if global_options.verbose == True: - print '>' * 40, '\n', '\n'.join((text.split('\n', 10))[:10]), '\n' * 5 + if not global_options.update: # Report only + print(filename + ' does not contai)n an up to date header') + if global_options.verbose: + print('>' * 40, '\n', + '\n'.join((text.split('\n', 10))[:10]), '\n' * 5) else: # Make sure any previous C-style header version is removed text = re.sub(r'^/\*+/$.*^/\*+/$', '', text, flags=re.S | re.M) @@ -98,12 +101,13 @@ def checkAndUpdatePython(filename): header = python_header # Check (exact match only) - if (string.find(text, header) == -1): + if (text.find(header) == -1): # print the first 10 lines or so of the file - if global_options.update == False: # Report only - print filename + ' does not contain an up to date header' - if global_options.verbose == True: - print '>' * 40, '\n', '\n'.join((text.split('\n', 10))[:10]), '\n' * 5 + if not global_options.update: # Report only + print(filename + ' does not contain an up to date header') + if global_options.verbose: + print('>' * 40, '\n', + '\n'.join((text.split('\n', 10))[:10]), '\n' * 5) else: # Save off the shebang line if it exists m = re.match(r'#!.*\n', text) diff --git a/scripts/install-format-hook.sh b/scripts/install-format-hook.sh deleted file mode 100755 index 44a2037a5b1..00000000000 --- a/scripts/install-format-hook.sh +++ /dev/null @@ -1,26 +0,0 @@ -#!/bin/bash - -REPO_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/../" -hookfile="$REPO_DIR/.git/hooks/pre-commit" - -if [[ -f $hookfile ]]; then - echo "'$hookfile' already exists - aborting" 1>&2 - exit 1 -fi - -echo '#!/bin/bash -patch=$(git clang-format --diff -- $(git diff --staged --name-only -- src include tests unit)) -if [[ "$patch" =~ "no modified files to format" || "$patch" =~ "clang-format did not modify any files" ]]; then - echo "" > /dev/null -else - echo "" - echo "Your code is not properly formatted." >&2 - echo "Run 'git clang-format' to resolve the following issues:" >&2 - echo "" - echo "$patch" - exit 1 -fi -' > $hookfile - -chmod a+x $hookfile - diff --git a/src/diracKernel/DiracSource.C b/src/diracKernel/DiracSource.C new file mode 100644 index 00000000000..f0b373e34b0 --- /dev/null +++ b/src/diracKernel/DiracSource.C @@ -0,0 +1,74 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#define _USE_MATH_DEFINES +#include +#include "DiracSource.h" +#include "Executioner.h" + +registerMooseObject("raccoonApp", DiracSource); + +InputParameters +DiracSource::validParams() +{ + InputParameters params = DiracKernel::validParams(); + params.addRequiredParam("point", "The x,y,z coordinates of the point"); + params.addRequiredParam("dim", "The dimension of the problem"); + params.addRequiredParam("fL", "some coefficient"); + params.addRequiredParam("t1", "some coefficient"); + params.addRequiredParam("tRT", "some coefficient"); + params.addRequiredParam("tL", "some coefficient"); + params.addRequiredParam("tP", "some coefficient"); + params.addRequiredParam("p0", "some coefficient"); + params.addRequiredParam("d1", "some coefficient"); + params.addRequiredParam("upcoeff", "some coefficient"); + params.addRequiredParam("downcoeff", "some coefficient"); + params.addRequiredParam("rho", "some coefficient"); + params.addRequiredParam("num_shots", "number of shots"); + return params; +} + +DiracSource::DiracSource(const InputParameters & parameters) + : DiracKernel(parameters), + _point(getParam("point")), + _dim(getParam("dim")), + _fL(getParam("fL")), + _t1(getParam("t1")), + _tRT(getParam("tRT")), + _tL(getParam("tL")), + _tP(getParam("tP")), + _p0(getParam("p0")), + _d1(getParam("d1")), + _upcoeff(getParam("upcoeff")), + _downcoeff(getParam("downcoeff")), + _rho(getParam("rho")), + _num_shots(getParam("num_shots")) +{ +} + +void +DiracSource::addPoints() +{ + // Add a point from the input file + addPoint(_point); +} + +Real +DiracSource::computeQpResidual() +{ + const Real _end_t = _app.getExecutioner()->getParam("end_time"); + Real _shot_duration = _end_t / _num_shots; + int _current_shot = std::floor(_t / _shot_duration); + Real _shot_t = _t - _current_shot * _shot_duration; + + // Yingjie's paper + Real _pressure_source = + 1 / _tP * 4 * M_PI / _rho * _upcoeff / _downcoeff * _p0 * _d1 * + (std::max((1 + tanh((_shot_t - _t1) / _tRT)) * std::exp(-(_shot_t - _t1) / _tL) * + cos(2 * M_PI * _fL * (_shot_t - _t1) + M_PI / 3), + 0.0)); + + // source pressure times test function is returned + return -_test[_i][_qp] * _pressure_source; +} diff --git a/src/ics/PhasefieldShapes.C b/src/ics/PhasefieldShapes.C new file mode 100644 index 00000000000..498b4c4e834 --- /dev/null +++ b/src/ics/PhasefieldShapes.C @@ -0,0 +1,243 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "PhasefieldShapes.h" + +registerMooseObject("raccoonApp", PhasefieldShapes); + +InputParameters +PhasefieldShapes::validParams() +{ + InputParameters params = InitialCondition::validParams(); + params.addClassDescription("Defining IC in different shapes for phase field variables"); + params.addRequiredParam("epsilon", "Phase field itransition parameter"); + params.addParam>("shapes", "array of shape types: crack, circle"); + params.addParam>("gradients", "array of gradient types: box"); + params.addParam>("centers_tips", "coordinates"); + params.addParam>("gradient_values", "coordinates and values"); + params.addRequiredParam("fluid_phase", "string indicating which fluid phase to place inside the shape"); + + return params; +} + +PhasefieldShapes::PhasefieldShapes(const InputParameters & parameters) + : InitialCondition(parameters), + _epsilon(getParam("epsilon")), + _centers_tips(getParam>("centers_tips")), + _shapes(getParam>("shapes")), + _gradients(getParam>("gradients")), + _gradient_values(getParam>("gradient_values")), + _fluid_phase(getParam("fluid_phase")) +{ +} + +Real +PhasefieldShapes::value(const Point & p) +{ + int _num_shapes = _shapes.size(); + int _num_gradients = _gradients.size(); + + // for shapes + + int steps = 1000; + double distance = 9e10; // start with big value. + double aux_distance = 0.0; + double current_value = 0.0; + double _crack_x0, _crack_x1, _crack_y0, _crack_y1; + double _center_x, _center_y, _radius_a; //, _radius_b; + double _x1, _y1, _v1, _x2, _y2, _v2, _v3, _v4; + + for (int i = 0; i < _num_shapes; i++) + { + if (_shapes[i] == "crack") + { + _crack_x0 = _centers_tips[i * 4 + 0]; + _crack_y0 = _centers_tips[i * 4 + 1]; + _crack_x1 = _centers_tips[i * 4 + 2]; + _crack_y1 = _centers_tips[i * 4 + 3]; + + double step_x = (_crack_x1 - _crack_x0) / steps; + double step_y = (_crack_y1 - _crack_y0) / steps; + + aux_distance = sqrt((p(0) - (_crack_x0)) * (p(0) - (_crack_x0)) + + (p(1) - (_crack_y0)) * (p(1) - (_crack_y0))); + if (aux_distance < distance) + distance = aux_distance; + + for (int j = 1; j < steps + 1; j++) + { + aux_distance = sqrt((p(0) - (_crack_x0 + j * step_x)) * (p(0) - (_crack_x0 + j * step_x)) + + (p(1) - (_crack_y0 + j * step_y)) * (p(1) - (_crack_y0 + j * step_y))); + if (aux_distance < distance) + distance = aux_distance; + + if (_fluid_phase == 1.0) + current_value = 1.0 - tanh(distance / _epsilon); + else if (_fluid_phase == 0.0) + current_value = tanh(distance / _epsilon); + } + } + + if (_shapes[i] == "circle") + { + + double amp, k; + amp = _centers_tips[i * 6 + 3]; + k = _centers_tips[i * 6 + 4]; + + _center_x = _centers_tips[i * 6 + 0]; + _center_y = _centers_tips[i * 6 + 1]; + _radius_a = _centers_tips[i * 6 + 2]; + + // angle + + double pi = 3.141591; + double angle = atan((p(1) - _center_y) / (p(0) - _center_x)); + + if (((p(0) - _center_x) >= 0.0) && ((p(1) - _center_y) >= 0.0)) + angle = angle; + if (((p(0) - _center_x) < 0.0) && ((p(1) - _center_y) >= 0.0)) + angle = -pi/2 + angle; + if (((p(0) - _center_x) < 0.0) && ((p(1) - _center_y) < 0.0)) + angle = -pi + angle; + if (((p(0) - _center_x) >= 0.0) && ((p(1) - _center_y) < 0.0)) + angle = -3*pi/2 + angle; + + double perturbation = amp * sin(k * angle); + + aux_distance = sqrt((p(0) - _center_x) * (p(0) - _center_x) + + (p(1) - _center_y) * (p(1) - _center_y)); // distance to + + if (aux_distance <= 0.0) { + if (_fluid_phase == 1.0) + current_value = 1.0; + else if (_fluid_phase == 0.0) + current_value = 0.0; + } else { + if (_fluid_phase == 1.0) + current_value = 1.0 - 0.5 * (1.0 + tanh((((aux_distance - _radius_a) + perturbation) / _epsilon))); + else if (_fluid_phase == 0.0) + current_value = 0.5 * (1.0 + tanh((((aux_distance - _radius_a) + perturbation) / _epsilon))); + } + + //if (_fluid_phase == 1.0) + // current_value = exp(-(aux_distance - (_radius_a + perturbation)) / _epsilon); + //else if (_fluid_phase == 0.0) + // current_value = 1.0 - exp(-(aux_distance - (_radius_a + perturbation)) / _epsilon); + // + //if (aux_distance < (_radius_a + perturbation)) { + // if (_fluid_phase == 1.0) + // current_value = 1.0; + // else if (_fluid_phase == 0.0) + // current_value = 0.0; + //} + } + + if (_shapes[i] == "line") + { + + // points + _x1 = _centers_tips[i * 6 + 0]; + _y1 = _centers_tips[i * 6 + 1]; + _x2 = _centers_tips[i * 6 + 2]; + _y2 = _centers_tips[i * 6 + 3]; + + // vector + double norm = sqrt((_x2 - _x1) * (_x2 - _x1) + (_y2 - _y1) * (_y2 - _y1)); + _v1 = (_x2 - _x1) / norm; + _v2 = (_y2 - _y1) / norm; + // normal + _v3 = -_v2; + _v4 = _v1; + + double pi = 3.141591; + + distance = (p(0) - _x1) * _v3 + (p(1) - _y1) * _v4; + + double amp, k; + amp = _centers_tips[i * 6 + 4]; + k = _centers_tips[i * 6 + 5]; + + double perturbation = amp * sin(((p(0) - _x1) * _v1 + (p(1) - _y1) * _v2) / k * pi); + + current_value = 0.5 * (1.0 + tanh(((distance + perturbation) / _epsilon))); + } + } + + for (int i = 0; i < _num_gradients; i++) + { + if (_gradients[i] == "box") + { + _x1 = _gradient_values[i * 8 + 0]; + _y1 = _gradient_values[i * 8 + 1]; + _x2 = _gradient_values[i * 8 + 2]; + _y2 = _gradient_values[i * 8 + 3]; + _v1 = _gradient_values[i * 8 + 4]; + _v2 = _gradient_values[i * 8 + 5]; + _v3 = _gradient_values[i * 8 + 6]; + _v4 = _gradient_values[i * 8 + 7]; + + double d_x[2], d_y[2]; + d_x[0] = _x2 - p(0); + d_x[1] = p(0) - _x1; + d_y[0] = _y2 - p(1); + d_y[1] = p(1) - _y1; + + current_value = (1 / (_x2 - _x1) / (_y2 - _y1)) * ((d_x[0] * _v1 + d_x[1] * _v2) * d_y[0] + + (d_x[0] * _v3 + d_x[1] * _v4) * d_y[1]); + } + if (_gradients[i] == "box_pattern") + { + _x1 = _gradient_values[i * 8 + 0]; + _y1 = _gradient_values[i * 8 + 1]; + _x2 = _gradient_values[i * 8 + 2]; + _y2 = _gradient_values[i * 8 + 3]; + _v1 = _gradient_values[i * 8 + 4]; + _v2 = _gradient_values[i * 8 + 5]; + _v3 = _gradient_values[i * 8 + 6]; + _v4 = _gradient_values[i * 8 + 7]; + + double d_x, d_y; + + d_x = p(0) - _x1; + d_y = p(1) - _y1; + + double pi = 3.141591; + + current_value = + _v1 + (_v2 - _v1) * std::abs(sin(pi * d_x / _v3)) * std::abs(sin(pi * d_y / _v4)); + } + if (_gradients[i] == "line") + { + _x1 = _gradient_values[i * 8 + 0]; + _y1 = _gradient_values[i * 8 + 1]; + _x2 = _gradient_values[i * 8 + 2]; + _y2 = _gradient_values[i * 8 + 3]; + _v1 = _gradient_values[i * 8 + 4]; + _v2 = _gradient_values[i * 8 + 5]; + _v3 = _gradient_values[i * 8 + 6]; + _v4 = _gradient_values[i * 8 + 7]; + + double m = (_y2 - _y1) / (_x2 - _x1); + + if (p(1) < (_y1 + m * (p(0) - _x1))) + { + + double distance_1 = (_y1 + m * (p(0) - _x1)) - p(1); + double diff_value = (_v1 + _v2) / 2 - _v1; + current_value = _v1 + exp(-distance_1 / _epsilon) * diff_value; + } + + if (p(1) >= (_y1 + m * (p(0) - _x1))) + { + + double distance_1 = -(_y1 + m * (p(0) - _x1)) + p(1); + double diff_value = (_v1 + _v2) / 2 - _v2; + current_value = _v2 + exp(-distance_1 / _epsilon) * diff_value; + } + } + } + + return current_value; +} diff --git a/src/kernels/ADAnisotropicDiffusion.C b/src/kernels/ADAnisotropicDiffusion.C new file mode 100644 index 00000000000..522a402adaf --- /dev/null +++ b/src/kernels/ADAnisotropicDiffusion.C @@ -0,0 +1,32 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADAnisotropicDiffusion.h" + +registerMooseObject("raccoonApp", ADAnisotropicDiffusion); + +InputParameters +ADAnisotropicDiffusion::validParams() +{ + InputParameters params = ADKernel::validParams(); + params.addClassDescription( + "Kernel handling fluid diffusion in domain with anisotropic permeability"); + params.addRequiredParam( + "mobility_name", "Name of fluid mobility material property"); + params.addCoupledVar("v", "Coupled variable of the kernel"); + return params; +} + +ADAnisotropicDiffusion::ADAnisotropicDiffusion(const InputParameters & parameters) + : ADKernel(parameters), + _grad_v(isCoupled("v") ? adCoupledGradient("v") : _grad_u), + _fluid_mob(getADMaterialProperty("mobility_name")) +{ +} + +ADReal +ADAnisotropicDiffusion::computeQpResidual() +{ + return (_fluid_mob[_qp] * _grad_v[_qp]) * _grad_test[_i][_qp]; +} diff --git a/src/kernels/ADPoroMechanicsCoupling.C b/src/kernels/ADPoroMechanicsCoupling.C new file mode 100644 index 00000000000..ecc63d6eb2c --- /dev/null +++ b/src/kernels/ADPoroMechanicsCoupling.C @@ -0,0 +1,35 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADPoroMechanicsCoupling.h" + +registerMooseObject("raccoonApp", ADPoroMechanicsCoupling); + +InputParameters +ADPoroMechanicsCoupling::validParams() +{ + InputParameters params = ADKernel::validParams(); + params.addClassDescription( + "Kernel handling coupling of porepressure to porous media through biot coefficient"); + params.addRequiredCoupledVar("porepressure", "Pore pressure"); + params.addRequiredParam("component", + "The gradient direction (0 for x, 1 for y and 2 for z)"); + return params; +} + +ADPoroMechanicsCoupling::ADPoroMechanicsCoupling(const InputParameters & parameters) + : ADKernel(parameters), + _coefficient(getADMaterialProperty("biot_coefficient")), + _porepressure(adCoupledValue("porepressure")), + _component(getParam("component")) +{ + if (_component >= _mesh.dimension()) + mooseError("PoroMechanicsCoupling: component should not be greater than the mesh dimension\n"); +} + +ADReal +ADPoroMechanicsCoupling::computeQpResidual() +{ + return -_coefficient[_qp] * _porepressure[_qp] * _grad_test[_i][_qp](_component); +} diff --git a/src/kernels/ADPorousFlowTimeDerivative.C b/src/kernels/ADPorousFlowTimeDerivative.C new file mode 100644 index 00000000000..50a546546a2 --- /dev/null +++ b/src/kernels/ADPorousFlowTimeDerivative.C @@ -0,0 +1,37 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADPorousFlowTimeDerivative.h" +#include "MooseVariable.h" +#include "libmesh/quadrature.h" +#include + +registerMooseObject("raccoonApp", ADPorousFlowTimeDerivative); + +InputParameters +ADPorousFlowTimeDerivative::validParams() +{ + InputParameters params = ADTimeKernel::validParams(); + params.addClassDescription("Kernel computing fluid content time derivative for multiphase flow."); + params.addParam( + "porosity_name", "porosity", "Name of porosity material property"); + params.addRequiredCoupledVar("saturation_variable", "fluid phase saturation variable"); + return params; +} + +ADPorousFlowTimeDerivative::ADPorousFlowTimeDerivative(const InputParameters & parameters) + : ADTimeKernel(parameters), + _porosity(getADMaterialProperty(getParam("porosity_name"))), + _porosity_old(getMaterialPropertyOld(getParam("porosity_name"))), + _S(adCoupledValue("saturation_variable")), + _S_dot(adCoupledDot("saturation_variable")) +{ +} + +ADReal +ADPorousFlowTimeDerivative::computeQpResidual() +{ + return _test[_i][_qp] * + (((_porosity[_qp] - _porosity_old[_qp]) / _dt) * _S[_qp] + _porosity[_qp] * _S_dot[_qp]); +} diff --git a/src/kernels/ADSPFPressureTimeDerivative.C b/src/kernels/ADSPFPressureTimeDerivative.C new file mode 100644 index 00000000000..65730f20068 --- /dev/null +++ b/src/kernels/ADSPFPressureTimeDerivative.C @@ -0,0 +1,28 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADSPFPressureTimeDerivative.h" + +registerMooseObject("raccoonApp", ADSPFPressureTimeDerivative); + +InputParameters +ADSPFPressureTimeDerivative::validParams() +{ + InputParameters params = ADTimeDerivative::validParams(); + params.addClassDescription( + "AD Time derivative of pressure divided by the biot modulus in single phase flow."); + params.addParam("biot_modulus", "biot_modulus", "biot_modulus"); + return params; +} + +ADSPFPressureTimeDerivative::ADSPFPressureTimeDerivative(const InputParameters & parameters) + : ADTimeDerivative(parameters), _M(getMaterialProperty("biot_modulus")) +{ +} + +ADReal +ADSPFPressureTimeDerivative::precomputeQpResidual() +{ + return 1 / _M[_qp] * ADTimeDerivative::precomputeQpResidual(); +} diff --git a/src/kernels/ADSPFVolStrTimeDerivative.C b/src/kernels/ADSPFVolStrTimeDerivative.C new file mode 100644 index 00000000000..da3b80319db --- /dev/null +++ b/src/kernels/ADSPFVolStrTimeDerivative.C @@ -0,0 +1,33 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADSPFVolStrTimeDerivative.h" +#include "MooseVariable.h" +#include "libmesh/quadrature.h" +#include + +registerMooseObject("raccoonApp", ADSPFVolStrTimeDerivative); + +InputParameters +ADSPFVolStrTimeDerivative::validParams() +{ + InputParameters params = ADTimeKernel::validParams(); + params.addClassDescription("Single phase flow volumetric strain time derivative term."); + params.addParam("biot_coefficient", "biot_coefficient", "biot_coefficient"); + return params; +} + +ADSPFVolStrTimeDerivative::ADSPFVolStrTimeDerivative(const InputParameters & parameters) + : ADTimeKernel(parameters), + _strain(getADMaterialPropertyByName("total_strain")), + _strain_old(getMaterialPropertyOldByName("total_strain")), + _alpha(getADMaterialProperty("biot_coefficient")) +{ +} + +ADReal +ADSPFVolStrTimeDerivative::computeQpResidual() +{ + return _test[_i][_qp] * _alpha[_qp] * ((_strain[_qp].trace() - _strain_old[_qp].trace()) / _dt); +} diff --git a/src/materials/ADComputeCrackOpening.C b/src/materials/ADComputeCrackOpening.C new file mode 100644 index 00000000000..1501f03be33 --- /dev/null +++ b/src/materials/ADComputeCrackOpening.C @@ -0,0 +1,39 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADComputeCrackOpening.h" + +registerMooseObject("raccoonApp", ADComputeCrackOpening); + +InputParameters +ADComputeCrackOpening::validParams() +{ + InputParameters params = Material::validParams(); + params.addClassDescription( + "compute crack opening using the damage phase field variable and strain elemental tensor"); + params.addParam( + "crack_opening_name", "crack_opening", "Name of the crack opening variable"); + params.addRequiredCoupledVar("damage", "damage field"); + return params; +} + +ADComputeCrackOpening::ADComputeCrackOpening(const InputParameters & parameters) + : Material(parameters), + _wn(declareADProperty(getParam("crack_opening_name"))), + _d(adCoupledValue("damage")), + _grad_d(adCoupledGradient("damage")), + _strain(getADMaterialPropertyByName("total_strain")), + _strain_old(getMaterialPropertyOldByName("total_strain")) +{ +} + +void +ADComputeCrackOpening::computeQpProperties() +{ + const Real eps = 1e-15; + ADRealVectorValue n; + if (_grad_d[_qp].norm() > eps) + n = _grad_d[_qp] / _grad_d[_qp].norm(); + _wn[_qp] = 0.5 * (_current_elem->hmin() + _current_elem->hmax()) * (_strain_old[_qp] * n) * n; +} diff --git a/src/materials/ADComputeFluidMobility.C b/src/materials/ADComputeFluidMobility.C new file mode 100644 index 00000000000..8561168945f --- /dev/null +++ b/src/materials/ADComputeFluidMobility.C @@ -0,0 +1,67 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADComputeFluidMobility.h" + +registerMooseObject("raccoonApp", ADComputeFluidMobility); + +InputParameters +ADComputeFluidMobility::validParams() +{ + InputParameters params = Material::validParams(); + params.addClassDescription("compute mobility in porous media including effect of damage"); + params.addParam( + "fluid_mobility_name", "fluid_mobility", "Name of fluid mobility material property"); + params.addRequiredCoupledVar("damage", "damage field"); + params.addParam( + "fluid_viscosity_name", "fluid_viscosity", "fluid_viscosity"); + params.addParam( + "intrinsic_permeability_name", "intrinsic_permeability", "intrinsic_permeability"); + params.addRequiredParam("mobility_exponent", "exponent used in mobility equation"); + params.addParam("initial_crack_opening", 0.0, "initial opening of a crack"); + return params; +} + +ADComputeFluidMobility::ADComputeFluidMobility(const InputParameters & parameters) + : Material(parameters), + _fluid_mob( + declareADProperty(getParam("fluid_mobility_name"))), + _wn(getADMaterialPropertyByName("crack_opening")), + _d(adCoupledValue("damage")), + _grad_d(adCoupledGradient("damage")), + _eta(getADMaterialProperty("fluid_viscosity_name")), + _K(getADMaterialProperty("intrinsic_permeability_name")), + _mob_eps(getParam("mobility_exponent")), + _wcr(getParam("initial_crack_opening")) +{ +} + +ADRankTwoTensor +ADComputeFluidMobility::computeMatrixMob() +{ + ADRankTwoTensor identity(ADRankTwoTensor::initIdentity); + return _K[_qp] / _eta[_qp] * identity; +} + +ADRankTwoTensor +ADComputeFluidMobility::computeFractureMob() +{ + const Real eps = 1e-15; + ADRankTwoTensor identity(ADRankTwoTensor::initIdentity); + ADRealVectorValue n; + if (_grad_d[_qp].norm() > eps) + n = _grad_d[_qp] / _grad_d[_qp].norm(); + ADRankTwoTensor nn; + nn.vectorOuterProduct(n, n); + return (_wn[_qp]+_wcr) * (_wn[_qp]+_wcr) / (12 * _eta[_qp]) * (identity - nn); +} + +void +ADComputeFluidMobility::computeQpProperties() +{ + ADRankTwoTensor matrix_mob = computeMatrixMob(); + ADRankTwoTensor fracture_mob = computeFractureMob(); + + _fluid_mob[_qp] = matrix_mob + std::pow(_d[_qp], _mob_eps) * fracture_mob; +} diff --git a/src/materials/ADComputePorosity.C b/src/materials/ADComputePorosity.C new file mode 100644 index 00000000000..012cefc46ac --- /dev/null +++ b/src/materials/ADComputePorosity.C @@ -0,0 +1,49 @@ +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu + +#include "ADComputePorosity.h" +#include "RankTwoTensor.h" + +registerMooseObject("raccoonApp", ADComputePorosity); + +InputParameters +ADComputePorosity::validParams() +{ + InputParameters params = Material::validParams(); + params.addClassDescription( + "compute porosity in poroelastic media as a function of fluid pressure and solid volumetric strain"); + params.addRequiredCoupledVar("porepressure", "fluid phase porepressure"); + params.addParam( + "porosity_name", "porosity", "Name of porosity material property"); + params.addRequiredRangeCheckedParam( + "initial_porosity", "initial_porosity>0.0 & initial_porosity<1.0", "Initial porosity"); + params.addParam("biot_coefficient", "biot_coefficient", "biot_coefficient"); + params.addParam("biot_modulus", "biot_modulus", "biot_modulus"); + return params; +} + +ADComputePorosity::ADComputePorosity(const InputParameters & parameters) + : Material(parameters), + _porepressure(adCoupledValue("porepressure")), + _strain(getADMaterialPropertyByName("total_strain")), + _porosity(declareADProperty(getParam("porosity_name"))), + _porosity_old(getMaterialPropertyOld(getParam("porosity_name"))), + _initial_porosity(getParam("initial_porosity")), + _alpha(getADMaterialProperty("biot_coefficient")), + _M(getADMaterialProperty("biot_modulus")) +{ +} + +void +ADComputePorosity::initQpStatefulProperties() +{ + _porosity[_qp] = _initial_porosity; +} + +void +ADComputePorosity::computeQpProperties() +{ + _porosity[_qp] = + _porepressure[_qp] / _M[_qp] + _alpha[_qp] * (_strain[_qp].trace()) + _initial_porosity; +} diff --git a/tutorials/hydraulic_fracturing_SPF/fracture.i b/tutorials/hydraulic_fracturing_SPF/fracture.i new file mode 100644 index 00000000000..87fc358fe70 --- /dev/null +++ b/tutorials/hydraulic_fracturing_SPF/fracture.i @@ -0,0 +1,180 @@ +############################################################################### +E = 16 +nu = 0.1812 + +K = '${fparse E/3/(1-2*nu)}' +G = '${fparse E/2/(1+nu)}' + +Gc = 9.49e-9 +l = 0.75 + +domain_size = 80.0 +crack_size = 8.0 +end_time = 4.0 +############################################################################### +[Mesh] + [./generated_mesh] + type = GeneratedMeshGenerator + dim = 2 + elem_type = QUAD4 + nx = ${fparse domain_size} + ny = ${fparse domain_size} + nz = 0 + xmin = 0 + xmax = ${domain_size} + ymin = 0 + ymax = ${domain_size} + zmin = 0 + zmax = 0 + [../] +[] + +[ICs] + [./d] + type = CohesiveDamageIC + variable = d + d0 = 1.0 + l = ${l} + x1 = ${fparse 0.5*(domain_size-crack_size)} + y1 = ${fparse 0.5*domain_size} + z1 = 0.0 + x2 = ${fparse 0.5*(domain_size+crack_size)} + y2 = ${fparse 0.5*domain_size} + z2 = 0 + [../] +[] + +############################################################################### +[MultiApps] + [mechanical] + type = TransientMultiApp + input_files = 'poromechanics.i' + app_type = raccoonApp + execute_on = 'TIMESTEP_BEGIN' + cli_args = 'G=${G};K=${K};l=${l};domain_size=${domain_size};end_time=${end_time};crack_size=${crack_size}' + [] +[] + +[Transfers] + [get_E_el_active] + type = MultiAppCopyTransfer + multi_app = mechanical + direction = from_multiapp + source_variable = 'psie_active' + variable = 'psie_active' + [] + [send_d] + type = MultiAppCopyTransfer + multi_app = mechanical + direction = to_multiapp + source_variable = 'd' + variable = 'd' + [] +[] + +[Variables] + [d] + [] +[] + +[AuxVariables] + [psie_active] + order = CONSTANT + family = MONOMIAL + [] + [bounds_dummy] + [] +[] + +[Bounds] + [irreversibility] + type = VariableOldValueBoundsAux + variable = 'bounds_dummy' + bounded_variable = 'd' + bound_type = lower + [] + [upper] + type = ConstantBoundsAux + variable = 'bounds_dummy' + bounded_variable = 'd' + bound_type = upper + bound_value = 1 + [] +[] + +[Kernels] + [diff] + type = ADPFFDiffusion + variable = 'd' + fracture_toughness = Gc + regularization_length = l + normalization_constant = c0 + [] + [source] + type = ADPFFSource + variable = d + free_energy = psi + [] +[] + +[Materials] + [fracture_properties] + type = ADGenericConstantMaterial + prop_names = 'Gc l' + prop_values = '${Gc} ${l}' + [] + [degradation] + type = PowerDegradationFunction + f_name = g + function = (1-d)^p*(1-eta)+eta + phase_field = d + parameter_names = 'p eta ' + parameter_values = '2 1e-3' + [] + [crack_geometric] + type = CrackGeometricFunction + f_name = alpha + function = 'd^2' + phase_field = d + [] + [psi] + type = ADDerivativeParsedMaterial + f_name = psi + function = 'alpha*Gc/c0/l+g*psie_active' + args = 'd psie_active' + material_property_names = 'alpha(d) g(d) Gc c0 l' + derivative_order = 1 + [] +[] + +[Postprocessors] + [norm_d] + type = ElementL2Norm + variable = 'd' + [] +[] + +[Executioner] + type = Transient + solve_type = 'NEWTON' + petsc_options_iname = '-pc_type -snes_type' + petsc_options_value = 'lu vinewtonrsls' + + dt = 1e-1 + end_time = ${end_time} + nl_rel_tol = 1e-06 + nl_abs_tol = 1e-08 + + fixed_point_max_its = 20 + custom_pp = 'norm_d' + custom_abs_tol = 1e-03 + custom_rel_tol = 1e-03 + disable_fixed_point_residual_norm_check = true + accept_on_max_fixed_point_iteration = false +[] + +[Outputs] + print_linear_residuals = false + print_linear_converged_reason = false + print_nonlinear_converged_reason = false +[] diff --git a/tutorials/hydraulic_fracturing_SPF/gold/results.e b/tutorials/hydraulic_fracturing_SPF/gold/results.e new file mode 100644 index 0000000000000000000000000000000000000000..0b19617cb4c6ad7fc3f112978ae050a50a7c4611 GIT binary patch literal 1072440 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 z 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

!miOvrOr1 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 I-u>JB2cinZxBvhE literal 0 HcmV?d00001 diff --git a/tutorials/hydraulic_fracturing_SPF/poromechanics.i b/tutorials/hydraulic_fracturing_SPF/poromechanics.i new file mode 100755 index 00000000000..01ca771694c --- /dev/null +++ b/tutorials/hydraulic_fracturing_SPF/poromechanics.i @@ -0,0 +1,403 @@ +############################################################################### +eta = 1e-12 +k_int = 3e-12 +Q = 4e-3 +alpha = 0.79 +eps = 50 +M = 12.5 + +############################################################################### +[Mesh] + [./generated_mesh] + type = GeneratedMeshGenerator + dim = 2 + elem_type = QUAD4 + nx = ${fparse domain_size} + ny = ${fparse domain_size} + nz = 0 + xmin = 0 + xmax = ${domain_size} + ymin = 0 + ymax = ${domain_size} + zmin = 0 + zmax = 0 + [../] +[] + +[ICs] + [./d0] + type = CohesiveDamageIC + variable = d0 + d0 = 1.0 + l = ${l} + x1 = ${fparse 0.5*(domain_size-crack_size)} + y1 = ${fparse 0.5*domain_size} + z1 = 0.0 + x2 = ${fparse 0.5*(domain_size+crack_size)} + y2 = ${fparse 0.5*domain_size} + z2 = 0 + [../] +[] + +############################################################################### +[GlobalParams] + displacements = 'disp_x disp_y' +[] + +[Variables] + [./disp_x] + [../] + [./disp_y] + [../] + [./pressure] + [../] +[] + +[AuxVariables] + [./d0] + [../] + [./d] + [../] + [./psie_active] + order = CONSTANT + family = MONOMIAL + [../] + [./stress_h] + order = CONSTANT + family = MONOMIAL + [../] + [./stress_xx] + order = CONSTANT + family = MONOMIAL + [../] + [./stress_yy] + order = CONSTANT + family = MONOMIAL + [../] + [./stress_xy] + order = CONSTANT + family = MONOMIAL + [../] + [./lambda_xx] + order = CONSTANT + family = MONOMIAL + [../] + [./lambda_xy] + order = CONSTANT + family = MONOMIAL + [../] + [./lambda_yy] + order = CONSTANT + family = MONOMIAL + [../] + [./crack_opening] + order = CONSTANT + family = MONOMIAL + [../] + [./fluid_source_term] + order = CONSTANT + family = MONOMIAL + [../] + [./biot_coefficient] + order = CONSTANT + family = MONOMIAL + [../] +[] + +############################################################################### +[BCs] + [./xfix] + type = DirichletBC + variable = 'disp_x' + boundary = 'top bottom left right' + value = 0 + [../] + [./yfix] + type = DirichletBC + variable = 'disp_y' + boundary = 'top bottom left right' + value = 0 + [../] + [./p] + type = DirichletBC + variable = 'pressure' + boundary = 'top bottom left right' + value = 0 + [../] +[] + +############################################################################### +[Kernels] + # solid mechaincs + ################################### + [./solid_x] + type = ADStressDivergenceTensors + variable = 'disp_x' + displacements = 'disp_x disp_y' + component = 0 + [../] + [./solid_y] + type = ADStressDivergenceTensors + variable = 'disp_y' + displacements = 'disp_x disp_y' + component = 1 + [../] + [./poro_x] + type = ADPoroMechanicsCoupling + variable = 'disp_x' + porepressure = 'pressure' + component = 0 + [../] + [./poro_y] + type = ADPoroMechanicsCoupling + variable = 'disp_y' + porepressure = 'pressure' + component = 1 + [../] + + # pressure + ################################### + [./timederivative_pressure] + type = ADSPFPressureTimeDerivative + variable = pressure + [../] + [./timederivative_epsV] + type = ADSPFVolStrTimeDerivative + variable = pressure + [../] + [./diffusion_pressure] + type = ADAnisotropicDiffusion + variable = pressure + mobility_name = 'fluid_mobility' + [../] + [./source_term] + type = ADCoefMatSource + variable = pressure + prop_names = 'fluid_source_term' + coefficient = -1 + [../] + ################################### + +[] + +############################################################################### +[AuxKernels] + [./E_el] + type = ADMaterialRealAux + variable = 'psie_active' + property = 'psie_active' + execute_on = 'TIMESTEP_END' + [] + [./stress_h] + type = ADRankTwoScalarAux + rank_two_tensor = 'stress' + variable = 'stress_h' + scalar_type = Hydrostatic + execute_on = 'TIMESTEP_END' + [../] + [./stress_xx] + type = ADRankTwoAux + variable = 'stress_xx' + rank_two_tensor = 'stress' + index_i = 0 + index_j = 0 + execute_on = 'TIMESTEP_END' + [../] + [./stress_xy] + type = ADRankTwoAux + variable = 'stress_xy' + rank_two_tensor = 'stress' + index_i = 0 + index_j = 1 + execute_on = 'TIMESTEP_END' + [../] + [./stress_yy] + type = ADRankTwoAux + variable = 'stress_yy' + rank_two_tensor = 'stress' + index_i = 1 + index_j = 1 + execute_on = 'TIMESTEP_END' + [../] + [./lambda_xx] + type = ADMaterialRankTwoTensorAux + property = 'fluid_mobility' + variable = 'lambda_xx' + i = 0 + j = 0 + execute_on = 'TIMESTEP_END' + [../] + [./lambda_xy] + type = ADMaterialRankTwoTensorAux + property = 'fluid_mobility' + variable = 'lambda_xy' + i = 0 + j = 1 + execute_on = 'TIMESTEP_END' + [../] + [./lambda_yy] + type = ADMaterialRankTwoTensorAux + property = 'fluid_mobility' + variable = 'lambda_yy' + i = 1 + j = 1 + execute_on = 'TIMESTEP_END' + [../] + [./crack_opening] + type = ADMaterialRealAux + property = 'crack_opening' + variable = 'crack_opening' + execute_on = 'TIMESTEP_END' + [../] + [./fluid_source_term] + type = ADMaterialRealAux + property = 'fluid_source_term' + variable = 'fluid_source_term' + execute_on = 'TIMESTEP_END' + [../] + [./biot_coefficient] + type = ADMaterialRealAux + property = 'biot_coefficient' + variable = 'biot_coefficient' + execute_on = 'TIMESTEP_END' + [../] +[] + +############################################################################### +[Materials] + [./constants] + type = ADGenericConstantMaterial + prop_names = 'fluid_viscosity intrinsic_permeability fluid_source' + prop_values = '${eta} ${k_int} ${Q}' + [../] + + [./biot] + type = GenericConstantMaterial + prop_names = 'biot_modulus' + prop_values = '${M}' + [../] + + [./biot_intact] + type = ADGenericConstantMaterial + prop_names = 'intact_biot_coef' + prop_values = '${alpha}' + [../] + + [./crack_opening] + type = ADComputeCrackOpening + damage = 'd' + [../] + + [./mob_w] + type = ADComputeFluidMobility + damage = 'd' + mobility_exponent = '${eps}' + [../] + + [./fluid_source_term] + type = ADParsedMaterial + f_name = fluid_source_term + material_property_names = 'fluid_source' + args = 'd0' + function = 'if(d0>0.5, fluid_source, 0.0)' + [../] + + [./biot_coefficient] + type = ADDerivativeParsedMaterial + f_name = biot_coefficient + material_property_names = 'intact_biot_coef' + args = 'd' + function = 'intact_biot_coef' + enable_jit = true + derivative_order = 1 + [../] + +## Elasticity ## + [bulk] + type = ADGenericConstantMaterial + prop_names = 'K G' + prop_values = '${K} ${G}' + [] + [degradation] + type = PowerDegradationFunction + f_name = g + function = (1-d)^p*(1-eta)+eta + phase_field = d + parameter_names = 'p eta ' + parameter_values = '2 1e-3' + [] + [strain] + type = ADComputeSmallStrain + [] + [elasticity] + type = SmallDeformationIsotropicElasticity + bulk_modulus = K + shear_modulus = G + phase_field = d + degradation_function = g + decomposition = SPECTRAL + output_properties = 'elastic_strain psie_active' + outputs = exodus + [] + [stress] + type = ComputeSmallDeformationStress + elasticity_model = elasticity + output_properties = 'stress' + outputs = exodus + [] +[] + +############################################################################### +[Postprocessors] + [./step_size] # Size of the time step + type = TimestepSize + [../] + [./iterations] # Number of iterations needed to converge timestep + type = NumNonlinearIterations + [../] + [./nodes] # Number of nodes in mesh + type = NumNodes + [../] + [./evaluations] # Cumulative residual calculations for simulation + type = NumResidualEvaluations + [../] +[] + +############################################################################### +[Preconditioning] + [./coupled] + type = SMP + full = true + [../] +[] + +############################################################################### +[Executioner] + type = Transient + solve_type = 'NEWTON' + nl_max_its = 50 + nl_rel_tol = 1e-6 + nl_abs_tol = 1e-8 + dt = 1e-1 + end_time = ${end_time} + petsc_options_iname = '-pc_type' + petsc_options_value = 'lu' + automatic_scaling = true +[] + +############################################################################### +[Outputs] + file_base = results + interval = 1 + exodus = true + console = true + print_linear_converged_reason = false + print_nonlinear_converged_reason = false + print_linear_residuals = false + [./console] + type = Console + max_rows = 10 + [../] +[] + +############################################################################### diff --git a/tutorials/hydraulic_fracturing_SPF/run.sh b/tutorials/hydraulic_fracturing_SPF/run.sh new file mode 100755 index 00000000000..87bf6abb708 --- /dev/null +++ b/tutorials/hydraulic_fracturing_SPF/run.sh @@ -0,0 +1 @@ +mpiexec -n 14 ~/Projects/raccoon/raccoon-opt -i fracture.i diff --git a/tutorials/hydraulic_fracturing_SPF/tests b/tutorials/hydraulic_fracturing_SPF/tests new file mode 100644 index 00000000000..0fb8c03237c --- /dev/null +++ b/tutorials/hydraulic_fracturing_SPF/tests @@ -0,0 +1,8 @@ +[Tests] + [hydraulic_fracture] + type = Exodiff + input = 'fracture.i' + exodiff = 'results.e' + cli_args = 'Executioner/num_steps=1 domain_size=20 end_time=1e-1' + [] +[] diff --git a/unit/include/raccoonUnitApp.h b/unit/include/raccoonUnitApp.h index 9d52668c14a..106b78d04db 100644 --- a/unit/include/raccoonUnitApp.h +++ b/unit/include/raccoonUnitApp.h @@ -1,24 +1,15 @@ -//* 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 +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu #pragma once #include "raccoonApp.h" -class raccoonUnitApp; - -template <> -InputParameters validParams(); - class raccoonUnitApp : public raccoonApp { public: + static InputParameters validParams(); raccoonUnitApp(const InputParameters & parameters); virtual ~raccoonUnitApp(); diff --git a/unit/src/raccoonUnitApp.C b/unit/src/raccoonUnitApp.C index 2e8a48199d3..16eaccbb5f0 100644 --- a/unit/src/raccoonUnitApp.C +++ b/unit/src/raccoonUnitApp.C @@ -1,20 +1,14 @@ -//* 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 +//* This file is part of the RACCOON application +//* being developed at Dolbow lab at Duke University +//* http://dolbow.pratt.duke.edu #include "raccoonUnitApp.h" #include "Moose.h" -template <> InputParameters -validParams() +raccoonUnitApp::validParams() { - InputParameters params = validParams(); + InputParameters params = raccoonApp::validParams(); return params; }