chloride
Summary
Analytical solution of Fick’s second law under the advection zone,
modified with material property and exposure environment.
Resistance: critical chloride content
Load: chloride content at rebar depth
limit-state: chloride content at rebar depth >= critical chloride content
Field data: chloride content profile
Future TODO: make t input vectorized.
- chloride.A_t(t, pars)[source]
Calculate A_t considering the ageing effect.
- Parameters:
t (int or float) – Time [year].
pars (instance of param object) –
A wrapper of all material and environmental parameters deep-copied from the raw data.
- pars.concrete_typestring
Option:
’Portland cement concrete’,
’Portland fly ash cement concrete’,
’Blast furnace slag cement concrete’
- Returns:
Subfunction considering the “ageing” [-].
- Return type:
numpy array
Note
- Built-in parameters
pars.k_t : transfer parameter, k_t =1 was set for experiment [-] pars.t_0 : reference point of time, 0.0767 [year]
- chloride.C_S_0(pars)[source]
Return (surface) chloride saturation concentration C_S_0 [wt.-%/cement] caused by C_eqv [g/l].
- Parameters:
pars.C_eqv (float) – calculated with by C_eqv(pars) [g/L]
pars.C_eqv_to_C_S_0 (global function) –
This function is based experiment with the info of
binder-specific chloride-adsorption-isotherms the concrete composition(cement/concrete ratio) potential chloride impact C_eqv [g/L]
- Returns:
chloride saturation concentration C_S_0 [wt.-%/cement]
- Return type:
float
Note
The conversion function C_eqv_to_C_S_0(pars.C_eqv) is derived from experiment data of 300kg cement w/c=0.5 OPC. TODO: update to a conversion function dependent on the proportioning and cementitious material
- chloride.C_S_dx(pars)[source]
Return the substitute chloride surface concentration, i.e. chloride content just below the advection zone.
- Parameters:
pars (object/instance of param class) – contains material and environment parameters
pars.C_S_0 (float or numpy array) – chloride saturation concentration C_S_0 [wt.-%/cement] built-in calculation with C_S_0(pars)
pars.C_max (float) – maximum content of chlorides within the chloride profile, [wt.-%/cement] built-in calculation with C_max(pars)
pars.exposure_condition (string) – continuous/intermittent exposure - ‘submerged’,’leakage’, ‘spray’, ‘splash’
pars.exposure_condition_geom_sensitive (bool) – if True, the C_max is used instead of C_S_0
- Returns:
C_S_dx, the substitute chloride surface concentration [wt.-%/cement]
- Return type:
float or numpy arrays
Note
Fick’s 2nd law applies below the advection zone (depth=dx). No advection effect when dx = 0. Conditions considered: continuous/intermittent exposure - ‘submerged’, ‘leakage’, ‘spray’, ‘splash’ where C_S_dx = C_S_0. The advection depth dx is calculated in the dx() function externally.
If exposure_condition_geom_sensitive is True, the observed/empirical highest chloride content in concrete C_max is used. C_max is calculated by C_max().
- chloride.C_crit_param()[source]
Return the beta distribution parameters for the critical chloride content(total chloride), C_crit [wt.-%/cement]
- Returns:
parameters of general beta distribution (mean, std, lower_bound, upper_bound)
- Return type:
tuple
- chloride.C_eqv(pars)[source]
Calculate equivalent chloride solution concentration, C_eqv[g/L] as a measurement of the Potential chloride impact from the source of
marine or coastal and/or
de icing salt
It is later used to estimate the boundary condition C_S_dx of contineous exposure or non-geometry-sensitive intermittent exposure
- Parameters:
pars (instance of the param object) – a wrapper of all material and environmental parameters deep-copied from the raw data See Note for details
- Returns:
C_eqv, equivalent chloride solution concentration [g/L]
- Return type:
float
Note
marine or coastal
pars.C_0_M : natural chloride content of sea water [g/l]
de-icing salt
pars.C_0_R : average chloride content of the chloride contaminated water [g/l] pars.n : average number of salting events per year [-] pars.C_R_i : average amount of chloride spread within one spreading event [g/m2] pars.h_S_i : amount of water from rain and melted snow per spreading period [l/m2]
C_eqv is used for continuous exposure or non-geometry-sensitive intermittent exposure. For geometry-sensitive conditions (roadside splash), the tested C_max() should be used.
- chloride.C_eqv_to_C_S_0(C_eqv)[source]
Convert aqueous solution chloride content to saturated chloride content in concrete interpolate function for 300kg cement w/c=0.5 OPC. Other empirical function should be used if available
- Parameters:
C_eqv (float) – chloride content of the solution at the surface[g/L]
- Returns:
saturated chloride content in concrete[wt-%/cement]
- Return type:
float
- chloride.C_max(pars)[source]
Calculate C_max: maximum content of chlorides within the chloride profile [wt.-%/cement]. It is calculated from empirical equations or from test data [wt.-%/concrete].
- Parameters:
pars (object/instance of param class) –
parameters. (Contains material and environment) –
pars.cement_concrete_ratio (float) – cement/concrete weight ratio, used to convert [wt.-%/concrete] -> [wt.-%/cement]
pars.C_max_option (string) – Option for determining C_max: - “empirical” - use empirical equation. - “user_input” - use user input from test.
pars.x_a (float) – “empirical” option: horizontal distance from the roadside [cm]
pars.x_h (float) – “empirical” option: height above road surface [cm]
pars.C_max_user_input (float) – “user_input” option: Experiment-tested maximum chloride content [wt.-%/concrete]
- Returns:
C_max, maximum content of chlorides within the chloride profile, [wt.-%/cement]
- Return type:
float
Note
The empirical expression should be determined for structures of different exposure or concrete mix. A typical C_max used by default in this function is from
location: urban and rural areas in Germany
time of exposure of the considered structure: 5-40 years
concrete: CEM I, w/c = 0.45 up to w/c = 0.60,
- class chloride.ChlorideModel(pars_raw)[source]
Bases:
object
- calibrate(t, chloride_content_field, print_proc=False, plot=True)[source]
Return a calibrated model with calibrate_chloride_f_group() function.
- Parameters:
t (int or float) – Time [year].
chloride_content_field (pandas DataFrame) – Field chloride contents at various depths [wt.-%/cement].
print_proc (bool, optional) – If True, print the optimization process, by default False.
plot (bool, optional) – If True, plot the field vs model comparison, by default True.
- Returns:
A new calibrated model with the averaged calibrated D_RCM_0.
- Return type:
- chloride_with_year(depth, year_lis, plot=True, amplify=1)[source]
Run the model for a list of time steps.
- Parameters:
depth (float) – Depth at which the chloride concrete is calculated, x [mm].
year_list (list of int or float) – A list of time steps [year].
plot (bool, optional) – If True, plot the R-S curve, pf, beta with time axis, by default True.
amplify (int, optional) – A scale parameter adjusting the height of the distribution curve, by default 1.
- Returns:
numpy array – Probability of failure (Pf) for each time step.
numpy array – Reliability factor (beta) for each time step.
- chloride.D_RCM_0(pars)[source]
Return the chloride migration coefficient from Rapid chloride migration test [m^2/s] see NT Build 492 if the test data is not available from pars, use interpolation of existing empirical data for orientation purpose Pay attention to the units output [mm^2/year], used for the model
- Parameters:
pars (instance of param object) – a wrapper of all material and environmental parameters deep-copied from the raw data
pars.D_RCM_test (int or float) – RCM test results[m^2/s], the mean value from the test is used, and standard deviation is estimated based on mean
pars.option.choose (bool) – If true interpolation from existing data table is used
pars.option.df_D_RCM_0 (pandas.DataFrame) – Experimental data table(cement type, and w/c eqv) for interpolation
pars.option.cement_type (string) –
Select cement type for data interpolation of the df_D_RCM_0, Options: ‘CEM_I_42.5_R’
’CEM_I_42.5_R+FA’
’CEM_I_42.5_R+SF’
’CEM_III/B_42.5’
pars.option.wc_eqv (float) – equivalent water cement ratio considering supplementary cementitious materials
- Returns:
D_RCM_0_final [mm^2/year].
- Return type:
numpy array
- chloride.D_app(t, pars)[source]
Calculate the apparent coefficient of chloride diffusion through concrete D_app[mm^2/year]
- Parameters:
t (float, int) – time [year]
pars (instance of param object) – a wrapper of all material and environmental parameters deep-copied from the raw data
- Returns:
sample of the distribution of the apparent coefficient of chloride diffusion through concrete [mm^2/year]
- Return type:
numpy array
Note
intermediate parameters calculated and attached to pars
k_e : environmental transfer variable [-] D_RCM_0 : chloride migration coefficient [mm^2/year] k_t : transfer parameter, k_t =1 was set in A_t()[-] A_t : subfunction considering the ‘ageing’ [-]
- chloride.calibrate_chloride_f(model_raw, x, t, chloride_content, tol=1e-15, max_count=50, print_out=True, print_proc=False)[source]
Calibrate the chloride model with field chloride test data (at one depth and at one time) and return the new calibrated model object/instance
- Parameters:
model_raw (object/instance of Chloride_model class (to be calibrated)) –
x (float) – depth [mm]
t (: int or float) – time [year]
chloride_content (float or int) – field chloride_content[wt.-%/cement] at time t, depth x,
tol (float) – D_RCM_0 optimization absolute tolerance 1e-15 [m^2/s]
max_count (int) – maximum number of searching iteration, default is 50
print_out (bool) – if true, print model and field chloride content
print_proc (bool) – if turn, print optimization process. (debug message in the logger)
- Returns:
new calibrated model
- Return type:
instance of Chloride_Model object
Note
Optimization method: Field chloride content at depth x and time t -> find corresponding D_RCM_test and then update D_RCM_0(repaid chloride migration diffusivity[m^2/s]) in the model.run()
calibrate model to field data at three depths in calibrate_chloride_f_group() chloride_content_field[wt.-%/cement] at time t
optimizing corresponding D_RCM_test,
fixed C_S_dx (exposure type dependent)
fixed dx (determined by the original model)
- chloride.calibrate_chloride_f_group(model_raw, t, chloride_content_field, plot=True, print_proc=False)[source]
Use calibrate_chloride_f() to calibrate model to field chloride content at three or more depths, and return the new calibrated model with the averaged D_RCM_0
- Parameters:
model_raw (object/instance of Chloride_Model class) – model object to be calibrated), model_raw.copy() will be used
chloride_content_field (pandas.DataFrame) – contains field chloride contents at various depths [wt.-%/cement]
t (int or float) – time [year]
- Returns:
a new calibrated model with the averaged calibrated D_RCM_test, and corresponding D_RCM_0 normal distribution array.
- Return type:
object/instance of Chloride_model class
- chloride.chloride_content(x, t, pars)[source]
Calculate the chloride content at depth x and time t with Fick’s 2nd law below the advection zone (x > dx).
Caution: The pars instance is mutable, so a deepcopy of the original instance should be used if the calculation is not intended for “inplace”.
- Parameters:
x (float or int) – Depth at which chloride content C_x_t is reported [mm].
t (float or int) – Time [year].
pars (param object) – An instance of the Param class, containing material and environmental parameters.
- Returns:
Sample of the distribution of the chloride content in concrete at a depth x (surface x=0) at time t [wt-.%/c]
- Return type:
numpy array
Note
Intermediate parameters are calculated and attached to pars:
C_0 : initial chloride content of the concrete [wt-.%/cement] C_S_dx : chloride content at a depth dx and a certain point of time t [wt-.%/cement] dx : depth of the advection zone (concrete layer, up to which the process of chloride penetration differs from Fick’s 2nd law of diffusion) [mm] D_app : apparent coefficient of chloride diffusion through concrete [mm^2/year] erf : imported error function
- chloride.chloride_year(model, depth, year_lis, plot=True, amplify=80)[source]
Run the model over a list of time steps.
- Parameters:
model (instance of ChlorideModel class) – The chloride model to run.
depth (float) – Depth [mm].
year_list (list of int or float) – List of time steps [years].
plot (bool, optional) – If True, plot the results, by default True.
amplify (float, optional) – Amplification factor for the plot, by default 80.
- Returns:
list – Probability of failure (Pf) for each time step.
list – Reliability factor (beta) for each time step.
- chloride.dx(pars)[source]
Return dx: advection depth [mm] dependent on the exposure conditions.
- Parameters:
pars (object/instance of param class) – Contains material and environment parameters.
pars.exposure_condition (string) – Exposure condition - ‘splash’, ‘submerged’, ‘leakage’, ‘spray’.
- Returns:
dx, advection depth [mm].
- Return type:
float
Note
The advection depth dx is specific to each exposure condition.
- chloride.k_e(pars)[source]
Calculate the environmental transfer variable k_e [-].
- Parameters:
pars (Param) – An instance of the Param class, containing the following parameters:
pars.T_ref (float) – Standard test temperature 293.[K].
pars.T_real (float) – Temperature of the structural element [K].
pars.b_e (float) – Regression variable [K].
- Returns:
Large sample of the distribution of k_e.
- Return type:
numpy array