Skip to content
Snippets Groups Projects
Commit bbe7ecce authored by Rostislav Chudoba's avatar Rostislav Chudoba
Browse files

Tour 7 minor fixes

parent bdf16ab7
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id:1cdb7314-aaae-4b45-8ab9-20c2e6d6e1cc tags:
<a id="top"></a>
# **7.1 Propagation of a straight crack**
%% Cell type:markdown id:0465afaf-c8d1-4604-a9bd-3bd91bb67ca4 tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/start_flag.png" alt="Previous trip" width="50" height="50">
&nbsp; &nbsp; <b>Starting point</b> </div>
%% Cell type:markdown id:564277ba-99b5-43ec-ab94-b448eed57ee0 tags:
In the notebook [6.3](../tour6_energy/6_3_localized_energy_dissipation.ipynb#top) we have analyzed the correspondence between the damage function inducing softening and the propagation of discontinuity macroscopically observable as debonding in a pullout test. We mentioned the correspondence between the locally and globally energy evaluated energy dissipation indicating the energy dissipated at a material point can be used to estimate the total amount of dissipated energy by relating it to a localized crack of a known known surface area. In case of an interface area between two material components, like CFRP sheet and concrete, the area is well defined.
Let us now apply the same concept to a crack propagation through a concrete specimen. Even though additional aspects, like two-dimensional stress and strains states, need to be considered, the general concept of energy dissipation introduced previously remains the similar.
%% Cell type:markdown id:b9526df2-893a-4125-b029-d843b224bae6 tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/destination.png" alt="Previous trip" width="50" height="50">
&nbsp; &nbsp; <b>Where are we heading</b> </div>
%% Cell type:markdown id:cc776d2c-f89a-4c69-8374-93447c23eda8 tags:
In the present notebook we apply the damage model inducing material softening to a two-dimensional case of stable crack propagation. In particular, we are going to use the three-point bending test as a means of rendering an elementary crack-propagation scenario, namely a straight crack propagating through a cross section. After discussing the test setup, we provide the test results in terms of load-deflection curve. Then, we will construct a numerical model that can reproduce such a behavior. Similarly to the previous lecture, we will consider the link between fracture and damage concepts that are both included in any finite element computation involving strain-softening material behavior
%% Cell type:markdown id:d098050e-94a4-4ea3-b817-20e14a132fef tags:
# **Why notched three-point bending test?**
%% Cell type:markdown id:b1e064b7-2688-40a4-83ce-491b6dcabe6d tags:
An isolated tensile crack propagation can be initiated using a notched specimen. The most common configurations used to study the cracking behavior for a tensile crack denoted as mode I are the wedge splitting test and notched, three-point bending test. Both these tests aim to characterize the material behavior in terms of the softening law describing the relation between the tensile stress transmitted across the localization zone and the corresponding crack opening.
Due to its simplicity, three-point-bending test on a notched concrete has become a standard (RILEM) to determine the fracture energy $G_\mathrm{f}$ characterizing the cracking behavior of concrete. The test induces a single crack in the notched section propagating straight upwards from the notch in a stable manner. The energy is dissipated in a local region in the crack vicinity so that it can be directly ascribed to the area of emerging crack surface.
The numerical simulation of this model can be readily performed using the material model with the damage function derived in previous notebooks. An example of the geometry and boundary conditions of the three-point bending test is provided by the [Petersson (1982)](https://portal.research.lu.se/portal/files/4705811/1785208.pdf) test series using the following setup.
%% Cell type:markdown id:0a4edb61-8c07-492a-8f08-82af92bb684d tags:
![image.png](attachment:aa0b3375-f959-416c-ad75-641d96347767.png)
%% Cell type:markdown id:969cea85-7c46-4444-8847-d793f565bc43 tags:
# **Boundary value problem and its FE discretization**
%% Cell type:markdown id:1f7c6217-d72e-4777-a276-1ff5f524da43 tags:
The numerical model simulating this test is assuming a plain stress described by the stress tensor with the enumeration of spatial dimensions using the index variables $a, b$ = [1,2]
$$
\sigma_{ab}
=
\left[
\begin{array}{cc}
\sigma_{xx} & \sigma_{xy} \\
\sigma_{yx} & \sigma_{yy}
\end{array}
\right]
$$
and $\sigma_{zz} = \sigma_{xz} = \sigma_{yz} = 0$. The finite element discretization in this model applies the symmetry condition at the middle section of the beam. Upon loading loading, the damage will localize
at the tip of the notch and propagate upwards.
%% Cell type:markdown id:4ec83d99-9cb1-4f2d-813e-bc3c2ae2acdb tags:
![image.png](attachment:b68d13da-8f97-4a34-bac4-2a9bb271b6c0.png)
%% Cell type:code id:39daf48d-335e-44f7-b95c-8ba901a2e974 tags:
``` python
%matplotlib widget
from bmcs_bending.bending3pt_2d import BendingTestModel
from ibvpy.tmodel.mats2D import MATS2DScalarDamage
bt = BendingTestModel(material_model='scalar damage',
n_e_x=6, n_e_y=16, w_max=-2, k_max=500)
bt.time_line.step=0.03
bt.history.warp_factor=100
bt.cross_section.trait_set(b=50)
bt.geometry.trait_set(L=2000, H=200, a=100, L_cb=1);
```
%% Cell type:markdown id:780cfe67-6a6f-435d-afce-dbb2bc491e76 tags:
# **Material model**
%% Cell type:code id:cda0ba20-eb96-48de-a904-1376d9376a73 tags:
``` python
E = 30000
f_ct = 3.3
kappa_0 = f_ct / E
bt.material_model_.trait_set(E = E, nu = 0.0); # note nu = 0.0 to avoid compressive failure
```
%% Cell type:markdown id:1e94865d-0081-4baa-a0b5-bc0268d82e92 tags:
## Damage function
%% Cell type:markdown id:49ade73c-3541-43a5-9237-2eee0892056e tags:
The exponential damage function with the two parameters $\kappa_0$ defining the onset of damage and $\kappa_\mathrm{f}$ controlling the slope of the exponential softening branch at the onset of damage is defined as follows.
%% Cell type:code id:312961a7-2faf-4589-9907-aff2da127200 tags:
``` python
bt.material_model_.omega_fn = 'exp-slope'
bt.material_model_.omega_fn_.trait_set(kappa_0=kappa_0, kappa_f=0.0200)
```
%% Output
$\displaystyle \begin{cases} 0 & \text{for}\: \kappa \leq \kappa_{0} \\1 - \frac{\kappa_{0} e^{\frac{- \kappa + \kappa_{0}}{- \kappa_{0} + \kappa_\mathrm{f}}}}{\kappa} & \text{otherwise} \end{cases}$
<ibvpy.tmodel.mats_damage_fn.ExpSlopeDamageFn at 0x7fe52ff5d090>
%% Cell type:markdown id:d696e066-9c01-4d81-8ded-43d718177840 tags:
To achieve a fast convergence of the nonlinear simulation, the tangential algorithmic stiffness will be activated by setting the parameter `D_alg = 1`. Note that `D_alg = 0` corresponds to the secant stiffness which requires large number of iterations but can cope with large stress redistribution within the simulated domain.
%% Cell type:code id:76bc7d7b-29cd-4cdf-98c3-0b23b06b808b tags:
``` python
bt.material_model_.trait_set(D_alg=1, eps_max=1);
```
%% Cell type:markdown id:49c01fbc-52ee-419d-b78e-d5905d6fef19 tags:
The important feature of the provided damage model is the possibility to evaluate the fracture energy, i.e. the amount of energy to achieve a zero stress state. This value can be accessed as a `G_f` property of the material model.
%% Cell type:code id:ba59dabe-e27f-4d71-a20b-21ffb3877d3d tags:
``` python
bt.material_model_.G_f
```
%% Output
0.06435413610343986
%% Cell type:markdown id:7541585c-f32d-4954-acfd-d81432fdfd29 tags:
## Strain norm
%% Cell type:markdown id:2a6b3a48-27f9-4fdf-9752-bd42bb9e861a tags:
The scalar damage material model can combine different measures of equivalent strain with a different type of damage function.
The task of the equivalent strain norm is to transform the two-dimensional strain tensor
$$
\varepsilon_{ab}
=
\left[
\begin{array}{cc}
\varepsilon_{xx} & \varepsilon_{xy} \\
\varepsilon_{yx} & \varepsilon_{yy}
\end{array}
\right]
$$
to a scalar value $\kappa$. The equivalent strain norms already mentioned in the notebook [5.1](../tour5_damage_bond/5_1_Introspect_Damage_Evolution_Damage_initiation.ipynb#strain_norm) play the role of an elastic limit. Their visual inspection
can be performed using the model component of the material model `MATSScalarDamage`.
%% Cell type:code id:0b3773c1-edc6-4952-a414-a0e5f1e41f91 tags:
``` python
bt.material_model_.strain_norm = 'Rankine'
bt.material_model_.strain_norm_.interact()
```
%% Output
%% Cell type:markdown id:db2febf3-5dbb-4199-bf91-495614a79d4d tags:
Further strain norms can be chosen from the options
- Rankine strain norm
- Masar's strain norm
- Energy norm
These norms have to be combined with an elastic threshold to distinguish the elastic and inelastic domains.
Inspect the visual representation of the equivalent strain measure by changing the selector in the material model app. (It is necessary to select the respective tree node to render the visualization of the currently selected option.)
%% Cell type:code id:8dd4a96a-e8b6-4cbc-9f71-bdf0f680b35d tags:
``` python
bt.material_model_.interact()
```
%% Output
%% Cell type:markdown id:58a74adf-61e5-4e1d-859c-f3655491c3f0 tags:
The mathematical expression delivering the three provided strain norms look as follows:
**Masars strain norm:**
$$
\kappa = \sqrt{ \sum_{I=1}^{3} \left< \varepsilon_I \right>^2 } = \sqrt{ \left< \varepsilon_I \right>^2\delta_{II} }
$$
where $\varepsilon_I$ denotes the principal strains. The second version of the expression uses the index notation with a summation over an index that repeats in a product of two terms (see [Einstein summation rule](https://en.wikipedia.org/wiki/Einstein_notation)). The symbol $\delta_{II}$ represents an identity mapping called Kronecker delta, with $\delta_{IJ} = 1$ if $I=J$ and $\delta_{IJ} = 0$ otherwise.
%% Cell type:markdown id:265a0444-bcae-47bb-87ed-e2d74733f612 tags:
**Rankine strain norm:**
$$
\kappa = \dfrac{1}{E} \max_{I=1}^{3} \sigma_I
$$
where $\sigma_I$ are the principal values of the stress tensor, i.e.
$$\sigma_{ab} = D^\mathrm{el}_{abcd} \varepsilon_{cd}
$$
**Energy norm**
$$
\kappa = \dfrac{1}{E} \sqrt{ \boldsymbol{\varepsilon} : \boldsymbol{D}^\mathrm{el}: \boldsymbol{\varepsilon} }
= \dfrac{1}{E} \sqrt{ \varepsilon_{ab} D^\mathrm{el}_{abcd} \varepsilon_{cd} }
$$
representing circular or spherical shape of the elastic domain in 2D or 3D, respectively.
%% Cell type:markdown id:d5e41956-14c6-4ad1-ac42-c4b8b66b15fc tags:
## The importance of algorithmic stiffness
%% Cell type:markdown id:382aac37-21a3-4c94-b245-48e353f576d3 tags:
The rate of convergence strongly depends on the quality of prediction of the stress state for the next step. The parameter `D_alg` can be used ton control the calculation by choosing between the secant and algorithmic, tangential stiffness. Derivation of the material stiffness might appear tedious at the first sight but in fact, it only requires the evaluation of the chain derivatives involved in the constitutive law.
%% Cell type:markdown id:d06b9560-012b-40ce-918a-7f93c60dbc97 tags:
Let us exemplify the derivation of the algorithmic material stiffness on the example of the isotropic damage model. In contrast to the version presented in notebook [5.1]() for the bond-slip law, we are applying the damage model to a 2D continuum described by the strain and stress tensor tensors $\boldsymbol{\varepsilon} = \varepsilon_{ab}$
and $\boldsymbol{\sigma} = \sigma_{ab}$, where letter indexes $a,b,c,d = [1,2]$ enumerate the orthogonal directions of the cartesian coordinate system. For example, $\varepsilon_{11} = \varepsilon_{xx}$. Then the stress-strain relation prescribed by the damage model is given as
%% Cell type:markdown id:d93e03f8-4d44-4316-b8db-c160517b8430 tags:
\begin{align}
\sigma_{ab} = (1 - \omega(\kappa(\varepsilon_{cd}))) D_{abcd}^\mathrm{el} \varepsilon_{cd}
\end{align}
%% Cell type:markdown id:0db20967-ba8d-426e-a1f8-dfbf6780fc45 tags:
where $\kappa(\varepsilon_{cd})$ represents the equivalent strain described above, and $\omega(\kappa)$ represents the particular damage function. The algorithmic stiffness is derived as the derivative of the above stress tensor with respect to a strain tensor. This means that every stress component must be differentiated with respect to every strain component. The result of this expression is a rank 4 tensor $D_{abcd}$ describing the instantaneous stiffness of a material point undergoing damage. The resulting expression delivers the material stiffness in the following form
%% Cell type:markdown id:d6ab78b9-00d0-4a8d-803a-111b10e920b4 tags:
\begin{align}
D_{abcd} &= \dfrac{\mathrm{d} \sigma_{ab}}{\mathrm{d}\varepsilon_{cd}} \\
& =
\left(1 - \omega(\kappa(\varepsilon_{cd}))\right) D_{abcd}^\mathrm{el} -
\dfrac{\mathrm{d} \omega}{\mathrm{d}\kappa}
\dfrac{\partial \kappa}{\partial\varepsilon_{cd}} D_{abcd}^\mathrm{el} \, \varepsilon_{cd} \, \theta_\mathrm{alg,stiff}
\end{align}
%% Cell type:markdown id:4795a44a-a0cd-41cf-a55f-32be19e84454 tags:
The parameter `D_alg` is denoted here as $\theta_{\mathrm{alg,stiff}}$ and is provided as an input parameter in the material model. By setting this parameter to zero, the second term in the above expression is canceled. Then, only the secant stiffness is available. The importance of the algorithmic stiffness can be studied in the simulation of the bending test. The default value $\theta_\mathrm{alg,stiff} = 1$ is activating the algorithmic stiffness. By setting $\theta_\mathrm{alg,stiff} = 0$ one can see the strong reduction of the performance.
%% Cell type:markdown id:a33174d1-fd84-4ca9-924c-a500ee83f47f tags:
However, in some situation, for example when simulating simultaneous crack propagation in reinforced specimens the tangential stiffness might induce divergence. The reason for such behavior is the fact that the bond stress can rapidly change the sign. In these situations, advanced control strategies are required.
%% Cell type:markdown id:8c12acf6-65fa-4655-bca6-1248c21b4de4 tags:
# **Simulation example**
%% Cell type:code id:aba5b31e-bdfb-4446-ba3b-bae4f01d91e6 tags:
``` python
bt.material_model_.strain_norm='Rankine'
bt.run()
```
%% Cell type:code id:bf30823c-3ed8-4e8b-a84c-23cc25c8e094 tags:
``` python
bt.interact()
```
%% Output
%% Cell type:markdown id:383468cb-a8bd-4f47-96f8-c0f9769deb28 tags:
## Evaluation of energy dissipation
%% Cell type:markdown id:9c3028e4-f16b-4d7c-8020-0fa13fade796 tags:
If a standard finite element discretization is combined with a softening material model,
1. it will always induce localization into a band of finite elements at the propagating stress concentration.
2. the area below the stress strain curve of a material model represents the energy dissipated by a unit volume of a material.
As a consequence, the total amount of the dissipated energy can be calculated as a product of the specific dissipation energy $G_\mathrm{f}$ $\mathrm{[J/mm^3]}$ and the volume of elements constituting the crack band $V_\mathrm{diss}$ $\mathrm{[mm^2]}$. In general,
$$
G_\mathrm{total} = G_\mathrm{f} V_\mathrm{diss}
$$
In a notched bending test, the crack band is running from the notch straight through the cross section. Therefore, it is possible to directly calculate the dissipative volume $V_\mathrm{diss}$ as
$$
V_\mathrm{diss} = (H - a) B L_\mathrm{cb}
$$
%% Cell type:code id:752906fd-2a8a-44ec-b77c-9e3a496f9c0f tags:
``` python
V_diss = (bt.geometry.H - bt.geometry.a)*bt.cross_section.b * bt.geometry.L_cb
V_diss
```
%% Output
5000.0
%% Cell type:markdown id:9dc0bd1a-7a3e-497b-bb63-0e0c239c1baa tags:
The specific energy $G_\mathrm{f}$ is available as an attribute of the material model. It has the value
%% Cell type:code id:ec96f0ce-0f91-4d3a-8d59-d3cedb3a9f9c tags:
``` python
bt.material_model_.G_f # J/mm^2
```
%% Output
0.06435413610343986
%% Cell type:markdown id:21b49bb5-cc8d-43d7-82f9-74a80a44f06b tags:
Thus, the total dissipated energy should read
%% Cell type:code id:8265609d-ed22-4240-a1ac-22bd025137a8 tags:
``` python
G_total = V_diss * bt.material_model_.G_f
G_total
```
%% Output
321.7706805171993
%% Cell type:markdown id:9a257535-82e4-451e-8b8f-82ee2a4cc686 tags:
The total dissipated energy is available in the `hist` model component as a last element of the recorded array, so that we can pick it using the index `-1`
%% Cell type:code id:e5e6854c-6ec7-43a7-b4bc-d6a725af6b79 tags:
``` python
import numpy as np
bt.hist.W_t[-1]
```
%% Output
282.5506041549446
%% Cell type:markdown id:2e354956-a60f-445f-8e8f-a7b21ce4c1ce tags:
# **Parametric study**
%% Cell type:markdown id:3479d206-6b40-4b8b-aef7-95143d0bb3fa tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/run.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <b>Run in a loop along the changing width of the crack band</b> </div>
%% Cell type:code id:fd5696fa-725e-4c7b-bac8-f263bdf532d3 tags:
``` python
Fw_dict = {}
G_dict = {}
```
%% Cell type:code id:c83a2693-4fbe-4ce8-a3eb-0a281430f1b7 tags:
``` python
L_cb_list = [1, 2, 4]
for L_cb in L_cb_list:
if Fw_dict.get(L_cb):
continue
print('calculating F-w and G for crack band L_cb = %g [mm]' % L_cb)
bt.reset()
bt.geometry.L_cb = L_cb
bt.run()
Fw_dict[L_cb] = bt.hist['Fw'].Fw
G_dict[L_cb] = bt.hist['energy'].G_t[-1]
```
%% Output
calculating F-w and G for crack band L_cb = 1 [mm]
calculating F-w and G for crack band L_cb = 2 [mm]
calculating F-w and G for crack band L_cb = 4 [mm]
%% Cell type:markdown id:6bdc3565-8107-4459-81ca-653b7c179da0 tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/view.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <b>... let us put the results into a diagram</b> </div>
%% Cell type:code id:cf30a1f8-7eae-4aa4-8101-fe8337c6cba8 tags:
``` python
import matplotlib.pylab as plt
fig, (ax, ax_G) = plt.subplots(1,2, figsize=(8,3), tight_layout=True)
fig.canvas.header_visible=False
for L_cb, (F, w) in Fw_dict.items():
ax.plot(-w,-F,label='L_cb = %g' % L_cb)
ax.legend()
ax.set_xlabel(r'$w$ [mm]');
ax.set_ylabel(r'$F$ [N]');
G_list = [G_dict[L_cb] for L_cb in L_cb_list]
ax_G.plot(L_cb_list, G_list, marker='H')
ax_G.set_xlabel(r'$L_\mathrm{c}$ [mm]')
ax_G.set_ylabel(r'$G_\mathrm{total}$ [kJ]');
ax_G.set_ylim(ymin=0, ymax=1.1 * np.max(G_list))
```
%% Output
(0.0, 1150.9964986034481)
%% Cell type:markdown id:21f31d44-8b2c-4d8c-9489-1a7eb97e356c tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/caveat.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <b>... mesh dependent results</b> </div>
%% Cell type:markdown id:e8e3d7e5-f4ad-4937-a582-4790ca86b2f0 tags:
By changing the element size within the crack band we change the volume of material which dissipates energy. As observed, a larger element size leads to a larger amount of energy dissipation which makes the structural response more ductile. Why does it happen? The displacement approximated within a finite element is continuous function. Using low-order elements, with, e.g. bilinear shape functions, means that the strain within the element is of even lower order, i.e. constant or linear. Therefore, strain cannot localize within a smaller size than the size of the element through which the crack propagates. As a consequence, upon softening, an element exhibits a nearly uniform increasing strain which results in energy dissipation over its whole volume. The obtained results are therefore biased by the mesh size which documents an ill-posed model behavior.
There are several techniques how to avoid this mesh dependency. The principle idea of these so called regularization methods is to ensure a prescribed amount of energy dissipation upon localization. The most simple technique is sketched and demonstrated in the following parametric study.
%% Cell type:markdown id:68f2a220-525a-4fc1-9209-eee1a98dd276 tags:
# **How to make the results mesh independent?**
%% Cell type:markdown id:83a6019b-7909-499c-8050-b2748563d382 tags:
The finite element codes solve this problem by adjusting the slope of the softening branch to keep the energy dissipation within a crack band invariant for a changed size of an element. This is the most common technique used in commercial finite element codes.
%% Cell type:markdown id:4a7904f7-2bf8-48db-bf3f-2fb8c598a8ba tags:
The above examples explain that the correspondence between the local value of $G_\mathrm{f}$ and the total energy $G_\mathrm{total}$ is established by realizing that energy dissipation is linked with the crack propagation. Indeed, if $G_\mathrm{f}$ is related to a unit area of the crack surface, the total energy dissipation in the whole test with a localized crack of the area $V_\mathrm{diss}$ is
obtained as
$$
G_\mathrm{total} = G_\mathrm{f} V_\mathrm{diss}.
$$
%% Cell type:markdown id:072277b8-b0c9-41ce-afbf-fe38be9c8ee8 tags:
In the above example, the crack was represented by a band of elements with the width specified by the $L_\mathrm{cb}$ model parameter. Since the crack developed over the whole notched cross section, we can express the dissipative volume as
%% Cell type:markdown id:7db41e2b-79d2-4b5b-a2d2-6291b3cd7b19 tags:
$$
V_\mathrm{diss} = (H - a) B L_\mathrm{cb}
$$
%% Cell type:markdown id:a242081d-0ae5-4d7d-b755-c6e472446d31 tags:
To ensure that the amount of dissipated energy for a changed $V_\mathrm{diss}$ due to different mesh size does not change, we need to correspondingly adjust effective value of dissipated energy in depending on $L_\mathrm{cb}$. In other words, we need to introduce
$$
G_\mathrm{f}^{L_\mathrm{cb}} = \dfrac{G_\mathrm{f}}{L_\mathrm{cb}}
$$
so that the total energy becomes independent on $L_\mathrm{cb}$
$$
G_\mathrm{total} = G_\mathrm{f}^{L_\mathrm{cb}} (H-a) B L_\mathrm{cb}
= G_\mathrm{f} (H-a) B.
$$
%% Cell type:markdown id:052c3446-73d5-48ec-9e31-3b640d62e2c7 tags:
This scaling must be achieved by adjusting the material parameters of the model depending on the size of the discretization element $L_\mathrm{cb}$. In present model we use the exponential damage function with the two parameters $\kappa_0$ and $\kappa_\mathrm{f}$ controlling the onset of damage and the slope of the descending branch, respectively. The above specified scaling of energy dissipation can be achieved by scaling the parameter
$$
\kappa_{\mathrm{f}}^{L_\mathrm{cb}} = \dfrac{\kappa_{\mathrm{f}}}{L_\mathrm{cb}}
\implies
G_\mathrm{f}^{L_\mathrm{cb}} \approx \dfrac{G_\mathrm{f}}{L_\mathrm{cb}}
$$.
%% Cell type:markdown id:dc7d789f-201b-4a9c-9c12-1793ae7d11e5 tags:
To verify, that this scaling correspondingly affects the effective amount of energy dissipation by evaluating the value of $G_{\mathrm{f}}^{L_\mathrm{cb}}$ for the values of $L_\mathrm{cb} = [1,2,3,4]$. These values should lead to the corresponding fractions [$1, \frac{1}{2}, \frac{1}{3}, \frac{1}{4}$] of $G_\mathrm{f}$. Assuming the reference value $\kappa_f$ corresponding to the length $L_\mathrm{cb} = 1$ we obtain
%% Cell type:code id:ba4e5e08-1bd1-447b-864d-51121cc9fbaa tags:
``` python
kappa_f = 0.0336 # reference value of kappa for L_cb = 1
kappa_f_range = kappa_f / np.array([1,2,3,4])
G_f_range = []
for kappa_f_ in kappa_f_range:
bt.material_model_.omega_fn_.kappa_f = kappa_0 + kappa_f_
G_f_range += [bt.material_model_.G_f]
np.array(G_f_range) / G_f_range[0]
```
%% Output
array([1. , 0.49416785, 0.32557841, 0.24129989])
%% Cell type:markdown id:2711a80a-b87e-4739-b4a6-e4608bdf4853 tags:
Which roughly correspond to the desired fractions
%% Cell type:markdown id:f4a93e45-ad34-4485-bf75-b7e7a46150ee tags:
Let us now apply this scaling by changing a single line in the parametric study. This line is denoted as `REGULARIZATION`.
%% Cell type:code id:3e2fc748-3c89-4e84-af7c-84f3f3f40632 tags:
``` python
Fw_reg_dict = {}
G_reg_dict = {}
```
%% Cell type:code id:0e49628e-0d75-4a92-a1e9-74386de668fc tags:
``` python
L_cb_list = [1, 2, 4]
kappa_f = 0.0336
for L_cb in L_cb_list:
if Fw_reg_dict.get(L_cb):
continue
print('calculating F-w and G_total for crack band L_cb = %g [mm]' % L_cb)
bt.reset()
bt.geometry.L_cb = L_cb
bt.geometry.L_cb = L_cb # change the size of the crack band
bt.material_model_.omega_fn_.kappa_f = kappa_f / L_cb #### REGULARIZATION ####
print('with scaled effective specific dissipation energy G_f', bt.material_model_.G_f)
try:
bt.run()
except StopIteration:
print('simulation interupted due to slow convergence', L_cb)
Fw_reg_dict[L_cb] = bt.hist['Fw'].Fw
G_reg_dict[L_cb] = bt.hist['energy'].G_t[-1]
```
%% Output
calculating F-w and G_total for crack band L_cb = 1 [mm]
with scaled effective specific dissipation energy G_f 0.1092317778327407
calculating F-w and G_total for crack band L_cb = 2 [mm]
with scaled effective specific dissipation energy G_f 0.053795255499048136
calculating F-w and G_total for crack band L_cb = 4 [mm]
with scaled effective specific dissipation energy G_f 0.02608239216637152
%% Cell type:code id:bc7eb155-af93-45db-b1c8-7237afbffb1f tags:
``` python
import matplotlib.pylab as plt
fig, (ax, ax_G) = plt.subplots(1,2, figsize=(8,3), tight_layout=True)
fig.canvas.header_visible=False
for L_cb, (F, w) in Fw_reg_dict.items():
ax.plot(-w,-F,label='L_cb = %g' % L_cb)
ax.legend()
ax.set_xlabel(r'$w$ [mm]');
ax.set_ylabel(r'$F$ [N]');
G_list = [G_reg_dict[L_cb] for L_cb in L_cb_list]
ax_G.plot(L_cb_list, G_list, marker='H')
ax_G.set_xlabel(r'$L_\mathrm{cb}$ [mm]')
ax_G.set_ylabel(r'$G_\mathrm{total}$ [kJ]');
ax_G.set_ylim(ymin=0, ymax=1.1 * np.max(G_list));
```
%% Output
%% Cell type:markdown id:21c01b03-1871-4979-adb4-6355d4086438 tags:
Even though the difference in the predicted peak of the load deflection curve shown left is still apparent, the amount of dissipated energy up to the control displacement of $w=2$ mm does not change with the element size any more. Let us remark that the applied scaling of $\kappa_\mathrm{f}$ was only approximate. A more sophisticated scaling and a smaller size of load increment would be required to achieve even a better match of the load deflection curves.
%% Cell type:markdown id:d691b328-6926-4ce6-a4e8-6154f7465ed8 tags:
The described kind of scaling can be found in the most common finite-element codes. In the present example, the position and profile of the crack was known a-priori. Finite element codes implementing material models with softening behavior must implement a general procedure for the described crack band regularization. This regularization is performed in each material point by including the size of the containing element and the orientation of principle strains to reflect the width of the softening zone correctly.
The described procedure can be regarded as a _quick fix_. It makes the standard finite-element method applicable to simulation cracking for problems with straight crack evolution, i.e. tensile cracks. It is, however, insufficient for crack propagation with non-negligible shear stress within the localization zone. Indeed, most of the commercially available software based on continuous finite-element approximation of the displacement field cannot correctly predict the shear crack propagation. Pragmatic solutions, including an additional parameter like a shear retention factor, are provided in some software packages (ATENA).
More advanced methods address the problem of mesh independence using
- Nonlocal averaging of state variables over a defined size of a process zone
- Gradient methods of damage and plasticity including the gradient of state variables into the constitutive law
They are mentioned here for completeness and as an optional further reading.
%% Cell type:markdown id:f63aca65-a261-4bb1-b9eb-e605bfff4190 tags:
**Note the dimensionality of $G_\mathrm{f}$:** To be precise, let us note that in contrast to the example shown in notebook [6.3](tour6_energy/6_3_localized_energy_dissipation.ipynb) for the CFRP pullout simulation, the damage function was applied to the bond-slip law, describing the behavior of a unit area of the interface. On the other hand, in the present notebook, we applied the damage function in a two-dimensional constitutive law.
%% Cell type:markdown id:cdc804ad-d583-44ad-9376-be203876faf3 tags:
<div style="background-color:lightgray;text-align:left;width:45%;display:inline-table;"> <img src="../icons/previous.png" alt="Previous trip" width="50" height="50">
&nbsp; <a href="../tour6_energy/6_3_localized_energy_dissipation.ipynb#top">6.3 Softening and fracture energy</a>
</div><div style="background-color:lightgray;text-align:center;width:10%;display:inline-table;"> <a href="#top"><img src="../icons/compass.png" alt="Compass" width="50" height="50"></a></div><div style="background-color:lightgray;text-align:right;width:45%;display:inline-table;">
<a href="../tour7_cracking/7_2_fracture_energy_ident.ipynb#top">7.2 Identification of fracture energy</a>&nbsp; <img src="../icons/next.png" alt="Previous trip" width="50" height="50"> </div>
%% Cell type:code id:a8412fb5-e582-4c05-9340-b8c399f67d42 tags:
``` python
```
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment