diff --git a/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_hydro_crack_scheme.md b/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_hydro_crack_scheme.md
deleted file mode 100644
index e938d33adaba54df328d623ca8c11f732bf1902b..0000000000000000000000000000000000000000
--- a/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_hydro_crack_scheme.md
+++ /dev/null
@@ -1 +0,0 @@
-In case of static, pressure is set to 1.0. For propagating crack, evolution of pressure is found through enforcing the crack volume balance.
diff --git a/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_pressurized_crack_scheme.md b/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_pressurized_crack_scheme.md
new file mode 100644
index 0000000000000000000000000000000000000000..74cc738e7ab8c791a22b5cefefee2d64812bf0b5
--- /dev/null
+++ b/Documentation/ProjectFile/prj/processes/process/PHASE_FIELD/t_pressurized_crack_scheme.md
@@ -0,0 +1,3 @@
+Pressurized crack is part of the phase field process (in the toughness-dominated regime). Pressure is set to 1.0 in the case of a static pressurized crack (pressurized_crack_scheme ="static"). Pressure evolution is found for propagating pressurized cracks (pressurized_crack_scheme ="propagating") by enforcing the crack volume balance.
+
+The implementation was carried out in accordance with \cite yoshioka2019comparative .
\ No newline at end of file
diff --git a/Documentation/bibliography/other.bib b/Documentation/bibliography/other.bib
index a059c74a3925768c48afe9abda026750f974d9c2..7c91cc03ef91f95ebd827fa340e32d2a491f2b74 100644
--- a/Documentation/bibliography/other.bib
+++ b/Documentation/bibliography/other.bib
@@ -441,4 +441,15 @@ URL = {https://doi.org/10.1680/geot.2008.58.3.157}
publisher = {arXiv},
year = {2022},
copyright = {Creative Commons Attribution Non Commercial No Derivatives 4.0 International}
+}
+
+@article{yoshioka2019comparative,
+ title={Comparative verification of discrete and smeared numerical approaches for the simulation of hydraulic fracturing},
+ author={Yoshioka, Keita and Parisio, Francesco and Naumov, Dmitri and Lu, Renchao and Kolditz, Olaf and Nagel, Thomas},
+ journal={GEM-International Journal on Geomathematics},
+ volume={10},
+ number={1},
+ pages={1--35},
+ year={2019},
+ publisher={Springer}
}
\ No newline at end of file
diff --git a/ProcessLib/PhaseField/Tests.cmake b/ProcessLib/PhaseField/Tests.cmake
index 3bb449833f02f34d4567c8440337270e8db71058..2463d5d043ed63263dff20e50edef179653f3f56 100644
--- a/ProcessLib/PhaseField/Tests.cmake
+++ b/ProcessLib/PhaseField/Tests.cmake
@@ -141,4 +141,5 @@ if(OGS_USE_PETSC)
NotebookTest(NOTEBOOKFILE PhaseField/surfing_jupyter_notebook/surfing_pyvista.ipynb RUNTIME 25)
NotebookTest(NOTEBOOKFILE PhaseField/beam_jupyter_notebook/beam.ipynb RUNTIME 500 PROPERTIES PROCESSORS 3)
NotebookTest(NOTEBOOKFILE PhaseField/tpb_jupyter_notebook/TPB.ipynb RUNTIME 110 PROPERTIES PROCESSORS 4)
+ NotebookTest(NOTEBOOKFILE PhaseField/kregime_jupyter_notebook/Kregime_Static_jupyter.ipynb RUNTIME 40 RESOURCE_LOCK PYVISTA)
endif()
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.gml b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.gml
new file mode 100644
index 0000000000000000000000000000000000000000..093bf35dcd84e2215dba13ef4d6e530f8ecf7639
--- /dev/null
+++ b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.gml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<?xml-stylesheet type="text/xsl" href="OpenGeoSysGLI.xsl"?>
+
+<OpenGeoSysGLI xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.opengeosys.org/images/xsd/OpenGeoSysGLI.xsd" xmlns:ogs="http://www.opengeosys.org">
+ <name>Kregime_Static</name>
+ <points>
+ <point id="0" x="-2." y="-2." z="0" name="p_0"/>
+ <point id="1" x="2." y="-2." z="0" name="p_1"/>
+ <point id="2" x="2." y="2." z="0" name="p_2"/>
+ <point id="3" x="-2." y="2." z="0" name="p_3"/>
+ <point id="4" x="-2." y="0." z="0" name="p_4"/>
+
+
+ </points>
+
+ <polylines>
+
+ <polyline id="0" name="top">
+ <pnt>2</pnt>
+ <pnt>3</pnt>
+ </polyline>
+ <polyline id="1" name="bottom">
+ <pnt>0</pnt>
+ <pnt>1</pnt>
+ </polyline>
+ <polyline id="2" name="left">
+ <pnt>3</pnt>
+ <pnt>0</pnt>
+ </polyline>
+ <polyline id="3" name="right">
+ <pnt>1</pnt>
+ <pnt>2</pnt>
+ </polyline>
+
+ </polylines>
+
+</OpenGeoSysGLI>
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.prj b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.prj
new file mode 100644
index 0000000000000000000000000000000000000000..f5bccface89fc6db49c8553be8f8b27a5d8c0816
--- /dev/null
+++ b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static.prj
@@ -0,0 +1,315 @@
+<?xml version='1.0' encoding='ISO-8859-1'?>
+<OpenGeoSysProject>
+ <mesh>mesh_full_pf_OGS_pf_ic.vtu</mesh>
+ <geometry>Kregime_Static.gml</geometry>
+ <processes>
+ <process>
+ <name>PhaseField</name>
+ <type>PHASE_FIELD</type>
+ <phasefield_model>AT1</phasefield_model>
+ <coupling_scheme>staggered</coupling_scheme>
+ <energy_split_model>Isotropic</energy_split_model>
+ <pressurized_crack_scheme>static</pressurized_crack_scheme>
+ <integration_order>2</integration_order>
+ <constitutive_relation>
+ <type>LinearElasticIsotropic</type>
+ <youngs_modulus>E</youngs_modulus>
+ <poissons_ratio>nu</poissons_ratio>
+ </constitutive_relation>
+ <phasefield_parameters>
+ <residual_stiffness>k</residual_stiffness>
+ <crack_resistance>gc</crack_resistance>
+ <crack_length_scale>ls</crack_length_scale>
+ </phasefield_parameters>
+ <solid_density>rho_sr</solid_density>
+ <process_variables>
+ <phasefield>phasefield</phasefield>
+ <displacement>displacement</displacement>
+ </process_variables>
+ <secondary_variables>
+ <secondary_variable type="static" internal_name="sigma" output_name="sigma"/>
+ <secondary_variable type="static" internal_name="epsilon" output_name="epsilon"/>
+ </secondary_variables>
+ <specific_body_force>0 0 </specific_body_force>
+ </process>
+ </processes>
+ <time_loop>
+ <global_process_coupling>
+ <max_iter> 1000 </max_iter>
+ <convergence_criteria>
+ <!-- convergence criterion for the first process -->
+ <convergence_criterion>
+ <type>DeltaX</type>
+ <norm_type>INFINITY_N</norm_type>
+ <abstol>1.e-4</abstol>
+ <reltol>1.e-4</reltol>
+ </convergence_criterion>
+ <!-- convergence criterion for the second process -->
+ <convergence_criterion>
+ <type>DeltaX</type>
+ <norm_type>INFINITY_N</norm_type>
+ <abstol>1.e-4</abstol>
+ <reltol>1.e-10</reltol>
+ </convergence_criterion>
+ </convergence_criteria>
+ </global_process_coupling>
+ <processes>
+ <process ref="PhaseField">
+ <nonlinear_solver>basic_newton_u</nonlinear_solver>
+ <convergence_criterion>
+ <type>DeltaX</type>
+ <norm_type>NORM2</norm_type>
+ <reltol>1.e-14</reltol>
+ </convergence_criterion>
+ <time_discretization>
+ <type>BackwardEuler</type>
+ </time_discretization>
+ <time_stepping>
+ <type>FixedTimeStepping</type>
+ <t_initial>0</t_initial>
+ <t_end>1</t_end>
+ <timesteps>
+ <pair>
+ <repeat>1</repeat>
+ <delta_t>0.5</delta_t>
+ </pair>
+ </timesteps>
+ </time_stepping>
+ </process>
+ <process ref="PhaseField">
+ <nonlinear_solver>petsc_snes</nonlinear_solver>
+ <convergence_criterion>
+ <type>DeltaX</type>
+ <norm_type>NORM2</norm_type>
+ <reltol>1.e-14</reltol>
+ </convergence_criterion>
+ <time_discretization>
+ <type>BackwardEuler</type>
+ </time_discretization>
+ <time_stepping>
+ <type>FixedTimeStepping</type>
+ <t_initial>0</t_initial>
+ <t_end>1</t_end>
+ <timesteps>
+ <pair>
+ <repeat>1</repeat>
+ <delta_t>0.5</delta_t>
+ </pair>
+ </timesteps>
+ </time_stepping>
+ </process>
+ </processes>
+ <output>
+ <type>VTK</type>
+ <prefix>results_h_0.0100</prefix>
+ <variables>
+ <variable>displacement</variable>
+ <variable>phasefield</variable>
+ </variables>
+ <timesteps>
+ <pair>
+ <repeat>100</repeat>
+ <each_steps>1</each_steps>
+ </pair>
+ <pair>
+ <repeat>10</repeat>
+ <each_steps>1</each_steps>
+ </pair>
+ </timesteps>
+ </output>
+ </time_loop>
+ <parameters>
+ <!-- Mechanics -->
+ <parameter>
+ <name>E</name>
+ <type>Constant</type>
+ <value>1.0</value>
+ </parameter>
+ <parameter>
+ <name>nu</name>
+ <type>Constant</type>
+ <value>0.15</value>
+ </parameter>
+ <parameter>
+ <name>k</name>
+ <type>Constant</type>
+ <value>1e-16</value>
+ </parameter>
+ <parameter>
+ <name>gc</name>
+ <type>Constant</type>
+ <value>1.0</value>
+ </parameter>
+ <parameter>
+ <name>ls</name>
+ <type>Constant</type>
+ <value>0.02</value>
+ </parameter>
+ <parameter>
+ <name>H</name>
+ <type>Constant</type>
+ <value>0.0</value>
+ </parameter>
+ <parameter>
+ <name>rho_sr</name>
+ <type>Constant</type>
+ <value>0.0</value>
+ </parameter>
+ <parameter>
+ <name>displacement0</name>
+ <type>Constant</type>
+ <values>0 0</values>
+ </parameter>
+ <parameter>
+ <name>phasefield_ic</name>
+ <type>MeshNode</type>
+ <field_name>phase-field</field_name>
+ </parameter>
+ <parameter>
+ <name>phasefield_bc</name>
+ <type>Constant</type>
+ <value>1</value>
+ </parameter>
+ <parameter>
+ <name>dirichlet0</name>
+ <type>Constant</type>
+ <value>0</value>
+ </parameter>
+ <parameter>
+ <name>M</name>
+ <type>Constant</type>
+ <value>0.0</value>
+ </parameter>
+ <parameter>
+ <name>Dirichlet_load</name>
+ <type>Constant</type>
+ <value>1</value>
+ </parameter>
+ <parameter>
+ <name>Dirichlet_top_y</name>
+ <type>CurveScaled</type>
+ <curve>Dirichlet_top_time</curve>
+ <parameter>Dirichlet_load</parameter>
+ </parameter>
+ </parameters>
+ <curves>
+ <curve>
+ <name>Dirichlet_top_time</name>
+ <coords>0 1</coords>
+ <values>0 1.0</values>
+ </curve>
+ </curves>
+ <process_variables>
+ <process_variable>
+ <name>displacement</name>
+ <components>2</components>
+ <order>1</order>
+ <initial_condition>displacement0</initial_condition>
+ <boundary_conditions>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>left</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>dirichlet0</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>right</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>dirichlet0</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>top</geometry>
+ <type>Dirichlet</type>
+ <component>1</component>
+ <parameter>dirichlet0</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>bottom</geometry>
+ <type>Dirichlet</type>
+ <component>1</component>
+ <parameter>dirichlet0</parameter>
+ </boundary_condition>
+ </boundary_conditions>
+ </process_variable>
+ <process_variable>
+ <name>phasefield</name>
+ <components>1</components>
+ <order>1</order>
+ <initial_condition>phasefield_ic</initial_condition>
+ <boundary_conditions>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>left</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>phasefield_bc</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>right</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>phasefield_bc</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>top</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>phasefield_bc</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <geometrical_set>Kregime_Static</geometrical_set>
+ <geometry>bottom</geometry>
+ <type>Dirichlet</type>
+ <component>0</component>
+ <parameter>phasefield_bc</parameter>
+ </boundary_condition>
+ <boundary_condition>
+ <mesh>Kregime_Static_bottom</mesh>
+ <type>PhaseFieldIrreversibleDamageOracleBoundaryCondition</type>
+ <component>0</component>
+ </boundary_condition>
+ </boundary_conditions>
+ </process_variable>
+ </process_variables>
+ <nonlinear_solvers>
+ <nonlinear_solver>
+ <name>petsc_snes</name>
+ <type>PETScSNES</type>
+ <max_iter>50</max_iter>
+ <linear_solver>linear_solver_d</linear_solver>
+ </nonlinear_solver>
+ <nonlinear_solver>
+ <name>basic_newton_u</name>
+ <type>Newton</type>
+ <max_iter>200</max_iter>
+ <linear_solver>linear_solver_u</linear_solver>
+ </nonlinear_solver>
+ </nonlinear_solvers>
+ <linear_solvers>
+ <linear_solver>
+ <name>linear_solver_d</name>
+ <eigen>
+ <solver_type>BiCGSTAB</solver_type>
+ <precon_type>ILUT</precon_type>
+ <max_iteration_step>10000</max_iteration_step>
+ <error_tolerance>1e-16</error_tolerance>
+ </eigen>
+ <petsc>
+ <parameters>-ksp_type cg -pc_type bjacobi -ksp_atol 1e-16 -ksp_rtol 1e-16 -snes_type vinewtonssls -snes_atol 1.e-8 -snes_rtol 1.e-8 -snes_max_it 1000 -snes_monitor </parameters>
+ </petsc>
+ </linear_solver>
+ <linear_solver>
+ <name>linear_solver_u</name>
+ <petsc>
+ <parameters>-ksp_type cg -pc_type bjacobi -ksp_atol 1e-16 -ksp_rtol 1e-16 </parameters>
+ </petsc>
+ </linear_solver>
+ </linear_solvers>
+</OpenGeoSysProject>
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static_jupyter.ipynb b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static_jupyter.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..20f7e31ec26f1a60e55ad28ca92101a13fd12667
--- /dev/null
+++ b/Tests/Data/PhaseField/kregime_jupyter_notebook/Kregime_Static_jupyter.ipynb
@@ -0,0 +1,606 @@
+{
+ "cells": [
+ {
+ "cell_type": "raw",
+ "metadata": {},
+ "source": [
+ "notebook = \"PhaseField/kregime_jupyter_notebook/Kregime_Static_jupyter.ipynb\"\n",
+ "author = \"Mostafa Mollaali, Keita Yoshioka\"\n",
+ "date = \"2022-12-06\"\n",
+ "title = \"Static fracture opening under a constant pressure – Sneddon solution\"\n",
+ "web_subsection = \"phase-field\"\n",
+ "<!--eofm-->"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from ogs6py import ogs\n",
+ "import numpy as np\n",
+ "import ogs6py\n",
+ "import matplotlib.pyplot as plt\n",
+ "import time\n",
+ "import math\n",
+ "import gmsh\n",
+ "import os\n",
+ "\n",
+ "pi = math.pi\n",
+ "plt.rcParams[\"text.usetex\"] = True"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Problem description\n",
+ "\n",
+ "### Static fracture opening under a constant pressure\n",
+ "\n",
+ "Consider a line fracture $[-a_0, a_0] \\times \\{0\\}$ ($a_0$ = 0.1) with no external loading and an internal fluid pressure of $p=1$ was applied to the fracture surfaces. The results are compared to the analytical solution (**Sneddon et al., 1969**) for the fracture half-opening:\n",
+ "\\begin{eqnarray}\n",
+ "u(x,0) = \\frac{2 p a_0}{ E'} \\sqrt{1-(x/a_0)^2}\n",
+ ",\n",
+ "\\label{eq:sneddon_2D_static}\n",
+ "\\end{eqnarray}\n",
+ "\n",
+ "where $u$ is the displacement $E'$ is the plane strain Young's modulus ($E' = E/(1-\\nu^2)$) with $\\nu$ is Poisson’s ratio, $p$ is the fluid pressure inside the fracture. To account for the infinite boundaries in the closed-form solution, we considered a large finite domain $ [-10a_o,10a_o] \\times [-10a_o,10a_o]$. The effective element size, $h$, is $1\\times10^{-2}$.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![Schematic view of Sneddon problem and Boundary conditions](./figures/Model_sneddon_straight.png#one-half \"Schematic view of Sneddon problem and Boundary conditions.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* In order to have a static pressurized fracture, add, $\\texttt{<pressurized_crack_scheme>static</pressurized_crack_scheme>}$ in the project file. It's important to note that static pressurized fracture implementation assumes $p=1$. **Yoshioka _et al._, 2019** discussed using real material properties and rescaling the phase-field energy functional.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Input data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The material and geometrical properties are listed in the Table below. It's worth noting that the properties are dimensionless and scaled."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "| **Name** | **Value** | **Symbol** |\n",
+ "|--------------------------------|------------------ |------------|\n",
+ "| _Young's modulus_ | 1 | $E$ |\n",
+ "| _Poisson's ratio_ | 0.15 | $\\nu$ |\n",
+ "| _Fracture toughness_ | 1 | $G_{c}$ |\n",
+ "| _Regularization parameter_ | 2$h$ | $\\ell_s$ |\n",
+ "| _Pressure_ | 1 | $p$ |\n",
+ "| _Length_ | 2 | $L$ |\n",
+ "| _Height_ | 2 | $H$ |\n",
+ "| _Initial crack length_ | 0.2 | $2a_0$ |"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "E = 1.0\n",
+ "nu = 0.15\n",
+ "Gc = 1.0\n",
+ "P = 1.0\n",
+ "h = 0.01\n",
+ "\n",
+ "\n",
+ "Orientation = 0\n",
+ "a0 = 0.1 # half of the initial crack length\n",
+ "n_slices = (\n",
+ " 2 * (round(3.0 * a0 / h)) + 1\n",
+ ") # number of slices for calcute width of fracture\n",
+ "\n",
+ "phasefield_model = \"AT1\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h_list = [0.01] # list of mesh sizes (h)\n",
+ "# h_list =[0.01, 0.005, 0.0025] # list of mesh sizes (h), for mesh sensitivity"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Output directory and project file"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# file's name\n",
+ "prj_name = \"Kregime_Static.prj\"\n",
+ "meshname = \"mesh_full_pf\"\n",
+ "\n",
+ "out_dir = os.environ.get(\"OGS_TESTRUNNER_OUT_DIR\", \"_out\")\n",
+ "os.makedirs(out_dir, exist_ok=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Mesh generation\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def mesh_generation(lc, lc_fine):\n",
+ " \"\"\"\n",
+ " lc ... characteristic length for coarse meshing\n",
+ " lc_fine ... characteristic length for fine meshing\n",
+ " \"\"\"\n",
+ " L = 4.0 # Length\n",
+ " H = 4.0 # Height\n",
+ " b = 0.4 # Length/Height of subdomain with fine mesh\n",
+ "\n",
+ " # Before using any functions in the Python API, Gmsh must be initialized\n",
+ " gmsh.initialize()\n",
+ " gmsh.option.setNumber(\"General.Terminal\", 1)\n",
+ " gmsh.model.add(\"rectangle\")\n",
+ "\n",
+ " # Dimensions\n",
+ " dim1 = 1\n",
+ " dim2 = 2\n",
+ "\n",
+ " # Points\n",
+ " gmsh.model.geo.addPoint(-L / 2, -H / 2, 0, lc, 1)\n",
+ " gmsh.model.geo.addPoint(L / 2, -H / 2, 0, lc, 2)\n",
+ " gmsh.model.geo.addPoint(L / 2, H / 2, 0, lc, 3)\n",
+ " gmsh.model.geo.addPoint(-L / 2, H / 2, 0, lc, 4)\n",
+ " gmsh.model.geo.addPoint(-b, -b - lc_fine / 2, 0, lc_fine, 5)\n",
+ " gmsh.model.geo.addPoint(b, -b - lc_fine / 2, 0, lc_fine, 6)\n",
+ " gmsh.model.geo.addPoint(b, b + lc_fine / 2, 0, lc_fine, 7)\n",
+ " gmsh.model.geo.addPoint(-b, b + lc_fine / 2, 0, lc_fine, 8)\n",
+ "\n",
+ " # Lines\n",
+ " gmsh.model.geo.addLine(1, 2, 1)\n",
+ " gmsh.model.geo.addLine(2, 3, 2)\n",
+ " gmsh.model.geo.addLine(3, 4, 3)\n",
+ " gmsh.model.geo.addLine(4, 1, 4)\n",
+ " gmsh.model.geo.addLine(5, 6, 5)\n",
+ " gmsh.model.geo.addLine(6, 7, 6)\n",
+ " gmsh.model.geo.addLine(7, 8, 7)\n",
+ " gmsh.model.geo.addLine(8, 5, 8)\n",
+ "\n",
+ " # Line loops\n",
+ " gmsh.model.geo.addCurveLoop([1, 2, 3, 4], 1)\n",
+ " gmsh.model.geo.addCurveLoop([5, 6, 7, 8], 2)\n",
+ "\n",
+ " # Add plane surfaces defined by one or more curve loops.\n",
+ " gmsh.model.geo.addPlaneSurface([1, 2], 1)\n",
+ " gmsh.model.geo.addPlaneSurface([2], 2)\n",
+ "\n",
+ " gmsh.model.geo.synchronize()\n",
+ "\n",
+ " # Prepare structured grid\n",
+ " gmsh.model.geo.mesh.setTransfiniteCurve(\n",
+ " 6, math.ceil(2 * b / lc_fine + 2), \"Progression\", 1\n",
+ " )\n",
+ " gmsh.model.geo.mesh.setTransfiniteCurve(\n",
+ " 8, math.ceil(2 * b / lc_fine + 2), \"Progression\", 1\n",
+ " )\n",
+ " gmsh.model.geo.mesh.setTransfiniteSurface(2, \"Alternate\")\n",
+ "\n",
+ " gmsh.model.geo.mesh.setRecombine(dim2, 1)\n",
+ " gmsh.model.geo.mesh.setRecombine(dim2, 2)\n",
+ "\n",
+ " gmsh.model.geo.synchronize()\n",
+ "\n",
+ " # Physical groups\n",
+ " Bottom = gmsh.model.addPhysicalGroup(dim1, [1])\n",
+ " gmsh.model.setPhysicalName(dim1, Bottom, \"Bottom\")\n",
+ "\n",
+ " Right = gmsh.model.addPhysicalGroup(dim1, [2])\n",
+ " gmsh.model.setPhysicalName(dim1, Right, \"Right\")\n",
+ "\n",
+ " Top = gmsh.model.addPhysicalGroup(dim1, [3])\n",
+ " gmsh.model.setPhysicalName(dim1, Top, \"Top\")\n",
+ "\n",
+ " Left = gmsh.model.addPhysicalGroup(dim1, [4])\n",
+ " gmsh.model.setPhysicalName(dim1, Left, \"Left\")\n",
+ "\n",
+ " Computational_domain = gmsh.model.addPhysicalGroup(dim2, [1, 2])\n",
+ " gmsh.model.setPhysicalName(dim2, Computational_domain, \"Computational_domain\")\n",
+ " gmsh.model.geo.synchronize()\n",
+ "\n",
+ " output_file = f\"{out_dir}/\" + meshname + \".msh\"\n",
+ " gmsh.model.mesh.generate(dim2)\n",
+ " gmsh.write(output_file)\n",
+ " gmsh.finalize()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Pre process\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def pre_processing(h, a0):\n",
+ " mesh = pv.read(f\"{out_dir}/mesh_full_pf_domain.vtu\")\n",
+ " phase_field = np.ones((len(mesh.points), 1))\n",
+ " pv.set_plot_theme(\"document\")\n",
+ "\n",
+ " for node_id, x in enumerate(mesh.points):\n",
+ " if (\n",
+ " (mesh.center[0] - x[0]) <= a0 + 0.001 * h\n",
+ " and (mesh.center[0] - x[0]) >= -a0 - 0.001 * h\n",
+ " and (mesh.center[1] - x[1]) < h / 2 + 0.001 * h\n",
+ " and (mesh.center[1] - x[1]) > -h / 2 - 0.001 * h\n",
+ " ):\n",
+ " phase_field[node_id] = 0.0\n",
+ "\n",
+ " mesh.point_data[\"phase-field\"] = phase_field\n",
+ " mesh.save(f\"{out_dir}/mesh_full_pf_OGS_pf_ic.vtu\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Run the simulation \n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pyvista as pv\n",
+ "pv.set_plot_theme(\"document\")\n",
+ "if \"PYVISTA_HEADLESS\" in os.environ:\n",
+ " pv.start_xvfb()\n",
+ "pv.set_jupyter_backend(\"static\")\n",
+ "\n",
+ "def sneddon_numerical(h):\n",
+ " #mesh properties\n",
+ " ls = 2*h\n",
+ " #generate prefix from properties\n",
+ " filename = 'results_h_%0.4f'%h\n",
+ " mesh_generation(0.1, h)\n",
+ " # Convert GMSH (.msh) meshes to VTU meshes appropriate for OGS simulation.\n",
+ " input_file = f\"{out_dir}/\"+meshname+\".msh\"\n",
+ " ! msh2vtu --ogs -o {out_dir}/{meshname} {input_file} \n",
+ " # As a preprocessing step, define the initial phase-field (crack).\n",
+ " pre_processing(h,a0)\n",
+ " #change properties in prj file #For more information visit: https://github.com/joergbuchwald/ogs6py\n",
+ " model = ogs.OGS(INPUT_FILE=prj_name, PROJECT_FILE=f\"{out_dir}/{prj_name}\", MKL=True, args=f\"-o {out_dir}\")\n",
+ " model.replace_parameter_value(name=\"ls\", value=ls)\n",
+ " model.replace_text(\"./Kregime_Static.gml\", xpath=\"./geometry\")\n",
+ " model.replace_text(filename, xpath=\"./time_loop/output/prefix\")\n",
+ " model.write_input() \n",
+ " #run simulation with ogs\n",
+ " t0 = time.time()\n",
+ " print(\">>> OGS started execution ... <<<\")\n",
+ " !ogs {out_dir}/{prj_name} -o {out_dir} > {out_dir}/log.txt\n",
+ " tf = time.time()\n",
+ " print(\">>> OGS terminated execution <<< Elapsed time: \", round(tf - t0, 2), \" s.\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2022-12-12 13:24:30.160] [ogs] [\u001b[33m\u001b[1mwarning\u001b[m] Array 'vtkOriginalPointIds' in VTU file uses unsupported data type 'idtype' of size 8. The data array will not be available.\n",
+ "[2022-12-12 13:24:30.161] [ogs] [\u001b[33m\u001b[1mwarning\u001b[m] Array 'vtkOriginalCellIds' in VTU file uses unsupported data type 'idtype' of size 8. The data array will not be available.\n",
+ "[2022-12-12 13:24:30.161] [ogs] [\u001b[32minfo\u001b[m] Reordering nodes... \n",
+ "[2022-12-12 13:24:30.172] [ogs] [\u001b[32minfo\u001b[m] Corrected 0 elements.\n",
+ "[2022-12-12 13:24:30.209] [ogs] [\u001b[32minfo\u001b[m] VTU file written.\n",
+ ">>> OGS started execution ... <<<\n",
+ ">>> OGS terminated execution <<< Elapsed time: 307.0 s.\n"
+ ]
+ }
+ ],
+ "source": [
+ "for h_j in h_list:\n",
+ " sneddon_numerical(h=h_j)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Post processing "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# As a post-process, we calculate the fracture opening.\n",
+ "def width_calculation(filename):\n",
+ " reader = pv.get_reader(f\"{out_dir}/{filename}.pvd\")\n",
+ " # --------------------------------------------------------------------------------\n",
+ " # Active the results of last time step\n",
+ " # --------------------------------------------------------------------------------\n",
+ " reader.set_active_time_value(reader.time_values[-1])\n",
+ " mesh = reader.read()[0]\n",
+ " # --------------------------------------------------------------------------------\n",
+ " # define grad d\n",
+ " # --------------------------------------------------------------------------------\n",
+ " mesh_d = mesh.compute_derivative(scalars=\"phasefield\")\n",
+ " mesh_d[\"gradient\"]\n",
+ "\n",
+ " def gradients_to_dict(arr):\n",
+ " \"\"\"A helper method to label the gradients into a dictionary.\"\"\"\n",
+ " keys = np.array(\n",
+ " [\"grad_dx\", \"grad_dy\", \"grad_dz\", \"grad_dx\", \"grad_dy\", \"grad_dz\"]\n",
+ " )\n",
+ " keys = keys.reshape((2, 3))[:, : arr.shape[1]].ravel()\n",
+ " return dict(zip(keys, mesh_d[\"gradient\"].T))\n",
+ "\n",
+ " gradients_d = gradients_to_dict(mesh_d[\"gradient\"])\n",
+ " mesh.point_data.update(gradients_d)\n",
+ " # --------------------------------------------------------------------------------\n",
+ " # define width at nodes\n",
+ " # --------------------------------------------------------------------------------\n",
+ " disp = mesh.point_data[\"displacement\"]\n",
+ " grad_dx = mesh.point_data[\"grad_dx\"]\n",
+ " grad_dy = mesh.point_data[\"grad_dy\"]\n",
+ " num_points = disp.shape\n",
+ " Wnode = np.zeros(num_points[0])\n",
+ " for i, x in enumerate(mesh.points):\n",
+ " u_x = disp[i][0]\n",
+ " u_y = disp[i][1]\n",
+ " gd_x = grad_dx[i]\n",
+ " gd_y = grad_dy[i]\n",
+ "\n",
+ " Wnode[i] = 0.5 * (u_x * gd_x + u_y * gd_y)\n",
+ " mesh.point_data[\"Wnode\"] = Wnode\n",
+ " # --------------------------------------------------------------------------------\n",
+ " # define width at nodes\n",
+ " # --------------------------------------------------------------------------------\n",
+ " # Normalize the vector\n",
+ " normal = [np.cos(Orientation), np.sin(Orientation), 0]\n",
+ " # Make points along that vector for the extent of your slices\n",
+ " point_a = mesh.center + np.array([1.5 * a0, 0, 0])\n",
+ " point_b = mesh.center + np.array([-1.5 * a0, 0, 0])\n",
+ " dist_a_b = ((point_b[0] - point_a[0]) ** 2 + (point_b[1] - point_a[1]) ** 2) ** 0.5\n",
+ " # Define the line/points for the slices\n",
+ " line = pv.Line(point_a, point_b, n_slices)\n",
+ " width_line = np.zeros(len(line.points))\n",
+ " r_i = np.zeros(len(line.points))\n",
+ " # Generate all of the slices\n",
+ " slices = pv.MultiBlock()\n",
+ "\n",
+ " for i, point in enumerate(line.points):\n",
+ " slices.append(mesh.slice(normal=normal, origin=point))\n",
+ " slice_mesh = mesh.slice(normal=normal, origin=point)\n",
+ " x_slice = slice_mesh.points[:, 0]\n",
+ " y_slice = slice_mesh.points[:, 1]\n",
+ " Wnode_slice = slice_mesh.point_data[\"Wnode\"]\n",
+ " width_i = np.trapz(Wnode_slice, x=y_slice)\n",
+ " if width_i >= 0:\n",
+ " width_line[i] = width_i\n",
+ " r_i[i] = (\n",
+ " (point[0] - point_a[0]) ** 2 + (point[1] - point_a[1]) ** 2\n",
+ " ) ** 0.5 - dist_a_b / 2\n",
+ "\n",
+ " return r_i, width_line"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Sneddon"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def sneddon(h, ls, phasefield_model):\n",
+ " # Effective a for AT1/A2\n",
+ " if phasefield_model == \"AT1\":\n",
+ " a_eff = a0 * (1 + pi * ls / (4.0 * a0 * (3 * h / 8.0 / ls + 1.0)))\n",
+ " elif phasefield_model == \"AT2\":\n",
+ " a_eff = a0 * (1 + pi * ls / (4.0 * a0 * (h / (2.0 * ls) + 1.0)))\n",
+ "\n",
+ " x = np.linspace(-1.0 * a_eff, a_eff, 40)\n",
+ " uy = []\n",
+ " for i in range(len(x)):\n",
+ " uy.append(\n",
+ " 2 * a_eff * (1 - nu**2) * P / E * math.sqrt(1.0 - ((x[i]) / (a_eff)) ** 2)\n",
+ " )\n",
+ "\n",
+ " return x, uy, a_eff"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Opening profile"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "results_h_0.0100\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 640x480 with 1 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "color = [\"-.k\", \"ko\", \"-.r\", \"ro\", \"-.b\", \"bo\", \"-.g\", \"go\"]\n",
+ "Label = [\"Closed form solution\", \"VPF-FEM\"]\n",
+ "lineWIDTH = [1.5, 1.5, 1.5]\n",
+ "\n",
+ "for (j, h_j) in enumerate(h_list):\n",
+ " r_i_num = []\n",
+ " width_line_num = []\n",
+ " filename = \"results_h_%0.4f\" % h_j\n",
+ " print(filename)\n",
+ " width_calculation(filename)\n",
+ " r_i_num = width_calculation(filename)[0]\n",
+ " width_line_num = width_calculation(filename)[1]\n",
+ " ls = 2 * h_j\n",
+ "\n",
+ " x_Sneddon = sneddon(h_j, ls, phasefield_model)[0]\n",
+ " uy_Sneddon = sneddon(h_j, ls, phasefield_model)[1]\n",
+ " a_eff_Sneddon = sneddon(h_j, ls, phasefield_model)[2]\n",
+ " plt.plot(\n",
+ " np.array(x_Sneddon[:]),\n",
+ " np.array(uy_Sneddon[:]),\n",
+ " color[2 * j],\n",
+ " fillstyle=\"none\",\n",
+ " markersize=0,\n",
+ " linewidth=lineWIDTH[0],\n",
+ " label=\"Closed form solution - $h= $%0.4f\" % h_j,\n",
+ " )\n",
+ " plt.plot(\n",
+ " np.array(r_i_num[:]),\n",
+ " np.array(width_line_num[:]),\n",
+ " color[2 * j + 1],\n",
+ " fillstyle=\"none\",\n",
+ " markersize=6,\n",
+ " linewidth=lineWIDTH[1],\n",
+ " label=\"VPF - $h =$%0.4f\" % h_j,\n",
+ " )\n",
+ " # ------------------------------------------------------------------------\n",
+ "plt.rcParams[\"figure.figsize\"] = [40, 20]\n",
+ "plt.rcParams[\"figure.dpi\"] = 1600\n",
+ "plt.ylabel(\"$w_n$ [m]\", fontsize=14)\n",
+ "plt.xlabel(\"$r$ [m]\", fontsize=14)\n",
+ "plt.grid(linestyle=\"dashed\")\n",
+ "plt.title(\"%s\" % phasefield_model)\n",
+ "\n",
+ "legend = plt.legend(bbox_to_anchor=(1.04, 1), loc=\"upper left\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To decrease computing time, we perform the simulation with an one coarse mesh; Mesh sensitivity can be investigated in order to assess the convergence of the opening profile for various mesh discretizations. Following are the mesh sensivity results for for Models $\\texttt{AT}_1$ and $\\texttt{AT}_2$ ($h=0.01,~0.005,~\\text{and} ~0.0025$ m.)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "![Crack opening profiles of VPF ($\\texttt{AT}_1$) with different mesh sizes compared against the Sneddon solution.](./figures/AT1_crackopening_mesh_sensitivity.png#one-half \"Crack opening profiles of VPF ($\\texttt{AT}_1$) with different mesh sizes compared against the Sneddon solution.\")\n",
+ "![Crack opening profiles of VPF ($\\texttt{AT}_2$) with different mesh sizes compared against the Sneddon solution.](./figures/AT2_crackopening_mesh_sensitivity.png#one-half \"Crack opening profiles of VPF ($\\texttt{AT}_2$) with different mesh sizes compared against the Sneddon solution.\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Our mesh size sensitivity study shows even with coarse mesh. The results away from crack tips agree well with the Sneddon solution. Using finer mesh demonstrates that the opening along the whole crack length is accurate compared with the closed-form solution.\n",
+ "\n",
+ "It's worth noting that we estimate width as part of post-processing (using the line integral and a given crack normal vector). However, near crack tips the crack normal vector is different to the given normal vector, so the width values are inaccurate near crack tips. For the sake of simplicity, we neglect determining the normal crack vector here; for more information on the line integral approach, see **Yoshioka et al., 2020**."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## References\n",
+ "\n",
+ "[1] Yoshioka, Keita, Francesco Parisio, Dmitri Naumov, Renchao Lu, Olaf Kolditz, and Thomas Nagel. _Comparative verification of discrete and smeared numerical approaches for the simulation of hydraulic fracturing._ GEM-International Journal on Geomathematics **10**, no. 1 (2019): 1-35.\n",
+ "\n",
+ "[2] Yoshioka, Keita, Dmitri Naumov, and Olaf Kolditz. _On crack opening computation in variational phase-field models for fracture._ Computer Methods in Applied Mechanics and Engineering 369 (2020): 113210.\n",
+ "\n",
+ "[3] Sneddon, Ian Naismith, and Morton Lowengrub. _Crack problems in the classical theory of elasticity._ 1969, 221 P (1969).\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.13"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT1_crackopening_mesh_sensitivity.png b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT1_crackopening_mesh_sensitivity.png
new file mode 100644
index 0000000000000000000000000000000000000000..366baf441b436ed56a01d61dc305c1eae5c2903a
Binary files /dev/null and b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT1_crackopening_mesh_sensitivity.png differ
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT2_crackopening_mesh_sensitivity.png b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT2_crackopening_mesh_sensitivity.png
new file mode 100644
index 0000000000000000000000000000000000000000..bf04212b38e131fef07f08b772715eb52e654303
Binary files /dev/null and b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/AT2_crackopening_mesh_sensitivity.png differ
diff --git a/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/Model_sneddon_straight.png b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/Model_sneddon_straight.png
new file mode 100644
index 0000000000000000000000000000000000000000..3df3ed02844a885dd2c4347613b869ddc98e4da9
Binary files /dev/null and b/Tests/Data/PhaseField/kregime_jupyter_notebook/figures/Model_sneddon_straight.png differ