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

update of exercise 3.4

parent 3420b052
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id:73893c57-4e0f-4f4a-b626-e9450ecc9a47 tags:
# Notebook supporting exercise X0304
Explain the inverse relation between ductility interface and ductility of the structure
Hardening bond-slip law can be regarded as ductile phenomenon. In the first branch of the constitutive law (shear stress – slip) grows until it reaches the elastic limit. After that, the shear stress either remains constant or further slowly increases with an increasing slip in the respective material point.
Figure
%% Cell type:markdown id:ec0fc4d4-e7f9-446b-83b3-e38c196787bb tags:
Explain how does the interface ductility influence the structural ductility of the pullout response or even of a tensile test. Some experts say, that by increasing the stress-strain ductility (i.e. the hardening) of an interface at the level of a material point it is possible to increase the structural ductility, i.e. to obtain larger deformation at failure. However, this is not the case. Explain why. You can use this notebook to support your explanation by the stress profiles at fiber rupture of the pullout test
%% Cell type:code id:d198c000-aaba-420f-bb4e-71d4fee6e737 tags:
``` python
%matplotlib widget
import matplotlib.pylab as plt
import numpy as np
from bmcs_cross_section.pullout import PullOutModel1D
```
%% Cell type:markdown id:08fbd1b1-8f48-4189-b85f-08852c870bdc tags:
Constract a model with the trilinear bond-slip law
%% Cell type:code id:32539418-1076-44c5-bcfd-be07823b1193 tags:
``` python
po_trc = PullOutModel1D(n_e_x=100, w_max=2.3) # mm
po_trc.geometry.L_x = 500
po_trc.time_line.step = 0.05
po_trc.cross_section.trait_set(A_m=1543, A_f=16.7, P_b=10)
po_trc.material_model='trilinear'
po_trc.material_model_.trait_set(E_m=28000, E_f=170000, tau_1=5.5, tau_2=5.5, s_1=0.07, s_2=6)
po_trc.material_model_.interact()
```
%% Cell type:markdown id:c4c01ad7-1e7f-4f9a-bc5d-2d2137e4c1fc tags:
Show the response for `tau_2 = 5.5` MPa
%% Cell type:code id:ccb47fb4-03fb-40bb-aaa1-988660e71109 tags:
``` python
po_trc.material_model_.tau_2 = 5.5 # MPa
po_trc.run()
po_trc.interact()
```
%% Cell type:markdown id:96da92b1-dc4b-4dcf-aef6-b157bd2327d1 tags:
Optically determine at which displacement does the fiber break. The ultimate force is given as the product of the strength and cross-sectional area
%% Cell type:code id:8425a30b-da92-4094-9d44-1b0b68e4165a tags:
``` python
f_trc_t = 1300 # [MPa]
P_fu = po_trc.cross_section.A_f * f_trc_t # [N]
P_fu / 1000 # [kN]
```
%% Cell type:markdown id:51372c58-2a6d-4ae9-8093-022df704d4fc tags:
Now, how does the pull-out displacement change if you increase the hardening slope to `tau_2 = 10` MPa?
Provide an explanation of your answer before verifying using the following code
%% Cell type:code id:0f0fe225-8cf6-4846-9d92-ba1f562e2faf tags:
``` python
# po_trc.material_model_.tau_2 = 10.0 # MPa
# po_trc.run()
# po_trc.interact()
```
%% Cell type:markdown id:40119ceb-27f9-430f-9986-9ce39d8e2a87 tags:
Finally, you can run the evaluation in a loop to see the effect even for softening bond-slip laws
%% Cell type:code id:0f206477-247a-4a09-9877-10fa9269d32d tags:
``` python
tau_list = [0.0, 2, 3, 5.5, 8, 12, 16]
Pw_list = []
po_trc.w_max = 2.3
for tau_2 in tau_list:
print('evaluating pullout curve for tau_2', tau_2)
po_trc.material_model_.tau_2=tau_2
po_trc.reset()
po_trc.run()
Pw_t = po_trc.history.get_Pw_t()
Pw_list.append(Pw_t)
```
%% Cell type:code id:f61a5d31-f96c-4d22-8273-89fa7d58f420 tags:
``` python
%matplotlib widget
fig, (ax, ax_w_fu) = plt.subplots(1,2, figsize=(10,4), tight_layout=True)
fig.canvas.header_visible = False
w_fu_list = []
for Pw_t, tau, color in zip(Pw_list, tau_list, ['red','green','blue','black','orange','gray', 'yellow']):
P_range, w_unloaded, w_loaded = Pw_t
ax.plot(w_loaded, P_range/1000, color=color, linestyle='solid', label=r'$\tau_2$ = %d' % tau)
ax.plot(w_unloaded, P_range/1000, color=color, linestyle='dashed')
arg_fu = np.argmax( P_range > P_fu )
w_fu = w_loaded[arg_fu] # mm
w_fu_list.append(w_fu)
print(tau_list, w_fu_list)
# Plotting
ax.set_xlabel(r'half of crack opening $w/2$ [mm]'); ax.set_ylabel(r'$P$ [kN]')
ax.legend()
ax_w_fu.plot(tau_list, w_fu_list, 'o-', color='blue', label=r'$P_\mathrm{max}$')
ax_w_fu.set_xlabel(r'residual shear (ductility) $\tau_2$ [MPa]')
ax_w_fu.set_ylabel(r'failure displacement $w_\mathrm{fu}$ [mm]')
ax_w_fu.set_xlim(xmin=0); ax_w_fu.set_ylim(ymin=0)
ax.plot([0, 2.3], [P_fu/1000, P_fu/1000], linestyle='dashed', linewidth=1, color='red', label='breaking force' );
# ax_w_fu.plot([0, 350], [P_fu/1000, P_fu/1000], linestyle='dashed', linewidth=1, color='red', label='breaking force' );
ax_w_fu.legend();
```
%% Cell type:code id:c0385e43-2b56-4bb7-9d1f-d4cca752fef5 tags:
``` python
```
......@@ -331,9 +331,9 @@
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"display_name": "bmcs_env2",
"language": "python",
"name": "python3"
"name": "bmcs_env2"
},
"language_info": {
"codemirror_mode": {
......
%% Cell type:markdown id: tags:
<a id="top"></a>
# **3.1 Nonlinear bond - softening and hardening**
<!-- [![title](../fig/bmcs_video.png)](https://moodle.rwth-aachen.de/mod/page/view.php?id=551816)&nbsp; part 1 -->
%% Cell type:code id: tags:
``` python
from IPython.display import YouTubeVideo
YouTubeVideo('M7JZNVzrgko')
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/start_flag.png" alt="Previous trip" width="40" height="40">
&nbsp; &nbsp; <b>Starting point</b> </div>
%% Cell type:markdown id: tags:
By saying that we want to capture the _material behavior_ we mean
that we realistically describe the **constitutive relation** between the strain and stress which is **valid for
any material point** of the considered volume. With the focus on a one-dimensional interface between two material
components we can reduce this task to the relation between bond stress and slip.
In Tour 2, we assumed the constitutive bond-slip relation constant. However, as we have learned
in trip [2.1 Pull-out of elastic fiber from rigid matrix](../pull_out/2_1_1_PO_observation.ipynb)
this stick-slip interface behavior cannot realistically describe the experimentally measured
response of steel-concrete pull-out with varied length of the bond length $L_b$.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/destination.png" alt="Previous trip" width="40" height="40">
&nbsp; &nbsp; <b>Where are we heading</b> </div>
%% Cell type:markdown id: tags:
To improve the quality of the model, in this notebook we introduce and investigate more complex shapes of bond slip laws and their effect on the observed pullout response. This extension will enable a more **realistic
prediction of a wide range of pull-out and crack bridge tests**, including
steel rebars, carbon textile fabrics or carbon fiber reinforced polymer (CFRP) sheets.
Using the models, we will perform automated studies of the pull-out response that can demonstrate the different phenomenology behind hardening and softening constitutive behavior.
These studies indicate how validated models can support the definition of engineering design rules.
%% Cell type:markdown id: tags:
To proceed in small steps we consider two shapes of constant bond-slip law, referred to as **bond-hardening and bond softening**.
![image.png](attachment:9086d2ee-b436-406a-aae8-44f90e71f5b3.png)
%% Cell type:markdown id: tags:
The increasing/hardening or decreasing/softening trend of the bond-slip law in the second branch introduces the question, what kind of **material structure** within the bond zone can induce such type of behavior. An example of an idealized bond system leading to hardening or softening can be provided using a rough surface with an increasing or decreasing number of asperities. A more detailed classification of the bond systems will be shown in Tour 3 which provides a more physically based description of the debonding process. The question studied in this notebook is **what is the qualitative effect of the second bond-slip slope on the pull-out response.**
%% Cell type:markdown id: tags:
# **Numerical support necessary**
To solve a pullout problem for a generally nonlinear bond-slip law, we have to solve
the initial boundary value problem numerically. In this notebook, we will use a finite-element code
implemented within the BMCS tool to study the behavior for two examples of qualitatively different bond-slip laws.
%% Cell type:markdown id: tags:
**Solution algorithm:** To study of the effect of the nonlinear bond-slip law on
the pullout response we will use the finite-element method solving the nonlinear response of the pull-out test by stepping through the loading history. Let us therefore briefly touch the topic of the solution algorithm needed to solve such a nonlinear problem boundary value problem of continuum mechanics. Generally, a non-linear finite element solver includes the solution of two separate tasks:
- **Time stepping** algorithm that can identify the material state variables satisfying the constitutive law for a prescribed loadincrement in all points of the domain using an iterative Newton-type algorithm.
- Find the **spatial distribution** of the displacement field satisfying the equilibrium, compatibility and boundary conditions using the finite-element discretization.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/bus.png" alt="Diver" width="40" height="40">
&nbsp; &nbsp; <b>Short sidetrip</b> </div>
## Time-stepping - Newton method to solve a set of nonlinear equations
The Newton method is the basis of all nonlinear time-stepping algorithms used in finite-element codes.
Let us explain the solution procedure by considering a very short bond length $L_\mathrm{b}$x and denote it as a material point $m$ for which a constant profile of the shear stress $\tau(x) = \tau_m$ and slip $s(x) = s_m$ can be assumed.
![image.png](attachment:fcf8bea4-2c06-4931-b39d-47e53c0d6dda.png)
The iterative time-stepping algorithm with increasing load levels can now be displayed for single unknown displacement variable $w$ which must satisfy the equilibrium condition $\bar{P}(t) = P(w)$, where $\bar(P)$ is a prescribed history of loading. A simple implementation of the time stepping procedure exemplifying the solution procedure for a nonlinear equation is provided for an interested tourist in an Annex notebook [A.2 Newton method](../extras/newton_method.ipynb).
![image.png](../fig/newton_iteration.png)
In a real simulation of the pull-out problem, the unknown variable is not a slip but the displacement fields $u_\mathrm{m}, u_\mathrm{f}$ are the primary unknowns. They are transformed to corresponding component strains $\varepsilon_\mathrm{m}=u_{\mathrm{m},x}, \varepsilon_\mathrm{f}=u_{\mathrm{f},x}$, and slip $s = u_\mathrm{m} - u_\mathrm{f}$. In the following examples, the component strains are still assumed linear elastic while the bond/shear stress is assumed generally nonlinear. With the known stress fields, the corresponding forces are obtained using numerical integration which deliver the residuum of the global equilibrium condition. The solution scheme described for a single variable in the notebook [A.2](../extras/newton_method.ipynb#newton_iteration_example) remains the same.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/diver.png" alt="Diver" width="40" height="40">
&nbsp; &nbsp; <b>Deep dive</b> </div>
%% Cell type:markdown id: tags:
## Spatial solver - boundary value problem solved using the finite element method
The identification of the displacements within each equilibrium iteration includes the same conditions that we have applied to derive the analytical solution of the pull-out problem with a constant bond slip law. However, the discrete solution satisfies the equilibrium conditions only approximately in a _week sense_. This means that the local differential equilibrium condition is not satisfied everywhere but only in integration points.
%% Cell type:markdown id: tags:
To provide an insight into the way how do the finite-element tools solve the problem, an open implementation of the nonlinear solver used in this and later notebooks is described completely with a running example, plots and animation in a notebook [A.3 Finite element solver for a pull-out problem](../extras/pullout1d.ipynb). This notebook is an Annex to the course and is meant for ambitious adventurers who want to see how the most finite-element programs available on the market are implemented. Detailed explanation of the theoretical background is provided in the Master's courses on linear structural analysis focused on the theoretical background of the finite-element method and on the nonlinear structural analysis.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/binoculars.png" alt="Traveler in a hurry" width="40" height="40">
&nbsp; &nbsp; <b>Distant view</b> </div>
%% Cell type:markdown id: tags:
## Example of the finite-element pull-out simulation
To understand the functionality of the finite-element model implemented in the referenced notebook [A.3](../extras/pullout1d.ipynb), its output is provided here in form of the pull-out curve and of the fields along the bond zone. The applied boundary conditions are given as follows, the free length $L_\mathrm{f}=0$, the matrix is supported at the loaded end.
%% Cell type:markdown id: tags:
![image.png](attachment:image.png)
%% Cell type:code id: tags:
``` python
from IPython.display import HTML
html_video_file = open('../extras/pull_out_animation.html','r')
HTML(html_video_file.read())
```
%% Cell type:markdown id: tags:
## What constitutive law can induce such a debonding process?
%% Cell type:markdown id: tags:
A closer look at the simulated evolution of the shear stress along the bond zone in the bottom right
diagram provides an important phenomenological observation. The level of shear increases
at the right, loaded end in the first stage. After reaching the peak shear stress of $N = 2~\mathrm{N}$ , it
diminishes slowly to a low value of approximately 0.1 N.
The constitutive law valid at each material point has thus a first ascending and second descending branch. Such kind of behavior is called **softening**. Constitutive behavior exhibiting softening has a severe impact on the structural behavior by introducing the phenomena of strain localization to discrete shear and tensile cracks, accompanied with stress redistribution during the debonding or crack propagation process. The pull-out problem can be conveniently used to visualize the correspondence between the **softening** material law and the structural response with a debonding propagation, as opposed to **hardening** material law.
%% Cell type:markdown id: tags:
# **Setting up the model components - new material model**
%% Cell type:markdown id: tags:
For the purpose of this comparison, let us introduce a simple piece-wise linear bond-slip law, that can be inserted into the non-linear finite-element code to investigate the effect of the type of nonlinearity on the pull-out response.
%% Cell type:markdown id: tags:
<a id="trilinear_material_model"></a>
<div style="background-color:lightgray;text-align:left"> <img src="../icons/work.png" alt="Coding intermezzo" width="40" height="40">
&nbsp; &nbsp; <b>Coding intermezzo</b> </div>
%% Cell type:markdown id: tags:
## Construct a material model with tri-linear bond-slip law
To indicate how the below examples are implemented let us define a a piece-wise linear function with three branches constituting the bond-slip behavior. It can be used to exemplify how to implement material models in standard non-linear finite-element codes for structural analysis. In codes like `ANSYS, Abaqus, ATENA, Diana`, the spatial integration of the stresses and stiffnesses is based on the so called **predictor**, **corrector** scheme.
%% Cell type:markdown id: tags:
This simply means that the material model must provide two functions
1. the stress evaluation for a given strain increment
2. the derivative of stress with respect to the strain increment, i.e. the material stiffness.
In our case of a bond-slip law, we need to provide two functions
\begin{align}
\tau(s) \\
\frac{\mathrm{d} \tau}{ \mathrm{d} s}
\end{align}.
%% Cell type:markdown id: tags:
**Let's import the packages:**
%% Cell type:code id: tags:
``` python
%matplotlib widget
import sympy as sp # symbolic algebra package
import numpy as np # numerical package
import matplotlib.pyplot as plt # plotting package
sp.init_printing() # enable nice formating of the derived expressions
```
%% Cell type:markdown id: tags:
The tri-linear function can be readily constructed using the already known `Piecewise` function provied in `sympy`
%% Cell type:code id: tags:
``` python
s = sp.symbols('s')
tau_1, s_1, tau_2, s_2 = sp.symbols(r'tau_1, s_1, tau_2, s_2')
tau_s = sp.Piecewise(
(tau_1 / s_1 * s, s <= s_1), # value, condition
(tau_1 + (tau_2-tau_1) / (s_2-s_1) * (s - s_1), s <= s_2), # value, condition
(tau_2, True) # value, otherwise
)
tau_s
```
%% Cell type:markdown id: tags:
The derivative is obtained as
%% Cell type:code id: tags:
``` python
d_tau_s = sp.diff(tau_s, s)
d_tau_s
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/evaluate.png" alt="Evaluate" width="40" height="40">
&nbsp; &nbsp; <b>How to get numbers?</b> </div>
%% Cell type:markdown id: tags:
**The above results are symbols! How to transform them to numbers and graphs?**
`sympy` offers the possibility to generate executable code from symbolic expression (`C`, `Fortran`, or `Python`).
To get `Python` functions that accept the characteristic points `tau_1`, `tau_2`, `s_1`, `s_2`
and evaluating the above defined expressions `tau_s` and `d_tau_s`, we need the following two lines:
%% Cell type:code id: tags:
``` python
get_tau_s = sp.lambdify((s, tau_1, tau_2, s_1, s_2), tau_s, 'numpy')
get_d_tau_s = sp.lambdify((s, tau_1, tau_2, s_1, s_2), d_tau_s, 'numpy')
```
%% Cell type:markdown id: tags:
The parameter `numpy` enables us to evaluate both functions for arrays of values, not only for a single number. As a result, an array of slip values can be directly sent to the function `get_tau_s` to obtain an array of corresponding stresses
%% Cell type:code id: tags:
``` python
get_tau_s(np.array([0, 0.5, 1, 1.5, 2]), 1, 0.1, 1, 2)
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/view.png" alt="Evaluate" width="40" height="40">
&nbsp; &nbsp; <b>How to to plot it?</b> </div>
%% Cell type:markdown id: tags:
Let us now show that the implemented bond-slip function provides a sufficient range of qualitative shapes to demonstrate and discuss the effect of softening and hardening behavior of the interface material. Let us setup a figure `fig` with two axes `ax1` and `ax2` to verify if the defined function is implemented correctly
%% Cell type:code id: tags:
``` python
fig, (ax1, ax2) = plt.subplots(1,2, figsize=(8,3), tight_layout=True)
fig.canvas.header_visible = False
s_range = np.linspace(0, 3, 1050)
for tau_2 in [0, 0.5, 1, 1.5, 2]:
ax1.plot(s_range, get_tau_s(s_range, 1, tau_2, 0.1, 2));
ax2.plot(s_range, get_d_tau_s(s_range, 1, tau_2, 0.1, 2));
ax1.set_xlabel(r'$s$ [mm]'); ax1.set_ylabel(r'$\tau$ [MPa]');
ax2.set_xlabel(r'$s$ [mm]'); ax2.set_ylabel(r'$\mathrm{d}\tau/\mathrm{d}s$ [MPa/mm]');
```
%% Cell type:markdown id: tags:
## Preconfigured pullout model provided in BMCS Tool Suite
The presented function is the simplest model provided in a general-purpose nonlinear finite-element simulator `BMCS-Tool-Suite`.
The package `bmcs_cross_section` provides several preconfigured models that can be used to analyze and visualize the behavior of a composite cross-section. The analysis of the pullout problem discussed here can be done using the class `PullOutModel1D` that can be imported as follows
%% Cell type:code id: tags:
``` python
from bmcs_cross_section.pullout import PullOutModel1D
```
%% Cell type:markdown id: tags:
An instance of the pullout model can be constructed using the following line
%% Cell type:code id: tags:
``` python
po = PullOutModel1D()
```
%% Cell type:markdown id: tags:
For convenience, let us summarize the model parameters before showing how to assign them to the model instance
%% Cell type:markdown id: tags:
**Geometrical variables:**
| Python | Parameter | Description |
| :- | :-: | :- |
| `A_f` | $A_\mathrm{f}$ | Cross section area modulus of the reinforcement |
| `A_m` | $A_\mathrm{m}$ | Cross section area modulus of the matrix |
| `P_b` | $p_\mathrm{b}$ | Perimeter of the reinforcement |
| `L_b` | $L_\mathrm{b}$ | Length of the bond zone of the pulled-out bar |
**Material parameters of a tri-linear bond law:**
| Python | Parameter | Description |
| :- | :-: | :- |
| `E_f` | $E_\mathrm{f}$ | Young's modulus of the reinforcement |
| `E_m` | $E_\mathrm{m}$ | Young's modulus of the matrix |
| `tau_1` | $\tau_1$ | bond strength |
| `tau_2` | $\tau_2$ | bond stress at plateu |
| `s_1` | $s_1$ | slip at bond strengh |
| `s_2` | $s_1$ | slip at plateau stress |
%% Cell type:markdown id: tags:
**Fixed support positions:**
| Python |
| :- |
| `non-loaded end (matrix)` |
| `loaded end (matrix)` |
| `non-loaded end (reinf)` |
| `clamped left` |
%% Cell type:markdown id: tags:
Even more conveniently, let us render the interaction window generated by the model to directly see the structure and the naming of the parameters
%% Cell type:code id: tags:
``` python
%matplotlib widget
po.material_model='trilinear'
po.interact()
```
%% Cell type:markdown id: tags:
The tree structure at the top-left frame shows the individual model components. Parameters of each component are shown in the bottom-left frame. By nagivating through tree, the parameter frame and the plotting frame are updated to see the corresponding part of the model. The control bar at the bottom can be used to start, stop and reset the simulation.
%% Cell type:markdown id: tags:
**Example interaction:** Develop some confidence into the correctness of the model. Change the stiffness of the components such that they have the same area and stiffness modulus. Run the simulation and watch the profile of the shear flow along the bond length. Increase the bond length, reset the calculation and run it anew. Change the position support and verify the profile of the displacements.
%% Cell type:markdown id: tags:
# **Studies 1: Hardening bond-slip law**
%% Cell type:markdown id: tags:
<!-- [![title](../fig/bmcs_video.png)](https://moodle.rwth-aachen.de/mod/page/view.php?id=551816)&nbsp; part 2 -->
%% Cell type:code id: tags:
``` python
YouTubeVideo('ytyeBbRDcvk')
```
%% Cell type:markdown id: tags:
## RILEM Pull-Out Test revisited
%% Cell type:markdown id: tags:
![image.png](attachment:image.png)
%% Cell type:code id: tags:
``` python
po_rilem = PullOutModel1D(n_e_x=300, w_max=0.12) # n_e_x - number of finite elements along the bond zone
po_rilem.n_e_x=400
```
%% Cell type:markdown id: tags:
To configure the model such that it reflects the RILEM test we can either use the interactive editor above, or assign the
attributes directly. As apparent from the editor frame above, attributes `fixed_boundary` and `material model` are dropdown boxes offering several options. To assign these parameters we can use the following scheme
- assign one of the options available in the dropdown box to the attribute `attribute` as a string
- the option object is then available as an attribute with the name `attribute_` with the trailing underscore.
Thus, to define a trilinear bond-slip law we can proceed as follows
%% Cell type:code id: tags:
``` python
po_rilem.material_model = 'trilinear' # polymorphis attribute - there are several options to be chosen from
# set the parameters of the above defined tri-linear bond-slip law - add also the matrix and fiber stiffness
po_rilem.material_model_.E_m=28000 # [MPa]
po_rilem.material_model_.E_f=210000 # [MPa]
po_rilem.material_model_.tau_1=4
po_rilem.material_model_.s_1=1e-3
po_rilem.material_model_.tau_2=8
po_rilem.material_model_.s_2=0.12
```
%% Cell type:markdown id: tags:
To set several parameters of the model component at once, the `trait_set` method can be used as an alternative to one-by-one assignement
%% Cell type:code id: tags:
``` python
d = 16.0 # [mm]
po_rilem.cross_section.trait_set(A_m=100*100, A_f=3.14*(d/2)**2, P_b=3.14*d)
po_rilem.geometry.L_x=5*d
#po_rilem.fixed_boundary='loaded end (matrix)'
```
%% Cell type:markdown id: tags:
The configured model can be rendered anytime as a web-app to check the input parameters and to adjust them.
%% Cell type:code id: tags:
``` python
po_rilem.run()
po_rilem.interact()
```
%% Cell type:markdown id: tags:
## Bond-slip law calibration/validation
**Can we find just one material law that predicts all three tests?**
- The preconfigured bond-slip law with an ascending branch after reaching the strength of $\tau_1 = 4$ MPa with the parameters $\tau_1 = 4$ MPa, $\tau_2 = 8$ MPa, $s_1 = 0.001$ mm, $s_1 = 0.12$ mm
can reproduce the test with $d = 16$ mm and $L_b = 5d = 80$ mm.
- To see the prediction for the test with $L_b = 10d = 160$ mm, modify the parameter `geometry.L_x = 160`. The result shows a good match with the experimentally observed response.
%% Cell type:markdown id: tags:
**Can we compare the differences in one plot?**
- The interactive user interface is illustrative and provides a quick orientation in the scope and functionality of the model. Once we have learned its structure, we can use the programming interface to run simulations in a loop and plot them in a single graph to see the similar picture as in the output of the RILEM test above.
- Try to compare the third test with $d = 28$ mm and $L_b = 5d$ mm.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/step_by_step.png" alt="Step by step" width="40" height="40">
&nbsp; &nbsp; <b>Plot step by step</b> </div>
%% Cell type:code id: tags:
``` python
%matplotlib widget
fig, (ax, ax_bond_slip) = plt.subplots(1,2, figsize=(8,3), tight_layout=True)
fig.canvas.header_visible = False
ax_d = ax_bond_slip.twinx()
print('calculate d=16 mm, L=5d')
d = 16.0 # [mm]
po_rilem.cross_section.trait_set(A_m=100*100, A_f=3.14*(d/2)**2, P_b=3.14*d)
po_rilem.w_max = 0.12
po_rilem.geometry.L_x=5*d
po_rilem.reset() # it is like pressing the reset button in the above window
po_rilem.run() # like pressing the run button
po_rilem.history.plot_Pw(ax, color='blue')
print('calculate d=16 mm, L=10d')
d = 16.0 # [mm]
po_rilem.cross_section.trait_set(A_m=100*100, A_f=3.14*(d/2)**2, P_b=3.14*d)
po_rilem.w_max = 0.12
po_rilem.geometry.L_x=10*d
po_rilem.reset()
po_rilem.run()
po_rilem.hist.plot_Pw(ax, color='red')
print('calculate d=28 mm, L=3d')
d = 28.0 # [mm]
po_rilem.cross_section.trait_set(A_m=100*100, A_f=3.14*(d/2)**2, P_b=3.14*d)
po_rilem.geometry.L_x=3*d
po_rilem.w_max = 0.05
po_rilem.reset()
po_rilem.run()
po_rilem.hist.plot_Pw(ax, color='green')
po_rilem.material_model_.update_plot((ax_bond_slip, ax_d))
# The code sequence can be certainly shortened by using the loop.
# It is deliberately omitted here as the focus is not on programming.
```
%% Cell type:markdown id: tags:
## **Comments** on the study
- Note that the bond-slip law that can fit all three pull-out tests exhibits hardening.
- The maximum control displacement `w_max` is set equal to the one applied in the test as no information beyond this value is provided by the tests.
- The trilinear bond-slip law does not give us the flexibility to reproduce the pull-out failure
as it ends with a plateu.
## **Need for a more flexible bond-slip law**
- A more flexibility is provided by a `multilinear` material model for which a list of `s_data` and `tau_data`
can be specified.
- The `multilinear` material model is used in the following code to show how to achieve a pull-out failure by introducing a descending branch in the bond-slip law.
- Note that for bond-slip laws with descending branch, convergence problems can occur when approaching the pullout failure. The convergence behavior can be improved by refining the spatial discretization given by the number of finite elements along the bond zone `n_e_x` and by the size of the time step
`time_line.step`.
%% Cell type:code id: tags:
``` python
fig, (ax, ax_bond_slip) = plt.subplots(1,2, figsize=(8,3), tight_layout=True)
fig.canvas.header_visible = False
ax_d = ax_bond_slip.twinx()
d = 32.0 # [mm]
po_rilem.w_max = 0.12
po_rilem.time_line.step = 0.05
po_rilem.material_model='multilinear'
po_rilem.material_model_.trait_set(E_m=28000, E_f=210000, tau_data='0, 4, 6, 0, 0', s_data='0, 1e-3, 0.08, 0.12, 0.2')
po_rilem.geometry.L_x= 1*d
po_rilem.reset()
po_rilem.run()
po_rilem.hist.plot_Pw(ax, color='magenta')
po_rilem.material_model_.plot((ax_bond_slip, ax_d))
```
%% Cell type:markdown id: tags:
## **Questions:** Effect of bond length on the pullout response - **bond hardening**
%% Cell type:markdown id: tags:
- The iterative trial and error fitting is tedious. **How to design a test from which we can directly obtain the bond-slip law?**
Comparing the test with $L_b = 5d$ and $L_b = 10d$, we recognize that the shorter bond length resembles more the shape of the bond-slip law. To verify this, set the bond length in the above example to $L_\mathrm{b} = 1d$.
- On the other hand, if we increase the length, the maximum pull-out will increase. **How can we determine the bond length at which the steel bar will yield?**. A simple and quick answer to this question can be provided by reusing the analytical pull-out model with a constant bond-slip law as a first approximation. The maximum achievable pull-out force of a test with an embedded length $L_\mathrm{b}$ is given as
\begin{align}
\label{EQ:MaxEmbeddedLength}
P_{L} = \bar{\tau} p_\mathrm{b} L_\mathrm{b}
\end{align}
where $p_\mathrm{b}$ denotes the perimeter, equal in all experiments. The force at which the reinforcement attains the strength $\sigma_{\mathrm{f},\mathrm{mu}}$ and breaks is
\begin{align}
P_{\mathrm{f},\mathrm{mu}} = \sigma_{\mathrm{f},\mathrm{mu}} A_\mathrm{f}
\end{align}
so that the bond length at which the reinforcement will fail is obtained by requiring $P_L = P_{\mathrm{f},\mathrm{mu}}$ which renders
\begin{align}
\label{EQ:ConstantBondAnchorageLength}
L_{\mathrm{b}} = \frac{\sigma_{\mathrm{f},\mathrm{mu}} A_\mathrm{f} }
{\bar{\tau} p}.
\end{align}
For a generally nonlinear bond-slip law, we need to evaluate the maximum load numerically. Two examples quantifying the effect of the bond-length for bond-hardening and bond-softening systematically are provided in the notebook [3.2 Anchorage length](3_2_anchorage_length.ipynb)
%% Cell type:markdown id: tags:
<a id="cfrp_sheet_test"></a>
# **Studies 2: Softening bond-slip law**
%% Cell type:markdown id: tags:
<!-- [![title](../fig/bmcs_video.png)](https://moodle.rwth-aachen.de/mod/page/view.php?id=551816)&nbsp; part 3 -->
%% Cell type:code id: tags:
``` python
YouTubeVideo('bSVj6UND89c')
```
%% Cell type:markdown id: tags:
The presence of the descending branch in a constitutive law is the key for understanding the propagating debonding. Let us use the established framework to study the different phenomenology that occurs for constitutive laws exhibiting softening.
Consider an interface between a fiber reinforced polymer (FRP) sheet used for retrofitting of RC structure. The study is based on a paper by [Dai et al. (2005)](../papers/dai_frp_pullout_2005.pdf). The goal of the paper is to derive constitutive laws capturing the bond-slip behavior of the adhesive between the FRP sheet and concrete surface. We will use selected experimental pullout curves from the paper to reproduce them using the numerical pullout model introduced above by verifying the bond-slip law derived in the paper.
%% Cell type:markdown id: tags:
## Test setup
%% Cell type:markdown id: tags:
![image.png](attachment:974c60ea-69f6-4175-ab89-cea30a6bf1d6.png)
%% Cell type:markdown id: tags:
The width of the sheet was $p_b = 100$ mm, the attached bond length is also $L_b = 100$ mm.
The properties of the tested sheets are summarized in the table. The dimensions of the concrete block were $200 \times 400 \times 200$ mm.
%% Cell type:markdown id: tags:
![image.png](attachment:fb43c5d7-b9f6-4d4d-8406-9d7610039506.png)
%% Cell type:markdown id: tags:
The pull-out curves measured for different adhesives used to realize the bond to the matrix were evaluated as the strain in the FRP sheet at the loaded end versus slip displacement.
%% Cell type:markdown id: tags:
![image.png](attachment:0e4f48fa-0996-4c4a-be4c-7a2f893ba91d.png)
%% Cell type:markdown id: tags:
To compare with our studies, we can transfer the results to pullout force $P$ by evaluating
\begin{align}
P = p_\mathrm{b} t_\mathrm{f} E_\mathrm{f} \varepsilon_\mathrm{f}
\end{align}
yielding for the strain 0.010
%% Cell type:code id: tags:
``` python
p_b = 100 # [mm]
t_f = 0.11 # [mm]
E_f = 230000 # [MPa]
eps_f_max = 0.01 # [-]
P_max = p_b * t_f * E_f * eps_f_max / 1000 # [kN]
P_max # [kN]
```
%% Cell type:markdown id: tags:
The bond-slip law reported by the authors of the paper has the following shape
<a id="cfrp_bond_slip"></a>
%% Cell type:markdown id: tags:
![image.png](attachment:766b18c8-7f58-49a7-9406-ec2022c29188.png)
%% Cell type:markdown id: tags:
## Model for CFRP pullout test
%% Cell type:markdown id: tags:
Let us construct another pullout model named `po_cfrp` with a bond slip law exhibiting strong softening. Such kind of behavior is observed in tests between FRP sheets and concrete. An example of such an experimental study
<a id="cfrp_trilinear_bond"></a>
%% Cell type:code id: tags:
``` python
po_cfrp = PullOutModel1D(n_e_x=300, w_max=0.1) # mm
po_cfrp.geometry.L_x=50 # mm
po_cfrp.time_line.step = 0.02
po_cfrp.cross_section.trait_set(A_m=np.pi*10**2, A_f=np.pi, P_b=np.pi * 2)
po_cfrp.material_model='trilinear'
po_cfrp.material_model_.trait_set(E_m=30000, E_f=230000, tau_1=1, tau_2=0, s_1=0.002, s_2=0.4)
```
%% Cell type:code id: tags:
``` python
po_cfrp.material_model_.interact()
```
%% Cell type:code id: tags:
``` python
po_cfrp.interact()
```
%% Cell type:markdown id: tags:
## **Conclusions:** to interactive study of CFRP sheet debonding
- The bond-slip law reported in the paper can reproduce well the pullout response measured in the test.
- The study of the debonding process shows that the adhesive is only active within an effective length of approximately 40-50 mm.
- As a consequence, in contrast to steel rebar studied above, the maximum pullout load cannot be increased by an increasing bond length.
- In the studied case there will FRP rupture is not possible because its strength is larger than $P_\max$ of 25 kN. To verify this, we use the strength of 3550 MPa given in the above table and multiply with the cross-sectional area of the sheet, i.e. $f_t t_f p_b$ to obtain
%% Cell type:code id: tags:
``` python
f_t = 3550 # CFRP sheet strength in [MPa] - see the table above
f_t * t_f * p_b / 1000 # breaking force of the sheet 100 x 100 mm in [kN]
```
%% Cell type:markdown id: tags:
## **Question:** Effect of bond length on the pullout response - **bond softening**
- Similarly to the the example with bond hardening above, we ask the question what happens with the pullout curve if we reduce the bond length to a minimum. The answer is the same - we will recover a bond-slip law multiplied by the bond area.
- However, if we increase the bond length, the trend will be different as already mentioned above. Once the length exceeds the effective bond length, there will be no increase in the pullout force and the pullout curve will exhibit a plateau. Let us show this trend by running a simple parametric study. Instead of doing it step by step we now run a loop over the list of length and colors, change the parameter `geometry.L_x` within the loop, `reset`, `run`, and `plot` the pullout curve in a respective color.
%% Cell type:markdown id: 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 to see the effect of bond length</b> </div>
%% Cell type:markdown id: tags:
Note that a list in python is defined by the brackets
```[1,2,3,4]```. Two lists can be "zipped" together so that we can run
a loop over the lengths and colors as shown in the third line of the cell
<a id="crfp_study"></a>
%% Cell type:code id: tags:
``` python
%matplotlib widget
fig, (ax, ax_bond_slip) = plt.subplots(1,2, figsize=(10,4), tight_layout=True)
ax_d = ax_bond_slip.twinx()
fig.canvas.header_visible = False
for L, color in zip([5, 10, 50, 100, 200], ['red','green','blue','black','orange']):
print('evaluating pullout curve for L', L)
po_cfrp.geometry.L_x=L
po_cfrp.reset()
po_cfrp.run()
po_cfrp.history.plot_Pw(ax, color=color)
po_cfrp.material_model_.plot((ax_bond_slip, ax_d))
```
%% Cell type:markdown id: tags:
# **Remark to structural ductility:** how to make the plateau useful?
The softening bond cannot exploit the full strength of the CFRP sheet which might seem uneconomic at first sight. On the other hand it can be viewed as a mechanism that increases the deformation capacity of the structure with a constant level of load. This property can be effectively used to enhance the ductility of the structure, i.e. induce large deformation before the structural collapse required in engineering designs. This documents the importance of knowledge of the stress redistribution mechanisms available in the material. In steel reinforced structure, the ductility is provided inherently by the steel yielding property. In In case of brittle reinforcement, e.g. carbon fabrics, CFRP sheets, glass fabrics, other sources of ductility must be provided to ensure the sufficient deformation capacity between the serviceability and ultimate limit states.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/exercise.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <a href="../exercises/X0301 - Pull-out curve versus shear stress profiles.pdf"><b>Exercise X0301:</b></a> <b>Pull-out curve versus shear stress profiles - part 1</b>
</div>
%% Cell type:code id: tags:
``` python
YouTubeVideo('SLrxMpAdmN4')
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/exercise.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <a href="../exercises/X0302 - Pull-out curve versus shear stress profiles.pdf"><b>Exercise X0302:</b></a> <b>Pull-out curve versus shear stress profiles - part 2</b>
</div>
%% Cell type:code id: tags:
``` python
YouTubeVideo('rg-NIf0e0kU')
```
%% Cell type:markdown id: 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="../tour2_constant_bond/fragmentation.ipynb#top">2.3 Tensile behavior of composite</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="3_2_anchorage_length.ipynb#top">3.2 Pullout curve versus bond length</a>&nbsp; <img src="../icons/next.png" alt="Previous trip" width="50" height="50"> </div>
%% Cell type:code id: tags:
``` python
```
......
%% Cell type:markdown id: tags:
<a id="top"></a>
# **3.2 Pullout curve versus bond length**
<!-- <a href="https://moodle.rwth-aachen.de/mod/page/view.php?id=551819"><img src="../icons/bmcs_video.png" alt="Run"></a> part 1 -->
%% Cell type:code id: tags:
``` python
from IPython.display import YouTubeVideo
YouTubeVideo('CMJaIZmgD2Q')
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/start_flag.png" alt="Previous trip" width="40" height="40">
&nbsp; &nbsp; <b>Starting point</b> </div>
%% Cell type:markdown id: tags:
In the previous notebook [3.1 Hardening and softening](3_1_nonlinear_bond.ipynb#top) we have seen that the effect of the softening
in the bond-slip law affects the pullout response in a qualitatively different way than a constant or increasing shear stress for a growing slip.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/destination.png" alt="Previous trip" width="40" height="40">
&nbsp; &nbsp; <b>Where are we heading</b> </div>
%% Cell type:markdown id: tags:
To deepen our understanding of the correspondence between the bond length and maximum achievable pullout force we will
study the response in three case studies. With the pullout model introduced in notebook [3.1](3_1_nonlinear_bond.ipynb#model)
we will simulate the pullout curve for a changing bond length and extract characteristic points of the structural response.
In particular, we are interested in the trend of the maximum pullout force versus the bond length.
%% Cell type:markdown id: tags:
**Quality of a model = our level of understanding:** We can establish a direct relation between the level of our understanding of the observed phenomena, e.g. pull-out behavior, and the quality of the models we are able to construct. The better the model, the more general the design rules can be formulated. Thus, the validity of the model is a central issue.
**Before starting to experiment:** Therefore, when designing experimental setups, it is necessary
- to **formulate a hypothesis** how the phenomenology works
- to provide **several perspective of observation** by changing some parameters
Indeed, the change of the bond length is an easy way how to extract much more information from the test then if only single geometrical configuration is used.
%% Cell type:markdown id: tags:
**Parametric studies:** The notebook demonstrates an important discipline of engineering research, namely the aim to capture the dependency between the material behavior, geometrical configuration by simple **design formulas** and rules
**applicable in engineering practice**. Many design formulas are derived **empirically**, based solely on
thorough experimental studies. With an increasing quality, or more precisely, **validity of the models**, some design configurations can be also covered based on the simulation results. In the subsequent studies, we will use a model and as a virtual experiment to demonstrate the derivation of a formula for **anchorage length**, i.e. the minimum necessary bond length that guarantees the full utilization of the reinforcement.
%% Cell type:markdown id: tags:
<a id="trc_pullout_study"></a>
# **Case study 1: textile reinforced concrete**
%% Cell type:markdown id: tags:
To characterize the bond behavior between carbon fabrics penetrated with rubber-like material the test setup with a variable bond length has been studied in [Li et al. (2018)](../papers/Li_Bielak_Hegger_Chudoba_2017.pdf). This symmetric, double-sided pullout-test was chosen to appropriately reflect the condition of a typical crack bridge as it occurs in structural TRC members under tensile or bending loads.
%% Cell type:markdown id: tags:
![image.png](attachment:0ebcbb43-c944-42e1-bf82-26894ad4513f.png)
%% Cell type:markdown id: tags:
## Test setup with symmetric debonding
%% Cell type:markdown id: tags:
In the test setup, a TRC specimen with a notch on both faces at the middle section is clamped using hydraulic cylinders.The proposed test setup induces high transversal stress into the anchorage zone of the specimen. For non-impregnated yarns and yarns with a flexible impregnation, e.g. styrene-butadiene, the bond characteristics are not influenced by transversal pressure if the concrete remains uncracked in longitudinal direction. Due to the low stiffness of the yarns in comparison to the concrete in transversal direction, the transversal pressure is transferred by small concrete vaults, forming around the yarn channels.
%% Cell type:markdown id: tags:
![image.png](../fig/trc_carbon_crack_bridge_study.png)
%% Cell type:markdown id: tags:
<a id="trc_test_results"></a>
## Test specimens and measured results
%% Cell type:markdown id: tags:
![image.png](../fig/trc_carbon_crack_bridge_study_results.png)
%% Cell type:markdown id: tags:
<a id="trc_parameters"></a>
| Material parameter | Value | Unit |
|:- | -:| -:|
| matrix area | 1543 | [mm$^2$] |
| matrix stiffness | 28.5 | [GPa] |
| reinforcement area | 16.7 | [mm$^2$] |
| reinforcement stiffness | 170 | [GPa] |
| bond perimeter | 10 | [mm] |
| specimen length | 200-700 | [mm] |
| fabric strength | 1300 | [MPa] |
The paper [Li et al. (2018)](../papers/Li_Bielak_Hegger_Chudoba_2017.pdf) describes an automatic calibration of the bond slip law. The resulting bond-slip law is used here to reproduce the length-dependency of the pullout response of the cross section described above. We will now use the ```PullOutModel1D``` to
reproduce the test results with the bond slip law identified in the paper.
%% Cell type:markdown id: tags:
![image.png](attachment:263bac71-1a20-4760-8605-237e221ae65a.png)
%% Cell type:markdown id: tags:
**Comment on the shape of the material law:** The diagram above shows the result of the automated bond-slip calibration that has been performed for several tested lengths to validate if the algorithm will derive the same bond-slip law from all the performed tests.
Let us remark the unusual shape of the pullout curve exhibiting a first peak followed by a small drop down and subsequent increase of the bond level. This kind of behavior explained by a so called jamming effect due to increasing the lateral pressure in the interface zone between the fiber and matrix.
Let us apply the derived average bond-slip law in a study to investigate and illuminate the correspondence between this type of hardening bond-slip law and pullout response. Recall that only a half of the specimen is simulated so that the pullout displacement in the model is equivalent to the half of the crack bridge displacement measured in the test. See a remark to the validity of the applied [symmetry assumption](#symmetry_assumption) below.
<a id="case_study_1"></a>
%% Cell type:code id: tags:
``` python
%matplotlib widget
import matplotlib.pylab as plt
import numpy as np
from bmcs_cross_section.pullout import PullOutModel1D
```
%% Cell type:code id: tags:
``` python
po_trc = PullOutModel1D(n_e_x=100, w_max=6) # mm
po_trc.geometry.L_x = 100
po_trc.time_line.step = 0.05
po_trc.cross_section.trait_set(A_m=1543, A_f=16.7, P_b=10)
po_trc.material_model='multilinear'
#po_trc.material_model_.trait_set(E_m=28000, E_f=170000, tau_1=5.5, tau_2=8, s_1=0.07, s_2=6)
po_trc.material_model_.trait_set(E_m=28000, E_f=170000,
s_data = '0, 0.1, 0.5, 1, 2, 3, 4.5, 6',
tau_data = '0, 5.4, 4.9, 5, 6, 7, 8.3, 9')
po_trc.interact()
```
%% Cell type:markdown id: 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 bond length</b> </div>
%% Cell type:markdown id: tags:
The model `po_trc` chould be again used to interactively, however, we will directly apply the automated evaluation to find the dependence between the maximum pullout force and the bond length. Let us extend the loop that we previously introduced in the notebook [3.1](3_1_nonlinear_bond.ipynb#crfp_study). Instead of plotting the results directly after each simulation `run`, let us now store the pullout curves in a list called `Pw_list`. The `history` attribute of the model provides the method `get_Pw_t` delivering three data arrays, namely the force and the corresponding two displacements at unloaded and loaded ends. Thus, the calculated arrays are obtained by writing
```python
P, w_unloaded, w_loaded = po_trc.history.get_Pw_t()
```
In the code below, we let all the three arrays in a single variable called ``Pw_t`` and append this tuple of three values into the list ``Pw_list`` collecting the results for each studied length from the list ``L_list``
%% Cell type:code id: tags:
``` python
L_list = [100, 150, 200, 250, 300, 350]
Pw_list = []
po_trc.w_max = 6
for L in L_list:
print('evaluating pullout curve for L', L)
po_trc.geometry.L_x=L
po_trc.reset()
po_trc.run()
Pw_t = po_trc.history.get_Pw_t()
Pw_list.append(Pw_t)
```
%% Cell type:markdown id: tags:
**Fiber rupture:** In addition to the parameters needed to simulate the debonding, let us also define the fabric strength so that we can plot the breaking force of the reinforcement $f_{\mathrm{trc,t}} = 1300$ MPa. Then the rupture force force is evaluated as
\begin{align}
P_\mathrm{fu} = A_\mathrm{f} f_{\mathrm{trc,t}}
\end{align}
%% Cell type:code id: tags:
``` python
f_trc_t = 1300 # [MPa]
P_fu = po_trc.cross_section.A_f * f_trc_t # [N]
P_fu / 1000 # [kN]
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/view.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <b>... plot and decorate the results</b> </div>
%% Cell type:markdown id: tags:
The data of all studies is stored in the list `Pw_list`. Let us now loop over this list, associate every study with a color and
show the pull-out curves in a single diagram refered to as `ax`. In parallel, we extract the maximum pullout force from each study and associate it with the respective bond length. This information is plotted in the diagram `ax_P_L`.
%% Cell type:code id: tags:
``` python
%matplotlib widget
fig, (ax, ax_P_L) = plt.subplots(1,2, figsize=(10,4), tight_layout=True)
fig.canvas.header_visible = False
P_max_list = []
for Pw_t, L, color in zip(Pw_list, L_list, ['red','green','blue','black','orange','gray']):
P_range, w_unloaded, w_loaded = Pw_t
ax.plot(w_loaded, P_range/1000, color=color, linestyle='solid', label=r'$L_\mathrm{b}$ = %d' % L)
ax.plot(w_unloaded, P_range/1000, color=color, linestyle='dashed')
P_max = np.max(P_range)/1000 # kN
P_max_list.append(P_max)
# Plotting
ax.set_xlabel(r'half of crack opening $w/2$ [mm]'); ax.set_ylabel(r'$P$ [kN]')
ax.legend()
ax_P_L.plot(L_list, P_max_list, 'o-', color='blue', label=r'$P_\mathrm{max}$')
ax_P_L.set_xlabel(r'bond length $L_\mathrm{b}$ [mm]')
ax_P_L.set_ylabel(r'pullout force $P_\mathrm{max}$ [kN]')
ax_P_L.set_xlim(xmin=0); ax_P_L.set_ylim(ymin=0)
ax.plot([0, 6], [P_fu/1000, P_fu/1000], linestyle='dashed', linewidth=1, color='red', label='breaking force' );
ax_P_L.plot([0, 350], [P_fu/1000, P_fu/1000], linestyle='dashed', linewidth=1, color='red', label='breaking force' );
ax_P_L.legend();
```
%% Cell type:markdown id: tags:
<a id="hardening_parametric_study"></a>
%% Cell type:markdown id: tags:
## **Comments** to the study
- **Anchorage length**: The relation between the maximum pullout force and the bond length is linear and reaches the breaking force of the reinforcement at the length 250 mm. Comparing this value with the experimental observation, we see that the breaking load exhibits a huge scatter. It is therefore impossible to specify the deterministic value of the fabric strength.
- **Scatter of breaking force**: What is the reason for the experimentally observed scatter of the force at which the fabric breaks? We cannot expect that the pullout force is distributed evenly across the cross section. The statistical aspects of a parallel fiber bundle significantly affect the response of the material that needs to be accounted for in the design rules of textile fabric composites. In case of brittle fabrics this issue **must** be included in the reliable design concept.
<a id="symmetry_assumption"></a>
- **Symmetric debonding in both directions**: The fact that the test is designed as symmetric raises the question if the debonding runs symmetrically in both directions, particularly in the context of an existing scatter in the material properties across the fabrics and bond structure. The answer is, that as far as the pullout (crack-bridge) force increases, the differences on both sides will balance each other. A weaker spot on a one side will lead to a faster increment of debonding upon increasing the bridging force transferred over the debonded zone. Due to hardening bond, the larger debonded length will be able to increase the amount of transfered force. To compensate this, the other side will have to balance this by a further debonding. This **balancing of debonding**, however, can only be assumed for an ascending branch of the pullout curve. If one side of the fabric starts to pullout with a decreasing force, the debonding process becomes one-sided.
%% Cell type:markdown id: tags:
# **Case study 2: Anchorage and constant bond-slip law**
<!-- <a href="https://moodle.rwth-aachen.de/mod/page/view.php?id=551819"><img src="../icons/bmcs_video.png" alt="Run"></a> part 2
-->
The first study using a hardening law has shown that the maximum pullout force increases nearly linearly
up to the failure of the reinforcement. Derivation of such a trend was our goal to have an idea how
to derive a formula for the assessment of anchorage length.
To provide a more straightforward derivation of this trend let us again consider a constant bond-slip law
and provide a simple analytical expression for the relation between the bond length and the maximum pullout load.
We will again make use of the `sympy` and `numpy` packages
%% Cell type:code id: tags:
``` python
YouTubeVideo('vBmCr7c5yrU')
```
%% Cell type:code id: tags:
``` python
import sympy as sp
import numpy as np
sp.init_printing()
```
%% Cell type:markdown id: tags:
Recall that the pull-out model with constant bond strength presented in
the notebook [2.1](../tour2_constant_bond/2_1_1_PO_observation.ipynb#top)
predicts a square root function
\begin{align}
P_w = \sqrt{A_\mathrm{f} E_\mathrm{f} p_\mathrm{b} \bar{\tau} w}
\end{align}
so that we can express it in `sympy` as
%% Cell type:code id: tags:
``` python
p_b, tau, E_f, A_f, L_b, w = sp.symbols(r'p_b, tau, E_f, A_f, L_b, w')
P_w = sp.sqrt(p_b*tau*E_f*A_f*w)
P_w
```
%% Cell type:markdown id: tags:
Once the debonding reached the end of the bond length $L_\mathrm{b}$, the pull out force can grow up to the maximum load of
\begin{align}
P_\max = L_\mathrm{b} p_\mathrm{b} \bar{\tau}
\end{align}
%% Cell type:code id: tags:
``` python
P_max = L_b * p_b * tau
P_max
```
%% Cell type:markdown id: tags:
**This is actually the equation wee seek!** The right diagram of the parametric study [performed above](#hardening_parametric_study)
%% Cell type:markdown id: tags:
To cover both phases of the pullout process, let us construct a piecewise function which the plateau after reaching the value $P_\max$
%% Cell type:code id: tags:
``` python
P_w_pull = sp.Piecewise(
(P_w, P_w < P_max),
(P_max, True)
)
P_w_pull
```
%% Cell type:markdown id: tags:
With these equation we can quickly reinterpret the results obtained numerically in [study 1](#case_study_1)
%% Cell type:markdown id: tags:
| Material parameter | Value | Unit |
|:- | -:| -:|
| matrix area | 1543 | [mm$^2$] |
| matrix stiffness | 28.5 | [GPa] |
| reinforcement area | 16.7 | [mm$^2$] |
| reinforcement stiffness | 170 | [GPa] |
| bond perimeter | 10 | [mm] |
| specimen length | 200-700 | [mm] |
| fabric strength | 1300 | [MPa] |
With these parameters we can require the anchorage length at which the fiber breaks by setting
\begin{align}
\tau_\mathrm{fu} = \dfrac{P_\mathrm{fu}}{p_\mathrm{b} L_\mathrm{b}}
\end{align}
and set $L_\mathrm{b}=250$ to obtain the same anchorage curve as in [study 1](#case_study_1)
%% Cell type:code id: tags:
``` python
tau_fu = P_fu / 10 / 250
tau_fu # [MPa]
```
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/view.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <b>... and plot it</b> </div>
%% Cell type:code id: tags:
``` python
%matplotlib widget
get_P_w_pull = sp.lambdify((w, p_b, tau, E_f, A_f, L_b), P_w_pull, 'numpy')
get_P_max = sp.lambdify((L_b, p_b, tau), P_max, 'numpy' )
# breaking force
w_range = np.linspace(0, 6, 100)
fig, (ax, ax_P_L) = plt.subplots(1,2, figsize=(10,4), tight_layout=True)
fig.canvas.header_visible=False
L_list = np.array([100, 150, 200, 250, 300, 350])
for L in L_list:
ax.plot(w_range, get_P_w_pull(w_range, p_b=10, tau=tau_fu, E_f=170000, A_f=16.7, L_b = L) / 1000, label=r'$L_\mathrm{b}$ = %d' % L)
ax.set_title(r'Pullout curves for variable bond length with constant bond slip');
ax.set_xlabel(r'$w$ [mm]'); ax.set_ylabel(r'$P$ [kN]')
ax.legend()
ax_P_L.plot(L_list, get_P_max(L_list, p_b=10, tau=tau_fu)/1000, 'o-', color='blue', label=r'$P_\mathrm{max}$')
ax_P_L.set_xlabel(r'bond length $L_\mathrm{b}$ [mm]')
ax_P_L.set_ylabel(r'pullout force $P_\mathrm{max}$ [kN]')
ax_P_L.set_xlim(xmin=0); ax_P_L.set_ylim(ymin=0)
ax_P_L.plot([0, 350], [P_fu/1000, P_fu/1000], linestyle='dashed', linewidth=2, color='red', label='breaking force' );
ax_P_L.legend();
```
%% Cell type:markdown id: tags:
## **Comment to the study:**
- Note that the anchorage length diagrams in [study 1](#case_study_1) with a nonlinear hardening law and the constant bond-slip law used in study 2 shown above are equal, even if the pull-out curves on the left are different. To explain this, compare the bond state at failure for a selected bond length. The shear profile at failure will be very similar because the a relatively large value of slip has been achieved over the whole bond length so that the shear stress is nearly uniform already. Verify this statement by using the interactive interface of `po_trc` and render it.
%% Cell type:markdown id: tags:
# **Case study 3: CFRP sheet revisited**
<!-- <a href="https://moodle.rwth-aachen.de/mod/page/view.php?id=551819"><img src="../icons/bmcs_video.png" alt="Run"></a> part 3 -->
%% Cell type:code id: tags:
``` python
YouTubeVideo('t0_atbKAfRE')
```
%% Cell type:markdown id: tags:
To complete the picture with the case of softening bond-slip law, let us extend the study previously presented [for CFRP sheets in notebook 3.1](3_1_nonlinear_bond.ipynb#cfrp_sheet_test) with the goal and construct the relation between the bond length $L_\mathrm{b}$ and the maximum pullout force $P_\max$.
%% Cell type:markdown id: tags:
## Model construction
%% Cell type:code id: tags:
``` python
po_cfrp = PullOutModel1D(n_e_x=200, w_max=1) # mm
po_cfrp.geometry.L_x=100
po_cfrp.time_line.step = 0.02
po_cfrp.cross_section.trait_set(A_m=400*200, A_f=100*0.11, P_b=100)
po_cfrp.material_model='trilinear'
po_cfrp.material_model_.trait_set(E_m=28000, E_f=230000, tau_1=5.5, tau_2=0, s_1=0.07, s_2=0.4)
po_cfrp.interact()
```
%% Cell type:markdown id: 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 bond length</b> </div>
%% Cell type:markdown id: tags:
To study the dependence between the maximum pullout force and the bond length, let us extend the loop that we previously introduced in the notebook [3.1](3_1_nonlinear_bond.ipynb#crfp_study). Instead of plotting the results directly after each simulation `run`, let us now store the pullout curves in a list called `Pw_list`. The `history` attribute of the model provides the method `get_Pw_t` delivering three data arrays, namely the force and the corresponding two displacements at unloaded and loaded ends.
%% Cell type:code id: tags:
``` python
L_list = [5, 10, 50, 100, 200]
Pw_list = []
for L in L_list:
print('evaluating pullout curve for L', L)
po_cfrp.geometry.L_x=L
po_cfrp.reset()
po_cfrp.run()
Pw_t = po_cfrp.history.get_Pw_t()
Pw_list.append(Pw_t)
```
%% Cell type:markdown id: 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 the same diagrams as above</b> </div>
%% Cell type:markdown id: tags:
In addition to the maximum pullout load, we also include the evolution of the pullout displacement at when the maximum load has been reached, denoted as $w_\mathrm{argmax}$
%% Cell type:code id: tags:
``` python
%matplotlib widget
fig, (ax, ax_P_L) = plt.subplots(1,2, figsize=(10,4), tight_layout=True)
ax_w_L = ax_P_L.twinx()
fig.canvas.header_visible = False
P_max_list = []
w_argmax_list = []
for Pw_t, L, color in zip(Pw_list, L_list, ['red','green','blue','black','orange']):
P_range, w_unloaded, w_loaded = Pw_t
ax.plot(w_loaded, P_range/1000, color=color, linestyle='solid', label=r'$L_\mathrm{b}$ = %d' % L)
ax.plot(w_unloaded, P_range/1000, color=color, linestyle='dashed')
P_max = np.max(P_range)/1000 # kN
w_argmax = w_loaded[np.argmax(P_range)]
P_max_list.append(P_max)
w_argmax_list.append(w_argmax)
ax.plot([w_argmax], [P_max], 'o', color=color)
# Plotting
ax.set_xlabel(r'$w$ [mm]'); ax.set_ylabel(r'$P$ [kN]')
ax.legend()
ax_P_L.plot(L_list, P_max_list, 'o-', color='blue', label=r'$P_\mathrm{max}$')
ax_P_L.set_xlabel(r'bond length $L_\mathrm{b}$ [mm]')
ax_P_L.set_ylabel(r'pullout force $P_\mathrm{max}$ [kN]')
ax_P_L.set_xlim(xmin=0); ax_P_L.set_ylim(ymin=0)
ax_P_L.legend(loc=4)
ax_w_L.plot(L_list, w_argmax_list, 'o-', color='orange', label=r'$w_\mathrm{argmax}$')
ax_w_L.set_ylabel(r'pullout displacement at $P_\mathrm{max}$ [mm]')
ax_w_L.set_ylim(ymin=0);
ax_w_L.legend(loc=5);
```
%% Cell type:markdown id: tags:
## **Discussion:**
- Comparing the result with the non-softening laws shown in the studies 1 and 2 above, the evolution of the maximum pullout force with the increasing debonded length displayed in the right diagram is nonlinear and reaches the plateau at $L_b \approx 0.75$ mm.
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/exercise.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <a href="../exercises/X0303 - Anchorage length.pdf"><b>Exercise X0303:</b></a> <b>Anchorage length</b>
<a href="https://moodle.rwth-aachen.de/mod/page/view.php?id=551825"><img src="../icons/bmcs_video.png" alt="Run"></a>
</div>
%% Cell type:markdown id: tags:
<div style="background-color:lightgray;text-align:left"> <img src="../icons/exercise.png" alt="Run" width="40" height="40">
&nbsp; &nbsp; <a href="../exercises/X0304_example_ductile_bond.ipynb"><b>Exercise X0304:</b></a> <b>Anchorage length</b>
</div>
%% Cell type:markdown id: 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="../tour3_nonlinear_bond/3_1_nonlinear_bond.ipynb#top">3.1 Nonlinear bond - softening and hardening</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="../tour4_plastic_bond/4_1_PO_multilinear_unloading.ipynb#top">4.1 Loading unloading and reloading</a>&nbsp; <img src="../icons/next.png" alt="Previous trip" width="50" height="50"> </div>
%% Cell type:code id: tags:
``` python
```
%% Cell type:code id: 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