Repository: fib-international/structuralcodes (language: python)

Issue:
docs: Create framework for docs
## General
- [x] Write configuration
- [x] Installation
- [x] Quickstart example
- [x] Examples
- [x] API reference
- [x] Theory reference
- [x] Update and pin versions

## API reference

### Library structure
- [x] Brief description of the hierarchy and modularity of the library

### Codes
- [x] General functions

### EC2 2004
- [x] Fix docstrings
- [x] Set public API
- [x] Autodoc functions

### EC2 2023
- [x] Fix docstrings
- [x] Set public API
- [x] Autodoc functions

### Model Code 2010
- [x] Fix docstrings
- [x] Set public API
- [x] Autodoc functions

### Materials
- [x] Concretes
- [x] Reinforcement steels
- [x] Constitutive laws
- [x] Fix docstrings

### Geometry
- [x] General geometry
- [x] Steel sections geometries
- [x] Fix docstrings
- [x] @talledodiego: can you please add a docstring to `SurfaceGeometry.split_two_lines`?

### Sections
- [x] Generic section class
- [x] Functions for adding reinforcement
- [x] Fix docstrings
- [x] @talledodiego: can you please add a description of the returns from `.prepare_input`,  `.integrate`, and `.integrate_strain_response_on_geometry` in the docstrings of our integrators?


Discussion / hints:

Fix patch:
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 00000000..d4bb2cbb
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 00000000..a0b721d9
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,45 @@
+# About the structuralcodes docs
+
+## General
+
+The docs are built using [sphinx](https://pypi.org/project/Sphinx/). We rely on [sphinx-design](https://pypi.org/project/sphinx_design/) and [furo](https://pypi.org/project/furo/) for the design. The content is written in MyST Markdown using the [MyST-Parser](https://pypi.org/project/myst-parser/4.0.0/).
+
+## How to build
+
+Navigate to the docs folder.
+
+```
+cd docs
+```
+
+If you have not created the virtual environment, you should do that. Note that the docs require a different virtual environment than the main library, such that there will be one venv-folder in the root directory and one venv-folder in the docs directory.
+
+```
+py -m venv venv
+```
+
+Activate the virtual environment.
+
+```
+venv\scripts\activate
+```
+
+Install the dependencies.
+
+```
+py -m pip install -r requirements.txt
+```
+
+The docs are built using [sphinx-autobuild](https://pypi.org/project/sphinx-autobuild/). Type the following to build the docs, and host a test server locally which automatically rebuilds the docs and reloads the browser when you make changes. By default, the docs are available in your browser on `http://127.0.0.1:8000`, but the port might be different from `8000` if you have other instances running. Make sure to review the output in the terminal.
+
+```
+sphinx-autobuild . _build
+```
+
+You can stop the test server by hitting `ctrl+c`.
+
+Sometimes, you might need to force a complete rebuild of the docs. You accomplish this through the following steps:
+
+1. Stop the test server if it is running, i.e. hit `ctrl+c` in the terminal.
+2. Delete the `_build`-folder, i.e. typing `rmdir .\_build\` in powershell.
+3. Restart the test server with `sphinx-autobuild` as described above.
diff --git a/docs/api/codes/ec2_2004/cracks.md b/docs/api/codes/ec2_2004/cracks.md
new file mode 100644
index 00000000..3b081f66
--- /dev/null
+++ b/docs/api/codes/ec2_2004/cracks.md
@@ -0,0 +1,106 @@
+# Crack width calculations
+
+The following functions are related to calculating crack widths.
+
+## Crack width criterion
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.w_max
+```
+
+## Calculated crack width
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.wk
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.sr_max_close
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.sr_max_far
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.sr_max_theta
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_sm_eps_cm
+```
+
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.alpha_e
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.hc_eff
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.k
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.k1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.k2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.k3
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.k4
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.kc_tension
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.kc_rect_area
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.kc_flanges_area
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.xi1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.rho_p_eff
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.phi_eq
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.kt
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.w_spacing
+```
+
+## Minimum reinforcement
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.As_min
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.As_min_p
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.As_min_2
+```
diff --git a/docs/api/codes/ec2_2004/creep_shrinkage.md b/docs/api/codes/ec2_2004/creep_shrinkage.md
new file mode 100644
index 00000000..5503e057
--- /dev/null
+++ b/docs/api/codes/ec2_2004/creep_shrinkage.md
@@ -0,0 +1,43 @@
+# Creep and shrinkage
+
+The following functions are related to calculation of creep and shrinkage.
+
+## Creep
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.phi
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.beta_c
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.beta_H
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.t0_adj
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.beta_fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.phi_RH
+```
+
+## Shrinkage
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_cs
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.beta_RH
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_cd_0
+```
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2004/index.md b/docs/api/codes/ec2_2004/index.md
new file mode 100644
index 00000000..baf83029
--- /dev/null
+++ b/docs/api/codes/ec2_2004/index.md
@@ -0,0 +1,11 @@
+(api-ec2_2004)=
+# Eurocode 2 (2004)
+
+:::{toctree}
+
+Material properties for concrete <material_concrete>
+Material properties for reinforcement steel <material_reinforcement>
+Shear capacity <shear>
+Crack width calculation <cracks>
+Creep and shrinkage <creep_shrinkage>
+:::
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2004/material_concrete.md b/docs/api/codes/ec2_2004/material_concrete.md
new file mode 100644
index 00000000..14c9a4ca
--- /dev/null
+++ b/docs/api/codes/ec2_2004/material_concrete.md
@@ -0,0 +1,61 @@
+# Material properties for concrete
+
+The following functions are related to calculation of material properties of concrete.
+
+## Strength
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fcd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fctm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fctk_5
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fctk_95
+```
+
+## Stiffness
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.Ecm
+```
+
+## Parameters of constitutive relations
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_c1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_cu1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_c2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_cu2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_c3
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.eps_cu3
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.n_parabolic_rectangular
+```
diff --git a/docs/api/codes/ec2_2004/material_reinforcement.md b/docs/api/codes/ec2_2004/material_reinforcement.md
new file mode 100644
index 00000000..b8d35260
--- /dev/null
+++ b/docs/api/codes/ec2_2004/material_reinforcement.md
@@ -0,0 +1,15 @@
+# Material properties for reinforcement steel
+
+The following functions are related to calculation of material properties of reinforcement steel.
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.reinforcement_duct_props
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.epsud
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.fyd
+```
diff --git a/docs/api/codes/ec2_2004/shear.md b/docs/api/codes/ec2_2004/shear.md
new file mode 100644
index 00000000..d70e5231
--- /dev/null
+++ b/docs/api/codes/ec2_2004/shear.md
@@ -0,0 +1,31 @@
+# Shear capacity
+
+The following functions are related to calculation of shear capacity with and without shear reinforcement.
+
+## Without shear reinforcement
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.VRdc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.VRdc_prin_stress
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.VEdmax_unreinf
+```
+
+## With shear reinforcement
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.VRds
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.VRdmax
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2004.Asw_max
+```
diff --git a/docs/api/codes/ec2_2023/cracks.md b/docs/api/codes/ec2_2023/cracks.md
new file mode 100644
index 00000000..7c2fc6f2
--- /dev/null
+++ b/docs/api/codes/ec2_2023/cracks.md
@@ -0,0 +1,39 @@
+# Crack width calculations
+
+The following functions are related to calculating crack widths.
+
+## Calculated crack width
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.epssm_epscm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.srm_cal
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.kfl
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.kh
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.wk_cal
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.wk_cal2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.k_1_r
+```
+
+## Minimum reinforcement
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.As_min_y
+```
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2023/creep_shrinkage.md b/docs/api/codes/ec2_2023/creep_shrinkage.md
new file mode 100644
index 00000000..e1f0f442
--- /dev/null
+++ b/docs/api/codes/ec2_2023/creep_shrinkage.md
@@ -0,0 +1,27 @@
+# Creep and shrinkage
+
+The following functions are related to calculation of creep and shrinkage.
+
+## Creep
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.phi_50y_t0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.phi_correction_factor
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.A_phi_correction_exp
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.hn
+```
+
+## Shrinkage
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.eps_cs_50y
+```
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2023/deflections.md b/docs/api/codes/ec2_2023/deflections.md
new file mode 100644
index 00000000..f24e9762
--- /dev/null
+++ b/docs/api/codes/ec2_2023/deflections.md
@@ -0,0 +1,11 @@
+# Deflection calculation
+
+The following functions are related to calculating deflections.
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.delta_simpl
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.Ec_eff
+```
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2023/index.md b/docs/api/codes/ec2_2023/index.md
new file mode 100644
index 00000000..78e1036b
--- /dev/null
+++ b/docs/api/codes/ec2_2023/index.md
@@ -0,0 +1,11 @@
+(api-ec2_2023)=
+# Eurocode 2 (2023)
+
+:::{toctree}
+
+Material properties for concrete <material_concrete>
+Material properties for reinforcement steel <material_reinforcement>
+Crack width calculation <cracks>
+Deflection calculation <deflections>
+Creep and shrinkage <creep_shrinkage>
+:::
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2023/material_concrete.md b/docs/api/codes/ec2_2023/material_concrete.md
new file mode 100644
index 00000000..fa4d39eb
--- /dev/null
+++ b/docs/api/codes/ec2_2023/material_concrete.md
@@ -0,0 +1,67 @@
+# Material properties for concrete
+
+The following functions are related to calculation of material properties of concrete.
+
+## Strength
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fcd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.eta_cc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.k_tc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.k_tt
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fctd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fctk_5
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fctk_95
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fctm
+```
+
+## Stiffness
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.Ecm
+```
+
+## Parameters of constitutive relations
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.eps_c1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.eps_cu1
+```
+
+## Miscellaneous properties
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.alpha_c_th
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.weight_c
+```
\ No newline at end of file
diff --git a/docs/api/codes/ec2_2023/material_reinforcement.md b/docs/api/codes/ec2_2023/material_reinforcement.md
new file mode 100644
index 00000000..2bcc387c
--- /dev/null
+++ b/docs/api/codes/ec2_2023/material_reinforcement.md
@@ -0,0 +1,37 @@
+# Material properties for reinforcement steel
+
+The following functions are related to calculation of material properties of reinforcement steel.
+
+## Strength
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fyd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.fpd
+```
+
+## Stiffness
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.Es
+```
+
+## Miscellaneous properties
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.reinforcement_duct_props
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.p_steel_stress_params
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.alpha_s_th
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.ec2_2023.weight_s
+```
diff --git a/docs/api/codes/general.md b/docs/api/codes/general.md
new file mode 100644
index 00000000..fc22dbf7
--- /dev/null
+++ b/docs/api/codes/general.md
@@ -0,0 +1,10 @@
+(api-codes-general)=
+# General
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.set_design_code
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.get_design_codes
+```
diff --git a/docs/api/codes/index.md b/docs/api/codes/index.md
new file mode 100644
index 00000000..5256aa19
--- /dev/null
+++ b/docs/api/codes/index.md
@@ -0,0 +1,11 @@
+(api-design-codes)=
+# Design codes
+
+:::{toctree}
+:maxdepth: 2
+
+General functions <general>
+Eurocode 2 (2004) <ec2_2004/index>
+Eurocode 2 (2023) <ec2_2023/index>
+fib Model Code 2010 <mc2010/index>
+:::
\ No newline at end of file
diff --git a/docs/api/codes/mc2010/creep_shrinkage.md b/docs/api/codes/mc2010/creep_shrinkage.md
new file mode 100644
index 00000000..42ace28a
--- /dev/null
+++ b/docs/api/codes/mc2010/creep_shrinkage.md
@@ -0,0 +1,101 @@
+# Creep and shrinkage
+
+## Creep
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.calc_J
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.phi
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.phi_bc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.phi_dc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_bc_fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_bc_t
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.t_T
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.t0_adj
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_dc_fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_dc_RH
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_dc_t
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_dc_t0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_h
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.gamma_t0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.alpha_fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.k_sigma
+```
+
+## Shrinkage
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.eps_cbs
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.eps_cds
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.eps_cbs0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_bs
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.eps_cds0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_ds
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_RH
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_s1
+```
\ No newline at end of file
diff --git a/docs/api/codes/mc2010/index.md b/docs/api/codes/mc2010/index.md
new file mode 100644
index 00000000..54cf253e
--- /dev/null
+++ b/docs/api/codes/mc2010/index.md
@@ -0,0 +1,10 @@
+(api-mc2010)=
+# _fib_ Model Code 2010
+
+:::{toctree}
+
+Material properties for concrete <material_concrete>
+Material properties for reinforcement steel <material_reinforcement>
+Shear, punching and torsion <shear>
+Creep and shrinkage <creep_shrinkage>
+:::
\ No newline at end of file
diff --git a/docs/api/codes/mc2010/material_concrete.md b/docs/api/codes/mc2010/material_concrete.md
new file mode 100644
index 00000000..c40bedfc
--- /dev/null
+++ b/docs/api/codes/mc2010/material_concrete.md
@@ -0,0 +1,47 @@
+# Material properties for concrete
+
+## Strength
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fcd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fcm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fctm
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fctkmin
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fctkmax
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_cc
+```
+
+## Stiffness
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.Eci
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.Eci_t
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.beta_e
+```
+
+## Miscellaneous properties
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.Gf
+```
\ No newline at end of file
diff --git a/docs/api/codes/mc2010/material_reinforcement.md b/docs/api/codes/mc2010/material_reinforcement.md
new file mode 100644
index 00000000..b0e95e07
--- /dev/null
+++ b/docs/api/codes/mc2010/material_reinforcement.md
@@ -0,0 +1,13 @@
+# Material properties for reinforcement steel
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.fyd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.epsud
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.reinforcement_duct_props
+```
diff --git a/docs/api/codes/mc2010/shear.md b/docs/api/codes/mc2010/shear.md
new file mode 100644
index 00000000..92403d9e
--- /dev/null
+++ b/docs/api/codes/mc2010/shear.md
@@ -0,0 +1,117 @@
+# Shear, punching and torsion capacity
+
+## Shear
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rdc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rdc_approx1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rdc_approx2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rdc_approx3
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rds
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_max_approx1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_max_approx2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_max_approx3
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_ct_approx1
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_ct_approx2
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.epsilon_x
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.eta_fc
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.create_load_dict
+```
+
+## Punching
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_punching
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rd_max_punching
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rdc_punching
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_rds_punching
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.b_0
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.m_ed
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.psi_punching
+```
+
+## Torsion
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.t_rd
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.t_rd_max
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.v_ed_ti
+```
+
+## Shear at the interface between concrete cast at different times
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.tau_edi
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.tau_rdi_without_reinforcement
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.codes.mc2010.tau_rdi_with_reinforcement
+```
\ No newline at end of file
diff --git a/docs/api/geometry/geometry_creation.md b/docs/api/geometry/geometry_creation.md
new file mode 100644
index 00000000..5e89f74b
--- /dev/null
+++ b/docs/api/geometry/geometry_creation.md
@@ -0,0 +1,71 @@
+(api-geometry-creation)=
+# Geometry creation
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.Geometry
+
+    .. automethod:: __init__
+
+    .. autoproperty:: name
+    .. autoproperty:: group_label
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.PointGeometry
+
+    .. automethod:: __init__
+
+    .. autoproperty:: diameter
+    .. autoproperty:: area
+    .. autoproperty:: material
+    .. autoproperty:: density
+    .. autoproperty:: x
+    .. autoproperty:: y
+    .. autoproperty:: point
+
+    .. automethod:: translate
+    .. automethod:: rotate
+    .. automethod:: from_geometry
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.SurfaceGeometry
+
+    .. automethod:: __init__
+
+    .. autoproperty:: area
+    .. autoproperty:: centroid
+    .. autoproperty:: density
+
+    .. automethod:: calculate_extents
+    .. automethod:: split
+    .. automethod:: split_two_lines
+    .. automethod:: translate
+    .. automethod:: rotate
+
+    .. automethod:: from_geometry
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.CompoundGeometry
+
+    .. automethod:: __init__
+
+    .. autoproperty:: reinforced_concrete
+    .. autoproperty:: area
+
+    .. automethod:: calculate_extents
+    .. automethod:: translate
+    .. automethod:: rotate
+    .. automethod:: from_geometry
+
+
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.geometry.create_line_point_angle
+
+```
\ No newline at end of file
diff --git a/docs/api/geometry/index.md b/docs/api/geometry/index.md
new file mode 100644
index 00000000..2b82cfdd
--- /dev/null
+++ b/docs/api/geometry/index.md
@@ -0,0 +1,9 @@
+(api-geometry)=
+# Geometry
+
+:::{toctree}
+:maxdepth: 2
+
+Geometry creation <geometry_creation>
+Steel sections <steel_sections>
+:::
\ No newline at end of file
diff --git a/docs/api/geometry/steel_sections.md b/docs/api/geometry/steel_sections.md
new file mode 100644
index 00000000..9af620ff
--- /dev/null
+++ b/docs/api/geometry/steel_sections.md
@@ -0,0 +1,212 @@
+(api-steel-sections)=
+# Steel sections
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.IPE
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.HE
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.UB
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.UC
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.UBP
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.IPN
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r1
+    .. autoproperty:: r2
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.geometry.UPN
+
+    .. autoproperty:: h
+    .. autoproperty:: b
+    .. autoproperty:: tw
+    .. autoproperty:: tf
+    .. autoproperty:: r1
+    .. autoproperty:: r2
+
+    .. autoproperty:: A
+    .. autoproperty:: Iy
+    .. autoproperty:: Iz
+    .. autoproperty:: Iyz
+    .. autoproperty:: Icsi
+    .. autoproperty:: Ieta
+    .. autoproperty:: theta
+    .. autoproperty:: Wely
+    .. autoproperty:: Welz
+    .. autoproperty:: Wply
+    .. autoproperty:: Wplz
+    .. autoproperty:: iy
+    .. autoproperty:: iz
+
+    .. autoproperty:: polygon
+
+    .. automethod:: get_polygon
+    .. automethod:: profiles
+
+```
\ No newline at end of file
diff --git a/docs/api/index.md b/docs/api/index.md
new file mode 100644
index 00000000..5514a830
--- /dev/null
+++ b/docs/api/index.md
@@ -0,0 +1,35 @@
+(api-ref)=
+# API reference
+
+This section contains descriptions of all modules, functions, classes and methods, as well as the structure of the library.
+
+:::{toctree}
+:hidden:
+
+Library structure <library_structure>
+Design codes <codes/index>
+Materials <materials/index>
+Geometry <geometry/index>
+Sections <sections/index>
+
+:::
+
+## [Library structure](api-structure)
+
+The content of the library is organized in a hierarchic manner.
+
+## [Design codes](api-design-codes)
+
+The design code equations are grouped in different modules.
+
+## [Materials](api-materials)
+
+Classes that represent materials from design codes.
+
+## [Geometry](api-geometry)
+
+Classes for creating the geometry of design sections.
+
+## [Sections](api-sections)
+
+Classes that represent design sections.
diff --git a/docs/api/library_structure.md b/docs/api/library_structure.md
new file mode 100644
index 00000000..32f39f65
--- /dev/null
+++ b/docs/api/library_structure.md
@@ -0,0 +1,21 @@
+(api-structure)=
+# Library structure
+
+The content of StructuralCodes is organized in a hierarchy:
+
+1. On the lowest level, we have the {ref}`code equations <api-design-codes>` from the various design codes. For example, the code equations from Eurocode 2 (2004) can be imported by typing `from structuralcodes.codes import ec2_2004`.
+2. Next, we have the classes that represent {ref}`materials <api-materials>` and {ref}`constitutive laws <api-constitutive-laws>` from the design codes. For example, import concrete from Eurocode 2 (2004) by typing `from structuralcodes.materials.concrete import ConcreteEC2_2004`. The materials in turn refer to code equations from the lower level to calculate material properties.
+3. Next we have the classes that represent {ref}`sections <api-sections>` and {ref}`geometry <api-geometry>`. We rely on the [Shapely](https://shapely.readthedocs.io/en/stable/) library for creating geometries. The sections in turn refer to materials and code equations from the lower levels. Section calculators are responsible for calculating the response in sections, and section integrators are responsible for integrating stress resultants from strains.
+
+:::{seealso}
+{ref}`Design codes reference <api-design-codes>`.
+
+{ref}`Materials reference <api-materials>`
+
+{ref}`Geometry reference <api-geometry>`
+
+{ref}`Sections reference <api-sections>`
+
+The [Shapely](https://shapely.readthedocs.io/en/stable/) library.
+
+:::
\ No newline at end of file
diff --git a/docs/api/materials/base_materials.md b/docs/api/materials/base_materials.md
new file mode 100644
index 00000000..b93f5e33
--- /dev/null
+++ b/docs/api/materials/base_materials.md
@@ -0,0 +1,47 @@
+(api-base-materials)=
+# Base material classes
+
+## Base material class
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core.base.Material
+
+   .. automethod:: update_attributes
+   .. autoproperty:: constitutive_law
+   .. autoproperty:: name
+   .. autoproperty:: density
+```
+
+## Base concrete class
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.concrete.Concrete
+
+   .. autoproperty:: fck
+   .. autoproperty:: constitutive_law
+   .. autoproperty:: gamma_c
+```
+
+## Base reinforcement steel class
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.reinforcement.Reinforcement
+
+   .. autoproperty:: fyk
+   .. autoproperty:: Es
+   .. autoproperty:: ftk
+   .. autoproperty:: epsuk
+   .. autoproperty:: epsyk
+   .. autoproperty:: epsyd
+   .. autoproperty:: constitutive_law
+```
+
+## Base constitutive law class
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core.base.ConstitutiveLaw
+
+   .. autoproperty:: name
+   .. automethod:: preprocess_strains_with_limits
+   .. automethod:: get_secant
+```
\ No newline at end of file
diff --git a/docs/api/materials/concretes.md b/docs/api/materials/concretes.md
new file mode 100644
index 00000000..c1429b47
--- /dev/null
+++ b/docs/api/materials/concretes.md
@@ -0,0 +1,82 @@
+(api-concrete-materials)=
+# Concrete materials
+
+## Concrete factory
+
+```{eval-rst}
+.. autofunction:: structuralcodes.materials.concrete.create_concrete
+```
+
+## Eurocode 2 (2004)
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.concrete.ConcreteEC2_2004
+
+   .. automethod:: __init__
+
+   .. automethod:: fcd
+   .. autoproperty:: fcm
+   .. autoproperty:: fctm
+   .. autoproperty:: fctk_5
+   .. autoproperty:: fctk_95
+   .. autoproperty:: Ecm
+   .. autoproperty:: gamma_c
+   .. autoproperty:: alpha_cc
+   .. autoproperty:: eps_c1
+   .. autoproperty:: eps_cu1
+   .. autoproperty:: k_sargin
+   .. autoproperty:: eps_c2
+   .. autoproperty:: eps_cu2
+   .. autoproperty:: n_parabolic_rectangular
+   .. autoproperty:: eps_c3
+   .. autoproperty:: eps_cu3
+```
+
+## _fib_ Model Code 2010
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.concrete.ConcreteMC2010
+
+   .. automethod:: __init__
+   
+   .. automethod:: fcd
+   .. autoproperty:: fcm
+   .. autoproperty:: Eci
+   .. autoproperty:: fctm
+   .. autoproperty:: fctkmin
+   .. autoproperty:: fctkmax
+   .. autoproperty:: Gf
+   .. autoproperty:: gamma_c
+   .. autoproperty:: alpha_cc
+   .. autoproperty:: eps_c1
+   .. autoproperty:: eps_cu1
+   .. autoproperty:: k_sargin
+   .. autoproperty:: eps_c2
+   .. autoproperty:: eps_cu2
+   .. autoproperty:: n_parabolic_rectangular
+   .. autoproperty:: eps_c3
+   .. autoproperty:: eps_cu3
+```
+
+## Eurocode 2 (2023)
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.concrete.ConcreteEC2_2023
+
+   .. automethod:: __init__
+
+   .. automethod:: fcd
+   .. automethod:: fctd
+   .. autoproperty:: fcm
+   .. autoproperty:: fctm
+   .. autoproperty:: fctk_5
+   .. autoproperty:: fctk_95
+   .. autoproperty:: Ecm
+   .. autoproperty:: gamma_c
+   .. autoproperty:: eps_c1
+   .. autoproperty:: eps_cu1
+   .. autoproperty:: k_sargin
+   .. autoproperty:: eps_c2
+   .. autoproperty:: eps_cu2
+   .. autoproperty:: n_parabolic_rectangular
+```
\ No newline at end of file
diff --git a/docs/api/materials/constitutive_laws.md b/docs/api/materials/constitutive_laws.md
new file mode 100644
index 00000000..cff12e3e
--- /dev/null
+++ b/docs/api/materials/constitutive_laws.md
@@ -0,0 +1,100 @@
+(api-constitutive-laws)=
+# Constitutive laws
+
+## Constitutive law factory
+
+```{eval-rst}
+.. autofunction:: structuralcodes.materials.constitutive_laws.get_constitutive_laws_list
+
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.materials.constitutive_laws.create_constitutive_law
+
+```
+
+## Linear elastic
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.Elastic
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+   .. automethod:: set_ultimate_strain
+
+```
+
+## Elastic plastic
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.ElasticPlastic
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+
+```
+
+## Parabola rectangle
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.ParabolaRectangle
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+
+```
+
+## Bilinear elastic perfectly plastic
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.BilinearCompression
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+
+```
+
+## Sargin
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.Sargin
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+
+```
+
+## Popovics
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.Popovics
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+
+```
+
+## Userdefined
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.constitutive_laws.UserDefined
+
+   .. automethod:: __init__
+   .. automethod:: get_stress
+   .. automethod:: get_tangent
+   .. automethod:: get_ultimate_strain
+   .. automethod:: set_ultimate_strain
+
+```
\ No newline at end of file
diff --git a/docs/api/materials/index.md b/docs/api/materials/index.md
new file mode 100644
index 00000000..6674cc18
--- /dev/null
+++ b/docs/api/materials/index.md
@@ -0,0 +1,11 @@
+(api-materials)=
+# Materials
+
+:::{toctree}
+:maxdepth: 2
+
+Concrete materials <concretes>
+Reinforcement steel materials <reinforcement_steels>
+Constitutive laws <constitutive_laws>
+Base material classes <base_materials>
+:::
\ No newline at end of file
diff --git a/docs/api/materials/reinforcement_steels.md b/docs/api/materials/reinforcement_steels.md
new file mode 100644
index 00000000..efc82edb
--- /dev/null
+++ b/docs/api/materials/reinforcement_steels.md
@@ -0,0 +1,43 @@
+(api-reinforcement-steel-materials)=
+# Reinforcement steel materials
+
+## Reinforcement steel factory
+
+```{eval-rst}
+.. autofunction:: structuralcodes.materials.reinforcement.create_reinforcement
+```
+
+## Eurocode 2 (2004)
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.reinforcement.ReinforcementEC2_2004
+
+   .. automethod:: fyd
+   .. automethod:: ftd
+   .. automethod:: epsud
+   .. autoproperty:: gamma_s
+   .. autoproperty:: gamma_eps
+```
+
+## _fib_ Model Code 2010
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.reinforcement.ReinforcementMC2010
+
+   .. automethod:: fyd
+   .. automethod:: ftd
+   .. automethod:: epsud
+   .. autoproperty:: gamma_s
+   .. autoproperty:: gamma_eps
+```
+
+## Eurocode 2 (2023)
+
+```{eval-rst}
+.. autoclass:: structuralcodes.materials.reinforcement.ReinforcementEC2_2023
+
+   .. automethod:: fyd
+   .. automethod:: ftd
+   .. automethod:: epsud
+   .. autoproperty:: gamma_s
+```
\ No newline at end of file
diff --git a/docs/api/sections/index.md b/docs/api/sections/index.md
new file mode 100644
index 00000000..6bc436e3
--- /dev/null
+++ b/docs/api/sections/index.md
@@ -0,0 +1,9 @@
+(api-sections)=
+# Sections
+
+:::{toctree}
+
+Section creation <section_creation>
+Section integrator <section_integrator>
+Section calculator <section_calculator>
+:::
\ No newline at end of file
diff --git a/docs/api/sections/section_calculator.md b/docs/api/sections/section_calculator.md
new file mode 100644
index 00000000..6c190aca
--- /dev/null
+++ b/docs/api/sections/section_calculator.md
@@ -0,0 +1,57 @@
+(api-section-calculator)=
+# Section calculator
+
+## Generic section calculator
+
+```{eval-rst}
+.. autoclass:: structuralcodes.sections.GenericSectionCalculator
+
+    .. autoproperty:: n_min
+    .. autoproperty:: n_max
+
+
+    .. automethod:: calculate_limit_axial_load
+    .. automethod:: check_axial_load
+    .. automethod:: integrate_strain_profile
+    .. automethod:: calculate_bending_strength
+    .. automethod:: calculate_moment_curvature
+    .. automethod:: calculate_nm_interaction_domain
+    .. automethod:: calculate_nmm_interaction_domain
+    .. automethod:: calculate_mm_interaction_domain
+
+    .. automethod:: get_balanced_failure_strain
+    .. automethod:: find_equilibrium_fixed_pivot
+    .. automethod:: find_equilibrium_fixed_curvature
+
+```
+
+(api-section-results)=
+## Section results
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.GrossProperties
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.CrackedProperties
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.MomentCurvatureResults
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.UltimateBendingMomentResults
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.NMMInteractionDomain
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.NMInteractionDomain
+```
+
+```{eval-rst}
+.. autoclass:: structuralcodes.core._section_results.MMInteractionDomain
+```
diff --git a/docs/api/sections/section_creation.md b/docs/api/sections/section_creation.md
new file mode 100644
index 00000000..58676e8f
--- /dev/null
+++ b/docs/api/sections/section_creation.md
@@ -0,0 +1,25 @@
+(api-section-creation)=
+# Section creation
+
+## The generic section
+
+```{eval-rst}
+.. autoclass:: structuralcodes.sections.GenericSection
+
+    .. automethod:: __init__
+
+    .. autoproperty:: gross_properties
+
+```
+
+## Functions for adding reinforcement
+
+```{eval-rst}
+.. autofunction:: structuralcodes.sections.add_reinforcement
+
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.sections.add_reinforcement_line
+
+```
diff --git a/docs/api/sections/section_integrator.md b/docs/api/sections/section_integrator.md
new file mode 100644
index 00000000..77a07fd5
--- /dev/null
+++ b/docs/api/sections/section_integrator.md
@@ -0,0 +1,48 @@
+(api-section-integrator)=
+# Section integrator
+
+## Base class for section integrators
+
+```{eval-rst}
+.. autoclass:: structuralcodes.sections.SectionIntegrator
+
+    .. automethod:: prepare_input
+    .. automethod:: integrate
+    .. automethod:: integrate_strain_response_on_geometry
+
+```
+
+## Integrator factory
+
+```{eval-rst}
+.. autofunction:: structuralcodes.sections.integrator_factory
+
+```
+
+## The Marin integrator
+
+```{eval-rst}
+.. autoclass:: structuralcodes.sections.MarinIntegrator
+
+    .. automethod:: prepare_input
+    .. automethod:: integrate
+    .. automethod:: integrate_strain_response_on_geometry
+
+```
+
+```{eval-rst}
+.. autofunction:: structuralcodes.sections.marin_integration
+
+```
+
+## The fiber integrator
+
+```{eval-rst}
+.. autoclass:: structuralcodes.sections.FiberIntegrator
+
+    .. automethod:: prepare_input
+    .. automethod:: integrate
+    .. automethod:: integrate_strain_response_on_geometry
+    .. automethod:: prepare_triangulation
+
+```
diff --git a/docs/conf.py b/docs/conf.py
new file mode 100644
index 00000000..ded4b6d3
--- /dev/null
+++ b/docs/conf.py
@@ -0,0 +1,119 @@
+"""Configuration for the docs of structuralcodes."""
+
+import datetime
+import importlib
+import inspect
+import os
+import sys
+
+sys.path.insert(1, '..')
+
+project = 'StructuralCodes documentation'
+copyright = f'{datetime.datetime.today().year}, fib International'
+author = 'fib International'
+
+# General configuration
+extensions = [
+    'myst_parser',
+    'sphinx_copybutton',
+    'sphinx_design',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.autodoc',
+    'sphinx.ext.linkcode',
+    'sphinx.ext.intersphinx',
+    'sphinx_tippy',
+]
+
+myst_enable_extensions = [
+    'colon_fence',
+    'deflist',
+]
+
+templates_path = ['_templates']
+exclude_patterns = [
+    '_build',
+    'Thumbs.db',
+    '.DS_Store',
+    'venv',
+    'README.md',
+    'node_modules',
+    'src',
+    'static',
+    'build',
+    'docs',
+]
+
+# Options for HTML output
+html_title = project
+html_theme = 'furo'
+html_static_path = ['_static']
+html_theme_options = {
+    'footer_icons': [
+        {
+            'name': 'GitHub',
+            'url': 'https://github.com/fib-international/structuralcodes',
+            'html': """
+                <svg stroke="currentColor" fill="currentColor" stroke-width="0" viewBox="0 0 16 16">
+                    <path fill-rule="evenodd" d="M8 0C3.58 0 0 3.58 0 8c0 3.54 2.29 6.53 5.47 7.59.4.07.55-.17.55-.38 0-.19-.01-.82-.01-1.49-2.01.37-2.53-.49-2.69-.94-.09-.23-.48-.94-.82-1.13-.28-.15-.68-.52-.01-.53.63-.01 1.08.58 1.23.82.72 1.21 1.87.87 2.33.66.07-.52.28-.87.51-1.07-1.78-.2-3.64-.89-3.64-3.95 0-.87.31-1.59.82-2.15-.08-.2-.36-1.02.08-2.12 0 0 .67-.21 2.2.82.64-.18 1.32-.27 2-.27.68 0 1.36.09 2 .27 1.53-1.04 2.2-.82 2.2-.82.44 1.1.16 1.92.08 2.12.51.56.82 1.27.82 2.15 0 3.07-1.87 3.75-3.65 3.95.29.25.54.73.54 1.48 0 1.07-.01 1.93-.01 2.2 0 .21.15.46.55.38A8.013 8.013 0 0 0 16 8c0-4.42-3.58-8-8-8z"></path>
+                </svg>
+            """,
+            'class': '',
+        },
+    ],
+    # 'light_logo': 'logo-structuralcodes.png',
+    # 'dark_logo': 'logo-structuralcodes.png',
+    'source_repository': 'https://github.com/fib-international/structuralcodes',
+    'source_branch': 'main',
+    'source_directory': 'docs/',
+    'sidebar_hide_name': False,
+}
+
+# Options for intersphinx
+intersphinx_mapping = {
+    'shapely': ('https://shapely.readthedocs.io/en/stable/', None),
+}
+
+# Autodoc settings
+autodoc_type_aliases = {
+    'ArrayLike': 'ArrayLike',
+    'npt.ArrayLike': 'ArrayLike',
+}
+
+# Options for sphinx-tippy
+tippy_rtd_urls = [
+    'https://shapely.readthedocs.io/en/stable/',
+]
+tippy_props = {'interactive': True}
+
+
+# Function to resolve links to source
+def linkcode_resolve(domain, info):
+    """Resolve link to source code using sphinx.ext.linkcode."""
+    if domain != 'py':
+        return None
+    if not info['module']:
+        return None
+    mod = importlib.import_module(info['module'])
+    if '.' in info['fullname']:
+        objname, attrname = info['fullname'].split('.')
+        obj = getattr(mod, objname)
+        try:
+            obj = getattr(obj, attrname)
+        except AttributeError:
+            return None
+    else:
+        obj = getattr(mod, info['fullname'])
+
+    try:
+        file = inspect.getsourcefile(obj)
+        lines = inspect.getsourcelines(obj)
+    except TypeError:
+        return None
+
+    filename = os.path.relpath(file, os.path.abspath('..'))
+    start, end = lines[1], lines[1] + len(lines[0]) - 1
+
+    return (
+        f'https://github.com/fib-international/structuralcodes/tree/main/{filename}'
+        f'#L{start}-L{end}'
+    )
diff --git a/docs/contributing/index.md b/docs/contributing/index.md
new file mode 100644
index 00000000..669674bd
--- /dev/null
+++ b/docs/contributing/index.md
@@ -0,0 +1,46 @@
+(contributing)=
+# Contributing
+
+[![Build](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+[![Code style: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/format.json)](https://github.com/charliermarsh/ruff)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/charliermarsh/ruff)
+
+## General
+
+For the moment, the core team has completed an initial structure for the two lowest levels, i.e. how to structure the models from the structural design codes, and how to create classes that represent materials and sections. Contributions that seek to add content to the lowest level are highly appreciated.
+
+We have defined a set of [milestones](https://github.com/fib-international/structuralcodes/milestones) that indicate our priorities. Issues are linked to each milesstone, and some of the issues include a to-do list and have linked pull requests. Contributions related to the milestones are highly appreciated. For the moment, our first priority is to add code related to _fib_ Model Code 2020, but other contributions are of course also welcome!
+
+## Contribution guidelines
+
+Here is how to get started.
+
+_First_
+
+- Take a look at the milestones, find one that suits your interests, and navigate to a related issue. Create a comment in the issue indicating the topic that you wish to contribute. Make sure that the topic is not already started by someone else.
+- If you didn't find a suitable milestone or issue, please create a new issue where you describe your request or feature idea. Make sure that you get a GO from the core team before continuing your contribution, so that you do not waste your time duplicating the work of someone else. We promise to provide feedback as soon as we can.
+
+_Then_
+
+- Create a fork of the repo.
+- Set up your local development environment, see [below](local-dev-env).
+- Start developing the feature in a feature branch with a suitable title.
+- We use `ruff` for code formatting and linting, and we have a test suite based on `pytest`. Please make sure that these checks pass before committing code.
+- Please follow common best practice when committing, provide a meaningful commit message, and split different sub-topics in separate commits.
+- Feel free to open a draft pull request as soon as you start committing so that the community can follow the development. The core team will make sure the pull request is linked to the relevant issue, and that we [keep track of the progress](https://github.com/orgs/fib-international/projects/1).
+- Remember to add tests for the new features that you implement.
+- Remember to add docstrings to your functions and classes. We use the [google format](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html).
+- When you feel that your contribution is ready, mark your pull request as ready for review, and we will assign some suitable reviewers.
+
+The core team continues working on the structure for the higher levels of the package. Feel free to join the discussions in the pull requests.
+
+(local-dev-env)=
+## Set up your local development environment
+
+To keep track of the library dependencies, we recommend to work in a virtual environment. To create one on Windows, type `py -m venv venv`, and activate it by typing `venv\scripts\activate`.
+
+We use `ruff` for linting and code formatting, and have set up our test suite using `pytest`. Make sure you have these installed (`make deps`). We have set up VS Code to use testing. Open VS Code inside the repo (`code .`) and view the tests in the test pane on the left side.
+
+We are using the [Ruff extension for VS Code](https://github.com/astral-sh/ruff-vscode?tab=readme-ov-file), and we have by default enabled all automatic fixes. If you wish to disable these fixes locally, e.g. auto-format or auto-sort imports on save, you should have a look at `.vscode/settings.json`.
+
+We have supplied a makefile that you may use to run formatting (`make form`), linting (`make lint`) and testing (`make test`). Don't have `make`? You can get it from [chocolatey](https://community.chocolatey.org/packages/make), `choco install make`. If you don't want to use `make`, feel free to manually type the commands from the makefile e.g. `py -m ruff format structuralcodes` and `py -m pytest`.
\ No newline at end of file
diff --git a/docs/examples/index.md b/docs/examples/index.md
new file mode 100644
index 00000000..4a03a71c
--- /dev/null
+++ b/docs/examples/index.md
@@ -0,0 +1,4 @@
+(examples)=
+# Examples
+
+We are working on a set of examples that demonstrate the use of the library. For now, have a look at the [quickstart](quickstart).
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 00000000..5a147a76
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,71 @@
+# Welcome to StructuralCodes documentation!
+
+[![Build](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml/badge.svg)](https://github.com/fib-international/structuralcodes/actions/workflows/build.yaml)
+
+:::{toctree}
+:hidden:
+:caption: Content
+
+Installation <installation/index>
+Quickstart <quickstart/index>
+Examples <examples/index>
+API reference <api/index>
+Theory reference <theory/index>
+Contributing <contributing/index>
+
+:::
+
+StructuralCodes is a Python library for structural engineering calculations. If you are new to StructuralCodes, you should check out our {ref}`quickstart <quickstart>`, our {ref}`examples <examples>`, and the {ref}`library structure <api-structure>`.
+
+<hr>
+
+::::{grid} 1 1 1 1
+
+:::{grid-item-card} Installation
+:link: installation
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+How to install StructuralCodes.
+:::
+
+:::{grid-item-card} Quickstart
+:link: quickstart
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+Get started in 5 minutes.
+:::
+
+:::{grid-item-card} Examples
+:link: examples
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+Examples are step-by-step instructions on how to do specific tasks.
+:::
+
+:::{grid-item-card} API reference
+:link: api-ref
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+A detailed description of the StructuralCodes API.
+:::
+
+:::{grid-item-card} Theory reference
+:link: theory-ref
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+A collection of the theory related to specific parts of StructuralCodes.
+:::
+
+:::{grid-item-card} Contributing
+:link: contributing
+:link-type: ref
+:margin: 2 2 auto auto
+:class-title: sd-fs-5
+We would love to have your contributions to StructuralCodes!
+:::
+::::
\ No newline at end of file
diff --git a/docs/installation/index.md b/docs/installation/index.md
new file mode 100644
index 00000000..60c7535b
--- /dev/null
+++ b/docs/installation/index.md
@@ -0,0 +1,42 @@
+(installation)=
+# Installation
+
+`structuralcodes` is compatible with Python 3.8, 3.9, 3.10, 3.11 and 3.12, and is installed by typing:
+
+:::::{tab-set}
+::::{tab-item} Python
+:sync: python
+
+:::{code-block} pwsh
+python -m pip install structuralcodes
+:::
+::::
+
+::::{tab-item} Python launcher
+:sync: py
+
+:::{code-block} pwsh
+py -m pip install structuralcodes
+:::
+::::
+:::::
+
+If you already have `structuralcodes` installed, you can upgrade it by typing:
+
+:::::{tab-set}
+::::{tab-item} Python
+:sync: python
+
+:::{code-block} pwsh
+python -m pip install --upgrade structuralcodes
+:::
+::::
+
+::::{tab-item} Python launcher
+:sync: py
+
+:::{code-block} pwsh
+py -m pip install --upgrade structuralcodes
+:::
+::::
+:::::
\ No newline at end of file
diff --git a/docs/make.bat b/docs/make.bat
new file mode 100644
index 00000000..954237b9
--- /dev/null
+++ b/docs/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/docs/quickstart/index.md b/docs/quickstart/index.md
new file mode 100644
index 00000000..fc86e351
--- /dev/null
+++ b/docs/quickstart/index.md
@@ -0,0 +1,95 @@
+(quickstart)=
+# Quickstart
+
+This example shows how to use `structuralcodes` to calculate the response of a rectangular reinforced concrete section. Follow the example step-by-step, or {ref}`skip to the end <quickstart-full-example>` if you are in a hurry.
+
+Import relevant functions and classes:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 3-9
+```
+
+:::{seealso}
+{ref}`Library structure <api-structure>`.
+:::
+
+Set the active design code to Eurocode 2, 2004 (`ec2_2004`):
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 11-12
+```
+
+:::{seealso}
+{func}`set_design_code() <structuralcodes.codes.set_design_code>`
+:::
+
+Create a concrete and a reinforcement material:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 14-24
+```
+
+:::{seealso}
+{ref}`Material reference <api-materials>`.
+
+The concrete factory {func}`create_concrete() <structuralcodes.materials.concrete.create_concrete>`.
+
+The reinforcement {func}`create_reinforcement() <structuralcodes.materials.reinforcement.create_reinforcement>`.
+:::
+
+Create a {class}`SurfaceGeometry <structuralcodes.geometry.SurfaceGeometry>` based on a {class}`shapely.Polygon` and the {class}`Concrete <structuralcodes.materials.concrete.Concrete>` created with {func}`create_concrete() <structuralcodes.materials.concrete.create_concrete>`:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 26-37
+```
+
+:::{seealso}
+{class}`shapely.Polygon`
+
+{ref}`Geometry reference <api-geometry>`.
+:::
+
+Add reinforcement to the geometry:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 39-60
+```
+
+Create a {class}`GenericSection <structuralcodes.sections.GenericSection>` based on the geometry:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 62-63
+```
+
+:::{seealso}
+{ref}`Section reference <api-sections>`
+:::
+
+Call the {func}`.calculate_moment_curvature() <structuralcodes.sections.GenericSectionCalculator.calculate_moment_curvature>` method on the {class}`GenericSectionCalculator <structuralcodes.sections.GenericSectionCalculator>` to calculate the moment-curvature relation:
+
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :lines: 65-66
+```
+
+:::{seealso}
+{ref}`Section calculator reference <api-section-calculator>`
+
+{ref}`Section integrator reference <api-section-integrator>`
+
+{ref}`Section results reference <api-section-results>`
+:::
+
+Full example:
+
+(quickstart-full-example)=
+```{eval-rst}
+.. literalinclude:: quickstart_example.py
+   :linenos:
+```
diff --git a/docs/quickstart/quickstart_example.py b/docs/quickstart/quickstart_example.py
new file mode 100644
index 00000000..96fa2f4d
--- /dev/null
+++ b/docs/quickstart/quickstart_example.py
@@ -0,0 +1,68 @@
+"""Quickstart example."""
+
+from shapely import Polygon
+
+from structuralcodes import set_design_code
+from structuralcodes.geometry import SurfaceGeometry
+from structuralcodes.materials.concrete import create_concrete
+from structuralcodes.materials.reinforcement import create_reinforcement
+from structuralcodes.sections import GenericSection, add_reinforcement
+
+# Set the active design code
+set_design_code('ec2_2004')
+
+# Create a concrete and a reinforcement
+fck = 45
+fyk = 500
+ftk = 550
+Es = 200000
+epsuk = 0.07
+
+# These factory functions create concrete and reinforcement materials according
+# to the globally set design code
+concrete = create_concrete(fck=fck)
+reinforcement = create_reinforcement(fyk=fyk, Es=Es, ftk=ftk, epsuk=epsuk)
+
+# Create a rectangular geometry
+width = 250
+height = 500
+polygon = Polygon(
+    [
+        (-width / 2, -height / 2),
+        (width / 2, -height / 2),
+        (width / 2, height / 2),
+        (-width / 2, height / 2),
+    ]
+)  # We leverage shapely to create geometries
+geometry = SurfaceGeometry(
+    polygon, concrete
+)  # A SurfaceGeometry is a shapely Polygon with an assigned material
+
+# Add reinforcement
+diameter_reinf = 25
+cover = 50
+
+geometry = add_reinforcement(
+    geometry,
+    (
+        -width / 2 + cover + diameter_reinf / 2,
+        -height / 2 + cover + diameter_reinf / 2,
+    ),
+    diameter_reinf,
+    reinforcement,
+)  # The add_reinforcement function returns a CompoundGeometry
+geometry = add_reinforcement(
+    geometry,
+    (
+        width / 2 - cover - diameter_reinf / 2,
+        -height / 2 + cover + diameter_reinf / 2,
+    ),
+    diameter_reinf,
+    reinforcement,
+)
+
+# Create section
+section = GenericSection(geometry)
+
+# Calculate the moment-curvature response
+moment_curvature = section.section_calculator.calculate_moment_curvature()
diff --git a/docs/requirements.txt b/docs/requirements.txt
new file mode 100644
index 00000000..0158d036
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,12 @@
+sphinx==8.0.2
+sphinx-autobuild==2024.2.4
+sphinx-copybutton==0.5.2
+sphinx-design==0.6.1
+sphinx-tippy==0.4.3
+furo==2024.8.6
+myst-parser==4.0.0
+
+numpy>=1.20.0
+scipy>=1.6.0
+shapely>=2.0.0
+triangle>=20230923
diff --git a/docs/theory/index.md b/docs/theory/index.md
new file mode 100644
index 00000000..01d92bbe
--- /dev/null
+++ b/docs/theory/index.md
@@ -0,0 +1,4 @@
+(theory-ref)=
+# Theory reference
+
+We are working on a description of the theoretical basis for the implementations in the library. Check back regularly for updates.
\ No newline at end of file
diff --git a/structuralcodes/codes/ec2_2004/__init__.py b/structuralcodes/codes/ec2_2004/__init__.py
index 93f4675a..a6f8ae26 100644
--- a/structuralcodes/codes/ec2_2004/__init__.py
+++ b/structuralcodes/codes/ec2_2004/__init__.py
@@ -49,11 +49,31 @@
     wk,
     xi1,
 )
+from .annex_b_shrink_and_creep import (
+    beta_c,
+    beta_fcm,
+    beta_H,
+    beta_RH,
+    eps_cd_0,
+    eps_cs,
+    phi,
+    phi_RH,
+    t0_adj,
+)
+from .shear import (
+    Asw_max,
+    VEdmax_unreinf,
+    VRdc,
+    VRdc_prin_stress,
+    VRdmax,
+    VRds,
+)
 
 __all__ = [
     'As_min',
     'As_min_2',
     'As_min_p',
+    'Asw_max',
     'alpha_e',
     'eps_sm_eps_cm',
     'hc_eff',
@@ -92,6 +112,20 @@
     'eps_cu3',
     'fyd',
     'epsud',
+    'VEdmax_unreinf',
+    'VRdc',
+    'VRdc_prin_stress',
+    'VRdmax',
+    'VRds',
+    'beta_c',
+    'beta_fcm',
+    'beta_H',
+    'beta_RH',
+    'eps_cd_0',
+    'eps_cs',
+    'phi',
+    'phi_RH',
+    't0_adj',
 ]
 
 __title__: str = 'EUROCODE 2 1992-1-1:2004'
diff --git a/structuralcodes/codes/ec2_2004/_concrete_material_properties.py b/structuralcodes/codes/ec2_2004/_concrete_material_properties.py
index dd467773..d2f5b70c 100644
--- a/structuralcodes/codes/ec2_2004/_concrete_material_properties.py
+++ b/structuralcodes/codes/ec2_2004/_concrete_material_properties.py
@@ -39,62 +39,62 @@ def fctm(fck: float) -> float:
     return mc2010.fctm(fck=abs(fck))
 
 
-def fctk_5(_fctm: float) -> float:
+def fctk_5(fctm: float) -> float:
     """The 5% fractile of the tensile strength of concrete.
 
     EN 1992-1-1: 2004, Table 3.1.
 
     Args:
-        _fctm (float): The mean tensile strength of concrete in MPa.
+        fctm (float): The mean tensile strength of concrete in MPa.
 
     Returns:
         float: The 5% fractile of the tensile strength in MPa.
     """
-    return mc2010.fctkmin(_fctm=abs(_fctm))
+    return mc2010.fctkmin(fctm=abs(fctm))
 
 
-def fctk_95(_fctm: float) -> float:
+def fctk_95(fctm: float) -> float:
     """The 95% fractile of the tensile strength of concrete.
 
     EN 1992-1-1: 2004, Table 3.1.
 
     Args:
-        _fctm (float): The mean tensile strength of concrete in MPa.
+        fctm (float): The mean tensile strength of concrete in MPa.
 
     Returns:
         float: The 95% fractile of the tensile strength in MPa.
     """
-    return mc2010.fctkmax(_fctm=abs(_fctm))
+    return mc2010.fctkmax(fctm=abs(fctm))
 
 
-def Ecm(_fcm: float) -> float:
+def Ecm(fcm: float) -> float:
     """The secant modulus of concrete.
 
     EN 1992-1-1:2004, Table 3.1.
 
     Args:
-        _fcm (float): The mean compressive strength of concrete in MPa.
+        fcm (float): The mean compressive strength of concrete in MPa.
 
     Returns:
         float: The secant modulus of concrete in MPa.
     """
-    return 22000.0 * math.pow(abs(_fcm) / 10, 0.3)
+    return 22000.0 * math.pow(abs(fcm) / 10, 0.3)
 
 
-def eps_c1(_fcm: float) -> float:
+def eps_c1(fcm: float) -> float:
     """The strain at maximum compressive stress of concrete (fcm) for the
     Sargin constitutive law.
 
     EN 1992-1-1:2004, Table 3.1.
 
     Args:
-        _fcm (float): The mean compressive strength of concrete in MPa.
+        fcm (float): The mean compressive strength of concrete in MPa.
 
     Returns:
         float: The strain at maximum compressive stress, absolute value, no
         unit.
     """
-    return min(0.7 * math.pow(abs(_fcm), 0.31), 2.8) / 1000
+    return min(0.7 * math.pow(abs(fcm), 0.31), 2.8) / 1000
 
 
 def eps_cu1(fck: float) -> float:
@@ -118,9 +118,9 @@ def eps_cu1(fck: float) -> float:
 
 
 def k_sargin(
-    _Ecm: float,
-    _fcm: float,
-    _eps_c1: float,
+    Ecm: float,
+    fcm: float,
+    eps_c1: float,
 ) -> float:
     """Computation of k parameter for Sargin constitutive Law.
 
@@ -131,7 +131,7 @@ def k_sargin(
         fcm (float): the mean compressive strength in MPa.
         eps_c1 (float): the strain corresponding to peak stress.
     """
-    return 1.05 * _Ecm * abs(_eps_c1) / _fcm
+    return 1.05 * Ecm * abs(eps_c1) / fcm
 
 
 def eps_c2(fck: float) -> float:
diff --git a/structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py b/structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py
index 0ee59d1b..afa49f82 100644
--- a/structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py
+++ b/structuralcodes/codes/ec2_2004/_reinforcement_material_properties.py
@@ -48,6 +48,8 @@ def epsud(epsuk: float, gamma_eps: float = 0.9) -> float:
 
     Args:
         epsuk (float): The characteristic ultimate strain
+
+    Keyword Args:
         gamma_eps (float): The partial factor specified in NA.
             Default value 0.9.
 
diff --git a/structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py b/structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py
index aa3d1589..e0a4ae20 100644
--- a/structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py
+++ b/structuralcodes/codes/ec2_2004/_section_7_3_crack_control.py
@@ -9,17 +9,21 @@
 import scipy.interpolate
 
 
-def w_max(exposure_class: str, load_combination: str) -> float:
+def w_max(
+    exposure_class: t.Literal[
+        'X0', 'XC1', 'XC2', 'XC3', 'XC4', 'XD1', 'XD2', 'XS1', 'XS2', 'XS3'
+    ],
+    load_combination: t.Literal['f', 'qp'],
+) -> float:
     """Computes the recommended value of the maximum crack width.
 
-    EUROCODE 2 1992-1-1:2004, Table (7.1N)
+    EUROCODE 2 1992-1-1:2004, Table (7.1N).
 
     Args:
-        exposure_class (str): The exposure class.
-            Possible values: X0, XC1, XC2, XC3, XC4, XD1, XD2, XS1, XS2, XS3
-        load_combination (str):
-            - f: for frequent load combination
-            - qp: for quasi-permanent load combination
+        exposure_class (str): The exposure class. Possible values: X0, XC1,
+            XC2, XC3, XC4, XD1, XD2, XS1, XS2, XS3.
+        load_combination (str): The characteristic of the load combination.
+            Frequent (f), or quasi-permanent (qp).
 
     Returns:
         float: The maximum recommended value for the crack width wmax in mm.
@@ -61,12 +65,12 @@ def w_max(exposure_class: str, load_combination: str) -> float:
 
 
 def As_min(
-    A_ct: float, sigma_s: float, fct_eff: float, _k: float, kc: float
+    A_ct: float, sigma_s: float, fct_eff: float, k: float, kc: float
 ) -> float:
     """Computes the minimum area of reinforcing steel within the tensile zone
     for control of cracking areas.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.1)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.1).
 
     Args:
         A_ct (float): is the area of concrete within the tensile zone in mm2.
@@ -82,7 +86,7 @@ def As_min(
             the concrete effective at the time when the cracks may first be
             expected to occur: fct,eff=fct or lower (fct(t)), is cracking
             is expected earlier than 28 days.
-        _k (float): is the coefficient which allow for the effect of
+        k (float): is the coefficient which allow for the effect of
             non-uniform self-equilibrating stresses, which lead to a
             reduction of restraint forces.
             k=1 for webs w<=300mm or flanges widths less than 300mm
@@ -93,11 +97,11 @@ def As_min(
             the change of the lever arm.
 
     Returns:
-        float: the minimm area of reinforcing steel within the tensile
-            zone in mm2.
+        float: The minimum area of reinforcing steel within the tensile zone in
+        mm2.
 
     Raises:
-        ValueError: if _k value is not between 0.65 and 1 or kc is not
+        ValueError: if k value is not between 0.65 and 1 or kc is not
             larger than 0 and lower than 1.
     """
     fct_eff = abs(fct_eff)
@@ -106,12 +110,12 @@ def As_min(
         raise ValueError(f'A_ct={A_ct} must be larger than 0')
     if sigma_s < 0:
         raise ValueError(f'sigma_s={sigma_s} must be equal or larger than 0')
-    if _k < 0.65 or _k > 1.0:
-        raise ValueError(f'_k={_k} must be between 0.65 and 1')
+    if k < 0.65 or k > 1.0:
+        raise ValueError(f'k={k} must be between 0.65 and 1')
     if kc > 1 or kc < 0:
         raise ValueError(f'kc={kc} must be lower than 1 and larger than 0')
 
-    return kc * _k * fct_eff * A_ct / sigma_s
+    return kc * k * fct_eff * A_ct / sigma_s
 
 
 def k(h: float) -> float:
@@ -121,13 +125,13 @@ def k(h: float) -> float:
     k=1 for webs w<=300mm or flanges widths less than 300mm
     k=0.65 for webs w>=800mm or flanges with widths greater than 800mm.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.1)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.1).
 
     Args:
         h (float): flange length or flange width in mm
 
     Returns:
-        float: k coefficient value
+        float: k coefficient value.
 
     Raises:
         ValueError: if h is less than 0
@@ -147,40 +151,40 @@ def kc_tension() -> float:
     distribution within the section immediately prior to cracking and
     the change of the lever arm in pure tension.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.1)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.1).
 
     Returns:
-        float: value of the kc coefficient in pure tension
+        float: Value of the kc coefficient in pure tension.
     """
     return 1
 
 
 def kc_rect_area(h: float, b: float, fct_eff: float, N_ed: float) -> float:
-    """Computes the coefficient which takes account of the stress
-    distribution within the section immediately prior to cracking and
-    the change of the lever arm for bending+axial combination
-    in rectangular sections and webs of box sections and T-sections.
+    """Computes the coefficient which takes account of the stress distribution
+    within the section immediately prior to cracking and the change of the
+    lever arm for bending+axial combination in rectangular sections and webs of
+    box sections and T-sections.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.2)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.2).
 
     Args:
         h (float): heigth of the element in mm
         b (float): width of the element in mm
         fct_eff (float): is the mean value of the tensile strength in MPa of
             the concrete effective at the time when the cracks may first be
-            expected to occur: fct,eff=fct or lower (fct(t)), is cracking
-            is expected earlier than 28 days.
-        N_ed (str): axial force at the serviceability limit state acting on
-            the part of the cross-section under consideration (compressive
-            force positive). n_ed should be determined considering the
-            characteristic values of prestress and axial forces under the
-            relevant combination of actions
+            expected to occur: fct,eff=fct or lower (fct(t)), is cracking is
+            expected earlier than 28 days.
+        N_ed (str): axial force at the serviceability limit state acting on the
+            part of the cross-section under consideration (compressive force
+            positive). n_ed should be determined considering the characteristic
+            values of prestress and axial forces under the relevant combination
+            of actions.
 
     Returns:
-        float: value of the kc coefficient
+        float: Value of the kc coefficient.
 
     Raises:
-        ValueError: is h or b are less than 0
+        ValueError: If h or b are less than 0.
     """
     if h < 0:
         raise ValueError(f'h={h} should be larger than 0mm')
@@ -188,10 +192,10 @@ def kc_rect_area(h: float, b: float, fct_eff: float, N_ed: float) -> float:
         raise ValueError(f'b={b} should be larger than 0mm')
 
     h_s = min(h, 1000)
-    _k1 = 1.5 if N_ed >= 0 else 2 * h_s / 3 / h
+    k1 = 1.5 if N_ed >= 0 else 2 * h_s / 3 / h
     s_concrete = N_ed * 1000 / b / h
     h_ratio = h / h_s
-    return min(max(0.4 * (1 - s_concrete / _k1 / h_ratio / fct_eff), 0), 1)
+    return min(max(0.4 * (1 - s_concrete / k1 / h_ratio / fct_eff), 0), 1)
 
 
 def kc_flanges_area(f_cr: float, A_ct: float, fct_eff: float) -> float:
@@ -200,12 +204,12 @@ def kc_flanges_area(f_cr: float, A_ct: float, fct_eff: float) -> float:
     the change of the lever arm for bending+axial combination
     in rectangular sections for flanges of box sections and T-sections.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.3)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.3).
 
     Args:
         f_cr: is the absolute value in kN of the tensile force within the
             flange immediately prior to cracking due to cracking moment
-            calculated with fct,eff
+            calculated with fct,eff.
         A_ct (float): is the area of concrete within the tensile zone in mm2.
             The tensile zone is that part of the section which is calculated
             to be in tension just before the formation of the first crack.
@@ -215,10 +219,10 @@ def kc_flanges_area(f_cr: float, A_ct: float, fct_eff: float) -> float:
             is expected earlier than 28 days.
 
     Returns:
-        float: value of the kc coefficient
+        float: Value of the kc coefficient.
 
     Raises:
-        ValueError: is A_ct is less than 0mm2
+        ValueError: If A_ct is less than 0mm2.
     """
     f_cr = abs(f_cr)
     return max(0.9 * f_cr * 1000 / A_ct / fct_eff, 0.5)
@@ -228,22 +232,22 @@ def xi1(xi: float, phi_p: float, phi_s: float) -> float:
     """Computes the adjusted ratio of bond strength taking into account
     the different diameters of prestressing and reinforcing steel.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.5)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.5).
 
     Args:
         xi (float): ratio of bond strength of prestressing and reinforcing
-            steel, according to Table 6.2 in 6.8.2
+            steel, according to Table 6.2 in 6.8.2.
         phi_p (float): largest bar diameter in mm of reinforcing steel.
-            Equal to 0 if only prestressing is used in control cracking
+            Equal to 0 if only prestressing is used in control cracking.
         phi_s (float): equivalent diameter in mm of tendon acoording
-            to 6.8.2
+            to 6.8.2.
 
     Returns:
-        float: with the value of the ratio
+        float: With the value of the ratio.
 
     Raises:
-        ValueError: if diameters phi_s or phi_p are lower than 0.
-            If ratio of bond strength xi is less than 0.15 or larger than 0.8.
+        ValueError: If diameters phi_s or phi_p are lower than 0. If ratio of
+            bond strength xi is less than 0.15 or larger than 0.8.
     """
     if phi_p <= 0:
         raise ValueError(f'phi_p={phi_p} cannot be less than 0')
@@ -258,23 +262,23 @@ def xi1(xi: float, phi_p: float, phi_s: float) -> float:
 
 
 def hc_eff(h: float, d: float, x: float) -> float:
-    """Returns the effective height of concrete in tension surrounding
-    the reinforcement or prestressing tendons.
+    """Returns the effective height of concrete in tension surrounding the
+    reinforcement or prestressing tendons.
 
-    EUROCODE 2 1992-1-1:2004, Section (7.3.2-3)
+    EUROCODE 2 1992-1-1:2004, Section (7.3.2-3).
 
     Args:
-        h (float): total depth of the element in mm
-        d (float): distance in mm to the level of the steel centroid
-        x (float): distance in mm to the zero tensile stress line
+        h (float): total depth of the element in mm.
+        d (float): distance in mm to the level of the steel centroid.
+        x (float): distance in mm to the zero tensile stress line.
 
     Returns:
-        float: the effective height in mm
+        float: The effective height in mm.
 
     Raises:
-        ValueError: if any of h, d or x is lower than zero.
-        ValueError: if d is greater than h
-        ValueError: if x is greater than h
+        ValueError: If any of h, d or x is lower than zero.
+        ValueError: If d is greater than h.
+        ValueError: If x is greater than h.
     """
     if h < 0:
         raise ValueError(f'h={h} cannot be less than 0')
@@ -294,7 +298,7 @@ def As_min_p(
     A_ct: float,
     sigma_s: float,
     fct_eff: float,
-    _k: float,
+    k: float,
     kc: float,
     Ap: float,
     phi_s: float,
@@ -305,52 +309,49 @@ def As_min_p(
     """Computes the minimum area of reinforcing steel within the tensile zone
     for control of cracking areas in addition with bonded tendons.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.1)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.1).
 
     Args:
         A_ct (float): is the area of concrete within the tensile zone in mm2.
-            The tensile zone is that part of the section which is calculated
-            to be in tension just before the formation of the first crack.
+            The tensile zone is that part of the section which is calculated to
+            be in tension just before the formation of the first crack.
         sigma_s (float): is the absolute value of the maximum stress in MPa
-            permitted in the reinforcement immediately after the formation
-            of the crack. This may be taken as the yield strength of the
+            permitted in the reinforcement immediately after the formation of
+            the crack. This may be taken as the yield strength of the
             reinforcement, fyk. A lower value may, however, be needed to
-            satisfy the crack width limits according to the maximum
-            bar size of spacing (see 7.3.3 (2)).
+            satisfy the crack width limits according to the maximum bar size of
+            spacing (see 7.3.3 (2)).
         fct_eff (float): is the mean value of the tensile strength in MPa of
             the concrete effective at the time when the cracks may first be
-            expected to occur: fct,eff=fct or lower (fct(t)), is cracking
-            is expected earlier than 28 days.
-        _k (float): is the coefficient which allow for the effect of
-            non-uniform self-equilibrating stresses, which lead to a
-            reduction of restraint forces.
-            k=1 for webs w<=300mm or flanges widths less than 300mm
-            k=0.65 for webs w>=800mm or flanges with widths greater than 800mm
-            Intermediate values may be interpolated.
+            expected to occur: fct,eff=fct or lower (fct(t)), is cracking is
+            expected earlier than 28 days.
+        k (float): is the coefficient which allow for the effect of non-
+            uniform self-equilibrating stresses, which lead to a reduction of
+            restraint forces. k=1 for webs w<=300mm or flanges widths less than
+            300mm. k=0.65 for webs w>=800mm or flanges with widths greater than
+            800mm. Intermediate values may be interpolated.
         kc (float): is a coefficient which takes account of the stress
             distribution within the section immediately prior to cracking and
             the change of the lever arm.
-        Ap (float): is the area in mm2 of pre or post-tensioned tendons
-            within ac_eff
-        phi_s (float): largest bar diameter in mm of reinforcing steel.
-            Equal to 0 if only prestressing is used in control cracking
-        phi_p (float): equivalent diameter in mm of tendon acoording
-            to 6.8.2
+        Ap (float): is the area in mm2 of pre or post-tensioned tendons within
+            ac_eff.
+        phi_s (float): largest bar diameter in mm of reinforcing steel. Equal
+            to 0 if only prestressing is used in control cracking.
+        phi_p (float): equivalent diameter in mm of tendon according to 6.8.2.
         xi (float): ratio of bond strength of prestressing and reinforcing
-            steel, according to Table 6.2 in 6.8.2
-        delta_s (float): stress variation in MPa in prestressing tendons
-            from the state of zero strain of the concrete at the same level
+            steel, according to Table 6.2 in 6.8.2.
+        delta_s (float): stress variation in MPa in prestressing tendons from
+            the state of zero strain of the concrete at the same level.
 
     Returns:
-        float: the minimm area of reinforcing steel within the tensile
-            zone in mm2.
+        float: The minimm area of reinforcing steel within the tensile zone in
+        mm2.
 
     Raises:
-        ValueError: if _k value is not between 0.65 and 1 or kc is not
-            larger than 0 and lower than 1. If diameters phi_s or
-            phi_p are lower than 0. If ratio of bond xi strength e
-            is less than 0.15 or larger than 0.8.
-            Is stress variation incr_stress is less than 0.
+        ValueError: If k value is not between 0.65 and 1 or kc is not larger
+        than 0 and lower than 1. If diameters phi_s or phi_p are lower than 0.
+        If ratio of bond xi strength is less than 0.15 or larger than 0.8. If
+        stress variation incr_stress is less than 0.
     """
     fct_eff = abs(fct_eff)
 
@@ -362,12 +363,12 @@ def As_min_p(
         raise ValueError(f'A_ct={A_ct} must be larger than 0')
     if sigma_s < 0:
         raise ValueError(f'sigma_s={sigma_s} must be equal or larger than 0')
-    if _k < 0.65 or _k > 1.0:
-        raise ValueError(f'_k={_k} must be between 0.65 and 1')
+    if k < 0.65 or k > 1.0:
+        raise ValueError(f'k={k} must be between 0.65 and 1')
     if kc > 1 or kc < 0:
         raise ValueError(f'kc={kc} must be lower than 1 and larger than 0')
 
-    a1 = kc * _k * fct_eff * A_ct
+    a1 = kc * k * fct_eff * A_ct
     e1 = xi1(xi, phi_p, phi_s)
     a2 = e1 * Ap * delta_s
     a = a1 - a2
@@ -376,7 +377,7 @@ def As_min_p(
 
 
 def As_min_2(
-    _wk: float,
+    wk: float,
     sigma_s: float,
     fct_eff: float,
     h_cr: float,
@@ -388,40 +389,43 @@ def As_min_2(
     """Computes the minimum area of reinforcing steel within the tensile zone
     for control of cracking areas.
 
-    EUROCODE 2 1992-1-1:2004, Table (7.2N), Table (7.3N)
+    EUROCODE 2 1992-1-1:2004, Table (7.2N), Table (7.3N).
 
     Args:
-        _wk (float): the characteristic crack width value in mm.
+        wk (float): the characteristic crack width value in mm.
         sigma_s (float): the steel stress value in MPa under the relevant
             combination of actions.
         fct_eff (float): is the mean value of the tensile strength in MPa of
             the concrete effective at the time when the cracks may first be
-            expected to occur: fct,eff=fct or lower (fct(t)), is cracking
-            is expected earlier than 28 days.
+            expected to occur: fct,eff=fct or lower (fct(t)), is cracking is
+            expected earlier than 28 days.
         h_cr (float): is the depth of the tensile zone immediately prior to
             cracking, considering the characteristic values of prestress and
             axial forces under the quasi-permanent combination of actions.
         h (float): the overall depth of the section in mm.
-        d (float): is the effective depth to the centroid of the outer layer
-            of the reinforcement.
+        d (float): is the effective depth to the centroid of the outer layer of
+            the reinforcement.
+
+    Keyword Args:
         delta_s (float, optional): value of prestressed stress in MPa if
-            applicable
+            applicable.
         kc (float, optional): is a coefficient which takes account of the
             stress distribution within the section immediately prior to
-            cracking and the change of the lever arm in a bending section.
-            'None' for pure tensile uniform axial section.
+            cracking and the change of the lever arm in a bending section. None
+            for pure tensile uniform axial section.
 
     Returns:
-        tuple(float, float): with the value of the maximum bar diameters in mm
-        in the first position and the maximum bar spacing in mm in the
-        second position
+        tuple(float, float): With the value of the maximum bar diameters in mm
+        in the first position and the maximum bar spacing in mm in the second
+        position.
+
     Raises:
-        ValueError: if _wk, fct_eff, h_cr, h or d are less than 0
-        ValueError: if kc is not between 0 and 1
-        ValueError: if combination of wk and stress values are out of scope
+        ValueError: If wk, fct_eff, h_cr, h or d are less than 0.
+        ValueError: If kc is not between 0 and 1.
+        ValueError: If combination of wk and stress values are out of scope.
     """
-    if _wk < 0:
-        raise ValueError(f'_wk={_wk} cannot be less than 0')
+    if wk < 0:
+        raise ValueError(f'wk={wk} cannot be less than 0')
     if fct_eff < 0:
         raise ValueError(f'fct_eff={fct_eff} is less than 0')
     if h_cr < 0:
@@ -489,7 +493,7 @@ def As_min_2(
 
     points_phi = np.array(np.meshgrid(y_phi, x)).T.reshape(-1, 2)
     points_spa = np.array(np.meshgrid(y_spa, x)).T.reshape(-1, 2)
-    xi = (s, _wk)
+    xi = (s, wk)
 
     phi_star = float(
         scipy.interpolate.griddata(points_phi, phi_s_v, xi, method='linear')
@@ -504,25 +508,25 @@ def As_min_2(
     )
 
     if math.isnan(phi) or math.isnan(spa):
-        raise ValueError('Combination of _wk or stress values out of scope')
+        raise ValueError('Combination of wk or stress values out of scope')
 
     return phi, spa
 
 
 def alpha_e(Es: float, Ecm: float) -> float:
-    """Compute the ratio between the steel and mean concrete
-    elastic modules.
+    """Compute the ratio between the steel and mean concrete elastic modules.
 
     EUROCODE 2 1992-1-1:2004, Section 7.3.4-2
 
     Args:
-        Es (float): steel elastic modulus in MPa
-        Ecm (float): concrete mean elastic modulus in MPa
+        Es (float): Steel elastic modulus in MPa.
+        Ecm (float): Concrete mean elastic modulus in MPa.
 
     Returns:
-        float: ratio between modules
-    Raise:
-        ValueError: if any of es or ecm is lower than 0.
+        float: Ratio between modules.
+
+    Raises:
+        ValueError: If any of es or ecm is lower than 0.
     """
     if Es < 0:
         raise ValueError(f'Es={Es} cannot be less than 0')
@@ -532,52 +536,49 @@ def alpha_e(Es: float, Ecm: float) -> float:
     return Es / Ecm
 
 
-def rho_p_eff(As: float, _xi1: float, Ap: float, Ac_eff: float) -> float:
+def rho_p_eff(As: float, xi1: float, Ap: float, Ac_eff: float) -> float:
     """Effective bond ratio between areas.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.10)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.10).
 
     Args:
-        As (float): steel area in mm2
-        _xi1 (float): the adjusted ratio of bond according
-            to expression (7.5)
-        Ap (float): the area in mm2 of post-tensioned tendons in ac_eff
-        Ac_eff (float): effective area of concrete in tension surrounding
-        the reinforcement or prestressing tendons of depth hc_eff.
+        As (float): Steel area in mm2.
+        xi1 (float): The adjusted ratio of bond according to expression (7.5).
+        Ap (float): The area in mm2 of post-tensioned tendons in ac_eff.
+        Ac_eff (float): Effective area of concrete in tension surrounding the
+            reinforcement or prestressing tendons of depth hc_eff.
 
     Returns:
-        float: with the retio between areas
+        float: With the retio between areas.
 
-
-    Raise:
-        ValueError: if any of As, xi1, Ap or Ac_eff is less than 0
+    Raises:
+        ValueError: If any of As, xi1, Ap or Ac_eff is less than 0.
     """
     if As < 0:
         raise ValueError(f'As={As} cannot be less than 0')
-    if _xi1 < 0:
-        raise ValueError(f'_xi1={_xi1} cannot be less than 0')
+    if xi1 < 0:
+        raise ValueError(f'xi1={xi1} cannot be less than 0')
     if Ap < 0:
         raise ValueError(f'Ap={Ap} cannot be less than 0')
     if Ac_eff < 0:
         raise ValueError(f'Ac_eff={Ac_eff} cannot be less than 0')
 
-    return (As + _xi1**2 * Ap) / Ac_eff
+    return (As + xi1**2 * Ap) / Ac_eff
 
 
-def kt(load_type: str) -> float:
-    """Returns the kt factor dependent on the load duration for
-    the crack width calculation.
+def kt(load_type: t.Literal['short', 'long']) -> float:
+    """Returns the kt factor dependent on the load duration for the crack width
+    calculation.
 
     Args:
-        load_type (str): the load type:
-            - 'short' for term loading
-            - 'long' for long term loading
+        load_type (str): The load type, 'short' for term loading, 'long' for
+            long term loading.
 
     Returns:
-        float: with the kt factor
+        float: With the kt factor.
 
     Raises:
-        ValueError: if load_type is not 'short' and not 'long'
+        ValueError: If load_type is not 'short' and not 'long'.
     """
     if not isinstance(load_type, str):
         raise TypeError
@@ -593,9 +594,9 @@ def kt(load_type: str) -> float:
 
 def eps_sm_eps_cm(
     sigma_s: float,
-    _alpha_e: float,
-    _rho_p_eff: float,
-    _kt: float,
+    alpha_e: float,
+    rho_p_eff: float,
+    kt: float,
     fct_eff: float,
     Es: float,
 ) -> float:
@@ -606,70 +607,70 @@ def eps_sm_eps_cm(
     strain beyond the state of zero strain of the concrete is considered.
     epsilon_cm is the mean strain in the concrete between the cracks.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.9)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.9).
 
     Args:
-        sigma_s (float): is the stress in MPa in the tension reinforcement
+        sigma_s (float): Is the stress in MPa in the tension reinforcement
             assuming a cracked section. For pretensioned members, s_steel may
             be replaced by increment of s_steel stress variation in
-            prestressing tendons from the state of zero strain of the
-            concrete at the same level.
-        _alpha_e (float): is the ratio Es/Ecm
-        _rho_p_eff (float): effective bond ratio between areas given by the
-            Eq. (7.10)
-        _kt (float): is a factor dependent on the load duration
-        fct_eff (float): is the mean value of the tensile strength in MPa
-            of the concrete effective at the time when the cracks may
-            first be expected to occur: fct_eff=fctm or fctm(t) if
-            crack is expected earlier than 28 days.
-        Es: steel elastic modulus in MPa
+            prestressing tendons from the state of zero strain of the concrete
+            at the same level.
+        alpha_e (float): Is the ratio Es/Ecm.
+        rho_p_eff (float): Effective bond ratio between areas given by Eq.
+            (7.10).
+        kt (float): Is a factor dependent on the load duration.
+        fct_eff (float): Is the mean value of the tensile strength in MPa of
+            the concrete effective at the time when the cracks may first be
+            expected to occur: fct_eff=fctm or fctm(t) if crack is expected
+            earlier than 28 days.
+        Es (float): Steel elastic modulus in MPa.
 
     Returns:
-        float: the strain difference between concrete and steel
+        float: The strain difference between concrete and steel.
 
     Raises:
-        ValueError: if any sigma_s, _alpha_e, _rho_p_eff, fct_eff or Es is less
+        ValueError: If any sigma_s, alpha_e, rho_p_eff, fct_eff or Es is less
             than 0.
-        ValueError: if _kt is not 0.6 and not 0.4
+        ValueError: if kt is not 0.6 and not 0.4.
     """
     if sigma_s < 0:
         raise ValueError(f'sigma_s={sigma_s} cannot be less than 0')
-    if _alpha_e < 0:
-        raise ValueError(f'_alpha_e={_alpha_e} cannot be less than 0')
-    if _rho_p_eff < 0:
-        raise ValueError(f'_rho_p_eff={_rho_p_eff} cannot be less than 0')
+    if alpha_e < 0:
+        raise ValueError(f'alpha_e={alpha_e} cannot be less than 0')
+    if rho_p_eff < 0:
+        raise ValueError(f'rho_p_eff={rho_p_eff} cannot be less than 0')
     if fct_eff < 0:
         raise ValueError(f'fct_eff={fct_eff} cannot be less than 0')
     if Es < 0:
         raise ValueError(f'Es={Es} cannot be less than 0')
-    if _kt not in (0.6, 0.4):
-        raise ValueError(f'_kt={_kt} can only take as values 0.4 and 0.6')
+    if kt not in (0.6, 0.4):
+        raise ValueError(f'kt={kt} can only take as values 0.4 and 0.6')
 
     min_val = 0.6 * sigma_s / Es
 
-    a = 1 + _alpha_e * _rho_p_eff
-    b = _kt * fct_eff / _rho_p_eff * a
+    a = 1 + alpha_e * rho_p_eff
+    b = kt * fct_eff / rho_p_eff * a
     c = (sigma_s - b) / Es
 
     return max(c, min_val)
 
 
 def w_spacing(c: float, phi: float) -> float:
-    """Computes the distance threshold from which the
-    maximum crack spacing is constant.
+    """Computes the distance threshold from which the maximum crack spacing is
+    constant.
 
-    EUROCODE 2 1992-1-1:2004, Sect. (7.3.4-3)
+    EUROCODE 2 1992-1-1:2004, Sect. (7.3.4-3).
 
     Args:
-        c (float): cover of  the longitudinal reinforcement in mm
-        phi (float): is the bar diameter in mm. Where mixed bar diameters
-            used, then it should be replaced for an equivalent bar diameter.
+        c (float): Cover of the longitudinal reinforcement in mm.
+        phi (float): Is the bar diameter in mm. Where mixed bar diameters used,
+            then it should be replaced for an equivalent bar diameter.
 
     Returns:
-        float: threshold distance in mm
+        float: Threshold distance in mm.
 
     Raises:
-        ValueError: if any of c or phi is less than 0.
+        ValueError: If any of c or phi is less than 0.
     """
     if c < 0:
         raise ValueError(f'c={c} cannot be less than 0')
@@ -680,24 +681,24 @@ def w_spacing(c: float, phi: float) -> float:
 
 
 def phi_eq(n1: int, n2: int, phi1: float, phi2: float) -> float:
-    """Computes the equivalent diameter. For a section with n1 bars of
-    diameter phi1 and n2 bars of diameter phi2.
+    """Computes the equivalent diameter. For a section with n1 bars of diameter
+    phi1 and n2 bars of diameter phi2.
 
-    EUROCODE 2 1992-1-1:2004, Sect. (7.12)
+    EUROCODE 2 1992-1-1:2004, Sect. (7.12).
 
     Args:
-        n1 (int): number of bars with diameter phi1
-        n2 (int): number of bars with diameter phi2
-        phi1 (float): diameter of n1 bars in mm
-        phi2 (float): diamater of n2 bars in mm
+        n1 (int): Number of bars with diameter phi1.
+        n2 (int): Number of bars with diameter phi2.
+        phi1 (float): Diameter of n1 bars in mm.
+        phi2 (float): Diamater of n2 bars in mm.
 
     Returns:
-        float: the equivalent diameter in mm
+        float: The equivalent diameter in mm.
 
     Raises:
-        ValueError: if any of n1 or n2 is less than 0
-        ValueError: if any of phi1 or phi2 is less than 0
-        TypeError: if any of n1 or n2 is not an integer
+        ValueError: If any of n1 or n2 is less than 0.
+        ValueError: If any of phi1 or phi2 is less than 0.
+        TypeError: If any of n1 or n2 is not an integer.
     """
     if n1 < 0:
         raise ValueError(f'n1={n1} cannot be less than 0')
@@ -717,25 +718,22 @@ def phi_eq(n1: int, n2: int, phi1: float, phi2: float) -> float:
     return a / b
 
 
-def k1(bond_type: str) -> float:
-    """Get the k1 coefficient which takes account of the bond properties
-    of the bounded reinforcement.
+def k1(bond_type: t.Literal['bond', 'plain']) -> float:
+    """Get the k1 coefficient which takes account of the bond properties of the
+    bounded reinforcement.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.11-k1)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.11-k1).
 
     Args:
-        bond_type (str): the bond property of the reinforcement.
-        Possible values:
-            - 'bond': for high bond bars
-            - 'plain': for bars with an effectively plain surface (e.g.
-            prestressing tendons)
+        bond_type (str): The bond property of the reinforcement. High bond bars
+            (bond), or bars with an effectively plain surface (plain).
 
     Returns:
-        (float): value of the k1 coefficient
+        float: Value of the k1 coefficient.
 
     Raises:
-        ValueError: if bond_type is neither 'bond' nor 'plain'
-        TypeError: if bond_type is not an str
+        ValueError: If bond_type is neither 'bond' nor 'plain'.
+        TypeError: If bond_type is not an str.
     """
     if not isinstance(bond_type, str):
         raise TypeError(f'bond_type={bond_type} is not an str')
@@ -752,19 +750,19 @@ def k1(bond_type: str) -> float:
 def k2(eps_r: float) -> float:
     """Computes a coeff. which takes into account the distribution of strain.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.13)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.13).
 
     Args:
-        eps_r (float): ratio epsilon_2/epsilon_1 where epsilon_1 is
-            the greater and epsilon_2 is the lesser strain at the boundaries
-            of the section considered, assessed on the basis of a cracked
-            section. epsilon_r=0 for bending and epsilon_r=1 for pure tension.
+        eps_r (float): ratio epsilon_2/epsilon_1 where epsilon_1 is the greater
+            and epsilon_2 is the lesser strain at the boundaries of the section
+            considered, assessed on the basis of a cracked section. epsilon_r=0
+            for bending and epsilon_r=1 for pure tension.
 
     Returns:
-        float: the k2 coefficient value.
+        float: The k2 coefficient value.
 
     Raises:
-        ValueError: if eps_r is not between 0 and 1.
+        ValueError: If eps_r is not between 0 and 1.
     """
     if eps_r < 0 or eps_r > 1:
         raise ValueError(f'eps_r={eps_r} must be between 0 and 1')
@@ -776,7 +774,7 @@ def k3():
     """Returns the k3 coefficient for computing sr_max.
 
     Returns:
-        float: value for the coefficient
+        float: Value for the coefficient.
     """
     return 3.4
 
@@ -785,90 +783,95 @@ def k4():
     """Returns the k4 coefficient for computing sr_max.
 
     Returns:
-        float: value for the coefficient
+        float: Value for the coefficient.
     """
     return 0.425
 
 
+K_COEFFICIENTS = {'k1': k1, 'k2': k2, 'k3': k3, 'k4': k4}
+
+
 def sr_max_close(
     c: float,
     phi: float,
-    _rho_p_eff: float,
-    _k1: float,
-    _k2: float,
-    _k3: t.Optional[float] = None,
-    _k4: t.Optional[float] = None,
+    rho_p_eff: float,
+    k1: float,
+    k2: float,
+    k3: t.Optional[float] = None,
+    k4: t.Optional[float] = None,
 ) -> float:
     """Computes the maximum crack spacing in cases where bonded reinforcement
     is fixed at reasonably close centres within the tension zone
     (w_spacing<=5(c+phi/2)).
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.11)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.11).
 
     Args:
-        c (float): is the cover in mm of the longitudinal reinforcement
-        phi (float): is the bar diameter in mm. Where mixed bar diameters
-            used, then it should be replaced for an equivalent bar diameter.
-        _rho_p_eff (float): effective bond ratio between areas given by the
-            Eq. (7.10)
-        _k1 (float): coefficient that takes into account the bound properties
-            of the bonded reinforcement
-        _k2 (float): coefficient that takes into account the distribution of
-            of the strain
-        _k3 (float, optional): coefficient from the National Annex.
-            If not specified then _k3=3.4
-        _k4 (float): coefficient from the National Annex.
-            If not specified then _k4=0.425
+        c (float): Is the cover in mm of the longitudinal reinforcement.
+        phi (float): Is the bar diameter in mm. Where mixed bar diameters used,
+            then it should be replaced for an equivalent bar diameter.
+        rho_p_eff (float): Effective bond ratio between areas given by Eq.
+            (7.10).
+        k1 (float): Coefficient that takes into account the bound properties
+            of the bonded reinforcement.
+        k2 (float): Coefficient that takes into account the distribution of of
+            the strain.
+
+    Keyword Args:
+        k3 (float, optional): Coefficient from the National Annex. If not
+            specified then k3=3.4.
+        k4 (float): Coefficient from the National Annex. If not specified then
+            k4=0.425.
 
     Returns:
-        float: the maximum crack spaing in mm.
+        float: The maximum crack spaing in mm.
 
     Raises:
-        ValueError: if one or more of c, phi, _rho_p_eff, _k3 or _k4
+        ValueError: If one or more of c, phi, rho_p_eff, k3 or k4
             is lower than zero.
-        ValueError: if _k1 is not 0.8 or 1.6
-        ValueError: if _k2 is not between 0.5 and 1.0
+        ValueError: If k1 is not 0.8 or 1.6.
+        ValueError: If k2 is not between 0.5 and 1.0.
     """
-    if _k3 is None:
-        _k3 = k3()
-    if _k4 is None:
-        _k4 = k4()
+    if k3 is None:
+        k3 = K_COEFFICIENTS['k3']()
+    if k4 is None:
+        k4 = K_COEFFICIENTS['k4']()
 
     if c < 0:
         raise ValueError(f'c={c} cannot be less than zero')
     if phi < 0:
         raise ValueError(f'phi={phi} cannot be less than zero')
-    if _rho_p_eff < 0:
-        raise ValueError(f'_rho_p_eff={_rho_p_eff} cannot be less than zero')
-    if _k3 < 0:
-        raise ValueError(f'_k3={_k3} cannot be less than zero')
-    if _k4 < 0:
-        raise ValueError(f'_k4={_k4} cannot be less than zero')
-    if _k1 not in (0.8, 1.6):
-        raise ValueError(f'_k1={_k1} can only take as values 0.8 and 1.6')
-    if _k2 < 0.5 or _k2 > 1:
-        raise ValueError(f'_k2={_k2} is not between 0.5 and 1.0')
+    if rho_p_eff < 0:
+        raise ValueError(f'rho_p_eff={rho_p_eff} cannot be less than zero')
+    if k3 < 0:
+        raise ValueError(f'k3={k3} cannot be less than zero')
+    if k4 < 0:
+        raise ValueError(f'k4={k4} cannot be less than zero')
+    if k1 not in (0.8, 1.6):
+        raise ValueError(f'k1={k1} can only take as values 0.8 and 1.6')
+    if k2 < 0.5 or k2 > 1:
+        raise ValueError(f'k2={k2} is not between 0.5 and 1.0')
 
-    return _k3 * c + _k1 * _k2 * _k4 * phi / _rho_p_eff
+    return k3 * c + k1 * k2 * k4 * phi / rho_p_eff
 
 
 def sr_max_far(h: float, x: float) -> float:
     """Computes the maximum crack spacing in cases where bonded reinforcement
-    exceeds (w_spacing>5(c+phi/2)) or where there is no bonded reinforcement
-    at all.
+    exceeds (w_spacing>5(c+phi/2)) or where there is no bonded reinforcement at
+    all.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.14)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.14).
 
     Args:
-        h (float): total depth of the beam in mm
-        x (float): distance to non tension area of the element mm
+        h (float): Total depth of the beam in mm.
+        x (float): Distance to non tension area of the element mm.
 
     Returns:
-        float: maximum crack spacing in mm
+        float: Maximum crack spacing in mm.
 
     Raises:
-        ValueError: if one of h or x is less than zero.
-        ValueError: x is greater than h.
+        ValueError: If one of h or x is less than zero.
+        ValueError: If x is greater than h.
     """
     if x < 0:
         raise ValueError(f'x={x} cannot be less than zero')
@@ -881,25 +884,24 @@ def sr_max_far(h: float, x: float) -> float:
 
 
 def sr_max_theta(sr_max_y: float, sr_max_z: float, theta: float) -> float:
-    """Computes the crack spacing sr_max when there is an angle
-    between the angle of  principal stress and the direction
-    of the reinforcement, for members in two orthogonal directions,
-    that is significant (> 15º).
+    """Computes the crack spacing sr_max when there is an angle between the
+    angle of principal stress and the direction of the reinforcement, for
+    members in two orthogonal directions, that is significant (> 15 degrees).
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.15)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.15).
 
     Args:
-        sr_max_y (float): crack spacing in mm in the y-direction.
-        sr_max_z (float): crack spacing in mm in the z-direction.
-        theta (float): angle in radians between the reinforcement in the
+        sr_max_y (float): Crack spacing in mm in the y-direction.
+        sr_max_z (float): Crack spacing in mm in the z-direction.
+        theta (float): Angle in radians between the reinforcement in the
             y-direction and the direction of the principal tensile stress.
 
     Returns:
-        float: the crack spacing in mm.
+        float: The crack spacing in mm.
 
     Raises:
-        ValueError: if sr_max_y or sr_max_z is negative.
-        ValueError: if theta is not between 0 and pi/2
+        ValueError: If sr_max_y or sr_max_z is negative.
+        ValueError: If theta is not between 0 and pi/2.
     """
     if sr_max_y < 0:
         raise ValueError(f'sr_max_y={sr_max_y} cannot be less than zero')
@@ -911,30 +913,29 @@ def sr_max_theta(sr_max_y: float, sr_max_z: float, theta: float) -> float:
     return 1 / (a + b)
 
 
-def wk(sr_max: float, _eps_sm_eps_cm: float) -> float:
+def wk(sr_max: float, eps_sm_eps_cm: float) -> float:
     """Computes the crack width.
 
-    EUROCODE 2 1992-1-1:2004, Eq. (7.8)
+    EUROCODE 2 1992-1-1:2004, Eq. (7.8).
 
     Args:
-        sr_max (float): the maximum crack length spacing in mm.
-        _eps_sm_eps_cm (float): the difference between the mean strain in the
-            reinforcement under relevant combination of loads, including
-            the effect of imposed deformations and taking into account
-            tension stiffening and the mean strain in the concrete
-            between cracks.
+        sr_max (float): The maximum crack length spacing in mm.
+        eps_sm_eps_cm (float): the difference between the mean strain in the
+            reinforcement under relevant combination of loads, including the
+            effect of imposed deformations and taking into account tension
+            stiffening and the mean strain in the concrete between cracks.
 
     Returns:
-        float: crack width in mm.
+        float: Crack width in mm.
 
     Raises:
-        ValueError: if any of sr_max or esm_ecm is less than zero.
+        ValueError: If any of sr_max or esm_ecm is less than zero.
     """
     if sr_max < 0:
         raise ValueError(f'sr_max={sr_max} cannot be less than zero')
-    if _eps_sm_eps_cm < 0:
+    if eps_sm_eps_cm < 0:
         raise ValueError(
-            f'_eps_sm_eps_cm={_eps_sm_eps_cm} cannot be less than zero'
+            f'eps_sm_eps_cm={eps_sm_eps_cm} cannot be less than zero'
         )
 
-    return sr_max * _eps_sm_eps_cm
+    return sr_max * eps_sm_eps_cm
diff --git a/structuralcodes/codes/ec2_2004/annex_b_shrink_and_creep.py b/structuralcodes/codes/ec2_2004/annex_b_shrink_and_creep.py
index c95baba4..fc046afb 100644
--- a/structuralcodes/codes/ec2_2004/annex_b_shrink_and_creep.py
+++ b/structuralcodes/codes/ec2_2004/annex_b_shrink_and_creep.py
@@ -2,109 +2,126 @@
 Annex B.
 """
 
-# Importing only required modules from the packages
-from math import e
+import math
+import typing as t
 
-from numpy import interp
+import numpy as np
 
+ALPHA_CEMENT_DICT = {'R': 1, 'N': 0, 'S': -1}
+ALPHA_DS_DICT = {
+    'R': {'alpha_ds1': 6, 'alpha_ds2': 0.11},
+    'N': {'alpha_ds1': 4, 'alpha_ds2': 0.12},
+    'S': {'alpha_ds1': 3, 'alpha_ds2': 0.13},
+}
 
-def annex_B_creep(
+
+def phi(
     h_0: float,
     f_cm: float,
     RH: int = 50,
-    cement_class: str = 'R',
+    cement_class: t.Literal['R', 'N', 'S'] = 'R',
     t0: int = 7,
     t: int = 18263,
 ) -> float:
-    """This function will calculate creep according to Annex B in
-     EUROCODE 1992-1-1:2004.
+    """Calculates the creep number.
+
+    EN 1992-1-1:2004, Eq. (B.1).
 
     Args:
-        h_0 (float): The product of 2 times the cross-sectional area divided
-        by the exposed circumference according to (B.6),
+        h_0 (float): The product of 2 times the cross-sectional area divided by
+            the exposed circumference according to (B.6).
         f_cm (float): The mean concrete strength,
-        RH (int): The relative humidity in percent, defaults to 50%,
-        cement_class (str): The cement class, defaults to 'R'.
-            Possible values: 'R', 'N', 'S',
-        t0: the age of the concrete at the time (in days) of loading
-        t: the age of the concrete at the time (in days) of evaluation
-            (50 years default)
+        RH (int): The relative humidity in percent, defaults to 50%.
+
+    Keyword Args:
+        cement_class (str): The cement class, defaults to 'R'. Possible values:
+            'R', 'N', 'S',
+        t0: The age of the concrete at the time (in days) of loading.
+        t: The age of the concrete at the time (in days) of evaluation (50
+            years default).
 
     Returns:
-        phi(t, t0): the creep value for the load
+        float: The creep value for the load, phi(t, t0).
 
     Raises:
         ValueError: checks if the cement class equals R, N or S.
     """
     # The cement class will decide the value of alpha_cement, ds1 and ds2.
     # The values are given in (B.9) and (B.12)
-    alpha_cement_dict = {'R': 1, 'N': 0, 'S': -1}
-    alpha_cement = alpha_cement_dict.get(cement_class)
+
+    _cement_class = cement_class.upper().strip()
+    alpha_cement = ALPHA_CEMENT_DICT.get(_cement_class)
     if alpha_cement is None:
         raise ValueError(f'cement_class={cement_class}, expected R, N or S')
 
-    beta_H = calculate_beta_H(h_0, f_cm, RH)
-    phi_RH = calculate_phi_RH(h_0, f_cm, RH)
-    beta_fcm = calculate_beta_fcm(f_cm)
-    t0_adjusted = calculate_t0_adjusted(t0, alpha_cement)
-    beta_t0 = 1 / (0.1 + t0_adjusted**0.20)  # (B.5)
-    beta_c = calculate_beta_c(t0, t, beta_H)
+    _beta_H = beta_H(h_0, f_cm, RH)
+    _phi_RH = phi_RH(h_0, f_cm, RH)
+    _beta_fcm = beta_fcm(f_cm)
+    _t0_adj = t0_adj(t0, alpha_cement)
+    beta_t0 = 1 / (0.1 + _t0_adj**0.20)  # (B.5)
+    _beta_c = beta_c(t0, t, _beta_H)
+
+    phi_0 = _phi_RH * _beta_fcm * beta_t0  # (B.2)
+    return phi_0 * _beta_c
 
-    phi_0 = phi_RH * beta_fcm * beta_t0  # (B.2)
-    return phi_0 * beta_c
 
+def beta_c(t0: float, t: float, beta_H: float) -> float:
+    """Calculates the factor beta_c.
 
-def calculate_beta_c(t0: float, t: float, beta_H: float) -> float:
-    """Calculates the factor beta_c as defined by Equation (B.7).
+    EN 1992-1-1:2004, Eq. (B.7).
 
     Args:
-        t0 (float) the concrete age in days a the time of loading
-        t (float) the concrete age at the evaluated time
-        beta_H: parameter defined in (B.8)
+        t0 (float): The concrete age in days a the time of loading.
+        t (float): The concrete age at the evaluated time.
+        beta_H: Parameter defined in (B.8).
 
-    Return:
-        beta_c (float): parameter defined by Equation (B.7)
+    Returns:
+        float: Parameter defined by Equation (B.7), beta_c.
     """
     return ((t - t0) / (beta_H + t - t0)) ** 0.3
 
 
-def calculate_t0_adjusted(t0: float, alpha_cement: float) -> float:
-    """Calculates the adjusted age of the concrete according to Annex B (2)
-    Equation (B.9).
+def t0_adj(t0: float, alpha_cement: float) -> float:
+    """Calculates the adjusted age of the concrete.
+
+    EN 1992-1-1:2004, Eq. (B.9).
 
     Args:
-        t0 (float): the concrete age in days at the time of loading
-        alpha_cement (float): exponent derived from the sement type
+        t0 (float): The concrete age in days at the time of loading.
+        alpha_cement (float): Exponent derived from the sement type.
 
-    Return:
-        float: the adjusted age of the concrete
+    Returns:
+        float: The adjusted age of the concrete.
     """
     return max(t0 * (9 / (2 + t0**1.2) + 1) ** alpha_cement, 0.5)
 
 
-def calculate_beta_fcm(f_cm: float) -> float:
-    """Calculates beta_f_cm according to Equation (B.4).
+def beta_fcm(f_cm: float) -> float:
+    """Calculates beta_f_cm.
+
+    EN 1992-1-1:2004, Eq. (B.4).
 
     Args:
-        f_cm (float): the mean concrete strength
+        f_cm (float): The mean concrete strength.
 
-    Return:
-        float: the factor defined in Equation (B.4)
+    Returns:
+        float: The factor defined in Equation (B.4).
     """
     return 16.8 / f_cm**0.5
 
 
-def calculate_phi_RH(h_0: float, f_cm: float, RH: int) -> float:
-    """This function calculates phi_RH according to Annex B in EUROCODE
-    1992-1-1:2004.
+def phi_RH(h_0: float, f_cm: float, RH: int) -> float:
+    """Calculates phi_RH.
+
+    EN 1992-1-1:2004, Eq. (B.3).
 
     Args:
-        h_0 (float): the effective cross sectional thickness, Equation (B.6)
-        f_cm (float): The mean concrete strength,
-        RH (int): The relative humidity in percent
+        h_0 (float): The effective cross sectional thickness, Equation (B.6).
+        f_cm (float): The mean concrete strength.
+        RH (int): The relative humidity in percent.
 
     Returns:
-        phi_RH (float): the calculation parameter (B.3)
+        float: The calculation parameter (B.3).
     """
     # (B.8c) Alpha 1 to 2 is a constant where the only variable is f_cm
     alpha_1, alpha_2 = (
@@ -113,69 +130,69 @@ def calculate_phi_RH(h_0: float, f_cm: float, RH: int) -> float:
     )
 
     if f_cm <= 35:
-        phi_RH = 1 + (1 - RH / 100) / (0.1 * h_0 ** (1 / 3))
-    else:
-        phi_RH = (
-            1 + (1 - RH / 100) / (0.1 * h_0 ** (1 / 3)) * alpha_1
-        ) * alpha_2
-    return phi_RH
+        return 1 + (1 - RH / 100) / (0.1 * h_0 ** (1 / 3))
+    return (1 + (1 - RH / 100) / (0.1 * h_0 ** (1 / 3)) * alpha_1) * alpha_2
 
 
-def calculate_beta_H(h_0: float, f_cm: float, RH: int) -> float:
-    """This function will calculate eps_cd_0 according to Annex B in EUROCODE
-    1992-1-1:2004.
+def beta_H(h_0: float, f_cm: float, RH: int) -> float:
+    """Calculates beta_H.
+
+    EN 1992-1-1:2004, Eq. (B.8a and b).
 
     Args:
-        h_0 (float): The cement class, defaults to 'R'.
-            Possible values: 'R', 'N', 'S',
-        f_cm (float): The mean concrete strength,
-        RH (int): Calculation parameter from equation (B.12).
+        h_0 (float): The effective cross sectional thickness, Equation (B.6).
+        f_cm (float): The mean concrete strength.
+        RH (int): The relative humidity in percent.
 
     Returns:
-        beta_H (float): the calculation parameters defined in (B.8)
+        float: The calculation parameter defined in (B.8).
     """
     # (B.8c) Alpha 3 is a constant where f_cm is the only  variable
     alpha_3 = (35 / f_cm) ** 0.5
 
     if f_cm <= 35:
         # (B.8a) and (B.3a) applies
-        beta_H = min(1.5 * (1 + (0.012 * RH) ** 18) * h_0 + 250, 1500)
-    else:
-        # (B.8b) and (B.3b) applies
-        beta_H = min(
-            1.5 * (1 + (0.012 * RH) ** 18) * h_0 + 250 * alpha_3,
-            1500 * alpha_3,
-        )
-    return beta_H
+        return min(1.5 * (1 + (0.012 * RH) ** 18) * h_0 + 250, 1500)
+    # (B.8b) and (B.3b) applies
+    return min(
+        1.5 * (1 + (0.012 * RH) ** 18) * h_0 + 250 * alpha_3,
+        1500 * alpha_3,
+    )
 
 
-def annex_B_shrinkage(
+def eps_cs(
     h_0: float,
     f_cm: float,
-    cement_class: str,
+    cement_class: t.Literal['R', 'N', 'S'] = 'R',
     RH: int = 50,
     t_S: int = 28,
     t: int = 18263,
 ) -> float:
-    """This function will calculate shrinkage according to Chapter 3 by using
-     the shrinkage as calculated by Annex B in EUROCODE 1992-1-1:2004.
+    """Calculates the shrinkage strain.
+
+    EN 1992-1-1:2004, Eq. (3.8).
 
     Args:
-        h_0 (float): The product of 2 times the cross-sectional area divided by
-        the exposed circumference according to (B.6),
-        f_cm (float): The mean concrete strength,
-        cement_class (str): The cement class, defaults to 'R'.
-            Possible values: 'R', 'N', 'S',
-        RH (int): The relative humidity in percent, defaults to 50,
-        t_S (int): the number of days when shrinkage begins, default: 28 days,
-        t (int): the concrete age at the time (in days) of evaluation,
-            default: 50 years
+        h_0 (float): The effective cross sectional thickness, Equation (B.6).
+        f_cm (float): The mean concrete strength.
+        cement_class (str): The cement class, defaults to 'R'. Possible values:
+            'R', 'N', 'S'.
+
+    Keyword Args:
+        RH (int): The relative humidity in percent, defaults to 50.
+        t_S (int): the number of days when shrinkage begins, default: 28 days.
+        t (int): the concrete age at the time (in days) of evaluation, default:
+            50 years.
 
     Returns:
-        float: the shrinkage. Given as absolute, not in percent or ppm.
+        float: The shrinkage. Given as absolute, not in percent or ppm.
+
+    Raises:
+        ValueError: Checks if the cement class equals R, N or S.
     """
+    _cement_class = cement_class.upper().strip()
     beta_ds = (t - t_S) / (t - t_S + 0.04 * h_0 ** (1 / 3))  # (3.10)
-    beta_as = 1 - e ** (-0.2 * t**0.5)  # (3.13)
+    beta_as = 1 - math.exp(-0.2 * t**0.5)  # (3.13)
 
     # k_h is defined in Table 3.3 under (3.9)
     if h_0 >= 500:
@@ -183,55 +200,58 @@ def annex_B_shrinkage(
     elif h_0 <= 100:
         k_h = 1.0
     else:
-        k_h = interp(h_0, [100, 200, 300, 500], [1.0, 0.85, 0.75, 0.7])
+        k_h = np.interp(h_0, [100, 200, 300, 500], [1.0, 0.85, 0.75, 0.7])
 
     eps_ca_infinite = 2.5 * (f_cm - 18) * 1e-6  # (3.12)
     eps_ca = beta_as * eps_ca_infinite  # (3.11)
-    eps_cd = (
-        beta_ds * k_h * calculate_eps_cd_0(cement_class, f_cm, RH)
-    )  # (3.9)
+    eps_cd = beta_ds * k_h * eps_cd_0(_cement_class, f_cm, RH)  # (3.9)
     return eps_cd + eps_ca  # (3.8)
 
 
-def calculate_beta_RH(RH: int, RH_0: int = 100) -> float:
-    """This function calculates beta_RH according to Annex B.12
+def beta_RH(RH: int, RH_0: int = 100) -> float:
+    """Calculates beta_RH.
+
+    EN 1992-1-1:2004, Eq. (B.12).
+
     Args:
-        RH (int): The relative humidity
-        RH_0 (int): 100%
+        RH (int): The relative humidity in percent.
+
+    Keyword Args:
+        RH_0 (int): The reference relative humidity, default: 100%.
+
     Returns:
-        beta_RH (float): Calculation parameter from Equation (B.12).
+        float: Calculation parameter from Equation (B.12).
     """
     return 1.55 * (1 - (RH / RH_0) ** 3)
 
 
-def calculate_eps_cd_0(cement_class: str, f_cm: float, RH: int) -> float:
-    """This function will calculate eps_cd_0 according to Annex B in
-    EUROCODE 1992-1-1:2004.
+def eps_cd_0(cement_class: str, f_cm: float, RH: int) -> float:
+    """Calculates eps_cd_0.
+
+    EN 1992-1-1:2004, Eq. (B.11).
 
     Args:
-        cement_class (str): The cement class, defaults to 'R'.
-            Possible values: 'R', 'N', 'S',
-        f_cm (float): The mean concrete strength,
-        RH (int): The relative humidity.
+        cement_class (str): The cement class, defaults to 'R'. Possible values:
+            'R', 'N', 'S'.
+        f_cm (float): The mean concrete strength.
+        RH (int): The relative humidity in percent.
 
     Returns:
-        float: the nominal value for shrinkage
+        float: The nominal value for shrinkage.
 
     Raises:
-        ValueError: checks if the cement class equals R, N or S.
+        ValueError: Checks if the cement class equals R, N or S.
     """
-    alpha_values = {
-        'R': {'alpha_ds1': 6, 'alpha_ds2': 0.11},
-        'N': {'alpha_ds1': 4, 'alpha_ds2': 0.12},
-        'S': {'alpha_ds1': 3, 'alpha_ds2': 0.13},
-    }
-    alpha = alpha_values.get(cement_class)
+    _cement_class = cement_class.upper().strip()
+    alpha = ALPHA_DS_DICT.get(_cement_class)
+    if alpha is None:
+        raise ValueError(f'cement_class={cement_class}, expected R, N or S')
     alpha_ds1 = alpha['alpha_ds1']
     alpha_ds2 = alpha['alpha_ds2']
 
     return (
         0.85
-        * ((220 + 110 * alpha_ds1) * e ** (-alpha_ds2 * f_cm / 10))
+        * ((220 + 110 * alpha_ds1) * math.exp(-alpha_ds2 * f_cm / 10))
         * 1e-6
-        * calculate_beta_RH(RH)
+        * beta_RH(RH)
     )  # (B.11)
diff --git a/structuralcodes/codes/ec2_2004/shear.py b/structuralcodes/codes/ec2_2004/shear.py
index df5f98fb..54480af5 100644
--- a/structuralcodes/codes/ec2_2004/shear.py
+++ b/structuralcodes/codes/ec2_2004/shear.py
@@ -2,9 +2,7 @@
 
 import math
 
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-#                              GENERAL FUNCTIONS                              #
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# General functions
 
 
 # Part of Equation (6.2).
@@ -17,8 +15,8 @@ def _k(d: float) -> float:
         d (float): The effective depth of the cross-section in mm.
 
     Returns:
-        float: Correction factor to account for the cross-sectional
-            size on the shear resistance.
+        float: Correction factor to account for the cross-sectional size on the
+        shear resistance.
     """
     return min(1.0 + math.sqrt(200.0 / d), 2.0)
 
@@ -30,16 +28,15 @@ def _rho_L(Asl: float, bw: float, d: float) -> float:
     Defined in EN 1992-1-1 (2005), Eq. (6.2).
 
     Args:
-        Asl (float): The cross-sectional area of the tensile
-            reinforcement, anchored at least (lbd + d) beyond the
-            considered cross-section, in mm2.
-        bw (float): The smallest width of the cross-section in tension
-            in mm.
+        Asl (float): The cross-sectional area of the tensile reinforcement,
+            anchored at least (lbd + d) beyond the considered cross-section, in
+            mm2.
+        bw (float): The smallest width of the cross-section in tension in mm.
         d (float): The effective depth of the cross-section in mm.
 
     Returns:
-        float: The maximum allowable reinforcement ratio of the
-            longitudinal reinforcement, unitless.
+        float: The maximum allowable reinforcement ratio of the longitudinal
+        reinforcement, unitless.
     """
     return min(Asl / (bw * d), 0.02)
 
@@ -51,62 +48,57 @@ def _sigma_cp(NEd: float, Ac: float, fcd: float) -> float:
     Defined in EN 1992-1-1 (2005), Eq. (6.2).
 
     Args:
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
         fcd (float): The design compressive strength in MPa.
 
     Returns:
-        float: The maximum allowable average prestress in the
-            cross-section in MPa.
+        float: The maximum allowable average prestress in the cross-section in
+        MPa.
     """
     return min(NEd / Ac, 0.2 * fcd)
 
 
 # Part of Equation (6.4)
 def _alpha_l(L_x, L_pt2) -> float:
-    """Compute the relative anchorage length for prestreched
-        prestressing steel.
+    """Compute the relative anchorage length for prestreched prestressing
+    steel.
 
     Defined in EN 1992-1-1 (2005), Eq. (6.4).
 
     Args:
-        L_x (float): Distance from the considered cross-section until
-            the starting point of the transference length of the
-            prestress steel.
+        L_x (float): Distance from the considered cross-section until the
+            starting point of the transference length of the prestress steel.
         L_pt2 (float): Maximum value of the transference length of the
             prestress steel, according to Eq. (8.18).
 
     Returns:
-        float: Fraction (relative anchorage length) for determining the
-            amount of prestress that may be used when determining
-            the shear resistance using Mohr's circle.
+        float: Fraction (relative anchorage length) for determining the amount
+        of prestress that may be used when determining the shear resistance
+        using Mohr's circle.
     """
     return min(L_x / L_pt2, 1.0)
 
 
 # Equation (6.7N)
 def _theta(theta: float, cot_min: float = 1.0, cot_max: float = 2.5) -> None:
-    """Check if the provided angle theta is within the bounds provided
-        by the code.
+    """Check if the provided angle theta is within the bounds provided by the
+    code.
 
     EN 1992-1-1 (2005). Eq. (6.7N)
 
     Args:
-        theta (float): The chosen angle of the compression strut in
-            degrees.
+        theta (float): The chosen angle of the compression strut in degrees.
 
-    Kwargs:
-        cot_min (float): The minimum value for cot(theta). Default
-            value is 1.0. Different value might be provided in the
-            National Annexes.
-        cot_max (float): The maximum value for cot(theta). Default
-            value is 2.5. Different value might be provided in the
-            National Annexes.
+    Keyword Args:
+        cot_min (float): The minimum value for cot(theta). Default value is
+            1.0. Different value might be provided in the National Annexes.
+        cot_max (float): The maximum value for cot(theta). Default value is
+            2.5. Different value might be provided in the National Annexes.
 
     Raises:
-        ValueError if the chosen angle is not within the given
-            bounds.
+        ValueError if the chosen angle is not within the given bounds.
     """
     # Use round to allow less precise angles (i.e. 21.8 degrees instead
     # of 21.801..... degrees for cot_max = 2.5).
@@ -128,24 +120,23 @@ def _theta(theta: float, cot_min: float = 1.0, cot_max: float = 2.5) -> None:
 
 # Equation (6.11N)
 def alpha_cw(Ned: float, Ac: float, fcd: float) -> float:
-    """Calculate factor that affects the maximum shear resistance of
-        the concrete based on the prestress.
+    """Calculate factor that affects the maximum shear resistance of the
+    concrete based on the prestress.
 
     EN 1992-1-1 (2005). Eq. (6.11N)
 
     Args:
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
         fcd (float): The design strength of the concrete in MPa.
 
     Returns:
-        float: Factor that affects the maximum shear resistance of the
-            concrete based on the level of prestress.
+        float: Factor that affects the maximum shear resistance of the concrete
+        based on the level of prestress.
 
     Raises:
-        ValueError: The applied prestress exceeds the concrete design
-            strength.
+        ValueError: The applied prestress exceeds the concrete design strength.
     """
     # No function call for sigma_cp, value is allowed to be higher than
     # 0.2fcd.
@@ -166,9 +157,7 @@ def alpha_cw(Ned: float, Ac: float, fcd: float) -> float:
     return value
 
 
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-#                               NORMAL CONCRETE                               #
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# Without shear reinforcement
 
 
 # Equation (6.2 a + b)
@@ -190,24 +179,21 @@ def VRdc(
     Args:
         fck (float): The characteristic compressive strength in MPa.
         d (float): The effective depth of the cross-section in mm.
-        Asl (float): The cross-sectional area of the tensile
-            reinforcement, anchored atleast (lbd + d) beyond the
-            considered cross-section, in mm2.
-        bw (float): The smallest width of the cross-section in tension
-            in mm.
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        Asl (float): The cross-sectional area of the tensile reinforcement,
+            anchored atleast (lbd + d) beyond the considered cross-section, in
+            mm2.
+        bw (float): The smallest width of the cross-section in tension in mm.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
         fcd (float): The design compressive strength in MPa.
 
-    Kwargs:
-        k1 (float): Factor used to include the effect of the normal
-            stress into the shear resistance of the concrete. Default
-            value = 0.15, value might differ between National Annexes.
-        gamma_c (float): Partial factor for concrete. Default value =
-            1.5, value might differ between National Annexes.
-        alpha_cc (float): A factor for considering long-term effects on the
-            strength, and effects that arise from the way the load is applied.
+    Keyword Args:
+        k1 (float): Factor used to include the effect of the normal stress
+            into the shear resistance of the concrete. Default value = 0.15,
+            value might differ between National Annexes.
+        gamma_c (float): Partial factor for concrete. Default value = 1.5,
+            value might differ between National Annexes.
 
     Returns:
         float: The concrete shear resistance in MPa.
@@ -235,14 +221,13 @@ def vmin(fck: float, d: float) -> float:
         d (float): The effective depth of the cross-section in mm.
 
     Returns:
-        float: The minimal shear stress resistance of the concrete in
-            MPa.
+        float: The minimal shear stress resistance of the concrete in MPa.
     """
     return 0.035 * _k(d) ** (3.0 / 2.0) * fck ** (1 / 2)
 
 
 # Equation (6.4)
-def Vrdc_prin_stress(
+def VRdc_prin_stress(
     Iy: float,
     bw: float,
     S: float,
@@ -252,38 +237,37 @@ def Vrdc_prin_stress(
     L_x: float = None,
     L_pt2: float = None,
 ) -> float:
-    """Calculate the shear resistance in uncracked, prestressed
-    elements without shear reinforcement, value is determined via Mohr's
-    circle.
+    """Calculate the shear resistance in uncracked, prestressed elements
+    without shear reinforcement, value is determined via Mohr's circle.
 
-    The maximal value of the principle tensile stress does no
-        necessarily lay at the centre of gravity. If this is the
-        ase the minimum value of the shear resistance and
-        corresponding stress needs to be found at the relevant location.
+    The maximal value of the principle tensile stress does no necessarily lay
+    at the centre of gravity. If this is the ase the minimum value of the shear
+    resistance and corresponding stress needs to be found at the relevant
+    location.
 
     EN 1992-1-1 (2005), Eq. (6.4).
 
     Args:
-        Iy (float): The second moment of area of the considered
-            cross-section in mm4.
+        Iy (float): The second moment of area of the considered cross-section
+            in mm4.
         bw (float): The width of the cross-section at the centre of gravity.
-        S (float): The first moment of area of the considered
-            cross-section of the part above the centre of gravity, and
-            with respect to the centre of gravity in mm3.
+        S (float): The first moment of area of the considered cross-section of
+            the part above the centre of gravity, and with respect to the
+            centre of gravity in mm3.
         fctd (float): Design value of the tensile strength of the concrete.
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
 
-    Kwargs:
-        L_x (float): Distance from the considered cross-section until
-            the starting point of the transference length of the
-            prestress steel. This value should be provided when the
-            prestressing steel is prestreched. Default value is None.
+    Keyword Args:
+        L_x (float): Distance from the considered cross-section until the
+            starting point of the transference length of the prestress steel.
+            This value should be provided when the prestressing steel is
+            prestreched. Default value is None.
         L_pt2 (float): Maximum value of the transference length of the
             prestress steel, according to Eq. (8.18). This value should be
-            provided when the prestressing steel is prestreched. Default
-            value is None.
+            provided when the prestressing steel is prestreched. Default value
+            is None.
 
     Returns:
         float: The maximum allowable shear force in N for an uncracked,
@@ -305,31 +289,29 @@ def VEdmax_unreinf(
     fck: float,
     fcd: float,
 ) -> float:
-    """Calculate the maximum allowable shear force for cross-sections
-        without shear reinforcement.
+    """Calculate the maximum allowable shear force for cross-sections without
+    shear reinforcement.
 
     En 1992-1-1 (2005), Eq. (6.5).
 
     Args:
-        bw (float): The smallest width of the cross-section in tension
-            in mm.
+        bw (float): The smallest width of the cross-section in tension in mm.
         d (float): The effective depth of the cross-section in mm.
         fck (float): The characteristic compressive strength in MPa.
         fcd (float): The design compressive strength in MPa.
 
-    Return:
-        float: The maximum allowable shear force in the cross-section
-            in N. When a reduced shear force may be considered for the
-            calculations, the unreduced shear force has to comply to
-            this value.
+    Returns:
+        float: The maximum allowable shear force in the cross-section in N.
+        When a reduced shear force may be considered for the calculations, the
+        unreduced shear force has to comply to this value.
     """
     return 0.5 * bw * d * v(fck) * fcd
 
 
 # Equation (6.6N)
 def v(fck: float) -> float:
-    """Calculate a strength redcution factor for concrete cracked by
-        shear forces.
+    """Calculate a strength redcution factor for concrete cracked by shear
+    forces.
 
     EN 1992-1-1 (2005), Eq. (6.6N)
 
@@ -337,16 +319,16 @@ def v(fck: float) -> float:
         fck (float): The characteristic compressive strength in MPa.
 
     Returns:
-        float: A concrete reduction factor to account for concrete
-            cracked by shear forces.
+        float: A concrete reduction factor to account for concrete cracked by
+        shear forces.
     """
     return 0.6 * (1 - fck / 250.0)
 
 
 # Equation (6.10N)
 def v1(fck: float) -> float:
-    """Calculate a strength redcution factor for concrete cracked by
-        shear forces.
+    """Calculate a strength redcution factor for concrete cracked by shear
+    forces.
 
     EN 1992-1-1 (2005), Eq. (6.10N)
 
@@ -354,15 +336,13 @@ def v1(fck: float) -> float:
         fck (float): The characteristic compressive strength in MPa.
 
     Returns:
-        float: A concrete reduction factor to account for concrete
-            cracked by shear forces.
+        float: A concrete reduction factor to account for concrete cracked by
+        shear forces.
     """
     return 0.6 if fck <= 60 else max(0.9 - fck / 200.0, 0.5)
 
 
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
-#                         SHEAR REINFORCEMENT                         #
-# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+# With shear reinforcement
 
 
 # Equation (6.8 & 6.13)
@@ -381,22 +361,20 @@ def VRds(
     EN 1992-1-1 (2005). Eq. (6.8)
 
     Args:
-        Asw (float): the cross-sectional area of the shear
-            reinforcement in mm2.
-        s (float): The centre-to-centre distance of the shear
-            reinforcement in mm.
+        Asw (float): the cross-sectional area of the shear reinforcement in
+            mm2.
+        s (float): The centre-to-centre distance of the shear reinforcement in
+            mm.
         z (float): The inner lever arm of internal forces in mm.
         theta (float): The angle of the compression strut in degrees.
-        fyk (float): The characteristic strength of the reinforcement
-            steel in MPa.
+        fyk (float): The characteristic strength of the reinforcement steel in
+            MPa.
 
-    Kwargs:
-        alpha (float): The angle of the shear reinforcement with
-            respect to the neutral axis in degrees. Default value = 90
-            degrees.
-        gamma_s (float): Partial factor of the reinforcement steel.
-            Default value = 1.15. Value might differ between
-            National Annexes.
+    Keyword Args:
+        alpha (float): The angle of the shear reinforcement with respect to the
+            neutral axis in degrees. Default value = 90 degrees.
+        gamma_s (float): Partial factor of the reinforcement steel. Default
+            value = 1.15. Value might differ between National Annexes.
 
     Returns:
         float: The shear resistance of the shear reinforcement in N.
@@ -436,20 +414,18 @@ def VRdmax(
     EN 1992-1-1 (2005). Eq. (6.9)
 
     Args:
-        bw (float): The smallest width of the cross-section in tension
-            in mm.
+        bw (float): The smallest width of the cross-section in tension in mm.
         z (float): The inner lever arm of internal forces in mm.
         fck (float): The characteristic compressive strength in MPa.
         theta (float): The angle of the compression strut in degrees.
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
         fcd (float): The design compressive strength in MPa.
 
-    Kwargs:
-        alpha (float): The angle of the shear reinforcement with
-            respect to the neutral axis in degrees. Default value = 90
-            degrees.
+    Keyword Args:
+        alpha (float): The angle of the shear reinforcement with respect to the
+            neutral axis in degrees. Default value = 90 degrees.
         limit_fyd (bool): Flag to indicate if the design yield stress is
             limited to 0.8 * fyk or not. This controls whether the stress
             reduction factor of concrete is given by Eq. (6.6) (False) or
@@ -489,27 +465,30 @@ def Asw_max(
     Ac: float,
     alpha: float = 90.0,
 ) -> float:
-    """Calculate the maximum cross-sectional area of the shear
-        reinforcement, based on the assumption 1/tan(theta) == 1.
+    """Calculate the maximum cross-sectional area of the shear reinforcement,
+    based on the assumption 1/tan(theta) == 1.
 
     EN 1992-1-1 (2005). Eq. (6.13)
 
     Args:
         fcd (float): The design strength of the concrete in MPa.
         fck (float): The characteristic compressive strength in MPa.
-        bw (float): The smallest width of the cross-section in tension
-            in mm.
-        s (float): The centre-to-centre distance of the shear
-            reinforcement in mm.
-        fwyd (float): The design strength of the shear reinforcement
-            steel in MPa.
-        NEd (float): The normal force in the cross-section due to
-            loading or prestress (NEd > 0 for compression) in N.
+        bw (float): The smallest width of the cross-section in tension in mm.
+        s (float): The centre-to-centre distance of the shear reinforcement in
+            mm.
+        fwyd (float): The design strength of the shear reinforcement steel in
+            MPa.
+        NEd (float): The normal force in the cross-section due to loading or
+            prestress (NEd > 0 for compression) in N.
         Ac (float): The cross-sectional area of the concrete in mm2.
 
+    Keyword Args:
+        alpha (float): The angle of the shear reinforcement with respect to the
+            neutral axis in degrees. Default value = 90 degrees.
+
     Returns:
         float: The maximum allowable cross-sectional area of the shear
-            reinforcement in mm2.
+        reinforcement in mm2.
 
     Raises:
         ValueError: When sigma_cp > fcd.
diff --git a/structuralcodes/codes/ec2_2023/__init__.py b/structuralcodes/codes/ec2_2023/__init__.py
index 05cc01ac..c8662148 100644
--- a/structuralcodes/codes/ec2_2023/__init__.py
+++ b/structuralcodes/codes/ec2_2023/__init__.py
@@ -32,7 +32,6 @@
     p_steel_stress_params,
     phi_50y_t0,
     phi_correction_factor,
-    r_steel_stress_strain_params,
     reinforcement_duct_props,
     sigma_p,
     sigma_s,
@@ -81,7 +80,6 @@
     'p_steel_stress_params',
     'phi_50y_t0',
     'phi_correction_factor',
-    'r_steel_stress_strain_params',
     'reinforcement_duct_props',
     'sigma_c',
     'sigma_p',
diff --git a/structuralcodes/codes/ec2_2023/_annexB_time_dependent.py b/structuralcodes/codes/ec2_2023/_annexB_time_dependent.py
index 42fb6787..84a5235d 100644
--- a/structuralcodes/codes/ec2_2023/_annexB_time_dependent.py
+++ b/structuralcodes/codes/ec2_2023/_annexB_time_dependent.py
@@ -2,16 +2,16 @@
 
 
 def alpha_c(fcm_28: float) -> float:
-    """Returns the coefficient to obtain the tangent modulus of elasticity
-    from the secant modulus of elasticity.
+    """Returns the coefficient to obtain the tangent modulus of elasticity from
+    the secant modulus of elasticity.
 
     EN 1992-1-1, Table 5.1
 
     Args:
         fcm_28 (float): The characteristic compressive strength at 28 days
-        in MPa.
+            in MPa.
 
     Returns:
-        float: coefficient alphac so that Ec=alphac*Ecm,28.
+        float: Coefficient alphac so that Ec=alphac*Ecm,28.
     """
     return max(1 / (0.8 + 0.2 * fcm_28 / 88), 1)
diff --git a/structuralcodes/codes/ec2_2023/_section5_materials.py b/structuralcodes/codes/ec2_2023/_section5_materials.py
index 70e92c99..921016ff 100644
--- a/structuralcodes/codes/ec2_2023/_section5_materials.py
+++ b/structuralcodes/codes/ec2_2023/_section5_materials.py
@@ -29,17 +29,17 @@
 def fcm(fck: float, delta_f: float = 8.0) -> float:
     """Determines the mean strength of concrete from its characteristic value.
 
-    EN 1992-1-1:2023, Table 5.1
+    EN 1992-1-1:2023, Table 5.1.
 
     Args:
-        fck (float): is the characteristic compressive strength in MPa.
+        fck (float): Is the characteristic compressive strength in MPa.
 
     Keyword Args:
-        delta_s (float): the increment in MPa to compute the mean
-            compressive strength
+        delta_s (float): The increment in MPa to compute the mean compressive
+            strength.
 
     Returns:
-        float: the mean compressive strength in MPa
+        float: The mean compressive strength in MPa
     """
     return mc2010.fcm(fck, delta_f)
 
@@ -48,92 +48,91 @@ def fctm(fck: float) -> float:
     """Compute the mean concrete tensile strength from the characteristic
     compressive strength.
 
-    EN 1992-1-1:2023, Table 5.1
+    EN 1992-1-1:2023, Table 5.1.
 
     Args:
-        fck (float): the characteristic compressive strength in MPa.
+        fck (float): The characteristic compressive strength in MPa.
 
     Returns:
-        float: the mean tensile strength in MPa.
+        float: The mean tensile strength in MPa.
     """
     if abs(fck) <= 50:
         return 0.3 * math.pow(abs(fck), 2 / 3)
     return 1.1 * math.pow(abs(fck), 1 / 3)
 
 
-def fctk_5(_fctm: float) -> float:
+def fctk_5(fctm: float) -> float:
     """Compute the 5% mean concrete tensile strength fractile.
 
-    EN 1992-1-1:2023, Table 5.1
+    EN 1992-1-1:2023, Table 5.1.
 
     Args:
-        _fctm (float): the mean concrete tensile strength in MPa
+        fctm (float): The mean concrete tensile strength in MPa.
 
     Returns:
-        float: the 5% mean concrete tensile strength fractile in MPa
+        float: The 5% mean concrete tensile strength fractile in MPa.
     """
-    return abs(_fctm) * 0.7
+    return abs(fctm) * 0.7
 
 
-def fctk_95(_fctm: float) -> float:
+def fctk_95(fctm: float) -> float:
     """Compute the 95% mean concrete tensile strength fractile.
 
-    EN 1992-1-1:2023, Table 5.1
+    EN 1992-1-1:2023, Table 5.1.
 
     Args:
-        _fctm (float): the mean concrete tensile strength in MPa
+        fctm (float): The mean concrete tensile strength in MPa.
 
     Returns:
-        float: the 5% mean concrete tensile strength fractile in MPa
+        float: The 5% mean concrete tensile strength fractile in MPa.
     """
-    return abs(_fctm) * 1.3
+    return abs(fctm) * 1.3
 
 
-def Ecm(_fcm: float, kE: float = 9500) -> float:
+def Ecm(fcm: float, kE: float = 9500) -> float:
     """Computes the secant modulus between sigma_c=0 and sigma_c=0.4*fcm.
 
-    EN 1992-1-1:2023, Eq. (5.1)
+    EN 1992-1-1:2023, Eq. (5.1).
 
     Args:
-        _fcm (float): the mean compressibe strength in MPa
+        fcm (float): The mean compressive strength in MPa.
 
     Keyword Args:
-        kE (float): coefficient relating the aggregates used
-            in concrete. Default value is 9500, but it can vary
-            from 5000 to 13000.
+        kE (float): Coefficient relating the aggregates used in concrete.
+            Default value is 9500, but it can vary from 5000 to 13000.
 
     Returns:
-        float: the secant concrete modulus in MPa
+        float: The secant concrete modulus in MPa.
 
     Raises:
-        ValueError: if _fcm is less than 0
-        ValueError: if kE is not between 5000 and 13000
+        ValueError: If fcm is less than 0.
+        ValueError: If kE is not between 5000 and 13000.
     """
-    if _fcm < 0:
-        raise ValueError(f'_fcm={_fcm} cannot be less than 0')
+    if fcm < 0:
+        raise ValueError(f'fcm={fcm} cannot be less than 0')
     if kE < 5000:
         raise ValueError(f'kE={kE} cannot be less than 5000')
     if kE > 13000:
         raise ValueError(f'kE={kE} cannot be larger than 13000')
 
-    return kE * math.pow(_fcm, 1 / 3)
+    return kE * math.pow(fcm, 1 / 3)
 
 
 def hn(Ac: float, u: float) -> float:
     """Computes the notional size of a given concrete cross-section.
 
-    EN 1992-1-1:2023, Table 5.2
+    EN 1992-1-1:2023, Table 5.2.
 
     Args:
-        Ac (float): the concrete cross-sectional area in (mm2)
-        u (float): the perimeter exposed to drying (mm)
+        Ac (float): The concrete cross-sectional area in (mm2).
+        u (float): The perimeter exposed to drying (mm).
 
     Returns:
-        float: the notional size (mm)
+        float: The notional size (mm).
 
     Raises:
-        ValueError: if Ac is less than 0
-        ValueError: if u is less than 0
+        ValueError: If Ac is less than 0.
+        ValueError: If u is less than 0.
     """
     if Ac < 0:
         raise ValueError(f'Ac={Ac} cannot be less than 0')
@@ -143,27 +142,29 @@ def hn(Ac: float, u: float) -> float:
     return 2 * Ac / u
 
 
-def A_phi_correction_exp(_hn: float, atm_conditions: str) -> float:
+def A_phi_correction_exp(
+    hn: float, atm_conditions: t.Literal['dry', 'humid']
+) -> float:
     """Computes the correction exponent for the modification for the phi_50y_t0
     with respect the fck value.
 
-    EN 1992-1-1:2023, Table 5.2
+    EN 1992-1-1:2023, Table 5.2.
 
     Args:
-        _hn (float): the notional size in mm
-        atm_conditions (str): 'dry' or 'humid'
+        hn (float): The notional size in mm.
+        atm_conditions (str): 'dry' or 'humid'.
 
     Returns:
-        (float): the correction exponent value
+        float: The correction exponent value.
 
     Raises:
-        ValueError: if _hn is less than 100 or greater than 1000
-        ValueError: if atm_conditions is not 'dry' or 'humid'
+        ValueError: If hn is less than 100 or greater than 1000.
+        ValueError: If atm_conditions is not 'dry' or 'humid'.
     """
-    if _hn < 100:
-        raise ValueError(f'_hn={_hn} cannot be less than 100')
-    if _hn > 1000:
-        raise ValueError(f'_hn={_hn} cannot be larger than 1000')
+    if hn < 100:
+        raise ValueError(f'hn={hn} cannot be less than 100')
+    if hn > 1000:
+        raise ValueError(f'hn={hn} cannot be larger than 1000')
 
     atm_conditions = atm_conditions.lower().strip()
     x = (100, 200, 500, 1000)
@@ -178,24 +179,24 @@ def A_phi_correction_exp(_hn: float, atm_conditions: str) -> float:
         )
 
     interpol = scipy.interpolate.interp1d(x, y)
-    return interpol(_hn)
+    return interpol(hn)
 
 
 def phi_correction_factor(fck: float, A_exponent: float) -> float:
     """Computes the correction factor for the computation of the phi_50y_t0.
 
-    EN 1992-1-1:2023able 5.2
+    EN 1992-1-1:2023, Table 5.2.
 
     Args:
-        fck (float): characteristic strength of concrete in MPa
-        A_exponent (float): the A correction exponent value
+        fck (float): Characteristic strength of concrete in MPa.
+        A_exponent (float): The A correction exponent value.
 
     Returns:
-        float: the correction factor value
+        float: The correction factor value.
 
     Raises:
-        ValueError: if fck is not between 12 and 100 MPa
-        ValueError: if A_exponent is not between 0.64 and 0.82
+        ValueError: If fck is not between 12 and 100 MPa.
+        ValueError: If A_exponent is not between 0.64 and 0.82.
     """
     if fck < 12:
         raise ValueError(f'fck={fck} cannot be less than 12')
@@ -210,29 +211,33 @@ def phi_correction_factor(fck: float, A_exponent: float) -> float:
 
 
 def phi_50y_t0(
-    t0: float, atm_conditions: str, _hn: float, strength_dev_class: str
+    t0: float,
+    atm_conditions: t.Literal['dry', 'humid'],
+    hn: float,
+    strength_dev_class: t.Literal['CS', 'CN', 'CR', 'slow', 'normal', 'rapid'],
 ) -> float:
     """Computes the creep coefficient of plain concrete at 50 years of loading.
     Interpolation is linear between values.
 
-    EN 1992-1-1:2023, Table 5.2
+    EN 1992-1-1:2023, Table 5.2.
 
     Args:
-        t0 (float): age at loading [days]
-        atm_conditions (str): 'dry' or 'humid'
-        _hn (float): the notional size in mm
-        strength_dev_class (str): 'CS', 'CN', 'CR', 'slow', 'normal' or 'rapid'
+        t0 (float): Age at loading [days].
+        atm_conditions (str): 'dry' or 'humid'.
+        hn (float): The notional size in mm.
+        strength_dev_class (str): Strength development class 'CS', 'CN', 'CR',
+            'slow', 'normal' or 'rapid'.
 
     Returns:
-        float: the creep coefficient
+        float: The creep coefficient.
 
     Raises:
-        ValueError: if t0 is less than 1
-        ValueError: if atm_conditions is not 'dry' or 'humid'
-        ValueError: if _hn is less than 100 or larger than 1000
-        ValueError: if strength_dev_class is not 'CS', 'CN',
-            'CR', 'slow', 'normal' or 'rapid'
-        ValueError: if combination of t0 and _hn is out of scope
+        ValueError: If t0 is less than 1.
+        ValueError: If atm_conditions is not 'dry' or 'humid'.
+        ValueError: If hn is less than 100 or larger than 1000.
+        ValueError: If strength_dev_class is not 'CS', 'CN',
+            'CR', 'slow', 'normal' or 'rapid'.
+        ValueError: If combination of t0 and hn is out of scope.
     """
     if t0 < 1:
         raise ValueError(f't0={t0} cannot be less than 1')
@@ -243,10 +248,10 @@ def phi_50y_t0(
             f'atm_conditions={atm_conditions} must be "dry" or "humid"'
         )
 
-    if _hn < 100:
-        raise ValueError(f'_hn={_hn} must be larger or equal than 100')
-    if _hn > 1000:
-        raise ValueError(f'_hn={_hn} must be less or equal than 1000')
+    if hn < 100:
+        raise ValueError(f'hn={hn} must be larger or equal than 100')
+    if hn > 1000:
+        raise ValueError(f'hn={hn} must be less or equal than 1000')
 
     strength_dev_class = strength_dev_class.upper().strip()
     if strength_dev_class not in VALID_STRENGTH_DEV_CLASSES:
@@ -312,41 +317,45 @@ def phi_50y_t0(
         )
 
     grid = np.array(np.meshgrid(_t, h_v)).T.reshape(-1, 2)
-    p = (t0, _hn)
+    p = (t0, hn)
 
     interp = scipy.interpolate.griddata(grid, values, p, method='linear')
     _phi_50y_t0 = float(interp)
 
     if math.isnan(_phi_50y_t0) or math.isnan(_phi_50y_t0):
-        raise ValueError('Combination of t0, _hn out of scope')
+        raise ValueError('Combination of t0, hn out of scope')
 
     return _phi_50y_t0
 
 
 def eps_cs_50y(  # noqa: PLR0912
-    fck_28: float, atm_conditions: str, _hn: float, strength_dev_class: str
+    fck_28: float,
+    atm_conditions: t.Literal['dry', 'humid'],
+    hn: float,
+    strength_dev_class: t.Literal['CS', 'CN', 'CR', 'slow', 'normal', 'rapid'],
 ) -> float:
     """Computes the nominal total shrinkage in ‰ for concrete after a duration
     of drying of 50 years.
 
-    EN 1992-1-1:2023, Table 5.3
+    EN 1992-1-1:2023, Table 5.3.
 
     Args:
-        fck_28 (float): characteristic strength at 28 days in MPa
-        atm_conditions (str): 'dry' or 'humid'
-        _hn (float): the notional size in mm
-        strength_dev_class (str): 'CS', 'CN', 'CR', 'slow', 'normal' or 'rapid'
+        fck_28 (float): Characteristic strength at 28 days in MPa
+        atm_conditions (str): 'dry' or 'humid'.
+        hn (float): The notional size in mm.
+        strength_dev_class (str): Strength development class 'CS', 'CN', 'CR',
+            'slow', 'normal' or 'rapid'.
 
     Returns:
-        float: the nominal shrinkage value in ‰
+        float: The nominal shrinkage value in percent.
 
     Raises:
-        ValueError: if fck_28 is less than 20 MPa or larger than 80 MPa
-        ValueError: if atm_conditions is not 'dry' or 'humid'
-        ValueError: if _hn is less than 100 or larger than 1000
-        ValueError: if strength_dev_class is not CS', 'CN', 'CR',
-            'slow', 'normal' or 'rapid'
-        ValueError: if combination of fck_28 and _hn is out of scope
+        ValueError: If fck_28 is less than 20 MPa or larger than 80 MPa.
+        ValueError: If atm_conditions is not 'dry' or 'humid'.
+        ValueError: If hn is less than 100 or larger than 1000.
+        ValueError: If strength_dev_class is not CS', 'CN', 'CR',
+            'slow', 'normal' or 'rapid'.
+        ValueError: If combination of fck_28 and hn is out of scope.
     """
     if fck_28 < 20:
         raise ValueError(f'fck_28={fck_28} cannot be less than 20')
@@ -359,10 +368,10 @@ def eps_cs_50y(  # noqa: PLR0912
             f'atm_conditions={atm_conditions} must be "dry" or "humid"'
         )
 
-    if _hn < 100:
-        raise ValueError(f'_hn={_hn} must be larger or equal than 100')
-    if _hn > 1000:
-        raise ValueError(f'_hn={_hn} must be less or equal than 1000')
+    if hn < 100:
+        raise ValueError(f'hn={hn} must be larger or equal than 100')
+    if hn > 1000:
+        raise ValueError(f'hn={hn} must be less or equal than 1000')
 
     strength_dev_class = strength_dev_class.upper().strip()
     if strength_dev_class == 'SLOW':
@@ -487,34 +496,36 @@ def eps_cs_50y(  # noqa: PLR0912
     values = data.get(atm_conditions).get(strength_dev_class)
 
     grid = np.array(np.meshgrid(fck_v, h_v)).T.reshape(-1, 2)
-    p = (fck_28, _hn)
+    p = (fck_28, hn)
 
     interp = scipy.interpolate.griddata(grid, values, p, method='linear')
     _eps_cs_50y = float(interp)
 
     if math.isnan(_eps_cs_50y):
-        raise ValueError('Combination of fck_28, _hn out of scope')
+        raise ValueError('Combination of fck_28, hn out of scope')
 
     return _eps_cs_50y
 
 
 def eta_cc(fck: float, fck_ref: float = 40) -> float:
     """Computes the factor to measure the difference between the undistributed
-    compressibe strength of a cylinder and the effective compressive strength
+    compressive strength of a cylinder and the effective compressive strength
     in a structural member.
 
-    EN 1992-1-1:2023, Eq. (5.4)
+    EN 1992-1-1:2023, Eq. (5.4).
 
     Args:
-        fck (float): the characterisitic compressive strength in MPa
-        fck_ref (float, optional): the reference compressive strength MPa
+        fck (float): The characterisitic compressive strength in MPa.
+
+    Keyword Args:
+        fck_ref (float, optional): The reference compressive strength MPa.
 
     Returns:
-        float: the value of the factor eta_cc
+        float: The value of the factor eta_cc.
 
     Raises:
-        ValueError: if fck is less than 12 MPa
-        ValueError: if fkc_ref is less or equal to 0
+        ValueError: If fck is less than 12 MPa.
+        ValueError: If fkc_ref is less or equal to 0.
     """
     if fck < 12:
         raise ValueError(f'fck={fck} must be larger or equal than 12 MPa')
@@ -524,25 +535,30 @@ def eta_cc(fck: float, fck_ref: float = 40) -> float:
     return min(math.pow(fck_ref / fck, 1 / 3), 1)
 
 
-def k_tc(t_ref: float, t0: float, strength_dev_class: str) -> float:
+def k_tc(
+    t_ref: float,
+    t0: float,
+    strength_dev_class: t.Literal['CS', 'CN', 'CR', 'slow', 'normal', 'rapid'],
+) -> float:
     """Computes the factor for considering the effect of high sustained loads
     and of time of loading on concrete compressive strength.
 
-    EN 1992-1-1:2023, Eq. (5.3)
+    EN 1992-1-1:2023, Eq. (5.3).
 
     Args:
-        t_ref (float): the reference time in days
-        t0 (float): age at loading in days
-        strength_dev_class (str): 'CS', 'CN', 'CR', 'slow', 'normal', 'rapid'
+        t_ref (float): The reference time in days.
+        t0 (float): Age at loading in days.
+        strength_dev_class (str): Strength development class 'CS', 'CN', 'CR',
+            'slow', 'normal', 'rapid'.
 
     Returns:
-        float: the factor value
+        float: The factor value.
 
     Raises:
-        ValueError: if t_ref is less than 0
-        ValueError: if t0 is less than 0
-        ValueError if strength_dev_class is not
-            'CS', 'CN', 'CR', 'slow', 'normal', 'rapid'
+        ValueError: If t_ref is less than 0.
+        ValueError: If t0 is less than 0.
+        ValueError: If strength_dev_class is not 'CS', 'CN', 'CR', 'slow',
+            'normal', 'rapid'.
     """
     if t_ref < 0:
         raise ValueError(f't_ref={t_ref} must be larger than 0')
@@ -570,56 +586,59 @@ def k_tc(t_ref: float, t0: float, strength_dev_class: str) -> float:
     return 0.85
 
 
-def fcd(fck: float, _eta_cc: float, _k_tc: float, gamma_c: float) -> float:
+def fcd(fck: float, eta_cc: float, k_tc: float, gamma_c: float) -> float:
     """Computes the value of the design compressive strength of concrete.
 
-    EN 1992-1-1:2023, Eq. (5.3)
+    EN 1992-1-1:2023, Eq. (5.3).
 
     Args:
-        fck (float): characteristic compressive strength in MPa
-        _eta_cc (float): factor for measuring the difference between
-            the undistributed compressive strength of a cylinder and
-            the effective compressive strength in the real structural
-            member
-        _k_tc (float): factor for taking into consideration high
-            sustained loads and of time of loading
-        gamma_c (float): partial factor of concrete
+        fck (float): Characteristic compressive strength in MPa.
+        eta_cc (float): Factor for measuring the difference between the
+            undistributed compressive strength of a cylinder and the effective
+            compressive strength in the real structural member.
+        k_tc (float): Factor for taking into consideration high sustained
+            loads and of time of loading.
+        gamma_c (float): Partial factor of concrete.
 
     Returns:
-        float: the design compressive strength of concrete in MPa
+        float: The design compressive strength of concrete in MPa.
 
     Raises:
-        ValueError: if fck is less than 12 MPa
-        ValueError if _etc_cc is not between 0 and 1
-        ValueError: if gamma_c is less than 1
+        ValueError: If fck is less than 12 MPa.
+        ValueError: If _etc_cc is not between 0 and 1.
+        ValueError: If gamma_c is less than 1.
     """
     if fck < 12:
         raise ValueError(f'fck={fck} must be larger or equal than 12 MPa')
-    if _eta_cc < 0 or _eta_cc > 1:
-        raise ValueError(f'_eta_cc={_eta_cc} must be between 0 and 1')
+    if eta_cc < 0 or eta_cc > 1:
+        raise ValueError(f'eta_cc={eta_cc} must be between 0 and 1')
     if gamma_c < 1:
         raise ValueError(f'gamma_c={gamma_c} must be larger or equal to 1')
 
-    return _eta_cc * _k_tc * fck / gamma_c
+    return eta_cc * k_tc * fck / gamma_c
 
 
-def k_tt(t_ref: float, strength_dev_class: str) -> float:
+def k_tt(
+    t_ref: float,
+    strength_dev_class: t.Literal['CS', 'CN', 'CR', 'slow', 'normal', 'rapid'],
+) -> float:
     """Computes the factor for considering the effect of high sustained loads
     and of time of loading on concrete tensile strength.
 
-    EN 1992-1-1:2023, Eq. (5.5)
+    EN 1992-1-1:2023, Eq. (5.5).
 
     Args:
-        t_ref (float): the reference time in days
-        strength_dev_class (str): 'CS', 'CN', 'CR', 'slow', 'normal' or 'rapid'
+        t_ref (float): The reference time in days.
+        strength_dev_class (str): Strength development class 'CS', 'CN', 'CR',
+            'slow', 'normal' or 'rapid'.
 
     Returns:
-        float: the factor value
+        float: The factor value.
 
     Raises:
-        ValueError: if t_ref is less than 0
-        ValueError if strength_dev_class is not 'CS', 'CN', 'CR',
-            'slow', 'normal' or 'rapid'
+        ValueError: If t_ref is less than 0.
+        ValueError: If strength_dev_class is not 'CS', 'CN', 'CR', 'slow',
+            'normal' or 'rapid'.
     """
     if t_ref < 0:
         raise ValueError(f't_ref={t_ref} must be larger than 0')
@@ -642,103 +661,103 @@ def k_tt(t_ref: float, strength_dev_class: str) -> float:
     return 0.7
 
 
-def fctd(_fctk_5: float, _k_tt: float, gamma_c: float) -> float:
+def fctd(fctk_5: float, k_tt: float, gamma_c: float) -> float:
     """Computes the value of the design tensile strength of concrete.
 
-    EN 1992-1-1:2023, Eq. (5.5)
+    EN 1992-1-1:2023, Eq. (5.5).
 
     Args:
-        fctk_5 (float): the 5% mean concrete tensile strength fractile in MPa
-        _k_tt (float): the factor for considering the effect of high sustained
-            loads and of time of loading on concrete tensile strength
-        gamma_c (float): partial factor of concrete
+        fctk_5 (float): The 5% mean concrete tensile strength fractile in MPa.
+        k_tt (float): The factor for considering the effect of high sustained
+            loads and of time of loading on concrete tensile strength.
+        gamma_c (float): Partial factor of concrete.
 
     Returns:
-        float: the design tensile strength of concrete in MPa
+        float: The design tensile strength of concrete in MPa.
 
     Raises:
-        ValueError: if fctk_5 is less than 0
-        ValueError: gamma_c is less than 1
+        ValueError: If fctk_5 is less than 0.
+        ValueError: If gamma_c is less than 1.
     """
-    if _fctk_5 < 0:
-        raise ValueError(f'fctk_5={_fctk_5} must be larger or equal to 0')
+    if fctk_5 < 0:
+        raise ValueError(f'fctk_5={fctk_5} must be larger or equal to 0')
     if gamma_c < 1:
         raise ValueError(f'gamma_c={gamma_c} must be larger or equal to 1')
 
-    return _k_tt * _fctk_5 / gamma_c
+    return k_tt * fctk_5 / gamma_c
 
 
-def eps_c1(_fcm: float) -> float:
+def eps_c1(fcm: float) -> float:
     """Computes the strain at maximum compressive strength of concrete (fcm)
     for the Sargin constitutive law.
 
-    EN 1992-1-1:2023, Eq. (5.9)
+    EN 1992-1-1:2023, Eq. (5.9).
 
     Args:
-        _fcm (float): the mean strength of concrete in MPa
+        fcm (float): The mean strength of concrete in MPa.
 
     Returns:
-        float: the strain at maximum compressive strength of concrete
+        float: The strain at maximum compressive strength of concrete.
 
     Raises:
-        ValueError: if _fcm is less than 12+8MPa
+        ValueError: If fcm is less than 12+8MPa.
     """
-    if _fcm < 20:
-        raise ValueError(f'_fcm={_fcm} must be larger or equal to 12+8MPa')
+    if fcm < 20:
+        raise ValueError(f'fcm={fcm} must be larger or equal to 12+8MPa')
 
-    return min(0.7 * math.pow(_fcm, 1 / 3), 2.8) / 1000
+    return min(0.7 * math.pow(fcm, 1 / 3), 2.8) / 1000
 
 
-def eps_cu1(_fcm: float) -> float:
+def eps_cu1(fcm: float) -> float:
     """Computes the strain at concrete failure of concrete.
 
-    EN 1992-1-1:2023, Eq. (5.10)
+    EN 1992-1-1:2023, Eq. (5.10).
 
     Args:
-        _fcm (float): the mean strength of concrete in MPa
+        fcm (float): The mean strength of concrete in MPa.
 
     Returns:
-        float: the maximum strength at failure of concrete
+        float: The maximum strength at failure of concrete.
 
     Raises:
-        ValueError: if _fcm is less than 12+8MPa
+        ValueError: If fcm is less than 12+8MPa.
     """
-    if _fcm < 20:
-        raise ValueError(f'_fcm={_fcm} must be larger or equal to 12+8MPa')
+    if fcm < 20:
+        raise ValueError(f'fcm={fcm} must be larger or equal to 12+8MPa')
 
-    return min(2.8 + 14 * (1 - _fcm / 108) ** 4, 3.5) / 1000
+    return min(2.8 + 14 * (1 - fcm / 108) ** 4, 3.5) / 1000
 
 
 def k_sargin(
-    _Ecm: float,
-    _fcm: float,
-    _eps_c1: float,
+    Ecm: float,
+    fcm: float,
+    eps_c1: float,
 ) -> float:
     """Computes the coefficient k for Sargin constitutive law in compression.
 
     EN 1992-1-1:2003, eq. (5.7)
 
     Args:
-        _Ecm (float): the secant modulus between sigma_c=0 and sigma_c=0.4*fcm
+        Ecm (float): the secant modulus between sigma_c=0 and sigma_c=0.4*fcm
             in MPa
-        _fcm (float): the mean compressive strength of concrete in MPa
-        _eps_c1 (float): the strain of concrete at stress fcm
+        fcm (float): the mean compressive strength of concrete in MPa
+        eps_c1 (float): the strain of concrete at stress fcm
 
     Returns:
         float: the coefficient k for Sargin constitutive law
 
     Raises:
-        ValueError: if _Ecm is less or equal to 0
-        ValueError: if _fcm is less than 12+8MPa
-        ValueError: if _eps_c1 is less or equal to 0
+        ValueError: if Ecm is less or equal to 0
+        ValueError: if fcm is less than 12+8MPa
+        ValueError: if eps_c1 is less or equal to 0
     """
-    if _Ecm <= 0:
-        raise ValueError(f'_Ecm={_Ecm} must be larger than 0')
-    if _fcm < 20:
-        raise ValueError(f'_fcm={_fcm} must be larger or equal to 12+8MPa')
-    if _eps_c1 <= 0:
-        raise ValueError(f'_eps_c1={_eps_c1} must be larger than 0')
-    return 1.05 * _Ecm * _eps_c1 / _fcm
+    if Ecm <= 0:
+        raise ValueError(f'Ecm={Ecm} must be larger than 0')
+    if fcm < 20:
+        raise ValueError(f'fcm={fcm} must be larger or equal to 12+8MPa')
+    if eps_c1 <= 0:
+        raise ValueError(f'eps_c1={eps_c1} must be larger than 0')
+    return 1.05 * Ecm * eps_c1 / fcm
 
 
 def eps_c2() -> float:
@@ -775,21 +794,20 @@ def n_parabolic_rectangular() -> float:
     return 2.0
 
 
-def weight_c(concrete_type: str) -> float:
+def weight_c(concrete_type: t.Literal['nc', 'npc']) -> float:
     """Returns the mean unit weight of concrete in kN/m3.
 
-    EN 1992-1-1:2023, 5.1.6-5
+    EN 1992-1-1:2023, 5.1.6-5.
 
     Args:
-        concrete_type (str):
-            'nc' for normal concrete
-            'npc' for normal plain concrete
+        concrete_type (str): 'nc' for normal concrete, or 'npc' for normal
+            plain concrete.
 
     Returns:
-        float: mean unit weight in kN/m3
+        float: Mean unit weight in kN/m3.
 
     Raises:
-        ValueError: if concrete_type is not 'nc' or 'npc'
+        ValueError: If concrete_type is not 'nc' or 'npc'.
     """
     concrete_type = concrete_type.lower().strip()
 
@@ -808,55 +826,23 @@ def alpha_c_th() -> float:
     """Returns the linear coefficient of thermal expansion in 1/Cº for
     concrete.
 
-    EN 1992-1-1:2023, 5.1.6-6
+    EN 1992-1-1:2023, 5.1.6-6.
 
     Returns:
-        float: the linear coefficient of thermal expansion in 1/Cº
-            for concrete
+        float: The linear coefficient of thermal expansion in 1/Cº for
+        concrete.
     """
     return 10 * 10e-6
 
 
-def r_steel_stress_strain_params(
-    ductility_class: str,
-) -> t.Tuple[float, float]:
-    """Returns the properties that define the stress-strain diagram for
-    reinforced steel k and eps_uk.
-
-    EN 1992-1-1:2023, Table 5.5
-
-    Args:
-        ductility_class (str): 'A', 'B' or 'C'
-
-    Returns:
-        Tuple(float, float): with the characteristic value k
-            and the characteristic strain at maximum force eps_uk
-
-    Raises:
-        ValueError: if ductility class is not 'A', 'B' or 'C'
-    """
-    ductility_class = ductility_class.upper().strip()
-
-    if ductility_class == 'A':
-        return (1.05, 0.025)
-    if ductility_class == 'B':
-        return (1.08, 0.05)
-    if ductility_class == 'C':
-        return (1.25, 0.075)
-    raise ValueError(
-        f'ductility_class={ductility_class} can only '
-        + 'take as values "A", "B" or "C'
-    )
-
-
 def Es() -> float:
     """Returns the value of the modulus of elasticity for weldable reinforcing
     steel.
 
-    EN 1992-1-1:2023, 5.2.4-3
+    EN 1992-1-1:2023, 5.2.4-3.
 
     Returns:
-        float: modulus of elasticity in MPa
+        float: Modulus of elasticity in MPa.
     """
     return 200000
 
@@ -868,8 +854,8 @@ def alpha_s_th() -> float:
     EN 1992-1-1:2023, 5.2.4-5
 
     Returns:
-        float: the linear coefficient of thermal expansion in 1/Cº
-            for weldable reinforce steel
+        float: The linear coefficient of thermal expansion in 1/Cº for weldable
+        reinforcement steel.
     """
     return 10 * 10e-6
 
@@ -878,10 +864,10 @@ def weight_s() -> float:
     """Returns the mean unit weight of reinforced steel for the purposes of
     design in kN/m3.
 
-    EN 1992-1-1:2023.2.4-4
+    EN 1992-1-1:2023.2.4-4.
 
     Returns:
-        float: the mean unit weight in kN/m3
+        float: The mean unit weight in kN/m3.
     """
     return 78.5
 
@@ -889,18 +875,18 @@ def weight_s() -> float:
 def fyd(fyk: float, gamma_s: float) -> float:
     """Design value for the yielding stress for welding reinforcing steel.
 
-    EN 1992-1-1:2023, Eq (5.11)
+    EN 1992-1-1:2023, Eq (5.11).
 
     Args:
-        fyk (float): characteristic yield stress for the steel in MPa
-        gamma_s (float): safety coefficient
+        fyk (float): Characteristic yield stress for the steel in MPa.
+        gamma_s (float): Safety coefficient.
 
     Returns:
-        float: design yielding stress for steel in MPa
+        float: Design yielding stress for steel in MPa.
 
     Raises:
-        ValueError: if fyk is less than 0
-        ValueError: if gamma_s is less than 1
+        ValueError: If fyk is less than 0.
+        ValueError: If gamma_s is less than 1.
     """
     if fyk < 0:
         raise ValueError(f'fyk={fyk} cannot be less than 0')
@@ -913,19 +899,18 @@ def fyd(fyk: float, gamma_s: float) -> float:
 def eps_ud(eps_uk: float, gamma_s: float) -> float:
     """Design value for the ultimate limit strain welding reinforcing steel.
 
-    EN 1992-1-1:2023, 5.2.4-2
+    EN 1992-1-1:2023, 5.2.4-2.
 
     Args:
-        eps_uk (float): characteristic ultimate limit
-            strain
-        gamma_s (float): safety coefficient
+        eps_uk (float): Characteristic ultimate limit strain.
+        gamma_s (float): Safety coefficient.
 
     Returns:
-        float: design ultimate strain limit
+        float: Design ultimate strain limit.
 
     Raises:
-        ValueError: if eps_uk is less than 0
-        ValueError: if gamma_s is less than 1
+        ValueError: If eps_uk is less than 0.
+        ValueError: If gamma_s is less than 1.
     """
     if eps_uk < 0:
         raise ValueError(f'eps_uk={eps_uk} must be equal or larger to 0')
@@ -936,37 +921,35 @@ def eps_ud(eps_uk: float, gamma_s: float) -> float:
 
 
 def sigma_s(
-    eps: float, fy: float, k: float, eps_u: float, _Es: float = 200000
+    eps: float, fy: float, k: float, eps_u: float, Es: float = 200000
 ) -> float:
     """Compute the stress for welded reinforcing steel in MPa for a given
     strain.
 
-    EN 1992-1-1:2023, 5.2.4
+    EN 1992-1-1:2023, 5.2.4.
 
     Args:
-        eps (float): the strain value
-        fy (float): the yielding stress in MPa.
-            fyd: for the design strength
-            fyk: for the characteristic strength
-        k (float): curve parameter. Ratio between the ultimate
-            stress and the yielding stress.
-            k = 1 for horizontal post-elastic branch without
-            strain limit
-        eps_u (float): ultimate strain at failure
-            eps_ud: for the design ultimate strain
-            eps_uk: for the characteristic ultimate strain
+        eps (float): The strain value.
+        fy (float): The yielding stress in MPa. Use fyd for the design
+            strength, and fyk for the characteristic strength.
+        k (float): Curve parameter. Ratio between the ultimate stress and the
+            yielding stress. k = 1 for horizontal post-elastic branch without
+            strain limit.
+        eps_u (float): Ultimate strain at failure. Use eps_ud for the design
+            ultimate strain, and eps_uk for the characteristic ultimate strain.
 
     Keyword Args:
-        _Es (float): the modulus of elasticity for reinforcing steel
+        Es (float): The modulus of elasticity for reinforcing steel.
+
     Returns:
-        float: stre nominal stress in MPa
+        float: The nominal stress in MPa.
 
     Raises:
-        ValueError: if eps is less than 0 or larger than eps_uk
-        ValueError: if _Es is less or equal to 0
-        ValueError: if fy is less or equal to 0
-        ValueError: if k is less than 1
-        ValueError: if eps_u is less or equal to 0 and k > 1
+        ValueError: If eps is less than 0 or larger than eps_uk.
+        ValueError: If Es is less or equal to 0.
+        ValueError: If fy is less or equal to 0.
+        ValueError: If k is less than 1.
+        ValueError: If eps_u is less or equal to 0 and k > 1.
     """
     if eps < 0:
         raise ValueError(f'eps={eps} must be larger or equal to 0')
@@ -977,18 +960,18 @@ def sigma_s(
             f'eps={eps} must be equal o less than'
             + 'eps_uk={eps_u} when k is larger than 1'
         )
-    if _Es <= 0:
-        raise ValueError(f'_Es={_Es} must be larger than 0')
+    if Es <= 0:
+        raise ValueError(f'Es={Es} must be larger than 0')
     if fy <= 0:
         raise ValueError(f'fyk={fy} must be larger than 0')
     if k < 0:
         raise ValueError(f'k={k} must be larger than 1')
 
-    eps_y = fy / _Es
+    eps_y = fy / Es
 
     # If in elastic area
     if eps <= eps_y:
-        return eps * _Es
+        return eps * Es
 
     # If in plastic area
     m = fy * (k - 1) / (eps_u - eps_y)
@@ -996,27 +979,39 @@ def sigma_s(
 
 
 def p_steel_stress_params(
-    prestress_class: str, element: str
+    prestress_class: t.Literal[
+        'Y1560',
+        'Y1670',
+        'Y1770',
+        'Y1860',
+        'Y1770',
+        'Y1860',
+        'Y1960',
+        'Y2060',
+        'Y1030',
+        'Y1050',
+        'Y1100',
+        'Y1230',
+    ],
+    element: t.Literal['W', 'S', 'B'],
 ) -> t.Tuple[float, float]:
     """Computes the stress-diagram parameters fp01k and fpk.
 
-    EN 1992-1-1:2023, 5.3.3
+    EN 1992-1-1:2023, 5.3.3.
 
     Args:
-        prestress_class (str): possible values: Y1560, 1670,
+        prestress_class (str): Possible values: Y1560, Y1670,
             Y1770, Y1860, Y1770, Y1860, Y1960, Y2060,
             Y1030, Y1050, Y1100 and Y1230
-        element (str):
-            'W' for Wires
-            'S' for Strands
-            'B' for Bars
+        element (str): Element type, 'W' for Wires, 'S' for Strands, and 'B'
+            for Bars.
 
     Returns:
-        Tuple(float, float): with the value of fp01k and fpk in MPa
+        Tuple(float, float): With the value of fp01k and fpk in MPa.
 
     Raises:
-        ValueError: if combination of prestress_class and element
-            is not a possible value from the range
+        ValueError: If combination of prestress_class and element is not a
+            possible value from the range.
     """
     prestress_class = prestress_class.upper().strip()
     element = element.upper().strip()
@@ -1057,19 +1052,19 @@ def p_steel_stress_params(
 def fpd(fp01k: float, gamma_P: float) -> float:
     """Computes the design value for the prestressing steel stress.
 
-    EN 1992-1-1:2023, 5.3.3
+    EN 1992-1-1:2023, 5.3.3.
 
     Args:
-        fp01k (float): the 0.1% proof stress in MPa
-        gamma_P (float): the safety coefficient
+        fp01k (float): The 0.1% proof stress in MPa.
+        gamma_P (float): The safety coefficient.
 
     Returns:
-        float: the design value for the design prestressing
-            steel stress in MPa
+        float: The design value for the design prestressing steel stress in
+        MPa.
 
     Raises:
-        ValueError: if fp01k is less than 0
-        ValueError: if gamma_P is less than 1
+        ValueError: If fp01k is less than 0.
+        ValueError: If gamma_P is less than 1.
     """
     if fp01k < 0:
         raise ValueError(f'fp01k={fp01k} must be larger or equal to 0')
@@ -1088,32 +1083,27 @@ def sigma_p(
 ) -> float:
     """Computes the stress for prestressing steel as a function of the strain.
 
-    EN 1992-1-1:2023, 5.3.3
+    EN 1992-1-1:2023, 5.3.3.
 
     Args:
-        eps (float): strain value
-        fpy (float): yielding stress of the steel in MPa
-            fd for design stress values
-            fp01k for nominal stress values
-        fpu (float): the maximum stress at eps_u in MPa
-            fpd: for design stress values
-            fpk: for nominal stress values
-            fpu == fpy for horizontal post-elastic branch without
-            strain limit.
+        eps (float): Strain value.
+        fpy (float): Yielding stress of the steel in MPa. Use fd for design
+            stress values, and fp01k for nominal stress values.
+        fpu (float): The maximum stress at eps_u in MPa. Use fpd for design
+            stress values, fpk for nominal stress values, and fpu == fpy for
+            horizontal post-elastic branch without strain limit.
 
     Keyword Args:
-        eps_u (float): ultimate strain.
-            eps_uk = 0.035 for nominal ultimate strain
-            eps_ud for design ultimate strain
-        Ep (float): modulus of elasticity of prestressing steel
-            in MPa
+        eps_u (float): Ultimate strain. Use eps_uk = 0.035 for nominal ultimate
+            strain, and eps_ud for design ultimate strain.
+        Ep (float): Modulus of elasticity of prestressing steel in MPa.
 
     Raises:
-        ValueError: if eps is less than 0 or larger than eps_u
-        ValueError: if fpy is less or equal to 0
-        ValueError: if fpu is less than fpy
-        ValueError: if eps_u is lower or equal to 0
-        ValueError: if _Ep is less or equal to 0
+        ValueError: If eps is less than 0 or larger than eps_u.
+        ValueError: If fpy is less or equal to 0.
+        ValueError: If fpu is less than fpy.
+        ValueError: If eps_u is lower or equal to 0.
+        ValueError: If _Ep is less or equal to 0.
     """
     if eps < 0:
         raise ValueError(f'eps={eps} must be larger or equal to 0')
@@ -1146,7 +1136,7 @@ def reinforcement_duct_props(
     """Return a dict with the minimum characteristic ductility properties for
     reinforcement ductility class.
 
-    EUROCODE 2 1992-1-1:2023, Tab. 5.5
+    EUROCODE 2 1992-1-1:2023, Tab. 5.5.
 
     Args:
         fyk (float): The characteristic yield strength.
diff --git a/structuralcodes/codes/ec2_2023/_section9_sls.py b/structuralcodes/codes/ec2_2023/_section9_sls.py
index 10b99580..b3630284 100644
--- a/structuralcodes/codes/ec2_2023/_section9_sls.py
+++ b/structuralcodes/codes/ec2_2023/_section9_sls.py
@@ -7,14 +7,14 @@
 from ._section5_materials import fcm, fctm
 
 
-def Ec_eff(fcm_: float, phi: float, kE: float = 9500) -> float:
+def Ec_eff(fcm: float, phi: float, kE: float = 9500) -> float:
     """Returns de effective modulus of elasticity from fcm and phi.
 
-    EN 1992-1-1:2023, Eq. (9.1)
+    EN 1992-1-1:2023, Eq. (9.1).
 
     Args:
         fcm (float): The mean compressive strength in MPa.
-        phi (float): The creep coefficient
+        phi (float): The creep coefficient.
 
     Keyword Args:
         kE (float): Constant to account for the type of aggregate.
@@ -22,8 +22,8 @@ def Ec_eff(fcm_: float, phi: float, kE: float = 9500) -> float:
     Returns:
         float: The effective modulus of elastiticy in MPa.
     """
-    Ecm = kE * fcm_ ** (1 / 3)
-    return alpha_c(fcm_) * Ecm / (1 + phi)
+    Ecm = kE * fcm ** (1 / 3)
+    return alpha_c(fcm) * Ecm / (1 + phi)
 
 
 def As_min_y(
@@ -33,27 +33,29 @@ def As_min_y(
     sections are to be divided into rectangles.
 
     EN 1992-1-1:2023, Eq. (9.4)
+
     Eq. (9.2) and (9.3) are particular cases of the general equation
+
     Eq. (9.2) is valid for pure bending, hence NEd=0
+
     Eq. (9.3) is valid for pure tension. The general expression has an upper
     limit that equals the values of Eq. (9.3)
 
     Args:
         NEd (float): SLS axial force applied on the section or rectangle
-                     (compressions are negative) in kN
-        b (float): the width of the section or rectangle in meters
-        h (float): the height of the section or rectange in meters
-        fct_eff (float): effective tension strength of concrete (can normally
-                         be taken as the mean tensile strength) in MPa
-        fyk (float): characteristic yield strength of steel in MPa
+            (compressions are negative) in kN.
+        b (float): The width of the section or rectangle in meters.
+        h (float): The height of the section or rectange in meters.
+        fct_eff (float): Effective tension strength of concrete (can normally
+            be taken as the mean tensile strength) in MPa.
+        fyk (float): Characteristic yield strength of steel in MPa.
 
     Returns:
-        As_min_y[0] (float): The minimum tensile reinforcement to avoid
-                             yielding of steel on the most tensioned fibre of
-                             the rectangle (As_min_y1) in cm2
-        As_min_y[1] (float): The minimum tensile reinforcement to avoid
-                             yielding of steel on the most tensioned fibre of
-                             the rectangle (As_min_y2) in cm2
+        tuple(float, float): The minimum tensile reinforcement to avoid
+        yielding of steel on the most tensioned fibre of the rectangle
+        (As_min_y1) in cm2, and the minimum tensile reinforcement to avoid
+        yielding of steel on the most tensioned fibre of the rectangle
+        (As_min_y2) in cm2.
     """
     As_min_y1 = (
         min(
@@ -71,61 +73,59 @@ def kh(b: float, h: float) -> float:
     """Returns factor kh, which reduces the tensile strength of concrete to
     account for imposed restrained deformations due to shrinkage.
 
-    EN 1992-1-1:2023, Eq. (9.5)
+    EN 1992-1-1:2023, Eq. (9.5).
 
     Args:
-        b (float): width of the rectangle in meters
-        h (float): height of the rectangle in meters
+        b (float): Width of the rectangle in meters.
+        h (float): Height of the rectangle in meters.
 
     Returns:
-        float: Factor kh which reduces the tensile strength of concrete
-        to account for imposed restrained deformations due
-        to shrinkage
+        float: Factor kh which reduces the tensile strength of concrete to
+        account for imposed restrained deformations due to shrinkage.
     """
     return min(max(0.8 - 0.6 * (min(b, h) - 0.3), 0.5), 0.8)
 
 
 def wk_cal2(
-    kw: float, k_1_r_: float, srm_cal_: float, epssm_epscm_: float
+    kw: float, k_1_r: float, srm_cal: float, epssm_epscm: float
 ) -> float:
-    """Returns de calculated characteristic crack width.
+    """Returns the calculated characteristic crack width.
 
-    EN 1992-1-1:2023 Eq. (9.8)
+    EN 1992-1-1:2023, Eq. (9.8).
 
     Args:
-        kw (float): factor that converts the mean crack spacing to a
-        characteristic value
-        k_1_r_ (float): factor accounting for the effect of curvature on crack
-                width - can be determined using the function k_1_r
-        srm_cal_ (float): mean crack spacing - can be determines using the
-                function srm_cal
-        epssm_epscm_ (float): mean diference of strain between steel anc
-                concrete - can be determined using the function epssm_epscm
+        kw (float): Factor that converts the mean crack spacing to a
+            characteristic value.
+        k_1_r (float): Factor accounting for the effect of curvature on crack
+            width - can be determined using the function k_1_r.
+        srm_cal (float): Mean crack spacing - can be determined using the
+            function srm_cal.
+        epssm_epscm (float): Mean diference of strain between steel and
+            concrete - can be determined using the function epssm_epscm.
 
     Returns:
-        float: the calculated characteristic crack width in in units consistent
-        with srm_cal
+        float: The calculated characteristic crack width in in units consistent
+        with srm_cal.
     """
-    return kw * k_1_r_ * srm_cal_ * epssm_epscm_
+    return kw * k_1_r * srm_cal * epssm_epscm
 
 
 def k_1_r(h: float, x: float, ay: float) -> float:
     """Returns k1/r factor to account for increase in crack width due to
     curvature of the section in bending.
 
-    EN 1992-1-1:2023 Eq. (9.9)
+    EN 1992-1-1:2023, Eq. (9.9).
 
     Args:
-        h (float): height of the section in consistent units (e.g. meters)
-        x (float): distance from most compressed fibre to neutra axis in
-        consistent units (e.g. meters)
-        ay (float): cover to centre of tensioned reinforcement closest to most
-        tensioned face in consistent units
-        (e.g. meters)
-
-    Returs:
+        h (float): Height of the section in consistent units (e.g. meters).
+        x (float): Distance from most compressed fibre to neutra axis in
+            consistent units (e.g. meters).
+        ay (float): Cover to centre of tensioned reinforcement closest to most
+            tensioned face in consistent units (e.g. meters).
+
+    Returns:
         float: Factor k1/r (non-dimensional) which accounts for the increase in
-        crack width due to curvature of the section in bending
+        crack width due to curvature of the section in bending.
     """
     return (h - x) / (h - ay - x)
 
@@ -138,27 +138,27 @@ def epssm_epscm(
     alphae: float,
     Es: float,
 ) -> float:
-    """Returns the mean strain difference between steel and concrete along
-    2 transfer lengths.
+    """Returns the mean strain difference between steel and concrete along 2
+    transfer lengths.
 
-    EN 1992-1-1:2023 Eq. (9.11)
+    EN 1992-1-1:2023, Eq. (9.11).
 
     Args:
-        sigma_s (float): the stress in steel at the section of the crack
-        kt (float): an integration factor to account for the variation in
+        sigma_s (float): The stress in steel at the section of the crack.
+        kt (float): An integration factor to account for the variation in
             strain in steel and concrete it is to be taken as 0.6 for short
             term loading or instantaneous loading and equal to 0.4 for long
-            term or repeated loading
-        fct_eff (float): the effective cracking stress, which can be taken
-            equal to the mean tensile strength of ocncrete, fctm
-        rho_eff (float): the effective reinforcement ratio in the tension zone
-        alphae (float): the equivalence factor equal to Es/Ecm
-        Es (float): is the modulus of elasticity of steel, normally taken
-            as 200 GPa
+            term or repeated loading.
+        fct_eff (float): The effective cracking stress, which can be taken
+            equal to the mean tensile strength of concrete, fctm.
+        rho_eff (float): The effective reinforcement ratio in the tension zone.
+        alphae (float): The equivalence factor equal to Es/Ecm.
+        Es (float): The modulus of elasticity of steel, normally taken as 200
+            GPa.
 
     Returns:
-        float: The mean strain difference bewteen steel and concrete along
-        2 transfer lengths
+        float: The mean strain difference bewteen steel and concrete along 2
+        transfer lengths.
     """
     return max(
         (sigma_s - kt * fct_eff / rho_eff * (1 + alphae * rho_eff)) / Es,
@@ -170,17 +170,17 @@ def kfl(h: float, xg: float, hceff: float) -> float:
     """Returns factor kfl which accounts for the distribution of stresses
     before cracking.
 
-    EN 1992-1-1:2023 Eq. (9.17)
+    EN 1992-1-1:2023, Eq. (9.17).
 
     Args:
-        h (float): height of the cross section
-        xg (float): distance from the compressed fibre to the centroid of the
-            uncracked section
-        hceff (float): height of the effective tension area
+        h (float): Height of the cross section.
+        xg (float): Distance from the compressed fibre to the centroid of the
+            uncracked section.
+        hceff (float): Height of the effective tension area.
 
     Returns:
         float: Returns factor kfl which accounts for the distribution of
-        stresses before cracking
+        stresses before cracking.
     """
     return max(0.5 * (1 + (h - xg - hceff) / (h - xg)), 0.5)
 
@@ -197,25 +197,25 @@ def srm_cal(
 ) -> float:
     """Returns the mean crack spacing.
 
-    EN 1992-1-1:2023 Eq. (9.15)
+    EN 1992-1-1:2023, Eq. (9.15).
 
     Args:
-        c (float): concrete cover of reinforcement to bar surface. Larger
-            value of lateral and vertical cover should be applied
-        kfl (float): factor accounting for distribution of stresses prior
-            to cracking
-        kb (float):  factor accounting for bond conditions
-        phi (float): bar diameter
-        rho_eff(float): effective reinforcement ratio in the tension zone
-        kw (float): factor converting the mean crack spacing into a
+        c (float): Concrete cover of reinforcement to bar surface. Larger value
+            of lateral and vertical cover should be applied.
+        kfl (float): Factor accounting for distribution of stresses prior to
+            cracking.
+        kb (float): Factor accounting for bond conditions.
+        phi (float): Bar diameter.
+        rho_eff(float): Effective reinforcement ratio in the tension zone.
+        kw (float): Factor converting the mean crack spacing into a
             characteristic crack spacing, with a reocmmended value of 1.3
-            (NDP)
-        h (float): height of the cross section
-        x (float): depth of the neutral axis measured form the mots
-            compressed fibre
+            (NDP).
+        h (float): Height of the cross section.
+        x (float): Depth of the neutral axis measured form the most compressed
+            fibre.
 
     Returns:
-        float: the mean crack spacing in units consistent with c and phi
+        float: The mean crack spacing in units consistent with c and phi.
     """
     return min(1.5 * c + kfl_ * kb / 7.2 * phi / rho_eff, 1.3 / kw * (h - x))
 
@@ -239,35 +239,35 @@ def wk_cal(
     """Returns the characteristic crack width, wk,cal, as well as auxiliary
     variables, 1/r, srm,cal and epssm-epscm.
 
-    EN1992-1-1:2023 Eq. (9.8), complemented with Eq. (9.11), Eq. (9.15),
-        Eq. (9.17)
+    EN1992-1-1:2023 Eq. (9.8), complemented with Eq. (9.11), Eq. (9.15), Eq.
+    (9.17).
 
     Args:
-        kw (float): factor that converts the mean crack spacing to a
-            characteristic value
-        h (float): height of cross section
-        xg (float): depth of centroid of section measured from compressed
-            fibre
-        hc_eff (float): height of the effective tensioned concrete area
-        c (float): concrete cover of reinforcement to bar surface. Larger
-            value of lateral and vertical cover should be applied
-        kb (float): factor account for bond conditions of bar
-        phi (float): diameter of tensioned bars (for different bar diameters,
-            equivalent diameter according to Eq. (9.19)
-        rho_eff (float): effective tension reinforcement ratio
-        x (float): depth of the neutral axis of the cracked section measured
-            from compressed fibre
-        sigma_s (float): tension in most tensioned bar according to fully
-            cracked analysis
-        kt (float): factor accounting for tension stiffening
-        fct_eff (float): effective tensile strength of concrete
-        alphae (float): modular ratio Es/Ecm
-        Es (float): modulus of elasticity of steel bars (normally Es=200 MPa)
+        kw (float): Factor that converts the mean crack spacing to a
+            characteristic value.
+        h (float): Height of cross section.
+        xg (float): Depth of centroid of section measured from compressed
+            fibre.
+        hc_eff (float): Height of the effective tensioned concrete area.
+        c (float): Concrete cover of reinforcement to bar surface. Larger
+            value of lateral and vertical cover should be applied.
+        kb (float): Factor account for bond conditions of bar.
+        phi (float): Diameter of tensioned bars (for different bar diameters,
+            equivalent diameter according to Eq. (9.19).
+        rho_eff (float): Effective tension reinforcement ratio.
+        x (float): Depth of the neutral axis of the cracked section measured
+            from compressed fibre.
+        sigma_s (float): Tension in most tensioned bar according to fully
+            cracked analysis.
+        kt (float): Factor accounting for tension stiffening.
+        fct_eff (float): Effective tensile strength of concrete.
+        alphae (float): Modular ratio Es/Ecm.
+        Es (float): Modulus of elasticity of steel bars (normally Es=200 MPa).
 
     Returns:
-        Tuple[float, float, float, float]: the characteristic
-        crack width, wk,cal, in consistent units, as
-        well as auxiliary variables, 1/r, srm,cal and epssm-epscm
+        Tuple[float, float, float, float]: The characteristic crack width,
+        wk,cal, in consistent units, as well as auxiliary variables, 1/r,
+        srm,cal and epssm-epscm.
     """
     k_1_r_ = k_1_r(h, x, c + phi / 2)
     srm_cal_ = srm_cal(c, kfl(h, xg, hc_eff), kb, phi, rho_eff, kw, h, x)
@@ -289,24 +289,24 @@ def delta_simpl(
 ) -> float:
     """Simplified calculation of the deflection for rectangular sections.
 
-    EN1992-1-1:2023 Eq. (9.23)
+    EN1992-1-1:2023, Eq. (9.23).
 
     Args:
-        delta_loads (float): linear elastic deflection due to loads
-        delta_shr (float): linear elastic deflection due to shrinkage
-        fck1 (float): characteristic concrete strength in MPa
-        phi1 (float): weighted mean value of the creep coefficient
-        b1 (float): width of rectangular cross-section in m
-        h (float): height of rectanguar cross-section in m
-        d (float): effective height of cross-section in m
-        As1 (float): tension reinforcement at centre span for continuous in cm2
-            beams or at the embedment for a cantilever
-        Mk (float): characteristic moment at centre span for continuous
-            beams or at the embedment for a cantilever
+        delta_loads (float): Linear elastic deflection due to loads.
+        delta_shr (float): Linear elastic deflection due to shrinkage.
+        fck1 (float): Characteristic concrete strength in MPa.
+        phi1 (float): Weighted mean value of the creep coefficient.
+        b1 (float): Width of rectangular cross-section in m.
+        h (float): Height of rectanguar cross-section in m.
+        d (float): Effective height of cross-section in m.
+        As1 (float): Tension reinforcement at centre span for continuous in cm2
+            beams or at the embedment for a cantilever.
+        Mk (float): Characteristic moment at centre span for continuous
+            beams or at the embedment for a cantilever.
 
     Returns:
-        float: the deflection of the beam in units consistent with delta_loads
-        and delta_shr
+        float: The deflection of the beam in units consistent with delta_loads
+        and delta_shr.
     """
     Mcr = fctm(fck1) * 1000 * b1 * h ** (2) / 6
     zeta = 1 - 0.5 * (Mcr / Mk) ** 2
diff --git a/structuralcodes/codes/mc2010/__init__.py b/structuralcodes/codes/mc2010/__init__.py
index 2edc3d15..4fc07ba3 100644
--- a/structuralcodes/codes/mc2010/__init__.py
+++ b/structuralcodes/codes/mc2010/__init__.py
@@ -2,9 +2,43 @@
 
 import typing as t
 
+from ._concrete_creep_and_shrinkage import (
+    alpha_fcm,
+    beta_bc_fcm,
+    beta_bc_t,
+    beta_bs,
+    beta_dc_fcm,
+    beta_dc_RH,
+    beta_dc_t,
+    beta_dc_t0,
+    beta_ds,
+    beta_h,
+    beta_RH,
+    beta_s1,
+    calc_J,
+    eps_cbs,
+    eps_cbs0,
+    eps_cds,
+    eps_cds0,
+    gamma_t0,
+    k_sigma,
+    phi,
+    phi_bc,
+    phi_dc,
+    t0_adj,
+    t_T,
+)
+from ._concrete_interface_different_casting_times import (
+    tau_edi,
+    tau_rdi_with_reinforcement,
+    tau_rdi_without_reinforcement,
+)
 from ._concrete_material_properties import (
-    E_ci,
+    Eci,
+    Eci_t,
     Gf,
+    beta_cc,
+    beta_e,
     eps_c1,
     eps_c2,
     eps_c3,
@@ -19,6 +53,34 @@
     k_sargin,
     n_parabolic_rectangular,
 )
+from ._concrete_punching import (
+    b_0,
+    m_ed,
+    psi_punching,
+    v_rd_max_punching,
+    v_rd_punching,
+    v_rdc_punching,
+    v_rds_punching,
+)
+from ._concrete_shear import (
+    create_load_dict,
+    epsilon_x,
+    eta_fc,
+    v_rd,
+    v_rd_ct,
+    v_rd_ct_approx1,
+    v_rd_ct_approx2,
+    v_rd_max,
+    v_rd_max_approx1,
+    v_rd_max_approx2,
+    v_rd_max_approx3,
+    v_rdc,
+    v_rdc_approx1,
+    v_rdc_approx2,
+    v_rdc_approx3,
+    v_rds,
+)
+from ._concrete_torsion import t_rd, t_rd_max, v_ed_ti
 from ._reinforcement_material_properties import (
     epsud,
     fyd,
@@ -27,7 +89,6 @@
 
 __all__ = [
     'fcm',
-    'E_ci',
     'fctm',
     'fctkmin',
     'fctkmax',
@@ -44,6 +105,63 @@
     'fyd',
     'epsud',
     'reinforcement_duct_props',
+    'Eci',
+    'Eci_t',
+    'beta_cc',
+    'beta_e',
+    'alpha_fcm',
+    'beta_bc_fcm',
+    'beta_bc_t',
+    'beta_bs',
+    'beta_dc_fcm',
+    'beta_dc_RH',
+    'beta_dc_t',
+    'beta_dc_t0',
+    'beta_ds',
+    'beta_h',
+    'beta_RH',
+    'beta_s1',
+    'calc_J',
+    'eps_cbs',
+    'eps_cbs0',
+    'eps_cds',
+    'eps_cds0',
+    'gamma_t0',
+    'k_sigma',
+    'phi',
+    'phi_bc',
+    'phi_dc',
+    't0_adj',
+    't_T',
+    'create_load_dict',
+    'epsilon_x',
+    'eta_fc',
+    'v_rd',
+    'v_rd_ct',
+    'v_rd_ct_approx1',
+    'v_rd_ct_approx2',
+    'v_rd_max',
+    'v_rd_max_approx1',
+    'v_rd_max_approx2',
+    'v_rd_max_approx3',
+    'v_rdc',
+    'v_rdc_approx1',
+    'v_rdc_approx2',
+    'v_rdc_approx3',
+    'v_rds',
+    'b_0',
+    'm_ed',
+    'psi_punching',
+    'v_rd_max_punching',
+    'v_rd_punching',
+    'v_rdc_punching',
+    'v_rds_punching',
+    'v_ed_ti',
+    't_rd_max',
+    't_rd',
+    'tau_edi',
+    'tau_rdi_with_reinforcement',
+    'tau_rdi_without_reinforcement',
 ]
 
 __title__: str = 'fib Model Code 2010'
diff --git a/structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py b/structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py
index 279419f0..8c30f8a9 100644
--- a/structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py
+++ b/structuralcodes/codes/mc2010/_concrete_creep_and_shrinkage.py
@@ -8,12 +8,15 @@
    (see 5.1.10.7 of [1])
 """
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
+import typing as t
 import warnings
 
 import numpy as np
 import numpy.typing as npt
 
-_alpha = {
+ALPHA = {
     '32.5 R': 0,
     '42.5 N': 0,
     '42.5 R': 1,
@@ -21,7 +24,7 @@
     '52.5 R': 1,
     '32.5 N': -1,
 }
-_alpha_as = {
+ALPHA_BS = {
     '32.5 R': 700,
     '42.5 N': 700,
     '42.5 R': 600,
@@ -29,7 +32,7 @@
     '52.5 R': 600,
     '32.5 N': 800,
 }
-_alpha_ds1 = {
+ALPHA_DS1 = {
     '32.5 R': 4,
     '42.5 N': 4,
     '42.5 R': 6,
@@ -37,7 +40,7 @@
     '52.5 R': 6,
     '32.5 N': 3,
 }
-_alpha_ds2 = {
+ALPHA_DS2 = {
     '32.5 R': 0.012,
     '42.5 N': 0.012,
     '42.5 R': 0.012,
@@ -54,12 +57,11 @@ def _check_fcm(fcm: float) -> None:
     Defined in fib Model Code 2010 (2013), section 5.1.9.4.2.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
-        Raises a ValueError if the mean compressive strength is outside
-            of the specified range.
+        Raises a ValueError if the mean compressive strength is outside of the
+        specified range.
     """
     if fcm < 20 or fcm > 130:
         raise ValueError(
@@ -79,14 +81,14 @@ def _check_initial_stress(sigma: float, fcm: float) -> None:
     Defined in fib Model Code 2010 (2013), section 5.1.9.4.2.
 
     Args:
-        sigma (float): The compressive stress applied to the concrete
-            at t0 in MPa.
-        fcm (float): The mean compressive strength of the concrete in
-            MPa. Note that its value is non-negative.
+        sigma (float): The compressive stress applied to the concrete at t0 in
+            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa. Note
+            that its value is non-negative.
 
-    Returns:
-        Raises a warning if the initial compressive stress is
-            greater than 0.4*fcm.
+    Raises:
+        Raises a warning if the initial compressive stress is greater than
+            0.4*fcm.
         Raises a ValueError if the compressive stress is greater than 0.6*fcm.
     """
     if abs(sigma) > 0.6 * fcm:
@@ -113,10 +115,10 @@ def _check_age_at_loading(t0: float) -> None:
     Defined in fib Model Code 2010 (2013), section 5.1.9.4.2.
 
     Args:
-        t0 (float): The age of the concrete in days at which the
-            loading is applied.
+        t0 (float): The age of the concrete in days at which the loading is
+            applied.
 
-    Returns:
+    Raises:
         Raises a ValueError if the age of the concrete is too low.
     """
     if t0 < 1:
@@ -139,9 +141,9 @@ def _check_RH(rh: float) -> None:
         rh (float): The relative humidity of the environment. Value can be
             provided as percentage (i.e. 40--100), or as ratio (i.e. 0.4--1).
 
-    Returns:
-        Raises a ValueError if the relative humidity is outside of the
-            range of applicability.
+    Raises:
+        Raises a ValueError if the relative humidity is outside of the range of
+            applicability.
     """
     if (rh < 0.4 or rh > 1) and (rh < 40 or rh > 100):
         raise ValueError(
@@ -154,17 +156,17 @@ def _check_RH(rh: float) -> None:
 
 
 def _check_env_temp(T: float) -> None:
-    """Check if the given environmental temperature is within the range
-        of applicability.
+    """Check if the given environmental temperature is within the range of
+    applicability.
 
     Defined in fib Model Code 2010 (2013), section 5.1.9.4.2.
 
     Args:
         T (float): The environmental temperature in degrees Celcius.
 
-    Returns:
-        Raises a warning if the applied environmental temperature is
-            outside of the range of applicability.
+    Raises:
+        Raises a warning if the applied environmental temperature is outside of
+            the range of applicability.
     """
     if T < 5 or T > 30:
         warnings.warn(
@@ -182,8 +184,8 @@ def t_T(
 ) -> np.ndarray:
     """Calculate the temperature corrected concrete age in days at t0.
 
-    Defined in fib Model Code 2010 (2013). Eq. 5.1-85 (only for a single
-     time value input, as required in Eq. 5.1-73).
+    Defined in fib Model Code 2010 (2013). Eq. 5.1-85 (only for a single time
+    value input, as required in Eq. 5.1-73).
 
     Args:
         t0 (np.typing.ArrayLike): The age of the concrete in days at which the
@@ -196,8 +198,8 @@ def t_T(
             Required when providing a list for T_cur.
 
     Returns:
-        np.ndarray: The temperature corrected age of the concrete in days
-            at loading.
+        np.ndarray: The temperature corrected age of the concrete in days at
+        loading.
     """
     _check_age_at_loading(t0)
     if dt is None:
@@ -215,50 +217,58 @@ def t_T(
     return np.sum(dt * np.exp(13.65 - (4000 / (273 + T_cur))))
 
 
-def t0_adj(_tT: float, cem_class: str) -> float:
-    """Calculate the modified age at loading (t0) to account for the
-        effect of the type of cement and curing temperature on the
-        degree of hydration and - in turn - on creep.
+def t0_adj(
+    t_T: float,
+    cem_class: t.Literal[
+        '32.5 N',
+        '32.5 R',
+        '42.5 N',
+        '42.5 R',
+        '52.5 N',
+        '52.5 R',
+    ],
+) -> float:
+    """Calculate the modified age at loading (t0) to account for the effect of
+    the type of cement and curing temperature on the degree of hydration and -
+    in turn - on creep.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-73.
 
     Args:
-        _tT (float): Temperature adjusted concrete age in days.
-        cem_class (str): The cement strength class that is used.
-            The choices are:
-                '32.5 N',
-                '32.5 R', '42.5 N',
-                '42.5 R', '52.5 N', '52.5 R'.
+        t_T (float): Temperature adjusted concrete age in days.
+        cem_class (str): The cement strength class that is used. The choices
+            are: '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'.
 
     Returns:
         float: The temperature corrected age of the concrete in days at
-            loading, accounting for the effect of the cement type.
-            For slow hardening concrete, the creep coefficient is
-            increased due to the lower modified age at loading.
+        loading, accounting for the effect of the cement type. For slow
+        hardening concrete, the creep coefficient is increased due to the lower
+        modified age at loading.
     """
-    return max(_tT * ((9 / (2 + _tT**1.2)) + 1) ** _alpha[cem_class], 0.5)
+    return max(t_T * ((9 / (2 + t_T**1.2)) + 1) ** ALPHA[cem_class], 0.5)
 
 
-def eps_cds0(fcm: float, cem_class: str) -> float:
+def eps_cds0(
+    fcm: float,
+    cem_class: t.Literal[
+        '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'
+    ],
+) -> float:
     """Calculate the notional drying shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-80.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
-        cem_class (str): The cement strength class that is used.
-            The choices are:
-                '32.5 N',
-                '32.5 R', '42.5 N',
-                '42.5 R', '52.5 N', '52.5 R'.
+        fcm (float): The mean compressive strength of the concrete in MPa.
+        cem_class (str): The cement strength class that is used. The choices
+            are: '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'.
 
     Returns:
-        float: The notional drying shrinkage in mm/mm.
+        float: The notional drying shrinkage, no units.
     """
     return (
-        (220 + 110 * _alpha_ds1[cem_class])
-        * np.exp(-_alpha_ds2[cem_class] * fcm)
+        (220 + 110 * ALPHA_DS1[cem_class])
+        * np.exp(-ALPHA_DS2[cem_class] * fcm)
         * 1e-6
     )
 
@@ -271,16 +281,15 @@ def beta_ds(
     Defined in fib Model Code 2010 (2013), Eq. 5.1-82.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which
-            the shrinkage strain is determined.
-        ts (float): Age of the concrete when exposed to the
-            environment.
-        notional_size (float): The notional size of the considered
-            element in mm, defined as 2A/u.
+        time (numpy.typing.ArrayLike): The different times in days at which the
+            shrinkage strain is determined.
+        ts (float): Age of the concrete when exposed to the environment.
+        notional_size (float): The notional size of the considered element in
+            mm, defined as 2A/u.
 
     Returns:
-        numpy.ndarray: Multiplication factor used for calculating the
-            drying shrinkage as a function of time.
+        numpy.ndarray: Multiplication factor used for calculating the drying
+        shrinkage as a function of time.
     """
     return np.sqrt((time - ts) / (0.035 * (notional_size) ** 2 + (time - ts)))
 
@@ -291,17 +300,16 @@ def beta_s1(fcm: float) -> float:
     Defined in fib Model Code 2010 (2013), Eq. 5.1-83.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
         float: Multiplication factor used when calculating the drying
-            shrinkage.
+        shrinkage.
     """
     return min((35 / fcm) ** 0.1, 1.0)
 
 
-def beta_RH(rh: float, _beta_s1: float) -> float:
+def beta_RH(rh: float, beta_s1: float) -> float:
     """Calculate the multiplication factor beta_RH.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-81
@@ -309,20 +317,20 @@ def beta_RH(rh: float, _beta_s1: float) -> float:
     Args:
         rh (float): The relative humidity of the environment. Value can be
             provided as percentage (i.e. 40--100), or as ratio (i.e. 0.4--1).
-        _beta_s1 (float): Multiplication factor as calculated in the
-            fib Model Code 2010 (2013), Eq. 5.1-83.
+        beta_s1 (float): Multiplication factor as calculated in the fib Model
+            Code 2010 (2013), Eq. 5.1-83.
 
     Returns:
         float: Multiplication factor used when calculating the drying
-            shrinkage.
+        shrinkage.
     """
     _check_RH(rh)
     if rh > 1:
         rh = rh / 100
 
-    if rh >= 0.99 * _beta_s1:
+    if rh >= 0.99 * beta_s1:
         return 0.25
-    if 0.4 * _beta_s1 <= rh < 0.99 * _beta_s1:
+    if 0.4 * beta_s1 <= rh < 0.99 * beta_s1:
         return -1.55 * (1 - rh**3)
     raise ValueError(
         'The specified rh*beta_s1 is not in the range of application.'
@@ -330,97 +338,95 @@ def beta_RH(rh: float, _beta_s1: float) -> float:
 
 
 def eps_cds(
-    _eps_cds0: float,
-    _beta_ds: npt.ArrayLike,
-    _beta_rh: float,
+    eps_cds0: float,
+    beta_ds: npt.ArrayLike,
+    beta_rh: float,
 ) -> np.ndarray:
     """Calculate the drying shrinkage of the concrete element.
 
     Defined in fib Model Code 2010 (2013), Eqs. 5.1-77.
 
     Args:
-        _eps_cds0 (float):  The notional drying shrinkage in mm/mm, as defined
+        eps_cds0 (float):  The notional drying shrinkage, no units, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-80.
-        _beta_ds (numpy.typing.ArrayLike): Multiplication factor used for
+        beta_ds (numpy.typing.ArrayLike): Multiplication factor used for
             calculating the drying shrinkage as a function of time, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-82.
-        _beta_rh (float): Multiplication factor used when calculating the
+        beta_rh (float): Multiplication factor used when calculating the
             drying shrinkage.
 
     Returns:
-        numpy.ndarray: The drying shrinkage strains for the given times in
-            mm/mm.
+        numpy.ndarray: The drying shrinkage strains for the given times, no
+        units.
     """
-    return _eps_cds0 * _beta_rh * _beta_ds
+    return eps_cds0 * beta_rh * beta_ds
 
 
-def eps_cas0(fcm: float, cem_class: str) -> float:
-    """Calculate the notional autogenous shrinkage.
+def eps_cbs0(
+    fcm: float,
+    cem_class: t.Literal[
+        '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'
+    ],
+) -> float:
+    """Calculate the notional basic shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-78.
 
     Args:
         fcm (float): The mean compressive strength of the concrete in
             MPa.
-        cem_class (str): The cement strength class that is used.
-            The choices are:
-                '32.5 N',
-                '32.5 R', '42.5 N',
-                '42.5 R', '52.5 N', '52.5 R'.
+        cem_class (str): The cement strength class that is used. The choices
+            are: '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'.
 
     Returns:
-        float: The notional autogenous shrinkage in mm/mm.
+        float: The notional basic shrinkage, no units.
     """
-    return (
-        -_alpha_as[cem_class] * ((0.1 * fcm) / (6 + 0.1 * fcm)) ** 2.5 * 1e-6
-    )
+    return -ALPHA_BS[cem_class] * ((0.1 * fcm) / (6 + 0.1 * fcm)) ** 2.5 * 1e-6
 
 
-def beta_as(time: npt.ArrayLike) -> np.ndarray:
-    """Calculate multiplication factor beta_as which is used to
-        determine the autogenous shrinkage.
+def beta_bs(time: npt.ArrayLike) -> np.ndarray:
+    """Calculate multiplication factor beta_bs which is used to determine the
+    basic shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-79.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which
-            the autogenous strain is determined.
+        time (numpy.typing.ArrayLike): The different times in days at which the
+            basic strain is determined.
 
     Returns:
-        numpy.ndarray: Multiplication factor that is used to determine
-            the autogenous shrinkage.
+        numpy.ndarray: Multiplication factor that is used to determine the
+        basic shrinkage.
     """
     return 1 - np.exp(-0.2 * np.sqrt(time))
 
 
-def eps_cas(_eps_cas0: float, _beta_as: npt.ArrayLike) -> np.ndarray:
-    """Calculate the autogenous shrinkage.
+def eps_cbs(eps_cbs0: float, beta_bs: npt.ArrayLike) -> np.ndarray:
+    """Calculate the basic shrinkage.
 
     Defined in fib Model Code 2010 (2013), Eqs. 5.1-76.
 
     Args:
-        _eps_cas0 (float): Notional autogeneous shrinkage, as defined in fib
-            Model Code 2010 (2013), Eq. 5.1-78.
-        _beta_as (numpy.typing.ArrayLike): Time function for autogeneous
-            shrinkage, as defined in fib Model Code 2010 (2013), Eq. 5.1-79.
+        eps_cbs0 (float): Notional basic shrinkage, as defined in fib Model
+            Code 2010 (2013), Eq. 5.1-78.
+        beta_bs (numpy.typing.ArrayLike): Time function for basic shrinkage,
+            as defined in fib Model Code 2010 (2013), Eq. 5.1-79.
 
     Returns:
-        numpy.ndarray: The autogenous shrinkage strains for the given
-            times.
+        numpy.ndarray: The basic shrinkage strains for the given times.
     """
-    return _eps_cas0 * _beta_as
+    return eps_cbs0 * beta_bs
 
 
 def beta_bc_fcm(fcm: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the compressive strength of the concrete to calculate the basic
-        creep coefficient.
+    """Calculate multiplication factor that accounts for the effect of the
+    compressive strength of the concrete to calculate the basic creep
+    coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-65.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
         float: Multiplication factor beta_bc_fcm.
@@ -428,59 +434,54 @@ def beta_bc_fcm(fcm: float) -> float:
     return 1.8 / fcm**0.7
 
 
-def beta_bc_t(time: npt.ArrayLike, t0: float, _t0_adj: float) -> np.ndarray:
-    """Calculate multiplication factor that accounts for the effect of
-        the age of the of the concrete to calculate the basic
-        creep coefficient.
+def beta_bc_t(time: npt.ArrayLike, t0: float, t0_adj: float) -> np.ndarray:
+    """Calculate multiplication factor that accounts for the effect of the age
+    of the of the concrete to calculate the basic creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-66.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which
-            the basic creep coefficient is determined.
-        t0 (float): The age of the concrete in days at which the
-            loading is applied.
-        _t0_adj (float): The temperature corrected age of the concrete
-            when the loading is applied in days, as defined in fib
-            Model Code 2010 (2013). Eq. 5.1-85.
+        time (numpy.typing.ArrayLike): The different times in days at which the
+            basic creep coefficient is determined.
+        t0 (float): The age of the concrete in days at which the loading is
+            applied.
+        t0_adj (float): The temperature corrected age of the concrete when the
+            loading is applied in days, as defined in fib Model Code 2010
+            (2013). Eq. 5.1-85.
 
     Returns:
         numpy.ndarray: Multiplication factors beta_bc_t.
     """
-    return np.log(((30 / _t0_adj + 0.035) ** 2) * (time - t0) + 1)
+    return np.log(((30 / t0_adj + 0.035) ** 2) * (time - t0) + 1)
 
 
-def phi_bc(_beta_bc_fcm: float, _beta_bc_t: npt.ArrayLike) -> np.ndarray:
+def phi_bc(beta_bc_fcm: float, beta_bc_t: npt.ArrayLike) -> np.ndarray:
     """Calculate the basic creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-64.
 
     Args:
-        _beta_bc_fcm (float): Multiplication factor that accounts for
-            the influence of the concrete strength of the creep
-            behaviour, as defined in fib Model Code 2010 (2013),
-            Eq. 5.1-65.
-        _beta_bc_t (numpy.typing.ArrayLike): Multiplication factor that
+        beta_bc_fcm (float): Multiplication factor that accounts for the
+            influence of the concrete strength of the creep behaviour, as
+            defined in fib Model Code 2010 (2013), Eq. 5.1-65.
+        beta_bc_t (numpy.typing.ArrayLike): Multiplication factor that
             accounts for the influence of the age of the concrete of the creep
-            behaviour, as defined in fib Model Code 2010 (2013),
-            Eq. 5.1-66.
+            behaviour, as defined in fib Model Code 2010 (2013), Eq. 5.1-66.
 
     Returns:
         numpy.ndarray: The basic creep coefficient.
     """
-    return _beta_bc_fcm * _beta_bc_t
+    return beta_bc_fcm * beta_bc_t
 
 
 def beta_dc_fcm(fcm: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the strength of the concrete to calculate the drying creep
-        coefficient.
+    """Calculate multiplication factor that accounts for the effect of the
+    strength of the concrete to calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-68.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
         float: Multiplication factor beta_dc_fcm.
@@ -489,17 +490,17 @@ def beta_dc_fcm(fcm: float) -> float:
 
 
 def beta_dc_RH(rh: float, notional_size: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the relative humidity of the environment to calculate the
-        drying creep coefficient.
+    """Calculate multiplication factor that accounts for the effect of the
+    relative humidity of the environment to calculate the drying creep
+    coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-69.
 
     Args:
         rh (float): The relative humidity of the environment. Value can be
             provided as percentage (i.e. 40--100), or as ratio (i.e. 0.4--1).
-        notional_size (float): The notional size of the considered
-            element in mm, defined as 2A/u.
+        notional_size (float): The notional size of the considered element in
+            mm, defined as 2A/u.
 
     Returns:
         float: Multiplication factor beta_RH.
@@ -510,34 +511,32 @@ def beta_dc_RH(rh: float, notional_size: float) -> float:
     return (1 - rh) / ((0.1 * notional_size / 100) ** (1 / 3))
 
 
-def beta_dc_t0(_t0_adj: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the (temperature corrected) age of the concrete when loading is
-        applied to calculate the drying creep coefficient.
+def beta_dc_t0(t0_adj: float) -> float:
+    """Calculate multiplication factor that accounts for the effect of the
+    (temperature corrected) age of the concrete when loading is applied to
+    calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-70.
 
     Args:
-        _t0_adj (float): The temperature corrected age of the concrete
-            when the loading is applied in days, as defined in fib
-            Model Code 2010 (2013). Eq. 5.1-85.
+        t0_adj (float): The temperature corrected age of the concrete when the
+            loading is applied in days, as defined in fib Model Code 2010
+            (2013). Eq. 5.1-85.
 
     Returns:
         float: Multiplication factor beta_dc_t0.
     """
-    return 1 / (0.1 + _t0_adj**0.2)
+    return 1 / (0.1 + t0_adj**0.2)
 
 
 def alpha_fcm(fcm: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the strength of the concrete to calculate the drying creep
-        coefficient.
+    """Calculate multiplication factor that accounts for the effect of the
+    strength of the concrete to calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-71d.
 
     Args:
-        fcm (float): The mean compressive strength of the concrete in
-            MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
         float: Multiplication factor alpha_fcm.
@@ -545,146 +544,140 @@ def alpha_fcm(fcm: float) -> float:
     return np.sqrt(35 / fcm)
 
 
-def beta_h(notional_size: float, _alpha_fcm: float) -> float:
-    """Calculate multiplication factor that accounts for the effect of
-        the notional size of the to calculate the drying creep
-        coefficient.
+def beta_h(notional_size: float, alpha_fcm: float) -> float:
+    """Calculate multiplication factor that accounts for the effect of the
+    notional size of the to calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-71c
 
     Args:
-        notional_size (float): The notional size of the considered
-            element in mm, defined as 2A/h.
-        _alpha_fcm (float): Multiplication factor that accounts for the
-            effect of the strength of the concrete on the drying creep
-            coefficient.
+        notional_size (float): The notional size of the considered element in
+            mm, defined as 2A/h.
+        alpha_fcm (float): Multiplication factor that accounts for the effect
+            of the strength of the concrete on the drying creep coefficient.
 
     Returns:
         float: Multiplication factor beta_h.
     """
-    return min(1.5 * notional_size + 250 * _alpha_fcm, 1500 * _alpha_fcm)
+    return min(1.5 * notional_size + 250 * alpha_fcm, 1500 * alpha_fcm)
 
 
-def gamma_t0(_t0_adj: float) -> float:
-    """Calculate exponent that accounts for the effect of the
-        (temperature corrected) age of the concrete when loaded. Used
-        to calculate the drying creep coefficient.
+def gamma_t0(t0_adj: float) -> float:
+    """Calculate exponent that accounts for the effect of the (temperature
+    corrected) age of the concrete when loaded. Used to calculate the drying
+    creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-71b.
 
     Args:
-        _t0_adj (float): The temperature corrected age of the concrete
-            when the loading is applied in days, as defined in fib
-            Model Code 2010 (2013). Eq. 5.1-85.
+        t0_adj (float): The temperature corrected age of the concrete when the
+            loading is applied in days, as defined in fib Model Code 2010
+            (2013). Eq. 5.1-85.
 
     Returns:
         float: Exponent gamma_t0.
     """
-    return 1 / (2.3 + 3.5 / np.sqrt(_t0_adj))
+    return 1 / (2.3 + 3.5 / np.sqrt(t0_adj))
 
 
 def beta_dc_t(
-    time: npt.ArrayLike, t0: float, _beta_h: float, _gamma_t0: float
+    time: npt.ArrayLike, t0: float, beta_h: float, gamma_t0: float
 ) -> np.ndarray:
     """Calculate multiplication factor that accounts for the different
-        considered values of time. Used to calculate the drying creep
-        coefficient.
+    considered values of time. Used to calculate the drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-71a.
 
     Args:
-        time (numpy.typing.ArrayLike): The different times in days at which
-            the drying creep coefficient is determined.
-        t0 (float): The age of the concrete concrete
-            when the loading is applied in days.
-        _beta_h (float): Multiplication factor that accounts for the effect of
+        time (numpy.typing.ArrayLike): The different times in days at which the
+            drying creep coefficient is determined.
+        t0 (float): The age of the concrete concrete when the loading is
+            applied in days.
+        beta_h (float): Multiplication factor that accounts for the effect of
             the notional size, as calculated by Eq. 5.1-71c
-        _gamma_t0 (float): Exponent that accounts for the effect of the
-            (temperature corrected) age of the concrete when loaded,
-            as calculated by Eq. 5.1-71b.
+        gamma_t0 (float): Exponent that accounts for the effect of the
+            (temperature corrected) age of the concrete when loaded, as
+            calculated by Eq. 5.1-71b.
 
     Returns:
-        numpy.ndarray: Multiplcation factor beta_dc_t for the
-            considered values of time.
+        numpy.ndarray: Multiplcation factor beta_dc_t for the considered values
+        of time.
     """
-    return ((time - t0) / (_beta_h + (time - t0))) ** _gamma_t0
+    return ((time - t0) / (beta_h + (time - t0))) ** gamma_t0
 
 
 def phi_dc(
-    _beta_dc_fcm: float,
-    _beta_dc_RH: float,
-    _beta_dc_t0: float,
-    _beta_dc_t: npt.ArrayLike,
+    beta_dc_fcm: float,
+    beta_dc_RH: float,
+    beta_dc_t0: float,
+    beta_dc_t: npt.ArrayLike,
 ) -> np.ndarray:
     """Calculate drying creep coefficient.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-67.
 
     Args:
-        _beta_dc_fcm (float): Multiplication factor that accounts for
-            the effect of the strength of the concrete, as calculated
-            by Eq. 5.1-68.
-        _beta_dc_RH (float): Multiplication factor that accounts for the
-            effect of the relative humidity of the environment, as
-            calculated by Eq. 5.1-69.
-        _beta_dc_t0 (float): multiplication factor that accounts for
-            the effect of the (temperature corrected) age of the
-            concrete when loading is applied, as calculated by Eq.
-            5.1-70.
-        _beta_dc_t (numpy.typing.ArrayLike): multiplication factor that
-            accounts for the different considered values of time, as
-            calculated by Eq. 5.1-71a.
+        beta_dc_fcm (float): Multiplication factor that accounts for the
+            effect of the strength of the concrete, as calculated by Eq.
+            5.1-68.
+        beta_dc_RH (float): Multiplication factor that accounts for the effect
+            of the relative humidity of the environment, as calculated by Eq.
+            5.1-69.
+        beta_dc_t0 (float): multiplication factor that accounts for the effect
+            of the (temperature corrected) age of the concrete when loading is
+            applied, as calculated by Eq. 5.1-70.
+        beta_dc_t (numpy.typing.ArrayLike): multiplication factor that
+            accounts for the different considered values of time, as calculated
+            by Eq. 5.1-71a.
 
     Returns:
         numpy.ndarray: Drying creep coeffcient.
     """
-    return _beta_dc_fcm * _beta_dc_RH * _beta_dc_t0 * _beta_dc_t
+    return beta_dc_fcm * beta_dc_RH * beta_dc_t0 * beta_dc_t
 
 
 def k_sigma(sigma: float, fcm: float) -> float:
-    """Calculate the ratio between the applied stress and the mean
-        concrete compressive strength.
+    """Calculate the ratio between the applied stress and the mean concrete
+    compressive strength.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-74.
 
     Args:
-        sigma (float): The compressive stress applied to the concrete
-            at ts in MPa.
-        fcm (float): The mean compressive strength of the concrete in
+        sigma (float): The compressive stress applied to the concrete at ts in
             MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
-        float: Absolute value of the ratio between the stress in the
-            concrete and the mean concrete strength.
+        float: Absolute value of the ratio between the stress in the concrete
+        and the mean concrete strength.
     """
     _check_initial_stress(sigma, fcm)
     return abs(sigma / fcm)
 
 
 def phi(
-    _phi_bc: npt.ArrayLike, _phi_dc: npt.ArrayLike, sigma: float, fcm: float
+    phi_bc: npt.ArrayLike, phi_dc: npt.ArrayLike, sigma: float, fcm: float
 ) -> np.ndarray:
     """Calculate the creep coefficient distinguishing between linear and
-        non-linear creep for compressive stresses sigma <= 0.4fcm, and
-        0.4fcm < sigma <= 0.6fcm, respectively.
+    non-linear creep for compressive stresses sigma <= 0.4fcm, and 0.4fcm <
+    sigma <= 0.6fcm, respectively.
 
     Defined in fib Model Code 2010, Eqs. 5.1-63 and 5.1-74.
 
     Args:
-        _phi_bc (numpy.typing.ArrayLike): Basic creep coefficient, as defined
+        phi_bc (numpy.typing.ArrayLike): Basic creep coefficient, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-64.
-        _phi_dc (numpy.typing.ArrayLike): Drying creep coefficient, as defined
+        phi_dc (numpy.typing.ArrayLike): Drying creep coefficient, as defined
             in fib Model Code 2010 (2013), Eq. 5.1-67.
-        sigma (float): The compressive stress applied to the concrete
-            at ts in MPa.
-        fcm (float): The mean compressive strength of the concrete in
+        sigma (float): The compressive stress applied to the concrete at ts in
             MPa.
+        fcm (float): The mean compressive strength of the concrete in MPa.
 
     Returns:
         numpy.ndarray: The creep coefficient.
     """
     # Calculate the creep coefficient (phi) (see Eq. 5.1-63)
-    _phi = _phi_bc + _phi_dc
+    _phi = phi_bc + phi_dc
     # Include the effect of high stress if needed (see Eq. 5.1-74 of [1]):
     _k_sigma = k_sigma(sigma, fcm)
     if 0.4 < _k_sigma <= 0.6:
@@ -692,20 +685,20 @@ def phi(
     return _phi
 
 
-def calc_J(_E_ci_t0: float, _phi: npt.ArrayLike, _E_ci: float) -> np.ndarray:
+def calc_J(E_ci_t0: float, phi: npt.ArrayLike, E_ci: float) -> np.ndarray:
     """Calculate the creep compliance function.
 
     Defined in fib Model Code 2010, Eq. 5.1-61.
 
     Args:
-        _E_ci_t0 (float): Modulus of elasticity at time of loading t0, as
+        E_ci_t0 (float): Modulus of elasticity at time of loading t0, as
             defined in fib Model Code 2010 (2013), Eq. 5.1-56.
-        _phi (numpy.typing.ArrayLike): Creep coefficient, as defined in fib
+        phi (numpy.typing.ArrayLike): Creep coefficient, as defined in fib
             Model Code 2010 (2013), Eq. 5.1-63.
-        _E_ci (float) Modulus of elasticity of the concrete at 28 days, as
+        E_ci (float) Modulus of elasticity of the concrete at 28 days, as
             defined in fib Model Code 2010 (2013), Eq. 5.1-21.
 
     Returns:
         numpy.ndarray: The creep compliance function.
     """
-    return (1 / _E_ci_t0) + (_phi / _E_ci)
+    return (1 / E_ci_t0) + (phi / E_ci)
diff --git a/structuralcodes/codes/mc2010/_concrete_interface_different_casting_times.py b/structuralcodes/codes/mc2010/_concrete_interface_different_casting_times.py
index 4fec441e..dedbc740 100644
--- a/structuralcodes/codes/mc2010/_concrete_interface_different_casting_times.py
+++ b/structuralcodes/codes/mc2010/_concrete_interface_different_casting_times.py
@@ -3,20 +3,20 @@
 from math import cos, pi, sin
 
 
-def tau_edi(beta: float, v_ed: float, z: float, b_i: float):
+def tau_edi(beta: float, v_ed: float, z: float, b_i: float) -> float:
     """Shear at the interface between concrete cast at different times.
 
-    fib Model Code 2010, eq. (7.3-49)
+    fib Model Code 2010, eq. (7.3-49).
 
     Args:
         beta (float): The ratio of longitudinal force in the new concrete and
-        the longitudinal force in either compression or tension zone
-        v_ed (float): The shear force at the interface in N
-        z (float): The inner lever arm of the composed section in mm
-        b_i (float): The width of the inerface in mm
+            the longitudinal force in either compression or tension zone.
+        v_ed (float): The shear force at the interface in N.
+        z (float): The inner lever arm of the composed section in mm.
+        b_i (float): The width of the inerface in mm.
 
-    Return:
-    The shear force that should be used at the intersection
+    Returns:
+        float: The shear force that should be used at the intersection.
     """
     return (beta * v_ed) / (z * b_i)
 
@@ -28,25 +28,25 @@ def tau_rdi_without_reinforcement(
     sigma_n: float,
     f_ck: float,
     f_cd: float,
-):
-    """Shear resistance without reinforcement at the intesection with
-    different casting time.
+) -> float:
+    """Shear resistance without reinforcement at the intesection with different
+    casting time.
 
-    fib Model Code 2010, eq. (7.3-50)
+    fib Model Code 2010, eq. (7.3-50).
 
     Args:
-        c_a (float): The coefficient for adhesive bond (Tabel 7.3-1)
-        f_ctd (float): The design axial tensile strength of concrete
-        mu (float): The friction coefficient
-        sigma_n (float): The lowest expected compressive stress from
-        normal forces in MPa
-        f_ck (float): Characteristic strength in MPa
-        f_cd (float): The design value of cylinder compressive
-        strength concrete in MPa
-
-    Return:
-        The shear resistance without reinforcement at the intesection with
-    different casting time
+        c_a (float): The coefficient for adhesive bond (Table 7.3-1).
+        f_ctd (float): The design axial tensile strength of concrete.
+        mu (float): The friction coefficient.
+        sigma_n (float): The lowest expected compressive stress from normal
+            forces in MPa.
+        f_ck (float): Characteristic strength in MPa.
+        f_cd (float): The design value of cylinder compressive strength
+            concrete in MPa.
+
+    Returns:
+        float: The shear resistance without reinforcement at the intesection
+        with different casting time.
     """
     v = min(0.55 * (30 / f_ck) ** (1 / 3), 0.55)
     return min((c_a * f_ctd) + (mu * sigma_n), 0.5 * v * f_cd)
@@ -64,35 +64,35 @@ def tau_rdi_with_reinforcement(
     f_ck: float,
     f_yd: float,
     f_cd: float,
-):
+) -> float:
     """Shear resistance with reinforcement or dowels at the intesection with
     different casting time.
 
-    fib Model Code 2010, eq. (7.3-51)
+    fib Model Code 2010, eq. (7.3-51).
 
     Args:
-        c_r (float): Coefficient for aggregate interlock effects (Tabel 7.3-2)
-        k1 (float): The interaction coefficient for tensile
-        force activated in reinforcment (Tabel 7.3-2)
-        k2 (float): The interaction coeffiction for flexural
-        resistance (Tabel 7.3-2)
-        mu (float): The friction coefficient (Tabel 7.3-2)
-        ro (float): The reinforcement ratio of reinforcing steel
-        crossing the interface
-        sigma_n (float): The lowest expected compressive stress resulting
-        from normal forces acting on the interface in MPa
-        alpha (float): The inclination of reinforcement crossing the
-        interface (Tabel 7.3-14)
-        beta_c (float): The coefficient for strength of
-        compression strut (Tabel 7.3-2)
-        f_ck (float): Characteristic strength in MPa
-        f_yd (float): design strength of reinforment steel in MPa
-        f_cd (float): The design value of cylinder compressive
-        strength concrete
-
-    Return:
-        Shear resistance with reinforcement at intesection with
-    different casting time
+        c_r (float): Coefficient for aggregate interlock effects (Table 7.3-2).
+        k1 (float): The interaction coefficient for tensile force activated in
+            reinforcment (Table 7.3-2).
+        k2 (float): The interaction coeffiction for flexural resistance (Table
+            7.3-2).
+        mu (float): The friction coefficient (Table 7.3-2).
+        ro (float): The reinforcement ratio of reinforcing steel crossing the
+            interface.
+        sigma_n (float): The lowest expected compressive stress resulting from
+            normal forces acting on the interface in MPa.
+        alpha (float): The inclination of reinforcement crossing the interface
+            (Table 7.3-14).
+        beta_c (float): The coefficient for strength of compression strut
+            (Table 7.3-2).
+        f_ck (float): Characteristic strength in MPa.
+        f_yd (float): design strength of reinforment steel in MPa.
+        f_cd (float): The design value of cylinder compressive strength
+            concrete.
+
+    Returns:
+        float: Shear resistance with reinforcement at intesection with
+        different casting time.
     """
     v = min(0.55 * (30 / f_ck) ** (1 / 3), 0.55)
     return min(
diff --git a/structuralcodes/codes/mc2010/_concrete_material_properties.py b/structuralcodes/codes/mc2010/_concrete_material_properties.py
index 52e4ae82..c73a1868 100644
--- a/structuralcodes/codes/mc2010/_concrete_material_properties.py
+++ b/structuralcodes/codes/mc2010/_concrete_material_properties.py
@@ -1,6 +1,9 @@
 """A collection of material properties for concrete."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import math
+import typing as t
 
 import numpy as np
 import numpy.typing as npt
@@ -27,14 +30,14 @@ def fcm(fck: float, delta_f: float = 8.0) -> float:
     """Compute the mean concrete compressive strength from the characteristic
     strength.
 
-    fib Model Code 2010, Eq. (5.1-1)
+    fib Model Code 2010, Eq. (5.1-1).
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
 
     Keyword Args:
-        delta_f (float): The difference between the mean and the
-        characteristic strength.
+        delta_f (float): The difference between the mean and the characteristic
+            strength.
 
     Returns:
         float: The mean compressive strength in MPa.
@@ -46,7 +49,7 @@ def fctm(fck: float) -> float:
     """Compute the mean concrete tensile strength from the characteristic
     compressive strength.
 
-    fib Model Code 2010, Eqs. (5.1-3a) and (5.1-3b)
+    fib Model Code 2010, Eqs. (5.1-3a) and (5.1-3b).
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
@@ -59,41 +62,41 @@ def fctm(fck: float) -> float:
     return 2.12 * math.log(1 + 0.1 * fcm(fck))
 
 
-def fctkmin(_fctm: float) -> float:
+def fctkmin(fctm: float) -> float:
     """Compute the lower bound value of the characteristic tensile strength
     from the mean tensile strength.
 
-    fib Model Code 2010, Eq. (5.1-4)
+    fib Model Code 2010, Eq. (5.1-4).
 
     Args:
-        _fctm (float): The mean tensile strength in MPa.
+        fctm (float): The mean tensile strength in MPa.
 
     Returns:
         float: Lower bound of the characteristic tensile strength in MPa.
     """
-    return 0.7 * _fctm
+    return 0.7 * fctm
 
 
-def fctkmax(_fctm: float) -> float:
+def fctkmax(fctm: float) -> float:
     """Compute the upper bound value of the characteristic tensile strength
     from the mean tensile strength.
 
-    fib Model Code 2010, Eq. (5.1-5)
+    fib Model Code 2010, Eq. (5.1-5).
 
     Args:
-        _fctm (float): The mean tensile strength in MPa.
+        fctm (float): The mean tensile strength in MPa.
 
     Returns:
         float: Upper bound of the characteristic tensile strength in MPa.
     """
-    return 1.3 * _fctm
+    return 1.3 * fctm
 
 
 def Gf(fck: float) -> float:
     """Compute tensile fracture energy from characteristic compressive
     strength.
 
-    fib Model Code 2010, Eq. (5.1-9)
+    fib Model Code 2010, Eq. (5.1-9).
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
@@ -104,8 +107,12 @@ def Gf(fck: float) -> float:
     return 73 * fcm(fck) ** 0.18
 
 
-def E_ci(
-    _fcm: float, agg_type: str = 'quartzite', EC0: float = 21500
+def Eci(
+    fcm: float,
+    agg_type: t.Literal[
+        'basalt', 'quartzite', 'limestone', 'sandstone'
+    ] = 'quartzite',
+    EC0: float = 21500,
 ) -> float:
     """Calculate the modulus of elasticity for normal weight concrete at 28
     days.
@@ -113,7 +120,7 @@ def E_ci(
     Defined in fib Model Code 2010 (2013), Eq. 5.1-21.
 
     Args:
-        _fcm (float): The mean value of the compressive strength of the
+        fcm (float): The mean value of the compressive strength of the
             concrete in MPa.
 
     Keyword Args:
@@ -122,71 +129,73 @@ def E_ci(
         EC0 (float): Initial value of modulus of elasticity in MPa.
 
     Returns:
-        float: The modulus of elasticity for normal weight concrete
-            at 28 days in MPa.
+        float: The modulus of elasticity for normal weight concrete at 28 days
+        in MPa.
     """
-    return EC0 * ALPHA_E[agg_type.lower()] * (_fcm / 10) ** (1 / 3)
+    return EC0 * ALPHA_E[agg_type.lower()] * (fcm / 10) ** (1 / 3)
 
 
-def beta_cc(time: npt.ArrayLike, _fcm: float, cem_class: str) -> np.ndarray:
+def beta_cc(
+    time: npt.ArrayLike,
+    fcm: float,
+    cem_class: t.Literal[
+        '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'
+    ],
+) -> np.ndarray:
     """Calculate multiplication factor beta_cc, used to determine the
-        modulus of elasticity at an arbitrary time.
+    compressive strength at an arbitrary time.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-51.
 
     Args:
-        time (numpy.typing.ArrayLike): The time in days at which the modulus
-            of elasticity is to be determined.
-        _fcm The mean compressive strength of the concrete in
-            MPa.
-        cem_class (str): The cement strength class that is used.
-            The choices are:
-                '32.5 N',
-                '32.5 R', '42.5 N',
-                '42.5 R', '52.5 N', '52.5 R'.
+        time (numpy.typing.ArrayLike): The time in days at which the
+            compressive strength is to be determined.
+        fcm (float): The mean compressive strength of the concrete in MPa.
+        cem_class (str): The cement strength class that is used. The choices
+            are: '32.5 N', '32.5 R', '42.5 N', '42.5 R', '52.5 N', '52.5 R'.
 
     Returns:
         numpy.ndarray: Multiplication factor beta_cc.
     """
-    if _fcm > 60:
+    if fcm > 60:
         return np.exp(0.2 * (1 - np.sqrt(28 / time)))
     return np.exp(S_CEM[cem_class.upper()] * (1 - np.sqrt(28 / time)))
 
 
-def beta_e(_beta_cc: npt.ArrayLike) -> np.ndarray:
-    """Calculate multiplication factor beta_e, used to determine the
-        modulus of elasticity at an arbitrary time.
+def beta_e(beta_cc: npt.ArrayLike) -> np.ndarray:
+    """Calculate multiplication factor beta_e, used to determine the modulus of
+    elasticity at an arbitrary time.
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-57.
 
     Args:
-        _beta_cc (numpy.typing.ArrayLike): multiplication factor as defined in
+        beta_cc (numpy.typing.ArrayLike): Multiplication factor as defined in
             the fib Model Code 2010 (2013), Eq. 5.1-51.
 
     Returns:
         numpy.ndarray: Multiplication factor beta_e.
     """
-    return np.sqrt(_beta_cc)
+    return np.sqrt(beta_cc)
 
 
-def E_ci_t(_beta_e: npt.ArrayLike, _E_ci: float) -> np.ndarray:
-    """Calculate the modulus of elasticity for normal weight concrete
-        at time 'time' (not 28 days).
+def Eci_t(beta_e: npt.ArrayLike, Eci: float) -> np.ndarray:
+    """Calculate the modulus of elasticity for normal weight concrete at time
+    'time' (not 28 days).
 
     Defined in fib Model Code 2010 (2013), Eq. 5.1-56.
 
     Args:
-        _beta_e (numpy.typing.ArrayLike): Multiplication factor to determine
+        beta_e (numpy.typing.ArrayLike): Multiplication factor to determine
             the modulus of elasticity at an arbitrary time, as defined in fib
             Model Code 2010 (2013), Eq. 5.1-51.
-        _E_ci (float): Modulus of elasticity of normal weight concrete at 28
+        Eci (float): Modulus of elasticity of normal weight concrete at 28
             days, as defined in fib Model Code 2010 (2013), Eq. 5.1-21.
 
     Returns:
         numpy.ndarray: The modulus of elasticity for normal weight concrete at
-            time 'time' (not 28 days) in MPa.
+        time 'time' (not 28 days) in MPa.
     """
-    return _beta_e * _E_ci
+    return beta_e * Eci
 
 
 def fcd(fck: float, alpha_cc: float = 1.0, gamma_c: float = 1.5) -> float:
@@ -196,13 +205,15 @@ def fcd(fck: float, alpha_cc: float = 1.0, gamma_c: float = 1.5) -> float:
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
+
+    Keyword Args:
         alpha_cc (float): A factor for considering long-term effects on the
             strength, and effects that arise from the way the load is applied.
             Default value 1.0.
         gamma_c (float): The partial factor of concrete. Default value 1.5.
 
     Returns:
-        float: The design compressive strength of concrete in MPa
+        float: The design compressive strength of concrete in MPa.
     """
     return abs(alpha_cc) * abs(fck) / abs(gamma_c)
 
diff --git a/structuralcodes/codes/mc2010/_concrete_punching.py b/structuralcodes/codes/mc2010/_concrete_punching.py
index cd82e630..442b3cce 100644
--- a/structuralcodes/codes/mc2010/_concrete_punching.py
+++ b/structuralcodes/codes/mc2010/_concrete_punching.py
@@ -7,15 +7,15 @@
 def b_0(v_ed: float, v_prep_d_max: float) -> float:
     """Gives the general output for b_0, shear-resisting control perimeter.
 
-    fib Model Code 2010, eq. (7.3-57)
+    fib Model Code 2010, eq. (7.3-57).
 
     Args:
-        V_ed (float): The acting shear force from the columns
+        V_ed (float): The acting shear force from the columns.
         v_prep_d_max (float): The maximum shear force per unit length
-        perpendiculerer to the basic control parameter (Figure 7.3-24)
+            perpendicular to the basic control parameter (Figure 7.3-24).
 
-    Return:
-    The shear-resisting control perimeter, b_0
+    Returns:
+        float: The shear-resisting control perimeter, b_0.
     """
     return v_ed / v_prep_d_max
 
@@ -33,24 +33,24 @@ def m_ed(
     """The average bending moment acting in the support strip.
 
     fib Model Code 2010, eq. (7.3-76), (7.3-71), (7.3-72), (7.3-73)
-    and (7.3-74)
+    and (7.3-74).
 
     Args:
-        v_ed (float): The acting shear force from the columns
+        v_ed (float): The acting shear force from the columns.
         e_u (float): Refers to the eccentricity of the resultant of shear
-        forces with respect to the centroid
-        l_x (float): The width in x direction that the collumn carries
-        l_y (float): The width in y direction that the collumn carries
-        inner (bool): Is true only if the column is a inner column
+            forces with respect to the centroid.
+        l_x (float): The width in x direction that the collumn carries.
+        l_y (float): The width in y direction that the collumn carries.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        corner (bool): Is true only if the column is a corner column
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
 
-    Return:
-        The bending moment acting in the support strip regardless of the
-        position of the column
+    Returns:
+        float: The bending moment acting in the support strip regardless of the
+        position of the column.
     """
     r_sx = 0.22 * l_x
     r_sy = 0.22 * l_y
@@ -85,30 +85,30 @@ def psi_punching(
 ) -> float:
     """The rotation of the slab around the supported area.
 
-    fib Model Code 2010, eq. (7.3-70), (7.3-75) and (7.3-77)
+    fib Model Code 2010, eq. (7.3-70), (7.3-75) and (7.3-77).
 
     Args:
-        l_x (float): The distance between two columns in x direction
-        l_y (float): The distance between two columns in y direction
-        f_yd (float): Design strength of reinforment steel in MPa
-        d (float): The mean value of the effective depth in mm
-        e_s (float): The E_modulus for steel in MPa
-        approx_lvl_p (float): The approx level for punching
-        v_ed (float): The acting shear force from the columns
+        l_x (float): The distance between two columns in x direction.
+        l_y (float): The distance between two columns in y direction.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        approx_lvl_p (float): The approx level for punching.
+        v_ed (float): The acting shear force from the columns.
         e_u (float): Refers to the eccentricity of the resultant of shear
-        forces with respect to the centroid
-        inner (bool): Is true only if the column is a inner column
+            forces with respect to the centroid.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        corner (bool): Is true only if the column is a corner column
-        m_rd (float): The design average strength per unit length in MPa
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
+        m_rd (float): The design average strength per unit length in MPa.
         m_pd: (float): The average decompresstion moment due to prestressing
-        in MPa
+            in MPa.
 
-    Return:
-    psi for the chosen approx level in punching
+    Returns:
+        float: psi for the chosen approx level in punching.
     """
     r_s = max(0.22 * l_x, 0.22 * l_y)
     if approx_lvl_p == 1:
@@ -147,36 +147,36 @@ def v_rdc_punching(
 ) -> float:
     """Punching resistance from the concrete.
 
-    fib Model Code 2010, eq. (7.3-61), (7.3-62) and (7.3-63)
+    fib Model Code 2010, eq. (7.3-61), (7.3-62) and (7.3-63).
 
     Args:
-        l_x (float): The distance between two columns in x direction
-        l_y (float): The distance between two columns in y direction
-        f_yd (float): Design strength of reinforment steel in MPa
-        d (float): The mean value of the effective depth in mm
-        e_s (float): The E_modulus for steel in MPa
-        approx_lvl_p (float): The approx level for punching
-        dg (float): Maximum size of aggregate
-        f_ck (float): Characteristic strength in MPa
-        d_v (float): The effective depth considering support in mm
-        v_ed (float): The acting shear force from the columns
+        l_x (float): The distance between two columns in x direction.
+        l_y (float): The distance between two columns in y direction.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        approx_lvl_p (float): The approx level for punching.
+        dg (float): Maximum size of aggregate.
+        f_ck (float): Characteristic strength in MPa.
+        d_v (float): The effective depth considering support in mm.
+        v_ed (float): The acting shear force from the columns.
         e_u (float): Refers to the eccentricity of the resultant of shear
-        forces with respect to the centroid
-        inner (bool): Is true only if the column is a inner column
+            forces with respect to the centroid.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        corner (bool): Is true only if the column is a corner column
-        m_rd (float): The design average strength per unit length in MPa
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
+        m_rd (float): The design average strength per unit length in MPa.
         m_pd: (float): The average decompresstion moment due to prestressing
-        in MPa
+            in MPa.
         v_prep_d_max (float): The maximum shear force per unit length
-        perpendiculerer to the basic control parameter (Figure 7.3-24)
-        gamma_c: Safety factor for concrete
+            perpendicular to the basic control parameter (Figure 7.3-24).
+        gamma_c: Safety factor for concrete.
 
-    Return:
-    v_rdc for punching with the right approx level
+    Returns:
+        float: v_rdc for punching with the right approx level.
     """
     k_dg = max(32 / (16 + dg), 0.75)
     k_psi = min(
@@ -231,39 +231,41 @@ def v_rds_punching(
     a_sw: float,
     gamma_s: float,
 ):
-    """The punching resistance from shear reinforcement
-     fib Model Code 2010, eq. (7.3-64) and (7.3-65).
+    """The punching resistance from shear reinforcement.
+
+    fib Model Code 2010, eq. (7.3-64) and (7.3-65).
 
     Args:
         e_u (float): The ecentrisity of the result of shear forces
-        with respect to the centroid (Figure 7.3-27b)
-        b_u (float): The diamter of a circle with same surface as the
-        region inside the basic control perimeter (Figure 7.3-27b)
-        l_x (float): The distance between two columns in x direction
-        l_y (float): The distance between two columns in y direction
-        f_yd (float): Design strength of reinforment steel in MPa
-        d (float): The mean value of the effective depth in mm
-        e_s (float): The E_modulus for steel in MPa
-        approx_lvl_p (float): The approx level for punching
-        v_ed (float): The acting shear force from the columns
-        inner (bool): Is true only if the column is a inner column
+            with respect to the centroid (Figure 7.3-27b).
+        b_u (float): The diamter of a circle with same surface as the region
+            inside the basic control perimeter (Figure 7.3-27b).
+        l_x (float): The distance between two columns in x direction.
+        l_y (float): The distance between two columns in y direction.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        approx_lvl_p (float): The approx level for punching.
+        v_ed (float): The acting shear force from the columns.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        corner (bool): Is true only if the column is a corner column
-        m_rd (float): The design average strength per unit length in MPa
-        m_pd: (float): The average decompresstion moment due to prestressing
-        in MPa
-        alpha (float): Inclination of the stirrups in degrees
-        f_bd (float): The design bond strength in MPa
-        f_ywk (float): Characteristic yield strength of the shear
-        reinforcement in MPa
-        phi_w (float): The diameter of the shear reinforcement
-        a_sw (float): The area of the shear reinforcement in mm^2
-        gamma_s (float): Steels reduction factor
-
-    Return: Punching resistance that comes from reinforcement
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
+        m_rd (float): The design average strength per unit length in MPa.
+        m_pd: (float): The average decompresstion moment due to prestressing in
+            MPa.
+        alpha (float): Inclination of the stirrups in degrees.
+        f_bd (float): The design bond strength in MPa.
+        f_ywk (float): Characteristic yield strength of the shear reinforcement
+            in MPa.
+        phi_w (float): The diameter of the shear reinforcement.
+        a_sw (float): The area of the shear reinforcement in mm^2.
+        gamma_s (float): Safety factor for reinforcement.
+
+    Returns:
+        float: Punching resistance that comes from reinforcement.
     """
     f_ywd = f_ywk / gamma_s
     k_e = 1 / (1 + e_u / b_u)
@@ -323,42 +325,42 @@ def v_rd_max_punching(
     d_head: bool,
     stirrups_compression: bool,
     gamma_c: float = 1.5,
-):
+) -> float:
     """Finds the maximum value you can have for v_rd_punching.
 
-    fib Model Code 2010, eq. (7.3-68) and (7.3-69)
+    fib Model Code 2010, eq. (7.3-68) and (7.3-69).
 
     Args:
-        l_x (float): The distance between two columns in x direction
-        l_y (float): The distance between two columns in y direction
-        f_yd (float): Design strength of reinforment steel in MPa
-        d (float): The mean value of the effective depth in mm
-        e_s (float): The E_modulus for steel in MPa
-        approx_lvl_p (float): The approx level for punching
-        v_ed (float): The acting shear force from the columns
+        l_x (float): The distance between two columns in x direction.
+        l_y (float): The distance between two columns in y direction.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        approx_lvl_p (float): The approx level for punching.
+        v_ed (float): The acting shear force from the columns.
         e_u (float): Refers to the eccentricity of the resultant of shear
-        forces with respect to the centroid
-        inner (bool): Is true only if the column is a inner column
+            forces with respect to the centroid.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        dg (float): Maximum size of aggregate
-        corner (bool): Is true only if the column is a corner column
-        m_rd (float): The design average strength per unit length in MPa
-        m_pd: (float): The average decompresstion moment due to prestressing
-        in MPa
+            tension reinforcement perpendicular to the edge.
+        dg (float): Maximum size of aggregate.
+        corner (bool): Is true only if the column is a corner column.
+        m_rd (float): The design average strength per unit length in MPa.
+        m_pd: (float): The average decompresstion moment due to prestressing in
+            MPa.
         v_prep_d_max (float): The maximum shear force per unit length
-        perpendiculerer to the basic control parameter (Figure 7.3-24)
-        d_v (float): The effective depth considering support in mm
-        f_ck (float): Characteristic strength in MPa
-        d_head (bool): True if diameter of heads is three times larger than
+            perpendiculerer to the basic control parameter (Figure 7.3-24).
+        d_v (float): The effective depth considering support in mm.
+        f_ck (float): Characteristic strength in MPa.
+        d_head (bool): True if diameter of heads is three times larger than.
         stirrups_compression: (bool): Stirrups with sufficient length at
-        compression face, and bent on tension face
-        gamma_c (float): Concrete reduction factor
+            compression face, and bent on tension face.
+        gamma_c (float): Safety factor for concrete.
 
     Return:
-        The maximum allowed punching resistance
+        float: The maximum allowed punching resistance.
     """
     if d_head:
         k_sys = 2.8
@@ -429,46 +431,47 @@ def v_rd_punching(
     stirrups_compression: bool,
     gamma_c: float = 1.5,
     gamma_s: float = 1.15,
-):
+) -> float:
     """The total resistance for punching, both Vrd,c and Vrd,s.
 
-     fib Model Code 2010, eq. (7.3-60)
+    fib Model Code 2010, eq. (7.3-60).
 
     Args:
-        e_u (float): The ecentrisity of the result of shear forces
-        with respect to the centroid (Figure 7.3-27b)
-        b_u (float): The diamter of a circle with same surface as the
-        region inside the basic control perimeter (Figure 7.3-27b)
-        l_x (float): The distance between two columns in x direction
-        l_y (float): The distance between two columns in y direction
-        f_yd (float): Design strength of reinforment steel in MPa
-        d (float): The mean value of the effective depth in mm
-        e_s (float): The E_modulus for steel in MPa
-        approx_lvl_p (float): The approx level for punching
-        v_ed (float): The acting shear force from the columns
-        inner (bool): Is true only if the column is a inner column
+        e_u (float): The ecentrisity of the result of shear forces with respect
+            to the centroid (Figure 7.3-27b).
+        b_u (float): The diamter of a circle with same surface as the region
+            inside the basic control perimeter (Figure 7.3-27b).
+        l_x (float): The distance between two columns in x direction.
+        l_y (float): The distance between two columns in y direction.
+        f_yd (float): Design strength of reinforment steel in MPa.
+        d (float): The mean value of the effective depth in mm.
+        e_s (float): The E_modulus for steel in MPa.
+        approx_lvl_p (float): The approx level for punching.
+        v_ed (float): The acting shear force from the columns.
+        inner (bool): Is true only if the column is a inner column.
         edge_par (bool): Is true only if the column is a edge column with
-        tension reinforcement parallel to the edge
+            tension reinforcement parallel to the edge.
         edge_per (bool): Is true only if the column is a edge column with
-        tension reinforcement perpendicular to the edge
-        corner (bool): Is true only if the column is a corner column
-        m_rd (float): The design average strength per unit length in MPa
-        m_pd: (float): The average decompresstion moment due to prestressing
-        in MPa
-        alpha (float): Inclination of the stirrups in degrees
-        f_bd (float): The design bond strength in MPa
+            tension reinforcement perpendicular to the edge.
+        corner (bool): Is true only if the column is a corner column.
+        m_rd (float): The design average strength per unit length in MPa.
+        m_pd: (float): The average decompresstion moment due to prestressing in
+            MPa.
+        alpha (float): Inclination of the stirrups in degrees.
+        f_bd (float): The design bond strength in MPa.
         f_ywk (float): Characteristic yield strength of the shear reinforcement
-        in MPa
-        phi_w (float): The diameter of the shear reinforcement
-        a_sw (float): The area of the shear reinforcement in mm^2
-        dg (float): Maximum size of aggregate
-        f_ck (float): Characteristic strength in MPa
-        d_v (float): The effective depth considering support in mm
+            in MPa.
+        phi_w (float): The diameter of the shear reinforcement.
+        a_sw (float): The area of the shear reinforcement in mm^2.
+        dg (float): Maximum size of aggregate.
+        f_ck (float): Characteristic strength in MPa.
+        d_v (float): The effective depth considering support in mm.
         v_prep_d_max (float): The maximum shear force per unit length
-        perpendiculerer to the basic control parameter (Figure 7.3-24)
+            perpendicular to the basic control parameter (Figure 7.3-24).
 
-    Return: The maximum allowed punching resistance, regardless of
-    values from v_rdc and v_rds
+    Return:
+        float: The maximum allowed punching resistance, regardless of values
+        from v_rdc and v_rds.
     """
     return min(
         v_rdc_punching(
diff --git a/structuralcodes/codes/mc2010/_concrete_shear.py b/structuralcodes/codes/mc2010/_concrete_shear.py
index 30de4172..5e5eab92 100644
--- a/structuralcodes/codes/mc2010/_concrete_shear.py
+++ b/structuralcodes/codes/mc2010/_concrete_shear.py
@@ -1,35 +1,28 @@
 """A collection of shear formulas for concrete."""
 
+import typing as t
 import warnings
 from math import pi, sin, tan
-from typing import Optional
 
 
 def epsilon_x(
     E_s: float,
     As: float,
     z: float,
-    loads: dict,
+    loads: t.Dict,
 ) -> float:
     """Calculate the longitudinal strain from a distance z.
 
-    fib Model Code 2010, eq. (7.3-16)
+    fib Model Code 2010, eq. (7.3-16).
 
     Args:
-        E (float): The E-modulus to the material in MPa
-        As (float): The cross-section area of reinforcement in mm^2
-        z: (float): The effective shear depth in mm
-        loads (dictionary) The given loads in a dictionary:
-            Med (Float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value in compression direction
+        E (float): The E-modulus to the material in MPa.
+        As (float): The cross-section area of reinforcement in mm^2.
+        z: (float): The effective shear depth in mm.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
 
     Returns:
-    float: The longitudinal strain
+        float: The longitudinal strain.
     """
     return max(
         (
@@ -47,21 +40,34 @@ def epsilon_x(
 def eta_fc(fck: float) -> float:
     """Calculating eta_fc to determin the strength reduction factor.
 
-    fib Model Code 2010, eq. (7.3-28)
+    fib Model Code 2010, eq. (7.3-28).
 
     Args:
-        fck (float): Characteristic strength in MPa
+        fck (float): Characteristic strength in MPa.
 
     Returns:
-        float: eta_fc in the strength reduction factor
+        float: eta_fc in the strength reduction factor.
     """
     return min((30 / fck) ** (1 / 3), 1)
 
 
 def create_load_dict(
     Med: float, Ved: float, Ned: float, delta_e: float
-) -> dict:
-    """Returns dictionary assosiated with loads."""
+) -> t.Dict:
+    """Returns dictionary assosiated with loads.
+
+    Args:
+        Med (Float): The positive moment working on the material in Nmm.
+        Ved (float): The positive shear force working on the material in N.
+        Ned (float): The normal force working on the material in N with
+            positive sign for tension and negative sign for compression.
+        delta_E (float): The eccentricity of the axial load due to imperfection
+            in the construction with distance in mm as a positive value in
+            compression direction.
+
+    Returns:
+        dict: A dictionary with the given loads.
+    """
     return {'Med': Med, 'Ved': Ved, 'Ned': Ned, 'delta_e': delta_e}
 
 
@@ -74,54 +80,47 @@ def v_rd(
     dg: float,
     E_s: float,
     As: float,
-    loads: dict,
-    asw: Optional[float],
-    sw: Optional[float],
-    f_ywk: Optional[float],
-    theta: Optional[float],
+    loads: t.Dict,
+    asw: t.Optional[float] = None,
+    sw: t.Optional[float] = None,
+    f_ywk: t.Optional[float] = None,
+    theta: t.Optional[float] = None,
     alpha: float = 90.0,
     gamma_c: float = 1.5,
     gamma_s: float = 1.15,
 ) -> float:
     """Compute the shear resistance of a web or slab.
 
-    fib Model Code 2010, Eq. (7.3-11)
+    fib Model Code 2010, Eq. (7.3-11).
 
     Args:
-        approx_lvl (int): Approximation level for concrete
+        approx_lvl (int): Approximation level for concrete.
         with_shear_reinforcment (bool): Shear reinforced concrete or no shear
-        reinforcement
-        fck (float): Characteristic strength in MPa
-        z (float): distances between the centerline of the
-        compressive chord and the reinforcement in mm
-        bw (float): Thickness of web in cross section in mm
-        dg (float): Maximum size of aggregate in mm
-        E_s (float): The E_s-modulus to the material in MPa
-        As (float): The cross-section area of reinforcement in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        asw (float): Area of shear reinforcement in mm^2
-        sw (float): Senter distance between the shear reinforcement in mm
+            reinforcement.
+        fck (float): Characteristic strength in MPa.
+        z (float): distances between the centerline of the compressive chord
+            and the reinforcement in mm.
+        bw (float): Thickness of web in cross section in mm.
+        dg (float): Maximum size of aggregate in mm.
+        E_s (float): The E_s-modulus to the material in MPa.
+        As (float): The cross-section area of reinforcement in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        asw (float): Area of shear reinforcement in mm^2.
+        sw (float): Senter distance between the shear reinforcement in mm.
         f_ywk (float): The characteristic yield strength of the shear
-        reinforcement
-        theta (float): Inclitantion of the compression stressfield in degrees
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
-        gamma_s (float): Steel safety factor
+            reinforcement.
+        theta (float): Inclitantion of the compression stressfield in degrees.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
+        gamma_s (float): Steel safety factor.
 
     Returns:
-        float: Design shear resistance
+        float: Design shear resistance.
     """
     if not with_shear_reinforcment:
         if approx_lvl not in (1, 2):
             warnings.warn(
-                'Choosen approximation is not suited without reinforcment'
+                'Chosen approximation is not suited without reinforcment'
             )
 
         return v_rdc(
@@ -215,35 +214,28 @@ def v_rdc(
     dg: float,
     E_s: float,
     As: float,
-    loads: dict,
+    loads: t.Dict,
     alpha: float = 90.0,
     gamma_c: float = 1.5,
 ) -> float:
     """Calculate shear resistance of a web / slab without shear reinforcement.
 
-    fib Model Code 2010, Eq. (7.3-17)
+    fib Model Code 2010, Eq. (7.3-17).
 
     Args:
-        approx_lvl (int): Approximation level for concrete
-        fck (float): Characteristic strength in MPa
-        z (float): The length to the areasenter of cross-section in mm
-        bw (float): Thickness of web in cross section in mm
-        dg (float): Maximum size of aggregate
-        E_s (float): The E_s-modulus to the materialb in MPa
-        As (float): The cross-section area in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        approx_lvl (int): Approximation level for concrete.
+        fck (float): Characteristic strength in MPa.
+        z (float): The length to the areasenter of cross-section in mm.
+        bw (float): Thickness of web in cross section in mm.
+        dg (float): Maximum size of aggregate.
+        E_s (float): The E_s-modulus to the materialb in MPa.
+        As (float): The cross-section area in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-        float: The design shear resistance attributed to the concrete
+        float: The design shear resistance attributed to the concrete.
     """
     if approx_lvl == 1:
         return v_rdc_approx1(fck, z, bw, gamma_c)
@@ -275,19 +267,19 @@ def v_rdc_approx1(
 ) -> float:
     """Calculate shear resistance for concrete with approx level 1.
 
-    For members with no segnificant axal load, with fyk <= 600 Mpa,
-    fck <= 70 Mpa and with maximum aggrigate size of no less then 10mm.
+    For members with no segnificant axal load, with fyk <= 600 Mpa, fck <= 70
+    Mpa and with maximum aggrigate size of no less then 10mm.
 
-    fib Model Code 2010, Eq. (7.3-17) and (7.3-19)
+    fib Model Code 2010, Eq. (7.3-17) and (7.3-19).
 
     Args:
         fck (float): The characteristic compressive strength in MPa.
-        z (float): The length to the areasenter of cross-section in mm
-        bw (float): Thickness of web in cross section
-        gamma_c (float): Safety factor for concrete
+        z (float): The length to the areasenter of cross-section in mm.
+        bw (float): Thickness of web in cross section.
+        gamma_c (float): Safety factor for concrete.
 
     Returns:
-        float: Design shear resistance without shear reinforcement
+        float: Design shear resistance without shear reinforcement.
     """
     fsqr = min(fck**0.5, 8)
     kv = 180 / (1000 + 1.25 * z)
@@ -302,36 +294,29 @@ def v_rdc_approx2(
     dg: float,
     E_s: float,
     As: float,
-    loads: dict,
+    loads: t.Dict,
     gamma_c: float = 1.5,
 ) -> float:
     """Calculate shear resistance for concrete with approx level 2.
 
-    In higher strength concrete and light-weight aggregate concretes,
-    the fracture surface may go through the aggregate particles,
-    rather then around, reducing the crack roughness
+    In higher strength concrete and light-weight aggregate concretes, the
+    fracture surface may go through the aggregate particles, rather then
+    around, reducing the crack roughness.
 
-    fib Model Code 2010, Eq. (7.3-17), (7.3-20) and (7.3-21)
+    fib Model Code 2010, Eq. (7.3-17), (7.3-20) and (7.3-21).
 
     Args:
-        fck (float): Characteristic strength in MPa
-        z (float): The length to the areasenter of cross-section in mm
-        bw (float): Thickness of web in cross section
-        dg (float): Maximum size of aggregate
-        E_s (float): The E_s-modulus to the materialb in MPa
-        As (float): The cross-section area in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        gamma_c (float): Concrete safety factor
+        fck (float): Characteristic strength in MPa.
+        z (float): The length to the areasenter of cross-section in mm.
+        bw (float): Thickness of web in cross section.
+        dg (float): Maximum size of aggregate.
+        E_s (float): The E_s-modulus to the materialb in MPa.
+        As (float): The cross-section area in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-        float: Design shear resistance without shear reinforcement
+        float: Design shear resistance without shear reinforcement.
     """
     if fck > 70:
         dg = 0
@@ -350,37 +335,29 @@ def v_rdc_approx3(
     bw: float,
     E_s: float,
     As: float,
-    loads: dict,
+    loads: t.Dict,
     alpha: float = 90.0,
     gamma_c: float = 1.5,
 ) -> float:
     """Calculate shear resistance for concrete with approx level 3.
 
-    The design shear resistance of a web or a slab without
-    shear reinforcement.
+    The design shear resistance of a web or a slab without shear reinforcement.
 
-    fib Model Code 2010, Eq. (7.3-17), (7.3-39) and (7.3-43)
+    fib Model Code 2010, Eq. (7.3-17), (7.3-39) and (7.3-43).
 
     Args:
-        fck (float): Characteristic strength in MPa
-        z: (float): The length to the areasenter of cross-section in mm
-        bw: (float): Thickness of web in cross section
-        E_s: (float): The E_s-modulus to the materialb in MPa
-        As: (float): The cross-section area in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        fck (float): Characteristic strength in MPa.
+        z: (float): The length to the areasenter of cross-section in mm.
+        bw: (float): Thickness of web in cross section.
+        E_s: (float): The E_s-modulus to the materialb in MPa.
+        As: (float): The cross-section area in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
 
     Returns:
-        float: Design shear resistance without shear reinforcement
+        float: Design shear resistance without shear reinforcement.
     """
     fsqr = min(fck**0.5, 8)
     epsilonx = epsilon_x(E_s, As, z, loads)
@@ -419,18 +396,18 @@ def v_rds(
     fib Model Code 2010, Eq. (7.3-25) and (7.3-29)
 
     Args:
-        asw (float): Area of shear reinforcement in mm
-        sw (float): Senter distance between the shear reinforcement in mm
-        z (float): The length to the areasenter of cross-section in mm
+        asw (float): Area of shear reinforcement in mm.
+        sw (float): Senter distance between the shear reinforcement in mm.
+        z (float): The length to the areasenter of cross-section in mm.
         f_ywk (float): The characteristic yield strength of the shear
-        reinforcement
-        theta (float): Inclitaniton of the compression stressfield in degrees
-        alpha (float): Inclination of the stirrups
-        gamma_s (float): Steel safety factor
+            reinforcement.
+        theta (float): Inclitaniton of the compression stressfield in degrees.
+        alpha (float): Inclination of the stirrups.
+        gamma_s (float): Steel safety factor.
 
 
     Returns:
-        The design shear resistance provided by shear reinforcement
+        float: The design shear resistance provided by shear reinforcement.
     """
     if theta > 45 or theta < 20:
         warnings.warn('Too high or too low compression field angel')
@@ -450,38 +427,31 @@ def v_rd_max(
     bw: float,
     theta: float,
     z: float,
-    E_s: Optional[float],
-    As: Optional[float],
-    loads: Optional[dict],
+    E_s: t.Optional[float] = None,
+    As: t.Optional[float] = None,
+    loads: t.Optional[t.Dict] = None,
     alpha: float = 90,
     gamma_c: float = 1.5,
 ) -> float:
     """The maximum allowed shear resistance, when there is shear reinforcement.
 
-    fib Model Code 2010, eq. (7.3-24) and (7.3-26)
+    fib Model Code 2010, eq. (7.3-24) and (7.3-26).
 
     Args:
-        approx_lvl (int): Approximation level for steel
-        fck (float): Characteristic strength in MPa
-        bw (float): Thickness of web in cross section
-        theta (float): Inclitaniton of the compression stressfield in degrees
-        z (float): The length to the areasenter of cross-section in mm
-        E_s (float): The E_s-modulus to the materialb in MPa
-        As (float): The cross-section area in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        approx_lvl (int): Approximation level for steel.
+        fck (float): Characteristic strength in MPa.
+        bw (float): Thickness of web in cross section.
+        theta (float): Inclitaniton of the compression stressfield in degrees.
+        z (float): The length to the areasenter of cross-section in mm.
+        E_s (float): The E_s-modulus to the materialb in MPa.
+        As (float): The cross-section area in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-        float: The maximum allowed shear resistance regardless of
-    approximation level
+        float: The maximum allowed shear resistance regardless of approximation
+        level.
     """
     if approx_lvl == 1:
         return v_rd_max_approx1(fck, bw, theta, z, alpha, gamma_c)
@@ -507,18 +477,18 @@ def v_rd_max_approx1(
 ) -> float:
     """The maximum allowed shear resistance, with level 1 approximation.
 
-    fib Model Code 2010, eq. (7.3-37)
+    fib Model Code 2010, eq. (7.3-37).
 
     Args:
-        fck (float): Characteristic strength in MPa
-        bw (float): Thickness of web in cross section
-        theta (float): Inclitaniton of the compression stressfield in degrees
-        z: (float): The length to the areasenter of cross-section in mm
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        fck (float): Characteristic strength in MPa.
+        bw (float): Thickness of web in cross section.
+        theta (float): Inclitaniton of the compression stressfield in degrees.
+        z: (float): The length to the areasenter of cross-section in mm.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-    float: Maximum allowed shear resistance for approximation level 1
+        float: Maximum allowed shear resistance for approximation level 1.
     """
     return (
         0.55
@@ -540,34 +510,27 @@ def v_rd_max_approx2(
     z: float,
     E_s: float,
     As: float,
-    loads: dict,
+    loads: t.Dict,
     alpha: float = 90.0,
     gamma_c: float = 1.5,
 ) -> float:
     """The maximum allowed shear resistance, with level 2 approximation.
 
-    fib Model Code 2010, eq. (7.3-24), (7.3-40) and (7.3-41)
+    fib Model Code 2010, eq. (7.3-24), (7.3-40) and (7.3-41).
 
     Args:
-        fck (float): Characteristic strength in MPa
-        bw (float): Thickness of web in cross section
-        theta (float): Inclitaniton of the compression stressfield in degrees
-        z (float): The length to the areasenter of cross-section in mm
-        E_s (float): The E_s-modulus to the materialb in MPa
-        As (float): The cross-section area of reinforcement in mm^2
-        loads (dictionary): The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        fck (float): Characteristic strength in MPa.
+        bw (float): Thickness of web in cross section.
+        theta (float): Inclitaniton of the compression stressfield in degrees.
+        z (float): The length to the areasenter of cross-section in mm.
+        E_s (float): The E_s-modulus to the materialb in MPa.
+        As (float): The cross-section area of reinforcement in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-    float: Maximum allowed shear resistance for approximation level 2
+        float: Maximum allowed shear resistance for approximation level 2.
     """
     epsilonx = epsilon_x(E_s, As, z, loads)
     epsilon_1 = epsilonx + (epsilonx + 0.002) * (
@@ -594,33 +557,26 @@ def v_rd_max_approx3(
     z: float,
     E_s: float,
     As: float,
-    loads: dict,
+    loads: t.Dict,
     alpha: float = 90.0,
     gamma_c: float = 1.5,
 ) -> float:
     """The maximum allowed shear resistance, with level 3 approximation.
 
-    fib Model Code 2010, eq. (7.3-24), (7.3-40) and (7.3-41)
+    fib Model Code 2010, eq. (7.3-24), (7.3-40) and (7.3-41).
 
     Args:
-        fck (float): Characteristic strength in MPa
-        bw (float): Thickness of web in cross section
-        z (float): The length to the areasenter of cross-section in mm
-        E_s (float): The E_s-modulus to the materialb in MPa
-        As (float): The cross-section area of reinforcement in mm^2
-        loads (dictionary): The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Concrete safety factor
+        fck (float): Characteristic strength in MPa.
+        bw (float): Thickness of web in cross section.
+        z (float): The length to the areasenter of cross-section in mm.
+        E_s (float): The E_s-modulus to the materialb in MPa.
+        As (float): The cross-section area of reinforcement in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
 
     Returns:
-    float: Maximum allowed shear resistance for approximation level 3
+        float: Maximum allowed shear resistance for approximation level 3.
     """
     epsilonx = epsilon_x(E_s, As, z, loads)
     theta_min = 20 + 10000 * epsilonx
@@ -651,33 +607,34 @@ def v_rd_ct(
 ) -> float:
     """The shear resistance for a hollow core slab.
 
-    fib Model Code 2010, eq. (7.3-44) and (7.3-45)
+    fib Model Code 2010, eq. (7.3-44) and (7.3-45).
 
     Args:
-        approx_lvl_h (int): approximationlevel for hollow core
-        f_ctd (float): The design value of concrete axial tensile strength
-        i_c (float): Second moment of area in mm^4
-        s_c (float): First moment of area, above and about the
-        centriodal axis in mm^3
-        b_w (float): The width of the cross-section at the centroidal axis
-        sigma_cp (float): The compressive stress at centroidal axis
-        due to prestress
+        approx_lvl_h (int): approximationlevel for hollow core.
+        f_ctd (float): The design value of concrete axial tensile strength.
+        i_c (float): Second moment of area in mm^4.
+        s_c (float): First moment of area, above and about the centriodal axis
+            in mm^3.
+        b_w (float): The width of the cross-section at the centroidal axis.
+        sigma_cp (float): The compressive stress at centroidal axis due to
+            prestress.
         l_x (float): The distance between edge and point of
-        failure (Figure: 7.3-12) in mm
-        l_bd0 (float): follows 7.13-5 in mm
-        S_cy (float): The first moment of area above y in mm^3
-        b_wy (float): The width at hight y in mm
-        y (float): Hight at of the critical point at the line of failure in mm
-        y_c (float): The hight of the concrete centroidal axis in mm
-        A_c (float): The area of concrete cross-section in mm^2
-        A_cy (float): The area of concrete cross-section above y in mm^2
-        y_pt (float): The hight of centroidal axis of prestressed steel in mm
-        f_p_lx (float): The prestressing force at the distance l_x in N
-        f_p_lx_dx (float): The change of prestressing force at the distance l_x
+        failure (Figure: 7.3-12) in mm.
+        l_bd0 (float): follows 7.13-5 in mm.
+        S_cy (float): The first moment of area above y in mm^3.
+        b_wy (float): The width at hight y in mm.
+        y (float): Hight at of the critical point at the line of failure in mm.
+        y_c (float): The hight of the concrete centroidal axis in mm.
+        A_c (float): The area of concrete cross-section in mm^2.
+        A_cy (float): The area of concrete cross-section above y in mm^2.
+        y_pt (float): The hight of centroidal axis of prestressed steel in mm.
+        f_p_lx (float): The prestressing force at the distance l_x in N.
+        f_p_lx_dx (float): The change of prestressing force at the distance
+            l_x.
 
-    Return:
-        The maximum allowed shear force in a hollow core. Regardless of the
-    approximation level
+    Returns:
+        float: The maximum allowed shear force in a hollow core. Regardless of
+        the approximation level.
     """
     if approx_lvl_h == 1:
         return v_rd_ct_approx1(f_ctd, i_c, s_c, b_w, sigma_cp, l_x, l_bd0)
@@ -711,25 +668,25 @@ def v_rd_ct_approx1(
     l_x: float,
     l_bd0: float,
 ) -> float:
-    """Calculating level 1 approximation for shear
-    resistance in hollow core slabs.
+    """Calculating level 1 approximation for shear resistance in hollow core
+    slabs.
 
-    fib Model Code 2010, eq. (7.3-44)
+    fib Model Code 2010, eq. (7.3-44).
 
     Args:
-        f_ctd (float): The design value of concrete axial tensile strength
-        i_c (float): The second moment of area
-        s_c (float): The first moment of area, above and about the
-        centriodal axis in mm^3
-        b_w (float): The width of the cross-section at the centroidal axis
-        sigma_cp (float): The compressive stress at centroidal
-        axis due to prestress in Mpa
-        l_x (float): Distance from the edge to point of
-        failure (Figure: 7.3-12)
-        l_bd0 (float): follows 7.13-5
+        f_ctd (float): The design value of concrete axial tensile strength.
+        i_c (float): The second moment of area.
+        s_c (float): The first moment of area, above and about the centriodal
+            axis in mm^3.
+        b_w (float): The width of the cross-section at the centroidal axis.
+        sigma_cp (float): The compressive stress at centroidal axis due to
+            prestress in MPa.
+        l_x (float): Distance from the edge to point of failure (Figure:
+            7.3-12).
+        l_bd0 (float): follows 7.13-5.
 
     Return:
-    Vrd Appoximation 1 for hollow slabs
+        float: Vrd Appoximation 1 for hollow slabs.
     """
     alpha_l = l_x / (1.2 * l_bd0)
 
@@ -755,36 +712,31 @@ def v_rd_ct_approx2(
     f_p_lx: float,
     f_p_lx_dx: float,
 ) -> float:
-    """Calculates the maximum shear force for level 2 approximation
-       in hollow core slabs.
+    """Calculates the maximum shear force for level 2 approximationin hollow
+    core slabs.
 
     fib Model Code 2010, eq. (7.3-45), (7.3-46) and (7.3-47)
 
     Args:
-           f_ctd (float): Design value of concrete axial tensile strength in
-           MPa
-           i_c (float): The second moment of area in mm^4
-           l_x (float): Distance from the edge to point of
-           failure (Figure: 7.3-12)
-           l_bd0 (float): follows 7.13-5
-           S_cy (float): The first moment of area above y in mm^3
-           b_wy (float): The width at hight y in mm
-           y (float): The highh of the critical point at the line of failure
-           in mm
-           y_c (float): The hight of the concrete centroidal axis in mm
-           A_c (float): The area of concrete cross-section in mm^2
-           A_cy (float): The area of concrete cross-section above y in mm^2
-           y_pt (float): The hight of centroidal axis of prestressed steel in
-           mm
-           f_p_lx (float): The prestressing force at the distance l_x in N
-           f_p_lx (float): The derivative of prestressing force at the
-           distance l_x with respect to dx
-
-       sigma_cpy: The compressiv stress in the concrete at hight y and l_x
-       tau_cpy: The shear stress due to prestress at hight y and l_x
+        f_ctd (float): Design value of concrete axial tensile strength in MPa.
+        i_c (float): The second moment of area in mm^4.
+        l_x (float): Distance from the edge to point of failure (Figure:
+            7.3-12).
+        l_bd0 (float): follows 7.13-5.
+        S_cy (float): The first moment of area above y in mm^3.
+        b_wy (float): The width at hight y in mm.
+        y (float): The highh of the critical point at the line of failure in
+            mm.
+        y_c (float): The hight of the concrete centroidal axis in mm.
+        A_c (float): The area of concrete cross-section in mm^2.
+        A_cy (float): The area of concrete cross-section above y in mm^2.
+        y_pt (float): The hight of centroidal axis of prestressed steel in mm.
+        f_p_lx (float): The prestressing force at the distance l_x in N.
+        f_p_lx (float): The derivative of prestressing force at the distance
+            l_x with respect to dx.
 
-    Return:
-    The maximum shear force for level 2 approximation
+    Returns:
+        float: The maximum shear force for level 2 approximation.
     """
     alpha_l = l_x / (1.2 * l_bd0)
     sigma_cpy = ((1 / A_c) * ((y_c - y) / i_c)) * f_p_lx
diff --git a/structuralcodes/codes/mc2010/_concrete_torsion.py b/structuralcodes/codes/mc2010/_concrete_torsion.py
index 9b91bdf6..1ce83315 100644
--- a/structuralcodes/codes/mc2010/_concrete_torsion.py
+++ b/structuralcodes/codes/mc2010/_concrete_torsion.py
@@ -5,25 +5,18 @@
 from ._concrete_shear import epsilon_x, eta_fc, v_rd_max
 
 
-def create_load_dict(
-    Med: float, Ved: float, Ned: float, delta_e: float
-) -> dict:
-    """Returns dictionary assosiated with loads."""
-    return {'Med': Med, 'Ved': Ved, 'Ned': Ned, 'delta_e': delta_e}
-
-
 def v_ed_ti(t_ed: float, a_k: float, z_i: float):
     """Shear force due to torsion.
 
-    fib Model Code 2010, eq. (7.3-53)
+    fib Model Code 2010, eq. (7.3-53).
 
     Args:
-        t_ed: The acting torsion force in the cross section in Nmm
-        z_i: Can be found in figure 7.3-18
-        a_k: Can be found in figure 7.3-18
+        t_ed: The acting torsion force in the cross section in Nmm.
+        z_i: Can be found in figure 7.3-18.
+        a_k: Can be found in figure 7.3-18.
 
     Returns:
-    The shear force that will occur due to torsion force.
+        float: The shear force that will occur due to torsion moment.
     """
     return t_ed * z_i / (2 * a_k)
 
@@ -42,32 +35,25 @@ def t_rd_max(
 ) -> float:
     """The maximum allowed torsion.
 
-    fib Model Code 2010, eq. (7.3-56)
+    fib Model Code 2010, eq. (7.3-56).
 
     Args:
-        f_ck (float): Characteristic strength in MPa
-        gamma_c (float): Concrete safety factor
-        d_k (float): Is the diameter in the smallest circel in the
-        cross section
-        a_k: Can be found in figure 7.3-18
-        theta (float): inclination of the compression stressfield in degrees
-        approx_lvl (int): Approximation method for concrete with reinforcement
-        z (float): distances between the centerline of the
-        compressive chord and the reinforcement in mm
-        E_s (float): The E_modulus to the material in MPa
-        As (float): The cross-section reinforcement in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        gamma_c (float): Concrete safety factor
-
-    Return:
-        The maximum allowed torsion allowed
+        f_ck (float): Characteristic strength in MPa.
+        gamma_c (float): Concrete safety factor.
+        d_k (float): Is the diameter in the smallest circel in the cross
+            section.
+        a_k: Can be found in figure 7.3-18.
+        theta (float): inclination of the compression stressfield in degrees.
+        approx_lvl (int): Approximation method for concrete with reinforcement.
+        z (float): distances between the centerline of the compressive chord
+            and the reinforcement in mm.
+        E_s (float): The E_modulus to the material in MPa.
+        As (float): The cross-section reinforcement in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        gamma_c (float): Concrete safety factor.
+
+    Returns:
+        float: The maximum allowed torsion.
     """
     t_ef = d_k / 8
 
@@ -119,34 +105,27 @@ def t_rd(  # pylint: disable=r0801
 ) -> bool:
     """Checks if the combination of torsion and shear is ok.
 
-    fib Model Code 2010, eq. (7.3-56)
+    fib Model Code 2010, eq. (7.3-56).
 
     Args:
-        t_ed (float): The torsion working on the material in Nmm
-        approx_lvl (int): Approximation level chosen for shear resistance
-        fck (float): Characteristic strength in MPa
-        bw: (float): Thickness of web in cross section
-        theta (float): inclination of the compression stressfield in degrees
-        z: (float): The length to the areasenter of cross-section in mm
-        E_s: (float): The E_modulus to the material in MPa
-        As: (float): The cross-section area in mm^2
-        loads (dictionary) The given loads in a dictionary:
-            Med (float): The positive moment working on the material in Nmm
-            Ved (float): The positive shear force working on the material in N
-            Ned (float): The normal force working on the material in N with
-            positive sign for tension and negative sign for compression
-            delta_E (float): The eccentricity of the axial load due to
-            imperfection in the construction with distance in mm as a positive
-            value
-        d_k (float): Is the diameter in the smallest circel in the
-        cross section
-        a_k (float): Can be found in figure 7.3-18
-        alpha (float): Inclination of the stirrups in degrees
-        gamma_c (float): Safety factor
-
-    Return:
-        Returns a bool that is true if the criterion for torsion and
-    shear is fulfilled
+        t_ed (float): The torsion working on the material in Nmm.
+        approx_lvl (int): Approximation level chosen for shear resistance.
+        fck (float): Characteristic strength in MPa.
+        bw: (float): Thickness of web in cross section.
+        theta (float): inclination of the compression stressfield in degrees.
+        z: (float): The length to the areasenter of cross-section in mm.
+        E_s: (float): The E_modulus to the material in MPa.
+        As: (float): The cross-section area in mm^2.
+        loads (dict): The given loads in a dictionary. See create_load_dict.
+        d_k (float): Is the diameter in the smallest circel in the cross
+            section.
+        a_k (float): Can be found in figure 7.3-18.
+        alpha (float): Inclination of the stirrups in degrees.
+        gamma_c (float): Concrete safety factor.
+
+    Returns:
+        bool: Returns a bool that is true if the criterion for torsion and
+        shear is fulfilled.
     """
     return bool(
         (
diff --git a/structuralcodes/codes/mc2010/_reinforcement_material_properties.py b/structuralcodes/codes/mc2010/_reinforcement_material_properties.py
index 7eaf2d72..39f2640d 100644
--- a/structuralcodes/codes/mc2010/_reinforcement_material_properties.py
+++ b/structuralcodes/codes/mc2010/_reinforcement_material_properties.py
@@ -25,7 +25,7 @@
 def fyd(fyk: float, gamma_s: float = 1.15) -> float:
     """Calculate the design value of the reinforcement yield strength.
 
-    fib Model Code 2010, Sec. 4.5.2.2.3
+    fib Model Code 2010, Sec. 4.5.2.2.3.
 
     Args:
         fyk (float): The characteristic yield strength in MPa.
@@ -35,8 +35,8 @@ def fyd(fyk: float, gamma_s: float = 1.15) -> float:
         float: The design yield strength in MPa.
 
     Raises:
-        ValueError: if fyk is less than 0
-        ValueError: if gamma_s is less than 1
+        ValueError: If fyk is less than 0.
+        ValueError: If gamma_s is less than 1.
     """
     if fyk < 0:
         raise ValueError(f'fyk={fyk} cannot be less than 0')
@@ -48,18 +48,18 @@ def fyd(fyk: float, gamma_s: float = 1.15) -> float:
 def epsud(epsuk: float, gamma_eps: float = 0.9) -> float:
     """Calculate the design value of the reinforcement ultimate strain.
 
-    fib Model Code 2010, Sec. 7.2.3.2
+    fib Model Code 2010, Sec. 7.2.3.2.
 
     Args:
-        epsuk (float): The characteristic ultimate strain
+        epsuk (float): The characteristic ultimate strain.
         gamma_eps (float): The partial factor. Default value 0.9.
 
     Returns:
-        float: The design ultimate strain
+        float: The design ultimate strain.
 
     Raises:
-        ValueError: if epsuk is less than 0
-        ValueError: if gamma_eps is greater than 1
+        ValueError: If epsuk is less than 0.
+        ValueError: If gamma_eps is greater than 1.
     """
     if epsuk < 0:
         raise ValueError(f'epsuk={epsuk} cannot be less than 0')
@@ -77,7 +77,7 @@ def reinforcement_duct_props(
     """Return a dict with the minimum characteristic ductility properties for
     reinforcement ductility class.
 
-    fib Model Code 2010, Sec. 5.2.5.4
+    fib Model Code 2010, Sec. 5.2.5.4.
 
     Args:
         fyk (float): The characteristic yield strength.
@@ -90,8 +90,8 @@ def reinforcement_duct_props(
         (ftk).
 
     Raises:
-        ValueError: when the ductility_class does not define a valid ductility
-            class
+        ValueError: When the ductility_class does not define a valid ductility
+            class.
     """
     duct_props = DUCTILITY_CLASSES.get(ductility_class.upper(), None)
     if duct_props is None:
diff --git a/structuralcodes/core/_section_results.py b/structuralcodes/core/_section_results.py
index 83b6b5da..5669e8eb 100644
--- a/structuralcodes/core/_section_results.py
+++ b/structuralcodes/core/_section_results.py
@@ -1,6 +1,7 @@
 """Results."""
 
-# import typing as t
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 from dataclasses import dataclass, field, fields
 
 from numpy.typing import ArrayLike
@@ -105,7 +106,7 @@ def __format__(self, spec: str) -> str:
         """Defines the format for returning the string representation.
 
         Arguments:
-        spec: the string specifying the format
+            spec (str): The string specifying the format.
         """
         output_string = 'Gross Concrete Section Properties:\n'
         for f in fields(self):
@@ -119,8 +120,7 @@ def __format__(self, spec: str) -> str:
         return output_string
 
     def __str__(self) -> str:
-        """Returns the informal string representation.
-        Returns the informal string representation of the gross concrete
+        """Returns the informal string representation of the gross concrete
         section properties.
         """
         return f'{self}'
@@ -142,9 +142,9 @@ class CrackedProperties:
 
 @dataclass
 class MomentCurvatureResults:
-    """class for storing moment curvature results
-    the analysis will be done in general for a given inclination
-    of n.a.
+    """Class for storing moment curvature results.
+
+    The analysis will be done in general for a given inclination of n.a.
     """
 
     theta: float = 0  # the inclination of n.a.
@@ -161,8 +161,8 @@ class MomentCurvatureResults:
 
 @dataclass
 class UltimateBendingMomentResults:
-    """class for storing the ultimate bending moment computation
-    for a given inclination of n.a. and axial load.
+    """Class for storing the ultimate bending moment computation for a given
+    inclination of n.a. and axial load.
     """
 
     theta: float = 0  # the inclination of n.a.
diff --git a/structuralcodes/core/base.py b/structuralcodes/core/base.py
index bf2a4d2f..91ea0d4a 100644
--- a/structuralcodes/core/base.py
+++ b/structuralcodes/core/base.py
@@ -1,5 +1,7 @@
 """Abstract base classes."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import abc
 import typing as t
 import warnings
@@ -137,8 +139,7 @@ def find_x_lim(x, y):
             return None
 
         eps_max, eps_min = self.get_ultimate_strain()
-        if eps_max > 1:
-            eps_max = 1
+        eps_max = min(eps_max, 1)
         # Analise positive branch
         eps = np.linspace(0, eps_max, 10000)
         sig = self.get_stress(eps)
diff --git a/structuralcodes/geometry/_geometry.py b/structuralcodes/geometry/_geometry.py
index a02b750b..fbdb7971 100644
--- a/structuralcodes/geometry/_geometry.py
+++ b/structuralcodes/geometry/_geometry.py
@@ -1,6 +1,6 @@
 """Generic class section implemenetation."""
 
-from __future__ import annotations
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
 
 import typing as t
 import warnings
@@ -42,15 +42,14 @@ class Geometry:
     def __init__(
         self, name: t.Optional[str] = None, group_label: t.Optional[str] = None
     ) -> None:
-        """Initializes a geometry object
-        The name and grouplabel serve for filtering
-        in a compound object. By default it
-        creates a new name each time.
+        """Initializes a geometry object.
+
+        The name and grouplabel serve for filtering in a compound object. By
+        default it creates a new name each time.
 
         Arguments:
-            name (Optional: default None): the name to be given to the object
-            group_label (Optional: default None): a label for grouping several
-        objects
+            name (Optional(str)): The name to be given to the object.
+            group_label (Optional(str)): A label for grouping several objects.
         """
         if name is not None:
             self._name = name
@@ -95,9 +94,8 @@ def from_geometry(
 class PointGeometry(Geometry):
     """Class for a point geometry with material.
 
-    Basically it is a wrapper for shapely Point
-    including the material (and other parameters that
-    may be needed)
+    Basically it is a wrapper for shapely Point including the material (and
+    other parameters that may be needed).
     """
 
     def __init__(
@@ -109,23 +107,24 @@ def __init__(
         name: t.Optional[str] = None,
         group_label: t.Optional[str] = None,
     ):
-        """Initializes a PointGeometry object
-        The name and grouplabel serve for filtering
-        in a compound object. By default it
-        creates a new name each time.
+        """Initializes a PointGeometry object.
+
+        The name and group_label serve for filtering in a compound object. By
+        default it creates a new name each time.
 
         Arguments:
-            point: a couple of coordinates or e shapely Point object
-            diameter: the diameter of the point
-            material: the material for the point (this can be a Material or
-                    a ConstitutiveLaw)
-            density (Optional: default None) when a ConstitutiveLaw is passed
-                    as material, the density can be providen by this argument.
-                    When the material is a Material object the density is taken
-                    from the material.
-            name (Optional: default None): the name to be given to the object
-            group_label (Optional: default None): a label for grouping several
-        objects
+            point (Union(Point, ArrayLike)): A couple of coordinates or a
+                shapely Point object.
+            diameter (float): The diameter of the point.
+            material (Union(Material, ConstitutiveLaw)): The material for the
+                point (this can be a Material or a ConstitutiveLaw).
+            density (Optional(float)): When a ConstitutiveLaw is passed as
+                material, the density can be providen by this argument. When
+                the material is a Material object the density is taken from the
+                material.
+            name (Optional(str)): The name to be given to the object.
+            group_label (Optional(str)): A label for grouping several objects
+                (default is None).
         """
         super().__init__(name, group_label)
         # I check if point is a shapely Point or an ArrayLike object
@@ -204,9 +203,12 @@ def _repr_svg_(self) -> str:
     def translate(self, dx: float = 0.0, dy: float = 0.0) -> PointGeometry:
         """Returns a new PointGeometry that is translated by dx, dy.
 
-        Args:
-            dx: Translation ammount in x direction
-            dy: Translation ammount in y direction
+        Arguments:
+            dx (float): Translation in x direction.
+            dy (float): Translation in y direction.
+
+        Returns:
+            PointGeometry: A new, translated point.
         """
         return PointGeometry(
             point=affinity.translate(self._point, dx, dy),
@@ -220,13 +222,18 @@ def translate(self, dx: float = 0.0, dy: float = 0.0) -> PointGeometry:
     def rotate(
         self,
         angle: float = 0.0,
-        point: tuple[float, float] = (0.0, 0.0),
+        point: t.Union[t.Tuple[float, float], Point] = (0.0, 0.0),
         use_radians: bool = True,
     ) -> PointGeometry:
         """Returns a new PointGeometry that is rotated by angle.
 
-        Args:
-            angle: Angle in radians
+        Arguments:
+            angle (float): Rotation angle in radians (if use_radians = True),
+                or degress (if use_radians = False).
+            point (Union(Point, Tuple(float, float))): The origin of the
+                rotation.
+            use_radians (bool): True if angle is in radians, and False if angle
+                is in degrees.
         """
         return PointGeometry(
             point=affinity.rotate(
@@ -247,15 +254,18 @@ def from_geometry(
         """Create a new PointGeometry with a different material.
 
         Arguments:
-        geo: (PointGeometry) the geometry
-        new_material: (Optional: dault None) a new material to
-            be applied to the geometry. If new_material is None
-            an Elastic material with same stiffness of the original
-            material is created.
+            geo (PointGeometry): The geometry.
+            new_material (Optional(Union(Material, ConstitutiveLaw))): A new
+                material to be applied to the geometry. If new_material is
+                None an Elastic material with same stiffness as the original
+                material is created.
+
+        Returns:
+            PointGeometry: The new PointGeometry.
 
         Note:
-        The polygon is not copied, but just referenced in the
-        returned PointGeometry object.
+            The polygon is not copied, but just referenced in the returned
+            PointGeometry object.
         """
         if not isinstance(geo, PointGeometry):
             raise TypeError('geo should be a PointGeometry')
@@ -289,8 +299,16 @@ def create_line_point_angle(
     theta: float,
     bbox: t.Tuple[float, float, float, float],
 ) -> LineString:
-    """Creates a line from point and angle within the bounding
-    box.
+    """Creates a line from point and angle within the bounding box.
+
+    Arguments:
+        point (Union(Point, Tuple(float, float))): A Point or a coordinate the
+            line should pass through.
+        theta (float): The angle of the line in radians.
+        bbox (Tuple(float, float, float, float)): Bounds for the created line.
+
+    Returns:
+        LineString: The created line.
     """
     # create a unit vector defining the line
     v = (np.cos(theta), np.sin(theta))
@@ -318,9 +336,9 @@ def create_line_point_angle(
 class SurfaceGeometry:
     """Class for a surface geometry with material.
 
-    Basically it is a wrapper for shapely polygon
-    including the material (and other parameters needed)
-    As a shapely polygon it can contain one or more holes
+    Basically it is a wrapper for shapely polygon including the material (and
+    other parameters needed). As a shapely polygon it can contain one or more
+    holes.
     """
 
     def __init__(
@@ -332,14 +350,14 @@ def __init__(
     ) -> None:
         """Initializes a SurfaceGeometry object.
 
-        Args:
-            poly (shapely.Polygon): Shapely polygon
-            mat (Material or ConstitutiveLaw): A Material or ConsitutiveLaw
-                class applied to the geometry
-            density (Optional: default None) when a ConstitutiveLaw is passed
-                    as mat, the density can be providen by this argument.
-                    When mat is a Material object the density is taken
-                    from the material.
+        Arguments:
+            poly (shapely.Polygon): A Shapely polygon.
+            mat (Union(Material, ConstitutiveLaw)): A Material or
+                ConsitutiveLaw class applied to the geometry.
+            density (Optional(float)): When a ConstitutiveLaw is passed as mat,
+                the density can be provided by this argument. When mat is a
+                Material object the density is taken from the material.
+            concrete (bool): Flag to indicate if the geometry is concrete.
         """
         # Check if inputs are of the correct type, otherwise return error
         if not isinstance(poly, Polygon):
@@ -372,7 +390,7 @@ def area(self) -> float:
         """Returns the area of the geometry.
 
         Returns:
-        float: area of the geometry
+            float: The area of the geometry.
         """
         return self.polygon.area
 
@@ -381,7 +399,7 @@ def centroid(self) -> t.Tuple[float, float]:
         """Returns the centroid of the geometry.
 
         Returns:
-        (float, float): x and y coordinates of centroid
+            Tuple(float, float): x and y coordinates of the centroid.
         """
         return self.polygon.centroid.coords[0]
 
@@ -390,14 +408,14 @@ def density(self) -> float:
         """Returns the density."""
         return self._density
 
-    def calculate_extents(self) -> tuple[float, float, float, float]:
+    def calculate_extents(self) -> t.Tuple[float, float, float, float]:
         """Calculate extents of SurfaceGeometry.
 
         Calculates the minimum and maximum x and y values.
 
         Returns:
-            Minimum and maximum x and y values (``x_min``, ``x_max``,
-            ``y_min``, ``y_max``)
+            Tuple(float, float, float, float): Minimum and maximum x and y
+            values (``x_min``, ``x_max``, ``y_min``, ``y_max``).
         """
         min_x, min_y, max_x, max_y = self.polygon.bounds
         return min_x, max_x, min_y, max_y
@@ -407,13 +425,15 @@ def split(
     ) -> t.Tuple[t.List[SurfaceGeometry], t.List[SurfaceGeometry]]:
         """Splits the geometry using a line.
 
-        Args:
-            line: can be a LineString shapely object, or a tuple
-                  (point, theta) where point is a tuple (x,y) and
-                  theta is the angle respect the horizontal axis
+        Arguments:
+            line (Union(LineString, Tuple(Tuple(float, float), float))): A line
+                either represented by a LineString shapely object, or a tuple
+                (point, theta) where point is a coordinate pair and theta is
+                the angle respect the horizontal axis in radians.
 
         Returns:
-            (above_polygons, below_polygons)
+            Tuple(List(SurfaceGeometry), List(SurfaceGeometry)): The
+            SurfaceGeometries above and below the line.
         """
         if not isinstance(line, LineString):
             point = line[0]
@@ -451,8 +471,18 @@ def split(
 
     def split_two_lines(
         self, lines: t.Union[t.Tuple[LineString, LineString], MultiLineString]
-    ) -> Polygon:
-        """Docstrings."""
+    ) -> t.Union[Polygon, MultiPolygon]:
+        """Splits the geometry using two lines.
+
+        Arguments:
+            lines (Union(Tuple(LineString, Linestring)), MultiLineString): Two
+                lines either represented by a tuple of two LineString shapely
+                objects, or a MultiLineString shapely object.
+
+        Returns:
+            Union(Polygon, Multipolygon): The polygon or multipolygon obtained
+            by splitting the SurfaceGeometry with the two lines.
+        """
         if isinstance(lines, MultiLineString):
             multi_line = lines
         elif isinstance(lines, tuple):
@@ -467,22 +497,22 @@ def split_two_lines(
     def __add__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "+" for geometries.
 
-        Args:
-            other: the other geometry to add
+        Arguments:
+            other (Geometry): The other geometry to add.
 
         Returns:
-        the Compound Geometry
+            CompoundGeometry: A new CompoundGeometry.
         """
         return CompoundGeometry([self, other])
 
     def __sub__(self, other: Geometry) -> SurfaceGeometry:
         """Add operator "-" for geometries.
 
-        Args:
-            other: the other geometry to be subtracted from a
+        Arguments:
+            other (Geometry): The other geometry to be subtracted.
 
         Returns:
-            the resulting SurfaceGeometry
+            SurfaceGeometry: The resulting SurfaceGeometry.
         """
         material = self.material
         density = self._density
@@ -507,9 +537,12 @@ def _repr_svg_(self) -> str:
     def translate(self, dx: float = 0.0, dy: float = 0.0) -> SurfaceGeometry:
         """Returns a new SurfaceGeometry that is translated by dx, dy.
 
-        Args:
-            dx: Translation ammount in x direction
-            dy: Translation ammount in y direction
+        Arguments:
+            dx (float): Translation in x direction.
+            dy (float): Translation in y direction.
+
+        Returns:
+            SurfaceGeometry: The translated SurfaceGeometry.
         """
         return SurfaceGeometry(
             poly=affinity.translate(self.polygon, dx, dy),
@@ -520,13 +553,21 @@ def translate(self, dx: float = 0.0, dy: float = 0.0) -> SurfaceGeometry:
     def rotate(
         self,
         angle: float = 0.0,
-        point: tuple[float, float] = (0.0, 0.0),
+        point: t.Tuple[float, float] = (0.0, 0.0),
         use_radians: bool = True,
     ) -> SurfaceGeometry:
         """Returns a new SurfaceGeometry that is rotated by angle.
 
-        Args:
-            angle: Angle in radians
+        Arguments:
+            angle (float): Rotation angle in radians (if use_radians = True),
+                or degress (if use_radians = False).
+            point (Union(Point, Tuple(float, float))): The origin of the
+                rotation.
+            use_radians (bool): True if angle is in radians, and False if angle
+                is in degrees.
+
+        Returns:
+            SurfaceGeometry: The rotated SurfaceGeometry.
         """
         return SurfaceGeometry(
             poly=affinity.rotate(
@@ -544,15 +585,18 @@ def from_geometry(
         """Create a new SurfaceGeometry with a different material.
 
         Arguments:
-        geo: (SurfaceGeometry) the geometry
-        new_material: (Optional: dault None) a new material to
-            be applied to the geometry. If new_material is None
-            an Elastic material with same stiffness of the original
-            material is created.
+            geo (SurfaceGeometry): The geometry.
+            new_material: (Optional(Union(Material, ConstitutiveLaw))): A new
+                material to be applied to the geometry. If new_material is None
+                an Elastic material with same stiffness of the original
+                material is created.
+
+        Returns:
+            SurfaceGeometry: The new SurfaceGeometry.
 
         Note:
-        The polygon is not copied, but just referenced in the
-        returned SurfaceGeometry object.
+            The polygon is not copied, but just referenced in the returned
+            SurfaceGeometry object.
         """
         if not isinstance(geo, SurfaceGeometry):
             raise TypeError('geo should be a SurfaceGeometry')
@@ -632,8 +676,8 @@ def _process_geometries_list(
 class CompoundGeometry(Geometry):
     """Class for a compound geometry.
 
-    it is basicaly a set of geometries, each one with its
-    own materials and properties.
+    It is basicaly a set of geometries, each one with its own materials and
+    properties.
     """
 
     def __init__(
@@ -644,13 +688,12 @@ def __init__(
         """Creates a compound geometry.
 
         Arguments:
-        geometries: a list of SurfaceGeometry objects or a shapely
-            MultiPolygon object (in this case also a list of
-            materials should be given)
-        materials (optional, default = None): a material (applied
-            to all polygons) or a list of materials. In this
-            case the number of polygons should match the number
-            of materials
+            geometries (Union(List(Geometry), MultiPolygon)): A list of
+                SurfaceGeometry objects or a shapely MultiPolygon object
+                (in this case also a list of materials should be given).
+            materials (Optional(List(Material), Material)): A material (applied
+                to all polygons) or a list of materials. In this case the
+                number of polygons should match the number of materials.
         """
         if isinstance(geometries, MultiPolygon):
             # a MultiPolygon is provided
@@ -697,21 +740,23 @@ def reinforced_concrete(self) -> bool:
 
     @property
     def area(self) -> float:
-        """Return the area of the compund geometry."""
+        """Return the area of the compound geometry."""
         area = 0
         for geo in self.geometries:
             area += geo.area
         return area
 
-    def calculate_extents(self) -> tuple[float, float, float, float]:
+    def calculate_extents(self) -> t.Tuple[float, float, float, float]:
         """Calculate extents of CompundGeometry.
 
         Calculates the minimum and maximum x and y-values.
-        Consideres only SurfaceGeometries and not points!
 
         Returns:
-            Minimum and maximum x and y values (``x_min``, ``x_max``,
-            ``y_min``, ``y_max``)
+            Tuple(float, float, float, float): Minimum and maximum x and y
+            values (``x_min``, ``x_max``, ``y_min``, ``y_max``).
+
+        Note:
+            Considers only SurfaceGeometries and not PointGeometries!
         """
         min_x = 1e16
         max_x = -1e16
@@ -728,9 +773,12 @@ def calculate_extents(self) -> tuple[float, float, float, float]:
     def translate(self, dx: float = 0.0, dy: float = 0.0) -> CompoundGeometry:
         """Returns a new CompountGeometry that is translated by dx, dy.
 
-        Args:
-            dx: Translation ammount in x direction
-            dy: Translation ammount in y direction
+        Arguments:
+            dx (float): Translation in x direction.
+            dy (float): Translation in y direction.
+
+        Returns:
+            CompoundGeometry: The translated CompoundGeometry.
         """
         processed_geoms = []
         for g in self.geometries:
@@ -742,13 +790,21 @@ def translate(self, dx: float = 0.0, dy: float = 0.0) -> CompoundGeometry:
     def rotate(
         self,
         angle: float = 0.0,
-        point: tuple[float, float] = (0.0, 0.0),
+        point: t.Tuple[float, float] = (0.0, 0.0),
         use_radians: bool = True,
     ) -> CompoundGeometry:
-        """Returns a new CompountGeometry that is rotate by angle.
+        """Returns a new CompoundGeometry that is rotated by angle.
 
-        Args:
-            angle: Angle in radians
+        Arguments:
+            angle (float): Rotation angle in radians (if use_radians = True),
+                or degress (if use_radians = False).
+            point (Union(Point, Tuple(float, float))): The origin of the
+                rotation.
+            use_radians (bool): True if angle is in radians, and False if angle
+                is in degrees.
+
+        Returns:
+            CompoundGeometry: The rotated CompoundGeometry.
         """
         processed_geoms = []
         for g in self.geometries:
@@ -760,22 +816,22 @@ def rotate(
     def __add__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "+" for geometries.
 
-        Args:
-            other: the other geometry to add
+        Arguments:
+            other (Geometry): The other geometry to add.
 
         Returns:
-        the Compound Geometry
+            CompoundGeometry: A new CompoundGeometry.
         """
         return CompoundGeometry([self, other])
 
     def __sub__(self, other: Geometry) -> CompoundGeometry:
         """Add operator "-" for geometries.
 
-        Args:
-            other: the other geometry to be subtracted from a
+        Arguments:
+            other (Geometry): The other geometry to be subtracted.
 
         Returns:
-        the Compound Geometry
+            CompoundGeometry: A new CompoundGeometry.
         """
         # if we subtract a point from a surface we obtain the same surface
         if isinstance(other, PointGeometry):
@@ -796,11 +852,14 @@ def from_geometry(
         """Create a new CompoundGeometry with a different material.
 
         Arguments:
-        geo: (CompoundGeometry) the geometry
-        new_material: (Optional: dault None) a new material to
-            be applied to the geometry. If new_material is None
-            an Elastic material with same stiffness of the original
-            material is created.
+            geo (CompoundGeometry): The geometry.
+            new_material (Optional(Union(Material, ConstitutiveLaw))): A new
+                material to be applied to the geometry. If new_material is None
+                an Elastic material with same stiffness of the original
+                material is created.
+
+        Returns:
+            CompoundGeometry: The new CompoundGeometry.
         """
         if not isinstance(geo, CompoundGeometry):
             raise TypeError('geo should be a CompoundGeometry')
diff --git a/structuralcodes/geometry/_steel_sections.py b/structuralcodes/geometry/_steel_sections.py
index b13f2373..cb848179 100644
--- a/structuralcodes/geometry/_steel_sections.py
+++ b/structuralcodes/geometry/_steel_sections.py
@@ -20,13 +20,13 @@
 
 
 class BaseProfile:
-    """Base class representing a profille.
+    """Base class representing a profile.
 
-    Contains the common code for all sections
+    Contains the common code for all sections.
     """
 
     def __init__(self):
-        """Creates an empy base profile."""
+        """Creates an empty base profile."""
         self._polygon: Polygon = None
         self._A: float = None
         self._Iy: float = None
@@ -44,8 +44,8 @@ def __init__(self):
     def _check_polygon_defined(self):
         """Just checks if polygon attribute is defined.
 
-        If the polygon is not defined (it should never happen),
-        an exception is Raised.
+        If the polygon is not defined (it should never happen), an exception
+        is Raised.
         """
         # The polygon attribute should be already defined
         if self._polygon is None:
@@ -91,8 +91,8 @@ def _find_plastic_neutral_axis_y(self) -> float:
     def _find_delta_area_above_minus_below(self, z: float) -> float:
         """Returns area difference between above and below parts.
 
-        Above and below parts are computed splitting the polygon
-        with a line parallel to Y axes at z coordinate.
+        Above and below parts are computed splitting the polygon with a line
+        parallel to Y axes at z coordinate.
         """
         bounds = self._polygon.bounds
         xmax = max(abs(bounds[0]), bounds[2])
@@ -187,8 +187,8 @@ def Iyz(self) -> float:
     def Icsi(self) -> float:
         """Returns second moment of area around principal csi axis.
 
-        It is assumed that Icsi is maximum second moment, while Ieta is
-        the minimum one.
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
         """
         if self._Icsi is None:
             self._find_principals_direction_and_moments()
@@ -198,8 +198,8 @@ def Icsi(self) -> float:
     def Ieta(self) -> float:
         """Returns second moment of area around principal eta axis.
 
-        It is assumed that Icsi is maximum second moment, while Ieta is
-        the minimum one.
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
         """
         if self._Ieta is None:
             self._find_principals_direction_and_moments()
@@ -209,11 +209,11 @@ def Ieta(self) -> float:
     def theta(self) -> float:
         """Returns angle between x and principal eta axis.
 
-        It is assumed that Icsi is maximum second moment, while Ieta is
-        the minimum one.
+        It is assumed that Icsi is maximum second moment, while Ieta is the
+        minimum one.
 
         Returns:
-            (float): the angle in radians
+            float: The angle in radians.
         """
         if self._theta is None:
             self._find_principals_direction_and_moments()
@@ -315,7 +315,7 @@ def iz(self) -> float:
 class IPE(BaseProfile):
     """Simple class for representing an IPE profile.
 
-    IPE 80-600 in accordance with standard Euronorm 19-57
+    IPE 80-600 in accordance with standard Euronorm 19-57.
     """
 
     parameters = {
@@ -382,52 +382,52 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the IPE section.
+            Polygon: The represention of the IPE section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of IPE section.
 
         Returns:
-            float: height h of IPE section.
+            float: Height h of IPE section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of IPE section.
 
         Returns:
-            float: width b of IPE section.
+            float: Width b of IPE section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of IPE section.
 
         Returns:
-            float: web thickness tw of IPE section.
+            float: Web thickness tw of IPE section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of IPE section.
 
         Returns:
-            float: flange thickness tw of IPE section.
+            float: Flange thickness tw of IPE section.
         """
         return self._tf
 
     @property
-    def r(self) -> Polygon:
+    def r(self) -> float:
         """Returns fillet radius of IPE section.
 
         Returns:
-            float: fillet radius r of IPE section.
+            float: Fillet radius r of IPE section.
         """
         return self._r
 
@@ -435,7 +435,7 @@ def r(self) -> Polygon:
 class HE(BaseProfile):
     """Simple class for representing an HE profile.
 
-    HE A, HE B, HE M 100-1000 in accordance with Standard Euronorm 53-62
+    HE A, HE B, HE M 100-1000 in accordance with Standard Euronorm 53-62.
     """
 
     parameters = {
@@ -564,52 +564,52 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the HE section.
+            Polygon: The represention of the HE section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of HE section.
 
         Returns:
-            float: height h of HE section.
+            float: Height h of HE section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of HE section.
 
         Returns:
-            float: width b of HE section.
+            float: Width b of HE section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of HE section.
 
         Returns:
-            float: web thickness tw of HE section.
+            float: Web thickness tw of HE section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of HE section.
 
         Returns:
-            float: flange thickness tw of HE section.
+            float: Flange thickness tw of HE section.
         """
         return self._tf
 
     @property
-    def r(self) -> Polygon:
+    def r(self) -> float:
         """Returns fillet radius of HE section.
 
         Returns:
-            float: fillet radius r of HE section.
+            float: Fillet radius r of HE section.
         """
         return self._r
 
@@ -617,7 +617,7 @@ def r(self) -> Polygon:
 class UB(BaseProfile):
     """Simple class for representing a UB profile.
 
-    Universal Beams
+    Universal Beams.
     """
 
     parameters = {
@@ -818,52 +818,52 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the UB section.
+            Polygon: The represention of the UB section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of UB section.
 
         Returns:
-            float: height h of UB section.
+            float: Height h of UB section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of UB section.
 
         Returns:
-            float: width b of UB section.
+            float: Width b of UB section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of UB section.
 
         Returns:
-            float: web thickness tw of UB section.
+            float: Web thickness tw of UB section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of UB section.
 
         Returns:
-            float: flange thickness tw of UB section.
+            float: Flange thickness tw of UB section.
         """
         return self._tf
 
     @property
-    def r(self) -> Polygon:
+    def r(self) -> float:
         """Returns fillet radius of UB section.
 
         Returns:
-            float: fillet radius r of UB section.
+            float: Fillet radius r of UB section.
         """
         return self._r
 
@@ -871,7 +871,7 @@ def r(self) -> Polygon:
 class UC(BaseProfile):
     """Simple class for representing a UC profile.
 
-    Universal Columns
+    Universal Columns.
     """
 
     parameters = {
@@ -1084,52 +1084,52 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the UC section.
+            Polygon: The represention of the UC section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of UC section.
 
         Returns:
-            float: height h of UC section.
+            float: Height h of UC section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of UC section.
 
         Returns:
-            float: width b of UC section.
+            float: Width b of UC section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of UC section.
 
         Returns:
-            float: web thickness tw of UC section.
+            float: Web thickness tw of UC section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of UC section.
 
         Returns:
-            float: flange thickness tw of UC section.
+            float: Flange thickness tw of UC section.
         """
         return self._tf
 
     @property
-    def r(self) -> Polygon:
+    def r(self) -> float:
         """Returns fillet radius of UC section.
 
         Returns:
-            float: fillet radius r of UC section.
+            float: Fillet radius r of UC section.
         """
         return self._r
 
@@ -1137,7 +1137,7 @@ def r(self) -> Polygon:
 class UBP(BaseProfile):
     """Simple class for representing a UBP profile.
 
-    Universal Bearing Pile
+    Universal Bearing Pile.
     """
 
     parameters = {
@@ -1301,52 +1301,52 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the UBP section.
+            Polygon: The represention of the UBP section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of UBP section.
 
         Returns:
-            float: height h of UBP section.
+            float: Height h of UBP section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of UBP section.
 
         Returns:
-            float: width b of UBP section.
+            float: Width b of UBP section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of UBP section.
 
         Returns:
-            float: web thickness tw of UBP section.
+            float: Web thickness tw of UBP section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of UBP section.
 
         Returns:
-            float: flange thickness tw of UBP section.
+            float: Flange thickness tw of UBP section.
         """
         return self._tf
 
     @property
-    def r(self) -> Polygon:
+    def r(self) -> float:
         """Returns fillet radius of UBP section.
 
         Returns:
-            float: fillet radius r of UBP section.
+            float: Fillet radius r of UBP section.
         """
         return self._r
 
@@ -1354,9 +1354,9 @@ def r(self) -> Polygon:
 class IPN(BaseProfile):
     """Simple class for representing an IPN profile.
 
-    IPN  in accordance with standard
+    IPN in accordance with standard.
 
-    14% slope in flange
+    14% slope in flange.
     """
 
     parameters = {
@@ -1611,61 +1611,61 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the IPN section.
+            Polygon: The represention of the IPN section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of IPN section.
 
         Returns:
-            float: height h of IPN section.
+            float: Height h of IPN section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of IPN section.
 
         Returns:
-            float: width b of IPN section.
+            float: Width b of IPN section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of IPN section.
 
         Returns:
-            float: web thickness tw of IPN section.
+            float: Web thickness tw of IPN section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of IPN section.
 
         Returns:
-            float: flange thickness tw of IPN section.
+            float: Flange thickness tw of IPN section.
         """
         return self._tf
 
     @property
-    def r1(self) -> Polygon:
+    def r1(self) -> float:
         """Returns fillet radius of IPN section.
 
         Returns:
-            float: fillet radius r1 of IPN section.
+            float: Fillet radius r1 of IPN section.
         """
         return self._r1
 
     @property
-    def r2(self) -> Polygon:
+    def r2(self) -> float:
         """Returns fillet radius of IPN section.
 
         Returns:
-            float: fillet radius r2 of IPN section.
+            float: Fillet radius r2 of IPN section.
         """
         return self._r2
 
@@ -1673,10 +1673,11 @@ def r2(self) -> Polygon:
 class UPN(BaseProfile):
     """Simple class for representing an UPN profile.
 
-    European standard channels UPN 50 - 400
-    Taper flange Channels
+    European standard channels UPN 50 - 400.
 
-    14% slope in flange
+    Taper flange Channels.
+
+    14% slope in flange.
     """
 
     parameters = {
@@ -1915,61 +1916,61 @@ def polygon(self) -> Polygon:
         """Returns shapely Polygon of section.
 
         Returns:
-            Polygon: the represention of the UPN section.
+            Polygon: The represention of the UPN section.
         """
         return self._polygon
 
     @property
-    def h(self) -> Polygon:
+    def h(self) -> float:
         """Returns height of UPN section.
 
         Returns:
-            float: height h of UPN section.
+            float: Height h of UPN section.
         """
         return self._h
 
     @property
-    def b(self) -> Polygon:
+    def b(self) -> float:
         """Returns width of UPN section.
 
         Returns:
-            float: width b of UPN section.
+            float: Width b of UPN section.
         """
         return self._b
 
     @property
-    def tw(self) -> Polygon:
+    def tw(self) -> float:
         """Returns thickness of web of UPN section.
 
         Returns:
-            float: web thickness tw of UPN section.
+            float: Web thickness tw of UPN section.
         """
         return self._tw
 
     @property
-    def tf(self) -> Polygon:
+    def tf(self) -> float:
         """Returns thickness of flange of UPN section.
 
         Returns:
-            float: flange thickness tw of UPN section.
+            float: Flange thickness tw of UPN section.
         """
         return self._tf
 
     @property
-    def r1(self) -> Polygon:
+    def r1(self) -> float:
         """Returns fillet radius of UPN section.
 
         Returns:
-            float: fillet radius r1 of UPN section.
+            float: Fillet radius r1 of UPN section.
         """
         return self._r1
 
     @property
-    def r2(self) -> Polygon:
+    def r2(self) -> float:
         """Returns fillet radius of UPN section.
 
         Returns:
-            float: fillet radius r2 of UPN section.
+            float: Fillet radius r2 of UPN section.
         """
         return self._r2
 
diff --git a/structuralcodes/materials/concrete/__init__.py b/structuralcodes/materials/concrete/__init__.py
index 2189d8cc..3bc053ef 100644
--- a/structuralcodes/materials/concrete/__init__.py
+++ b/structuralcodes/materials/concrete/__init__.py
@@ -36,23 +36,23 @@ def create_concrete(
     """A factory function to create the correct type of concrete based on the
     desired design code.
 
-    Args:
-        fck (float): Characteristic strength of concrete in MPa.
-            (if existing it is intended as the mean strength)
+    Arguments:
+        fck (float): Characteristic strength of concrete in MPa. (if existing
+            it is intended as the mean strength).
 
-    Keyword Args:
-        density (float): Density of Concrete in kg/m3 (default: 2400)
+    Keyword Arguments:
+        density (float): Density of Concrete in kg/m3 (default: 2400).
         gamma_c (Optional(float)): The partial factor for concrete.
-        existing (bool): Boolean indicating if the concrete is of an
-            existing structure (default: False)
+        existing (bool): Boolean indicating if the concrete is of an existing
+            structure (default: False).
         design_code (str): Optional string (default: None) indicating the
             desired standard. If None (default) the globally used design
             standard will be adopted. Otherwise the design standard specified
             will be used for the instance of the material.
 
     Raises:
-        ValueError: if the design code is not valid or does not cover
-            concrete as a material.
+        ValueError: if the design code is not valid or does not cover concrete
+            as a material.
     """
     # Get the code from the global variable
     _code = _use_design_code(design_code)
diff --git a/structuralcodes/materials/concrete/_concrete.py b/structuralcodes/materials/concrete/_concrete.py
index 18dda609..05af36d1 100644
--- a/structuralcodes/materials/concrete/_concrete.py
+++ b/structuralcodes/materials/concrete/_concrete.py
@@ -49,8 +49,8 @@ def fck(self, fck: float) -> None:
 
     @abc.abstractmethod
     def _reset_attributes(self):
-        """Each concrete should define its own _reset_attributes method
-        This is because fck setting, reset the object arguments.
+        """Each concrete should define its own _reset_attributes method. This
+        is because fck setting, reset the object arguments.
         """
 
     @property
@@ -70,12 +70,12 @@ def constitutive_law(
     ) -> None:
         """Setter for constitutive law.
 
-        Args:
-        consitutive_law (ConstitutiveLaw | str): a valid ConstitutiveLaw object
-                for concrete or  a string defining a valid constitutive law
-                type for concrete.
-                (valid options for string: 'elastic', 'parabolarectangle',
-                'bilinearcompression', 'sargin', 'popovics').
+        Arguments:
+            consitutive_law (ConstitutiveLaw | str): A valid ConstitutiveLaw
+                object for concrete or a string defining a valid constitutive
+                law type for concrete. (valid options for string: 'elastic',
+                'parabolarectangle', 'bilinearcompression', 'sargin',
+                'popovics').
         """
         if constitutive_law is None:
             raise ValueError(
diff --git a/structuralcodes/materials/concrete/_concreteEC2_2004.py b/structuralcodes/materials/concrete/_concreteEC2_2004.py
index b1726eb1..ff945a2f 100644
--- a/structuralcodes/materials/concrete/_concreteEC2_2004.py
+++ b/structuralcodes/materials/concrete/_concreteEC2_2004.py
@@ -38,15 +38,15 @@ def __init__(
     ) -> None:
         """Initializes a new instance of Concrete for EC2 2004.
 
-        Args:
+        Arguments:
             fck (float): Characteristic strength in MPa if concrete is not
                 existing.
 
-        Keyword Args:
-            name (str): A descriptive name for concrete
-            density (float): Density of material in kg/m3 (default: 2400)
-            gamma_c (float, optional): partial factor of concrete
-                (default is 1.5)
+        Keyword Arguments:
+            name (str): A descriptive name for concrete.
+            density (float): Density of material in kg/m3 (default: 2400).
+            gamma_c (float, optional): partial factor of concrete (default is
+                1.5).
             alpha_cc (float, optional): A factor for considering long-term
                 effects on the strength, and effects that arise from the way
                 the load is applied.
@@ -93,11 +93,11 @@ def fcm(self) -> float:
     def fcm(self, value: float):
         """Sets a user defined value for fcm.
 
-        Args:
-            value (float): the value of fcm in MPa
+        Arguments:
+            value (float): The value of fcm in MPa.
 
         Raises:
-            ValueError: if value is lower than fck
+            ValueError: If value is lower than fck.
         """
         if abs(value) <= self._fck:
             raise ValueError(
@@ -116,7 +116,7 @@ def fctm(self) -> float:
         """Returns fctm in MPa.
 
         Returns:
-            float: The mean tensile strength in MPa
+            float: The mean tensile strength in MPa.
         """
         if self._fctm is None:
             self._fctm = ec2_2004.fctm(self._fck)
@@ -126,8 +126,8 @@ def fctm(self) -> float:
     def fctm(self, value: float):
         """Sets a user defined value for fctm.
 
-        Args:
-            value (float): the value of fctm in MPa
+        Arguments:
+            value (float): The value of fctm in MPa.
         """
         if value > 0.5 * self._fck:
             warnings.warn(
@@ -140,7 +140,7 @@ def fctk_5(self) -> float:
         """Returns fctk_5 in MPa.
 
         Returns:
-            float: The lower bound tensile strength in MPa
+            float: The lower bound tensile strength in MPa.
         """
         if self._fctk_5 is not None:
             return self._fctk_5
@@ -150,8 +150,8 @@ def fctk_5(self) -> float:
     def fctk_5(self, value: float):
         """Sets a user defined value for fctk_5.
 
-        Args:
-            value (float): the value of fctk_5 in MPa
+        Arguments:
+            value (float): The value of fctk_5 in MPa.
         """
         self._fctk_5 = abs(value)
 
@@ -160,7 +160,7 @@ def fctk_95(self) -> float:
         """Returns fctk_95 in MPa.
 
         Returns:
-            float: The upper bound tensile strength in MPa
+            float: The upper bound tensile strength in MPa.
         """
         if self._fctk_95 is not None:
             return self._fctk_95
@@ -171,8 +171,8 @@ def fctk_95(self) -> float:
     def fctk_95(self, value: float):
         """Sets a user defined value for fctk_95.
 
-        Args:
-            value (float): the value of fctk_95 in MPa
+        Arguments:
+            value (float): The value of fctk_95 in MPa.
         """
         self._fctk_95 = abs(value)
 
@@ -181,7 +181,7 @@ def Ecm(self) -> float:
         """Returns Ecm in MPa.
 
         Returns:
-            float: The upper bound tensile strength in MPa
+            float: The upper bound tensile strength in MPa.
         """
         if self._Ecm is not None:
             return self._Ecm
@@ -192,8 +192,8 @@ def Ecm(self) -> float:
     def Ecm(self, value: float):
         """Sets a user defined value for Ecm.
 
-        Args:
-            value (float): the value of Ecm in MPa
+        Arguments:
+            value (float): The value of Ecm in MPa.
         """
         self._Ecm = abs(value)
 
@@ -201,7 +201,7 @@ def fcd(self) -> float:
         """Return the design compressive strength in MPa.
 
         Returns:
-            float: The design compressive strength of concrete in MPa
+            float: The design compressive strength of concrete in MPa.
         """
         # This method should perhaps become a property, but is left as a method
         # for now, to be consistent with other concretes.
@@ -225,22 +225,22 @@ def alpha_cc(self) -> float:
 
     @property
     def eps_c1(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcm) for the Sargin constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcm)
+        for the Sargin constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c1 = self._eps_c1 or ec2_2004.eps_c1(self.fcm)
         return self._eps_c1
 
     @eps_c1.setter
     def eps_c1(self, value: float):
-        """Sets a user defined value for strain at peak strenght
-        for Sargin constitutive law.
+        """Sets a user defined value for strain at peak strength for Sargin
+        constitutive law.
 
-        Args:
-            value (float): the new value for eps_c1, no units
+        Arguments:
+            value (float): The new value for eps_c1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -254,7 +254,7 @@ def eps_cu1(self) -> float:
         """Returns the strain at concrete failure of concrete.
 
         Returns:
-            float: the maximum strength at failure of concrete
+            float: The maximum strength at failure of concrete.
         """
         self._eps_cu1 = self._eps_cu1 or ec2_2004.eps_cu1(self.fcm)
         return self._eps_cu1
@@ -263,8 +263,8 @@ def eps_cu1(self) -> float:
     def eps_cu1(self, value: float):
         """Sets the nominal ultimate strain for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu1, no units
+        Arguments:
+            value (float): The new value for eps_cu1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -278,12 +278,12 @@ def k_sargin(self) -> float:
         """Returns the coefficient for Sargin constitutive law.
 
         Returns:
-        float: the plastic coefficient for Sargin law.
+            float: The plastic coefficient for Sargin law.
         """
         self._k_sargin = self._k_sargin or ec2_2004.k_sargin(
-            _Ecm=self.Ecm,
-            _fcm=self.fcm,
-            _eps_c1=self.eps_c1,
+            Ecm=self.Ecm,
+            fcm=self.fcm,
+            eps_c1=self.eps_c1,
         )
         return self._k_sargin
 
@@ -291,11 +291,11 @@ def k_sargin(self) -> float:
     def k_sargin(self, value: float):
         """Sets the the coefficient for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for k, no units
+        Arguments:
+            value (float): The new value for k, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
@@ -303,22 +303,22 @@ def k_sargin(self, value: float):
 
     @property
     def eps_c2(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c2 = self._eps_c2 or ec2_2004.eps_c2(self.fck)
         return self._eps_c2
 
     @eps_c2.setter
     def eps_c2(self, value: float):
-        """Sets the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Sets the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_c2, no units
+        Arguments:
+            value (float): The new value for eps_c2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -330,10 +330,10 @@ def eps_c2(self, value: float):
     @property
     def eps_cu2(self) -> float:
         """Returns the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
         Returns:
-            float: the maximum strain at failure of concrete
+            float: The maximum strain at failure of concrete.
         """
         self._eps_cu2 = self._eps_cu2 or ec2_2004.eps_cu2(self.fck)
         return self._eps_cu2
@@ -341,10 +341,10 @@ def eps_cu2(self) -> float:
     @eps_cu2.setter
     def eps_cu2(self, value: float):
         """Sets the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu2, no units
+        Arguments:
+            value (float): The new value for eps_cu2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -358,7 +358,7 @@ def n_parabolic_rectangular(self) -> float:
         """Returns the coefficient for Parabola-rectangle constitutive law.
 
         Returns:
-        float: the exponent for Parabola-recangle law.
+            float: The exponent for Parabola-rectangle law.
         """
         self._n_parabolic_rectangular = (
             self._n_parabolic_rectangular
@@ -370,11 +370,11 @@ def n_parabolic_rectangular(self) -> float:
     def n_parabolic_rectangular(self, value: float):
         """Sets the coefficient for Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for n, no units
+        Arguments:
+            value (float): The new value for n, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
@@ -387,22 +387,22 @@ def n_parabolic_rectangular(self, value: float):
 
     @property
     def eps_c3(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcd) for the Bi-linear constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcd)
+        for the Bi-linear constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c3 = self._eps_c3 or ec2_2004.eps_c3(self.fck)
         return self._eps_c3
 
     @eps_c3.setter
     def eps_c3(self, value: float):
-        """Sets the strain at maximum compressive strength
-            of concrete (fcd) for the Bi-linear constitutive law.
+        """Sets the strain at maximum compressive strength of concrete (fcd)
+        for the Bi-linear constitutive law.
 
-        Args:
-            value (float): the new value for eps_c3, no units
+        Arguments:
+            value (float): The new value for eps_c3, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -413,22 +413,22 @@ def eps_c3(self, value: float):
 
     @property
     def eps_cu3(self) -> float:
-        """Returns the strain at concrete failure of concrete for the
-            Bi-linear constitutive law.
+        """Returns the strain at concrete failure of concrete for the Bi-linear
+        constitutive law.
 
         Returns:
-            float: the maximum strain at failure of concrete
+            float: The maximum strain at failure of concrete.
         """
         self._eps_cu3 = self._eps_cu3 or ec2_2004.eps_cu3(self.fck)
         return self._eps_cu3
 
     @eps_cu3.setter
     def eps_cu3(self, value: float):
-        """Sets the strain at concrete failure of concrete for the
-            Bi-linear constitutive law.
+        """Sets the strain at concrete failure of concrete for the Bi-linear
+        constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu3, no units
+        Arguments:
+            value (float): The new value for eps_cu3, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
diff --git a/structuralcodes/materials/concrete/_concreteEC2_2023.py b/structuralcodes/materials/concrete/_concreteEC2_2023.py
index 818409e7..553b8d12 100644
--- a/structuralcodes/materials/concrete/_concreteEC2_2023.py
+++ b/structuralcodes/materials/concrete/_concreteEC2_2023.py
@@ -34,27 +34,29 @@ def __init__(
         name: t.Optional[str] = None,
         density: float = 2400.0,
         kE: float = 9500,
-        strength_dev_class: str = 'CN',
+        strength_dev_class: t.Literal[
+            'CS', 'CN', 'CR', 'slow', 'normal', 'rapid'
+        ] = 'CN',
         gamma_c: t.Optional[float] = None,
         existing: bool = False,
         **kwargs,
     ):
         """Initializes a new instance of Concrete for EC2 2023.
 
-        Args:
+        Arguments:
             fck (float): Characteristic strength in MPa if concrete is not
                 existing.
 
-        Keyword Args:
-            name (str): A descriptive name for concrete
-            density (float): Density of material in kg/m3 (default: 2400)
-            kE (float): coefficient relating aggregates.
-            strength_dev_class (str, optional): default is CN.
-                Possible values: CS, CN, CR, slow, normal or rapid
-            gamma_c (float, optional): partial factor of concrete
-                (default is 1.5)
+        Keyword Arguments:
+            name (str): A descriptive name for concrete.
+            density (float): Density of material in kg/m3 (default: 2400).
+            kE (float): Coefficient relating aggregates.
+            strength_dev_class (str, optional): Default is CN. Possible values:
+                CS, CN, CR, slow, normal or rapid.
+            gamma_c (float, optional): Partial factor of concrete (default is
+                1.5).
             existing (bool, optional): The material is of an existing structure
-                (default: False)
+                (default: False).
         """
         del kwargs
         if name is None:
@@ -114,12 +116,11 @@ def fcm(self) -> float:
     def fcm(self, value: float):
         """Sets a user defined value for the mean strength of concrete.
 
-        Args:
-            value (float): the value of the mean strength of
-                concrete in MPa.
+        Arguments:
+            value (float): the value of the mean strength of concrete in MPa.
 
         Raises:
-            ValueError: if value is less or equal than the value of fck
+            ValueError: If value is less or equal than the value of fck.
         """
         if abs(value) <= self._fck:
             raise ValueError(
@@ -138,18 +139,18 @@ def fctm(self) -> None:
         """Returns the mean concrete tensile strength.
 
         Returns:
-            float: the mean concrete tensile strength.
+            float: The mean concrete tensile strength.
         """
         self._fctm = self._fctm or ec2_2023.fctm(self.fck)
         return self._fctm
 
     @fctm.setter
     def fctm(self, value: float):
-        """Sets a custom user defined value for the concrete tensile
-            strength for the concrete.
+        """Sets a custom user defined value for the concrete tensile strength
+        for the concrete.
 
-        Args:
-            value (float): the new value for fctm in MPa.
+        Arguments:
+            value (float): The new value for fctm in MPa.
         """
         self._fctm = value
 
@@ -158,7 +159,7 @@ def fctk_5(self) -> float:
         """Returns the 5% mean concrete tensile strength fractile.
 
         Returns:
-            float: the 5% mean concrete tensile strength fractile in MPa
+            float: The 5% mean concrete tensile strength fractile in MPa.
         """
         self._fctk_5 = self._fctk_5 or ec2_2023.fctk_5(self.fctm)
         return self._fctk_5
@@ -168,7 +169,7 @@ def fctk_95(self) -> float:
         """Returns the 95% mean concrete tensile strength fractile.
 
         Returns:
-            float: the 5% mean concrete tensile strength fractile in MPa
+            float: The 5% mean concrete tensile strength fractile in MPa.
         """
         self._fctk_95 = self._fctk_95 or ec2_2023.fctk_95(self.fctm)
         return self._fctk_95
@@ -178,7 +179,7 @@ def Ecm(self) -> float:
         """Returns the secant modulus.
 
         Returns:
-            float: the secant concrete modulus in MPa
+            float: The secant concrete modulus in MPa.
         """
         self._Ecm = self._Ecm or ec2_2023.Ecm(self.fcm, self._kE)
         return self._Ecm
@@ -187,31 +188,30 @@ def Ecm(self) -> float:
     def Ecm(self, value: float) -> None:
         """Sets the secant modulus.
 
-        Args:
-            float: the secand modulus value in MPa.
+        Arguments:
+            float: The secand modulus value in MPa.
         """
         self._Ecm = value
 
     def fcd(
         self, t_ref: float = 28, t0: float = 91, fck_ref: float = 40
     ) -> float:
-        """Computes the value of the design compressive strength of
-        concrete.
-
-        Args:
-            t_ref (float,optional): the reference time in days
-                (default is 28 days).
-            t0 (float, optional): age at loading in days (default is 91 days).
-            fck_ref (float, optional): the reference compressive strength
+        """Computes the value of the design compressive strength of concrete.
+
+        Arguments:
+            t_ref (float,optional): The reference time in days (default is 28
+                days).
+            t0 (float, optional): Age at loading in days (default is 91 days).
+            fck_ref (float, optional): The reference compressive strength in
                 MPa (default is 40 MPa).
 
         Returns:
-            float: the design compressive strength of concrete in MPa
+            float: The design compressive strength of concrete in MPa.
 
         Raises:
-            ValueError: if fck_ref is less or equal to 0
-            ValueError: if t_ref is less than 0
-            ValueError: if t0 is less than 0
+            ValueError: If fck_ref is less or equal to 0.
+            ValueError: If t_ref is less than 0.
+            ValueError: If t0 is less than 0.
         """
         eta_cc = ec2_2023.eta_cc(self.fck, fck_ref=fck_ref)
         k_tc = ec2_2023.k_tc(t_ref, t0, self._strength_dev_class)
@@ -220,15 +220,15 @@ def fcd(
     def fctd(self, t_ref: float = 28) -> float:
         """Computes the value of the design tensile strength of concrete.
 
-        Args:
-            t_ref (float, optional): the reference time in days
-                (default is 28 days).
+        Arguments:
+            t_ref (float, optional): The reference time in days (default is 28
+                days).
 
         Returns:
-            float: the design tensile strength of concrete in MPa
+            float: The design tensile strength of concrete in MPa.
 
         Raises:
-            ValueError: if t_ref is less than 0
+            ValueError: If t_ref is less than 0.
         """
         k_tt = ec2_2023.k_tt(
             t_ref=t_ref, strength_dev_class=self._strength_dev_class
@@ -237,22 +237,22 @@ def fctd(self, t_ref: float = 28) -> float:
 
     @property
     def eps_c1(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcm) for the Sargin constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcm)
+        for the Sargin constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c1 = self._eps_c1 or ec2_2023.eps_c1(self.fcm)
         return self._eps_c1
 
     @eps_c1.setter
     def eps_c1(self, value: float):
-        """Sets a user defined value for strain at peak strenght
-        for Sargin constitutive law.
+        """Sets a user defined value for strain at peak strength for Sargin
+        constitutive law.
 
-        Args:
-            value (float): the new value for eps_c1, no units
+        Arguments:
+            value (float): The new value for eps_c1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -266,7 +266,7 @@ def eps_cu1(self) -> float:
         """Returns the strain at concrete failure of concrete.
 
         Returns:
-            float: the maximum strength at failure of concrete
+            float: The maximum strength at failure of concrete.
         """
         self._eps_cu1 = self._eps_cu1 or ec2_2023.eps_cu1(self.fcm)
         return self._eps_cu1
@@ -275,8 +275,8 @@ def eps_cu1(self) -> float:
     def eps_cu1(self, value: float):
         """Sets the nominal ultimate strain for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu1, no units
+        Arguments:
+            value (float): The new value for eps_cu1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -293,9 +293,9 @@ def k_sargin(self) -> float:
             float: k coefficient for Sargin constitutive law.
         """
         self._k_sargin = self._k_sargin or ec2_2023.k_sargin(
-            _Ecm=self.Ecm,
-            _fcm=self.fcm,
-            _eps_c1=self.eps_c1,
+            Ecm=self.Ecm,
+            fcm=self.fcm,
+            eps_c1=self.eps_c1,
         )
         return self._k_sargin
 
@@ -303,11 +303,11 @@ def k_sargin(self) -> float:
     def k_sargin(self, value: float):
         """Sets the the coefficient for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for k, no units
+        Arguments:
+            value (float): The new value for k, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
@@ -315,22 +315,22 @@ def k_sargin(self, value: float):
 
     @property
     def eps_c2(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c2 = self._eps_c2 or ec2_2023.eps_c2()
         return self._eps_c2
 
     @eps_c2.setter
     def eps_c2(self, value: float):
-        """Sets the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Sets the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_c2, no units
+        Arguments:
+            value (float): The new value for eps_c2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -342,10 +342,10 @@ def eps_c2(self, value: float):
     @property
     def eps_cu2(self) -> float:
         """Returns the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
         Returns:
-            float: the maximum strain at failure of concrete
+            float: The maximum strain at failure of concrete.
         """
         self._eps_cu2 = self._eps_cu2 or ec2_2023.eps_cu2()
         return self._eps_cu2
@@ -353,10 +353,10 @@ def eps_cu2(self) -> float:
     @eps_cu2.setter
     def eps_cu2(self, value: float):
         """Sets the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu2, no units
+        Arguments:
+            value (float): The new value for eps_cu2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -370,7 +370,7 @@ def n_parabolic_rectangular(self) -> float:
         """Returns the coefficient for Parabola-rectangle constitutive law.
 
         Returns:
-        float: the exponent for Parabola-recangle law.
+            float: The exponent for Parabola-recangle law.
         """
         self._n_parabolic_rectangular = (
             self._n_parabolic_rectangular or ec2_2023.n_parabolic_rectangular()
@@ -381,11 +381,11 @@ def n_parabolic_rectangular(self) -> float:
     def n_parabolic_rectangular(self, value: float):
         """Sets the coefficient for Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for n, no units
+        Arguments:
+            value (float): The new value for n, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
diff --git a/structuralcodes/materials/concrete/_concreteMC2010.py b/structuralcodes/materials/concrete/_concreteMC2010.py
index 8795dfde..47cc3d30 100644
--- a/structuralcodes/materials/concrete/_concreteMC2010.py
+++ b/structuralcodes/materials/concrete/_concreteMC2010.py
@@ -41,11 +41,11 @@ def __init__(
     ):
         """Initializes a new instance of Concrete for MC 2010.
 
-        Args:
+        Arguments:
             fck (float): Characteristic strength in MPa if concrete is not
                 existing.
 
-        Keyword Args:
+        Keyword Arguments:
             name (Optional(str)): A descriptive name for concrete.
             density (float): Density of material in kg/m3 (default: 2400).
             gamma_c (Optional(float)): The partial factor for concrete.
@@ -97,11 +97,11 @@ def fcm(self) -> float:
     def fcm(self, value: float):
         """Sets a user defined value for fcm.
 
-        Args:
-            value (float): the value of fcm in MPa
+        Arguments:
+            value (float): The value of fcm in MPa.
 
         Raises:
-            ValueError: if value is lower than fck
+            ValueError: If value is lower than fck.
         """
         if abs(value) <= self._fck:
             raise ValueError(
@@ -122,7 +122,7 @@ def Eci(self) -> float:
 
         It is assumed a normal concrete with quartzite aggregates (alfa_e = 1)
         """
-        self._Eci = self._Eci or mc2010.E_ci(self.fcm)
+        self._Eci = self._Eci or mc2010.Eci(self.fcm)
         return self._Eci
 
     @Eci.setter
@@ -130,8 +130,8 @@ def Eci(self, value: float):
         """Sets a user defined value for modulus of elasticity at the concrete
         age of 28 days, Eci.
 
-        Args:
-            value (float): the value of Eci in MPa
+        Arguments:
+            value (float): The value of Eci in MPa.
         """
         if value < 1e4 or value > 1e5:
             warnings.warn(
@@ -145,7 +145,7 @@ def fctm(self) -> float:
         """Returns fctm in MPa.
 
         Returns:
-            float: The mean tensile strength in MPa
+            float: The mean tensile strength in MPa.
         """
         self._fctm = self._fctm or mc2010.fctm(self._fck)
         return self._fctm
@@ -154,8 +154,8 @@ def fctm(self) -> float:
     def fctm(self, value: float):
         """Sets a user defined value for fctm.
 
-        Args:
-            value (float): the value of fctm in MPa
+        Arguments:
+            value (float): The value of fctm in MPa.
         """
         if value > 0.5 * self._fck:
             warnings.warn(
@@ -168,7 +168,7 @@ def fctkmin(self) -> float:
         """Returns fctkmin in MPa.
 
         Returns:
-            float: The lower bound tensile strength in MPa
+            float: The lower bound tensile strength in MPa.
         """
         self._fctkmin = self._fctkmin or mc2010.fctkmin(self.fctm)
         return self._fctkmin
@@ -177,8 +177,8 @@ def fctkmin(self) -> float:
     def fctkmin(self, value: float):
         """Sets a user defined value for fctkmin.
 
-        Args:
-            value (float): the value of fctkmin in MPa
+        Arguments:
+            value (float): The value of fctkmin in MPa.
         """
         self._fctkmin = abs(value)
 
@@ -187,7 +187,7 @@ def fctkmax(self) -> float:
         """Returns fctkmax in MPa.
 
         Returns:
-            float: The upper bound tensile strength in MPa
+            float: The upper bound tensile strength in MPa.
         """
         self._fctkmax = self._fctkmax or mc2010.fctkmax(self.fctm)
         return self._fctkmax
@@ -196,8 +196,8 @@ def fctkmax(self) -> float:
     def fctkmax(self, value: float):
         """Sets a user defined value for fctkmax.
 
-        Args:
-            value (float): the value of fctkmax in MPa
+        Arguments:
+            value (float): The value of fctkmax in MPa.
         """
         self._fctkmax = abs(value)
 
@@ -206,7 +206,7 @@ def Gf(self) -> float:
         """Fracture energy of concrete.
 
         Returns:
-            float: The fracture energy in N/m
+            float: The fracture energy in N/m.
         """
         self._Gf = self._Gf or mc2010.Gf(self._fck)
         return self._Gf
@@ -215,8 +215,8 @@ def Gf(self) -> float:
     def Gf(self, value: float):
         """Sets a user defined value for fracture energy Gf.
 
-        Args:
-            value (float): the value of Gf in N/m
+        Arguments:
+            value (float): The value of Gf in N/m.
         """
         self._Gf = abs(value)
 
@@ -229,7 +229,7 @@ def fcd(self) -> float:
         """Return the design compressive strength in MPa.
 
         Returns:
-            float: The design compressive strength of concrete in MPa
+            float: The design compressive strength of concrete in MPa.
         """
         # This method should perhaps become a property, but is left as a method
         # for now, to be consistent with other concretes.
@@ -246,22 +246,22 @@ def alpha_cc(self) -> float:
 
     @property
     def eps_c1(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcm) for the Sargin constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcm)
+        for the Sargin constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c1 = self._eps_c1 or mc2010.eps_c1(self._fck)
         return self._eps_c1
 
     @eps_c1.setter
     def eps_c1(self, value: float):
-        """Sets a user defined value for strain at peak strenght
-        for Sargin constitutive law.
+        """Sets a user defined value for strain at peak strenght for Sargin
+        constitutive law.
 
-        Args:
-            value (float): the new value for eps_c1, no units
+        Arguments:
+            value (float): The new value for eps_c1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -275,7 +275,7 @@ def eps_cu1(self) -> float:
         """Returns the strain at concrete failure of concrete.
 
         Returns:
-            float: the maximum strength at failure of concrete
+            float: The maximum strength at failure of concrete.
         """
         self._eps_cu1 = self._eps_cu1 or mc2010.eps_cu1(self._fck)
         return self._eps_cu1
@@ -284,8 +284,8 @@ def eps_cu1(self) -> float:
     def eps_cu1(self, value: float):
         """Sets the nominal ultimate strain for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu1, no units
+        Arguments:
+            value (float): The new value for eps_cu1, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -299,7 +299,7 @@ def k_sargin(self) -> float:
         """Returns the coefficient for Sargin constitutive law.
 
         Returns:
-        float: the plastic coefficient for Sargin law.
+            float: The plastic coefficient for Sargin law.
         """
         self._k_sargin = self._k_sargin or mc2010.k_sargin(self._fck)
         return self._k_sargin
@@ -308,11 +308,11 @@ def k_sargin(self) -> float:
     def k_sargin(self, value: float):
         """Sets the the coefficient for Sargin constitutive law.
 
-        Args:
-            value (float): the new value for k, no units
+        Arguments:
+            value (float): The new value for k, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
@@ -320,22 +320,22 @@ def k_sargin(self, value: float):
 
     @property
     def eps_c2(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c2 = self._eps_c2 or mc2010.eps_c2(self.fck)
         return self._eps_c2
 
     @eps_c2.setter
     def eps_c2(self, value: float):
-        """Sets the strain at maximum compressive strength
-            of concrete (fcd) for the Parabola-rectangle constitutive law.
+        """Sets the strain at maximum compressive strength of concrete (fcd)
+        for the Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_c2, no units
+        Arguments:
+            value (float): The new value for eps_c2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -347,10 +347,10 @@ def eps_c2(self, value: float):
     @property
     def eps_cu2(self) -> float:
         """Returns the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
         Returns:
-            float: the maximum strain at failure of concrete
+            float: The maximum strain at failure of concrete.
         """
         self._eps_cu2 = self._eps_cu2 or mc2010.eps_cu2(self.fck)
         return self._eps_cu2
@@ -358,10 +358,10 @@ def eps_cu2(self) -> float:
     @eps_cu2.setter
     def eps_cu2(self, value: float):
         """Sets the strain at concrete failure of concrete for the
-            Parabola-rectangle constitutive law.
+        Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu2, no units
+        Arguments:
+            value (float): The new value for eps_cu2, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -375,7 +375,7 @@ def n_parabolic_rectangular(self) -> float:
         """Returns the coefficient for Parabola-rectangle constitutive law.
 
         Returns:
-        float: the exponent for Parabola-recangle law.
+            float: The exponent for Parabola-recangle law.
         """
         self._n_parabolic_rectangular = (
             self._n_parabolic_rectangular
@@ -387,11 +387,11 @@ def n_parabolic_rectangular(self) -> float:
     def n_parabolic_rectangular(self, value: float):
         """Sets the coefficient for Parabola-rectangle constitutive law.
 
-        Args:
-            value (float): the new value for n, no units
+        Arguments:
+            value (float): The new value for n, no units.
 
         Raises:
-            ValueError if value < 0
+            ValueError: If value < 0.
         """
         if value < 0:
             raise ValueError(f'n should be a positive value ({value} given)')
@@ -404,22 +404,22 @@ def n_parabolic_rectangular(self, value: float):
 
     @property
     def eps_c3(self) -> float:
-        """Returns the strain at maximum compressive strength
-            of concrete (fcd) for the Bi-linear constitutive law.
+        """Returns the strain at maximum compressive strength of concrete (fcd)
+        for the Bi-linear constitutive law.
 
         Returns:
-            float: the strain at maximum compressive strength of concrete
+            float: The strain at maximum compressive strength of concrete.
         """
         self._eps_c3 = self._eps_c3 or mc2010.eps_c3(self.fck)
         return self._eps_c3
 
     @eps_c3.setter
     def eps_c3(self, value: float):
-        """Sets the strain at maximum compressive strength
-            of concrete (fcd) for the Bi-linear constitutive law.
+        """Sets the strain at maximum compressive strength of concrete (fcd)
+        for the Bi-linear constitutive law.
 
-        Args:
-            value (float): the new value for eps_c3, no units
+        Arguments:
+            value (float): The new value for eps_c3, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
@@ -430,22 +430,22 @@ def eps_c3(self, value: float):
 
     @property
     def eps_cu3(self) -> float:
-        """Returns the strain at concrete failure of concrete for the
-            Bi-linear constitutive law.
+        """Returns the strain at concrete failure of concrete for the Bi-linear
+        constitutive law.
 
         Returns:
-            float: the maximum strain at failure of concrete
+            float: The maximum strain at failure of concrete.
         """
         self._eps_cu3 = self._eps_cu3 or mc2010.eps_cu3(self.fck)
         return self._eps_cu3
 
     @eps_cu3.setter
     def eps_cu3(self, value: float):
-        """Sets the strain at concrete failure of concrete for the
-            Bi-linear constitutive law.
+        """Sets the strain at concrete failure of concrete for the Bi-linear
+        constitutive law.
 
-        Args:
-            value (float): the new value for eps_cu3, no units
+        Arguments:
+            value (float): The new value for eps_cu3, no units.
         """
         if abs(value) >= 0.1:
             warnings.warn(
diff --git a/structuralcodes/materials/constitutive_laws.py b/structuralcodes/materials/constitutive_laws.py
index b5cd1c9f..65f8ee77 100644
--- a/structuralcodes/materials/constitutive_laws.py
+++ b/structuralcodes/materials/constitutive_laws.py
@@ -1,5 +1,7 @@
 """Collection of some standard constitutive laws."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import typing as t
 
 import numpy as np
@@ -9,7 +11,7 @@
 
 
 class Elastic(ConstitutiveLaw):
-    """Class for elastic Constitutive Law."""
+    """Class for elastic constitutive law."""
 
     __materials__: t.Tuple[str] = (
         'concrete',
@@ -18,7 +20,14 @@ class Elastic(ConstitutiveLaw):
     )
 
     def __init__(self, E: float, name: t.Optional[str] = None) -> None:
-        """Initialize an Elastic Material."""
+        """Initialize an Elastic Material.
+
+        Arguments:
+            E (float): The elastic modulus.
+
+        Keyword Arguments:
+            name (str): A descriptive name for the constitutive law.
+        """
         name = name if name is not None else 'ElasticLaw'
         super().__init__(name=name)
         self._E = E
@@ -37,13 +46,12 @@ def get_tangent(self, eps: ArrayLike) -> ArrayLike:
     def __marin__(
         self, strain: t.Tuple[float, float]
     ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
-        """Returns coefficients and strain limits for Marin
-        integration in a simply formatted way.
+        """Returns coefficients and strain limits for Marin integration in a
+        simply formatted way.
 
-        Args:
-            strain: (float, float) tuple defining the strain
-                profile: eps = strain[0] + strain[1]*y
-        Returns:
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
 
         Example:
             [(0, -0.002), (-0.002, -0.003)]
@@ -67,10 +75,10 @@ def set_ultimate_strain(
     ) -> None:
         """Set ultimate strains for Elastic Material if needed.
 
-        Args:
-            eps_su: float or (float, float) defining ultimate strain
-                if a single value is provided the same is adopted for
-                both positive and negative strains
+        Arguments:
+            eps_su (float or (float, float)): Defining ultimate strain if a
+                single value is provided the same is adopted for both positive
+                and negative strains.
         """
         if isinstance(eps_su, float):
             self._eps_su = (abs(eps_su), -abs(eps_su))
@@ -115,7 +123,17 @@ def __init__(
         eps_su: t.Optional[float] = None,
         name: t.Optional[str] = None,
     ) -> None:
-        """Initialize an Elastic-Plastic Material."""
+        """Initialize an Elastic-Plastic Material.
+
+        Arguments:
+            E (float): The elastic modulus.
+            fy (float): The yield strength.
+
+        Keyword Arguments:
+            Eh (float): The hardening modulus.
+            eps_su (float): The ultimate strain.
+            name (str): A descriptive name for the constitutive law.
+        """
         name = name if name is not None else 'ElasticPlasticLaw'
         super().__init__(name=name)
         if E > 0:
@@ -154,13 +172,12 @@ def get_tangent(self, eps: ArrayLike) -> ArrayLike:
     def __marin__(
         self, strain: t.Tuple[float, float]
     ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
-        """Returns coefficients and strain limits for Marin
-        integration in a simply formatted way.
+        """Returns coefficients and strain limits for Marin integration in a
+        simply formatted way.
 
-        Args:
-            strain: (float, float) tuple defining the strain
-                profile: eps = strain[0] + strain[1]*y
-        Returns:
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
 
         Example:
             [(0, -0.002), (-0.002, -0.003)]
@@ -245,14 +262,15 @@ def __init__(
         """Initialize a Parabola-Rectangle Material.
 
         Arguments:
-        fc: (float) the strength of concrete in compression
-        eps_0: (float) peak strain of concrete in compression
-               optional, default value = -0.002
-        eps_u: (float) ultimate strain of concrete in compression
-               optional, default value = -0.0035
-        n: (float) exponent for the pre-peak branch
-           optional, default value = 2
-        name: (str) a name for the constitutive law, optional
+            fc (float): The strength of concrete in compression.
+
+        Keyword Arguments:
+            eps_0 (float): Peak strain of concrete in compression. Default
+                value = -0.002.
+            eps_u (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            n (float): Exponent for the pre-peak branch. Default value = 2.
+            name (str): A name for the constitutive law.
         """
         name = name if name is not None else 'ParabolaRectangleLaw'
         super().__init__(name=name)
@@ -301,13 +319,12 @@ def get_tangent(self, eps: ArrayLike) -> ArrayLike:
     def __marin__(
         self, strain: t.Tuple[float, float]
     ) -> t.Tuple[t.List[float], t.List[float]]:
-        """Returns coefficients and strain limits for Marin
-        integration in a simply formatted way.
+        """Returns coefficients and strain limits for Marin integration in a
+        simply formatted way.
 
-        Args:
-            strain: (float, float) tuple defining the strain
-                profile: eps = strain[0] + strain[1]*y
-        Returns:
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
 
         Example:
             [(0, -0.002), (-0.002, -0.003)]
@@ -404,10 +421,13 @@ def __init__(
     ) -> None:
         """Initialize a BilinearCompression Material.
 
-        Args:
-            fc (float): compressive strength (negative number)
-            eps_c (float): strain at compressive strength (pure number)
-        eps_cu (float): ultimate strain (pure number)
+        Arguments:
+            fc (float): Compressive strength (negative number).
+            eps_c (float): Strain at compressive strength (pure number).
+
+        Keyword Arguments:
+            eps_cu (float): Ultimate strain (pure number).
+            name (str): A descriptive name for the constitutive law.
         """
         name = name if name is not None else 'BilinearCompressionLaw'
         super().__init__(name=name)
@@ -439,13 +459,12 @@ def get_tangent(self, eps: ArrayLike) -> ArrayLike:
     def __marin__(
         self, strain: t.Tuple[float, float]
     ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
-        """Returns coefficients and strain limits for Marin
-        integration in a simply formatted way.
+        """Returns coefficients and strain limits for Marin integration in a
+        simply formatted way.
 
-        Args:
-            strain: (float, float) tuple defining the strain
-                profile: eps = strain[0] + strain[1]*y
-        Returns:
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
 
         Example:
             [(0, -0.002), (-0.002, -0.003)]
@@ -499,8 +518,8 @@ def get_ultimate_strain(
 class Sargin(ConstitutiveLaw):
     """Class for Sargin constitutive law.
 
-    The stresses and strains are assumed negative in compression
-    and positive in tension.
+    The stresses and strains are assumed negative in compression and positive
+    in tension.
 
     References:
     Sargin, M. (1971), "Stress-strain relationship for concrete and the
@@ -521,19 +540,22 @@ def __init__(
         """Initialize a Sargin Material.
 
         Arguments:
-            fc: (float) the strength of concrete in compression
-            eps_c1: (float) peak strain of concrete in compression
-                optional, default value = -0.0023
-            eps_u: (float) ultimate strain of concrete in compression
-                optional, default value = -0.0035
-            k: (float) plasticity numberm, default value = 2.04
-            name: (str) a name for the constitutive law,
+            fc (float): The strength of concrete in compression
+
+        Keyword Arguments:
+            eps_c1 (float): Peak strain of concrete in compression. Default
+                value = -0.0023.
+            eps_u (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            k (float): Plasticity number. Default value = 2.04.
+            name (str): A name for the constitutive law.
 
         Raises:
-            ValueError: if k is less or equal to 0
-        Notes:
-            if positive values are input for fc, eps_c1 and eps_cu1
-            are input, they will be assumed negative.
+            ValueError: If k is less or equal to 0.
+
+        Note:
+            If positive values are input for fc, eps_c1 and eps_cu1 are input,
+            they will be assumed negative.
         """
         name = name if name is not None else 'SarginLaw'
         super().__init__(name=name)
@@ -589,12 +611,11 @@ def get_ultimate_strain(
 class Popovics(ConstitutiveLaw):
     """Class for Popovics-Mander constitutive law.
 
-    The stresses and strains are assumed negative in compression
-    and positive in tension.
+    The stresses and strains are assumed negative in compression and positive
+    in tension.
 
-    If the relation Ec = 5000 * sqrt(fc) is used for elastic modulus,
-    the constitutive law is identical to the one proposed by
-    Mander et al. (1988).
+    If the relation Ec = 5000 * sqrt(fc) is used for elastic modulus, the
+    constitutive law is identical to the one proposed by Mander et al. (1988).
 
     References:
     Popovics, S., 1973, “A Numerical Approach to the Complete Stress-Strain
@@ -615,25 +636,27 @@ def __init__(
         Ec: t.Optional[float] = None,
         name: t.Optional[str] = None,
     ) -> None:
-        """Initialize a Ppovics Material.
+        """Initialize a Popovics Material.
 
         Arguments:
-            fc: (float) the strength of concrete in compression
-            eps_c: (float) peak strain of concrete in compression
-                optional, default value = -0.002
-            eps_cu: (float) ultimate strain of concrete in compression
-                optional, default value = -0.0035
-            E: (optional float) elastic modulus of concrete. If None,
-                the equation Ec = 5000 * fc**0.5 proposed by
-                Mander et al. (1988) is adopted (fc in MPa).
-                optional, default value = None.
-            name: (str) a name for the constitutive law,
+            fc (float): the strength of concrete in compression
+
+        Keyword Arguments:
+            eps_c (float): Peak strain of concrete in compression. Default
+                value = -0.002.
+            eps_cu (float): Ultimate strain of concrete in compression. Default
+                value = -0.0035.
+            E (optional float): Elastic modulus of concrete. If None, the
+                equation Ec = 5000 * fc**0.5 proposed by Mander et al. (1988)
+                is adopted (fc in MPa). Default value = None.
+            name (str): A name for the constitutive law.
 
         Raises:
-            ValueError: if E is less or equal to 0
-        Notes:
-            if positive values are input for fc, eps_c and eps_cu
-            are input, they will be assumed negative.
+            ValueError: If E is less or equal to 0.
+
+        Note:
+            If positive values are input for fc, eps_c and eps_cu are input,
+            they will be assumed negative.
         """
         name = name if name is not None else 'PopovicsLaw'
         super().__init__(name=name)
@@ -699,11 +722,10 @@ def get_ultimate_strain(
 class UserDefined(ConstitutiveLaw):
     """Class for a user defined constitutive law.
 
-    The curve is defined with positive and optionally negative
-    values. After the last value, the stress can go to zero to simulate
-    failure (default), or be mantained constante, or the last tanget or
-    secant values may be mantained indefinetely. The flag parameter
-    controls this behavior.
+    The curve is defined with positive and optionally negative values. After
+    the last value, the stress can go to zero to simulate failure (default), or
+    be maintained constante, or the last tanget or secant values may be
+    maintained indefinetely. The flag parameter controls this behavior.
     """
 
     __materials__: t.Tuple[str] = ('concrete', 'steel', 'rebars')
@@ -718,16 +740,15 @@ def __init__(
         """Initialize a UserDefined constitutive law.
 
         Arguments:
-            x, y: two arrayLike objects containing data for strain and stress
-                    (must be of same length)
-            name: (Optional) a name for the constitutive law
-            flag: (Optional) a flag specifying the behavior after the last
-                point.
-                Admissible values:
-                    0 (default): stress drops to zero after ultimate strain
-                    1: stress is mantained constant
-                    2: last tangent is used
-                    3: last secant is used
+            x (ArrayLike): Data for strains.
+            y (ArrayLike): Data for stresses. Must be of same length as x.
+
+        Keyword Arguments:
+            name (Optional, str): A name for the constitutive law.
+            flag (Optional): A flag specifying the behavior after the last
+                point. Admissible values: 0 (default): stress drops to zero
+                after ultimate strain, 1: stress is mantained constant, 2:
+                last tangent is used, 3: last secant is used.
         """
         name = name if name is not None else 'UserDefinedLaw'
         super().__init__(name=name)
@@ -808,13 +829,12 @@ def get_tangent(self, eps: ArrayLike) -> ArrayLike:
     def __marin__(
         self, strain: t.Tuple[float, float]
     ) -> t.Tuple[t.List[t.Tuple], t.List[t.Tuple]]:
-        """Returns coefficients and strain limits for Marin
-        integration in a simply formatted way.
+        """Returns coefficients and strain limits for Marin integration in a
+        simply formatted way.
 
-        Args:
-            strain: (float, float) tuple defining the strain
-                profile: eps = strain[0] + strain[1]*y
-        Returns:
+        Arguments:
+            strain (float, float): Tuple defining the strain profile: eps =
+                strain[0] + strain[1]*y.
 
         Example:
             [(0, -0.002), (-0.002, -0.003)]
@@ -864,10 +884,10 @@ def set_ultimate_strain(
     ) -> None:
         """Set ultimate strains for Elastic Material if needed.
 
-        Args:
-            eps_su: float or (float, float) defining ultimate strain
-                if a single value is provided the same is adopted for
-                both positive and negative strains
+        Arguments:
+            eps_su (float or (float, float)): Defining ultimate strain if a
+                single value is provided the same is adopted for both positive
+                and negative strains.
         """
         if isinstance(eps_su, float):
             self._ultimate_strain_p = abs(eps_su)
@@ -919,20 +939,21 @@ def create_constitutive_law(
 ) -> ConstitutiveLaw:
     """A factory function to create the constitutive law.
 
-    Args:
-        constitutive_law_name (str): a string defining a valid constitutive law
+    Arguments:
+        constitutive_law_name (str): A string defining a valid constitutive law
             type. The available keys can be get with the method
-            `get_constitutive_laws_list`
+            `get_constitutive_laws_list`.
         material (Material): The material containing the properties needed for
-            the definition of the constitutive law
+            the definition of the constitutive law.
 
     Note:
-        For working with this facotry function, the material classes
+        For working with this facotry function, the material class
         implementations need to provide special dunder methods (__elastic__,
         __parabolarectangle__, etc.) needed for the specific material that
         return the kwargs needed to create the corresponding constitutive
         law object. If the special dunder method is not found an exception
         will be raised.
+
         If the consitutive law selected is not available for the specific
         material, an exception will be raised.
     """
diff --git a/structuralcodes/materials/reinforcement/__init__.py b/structuralcodes/materials/reinforcement/__init__.py
index 90dc2fb3..907c1559 100644
--- a/structuralcodes/materials/reinforcement/__init__.py
+++ b/structuralcodes/materials/reinforcement/__init__.py
@@ -37,13 +37,13 @@ def create_reinforcement(
     """A factory function to create the correct type of reinforcement based on
     the desired design code.
 
-    Args:
+    Arguments:
         fyk (float): Characteristic yield strength in MPa.
         Es (float): The Young's modulus in MPa.
         ftk (float): Characteristic ultimate strength in MPa.
         epsuk (float): The characteristik strain at the ultimate stress level.
 
-    Keyword Args:
+    Keyword Arguments:
         gamma_s (Optional(float)): The partial factor for reinforcement.
         density (float): Density of the material in kg/m3 (default: 7850)
         design_code (str): Optional string (default: None) indicating the
@@ -52,8 +52,8 @@ def create_reinforcement(
             will be used for the instance of the material.
 
     Raises:
-        ValueError: if the design code is not valid or does not cover
-        reinforcement as a material.
+        ValueError: If the design code is not valid or does not cover
+            reinforcement as a material.
     """
     # Get the code from the global variable
     _code = _use_design_code(design_code)
diff --git a/structuralcodes/materials/reinforcement/_reinforcement.py b/structuralcodes/materials/reinforcement/_reinforcement.py
index fca61a13..f093682b 100644
--- a/structuralcodes/materials/reinforcement/_reinforcement.py
+++ b/structuralcodes/materials/reinforcement/_reinforcement.py
@@ -112,12 +112,11 @@ def constitutive_law(
     ) -> None:
         """Setter for constitutive law.
 
-        Args:
-        consitutive_law (ConstitutiveLaw | str): a valid ConstitutiveLaw object
-                for concrete or  a string defining a valid constitutive law
-                type for concrete.
-                (valid options: 'elastic', 'elasticperfectlyplastic',
-                'elasticplastic').
+        Arguments:
+            consitutive_law (ConstitutiveLaw | str): a valid ConstitutiveLaw
+                object for reinforcement or  a string defining a valid
+                constitutive law type for reinforcement. (valid options:
+                'elastic', 'elasticperfectlyplastic', 'elasticplastic').
         """
         if constitutive_law is None:
             raise ValueError(
diff --git a/structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py b/structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py
index 6f011b30..f22dea4a 100644
--- a/structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py
+++ b/structuralcodes/materials/reinforcement/_reinforcementEC2_2004.py
@@ -23,7 +23,7 @@ def __init__(
     ):
         """Initializes a new instance of Reinforcement for EC2 2004.
 
-        Args:
+        Arguments:
             fyk (float): Characteristic yield strength in MPa.
             Es (float): The Young's modulus in MPa.
             ftk (float): Characteristic ultimate strength in MPa.
@@ -32,9 +32,9 @@ def __init__(
             gamma_s (Optional(float)): The partial factor for reinforcement.
                 Default value is 1.15.
 
-        Keyword Args:
+        Keyword Arguments:
             name (str): A descriptive name for the reinforcement.
-            desnsity (float): Density of material in kg/m3 (default: 7850).
+            density (float): Density of material in kg/m3 (default: 7850).
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
diff --git a/structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py b/structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py
index 857728b0..61c7e70e 100644
--- a/structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py
+++ b/structuralcodes/materials/reinforcement/_reinforcementEC2_2023.py
@@ -33,7 +33,7 @@ def __init__(
 
         Keyword Args:
             name (str): A descriptive name for the reinforcement.
-            desnsity (float): Density of material in kg/m3 (default: 7850).
+            density (float): Density of material in kg/m3 (default: 7850).
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
diff --git a/structuralcodes/materials/reinforcement/_reinforcementMC2010.py b/structuralcodes/materials/reinforcement/_reinforcementMC2010.py
index 7c148a90..e4c9e4af 100644
--- a/structuralcodes/materials/reinforcement/_reinforcementMC2010.py
+++ b/structuralcodes/materials/reinforcement/_reinforcementMC2010.py
@@ -34,7 +34,7 @@ def __init__(
 
         Keyword Args:
             name (str): A descriptive name for the reinforcement.
-            desnsity (float): Density of material in kg/m3 (default: 7850).
+            density (float): Density of material in kg/m3 (default: 7850).
         """
         if name is None:
             name = f'Reinforcement{round(fyk):d}'
diff --git a/structuralcodes/sections/__init__.py b/structuralcodes/sections/__init__.py
index d110e145..5d5e7619 100644
--- a/structuralcodes/sections/__init__.py
+++ b/structuralcodes/sections/__init__.py
@@ -7,6 +7,7 @@
     MarinIntegrator,
     SectionIntegrator,
     integrator_factory,
+    marin_integration,
 )
 
 __all__ = [
@@ -18,4 +19,5 @@
     'FiberIntegrator',
     'MarinIntegrator',
     'integrator_factory',
+    'marin_integration',
 ]
diff --git a/structuralcodes/sections/_generic.py b/structuralcodes/sections/_generic.py
index 4e49a15f..def72fd6 100644
--- a/structuralcodes/sections/_generic.py
+++ b/structuralcodes/sections/_generic.py
@@ -1,6 +1,6 @@
 """Generic class section implemenetation."""
 
-from __future__ import annotations
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
 
 import typing as t
 import warnings
@@ -26,21 +26,19 @@
 class GenericSection(Section):
     """This is the implementation of the generic class section.
 
-    The section is a 2D geometry where Y axis is horizontal while
-    Z axis is vertical.
-    The moments and curvatures around Y and Z axes are assumed
-    positive according to RHR.
+    The section is a 2D geometry where Y axis is horizontal while Z axis is
+    vertical.
+
+    The moments and curvatures around Y and Z axes are assumed positive
+    according to RHR.
 
     Attributes:
-        geometry: (SurfaceGeometry or CompoundGeometry)
-            the geometry of the section
-        name: (str) the name of the section
-        section_calculator: (GenericSectionCalculator)
-            the object responsible for performing different
-            calculations on the section (e.g. bending strength,
-            moment curvature, etc.)
-        gross_properties: (GrossProperties)
-            the results of gross properties computation
+        geometry (Union(SurfaceGeometry, CompoundGeometry)): The geometry of
+            the section.
+        name (str): The name of the section.
+        section_calculator (GenericSectionCalculator): The object responsible
+            for performing different calculations on the section (e.g. bending
+            strength, moment curvature, etc.).
     """
 
     def __init__(
@@ -50,6 +48,14 @@ def __init__(
         integrator: t.Literal['marin', 'fiber'] = 'marin',
         **kwargs,
     ) -> None:
+        """Initialize a GenericSection.
+
+        Arguments:
+            geometry (Union(SurfaceGeometry, CompoundGeometry)): The geometry
+                of the section.
+            name (str): The name of the section.
+            integrator (str): The name of the SectionIntegrator to use.
+        """
         if name is None:
             name = 'GenericSection'
         super().__init__(name)
@@ -76,24 +82,25 @@ def gross_properties(self) -> s_res.GrossProperties:
 
 
 class GenericSectionCalculator(SectionCalculator):
-    """Calculator class implementing analysis algortims for
-    Code checks.
-    """
+    """Calculator class implementing analysis algorithms for code checks."""
 
     def __init__(
-        self, sec: GenericSection, integrator: str = 'Marin', **kwargs
+        self,
+        sec: GenericSection,
+        integrator: t.Literal['marin', 'fiber'] = 'marin',
+        **kwargs,
     ) -> None:
         """Initialize the GenericSectionCalculator.
 
-        Args:
-            section (SectionCalculator): the section object.
-            integrator (str): the integrator to be used for computations
-                            (default = 'marin')
+        Arguments:
+            section (GenericSection): The section object.
+            integrator (str): The SectionIntegrator to be used for computations
+                (default = 'marin').
 
         Note:
-            when using 'fiber' integrator the kwarg 'mesh_size' can be used
-            to specify a dimensionless number (between 0 and 1) specifying
-            the size of the resulting mesh.
+            When using 'fiber' integrator the kwarg 'mesh_size' can be used to
+            specify a dimensionless number (between 0 and 1) specifying the
+            size of the resulting mesh.
         """
         super().__init__(section=sec)
         # Select the integrator if specified
@@ -109,11 +116,11 @@ def __init__(
     def _calculate_gross_section_properties(self) -> s_res.GrossProperties:
         """Calculates the gross section properties of the GenericSection.
 
-        This function is private and called when the section is created
+        This function is private and called when the section is created.
         It stores the result into the result object.
 
         Returns:
-        gross_section_properties (GrossSection)
+            GrossProperties: The gross properties of the section.
         """
         # It will use the algorithms for generic sections
         gp = s_res.GrossProperties()
@@ -267,21 +274,18 @@ def get_balanced_failure_strain(
 
         This is found from all ultimate strains for all materials, checking
         the minimum value of curvature.
-        It returns a tuple with:
-        1. Value of y coordinate for negative failure
-        2. Value of y coordinate for positive failure
-        3. Strain profile as a list with three values: axial strain, curvature
-           y*, curvature z* (assumed zero since in the rotated frame y*z* it is
-           a case of uniaxial bending).
-
-        Args:
-            geom: the compund geometry
-            yielding: (bool, default = False) consider yielding instead of
-                ultimate strain
+
+        Arguments:
+            geom (CompoundGeometry): The compund geometry.
+            yielding (bool): consider yielding instead of ultimate strain,
+                default = False.
 
         Returns:
-            Returns a tuple (float, float, float) that define the strain
-            distribution
+            Tuple(float, float, List): It returns a tuple with, 1) Value of y
+            coordinate for negative failure, 2) Value of y coordinate for
+            positive failure, 3) Strain profile as a list with three values:
+            axial strain, curvature y*, curvature z* (assumed zero since in the
+            rotated frame y*z* it is a case of uniaxial bending).
         """
         chi_min = 1e10
         for g in geom.geometries + geom.point_geometries:
@@ -323,12 +327,15 @@ def find_equilibrium_fixed_pivot(
         raised respectively.
 
         Arguments:
-        geom: (CompoundGeometry) A geometry in the rotated reference system
-        n: (float) value of external axial force needed to be equilibrated
+            geom (CompoundGeometry): A geometry in the rotated reference
+                system.
+            n (float): Value of external axial force needed to be equilibrated.
+            yielding (bool): ...
 
         Returns:
-        strain: list of 3 floats. Axial strain at (0,0) curvatures of y* and z*
-            axes. Note that being uniaxial bending, curvature along z* is 0.0
+            Tuple(float, float, float): 3 floats: Axial strain at (0,0), and
+            curvatures of y* and z* axes. Note that being uniaxial bending,
+            curvature along z* is 0.0.
         """
         # Number of maximum iteration for the bisection algorithm
         ITMAX = 100
@@ -408,8 +415,8 @@ def _prefind_range_curvature_equilibrium(
         """Perfind range where the curvature equilibrium is located.
 
         This algorithms quickly finds a position of NA that guaranteed the
-        existence of at least one zero in the function dn vs. curv in order
-        to apply the bisection algorithm.
+        existence of at least one zero in the function dn vs. curv in order to
+        apply the bisection algorithm.
         """
         ITMAX = 20
         sign = -1 if dn_a > 0 else 1
@@ -443,16 +450,21 @@ def _prefind_range_curvature_equilibrium(
 
     def find_equilibrium_fixed_curvature(
         self, geom: CompoundGeometry, n: float, curv: float, eps_0: float
-    ):
+    ) -> t.Tuple[float, float, float]:
         """Find strain profile with equilibrium with fixed curvature.
-        Given curvature and external axial force, find the strain profile
-        that makes internal and external axial force in equilibrium.
+
+        Given curvature and external axial force, find the strain profile that
+        makes internal and external axial force in equilibrium.
 
         Arguments:
-        geom: (CompounGeometry) the geometry
-        n: (float) the external axial load
-        curv: (float) the value of curvature
-        eps_0: (float) a first attempt for neutral axis position
+            geom (CompounGeometry): The geometry.
+            n (float): The external axial load.
+            curv (float): The value of curvature.
+            eps_0 (float): A first attempt for neutral axis position.
+
+        Returns:
+            Tuple(float, float, float): The axial strain and the two
+            curvatures.
         """
         # Useful for Moment Curvature Analysis
         # Number of maximum iteration for the bisection algorithm
@@ -502,13 +514,13 @@ def find_equilibrium_fixed_curvature(
             s = f'Last iteration reached a unbalance of: \
                 dn_c = {dn_c}'
             raise ValueError(f'Maximum number of iterations reached.\n{s}')
-        return [eps_0_c, curv, 0]
+        return eps_0_c, curv, 0
 
     def calculate_limit_axial_load(self):
         """Compute maximum and minimum axial load.
 
         Returns:
-            (float, float) Minimum and Maximum axial load.
+            Tuple(float, float): Minimum and Maximum axial load.
         """
         # Find balanced failure to get strain limits
         y_n, y_p, strain = self.get_balanced_failure_strain(
@@ -548,7 +560,11 @@ def n_max(self) -> float:
         return self._n_max
 
     def check_axial_load(self, n: float):
-        """Check if axial load n is within section limits."""
+        """Check if axial load n is within section limits.
+
+        Raises:
+            ValueError: If axial load cannot be carried by the section.
+        """
         if n < self.n_min or n > self.n_max:
             error_str = f'Axial load {n} cannot be taken by section.\n'
             error_str += f'n_min = {self.n_min} / n_max = {self.n_max}'
@@ -571,16 +587,13 @@ def integrate_strain_profile(
     ) -> t.Tuple[float, float, float]:
         """Integrate a strain profile returning internal forces.
 
-        Args:
-            strain: (Array like) represents the deformation plane
-                    the strain should have three entries representing
-                    respectively:
-                    axial strain (At 0,0 coordinates)
-                    curv_y
-                    curv_z
+        Arguments:
+            strain (ArrayLike): Represents the deformation plane. The strain
+                should have three entries representing respectively: axial
+                strain (At 0,0 coordinates), curv_y, curv_z.
 
         Returns:
-            (float, float, float) N, My and Mz
+            Tuple(float, float, float): N, My and Mz.
         """
         N, My, Mz, _ = self.integrator.integrate_strain_response_on_geometry(
             geo=self.section.geometry,
@@ -593,17 +606,17 @@ def integrate_strain_profile(
     def calculate_bending_strength(
         self, theta=0, n=0
     ) -> s_res.UltimateBendingMomentResults:
-        """Calculates the bending strength for given inclination of n.a.
-        and axial load.
+        """Calculates the bending strength for given inclination of n.a. and
+        axial load.
 
         Arguments:
-        theta (float, default = 0): inclination of n.a. respect to section
-            y axis
-        n (float, default = 0): axial load applied to the section
-            (+: tension, -: compression)
+            theta (float): Inclination of n.a. respect to section y axis,
+                default = 0.
+            n (float): Axial load applied to the section (+: tension, -:
+                compression), default = 0.
 
-        Return:
-        ultimate_bending_moment_result (UltimateBendingMomentResult)
+        Returns:
+            UltimateBendingMomentResults: The results from the calculation.
         """
         # Compute the bending strength with the bisection algorithm
         # Rotate the section of angle theta
@@ -654,23 +667,25 @@ def calculate_moment_curvature(
         n.a. and axial load.
 
         Arguments:
-        theta (float, default = 0): inclination of n.a. respect to y axis
-        n (float, default = 0): axial load applied to the section (+: tension,
-            -: compression)
-        chi_first (float, default = 1e-8): the first value of the curvature
-        num_pre_yield (int, default = 10): Number of points before yielding.
-            Note that the yield curvature will be at the num_pre_yield-th point
-            in the result array.
-        num_post_yield (int, default = 10): Number of points after yielding
-        chi (Optional[ArrayLike], default = None): An ArrayLike with curvatures
-            to calculate the moment response for. If chi is None, the array is
-            constructed from chi_first, num_pre_yield and num_post_yield. If
-            chi is not None, chi_first, num_pre_yield and num_post_yield are
-            disregarded, and the provided chi is used directly in the
-            calculations.
+            theta (float): Inclination of n.a. respect to y axis, default = 0.
+            n (float): Axial load applied to the section (+: tension, -:
+                compression), default = 0.
+            chi_first (float): The first value of the curvature, default =
+                1e-8.
+            num_pre_yield (int): Number of points before yielding. Note that
+                the yield curvature will be at the num_pre_yield-th point in
+                the result array, default = 10.
+            num_post_yield (int): Number of points after yielding, default =
+                10.
+            chi (Optional[ArrayLike]): An ArrayLike with curvatures to
+                calculate the moment response for. If chi is None, the array is
+                constructed from chi_first, num_pre_yield and num_post_yield.
+                If chi is not None, chi_first, num_pre_yield and num_post_yield
+                are disregarded, and the provided chi is used directly in the
+                calculations.
 
-        Return:
-        moment_curvature_result (MomentCurvatureResults)
+        Returns:
+            MomentCurvatureResults: The calculation results.
         """
         # Create an empty response object
         res = s_res.MomentCurvatureResults()
@@ -883,7 +898,7 @@ def calculate_nm_interaction_domain(
                 type_1 for options.
 
         Returns:
-            (NmInteractionDomain)
+            NMInteractionDomain: The calculation results.
         """
         # Prepare the results
         res = s_res.NMInteractionDomain()
@@ -1145,8 +1160,8 @@ def calculate_nmm_interaction_domain(
             type_6 (literal): Type of spacing for field 6 (default = 'linear').
                 See type_1 for options.
 
-        Return:
-            (NMMInteractionDomain)
+        Returns:
+            NMInteractionDomain: The calculation results.
         """
         res = s_res.NMMInteractionDomain()
         res.num_theta = num_theta
@@ -1210,11 +1225,11 @@ def calculate_mm_interaction_domain(
         """Calculate the My-Mz interaction domain.
 
         Arguments:
-        n (float, default = 0): axial force
-        n_theta (int, default = 32): number of discretization for theta
+            n (float): Axial force, default = 0.
+            n_theta (int): Number of discretization for theta, default = 32.
 
         Return:
-        (MMInteractionDomain)
+            MMInteractionDomain: The calculation results.
         """
         # Prepare the results
         res = s_res.MMInteractionDomain()
diff --git a/structuralcodes/sections/_reinforcement.py b/structuralcodes/sections/_reinforcement.py
index e2810239..44b4fe20 100644
--- a/structuralcodes/sections/_reinforcement.py
+++ b/structuralcodes/sections/_reinforcement.py
@@ -21,16 +21,17 @@ def add_reinforcement(
 ) -> CompoundGeometry:
     """Add a single bar given coordinate.
 
-    Args:
-        geo: a geometry (SurfaceGeometry or CompoundGeometry) to
-            which add reinforcement
-        coords: a tuple with cordinates of bar
-        diameter: the diameter of the reinforcement
-        material: a material or a constitutive law for the behavior
-            of the reinforcement
+    Arguments:
+        geo (Union(SurfaceGeometry, CompoundGeometry)): A geometry to which add
+            reinforcement.
+        coords (Tuple(float, float)): A tuple with cordinates of bar.
+        diameter (float): The diameter of the reinforcement.
+        material (Union(Material, ConstitutiveLaw)): A material or a
+            constitutive law for the behavior of the reinforcement.
 
     Returns:
-        the resulting compound geometry
+        CompoundGeometry: A compound geometry with the original geometry and
+        the reinforcement.
     """
     bar = PointGeometry(Point(coords), diameter, material)
     return geo + bar
@@ -49,22 +50,29 @@ def add_reinforcement_line(
 ) -> CompoundGeometry:
     """Adds a set of bars distributed in a line.
 
-    Args:
-        geo: the geometry used as input
-        coords_i: coordinates of the initial point of line
-        coords_j: coordinates of the final point of line
-        diamter: the diameter of the bars
-        material: a valid material or constitutive law
-        n: the number of bars to be distributed inside the line (default = 0)
-        s: the distance between the bars (default = 0)
-        first: boolean indicating if placing the first bar (default = True)
-        last: boolean indicating if placing the last bar (default = True)
+    Arguments:
+        geo (Union(SurfaceGeometry, CompoundGeometry)): The geometry used as
+            input.
+        coords_i (Tuple(float, float)): Coordinates of the initial point of
+            line.
+        coords_j (Tuple(float, float)): Coordinates of the final point of line.
+        diamter (float): The diameter of the bars.
+        material (Union(Material, ConstitutiveLaw)): A valid material or
+            constitutive law.
+        n (int): The number of bars to be distributed inside the line (default
+            = 0).
+        s (float): The distance between the bars (default = 0).
+        first (bool): Boolean indicating if placing the first bar (default =
+            True).
+        last (bool): Boolean indicating if placing the last bar (default =
+            True).
 
     Note:
-        at least n or s should be greater than zero
+        At least n or s should be greater than zero.
 
     Returns:
-        compound geometry
+        CompoundGeometry: A compound geometry with the original geometry and
+        the reinforcement.
     """
     from math import floor
 
diff --git a/structuralcodes/sections/section_integrators/__init__.py b/structuralcodes/sections/section_integrators/__init__.py
index 4e53f8e1..e32f448b 100644
--- a/structuralcodes/sections/section_integrators/__init__.py
+++ b/structuralcodes/sections/section_integrators/__init__.py
@@ -2,7 +2,7 @@
 
 from ._factory import integrator_factory
 from ._fiber_integrator import FiberIntegrator
-from ._marin_integrator import MarinIntegrator
+from ._marin_integrator import MarinIntegrator, marin_integration
 from ._section_integrator import SectionIntegrator
 
 __all__ = [
@@ -10,4 +10,5 @@
     'FiberIntegrator',
     'MarinIntegrator',
     'SectionIntegrator',
+    'marin_integration',
 ]
diff --git a/structuralcodes/sections/section_integrators/_factory.py b/structuralcodes/sections/section_integrators/_factory.py
index d2254e49..f127d2dd 100644
--- a/structuralcodes/sections/section_integrators/_factory.py
+++ b/structuralcodes/sections/section_integrators/_factory.py
@@ -19,8 +19,17 @@ def __init__(self, registry: t.Dict[str, SectionIntegrator]):
         self.instances = {}
         self.registry = registry
 
-    def __call__(self, method: str) -> SectionIntegrator:
-        """Create an integrator based on its name."""
+    def __call__(
+        self, method: t.Literal['marin', 'fiber']
+    ) -> SectionIntegrator:
+        """Create an integrator based on its name.
+
+        Arguments:
+            method (str): The name of the integrator to use.
+
+        Returns:
+            SectionIntegrator: The section integrator.
+        """
         self.instances.setdefault(
             method.lower(), self.registry.get(method.lower(), MarinIntegrator)
         )
diff --git a/structuralcodes/sections/section_integrators/_fiber_integrator.py b/structuralcodes/sections/section_integrators/_fiber_integrator.py
index e06572e1..45ebccdc 100644
--- a/structuralcodes/sections/section_integrators/_fiber_integrator.py
+++ b/structuralcodes/sections/section_integrators/_fiber_integrator.py
@@ -1,5 +1,7 @@
 """The fiber section integrator."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import typing as t
 
 import numpy as np
@@ -18,8 +20,11 @@ class FiberIntegrator(SectionIntegrator):
     def prepare_triangulation(self, geo: SurfaceGeometry) -> t.Dict:
         """Triangulate a SurfaceGeometry object.
 
-        Args:
-            geo (SurfaceGeometry): The geometry to triangulate
+        Arguments:
+            geo (SurfaceGeometry): The geometry to triangulate.
+
+        Returns:
+            Dict: The triangulation data.
         """
         # Create the tri dictionary
         tri: dict[str:ArrayLike] = {}
@@ -62,15 +67,19 @@ def prepare_input(
 
         Calculate the stresses based on strains in a set of points.
 
-        Args:
+        Keyword Arguments:
             geo (CompoundGeometry): The geometry of the section.
-            strain (ArrayLike): The strains and curvatures of the section.
-                                given in the format (ea, ky, kz) which are
-                                strain at 0,0
-                                curvature y axis
-                                curvature z axis
+            strain (ArrayLike): The strains and curvatures of the section,
+                given in the format (ea, ky, kz) which are i) strain at 0,0,
+                ii) curvature y axis, iii) curvature z axis.
             mesh_size: Percentage of area (number from 0 to 1) max for triangle
-                        elements
+                elements.
+
+        Returns:
+            Tuple(List, Dict): The prepared input representing a list with
+            x-coordinates, y-coordinates and force for each fiber and a
+            dictionary containing the triangulation data that can be stored and
+            used later to avoid repetition of triangulation.
         """
         # This method should:
         #  - discretize the section in a number of fibers (mesh_size)
@@ -186,7 +195,14 @@ def integrate(
             t.Tuple[int, np.ndarray, np.ndarray, np.ndarray]
         ],
     ) -> t.Tuple[float, float, float]:
-        """Integrate stresses over the geometry."""
+        """Integrate stresses over the geometry.
+
+        Arguments:
+            prepared_input (List): The prepared input from .prepare_input().
+
+        Returns:
+            Tuple(float, float, float): The stress resultants N, Mx and My.
+        """
         # Integration over all fibers
         x, y, F = prepared_input[0]
 
@@ -199,7 +215,20 @@ def integrate(
     def integrate_strain_response_on_geometry(
         self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
     ):
-        """Integrate the strain response with the Marin algorithm."""
+        """Integrate the strain response with the fiber algorithm.
+
+        Arguments:
+            geo (CompoundGeometry): The geometry of the section.
+            strain (ArrayLike): The strains and curvatures of the section,
+                given in the format (ea, ky, kz) which are i) strain at 0,0,
+                ii) curvature y axis, iii) curvature z axis.
+            mesh_size: Percentage of area (number from 0 to 1) max for triangle
+                elements.
+
+        Returns:
+            Tuple(Tuple(float, float, float), Dict): The stress resultants N,
+            Mx and My and the triangulation data.
+        """
         # Prepare the general input based on the geometry and the input strains
         prepared_input, triangulated_data = self.prepare_input(
             geo, strain, **kwargs
diff --git a/structuralcodes/sections/section_integrators/_marin_integration.py b/structuralcodes/sections/section_integrators/_marin_integration.py
index b08c497b..db4bb31a 100644
--- a/structuralcodes/sections/section_integrators/_marin_integration.py
+++ b/structuralcodes/sections/section_integrators/_marin_integration.py
@@ -21,13 +21,17 @@ def marin_integration(
     """Marin's algorithm for integrating a polynomial over a closed polygon.
 
     The order of the polygon vertices is significant. If the points are in
-    counterclockwise order the integral is positive, otherwise the integral
-    is negative.
+    counterclockwise order the integral is positive, otherwise the integral is
+    negative.
 
     Arguments:
-        y, z (lists of floats): Coordinates of polygon vertices.
+        y (List(float)): Y coordinates of polygon vertices.
+        z (List(float)): Z coordinates of polygon vertices.
         m (int): The degree of the polynomial in the y direction.
         n (int): The degree of the polynomial in the z direction.
+
+    Returns:
+        float: The result of the integrated polynomial.
     """
     mom = 0
     for i in range(len(y) - 1):
diff --git a/structuralcodes/sections/section_integrators/_marin_integrator.py b/structuralcodes/sections/section_integrators/_marin_integrator.py
index 1dabed45..9731a903 100644
--- a/structuralcodes/sections/section_integrators/_marin_integrator.py
+++ b/structuralcodes/sections/section_integrators/_marin_integrator.py
@@ -1,5 +1,7 @@
 """The Marin section integrator."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import typing as t
 from math import atan2, cos, sin
 
@@ -19,18 +21,24 @@ class MarinIntegrator(SectionIntegrator):
 
     def prepare_input(
         self, geo: CompoundGeometry, strain: ArrayLike
-    ) -> t.Tuple[t.Tuple[np.ndarray, np.ndarray, np.ndarray]]:
+    ) -> t.Tuple[float, t.Tuple[np.ndarray, np.ndarray, np.ndarray]]:
         """Prepare general input to the integration.
 
         Calculate the stresses based on strains in a set of points.
 
-        Args:
+        Keyword Arguments:
             geo (CompoundGeometry): The geometry of the section.
-            strain (ArrayLike): The strains and curvatures of the section.
-                                given in the format (ea, ky, kz) which are
-                                strain at 0,0
-                                curvature y axis
-                                curvature z axis
+            strain (ArrayLike): The strains and curvatures of the section,
+                given in the format (ea, ky, kz) which are i) strain at 0,0,
+                ii) curvature y axis, iii) curvature z axis.
+            mesh_size: Percentage of area (number from 0 to 1) max for triangle
+                elements.
+
+        Returns:
+            Tuple(float, Tuple(ndarray, ndarray, ndarray)): The prepared input
+            represented as the angle of rotation computed (needed for rotating
+            back the resultants) and as a tuple with 3 ndarrys collecting
+            respectively y, z and stress coefficients for each sub-part.
         """
         # This method should do the following tasks:
         # - For each geo:
@@ -147,7 +155,14 @@ def integrate(
             t.Tuple[int, np.ndarray, np.ndarray, np.ndarray]
         ],
     ) -> t.Tuple[float, float, float]:
-        """Integrate stresses over the geometry."""
+        """Integrate stresses over the geometry.
+
+        Arguments:
+            prepared_input (List): The prepared input from .prepare_input().
+
+        Returns:
+            Tuple(float, float, float): The stress resultants N, Mx and My.
+        """
         # Set the stress resultants to zero
         N, Mx, My = 0.0, 0.0, 0.0
 
@@ -187,7 +202,18 @@ def integrate(
     def integrate_strain_response_on_geometry(
         self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
     ):
-        """Integrate the strain response with the Marin algorithm."""
+        """Integrate the strain response with the Marin algorithm.
+
+        Arguments:
+            geo (CompoundGeometry): The geometry of the section.
+            strain (ArrayLike): The strains and curvatures of the section,
+                given in the format (ea, ky, kz) which are i) strain at 0,0,
+                ii) curvature y axis, iii) curvature z axis.
+
+        Returns:
+            Tuple(Tuple(float, float, float), Dict): The stress resultants N,
+            Mx and My and the triangulation data.
+        """
         del kwargs
         # Prepare the general input based on the geometry and the input strains
         angle, prepared_input = self.prepare_input(geo, strain)
diff --git a/structuralcodes/sections/section_integrators/_section_integrator.py b/structuralcodes/sections/section_integrators/_section_integrator.py
index 8c4b0a6b..4884d28e 100644
--- a/structuralcodes/sections/section_integrators/_section_integrator.py
+++ b/structuralcodes/sections/section_integrators/_section_integrator.py
@@ -1,5 +1,7 @@
 """Abstract base class for section integrators."""
 
+from __future__ import annotations  # To have clean hints of ArrayLike in docs
+
 import abc
 
 from numpy.typing import ArrayLike
@@ -22,8 +24,8 @@ def prepare_input(self, geo: CompoundGeometry, strain: ArrayLike):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def integrate(self, *prepared_input, **kwargs) -> float:
-        """Integrate stresses over the gemetry.
+    def integrate(self, *prepared_input, **kwargs):
+        """Integrate stresses over the geometry.
 
         The input to this method is generated by the prepare_input method. It
         also takes kwargs depending on the concrete implementation.
@@ -41,7 +43,7 @@ def integrate(self, *prepared_input, **kwargs) -> float:
     def integrate_strain_response_on_geometry(
         self, geo: CompoundGeometry, strain: ArrayLike, **kwargs
     ):
-        """Integrate over the geometry to obtain the response due
-        to strains.
+        """Integrate stresses over the geometry to obtain the response due to
+        strains.
         """
         raise NotImplementedError


Test patch:
diff --git a/tests/test_ec2_2004/test_concrete_ec2_2004.py b/tests/test_ec2_2004/test_concrete_ec2_2004.py
index b466ccad..9b07be08 100644
--- a/tests/test_ec2_2004/test_concrete_ec2_2004.py
+++ b/tests/test_ec2_2004/test_concrete_ec2_2004.py
@@ -333,9 +333,9 @@ def test_k_getter(fck):
     """Test k getter."""
     c = ConcreteEC2_2004(fck=fck)
     expected = ec2_2004.k_sargin(
-        _Ecm=ec2_2004.Ecm(ec2_2004.fcm(fck=fck)),
-        _fcm=ec2_2004.fcm(fck=fck),
-        _eps_c1=ec2_2004.eps_c1(ec2_2004.fcm(fck=fck)),
+        Ecm=ec2_2004.Ecm(ec2_2004.fcm(fck=fck)),
+        fcm=ec2_2004.fcm(fck=fck),
+        eps_c1=ec2_2004.eps_c1(ec2_2004.fcm(fck=fck)),
     )
     assert math.isclose(c.k_sargin, expected, rel_tol=1e-6)
 
diff --git a/tests/test_ec2_2004/test_ec2_2004_annex_B_shrink_and_creep.py b/tests/test_ec2_2004/test_ec2_2004_annex_B_shrink_and_creep.py
index 3daa3243..7ab365bd 100644
--- a/tests/test_ec2_2004/test_ec2_2004_annex_B_shrink_and_creep.py
+++ b/tests/test_ec2_2004/test_ec2_2004_annex_B_shrink_and_creep.py
@@ -1,5 +1,7 @@
 """Tests for EUROCODE 2-1-2:2004 Annex B and chapter 3."""
 
+import math
+
 import pytest
 
 from structuralcodes.codes.ec2_2004 import annex_b_shrink_and_creep
@@ -10,35 +12,61 @@
     [
         (138.5, 43, 50, 'R', 7, 18263, 2.567),
         (136.5, 38, 55, 'N', 7, 18263, 3.083),
+        (136.5, 28, 55, 'N', 7, 18263, 3.748),
     ],
 )
 def test_creep_returns_expected_values(
     test_h_0, test_f_cm, test_RH, test_c_class, test_t0, test_t, expected
 ):
-    """Test that annex_B_Creep returns expected values."""
-    creep = annex_b_shrink_and_creep.annex_B_creep(
+    """Test that phi returns expected values."""
+    creep = annex_b_shrink_and_creep.phi(
         test_h_0, test_f_cm, test_RH, test_c_class, test_t0, test_t
     )
-    assert pytest.approx(creep, 0.001) == expected
+    assert math.isclose(creep, expected, abs_tol=1e-3)
 
 
 @pytest.mark.parametrize(
     'test_h_0, test_f_cm, test_c_class, test_RH, test_t_S, test_t, expected',
     [
-        (138.5, 43, 'R', 50, 28, 18263, 0.00065817),
-        (136.8, 38, 'N', 55, 28, 18263, 0.00048427),
+        (138.5, 43, 'R ', 50, 28, 18263, 0.00065817),
+        (138.5, 43, 'r', 50, 28, 18263, 0.00065817),
+        (600.0, 43, 'N', 50, 28, 18263, 0.00038040),
+        (600.0, 43, 'n', 50, 28, 18263, 0.00038040),
+        (500.0, 43, 'N', 50, 28, 18263, 0.00038040),
+        (136.8, 38, 'N ', 55, 28, 18263, 0.00048427),
+        (100.0, 38, 'N', 55, 28, 18263, 0.00050943),
+        (90.0, 38, 'N', 55, 28, 18263, 0.00050943),
+        (136.8, 28, 'N', 55, 28, 18263, 0.00051442),
     ],
 )
 def test_shrinkage_returns_expected_values(
     test_h_0, test_f_cm, test_c_class, test_RH, test_t_S, test_t, expected
 ):
-    """Test that annex_B_Shrinkage returns expected values."""
-    shrinkage = annex_b_shrink_and_creep.annex_B_shrinkage(
+    """Test that eps_cs returns expected values."""
+    shrinkage = annex_b_shrink_and_creep.eps_cs(
         test_h_0, test_f_cm, test_c_class, test_RH, test_t_S, test_t
     )
-    assert pytest.approx(shrinkage, 0.001) == expected
+    assert math.isclose(shrinkage, expected, abs_tol=1e-6)
+
+
+invalid_cement_classes = pytest.mark.parametrize(
+    'cement_class',
+    [
+        'not a valid class',
+        'rns',
+    ],
+)
+
+
+@invalid_cement_classes
+def test_creep_wrong_cement_class(cement_class):
+    """Test that ValueError is raised if a wrong cement class is provided."""
+    with pytest.raises(ValueError):
+        annex_b_shrink_and_creep.phi(300, 38, 50, cement_class)
 
 
-if __name__ == '__main__':
-    test_shrinkage_returns_expected_values()
-    test_creep_returns_expected_values()
+@invalid_cement_classes
+def test_shrinkage_wrong_cement_class(cement_class):
+    """Test that ValueError is raised if a wrong cement class is provided."""
+    with pytest.raises(ValueError):
+        annex_b_shrink_and_creep.eps_cd_0(cement_class, 38, 50)
diff --git a/tests/test_ec2_2004/test_ec2_2004_shear.py b/tests/test_ec2_2004/test_ec2_2004_shear.py
index 5b8b1e4e..3ba5d046 100644
--- a/tests/test_ec2_2004/test_ec2_2004_shear.py
+++ b/tests/test_ec2_2004/test_ec2_2004_shear.py
@@ -132,7 +132,7 @@ def test_VRdc(fck, d, Asl, bw, Ned, Ac, k1, gamma_c, expected):
 def test_Vrdc_prin_stress(Iy, bw, S, fctd, NEd, Ac, L_x, L_pt2, expected):
     """Test Vrdc_prin_stress function."""
     assert math.isclose(
-        shear.Vrdc_prin_stress(Iy, bw, S, fctd, NEd, Ac, L_x, L_pt2),
+        shear.VRdc_prin_stress(Iy, bw, S, fctd, NEd, Ac, L_x, L_pt2),
         expected,
         rel_tol=1e-2,
     )
diff --git a/tests/test_ec2_2023/test_ec2_2023_section5_materials.py b/tests/test_ec2_2023/test_ec2_2023_section5_materials.py
index 2307eb5f..60f92530 100644
--- a/tests/test_ec2_2023/test_ec2_2023_section5_materials.py
+++ b/tests/test_ec2_2023/test_ec2_2023_section5_materials.py
@@ -465,25 +465,6 @@ def test_alpha_c_th():
     )
 
 
-@pytest.mark.parametrize(
-    'ductility_class, expected_k, expected_eps_uk',
-    [('A', 1.05, 0.025), ('B', 1.08, 0.05), ('C', 1.25, 0.075)],
-)
-def test_r_steel_stress_strain_params(
-    ductility_class, expected_k, expected_eps_uk
-):
-    """Test r_steel_stress_strain retuns proper values."""
-    params = _section5_materials.r_steel_stress_strain_params(ductility_class)
-    assert math.isclose(params[0], expected_k, rel_tol=10e-5)
-    assert math.isclose(params[1], expected_eps_uk, rel_tol=10e-5)
-
-
-def test_r_steel_stress_strain_params_raises_errors():
-    """Test r_steel_stress_strain_params raises errors."""
-    with pytest.raises(ValueError):
-        _section5_materials.r_steel_stress_strain_params('asdf')
-
-
 def test_Es():
     """Test Es function."""
     assert math.isclose(_section5_materials.Es(), 200000, rel_tol=10e-5)
@@ -727,4 +708,4 @@ def test_k_sargin(Ecm, fcm, epsc1, expected):
 def test_k_sargin_raises_errors(Ecm, fcm, epsc1):
     """Test k_sargin raises errors."""
     with pytest.raises(ValueError):
-        _section5_materials.k_sargin(_Ecm=Ecm, _fcm=fcm, _eps_c1=epsc1)
+        _section5_materials.k_sargin(Ecm=Ecm, fcm=fcm, eps_c1=epsc1)
diff --git a/tests/test_mc2010/test_mc2010_creep_and_shrinkage.py b/tests/test_mc2010/test_mc2010_creep_and_shrinkage.py
index c4d02682..ca16f53d 100644
--- a/tests/test_mc2010/test_mc2010_creep_and_shrinkage.py
+++ b/tests/test_mc2010/test_mc2010_creep_and_shrinkage.py
@@ -275,10 +275,10 @@ def test_eps_cds(_eps_cds0, _beta_ds, _beta_rh, expected):
         (28, '52.5 R', -3.426412e-5),
     ],
 )
-def test_eps_cas0(fcm, cem_class, expected):
-    """Test eps_cas0 function."""
+def test_eps_cbs0(fcm, cem_class, expected):
+    """Test eps_cbs0 function."""
     assert np.isclose(
-        _concrete_creep_and_shrinkage.eps_cas0(fcm, cem_class),
+        _concrete_creep_and_shrinkage.eps_cbs0(fcm, cem_class),
         expected,
         rtol=1e-5,
         atol=1e-10,
@@ -298,25 +298,25 @@ def test_eps_cas0(fcm, cem_class, expected):
         ),
     ],
 )
-def test_beta_as(time, expected):
-    """Test beta_as function."""
+def test_beta_bs(time, expected):
+    """Test beta_bs function."""
     assert np.isclose(
-        _concrete_creep_and_shrinkage.beta_as(time), expected, rtol=1e-5
+        _concrete_creep_and_shrinkage.beta_bs(time), expected, rtol=1e-5
     ).all()  # all() is to test numpy array.
 
 
 @pytest.mark.parametrize(
-    '_eps_cas0, _beta_as, expected',
+    '_eps_cbs0, _beta_bs, expected',
     [
         (-3.997481e-5, 0.181269, -7.246194e-6),
         (-4.568550e-5, 0.468714, -2.141343e-5),
         (-3.426412e-5, 0.998208, -3.420272e-5),
     ],
 )
-def test_eps_cas(_eps_cas0, _beta_as, expected):
-    """Test eps_cas function."""
+def test_eps_cbs(_eps_cbs0, _beta_bs, expected):
+    """Test eps_cbs function."""
     assert np.isclose(
-        _concrete_creep_and_shrinkage.eps_cas(_eps_cas0, _beta_as),
+        _concrete_creep_and_shrinkage.eps_cbs(_eps_cbs0, _beta_bs),
         expected,
         rtol=1e-5,
         atol=1e-10,
diff --git a/tests/test_mc2010/test_mc2010_material_properties.py b/tests/test_mc2010/test_mc2010_material_properties.py
index b2672be6..43e681de 100644
--- a/tests/test_mc2010/test_mc2010_material_properties.py
+++ b/tests/test_mc2010/test_mc2010_material_properties.py
@@ -142,10 +142,10 @@ def test_Gf(test_input, expected):
         (20, 'SANDSTONE', 21500, 18961.8),
     ],
 )
-def test_E_ci(_fcm, agg_type, EC0, expected):
-    """Test E_ci function."""
+def test_Eci(_fcm, agg_type, EC0, expected):
+    """Test Eci function."""
     assert np.isclose(
-        _concrete_material_properties.E_ci(_fcm, agg_type, EC0),
+        _concrete_material_properties.Eci(_fcm, agg_type, EC0),
         expected,
         rtol=1e-5,
     )
@@ -194,7 +194,7 @@ def test_beta_e(beta_cc, expected):
 
 
 @pytest.mark.parametrize(
-    '_beta_e, _E_ci, expected',
+    '_beta_e, _Eci, expected',
     [
         (0.8799, 27088.3, 23835.0),
         (0.9658, 34129.1, 32961.9),
@@ -202,10 +202,10 @@ def test_beta_e(beta_cc, expected):
         (1.0315, 32506.0, 33529.9),
     ],
 )
-def test_E_ci_t(_beta_e, _E_ci, expected):
-    """Test E_ci_t function."""
+def test_E_ci_t(_beta_e, _Eci, expected):
+    """Test Eci_t function."""
     assert np.isclose(
-        _concrete_material_properties.E_ci_t(_beta_e, _E_ci),
+        _concrete_material_properties.Eci_t(_beta_e, _Eci),
         expected,
         rtol=1e-5,
     )