corr

DICTIONNAIRE_FLOWER.md

@@ -1,873 +0,0 @@
-# 📖 Dictionnaire du Code Source Flower.jl
-Date de l'analyse : Sun Feb  8 14:15:52 UTC 2026
----
-
-## 📁 Fichier : `./examples/channel_Khalighi2023.jl` (1 fonctions)
-```julia
-24: function f(x,v_inlet,L0)
-```
-
-## 📁 Fichier : `./examples/conservation.jl` (2 fonctions)
-```julia
-89: function momentum(fwdL, gu, gv)
-106: function kinetic_energy(fwdL, gp, gu, gv)
-```
-
-## 📁 Fichier : `./examples/convergence.jl` (5 fonctions)
-```julia
-11: function execute_simulation_step(num, gp, gu, gv, op, phS, phL, sim, phys, time_scheme, bc_dict)
-366: function full_cell_u1(x, t)
-369: function full_cell_A_n(n, L, F1, dx, c0)
-376: function full_cell_u2(x, t, L, D, max_nb_Fourier_series, c0, analytical_dx)
-381: function full_cell_u(x, t, L, D, max_nb_Fourier_series, c0, analytical_dx)
-```
-
-## 📁 Fichier : `./examples/electrolysis_channel.jl` (1 fonctions)
-```julia
-21: function f(x)
-```
-
-## 📁 Fichier : `./examples/electrolysis_concentration.jl` (2 fonctions)
-```julia
-54: function fmax(x,v_inlet_max,L0)
-58: function favg(x,v_inlet_moy,L0)
-```
-
-## 📁 Fichier : `./examples/electrolysis_concentration_cyl.jl` (3 fonctions)
-```julia
-83: function fmax(x,v_inlet_max,L0)
-87: function favg(x,v_inlet_moy,L0)
-91: function zerovel(x,v_inlet_moy,L0)
-```
-
-## 📁 Fichier : `./examples/electrolysis_concentration_growth.jl` (8 fonctions)
-```julia
-102: function fmax(x,v_inlet_max,L0)
-106: function favg(x,v_inlet_moy,L0)
-110: function zerovel(x,v_inlet_moy,L0)
-704: function strtitlefunc(isnap)
-1195: function make_frame(i)
-1379: function make_frame(i)
-1461: function make_frame(i)
-1620: function make_frame_3(i)
-```
-
-## 📁 Fichier : `./examples/gradient_test.jl` (6 fonctions)
-```julia
-20: function plot_grid_figtest!(fig,ax,
-48: function scal_magnitude(phL, phS, gp, gu, gv)
-101: function scal_magnitude_L(ph, gp, gu, gv)
-157: function compute_grad_T_x!(num,grid,grid_u, ph, opC_p)
-174: function compute_grad_T_y!(num,grid, grid_v, ph, opC_p)
-312: function ftest(x,y)
-```
-
-## 📁 Fichier : `./examples/koenig.jl` (1 fonctions)
-```julia
-5: function run_koenig(num, idx, tmp, fwd, s_l, u_x, u_y;
-```
-
-## 📁 Fichier : `./examples/navier-stokes_airfoil.jl` (3 fonctions)
-```julia
-6: function suction_side(x, t)
-10: function pressure_side(x, t)
-14: function naca(n, t)
-```
-
-## 📁 Fichier : `./examples/poisson.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-14: function ∇fx(x, y)
-18: function ∇fy(x, y)
-22: function Δf(x, y)
-32: function regression(x, y, x_reg)
-40: function dirichlet_bcs!(gp, D)
-50: function neumann_bcs!(gp, N)
-65: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./examples/sessile.jl` (1 fonctions)
-```julia
-21: function run_sessile(θe = 90)
-```
-
-## 📁 Fichier : `./examples_optimization/crystal_opt.jl` (2 fonctions)
-```julia
-65: function fg2!(F, G, x, des, opt, num, idx, idxu, idxv, initial_levelset, initial_temperature, basis)
-109: function gradient_based_optimization2(x_desired, x_initial, opt, num, idx, idxu, idxv, des, initial_levelset, initial_temperature, basis;
-```
-
-## 📁 Fichier : `./examples_optimization/mullins_opt.jl` (2 fonctions)
-```julia
-53: function fg2!(F, G, x, des, opt, num, idx, idxu, idxv, initial_levelset, initial_temperature, basis)
-95: function gradient_based_optimization2(x_desired, x_initial, opt, num, idx, idxu, idxv, des, initial_levelset, initial_temperature, basis;
-```
-
-## 📁 Fichier : `./src/bicgstabl_flower.jl` (3 fonctions)
-```julia
-32: function bicgstabl_iterator_flower!(x, A, b, l::Int = 2;
-85: function iterate(it::BiCGStabIterable_Flower, iteration::Int=start(it),norm_type=Inf)
-188: function bicgstabl_flower!(x, A, b, l = 2;
-```
-
-## 📁 Fichier : `./src/common.jl` (27 fonctions)
-```julia
-135: function veci(a, g::Vector{G}, p::Integer) where {G<:Grid}
-245: function smekerka_curvature(u, II, h)
-301: function debug_val(test)
-427: function mean_curvature_interpolated(u, II, h, B, BT, mid)
-441: function interpolated_curvature(grid, II, per_x, per_y)
-513: function get_NB_width_indices_base(n)
-519: function get_NB_width_indices_base1(n)
-583: function fit_order(x, y)
-606: function find_2closest_points(POS, ind, II)
-625: function monitor(header, history, it)
-635: function within_cell(p::Point)
-643: function points2polygon(points)
-742: function get_fresh_cells!(grid, geo, Mm1, indices)
-752: function kill_dead_cells!(T::Matrix, grid, geo)
-762: function kill_dead_cells!(T::Vector, grid, geo)
-773: function kill_dead_cells!(S::SubArray{T,N,P,I,L}, grid, geo) where {T,N,P<:Vector{T},I,L}
-784: function kill_dead_cells!(S::SubArray{T,N,P,I,L}, grid, geo) where {T,N,P<:Array{T,3},I,L}
-796: function init_borders!(T, grid, BC, val=0.0)
-900: function export_all()
-912: function mat_assign!(mat1, mat2)
-930: function mat_assign_T!(mat1, mat2)
-944: function mat_op!(mat1, mat2, op)
-960: function mat_T_op!(mat1, mat2, op)
-979: function $op(A::AbstractSparseMatrix{Tv,Ti}, B::Tv) where {Tv<:Number,Ti}
-988: function $op(B::Tv, A::AbstractSparseMatrix{Tv,Ti}) where {Tv<:Number,Ti}
-1021: function (-)(B::Diagonal{Tv,Vector{Tv}}, A::AbstractSparseMatrix{Tv,Ti}) where {Tv<:Number,Ti}
-1034: function mytime_print(elapsedtime, gctime=0)
-```
-
-## 📁 Fichier : `./src/common_run.jl` (6 fonctions)
-```julia
-5: function indices_extension(grid, LS, inside_ext, periodic_x, periodic_y)
-44: function update_all_ls_data(num, grid, grid_u, grid_v, BC_int, periodic_x, periodic_y, empty = true,one_fluid_model=false)
-96: function update_ls_data(num, grid, grid_u, grid_v, iLS, u, κ, BC_int, bc_int, periodic_x, periodic_y, neighbours, empty = true,one_fluid_model=false)
-136: function update_ls_data_grid(num, grid, LS, u, κ, periodic_x, periodic_y)
-162: function update_stefan_velocity(num, grid, iLS, u, TS, TL, periodic_x, periodic_y, λ, Vmean)
-175: function update_free_surface_velocity(num, grid_u, grid_v, iLS, uD, vD, periodic_x, periodic_y)
-```
-
-## 📁 Fichier : `./src/compute_mass_transfer_rate.jl` (5 fonctions)
-```julia
-1: function compute_mass_transfer_rate_main!(num, grid_p, grid_u, grid_v, op, phL, phS, BC_int, electrolysis, electrolysis_phase_change_case, 
-362: function compute_conservation_mass(num,phL, grid_p, grid_u, grid_v,rho_one_fluid)
-423: function extract_border_capacities_1D(grid, dcap)
-457: function extract_border_capacities_1D_one_fluid(grid_p)
-484: function extract_vec_1D_one_fluid(grid_p,vecx,vecy)
-```
-
-## 📁 Fichier : `./src/contact_line.jl` (7 fonctions)
-```julia
-11: function BC_LS!(grid, u, A, B, rhs, BC)
-115: function update_radius_from_contact_line(num,grid, u, BC)
-178: function BC_LS_interior!(num, grid, grid_u, grid_v, iLS, A, B, rhs, BC_int, periodic_x, periodic_y)
-703: function locate_contact_line!(num, grid, iLS, cl, MIXED, BC_int)
-722: function extend_contact_line!(grid, cl, n_ext)
-756: function extend_contact_line!(grid, LS)
-783: function dynamic_contact_angle(grid)
-```
-
-## 📁 Fichier : `./src/convection.jl` (2 fonctions)
-```julia
-57: function compute_fluxes_upwind(num,u, v, rho_u, rho_v, dx_u, dy_u ,dx_v, dy_v,grid_u,grid_v)
-220: function compute_fluxes_CUI(u, v, rho_u, rho_v, dx_u, dy_u ,dx_v, dy_v,grid_u,grid_v)
-```
-
-## 📁 Fichier : `./src/cutcell.jl` (53 fonctions)
-```julia
-151: function find_radius(grid, LS)
-192: function clip_large_cell!(grid, LS, geo, II, ϵ, neighbours)
-217: function clip_small_cell!(grid, LS, geo, II, ϵ, neighbours)
-243: function empty_cell!(grid, LS, geo, II, neighbours = true)
-267: function clip_cells!(grid, LS, ϵ, ϵwall, neighbours, BC_int)
-480: function clip_A_acc_to_V(grid, grid_u, grid_v, geo, geo_u, geo_v, ϵ, ϵwall, neighbours, BC_int)
-572: function clip_middle_cells!(grid, LS)
-599: function dimensionalize!(grid, geo)
-622: function postprocess_grids1!(num, grid, LS, grid_u, LS_u, grid_v, LS_v, periodic_x, periodic_y, neighbours, empty, BC_int,one_fluid_model)
-674: function postprocess_grids2!(grid::Mesh{Flower.GridCC,Float64,Int64},
-713: function ilp2cap(l, p)
-728: function crossing_2levelsets!(num, grid, LS1, LS2, BC_int)
-1169: function set_A_caps!(capn, LS1, LS2, II, poly1, poly2, p, min_face)
-1209: function set_A_caps_full_mixed!(capn, LS1, LS2, II, poly1, poly2, p, min_face)
-1243: function set_A_caps_double_mixed_full_empty!(capn, capm, LS1, LS2, II, poly1, p)
-1270: function set_A_caps_full_empty!(capn, capm, LS1, LS2, II, poly1, p)
-1299: function set_A_caps_double_mixed_mixed!(capn, capm, LS1, LS2, II, poly1, poly2, p, min_face)
-1325: function set_B_caps!(capn, LS1, LS2, II, B)
-1359: function _marching_squares!(num,grid, LS, u, periodic_x, periodic_y, II, II_0, near_interface)
-1419: function marching_squares!(num,grid, LS, u, periodic_x, periodic_y)
-1487: function get_interface_location!(grid, LS, periodic_x, periodic_y)
-1501: function get_interface_location_borders!(grid::Mesh{GridFCx,T,N}, u, periodic_x) where {T,N}
-1534: function get_interface_location_borders!(grid::Mesh{GridFCy,T,N}, u, periodic_y) where {T,N}
-1570: function get_curvature(num, grid, geoL, u, κ, inside, per_x, per_y)
-1636: function capacities(F_prev, case)
-2095: function set_cap_bcs!(grid::Mesh{GridCC,T,N}, num, LS, periodic_x, periodic_y, empty = true) where {T,N}
-2134: function set_cap_diff_S_L!(num,geoS,geoL,tmpS,tmpL,cap_id,II)
-2150: function set_cap_bcs!(grid::Mesh{GridFCx,T,N}, num, LS, periodic_x, periodic_y, empty = true) where {T,N}
-2311: function set_cap_bcs!(grid::Mesh{GridFCy,T,N}, num, LS, periodic_x, periodic_y, empty = true) where {T,N}
-2468: function Bcapacities(cut_points, sol_centroid, liq_centroid)
-2508: function Wcapacities!(cap, periodic_x, periodic_y)
-2546: function face_capacities(num,grid, faces, itp, case, II_0, II, posW, posS, posE, posN)
-2583: function EAST_face(num,itp, p=Point(0.5,0.0), dy=1.0, dx2=2.0, dy2=2.0) 
-2613: function WEST_face(num,itp, p=Point(-0.5,0.0), dy=1.0, dx2=2.0, dy2=2.0)
-2632: function SOUTH_face(num,itp, p=Point(0.0,-0.5), dx=1.0, dx2=2.0, dy2=2.0)
-2652: function NORTH_face(num,itp, p=Point(0.0,0.5), dx=1.0, dx2=2.0, dy2=2.0) 
-2680: function average_face_capacities(grid, LS, iso, II, per_x, per_y)
-2736: function average_face_capacities!(a, per_x, per_y)
-2789: function get_cells_indices(iso, all)
-2820: function get_cells_indices(iso, all, nx, ny, periodic_x, periodic_y)
-2848: function get_cells_indices(iso, inside, NB_width)
-2880: function get_NB_width(MIXED, NB_indices_base)
-2890: function get_NB_width(grid, MIXED, NB_indices_base)
-2965: function projection_2points(grid, LS, II)
-3047: function kill_dead_cells!(T::Matrix, L, EMPTY, MIXED, n)
-3087: function kill_dead_cells!(T::Vector, L, EMPTY, MIXED, n)
-3104: function init_fresh_cells!(grid, T, projection, FRESH, periodic_x, periodic_y)
-3117: function init_fresh_cells!(grid, T::Vector, projection, FRESH, periodic_x, periodic_y)
-3132: function init_fresh_cells!(grid, u::Matrix, V::Matrix, projection, FRESH, periodic_x, periodic_y)
-3145: function init_fresh_cells!(grid, u::Vector, V, projection, FRESH, periodic_x, periodic_y)
-3160: function init_fresh_cells!(grid, u::SubArray{T,N,P,I,L}, V, projection, FRESH, periodic_x, periodic_y) where {T,N,P<:Vector{T},I,L}
-3178: function x_extrapolation(T_1, T_2, p1, p2, pnew)
-3184: function y_extrapolation(T_1, T_2, p1, p2, pnew)
-```
-
-## 📁 Fichier : `./src/electrolysis.jl` (20 fonctions)
-```julia
-11: function pdi_expose_data(event_name::String, args...)
-34: function interpolate_grid_liquid!(
-60: function interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(
-71: function interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(
-84: function check_divergence!(num, phL)
-97: function convert_interfacial_D_to_segments(
-116: function adapt_timestep!(
-155: function update_electrical_conductivity!(
-174: function compute_grad_phi_ele!(
-185: function solve_poisson_loop!(
-271: function set_convection_2!(
-289: function update_BC_electrical_potential_left!(num, grid, BC_phi_ele, elec_cond, elec_condD, i_butler)
-295: function veci(arr, grid, iLS)
-302: function vecb_L(arr, grid) return arr[1:grid.ny] end
-303: function vecb_R(arr, grid) return arr[end-grid.ny+1:end] end
-304: function vecb_B(arr, grid) return arr[1:grid.nx:end] end 
-305: function vecb_T(arr, grid) return arr[grid.nx:grid.nx:end] end
-308: function solve_poisson_variable_coeff!(args...) end
-309: function update_electrical_current_from_Butler_Volmer_func!(args...; kwargs...) end
-310: function handle_special_cells_electrical_potential!(args...) end
-```
-
-## 📁 Fichier : `./src/electrolysis_2.jl` (11 fonctions)
-```julia
-16: function butler_volmer_concentration(alpha_a,alpha_c,c_H2,c0_H2,c_H2O,c0_H2O,c_KOH,c0_KOH,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0)
-35: function butler_volmer_no_concentration(alpha_a,alpha_c,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0)
-54: function derivative_butler_volmer_no_concentration(alpha_a,alpha_c,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0)
-69: function butler_volmer_no_concentration!(alpha_a,alpha_c,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0,i_current)
-84: function butler_volmer_no_concentration_concentration_Neumann!(alpha_a,alpha_c,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0,diffusion_coeff,inv_stoechiometric_coeff,a0)
-99: function butler_volmer_no_concentration_concentration_Neumann(alpha_a,alpha_c,Faraday,i0,phi_ele,phi_ele1,Ru,temperature0,diffusion_coeff,inv_stoechiometric_coeff)
-110: function electrical_conductivity!(num,concentration,temperature,elec_cond)
-122: function butler_volmer_no_concentration_potential_Neumann!(num,phi_eleD,concentration,temperature,a0)
-135: function butler_volmer_no_concentration_potential_Neumann(num,phi_eleD,concentration,temperature)
-149: function butler_volmer_no_concentration_potential_Neumann_no_struct!(i0,alpha_a,alpha_c,Faraday,phi_ele1,phi_eleD,Ru,diffusion_coeff,concentration,temperature)
-159: function compute_ele_cond(Faraday,diffusion_coeff,Ru,temperature,concentration)
-```
-
-## 📁 Fichier : `./src/electrolysis_3.jl` (1 fonctions)
-```julia
-98: function set_poisson_variable_coeff_no_interpolation!(num::Numerical{Float64, Int64},
-```
-
-## 📁 Fichier : `./src/electrolysis_init.jl` (3 fonctions)
-```julia
-4: function Poiseuille_fmax(x,v_inlet_max,L0)
-9: function Poiseuille_favg(x,v_inlet_moy,L0)
-14: function test_Poiseuille(num,velD,grid_v)
-```
-
-## 📁 Fichier : `./src/electrolysis_operators.jl` (10 fonctions)
-```julia
-9: function compute_grad_T_x_T_y_array!(num_LS, grid, grid_u, grid_v, opC_p, grad_x, grad_y, TD)
-31: function compute_grad_T_x_T_y_array_u_v_capacities!(num, grid, grid_u, grid_v, opC_u, opC_v, grad_x, grad_y, TD)
-74: function compute_grad_T_x_T_y_array_u_v_capacities_cell_integrated!(num, grid, grid_u, grid_v, opC_u, opC_v, grad_x, grad_y, TD)
-116: function compute_grad_T_x_array!(num_LS, grid, grid_u, opC_p, grad_x, TD)
-133: function compute_grad_T_y_array!(num_LS, grid, grid_v, opC_p, grad_y, TD)
-200: function integrate_mass_transfer_rate_over_interface(num::Numerical{Float64, Int64},
-411: function integrate_mass_transfer_rate_over_interface_old(num::Numerical{Float64, Int64},
-578: function integrate_mass_transfer_rate_over_interface_no_writing(num::Numerical{Float64, Int64},
-738: function integrate_mass_transfer_rate_over_interface_2(num::Numerical{Float64, Int64},
-903: function integrate_mass_transfer_rate_over_interface_2_no_writing(num::Numerical{Float64, Int64},
-```
-
-## 📁 Fichier : `./src/electrolysis_plot.jl` (17 fonctions)
-```julia
-43: function strtitlefunc(isnap,fwd)
-50: function plot_current_wall()
-135: function plot_bc(iter_list,vec,grid,xscale,figname,prefix,fwd)
-162: function plot_bc2(iter_list,vec,grid,xscale,figname,prefix,fwd)
-189: function plot_python_pdf(itmp,field0,figname,prefix,plot_levelset,isocontour,plot_grid,plot_mode,levels,range,cmap,x_array,y_array,gp,cbarlabel,i0,i1,j0,j1,fwd)
-349: function plot_python_pdf_full2(itmp,field0,field0D,figname,prefix,plot_levelset,isocontour,plot_grid,plot_mode,levels,range,cmap,x_array,y_array,gp,cbarlabel,ii0,ii1,jj0,jj1,fwd,fwdL,xscale,fontsize,printmode,plotcase,num,plotbc)
-659: function python_movie_zoom(field0,figname,prefix,plot_levelset,isocontour,plot_mode,levels,range,cmap,x_array,y_array,gp,cbarlabel,size_frame,i0,i1,j0,j1,fwd)
-720: function make_frame(i)
-838: function plot_electrolysis_velocity!(num, grid, LS, V, TL, MIXED, periodic_x, periodic_y, concentration_scal_intfc)
-915: function plot_python_bc(num,x_array,y_array,field,figname,prefix,grid)
-999: function plot_last_iter_python_pdf(field,figname,prefix,plot_levelset,isocontour,levels,range,cmap,x_array,y_array,gp,cbarlabel)
-1065: function debug_border_top(iplot,jplot,A,B,rhs,geo,inside,ind,grid,bc,iscal,num,op,ni,nb,ph,Bx,By)
-1123: function debug_border_left(iplot,jplot,A,B,rhs,geo,inside,ind,grid,bc,iscal,num,op,ni,nb,ph,Bx,By)
-1168: function scalar_debug_border(cap, n, BC, inside, ind,num,grid,iplot,jplot,op)
-1297: function scalar_debug!(::Dirichlet, O, B, u, v, Dx, Dy, Du, Dv, cap, n, BC, inside, b_left, b_bottom, b_right, b_top,num,grid,iplot,jplot)
-1525: function plot_radial_vel()
-1569: function plot_vector()
-```
-
-## 📁 Fichier : `./src/electrolysis_print.jl` (5 fonctions)
-```julia
-22: function print_BC_LS_html(BC,name;io=stdout)
-28: function print_BC_html(BC,name;io=stdout)
-34: function print_BC_line(BC)
-39: function print_BC(BC)
-44: function typeofBC(BC)
-```
-
-## 📁 Fichier : `./src/electrolysis_tests.jl` (4 fonctions)
-```julia
-5: function test_laplacian_pressure(num,grid_v,vD, opC_p, Lv, bc_Lv, bc_Lv_b)
-48: function test_LS(grid)
-69: function FE_set_momentum_debug(
-185: function pressure_projection_debug!(
-```
-
-## 📁 Fichier : `./src/electrolysis_utils.jl` (17 fonctions)
-```julia
-4: function average!(T::Matrix, grid, geo,num)
-31: function get_height!(LS,ind,dx,dy,geo,H)
-106: function init_Neumann_iLS(num,TD,BC,grid,dir_val_intfc,iLS)
-199: function init_fields_multiple_levelsets!(num,TD,T,H,BC,grid,dir_val_intfc,str)
-316: function mean_intfc_non_null(scalD,iscal,grid,iLS)
-345: function mean_intfc_non_null_v2(scalD,grid,iLS)
-375: function mean_intfc_non_null_v3(scalD,grid,index)
-420: function scal_magnitude(phL, phS, gp, gu, gv)
-475: function scal_magnitude_L(ph, gp, gu, gv)
-504: function relative_errors(T, Tanalytical, pos, cap, h)
-587: function relative_errors_interface(T, Tanalytical, pos, cap, h)
-632: function compute_interface_average(num,scalar_1D_vec, grid, iLS)
-725: function compute_bulk_or_interface_average(scalar_1D_vec, grid, iLS)
-782: function find_sign_changes(slice::AbstractVector)
-818: function compute_bubble_drop_radius(num, grid_p)
-935: function compute_radius_from_levelset_slice(
-1015: function find_slice_coord_bubble_mass_center(center_of_mass_x,center_of_mass_y,num,grid_p)
-```
-
-## 📁 Fichier : `./src/electrolysis_viz.jl` (2 fonctions)
-```julia
-7: function plot_grid_fig!(fig,ax,
-53: function make_video_vec(
-```
-
-## 📁 Fichier : `./src/fill_struct.jl` (4 fonctions)
-```julia
-8: function safefill(T; sources=(;), defaults=nothing)
-35: function safefill_with_aliases(::Type{Numerical{T,D}}, sim, phys, io,aliases) where {T<:Real, D<:Integer}
-59: function safefill_with_aliases_and_extra(::Type{Numerical{T,D}}, sim, phys, io, aliases, extra) where {T<:Real, D<:Integer}
-79: function safefill_with_aliases_and_extra_already_init(::Type{Numerical{T,D}}, default,sim, phys, io, aliases, extra) where {T<:Real, D<:Integer}
-```
-
-## 📁 Fichier : `./src/heat.jl` (1 fonctions)
-```julia
-1: function Stefan_velocity!(num, grid, LS, V, TS, TL, MIXED, periodic_x, periodic_y)
-```
-
-## 📁 Fichier : `./src/heat_coupled.jl` (2 fonctions)
-```julia
-25: function set_heat_borders!(grid, a0, a1, b, BC_T, per_x, per_y)
-110: function set_heat!(bc_type, num, grid, op, geo, ph, θd, BC_T, MIXED, projection,
-```
-
-## 📁 Fichier : `./src/init.jl` (14 fonctions)
-```julia
-4: function Indices(nx, ny)
-29: function Levelset(nx, ny)
-193: function allocate_ghost_matrices_2(nx0,ny0,nghost)
-255: function Mesh(gridType, x_nodes, y_nodes, nLS)
-287: function init_meshes(num::NumericalParameters)
-303: function init_sparse_Bx(grid)
-328: function init_sparse_By(grid)
-356: function init_sparse_BxT(grid) 
-377: function init_sparse_ByT(grid)
-457: function init_fields(num::NumericalParameters,
-1362: function init_mullins!(grid, T, V, t, A, N, shift)
-1374: function init_mullins2!(grid, T, V, t, A, N, shift)
-1386: function init_franck!(grid, temp, R, T_inf, h)
-1398: function init_smooth(X, Y)
-```
-
-## 📁 Fichier : `./src/interface_transport.jl` (3 fonctions)
-```julia
-5: function advection_u_and_v(grid_p, grid_u, grid_v, iLS, θ_out, num, BC_int, BC_u, rhs_LS, periodic_x, periodic_y)
-26: function compute_normal_component_of_velocity(num,grid_u, grid_v, u, v, grid_p, iLS, II)
-123: function select_advection!(num, grid_p, BC_int, BC_u, grid_u, grid_v, CFL_sc, periodic_x, periodic_y, 
-```
-
-## 📁 Fichier : `./src/levelset.jl` (54 fonctions)
-```julia
-5: function diamond(a, p, n)
-18: function diamond(a, II, nx, ny, per_x, per_y)
-30: function diamond_not_periodic(a, II)
-38: function quadratic_recons(a, U::SArray{Tuple{4},Float64,1,4},
-47: function quadratic_recons(a, U::SArray{Tuple{4},Float64,1,4},
-59: function quadratic_recons_not_periodic(a, U::SArray{Tuple{4},Float64,1,4},
-68: function quadratic_recons(D::SArray{Tuple{4},Float64,1,4})
-73: function normal_grad(a, g,
-84: function normal_grad(a, g,
-94: function normal_grad(a,
-104: function grad(a, g,
-115: function grad(a, g,
-125: function grad(a, g,
-138: function grad_not_periodic(a, g,
-148: function grad_IIOE(a, gx, gy,
-159: function grad_IIOE(a, gx, gy,
-169: function advection(a, gx, gy,
-179: function advection(gx, gy,
-189: function θout(a_out, u, umax, umin, II, timestep_n, nx, ny, mp, per_x, per_y)
-213: function θin(θ_out, nx, ny, per_x, per_y, II)
-232: function inflow_outflow(F::SArray{Tuple{4},Float64,1,4})
-244: function sumloc(a_in::SArray{Tuple{4},Float64,1,4},
-251: function sumloc(a_in::SizedVector{4,Float64,Vector{Float64}},
-280: function init_ghost_neumann(u,nx,ny,nghost)
-302: function init_ghost_neumann_2(u,nx,ny,nghost)
-327: function IIOE_normal!(grid, A, B, u, V, CFL, periodic_x, periodic_y)
-374: function IIOE_normal_indices!(grid, A, B, u,ughost, V, CFL, periodic_x, periodic_y,indices)
-413: function IIOE_normal_indices_2!(grid, A, B, u,ughost, V, CFL, periodic_x, periodic_y,nghost)
-465: function IIOE!(grid, grid_u, grid_v, A, B, θ_out, timestep_n, periodic_x, periodic_y)
-497: function S2IIOE!(grid, grid_u, grid_v, A, B, utmp, u, θ_out, timestep_n, periodic_x, periodic_y)
-754: function Φeno(a)
-773: function finite_difference_weno5(grid, u, II, nx, ny, dx, dy, per_x, per_y)
-919: function δ0(u, II, ϵ, nx, ny, per_x, per_y)
-927: function δ0_l(u, II, ϵ, nx, ny, per_x, per_y)
-934: function δ0_b(u, II, ϵ, nx, ny, per_x, per_y)
-941: function δ0_r(u, II, ϵ, nx, ny, per_x, per_y)
-948: function δ0_t(u, II, ϵ, nx, ny, per_x, per_y)
-955: function δ0_bl(u, II, ϵ, nx, ny, per_x, per_y)
-961: function δ0_br(u, II, ϵ, nx, ny, per_x, per_y)
-967: function δ0_tl(u, II, ϵ, nx, ny, per_x, per_y)
-973: function δ0_tr(u, II, ϵ, nx, ny, per_x, per_y)
-988: function reinit_min(scheme, grid, u, u0, indices, periodic_x, periodic_y)
-1243: function reinit_rs(scheme, grid, u, u0, indices, periodic_x, periodic_y)
-1408: function reinit_hartmann(scheme, grid, u, u0, indices, periodic_x, periodic_y)
-1595: function FE_reinit!(scheme, grid, ind, u, nb_reinit, periodic_x, periodic_y, BC)
-1624: function RK2_reinit!(scheme, grid, ind, iLS, u, nb_reinit, periodic_x, periodic_y, BC, BC_int, solid=false)
-1672: function rg(num, grid, u, periodic_x, periodic_y, BC_int)
-1771: function field_extension!(grid, u, f, indices_ext, left_ext, bottom_ext, right_ext, top_ext, NB, periodic_x, periodic_y)
-1936: function aux_interpolate_scalar!(II_0, II, u, x, y, dx, dy, u_faces)
-1995: function interpolate_scalar!(grid, grid_u, grid_v, u, uu, uv)
-2073: function breakup_n(u, nx, ny, dx, dy, periodic_x, periodic_y, NB_indices, ϵ_break)
-2102: function breakup_f(grid, u, idx)
-2154: function combine_levelsets!(num, grid)
-2169: function combine_levelsets(grid, u1, u2)
-```
-
-## 📁 Fichier : `./src/navier_stokes_coupled.jl` (33 fonctions)
-```julia
-15: function set_borders!(grid, cl, u, a0, a1, b, BC, n_ext)
-199: function update_dirichlet_field!(grid, bv, v, BC)
-269: function set_cutcell_matrices!(num, grid, geo, geo_p, opC, periodic_x, periodic_y)
-332: function set_other_cutcell_matrices!(
-358: function set_boundary_indicator!(grid::Mesh{GridCC,T,N}, geo, geo_p, opC) where {T,N}
-386: function set_boundary_indicator!(grid::Mesh{GridFCx,T,N}, geo, geo_p, opC) where {T,N}
-414: function set_boundary_indicator!(grid::Mesh{GridFCy,T,N}, geo, geo_p, opC) where {T,N}
-441: function set_border_matrices!(num,
-485: function laplacian(opC::Operators{Float64, Int64})
-503: function laplacian_bc(opC::Operators{Float64, Int64}, nLS::Int64)
-536: function set_matrices!(
-602: function strain_rate(iLS, opC_u, opC_v, opC_p)
-617: function no_slip_condition!(num, grid, grid_u, LS_u, grid_v, LS_v, periodic_x, periodic_y)
-649: function set_convection!(
-802: function FE_set_momentum_coupled(
-1436: function set_velocity_boundary_conditions(bc_type, iLS, gu, gv, gp, num)
-1571: function interpolating_coefficient_Navier(gu::Mesh{GridFCx,T,N},gp::Mesh{GridCC,T,N},index_LS,bc_type) where {T,N}
-1622: function interpolating_coefficient_Navier(gu::Mesh{GridFCx,T,N},gp::Mesh{GridCC,T,N},bc_type::Union{Navier{T,N},Navier_cl{T,N}}) where {T,N}
-1692: function interpolating_coefficient_Navier(gv::Mesh{GridFCy,T,N},gp::Mesh{GridCC,T,N},bc_type) where {T,N}
-1737: function interpolating_coefficient_Navier(gv::Mesh{GridFCy,T,N},gp::Mesh{GridCC,T,N},bc_type::Union{Navier{T,N},Navier_cl{T,N}}) where {T,N}
-1809: function interpolating_coefficient_Navier_uv_grids_to_p_grid_volume(num,gp,gu,gv,iLS)
-1848: function interpolating_coefficient_Navier_uv_grids_to_p_grid_height(num,gp,gu,gv,i)
-1891: function CN_set_momentum(
-2019: function FE_set_momentum(
-2137: function FE_set_momentum_old(
-2262: function set_poisson(
-2370: function set_Crank_Nicolson!(
-2496: function set_Forward_Euler!(
-2675: function pressure_projection!(
-3398: function coupled_pressure_velocity!(
-4210: function linear_advection!(
-4278: function residual(u_guess, v_guess, num, grid, geo, grid_u, geo_u, grid_v, geo_v, u, v, op_conv, ph, BC_u, BC_v)
-4319: function dresidual(u_guess, v_guess, res0, eps, num, grid, geo, grid_u, geo_u, grid_v, geo_v, u, v, op_conv, ph, BC_u, BC_v)
-```
-
-## 📁 Fichier : `./src/navier_stokes_coupled_pressure_velocity.jl` (6 fonctions)
-```julia
-30: function FE_set_momentum_coupled2(
-836: function FE_set_momentum_coupled_two_phases(
-1650: function set_first_cells!(A,rhs,grid,start_index,start_index2,left,bottom,right,top)
-1730: function set_first_cells_Neumann!(A,rhs,grid,start_index,start_index2,left,bottom,right,top)
-1826: function deactivate_merge_first_cells_capacities!(num,grid::Mesh{GridFCx, T, N}) where {T,N}
-1845: function deactivate_merge_first_cells_capacities!(num,grid::Mesh{GridFCy, T, N}) where {T,N}
-```
-
-## 📁 Fichier : `./src/one_fluid.jl` (25 fonctions)
-```julia
-4: function update_one_fluid_density_viscosity(num,grid_p,grid_u,grid_v,volume_fraction,levelset_one_fluid,rho_one_fluid,
-155: function harmonic_average_one_fluid(mu1,mu2, volume_fraction)
-159: function average_one_fluid(average_mode,mu1,mu2, volume_fraction)
-175: function bilinear_interpolation(x, y, x1, y1, x2, y2, Q11, Q12, Q21, Q22)
-191: function bilinear_interpolation(grid_p, x, y,values)
-226: function create_2D_grid_x(grid_p,add_x=true,add_y=true)
-294: function create_2D_grid_y(grid_p,add_x=true,add_y=true)
-382: function create_2D_grid_volume_fraction(grid_p,volume_fraction)
-443: function levelset_heavyside(phi, epsilon)
-460: function levelset_to_binary(phi)
-474: function smooth_vof_2d!(grid_p,vof_field, num_smoothings,smoothed_vof)
-566: function compute_fluxes(u, v, rho_u, rho_v, dx_u, dy_u ,dx_v, dy_v,grid_u,grid_v)
-663: function allocate_offset_array(yrange::UnitRange, xrange::UnitRange; init_val=0.0)
-673: function fill_bulk_ghost(uconv,u,grid_u)
-768: function solve_one_fluid_NS!(
-2764: function set_Forward_Euler_one_fluid!(
-3496: function FE_set_momentum_coupled2_one_fluid(
-4382: function check_coupled_matrix()
-4584: function set_convection_with_rho!(
-4732: function vector_convection_with_rho!(::Dirichlet, ::Type{GridFCx}, O, B, u, v, velocity_and_BC_convection_u_x, velocity_and_BC_convection_u_y, velocity_and_BC_convection_v_x, velocity_and_BC_convection_v_y, cap, n, ny, BC, inside, b_left, b_bottom, b_right, b_top)
-4966: function vector_convection_with_rho!(::Dirichlet, ::Type{GridFCy}, O, B, u, v, velocity_and_BC_convection_u_x, velocity_and_BC_convection_u_y, velocity_and_BC_convection_v_x, velocity_and_BC_convection_v_y, cap, n, ny, BC, inside, b_left, b_bottom, b_right, b_top)
-5202: function set_poisson_one_fluid(
-5336: function solve_poisson_one_fluid!(num::Numerical{Float64, Int64},
-5473: function interpolate_interface_velocity!(ph,grid_u,grid_v)
-5489: function set_convection_preallocated!(
-```
-
-## 📁 Fichier : `./src/operators.jl` (43 fonctions)
-```julia
-1: function empty_laplacian(grid, O, empty, MIXED)
-47: function set_bc_bnds(::Dirichlet, D, H, BC)
-99: function laplacian!(::Dirichlet, num, L, B, Dx, Dy, cap, n, BC, inside, empty, MIXED, b_left, b_bottom, b_right, b_top)
-197: function set_bc_bnds(::Neumann, Nx, Ny, BC, dx, dy)
-238: function inv_weight_clip(num,M)
-247: function inv_weight_clip2(epsilon_vol,M)
-259: function inv_weight_eps(num,W)
-269: function inv_weight_eps2(epsilon_mode,epsilon_vol,W)
-279: function inv_weight_diag(num,II,IIbis,n,iMx,Mx)
-305: function laplacian!(::Neumann, num, L, B, Nx, Ny, HNx, HNy, cap, dx, dy, n, BC, inside, empty, MIXED, ns_vec, b_left, b_bottom, b_right, b_top)
-434: function divergence!(::Dirichlet, Ox, Oy, Bx, By, Dx, Dy, cap, n, all_indices)
-461: function set_bc_bnds(::Neumann, HNx, HNy, BC, dx, dy, H)
-508: function gradient!(::Neumann, Ox, Oy, Bx, By, HNx, HNy, Divx, Divy, dcap, n, BC, all_indices, b_left_u, b_bottom_v, b_right_u, b_top_v, b_left_p, b_bottom_p, b_right_p, b_top_p)
-602: function divergence!(::Neumann, Ox, Oy, Bx, By, NHx, NHy, cap, n, all_indices)
-653: function gradient!(::Dirichlet, Ox, Oy, Bx, By, Dx, Dy, Divx, Divy, dcap, n, BC, all_indices, b_left_u, b_bottom_v, b_right_u, b_top_v, b_left_p, b_bottom_p, b_right_p, b_top_p)
-722: function uv_to_p!(Ox, Oy, cap, dx, dy, n, all_indices)
-737: function harmonic_average(W4, W3)
-751: function strain_rate!(::Dirichlet, O11, O12_x, O12_y, O22, cap_x, cap_y, n, all_indices, inside)
-804: function set_bc_bnds(::Dirichlet, Du, Dv, Hu, Hv, u, v, BC_u, BC_v)
-866: function scalar_convection!(::Dirichlet, O, B, u, v, Dx, Dy, Du, Dv, cap, n, BC, inside, b_left, b_bottom, b_right, b_top)
-973: function scalar_convection_CUTCT!(::Dirichlet, B, u, v, 
-1084: function scalar_convection_debug!(::Dirichlet, O, B, u, v, Dx, Dy, Du, Dv, cap, n, BC, inside, b_left, b_bottom, b_right, b_top)
-1315: function set_bc_bnds(::Dirichlet, ::Union{Type{GridFCx},Type{GridFCy}}, Du_x, Du_y, Dv_x, Dv_y, Hu, Hv, u, v, BC_u, BC_v)
-2266: function fill_inside_conv!(::Type{GridFCx}, O, B, u, v, Du, Dv, cap, ny, II)
-2307: function vec_convx_1!(II, O, B, u, Du, Dv, cap, ny)
-2333: function vec_convx_2!(II, O, B, u, Du, Dv, cap, ny)
-2359: function vec_convx_3!(II, O, v, cap, ny)
-2375: function vec_convx_4!(II, O, v, cap, ny)
-2391: function vec_convx_5!(II, O, v, cap, n, ny, BC)
-2412: function vec_convx_6!(II, O, v, cap, n, ny, BC)
-2433: function vec_convx_7!(II, O, v, cap, n, ny, BC)
-2454: function vec_convx_8!(II, O, v, cap, n, ny, BC)
-2479: function vector_convection!(::Dirichlet, ::Type{GridFCx}, O, B, u, v, Du_x, Du_y, Dv_x, Dv_y, cap, n, ny, BC, inside, b_left, b_bottom, b_right, b_top)
-2694: function fill_inside_conv!(::Type{GridFCy}, O, B, u, v, Du, Dv, cap, ny, II)
-2737: function vec_convy_1!(II, O, B, v, Du, Dv, cap, ny)
-2767: function vec_convy_2!(II, O, B, v, Du, Dv, cap, ny)
-2797: function vec_convy_3!(II, O, u, cap, ny)
-2817: function vec_convy_4!(II, O, u, cap, ny)
-2837: function vec_convy_5!(II, O, u, cap, ny, BC)
-2862: function vec_convy_6!(II, O, u, cap, ny, BC)
-2887: function vec_convy_7!(II, O, u, cap, ny, BC)
-2912: function vec_convy_8!(II, O, u, cap, ny, BC)
-2959: function vector_convection!(::Dirichlet, ::Type{GridFCy}, O, B, u, v, Du_x, Du_y, Dv_x, Dv_y, cap, n, ny, BC, inside, b_left, b_bottom, b_right, b_top)
-```
-
-## 📁 Fichier : `./src/operators_coupled.jl` (17 fonctions)
-```julia
-1: function fill_empty_rows!(num, grid, geo, O)
-22: function pad(A, a=1.0)
-36: function pad_crank_nicolson(A, grid, timestep_n)
-85: function divergence_B!(Ox, Oy, dcap, n, all_indices)
-110: function divergence_A!(grid, Ox, Oy, dcap, n, all_indices, per_x, per_y)
-180: function bc_matrix!(grid::Mesh{GridCC,T,N}, Hx, Hy, dcap, dcap_p, n, all_indices) where {T,N}
-239: function bc_matrix!(grid::Mesh{GridFCx,T,N}, Hx, Hy, dcap, dcap_p, n, all_indices) where {T,N}
-297: function bc_matrix!(grid::Mesh{GridFCy,T,N}, Hx, Hy, dcap, dcap_p, n, all_indices) where {T,N}
-356: function bc_matrix!(grid, Hx, Hy, dcap, dcap_u, dcap_v, n, all_indices)
-422: function periodic_bcs!(grid, Gx, Gy, Hx, Hy, periodic_x, periodic_y)
-463: function periodic_bcs_R!(grid, Rx, Ry, periodic_x, periodic_y)
-498: function mass_matrix_borders!(num,ind, iMx_b, iMy_b, iMx_bd, iMy_bd, dcap, n)
-535: function bc_matrix_borders!(grid::Mesh{GridCC,T,N}, ind, Hx, Hy, dcap) where {T,N}
-564: function bc_matrix_borders!(grid::Mesh{GridFCx,T,N}, ind, ind_u, Hx, Hy, dcap, dcap_u) where {T,N}
-594: function bc_matrix_borders!(grid::Mesh{GridFCy,T,N}, ind, ind_v, Hx, Hy, dcap, dcap_v) where {T,N}
-631: function bc_matrix_borders!(grid, Hx_u, Hy_v, Hx_p, Hy_p, dcap)
-678: function periodic_bcs_borders!(grid, Hx, Hy, periodic_x, periodic_y)
-```
-
-## 📁 Fichier : `./src/optimize.jl` (4 fonctions)
-```julia
-1: function cost_functional(u, u_desired, T_all, T_desired, inside, MIXED, BC_indices, γ)
-19: function fg!(F, G, x, des, opt, num, idx, idxu, idxv, initial_levelset, basis)
-65: function gradient_based_optimization(x_desired, x_initial, opt, num, idx, idxu, idxv, initial_levelset, basis;
-98: function cost_functional(fwd, des, opt, idx, num, MIXED)
-```
-
-## 📁 Fichier : `./src/post_processing.jl` (3 fonctions)
-```julia
-4: function calculate_centroid(x, y, volume_cell)
-26: function calculate_circularity(perimeter_bubble, area)
-42: function calculate_rise_velocity(v, volume_cell)
-```
-
-## 📁 Fichier : `./src/run.jl` (1 fonctions)
-```julia
-6: function run_forward!(
-```
-
-## 📁 Fichier : `./src/run_bwd.jl` (1 fonctions)
-```julia
-1: function run_backward(num, grid, opS, opL, fwd, adj;
-```
-
-## 📁 Fichier : `./src/run_profile.jl` (1 fonctions)
-```julia
-1: function profile_run_forward!(
-```
-
-## 📁 Fichier : `./src/solve_one_fluid.jl` (1 fonctions)
-```julia
-86: function solve_one_fluid_NS_no_phase!(
-```
-
-## 📁 Fichier : `./src/surface_tension_LS.jl` (5 fonctions)
-```julia
-5: function compute_surface_tension_LS!(num,grid, grid_u, grid_v, opC_p, opC_u, opC_v,
-198: function compute_curvature_levelset(phi, Δx, Δy)
-231: function compute_unit_normal(num,grid, grid_u, grid_v, 
-429: function compute_unit_normal_debug(num,grid, grid_u, grid_v, 
-606: function compute_curvature_cutcell_operator(opC_p,normal_and_dirac_u,normal_and_dirac_v)
-```
-
-## 📁 Fichier : `./src/surface_tension_VOF.jl` (1 fonctions)
-```julia
-5: function compute_surface_tension_VOF!(num,grid, grid_u, grid_v, opC_p, opC_u, opC_v,volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0)
-```
-
-## 📁 Fichier : `./src/test_functions.jl` (5 fonctions)
-```julia
-55: function integrate_mass_transfer_rate_over_interface_3(num::Numerical{Float64, Int64},
-238: function integrate_mass_transfer_rate_over_interface_3_no_writing(num::Numerical{Float64, Int64},
-375: function compute_grad_T_x_T_y_array_test!(num_LS, grid, grid_u, grid_v, opC_p, grad_x, grad_y, TD)
-523: function ftest(x,y)
-527: function ftest_1(x,y)
-```
-
-## 📁 Fichier : `./src/tools.jl` (6 fonctions)
-```julia
-1: function save_field(path::String, num::Numerical, gp::Mesh, ph::Phase, fwdPh::ForwardPhase, fwd::Forward)
-5: function save_field(path::String, num::Numerical, gp::Mesh, ph::Phase)
-9: function load_phase!(data, ph::Phase)
-17: function stretching(n::Int, dn0::Float64, dn1::Float64, ds::Float64, ws=12, we=12, maxs=0.04)
-38: function force_coefficients!(num, grid, grid_u, grid_v, op, fwd, ph; A=1., p0=0., step=size(fwd.psave,1), saveCoeffs = true)
-86: function vorticity(grid, ph)
-```
-
-## 📁 Fichier : `./src/viz.jl` (7 fonctions)
-```julia
-6: function get_minor_tickvalues(::LogMinorTicks, scale, tickvalues, vmin, vmax)
-19: function custom_formatter(values)
-39: function plot_grid(
-105: function plot_field(
-202: function add_streamlines(fig, gu, gv, u, v, xlims, ylims;
-211: function fstream(x, S::Stream)
-265: function make_video(
-```
-
-## 📁 Fichier : `./test/poisson.jl` (8 fonctions)
-```julia
-14: function f(x, y)
-18: function ∇fx(x, y)
-22: function ∇fy(x, y)
-26: function Δf(x, y)
-36: function regression(x, y, x_reg)
-44: function dirichlet_bcs!(gp, D)
-54: function neumann_bcs!(gp, N)
-69: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_circular_interface_Dirichlet.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-73: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_circular_interface_Neumann.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-89: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_circular_interface_wall.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-73: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_no_interface.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-73: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_no_interface_right_Neumann.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-73: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_square.jl` (10 fonctions)
-```julia
-10: function f(x, y)
-16: function ∇fx(x, y)
-21: function minusf(x, y)
-28: function minus∇fx(x, y)
-32: function ∇fy(x, y)
-37: function Δf(x, y)
-48: function regression(x, y, x_reg)
-56: function dirichlet_bcs!(gp, D)
-66: function neumann_bcs!(gp, N)
-81: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_square_circle_solve_poisson_cos_cos.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-18: function ∇fx(x, y)
-24: function ∇fy(x, y)
-29: function Δf(x, y)
-40: function regression(x, y, x_reg)
-48: function dirichlet_bcs!(gp, D)
-58: function neumann_bcs!(gp, N)
-73: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_square_constant_solve_poisson.jl` (10 fonctions)
-```julia
-10: function f(x, y)
-15: function ∇fx(x, y)
-19: function minusf(x, y)
-24: function minus∇fx(x, y)
-28: function ∇fy(x, y)
-33: function Δf(x, y)
-44: function regression(x, y, x_reg)
-52: function dirichlet_bcs!(gp, D)
-62: function neumann_bcs!(gp, N)
-77: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_square_solve_poisson.jl` (8 fonctions)
-```julia
-10: function f(x, y)
-16: function ∇fx(x, y)
-20: function ∇fy(x, y)
-24: function Δf(x, y)
-34: function regression(x, y, x_reg)
-42: function dirichlet_bcs!(gp, D)
-52: function neumann_bcs!(gp, N)
-67: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/poisson_square_solve_poisson_lin.jl` (10 fonctions)
-```julia
-10: function f(x, y)
-16: function ∇fx(x, y)
-21: function minusf(x, y)
-28: function minus∇fx(x, y)
-32: function ∇fy(x, y)
-37: function Δf(x, y)
-48: function regression(x, y, x_reg)
-56: function dirichlet_bcs!(gp, D)
-66: function neumann_bcs!(gp, N)
-81: function robin_bcs!(gp, R)
-```
-
-## 📁 Fichier : `./test/validation_test.jl` (1 fonctions)
-```julia
-77: function run_case(test_case,n,max_iter,prefix,prediction,test_tolerance)
-```
-
-## 📁 Fichier : `./validation/Frank.jl` (1 fonctions)
-```julia
-8: function conv_Frank(x;
-```
-
-## 📁 Fichier : `./validation/IIOE_CFL.jl` (1 fonctions)
-```julia
-10: function conv_IIOE_CFL(x, y;
-```
-
-## 📁 Fichier : `./validation/NB_test.jl` (1 fonctions)
-```julia
-6: function test_NB(NB_array; n = 128, ϵ_κ = 0.005, R = 0.5, case = "Crystal")
-```
-
-## 📁 Fichier : `./validation/crystal_growth.jl` (1 fonctions)
-```julia
-6: function surface_tension_effect(x;
-```
-
-## 📁 Fichier : `./validation/cutcell_validation.jl` (1 fonctions)
-```julia
-8: function conv_cutcell_CN(x;
-```
-
-## 📁 Fichier : `./validation/grid_effect_crystal.jl` (1 fonctions)
-```julia
-6: function grid_effect(x;
-```
-
-## 📁 Fichier : `./validation/johansen_colella.jl` (1 fonctions)
-```julia
-8: function conv_cutcell_johansen_colella(x;
-```
-
----
-## 📊 Résumé Global
-- **Total Fichiers analysés** : 0
-- **Total Fonctions détectées** : 666

Dockerfile

@@ -1,213 +0,0 @@
-FROM debian:trixie-slim
-
-# Metadata
-LABEL maintainer="jmbatto"
-LABEL description="Julia 1.12 (Source Build) on Debian Trixie with PDI/GTK - Optimized for stability"
-
-# Build Arguments
-ARG USER_ID=1001
-ARG GROUP_ID=1001
-ARG USER_NAME=coder
-ARG JULIA_VERSION=v1.12.4
-ARG PDI_VERSION=1.10.0
-
-# -----------------------------------------------------------------------------
-# 1. System Dependencies Installation
-# -----------------------------------------------------------------------------
-# Rationale:
-# - 'neowofetch': Replaces 'neofetch' which has been removed from Debian Trixie repos.
-# - 'python3-setuptools': REQUIRED for PDI compilation. Python 3.12+ (shipped with Trixie)
-#   removed 'distutils', causing CMake/PDI detection scripts to fail without setuptools.
-# - 'dbus-x11' & 'xvfb': Essential for running GTK applications in a headless Docker environment.
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    # Build tools and base utilities
-    build-essential cmake git pkg-config \
-    gfortran which perl gawk m4 vim libatomic1 \
-    nano sudo lsof jq neowofetch curl wget \
-    gdb valgrind clang-format \
-    ca-certificates iputils-ping colordiff \
-    # Python Environment (with setuptools fix for Py3.12)
-    python3 python3-dev python3-numpy python3-setuptools \
-    # Scientific Libraries (MPI/PDI/HDF5)
-    mpi-default-dev libhdf5-dev libz-dev \
-    # Graphics Stack (X11, GTK4, OpenGL, DBus)
-    libx11-6 libxext6 libxrender1 libxtst6 xauth xvfb dbus-x11 \
-    libgl1-mesa-dri libgl1 \
-    libgtk-4-1 libgtk-3-0 libglib2.0-0 libcairo2 \
-    libpango-1.0-0 libharfbuzz0b \
-    libgdk-pixbuf-2.0-0 libgdk-pixbuf2.0-bin \
-    libgraphene-1.0-0 librsvg2-common \
-    shared-mime-info \
-    adwaita-icon-theme-full hicolor-icon-theme fonts-liberation \
-    graphviz \
-    && rm -rf /var/lib/apt/lists/*
-
-# Fix: Generate machine-id to prevent GLib/GTK runtime errors regarding missing D-Bus UUID.
-RUN dbus-uuidgen > /etc/machine-id
-
-# Fix: Update GDK pixbuf loaders cache.
-# Prevents runtime warnings/errors about missing image format loaders.
-RUN LOADER_PATH=$(find /usr/lib -name gdk-pixbuf-query-loaders | head -n 1) && \
-    ln -s $LOADER_PATH /usr/bin/gdk-pixbuf-query-loaders && \
-    gdk-pixbuf-query-loaders --update-cache
-
-# -----------------------------------------------------------------------------
-# 2. JULIA COMPILATION
-# -----------------------------------------------------------------------------
-WORKDIR /tmp/julia-build
-RUN git clone --depth 1 --branch ${JULIA_VERSION} https://github.com/JuliaLang/julia.git .
-
-# Build Configuration (Make.user) - CRITICAL FIXES FOR DEBIAN TRIXIE
-# 1. USE_SYSTEM_LIBUNWIND=0: Forces internal libunwind. System libunwind on Trixie causes Segfaults.
-# 2. noexecstack: Security flag required by modern Linux kernels.
-# 3. -gdwarf-4: CRITICAL FIX. GCC 13+ defaults to DWARF-5 debug format, which is incompatible
-#    with Julia's current unwinder, leading to immediate Segfaults on startup.
-RUN echo "prefix=/usr/local/julia" > Make.user && \
-    echo "MARCH=x86-64" >> Make.user && \
-    echo "USE_SYSTEM_LIBUNWIND=0" >> Make.user && \
-    echo "LDFLAGS=-Wl,-z,noexecstack" >> Make.user && \
-    echo "CFLAGS=-Wa,--noexecstack -gdwarf-4" >> Make.user && \
-    echo "CXXFLAGS=-Wa,--noexecstack -gdwarf-4" >> Make.user
-
-# Compile, Install, and Cleanup
-# Cleanup is performed immediately to reduce final image size (~1GB saved).
-ENV JULIA_PATH=/usr/local/julia
-ENV PATH=$JULIA_PATH/bin:$PATH
-RUN make -j$(nproc) && \
-    make install && \
-    rm -rf /tmp/julia-build
-
-# -----------------------------------------------------------------------------
-# 3. PDI INSTALLATION
-# -----------------------------------------------------------------------------
-ENV PDI_DIR=/usr/local
-ENV LD_LIBRARY_PATH=/usr/local/lib:/usr/lib/x86_64-linux-gnu
-ENV CPATH=/usr/local/include
-ENV PREFIX=/usr/local
-
-WORKDIR /tmp/pdi-build
-# Build Configuration:
-# - BUILD_PYTHON=ON & BUILD_PYCALL_PLUGIN=ON: Explicitly enabled to generate
-#   'libpdi_pycall_plugin.so'. Required to prevent 'plugin not found' errors
-#   when interacting with Python from Julia/PDI.
-RUN git clone --depth 1 --branch ${PDI_VERSION} https://github.com/pdidev/pdi.git . && \
-    mkdir build && cd build && \
-    cmake \
-        -DBUILD_MPI=OFF \
-        -DBUILD_DECL_HDF5_PLUGIN=ON \
-        -DBUILD_SHARED_LIBS=ON \
-        -DBUILD_FORTRAN=OFF \
-        -DBUILD_HDF5_PARALLEL=OFF \
-        -DBUILD_PYTHON=ON \
-        -DBUILD_PYCALL_PLUGIN=ON \
-        -DBUILD_NETCDF_PARALLEL=OFF \
-        -DCMAKE_INSTALL_PREFIX=/usr/local \
-        .. && \
-    make -j$(nproc) && \
-    make install && \
-    ldconfig && \
-    cd / && rm -rf /tmp/pdi-build
-
-# -----------------------------------------------------------------------------
-# 4. USER CONFIGURATION & RUNTIME ENVIRONMENT
-# -----------------------------------------------------------------------------
-RUN groupadd -g ${GROUP_ID} ${USER_NAME} && \
-    useradd -m -u ${USER_ID} -g ${USER_NAME} -s /bin/bash ${USER_NAME} && \
-    echo "${USER_NAME} ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
-
-# RUNTIME ENVIRONMENT VARIABLES - CRITICAL SETTINGS
-# 1. LD_LIBRARY_PATH: STRICTLY excludes '/usr/lib/x86_64-linux-gnu'.
-#    Reason: Preventing "DLL Hell". Including system paths forces Julia to load system
-#    libraries (e.g., system libglib) instead of its own Artifacts, causing undefined
-#    symbol errors (e.g., 'g_string_copy'). We prioritize Julia and PDI libs.
-ENV LD_LIBRARY_PATH=/usr/local/julia/lib:/usr/local/julia/lib/julia:/usr/local/lib
-
-# 2. GTK_A11Y=none: Disables GTK Accessibility Bus to suppress "org.a11y.Bus" warnings in logs.
-ENV GTK_A11Y=none
-
-# 3. Graphics & Julia settings
-ENV GKSwstype=100
-ENV JULIA_PKG_PRECOMPILE_AUTO=0
-ENV JULIA_PKG_USE_CLI_GIT=true
-ENV DISPLAY=host.docker.internal:0.0
-ENV PYTHONPATH=/usr/local/lib/python3/dist-packages
-
-# Switch to non-root user for Package Installation
-# Ensures ~/.julia permissions are correctly set for the user 'coder'.
-USER ${USER_NAME}
-WORKDIR /home/${USER_NAME}/project
-
-# -----------------------------------------------------------------------------
-# 5. JULIA PACKAGES INSTALLATION
-# -----------------------------------------------------------------------------
-# Optimization:
-# - Operations are consolidated into a single RUN instruction to reduce Docker layer count.
-# - xvfb-run: Executes in a virtual framebuffer. Essential for 'Pkg.precompile()'
-#   of Gtk4 and ProfileView, which require a display server even during installation.
-
-
-
-
-ENV LD_LIBRARY_PATH=/usr/local/julia/lib:/usr/local/julia/lib/julia:/usr/local/lib
-
-RUN julia -e 'import Pkg; \
-    Pkg.add([ \
-		"Pkg", \
-        "AbstractTrees", \
-		"BenchmarkTools", \ 
-		"Cairo_jll", \
-		"Documenter", \ 
-		"GeoInterface", \
-		"GeometryBasics", \ 
-		"HDF5", \ 
-		"Interpolations", \ 
-		"IterativeSolvers", \ 
-		"JLD", \ 
-		"LibGEOS", \ 
-		"LinearAlgebra", \ 
-		"LsqFit", \ 
-		"MPI", \ 
-		"MUMPS", \
-		"MethodAnalysis", \ 
-		"OffsetArrays", \ 
-		"PProf", \
-		"PackageCompiler", \ 
-		"Parameters", \ 
-		"Peaks", \
-		"Polynomials", \
-		"Printf", \ 
-		"Profile", \ 
-		"PropertyDicts", \
-		"Revise", \ 
-		"Roots", \ 
-		"SnoopCompileCore", \
-		"SparseArrays", \ 
-		"SpecialFunctions", \
-		"StaticArrays", \
-		"Statistics", \ 
-		"Test", \
-		"YAML" \
-	])'
-RUN xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24 -nolisten tcp" \
-	julia -e 'import Pkg; \
-       Pkg.add([ \		
-        "DataFrames", \
-        "Gtk4", \
-        "Gtk", \
-        "ProfileView", \
-        "PProf", \
-        "Reexport" \
-    ])'
-
-
-ENV LD_LIBRARY_PATH=""
-# hack to install julia package
-RUN xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24 -nolisten tcp" \
-    julia -e 'import Pkg; Pkg.precompile()'
-RUN xvfb-run --auto-servernum --server-args="-screen 0 1920x1080x24 -nolisten tcp" \
-    julia -e 'import Pkg; Pkg.update(); Pkg.precompile()'
-ENV LD_LIBRARY_PATH=/usr/local/julia/lib:/usr/local/julia/lib/julia:/usr/local/lib
-
-
-
-CMD ["/bin/bash"]

Flower.jl

@@ -1,180 +0,0 @@
-# __precompile__()
-
-module Flower
-
-using Reexport
-
-import Base.<
-import Base.isnan
-import Base.*
-import Base.+
-import Base.-
-import Base.abs
-import Base.OneTo
-import Base.ones
-import Base.zeros
-import Base.reshape
-
-# import Base.union
-
-# @reexport using Base.Union
-
-@reexport using Printf
-@reexport using Base.Threads
-@reexport using LinearAlgebra
-@reexport using SparseArrays
-
-@reexport using Parameters
-@reexport using StaticArrays
-@reexport using OffsetArrays
-@reexport using Roots
-# @reexport using SpecialFunctions
-@reexport using GeometryBasics
-@reexport using GeoInterface
-
-# @reexport using LibGEOS
-@reexport import LibGEOS #avoids warnings like:
-# "WARNING: both MUMPS and Roots export "solve!"; uses of it in module Flower must be qualified"
-
-
-# @reexport using HDF5
-
-@reexport import YAML
-@reexport using Test
-# @reexport using MPI
-@reexport using PropertyDicts
-# @reexport using PrettyTables
-# @reexport using Polynomials
-@reexport using Peaks
-# @reexport using Profile
-
-# @reexport using ProfileCanvas
-
-# @reexport using BenchmarkTools
-
-@reexport using IterativeSolvers #for gmres
-# @reexport using ConvergenceHistory #for reserve!
-
-@reexport using Statistics #for mean
-# @reexport using MPI
-
-# @reexport using MUMPS
-@reexport import MUMPS
-
-@reexport using SpecialFunctions #not @reexport import SpecialFunctions
-
-# using SpecialFunctions
-
-# #Long version
-# @reexport using Printf
-# # @reexport using Statistics
-# @reexport using Base.Threads
-# @reexport using LinearAlgebra
-# @reexport using SparseArrays
-# @reexport using BenchmarkTools
-# @reexport using Parameters
-# @reexport using StaticArrays
-# @reexport using OffsetArrays
-# @reexport using Roots
-# @reexport using SpecialFunctions
-# # @reexport using Test 
-# # @reexport using CairoMakie
-# # @reexport using LaTeXStrings
-# # @reexport using Gnuplot
-# @reexport using IterativeSolvers
-# # @reexport using LsqFit
-# # @reexport using Polynomials
-# # @reexport using JLD
-# # @reexport using Peaks
-# @reexport using GeometryBasics
-# @reexport using GeoInterface
-# @reexport using LibGEOS
-
-
-
-# @reexport using PackageCompiler
-
-###################################################################################################
-# For plotting with python
-###################################################################################################
-# @reexport using PyCall
-# @reexport using LaTeXStrings
-# @reexport using PyPlot
-
-# const anim = PyNULL()
-# # const plt = PyNULL()
-# const mpl_colors = PyNULL()
-# const mpl_tickers = PyNULL()
-# const pd = PyNULL()
-
-# # from matplotlib.colors import BoundaryNorm
-# # from matplotlib.ticker import MaxNLocator
-
-# function __init__()
-#     copy!(anim, pyimport_conda("matplotlib.animation", "matplotlib"))
-#     # copy!(plt, pyimport_conda("matplotlib.pyplot", "matplotlib"))
-#     copy!(mpl_colors, pyimport_conda("matplotlib.colors", "matplotlib"))
-#     copy!(mpl_tickers, pyimport_conda("matplotlib.ticker", "matplotlib"))
-#     copy!(pd, pyimport_conda("pandas", "pandas"))
-# end
-###################################################################################################
-
-include("types.jl")
-include("types_PDI.jl")
-include("init.jl")
-include("common.jl")
-include("levelset.jl")
-include("cutcell.jl")
-include("operators.jl")
-include("operators_coupled.jl")
-include("heat.jl")
-include("heat_coupled.jl")
-include("navier_stokes_coupled.jl")
-include("navier_stokes_coupled_pressure_velocity.jl")
-include("run.jl")
-include("common_run.jl")
-include("contact_line.jl")
-include("optimize.jl")
-# include("viz.jl")
-include("tools.jl")
-include("electrolysis_init.jl")
-include("electrolysis_utils.jl")
-include("electrolysis.jl")
-include("electrolysis_2.jl")
-include("electrolysis_operators.jl")
-include("electrolysis_tests.jl")
-include("electrolysis_print.jl")
-
-include("bicgstabl_flower.jl")
-
-include("run_profile.jl") #for profiling
-
-include("one_fluid.jl")
-include("surface_tension_LS.jl")
-include("surface_tension_VOF.jl")
-include("interface_transport.jl")
-include("solve_one_fluid.jl")
-include("compute_mass_transfer_rate.jl")
-include("test_functions.jl")
-include("convection.jl")
-include("post_processing.jl")
-include("fill_struct.jl")
-
-
-
-###################################################################################################
-# For plotting with python
-###################################################################################################
-# include("electrolysis_plot.jl")
-###################################################################################################
-
-
-# include("Plotpython.jl")
-# using .Plotpython
-
-# include("electrolysis_viz.jl")
-
-
-export_all()
-#this is a second test
-end

Makefile

@@ -1,17 +0,0 @@
-# Makefile pour le portage
-.PHONY: trace-julia build-c compare clean
-
-# 1. Lance Julia avec l'instrumentation pour générer les traces et le Golden Master HDF5
-trace-julia:
-	julia --project=. src/main_simulation.jl --trace-mode
-
-# 2. Compile le nouveau code C
-build-c:
-	gcc -g -O2 src_c/main.c -o build/sim_c -lpdi
-
-# 3. Compare les sorties (Vision Test)
-compare:
-	julia scripts/compare_results.jl build/output_c.h5 build/output_julia.h5
-
-clean:
-	rm -f build/*

RAPPORT_USAGE_CODE_MORT.md

@@ -1,533 +0,0 @@
-# 💀 Audit de Code Mort & Usage
-Analyse basée sur la recherche textuelle exacte des noms de fonctions.
-
-| Fichier | Ligne | Fonction | État | Occurrences | Note |
-|---|---|---|---|---|---|
-| `./examples/poisson.jl` | 10 | `f` | ✅ ACTIF | 573 | Exemple |
-| `./examples/poisson.jl` | 32 | `regression` | ✅ ACTIF | 128 | Exemple |
-| `./examples/poisson.jl` | 40 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Exemple |
-| `./examples/poisson.jl` | 50 | `neumann_bcs!` | ✅ ACTIF | 26 | Exemple |
-| `./examples/poisson.jl` | 65 | `robin_bcs!` | ✅ ACTIF | 24 | Exemple |
-| `./examples/electrolysis_concentration.jl` | 54 | `fmax` | ✅ ACTIF | 3 | Exemple |
-| `./examples/electrolysis_concentration.jl` | 58 | `favg` | ✅ ACTIF | 9 | Exemple |
-| `./examples/electrolysis_concentration_cyl.jl` | 83 | `fmax` | ✅ ACTIF | 3 | Exemple |
-| `./examples/electrolysis_concentration_cyl.jl` | 87 | `favg` | ✅ ACTIF | 9 | Exemple |
-| `./examples/electrolysis_concentration_cyl.jl` | 91 | `zerovel` | ✅ ACTIF | 6 | Exemple |
-| `./examples/electrolysis_channel.jl` | 21 | `f` | ✅ ACTIF | 573 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 102 | `fmax` | ✅ ACTIF | 3 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 106 | `favg` | ✅ ACTIF | 9 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 110 | `zerovel` | ✅ ACTIF | 6 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 704 | `strtitlefunc` | ✅ ACTIF | 15 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 1195 | `make_frame` | ✅ ACTIF | 14 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 1379 | `make_frame` | ✅ ACTIF | 14 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 1461 | `make_frame` | ✅ ACTIF | 14 | Exemple |
-| `./examples/electrolysis_concentration_growth.jl` | 1620 | `make_frame_3` | ✅ ACTIF | 2 | Exemple |
-| `./examples/koenig.jl` | 5 | `run_koenig` | ✅ ACTIF | 2 | Exemple |
-| `./examples/sessile.jl` | 21 | `run_sessile` | ✅ ACTIF | 8 | Exemple |
-| `./examples/gradient_test.jl` | 20 | `plot_grid_figtest!` | ✅ ACTIF | 5 | Exemple |
-| `./examples/gradient_test.jl` | 48 | `scal_magnitude` | ✅ ACTIF | 3 | Exemple |
-| `./examples/gradient_test.jl` | 101 | `scal_magnitude_L` | ✅ ACTIF | 4 | Exemple |
-| `./examples/gradient_test.jl` | 157 | `compute_grad_T_x!` | ✅ ACTIF | 3 | Exemple |
-| `./examples/gradient_test.jl` | 174 | `compute_grad_T_y!` | ✅ ACTIF | 3 | Exemple |
-| `./examples/gradient_test.jl` | 312 | `ftest` | ✅ ACTIF | 76 | Exemple |
-| `./examples/conservation.jl` | 89 | `momentum` | ✅ ACTIF | 7 | Exemple |
-| `./examples/conservation.jl` | 106 | `kinetic_energy` | ✅ ACTIF | 8 | Exemple |
-| `./examples/navier-stokes_airfoil.jl` | 6 | `suction_side` | ✅ ACTIF | 2 | Exemple |
-| `./examples/navier-stokes_airfoil.jl` | 10 | `pressure_side` | ✅ ACTIF | 2 | Exemple |
-| `./examples/navier-stokes_airfoil.jl` | 14 | `naca` | ✅ ACTIF | 2 | Exemple |
-| `./examples/channel_Khalighi2023.jl` | 24 | `f` | ✅ ACTIF | 573 | Exemple |
-| `./examples/convergence.jl` | 11 | `execute_simulation_step` | ✅ ACTIF | 2 | Exemple |
-| `./examples/convergence.jl` | 366 | `full_cell_u1` | ✅ ACTIF | 2 | Exemple |
-| `./examples/convergence.jl` | 369 | `full_cell_A_n` | ✅ ACTIF | 3 | Exemple |
-| `./examples/convergence.jl` | 376 | `full_cell_u2` | ✅ ACTIF | 2 | Exemple |
-| `./examples/convergence.jl` | 381 | `full_cell_u` | ✅ ACTIF | 2 | Exemple |
-| `./examples_optimization/mullins_opt.jl` | 53 | `fg2!` | ✅ ACTIF | 4 |  |
-| `./examples_optimization/mullins_opt.jl` | 95 | `gradient_based_optimization2` | ✅ ACTIF | 4 |  |
-| `./examples_optimization/crystal_opt.jl` | 65 | `fg2!` | ✅ ACTIF | 4 |  |
-| `./examples_optimization/crystal_opt.jl` | 109 | `gradient_based_optimization2` | ✅ ACTIF | 4 |  |
-| `./src/run_profile.jl` | 1 | **profile_run_forward!** | 💀 MORT | 1 |  |
-| `./src/one_fluid.jl` | 4 | `update_one_fluid_density_viscosity` | ✅ ACTIF | 4 |  |
-| `./src/one_fluid.jl` | 155 | `harmonic_average_one_fluid` | ✅ ACTIF | 5 |  |
-| `./src/one_fluid.jl` | 159 | `average_one_fluid` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 175 | `bilinear_interpolation` | ✅ ACTIF | 10 |  |
-| `./src/one_fluid.jl` | 191 | `bilinear_interpolation` | ✅ ACTIF | 10 |  |
-| `./src/one_fluid.jl` | 226 | `create_2D_grid_x` | ✅ ACTIF | 13 |  |
-| `./src/one_fluid.jl` | 294 | `create_2D_grid_y` | ✅ ACTIF | 11 |  |
-| `./src/one_fluid.jl` | 382 | `create_2D_grid_volume_fraction` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 443 | `levelset_heavyside` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 460 | `levelset_to_binary` | ✅ ACTIF | 2 |  |
-| `./src/one_fluid.jl` | 474 | `smooth_vof_2d!` | ✅ ACTIF | 2 |  |
-| `./src/one_fluid.jl` | 566 | `compute_fluxes` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 663 | `allocate_offset_array` | ✅ ACTIF | 8 |  |
-| `./src/one_fluid.jl` | 673 | `fill_bulk_ghost` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 768 | `solve_one_fluid_NS!` | ✅ ACTIF | 4 |  |
-| `./src/one_fluid.jl` | 2764 | `set_Forward_Euler_one_fluid!` | ✅ ACTIF | 4 |  |
-| `./src/one_fluid.jl` | 3496 | `FE_set_momentum_coupled2_one_fluid` | ✅ ACTIF | 7 |  |
-| `./src/one_fluid.jl` | 4382 | `check_coupled_matrix` | ✅ ACTIF | 5 |  |
-| `./src/one_fluid.jl` | 4584 | **set_convection_with_rho!** | 💀 MORT | 1 |  |
-| `./src/one_fluid.jl` | 4732 | `vector_convection_with_rho!` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 4966 | `vector_convection_with_rho!` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 5202 | `set_poisson_one_fluid` | ✅ ACTIF | 2 |  |
-| `./src/one_fluid.jl` | 5336 | `solve_poisson_one_fluid!` | ✅ ACTIF | 3 |  |
-| `./src/one_fluid.jl` | 5473 | `interpolate_interface_velocity!` | ✅ ACTIF | 2 |  |
-| `./src/one_fluid.jl` | 5489 | `set_convection_preallocated!` | ✅ ACTIF | 2 |  |
-| `./src/run.jl` | 6 | `run_forward!` | ✅ ACTIF | 28 |  |
-| `./src/run_bwd.jl` | 1 | `run_backward` | ✅ ACTIF | 4 |  |
-| `./src/convection.jl` | 57 | `compute_fluxes_upwind` | ✅ ACTIF | 3 |  |
-| `./src/convection.jl` | 220 | `compute_fluxes_CUI` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 5 | `diamond` | ✅ ACTIF | 19 |  |
-| `./src/levelset.jl` | 18 | `diamond` | ✅ ACTIF | 19 |  |
-| `./src/levelset.jl` | 30 | `diamond_not_periodic` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 38 | `quadratic_recons` | ✅ ACTIF | 10 |  |
-| `./src/levelset.jl` | 47 | `quadratic_recons` | ✅ ACTIF | 10 |  |
-| `./src/levelset.jl` | 59 | `quadratic_recons_not_periodic` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 68 | `quadratic_recons` | ✅ ACTIF | 10 |  |
-| `./src/levelset.jl` | 73 | `normal_grad` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 84 | `normal_grad` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 94 | `normal_grad` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 104 | `grad` | ✅ ACTIF | 74 |  |
-| `./src/levelset.jl` | 115 | `grad` | ✅ ACTIF | 74 |  |
-| `./src/levelset.jl` | 125 | `grad` | ✅ ACTIF | 74 |  |
-| `./src/levelset.jl` | 138 | `grad_not_periodic` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 148 | `grad_IIOE` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 159 | `grad_IIOE` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 169 | `advection` | ✅ ACTIF | 130 |  |
-| `./src/levelset.jl` | 179 | `advection` | ✅ ACTIF | 130 |  |
-| `./src/levelset.jl` | 232 | `inflow_outflow` | ✅ ACTIF | 12 |  |
-| `./src/levelset.jl` | 244 | `sumloc` | ✅ ACTIF | 12 |  |
-| `./src/levelset.jl` | 251 | `sumloc` | ✅ ACTIF | 12 |  |
-| `./src/levelset.jl` | 280 | `init_ghost_neumann` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 302 | `init_ghost_neumann_2` | ✅ ACTIF | 11 |  |
-| `./src/levelset.jl` | 327 | `IIOE_normal!` | ✅ ACTIF | 12 |  |
-| `./src/levelset.jl` | 374 | `IIOE_normal_indices!` | ✅ ACTIF | 9 |  |
-| `./src/levelset.jl` | 413 | `IIOE_normal_indices_2!` | ✅ ACTIF | 5 |  |
-| `./src/levelset.jl` | 465 | `IIOE!` | ✅ ACTIF | 9 |  |
-| `./src/levelset.jl` | 497 | `S2IIOE!` | ✅ ACTIF | 10 |  |
-| `./src/levelset.jl` | 773 | `finite_difference_weno5` | ✅ ACTIF | 29 |  |
-| `./src/levelset.jl` | 988 | `reinit_min` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 1243 | `reinit_rs` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 1408 | `reinit_hartmann` | ✅ ACTIF | 7 |  |
-| `./src/levelset.jl` | 1595 | `FE_reinit!` | ✅ ACTIF | 2 |  |
-| `./src/levelset.jl` | 1624 | `RK2_reinit!` | ✅ ACTIF | 6 |  |
-| `./src/levelset.jl` | 1672 | `rg` | ✅ ACTIF | 5 |  |
-| `./src/levelset.jl` | 1771 | `field_extension!` | ✅ ACTIF | 16 |  |
-| `./src/levelset.jl` | 1936 | `aux_interpolate_scalar!` | ✅ ACTIF | 11 |  |
-| `./src/levelset.jl` | 1995 | `interpolate_scalar!` | ✅ ACTIF | 9 |  |
-| `./src/levelset.jl` | 2073 | `breakup_n` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 2102 | `breakup_f` | ✅ ACTIF | 3 |  |
-| `./src/levelset.jl` | 2154 | `combine_levelsets!` | ✅ ACTIF | 4 |  |
-| `./src/levelset.jl` | 2169 | `combine_levelsets` | ✅ ACTIF | 11 |  |
-| `./src/test_functions.jl` | 55 | **integrate_mass_transfer_rate_over_interface_3** | 💀 MORT | 1 |  |
-| `./src/test_functions.jl` | 238 | **integrate_mass_transfer_rate_over_interface_3_no_writing** | 💀 MORT | 1 |  |
-| `./src/test_functions.jl` | 375 | **compute_grad_T_x_T_y_array_test!** | 💀 MORT | 1 |  |
-| `./src/test_functions.jl` | 523 | `ftest` | ✅ ACTIF | 76 |  |
-| `./src/test_functions.jl` | 527 | **ftest_1** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 43 | `strtitlefunc` | ✅ ACTIF | 15 |  |
-| `./src/electrolysis_plot.jl` | 50 | `plot_current_wall` | ✅ ACTIF | 5 |  |
-| `./src/electrolysis_plot.jl` | 135 | `plot_bc` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_plot.jl` | 162 | `plot_bc2` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_plot.jl` | 189 | `plot_python_pdf` | ✅ ACTIF | 141 |  |
-| `./src/electrolysis_plot.jl` | 349 | `plot_python_pdf_full2` | ✅ ACTIF | 36 |  |
-| `./src/electrolysis_plot.jl` | 659 | `python_movie_zoom` | ✅ ACTIF | 63 |  |
-| `./src/electrolysis_plot.jl` | 720 | `make_frame` | ✅ ACTIF | 14 |  |
-| `./src/electrolysis_plot.jl` | 838 | `plot_electrolysis_velocity!` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_plot.jl` | 915 | **plot_python_bc** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 999 | **plot_last_iter_python_pdf** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 1065 | **debug_border_top** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 1123 | **debug_border_left** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 1168 | `scalar_debug_border` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_plot.jl` | 1297 | **scalar_debug!** | 💀 MORT | 1 |  |
-| `./src/electrolysis_plot.jl` | 1525 | `plot_radial_vel` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_plot.jl` | 1569 | `plot_vector` | ✅ ACTIF | 2 |  |
-| `./src/tools.jl` | 1 | `save_field` | ✅ ACTIF | 16 |  |
-| `./src/tools.jl` | 5 | `save_field` | ✅ ACTIF | 16 |  |
-| `./src/tools.jl` | 9 | `load_phase!` | ✅ ACTIF | 3 |  |
-| `./src/tools.jl` | 17 | `stretching` | ✅ ACTIF | 16 |  |
-| `./src/tools.jl` | 38 | `force_coefficients!` | ✅ ACTIF | 2 |  |
-| `./src/tools.jl` | 86 | `vorticity` | ✅ ACTIF | 2 |  |
-| `./src/bicgstabl_flower.jl` | 32 | `bicgstabl_iterator_flower!` | ✅ ACTIF | 6 |  |
-| `./src/bicgstabl_flower.jl` | 85 | `iterate` | ✅ ACTIF | 18 |  |
-| `./src/bicgstabl_flower.jl` | 188 | `bicgstabl_flower!` | ✅ ACTIF | 6 |  |
-| `./src/init.jl` | 4 | `Indices` | ✅ ACTIF | 14 |  |
-| `./src/init.jl` | 29 | `Levelset` | ✅ ACTIF | 27 |  |
-| `./src/init.jl` | 193 | `allocate_ghost_matrices_2` | ✅ ACTIF | 5 |  |
-| `./src/init.jl` | 255 | `Mesh` | ✅ ACTIF | 91 |  |
-| `./src/init.jl` | 287 | `init_meshes` | ✅ ACTIF | 61 |  |
-| `./src/init.jl` | 303 | `init_sparse_Bx` | ✅ ACTIF | 29 |  |
-| `./src/init.jl` | 328 | `init_sparse_By` | ✅ ACTIF | 29 |  |
-| `./src/init.jl` | 356 | `init_sparse_BxT` | ✅ ACTIF | 30 |  |
-| `./src/init.jl` | 377 | `init_sparse_ByT` | ✅ ACTIF | 30 |  |
-| `./src/init.jl` | 457 | `init_fields` | ✅ ACTIF | 88 |  |
-| `./src/init.jl` | 1362 | `init_mullins!` | ✅ ACTIF | 2 |  |
-| `./src/init.jl` | 1374 | `init_mullins2!` | ✅ ACTIF | 2 |  |
-| `./src/init.jl` | 1386 | `init_franck!` | ✅ ACTIF | 7 |  |
-| `./src/init.jl` | 1398 | **init_smooth** | 💀 MORT | 1 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 30 | `FE_set_momentum_coupled2` | ✅ ACTIF | 9 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 836 | `FE_set_momentum_coupled_two_phases` | ✅ ACTIF | 3 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 1650 | `set_first_cells!` | ✅ ACTIF | 13 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 1730 | `set_first_cells_Neumann!` | ✅ ACTIF | 5 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 1826 | `deactivate_merge_first_cells_capacities!` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled_pressure_velocity.jl` | 1845 | `deactivate_merge_first_cells_capacities!` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_utils.jl` | 4 | `average!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_utils.jl` | 31 | `get_height!` | ✅ ACTIF | 14 |  |
-| `./src/electrolysis_utils.jl` | 106 | `init_Neumann_iLS` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_utils.jl` | 199 | `init_fields_multiple_levelsets!` | ✅ ACTIF | 24 |  |
-| `./src/electrolysis_utils.jl` | 316 | `mean_intfc_non_null` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_utils.jl` | 345 | **mean_intfc_non_null_v2** | 💀 MORT | 1 |  |
-| `./src/electrolysis_utils.jl` | 375 | **mean_intfc_non_null_v3** | 💀 MORT | 1 |  |
-| `./src/electrolysis_utils.jl` | 420 | `scal_magnitude` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_utils.jl` | 475 | `scal_magnitude_L` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_utils.jl` | 504 | `relative_errors` | ✅ ACTIF | 43 |  |
-| `./src/electrolysis_utils.jl` | 587 | `relative_errors_interface` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_utils.jl` | 632 | **compute_interface_average** | 💀 MORT | 1 |  |
-| `./src/electrolysis_utils.jl` | 725 | **compute_bulk_or_interface_average** | 💀 MORT | 1 |  |
-| `./src/electrolysis_utils.jl` | 782 | `find_sign_changes` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_utils.jl` | 818 | `compute_bubble_drop_radius` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_utils.jl` | 935 | `compute_radius_from_levelset_slice` | ✅ ACTIF | 10 |  |
-| `./src/electrolysis_utils.jl` | 1015 | `find_slice_coord_bubble_mass_center` | ✅ ACTIF | 4 |  |
-| `./src/operators.jl` | 1 | **empty_laplacian** | 💀 MORT | 1 |  |
-| `./src/operators.jl` | 47 | `set_bc_bnds` | ✅ ACTIF | 18 |  |
-| `./src/operators.jl` | 99 | `laplacian!` | ✅ ACTIF | 6 |  |
-| `./src/operators.jl` | 197 | `set_bc_bnds` | ✅ ACTIF | 18 |  |
-| `./src/operators.jl` | 238 | `inv_weight_clip` | ✅ ACTIF | 3 |  |
-| `./src/operators.jl` | 247 | `inv_weight_clip2` | ✅ ACTIF | 2 |  |
-| `./src/operators.jl` | 259 | `inv_weight_eps` | ✅ ACTIF | 58 |  |
-| `./src/operators.jl` | 269 | `inv_weight_eps2` | ✅ ACTIF | 27 |  |
-| `./src/operators.jl` | 279 | **inv_weight_diag** | 💀 MORT | 1 |  |
-| `./src/operators.jl` | 305 | `laplacian!` | ✅ ACTIF | 6 |  |
-| `./src/operators.jl` | 434 | `divergence!` | ✅ ACTIF | 2 |  |
-| `./src/operators.jl` | 461 | `set_bc_bnds` | ✅ ACTIF | 18 |  |
-| `./src/operators.jl` | 508 | `gradient!` | ✅ ACTIF | 2 |  |
-| `./src/operators.jl` | 602 | `divergence!` | ✅ ACTIF | 2 |  |
-| `./src/operators.jl` | 653 | `gradient!` | ✅ ACTIF | 2 |  |
-| `./src/operators.jl` | 722 | **uv_to_p!** | 💀 MORT | 1 |  |
-| `./src/operators.jl` | 737 | `harmonic_average` | ✅ ACTIF | 4 |  |
-| `./src/operators.jl` | 751 | `strain_rate!` | ✅ ACTIF | 3 |  |
-| `./src/operators.jl` | 804 | `set_bc_bnds` | ✅ ACTIF | 18 |  |
-| `./src/operators.jl` | 866 | `scalar_convection!` | ✅ ACTIF | 4 |  |
-| `./src/operators.jl` | 973 | **scalar_convection_CUTCT!** | 💀 MORT | 1 |  |
-| `./src/operators.jl` | 1084 | **scalar_convection_debug!** | 💀 MORT | 1 |  |
-| `./src/operators.jl` | 1315 | `set_bc_bnds` | ✅ ACTIF | 18 |  |
-| `./src/operators.jl` | 2266 | `fill_inside_conv!` | ✅ ACTIF | 16 |  |
-| `./src/operators.jl` | 2307 | `vec_convx_1!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2333 | `vec_convx_2!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2359 | `vec_convx_3!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2375 | `vec_convx_4!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2391 | `vec_convx_5!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2412 | `vec_convx_6!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2433 | `vec_convx_7!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2454 | `vec_convx_8!` | ✅ ACTIF | 5 |  |
-| `./src/operators.jl` | 2479 | `vector_convection!` | ✅ ACTIF | 12 |  |
-| `./src/operators.jl` | 2694 | `fill_inside_conv!` | ✅ ACTIF | 16 |  |
-| `./src/operators.jl` | 2737 | `vec_convy_1!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2767 | `vec_convy_2!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2797 | `vec_convy_3!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2817 | `vec_convy_4!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2837 | `vec_convy_5!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2862 | `vec_convy_6!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2887 | `vec_convy_7!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2912 | `vec_convy_8!` | ✅ ACTIF | 7 |  |
-| `./src/operators.jl` | 2959 | `vector_convection!` | ✅ ACTIF | 12 |  |
-| `./src/electrolysis_print.jl` | 22 | **print_BC_LS_html** | 💀 MORT | 1 |  |
-| `./src/electrolysis_print.jl` | 28 | **print_BC_html** | 💀 MORT | 1 |  |
-| `./src/electrolysis_print.jl` | 34 | `print_BC_line` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_print.jl` | 39 | `print_BC` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_print.jl` | 44 | `typeofBC` | ✅ ACTIF | 7 |  |
-| `./src/optimize.jl` | 19 | `fg!` | ✅ ACTIF | 2 |  |
-| `./src/optimize.jl` | 65 | `gradient_based_optimization` | ✅ ACTIF | 3 |  |
-| `./src/interface_transport.jl` | 5 | `advection_u_and_v` | ✅ ACTIF | 3 |  |
-| `./src/interface_transport.jl` | 26 | `compute_normal_component_of_velocity` | ✅ ACTIF | 5 |  |
-| `./src/interface_transport.jl` | 123 | `select_advection!` | ✅ ACTIF | 2 |  |
-| `./src/heat_coupled.jl` | 25 | **set_heat_borders!** | 💀 MORT | 1 |  |
-| `./src/heat_coupled.jl` | 110 | `set_heat!` | ✅ ACTIF | 11 |  |
-| `./src/common_run.jl` | 5 | `indices_extension` | ✅ ACTIF | 15 |  |
-| `./src/common_run.jl` | 44 | `update_all_ls_data` | ✅ ACTIF | 30 |  |
-| `./src/common_run.jl` | 96 | `update_ls_data` | ✅ ACTIF | 4 |  |
-| `./src/common_run.jl` | 136 | `update_ls_data_grid` | ✅ ACTIF | 4 |  |
-| `./src/common_run.jl` | 162 | `update_stefan_velocity` | ✅ ACTIF | 2 |  |
-| `./src/common_run.jl` | 175 | `update_free_surface_velocity` | ✅ ACTIF | 8 |  |
-| `./src/heat.jl` | 1 | `Stefan_velocity!` | ✅ ACTIF | 3 |  |
-| `./src/viz.jl` | 6 | **get_minor_tickvalues** | 💀 MORT | 1 |  |
-| `./src/viz.jl` | 19 | `custom_formatter` | ✅ ACTIF | 3 |  |
-| `./src/viz.jl` | 39 | `plot_grid` | ✅ ACTIF | 82 |  |
-| `./src/viz.jl` | 105 | `plot_field` | ✅ ACTIF | 2 |  |
-| `./src/viz.jl` | 202 | **add_streamlines** | 💀 MORT | 1 |  |
-| `./src/viz.jl` | 211 | `fstream` | ✅ ACTIF | 3 |  |
-| `./src/viz.jl` | 265 | `make_video` | ✅ ACTIF | 84 |  |
-| `./src/electrolysis_3.jl` | 98 | **set_poisson_variable_coeff_no_interpolation!** | 💀 MORT | 1 |  |
-| `./src/contact_line.jl` | 11 | `BC_LS!` | ✅ ACTIF | 14 |  |
-| `./src/contact_line.jl` | 115 | `update_radius_from_contact_line` | ✅ ACTIF | 17 |  |
-| `./src/contact_line.jl` | 178 | `BC_LS_interior!` | ✅ ACTIF | 16 |  |
-| `./src/contact_line.jl` | 703 | `locate_contact_line!` | ✅ ACTIF | 5 |  |
-| `./src/contact_line.jl` | 722 | `extend_contact_line!` | ✅ ACTIF | 6 |  |
-| `./src/contact_line.jl` | 756 | `extend_contact_line!` | ✅ ACTIF | 6 |  |
-| `./src/contact_line.jl` | 783 | `dynamic_contact_angle` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_viz.jl` | 7 | **plot_grid_fig!** | 💀 MORT | 1 |  |
-| `./src/electrolysis_viz.jl` | 53 | `make_video_vec` | ✅ ACTIF | 34 |  |
-| `./src/electrolysis_tests.jl` | 5 | `test_laplacian_pressure` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_tests.jl` | 48 | `test_LS` | ✅ ACTIF | 14 |  |
-| `./src/electrolysis_tests.jl` | 69 | **FE_set_momentum_debug** | 💀 MORT | 1 |  |
-| `./src/electrolysis_tests.jl` | 185 | **pressure_projection_debug!** | 💀 MORT | 1 |  |
-| `./src/post_processing.jl` | 4 | `calculate_centroid` | ✅ ACTIF | 6 |  |
-| `./src/post_processing.jl` | 26 | `calculate_circularity` | ✅ ACTIF | 3 |  |
-| `./src/post_processing.jl` | 42 | `calculate_rise_velocity` | ✅ ACTIF | 3 |  |
-| `./src/cutcell.jl` | 151 | `find_radius` | ✅ ACTIF | 3 |  |
-| `./src/cutcell.jl` | 192 | `clip_large_cell!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 217 | `clip_small_cell!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 243 | `empty_cell!` | ✅ ACTIF | 12 |  |
-| `./src/cutcell.jl` | 267 | `clip_cells!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 480 | `clip_A_acc_to_V` | ✅ ACTIF | 4 |  |
-| `./src/cutcell.jl` | 572 | `clip_middle_cells!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 599 | `dimensionalize!` | ✅ ACTIF | 8 |  |
-| `./src/cutcell.jl` | 622 | `postprocess_grids1!` | ✅ ACTIF | 3 |  |
-| `./src/cutcell.jl` | 674 | `postprocess_grids2!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 713 | `ilp2cap` | ✅ ACTIF | 59 |  |
-| `./src/cutcell.jl` | 728 | `crossing_2levelsets!` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 1169 | `set_A_caps!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1209 | `set_A_caps_full_mixed!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1243 | `set_A_caps_double_mixed_full_empty!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1270 | `set_A_caps_full_empty!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1299 | `set_A_caps_double_mixed_mixed!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1325 | `set_B_caps!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1359 | `_marching_squares!` | ✅ ACTIF | 10 |  |
-| `./src/cutcell.jl` | 1419 | `marching_squares!` | ✅ ACTIF | 7 |  |
-| `./src/cutcell.jl` | 1487 | `get_interface_location!` | ✅ ACTIF | 4 |  |
-| `./src/cutcell.jl` | 1501 | `get_interface_location_borders!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1534 | `get_interface_location_borders!` | ✅ ACTIF | 2 |  |
-| `./src/cutcell.jl` | 1570 | `get_curvature` | ✅ ACTIF | 5 |  |
-| `./src/cutcell.jl` | 1636 | `capacities` | ✅ ACTIF | 28 |  |
-| `./src/cutcell.jl` | 2095 | `set_cap_bcs!` | ✅ ACTIF | 11 |  |
-| `./src/cutcell.jl` | 2134 | `set_cap_diff_S_L!` | ✅ ACTIF | 6 |  |
-| `./src/cutcell.jl` | 2150 | `set_cap_bcs!` | ✅ ACTIF | 11 |  |
-| `./src/cutcell.jl` | 2311 | `set_cap_bcs!` | ✅ ACTIF | 11 |  |
-| `./src/cutcell.jl` | 2468 | `Bcapacities` | ✅ ACTIF | 13 |  |
-| `./src/cutcell.jl` | 2508 | `Wcapacities!` | ✅ ACTIF | 9 |  |
-| `./src/cutcell.jl` | 2546 | `face_capacities` | ✅ ACTIF | 4 |  |
-| `./src/cutcell.jl` | 2583 | `EAST_face` | ✅ ACTIF | 7 |  |
-| `./src/cutcell.jl` | 2613 | `WEST_face` | ✅ ACTIF | 7 |  |
-| `./src/cutcell.jl` | 2632 | `SOUTH_face` | ✅ ACTIF | 7 |  |
-| `./src/cutcell.jl` | 2652 | `NORTH_face` | ✅ ACTIF | 7 |  |
-| `./src/cutcell.jl` | 2680 | `average_face_capacities` | ✅ ACTIF | 10 |  |
-| `./src/cutcell.jl` | 2736 | `average_face_capacities!` | ✅ ACTIF | 8 |  |
-| `./src/cutcell.jl` | 2789 | `get_cells_indices` | ✅ ACTIF | 9 |  |
-| `./src/cutcell.jl` | 2820 | `get_cells_indices` | ✅ ACTIF | 9 |  |
-| `./src/cutcell.jl` | 2848 | `get_cells_indices` | ✅ ACTIF | 9 |  |
-| `./src/cutcell.jl` | 2880 | `get_NB_width` | ✅ ACTIF | 8 |  |
-| `./src/cutcell.jl` | 2890 | `get_NB_width` | ✅ ACTIF | 8 |  |
-| `./src/cutcell.jl` | 2965 | `projection_2points` | ✅ ACTIF | 3 |  |
-| `./src/cutcell.jl` | 3047 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/cutcell.jl` | 3087 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/cutcell.jl` | 3104 | `init_fresh_cells!` | ✅ ACTIF | 15 |  |
-| `./src/cutcell.jl` | 3117 | `init_fresh_cells!` | ✅ ACTIF | 15 |  |
-| `./src/cutcell.jl` | 3132 | `init_fresh_cells!` | ✅ ACTIF | 15 |  |
-| `./src/cutcell.jl` | 3145 | `init_fresh_cells!` | ✅ ACTIF | 15 |  |
-| `./src/cutcell.jl` | 3160 | `init_fresh_cells!` | ✅ ACTIF | 15 |  |
-| `./src/cutcell.jl` | 3178 | `x_extrapolation` | ✅ ACTIF | 6 |  |
-| `./src/cutcell.jl` | 3184 | `y_extrapolation` | ✅ ACTIF | 6 |  |
-| `./src/electrolysis_2.jl` | 16 | **butler_volmer_concentration** | 💀 MORT | 1 |  |
-| `./src/electrolysis_2.jl` | 35 | `butler_volmer_no_concentration` | ✅ ACTIF | 30 |  |
-| `./src/electrolysis_2.jl` | 54 | **derivative_butler_volmer_no_concentration** | 💀 MORT | 1 |  |
-| `./src/electrolysis_2.jl` | 69 | **butler_volmer_no_concentration!** | 💀 MORT | 1 |  |
-| `./src/electrolysis_2.jl` | 84 | **butler_volmer_no_concentration_concentration_Neumann!** | 💀 MORT | 1 |  |
-| `./src/electrolysis_2.jl` | 99 | `butler_volmer_no_concentration_concentration_Neumann` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_2.jl` | 110 | `electrical_conductivity!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_2.jl` | 122 | `butler_volmer_no_concentration_potential_Neumann!` | ✅ ACTIF | 5 |  |
-| `./src/electrolysis_2.jl` | 135 | `butler_volmer_no_concentration_potential_Neumann` | ✅ ACTIF | 14 |  |
-| `./src/electrolysis_2.jl` | 149 | `butler_volmer_no_concentration_potential_Neumann_no_struct!` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis_2.jl` | 159 | `compute_ele_cond` | ✅ ACTIF | 5 |  |
-| `./src/common.jl` | 135 | `veci` | ✅ ACTIF | 418 |  |
-| `./src/common.jl` | 245 | **smekerka_curvature** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 301 | `debug_val` | ✅ ACTIF | 11 |  |
-| `./src/common.jl` | 427 | **mean_curvature_interpolated** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 441 | **interpolated_curvature** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 513 | `get_NB_width_indices_base` | ✅ ACTIF | 4 |  |
-| `./src/common.jl` | 519 | `get_NB_width_indices_base1` | ✅ ACTIF | 3 |  |
-| `./src/common.jl` | 583 | `fit_order` | ✅ ACTIF | 12 |  |
-| `./src/common.jl` | 606 | **find_2closest_points** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 625 | **monitor** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 635 | `within_cell` | ✅ ACTIF | 2 |  |
-| `./src/common.jl` | 643 | `points2polygon` | ✅ ACTIF | 3 |  |
-| `./src/common.jl` | 742 | `get_fresh_cells!` | ✅ ACTIF | 7 |  |
-| `./src/common.jl` | 752 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/common.jl` | 762 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/common.jl` | 773 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/common.jl` | 784 | `kill_dead_cells!` | ✅ ACTIF | 129 |  |
-| `./src/common.jl` | 796 | **init_borders!** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 900 | `export_all` | ✅ ACTIF | 3 |  |
-| `./src/common.jl` | 912 | `mat_assign!` | ✅ ACTIF | 11 |  |
-| `./src/common.jl` | 930 | `mat_assign_T!` | ✅ ACTIF | 16 |  |
-| `./src/common.jl` | 944 | **mat_op!** | 💀 MORT | 1 |  |
-| `./src/common.jl` | 960 | `mat_T_op!` | ✅ ACTIF | 5 |  |
-| `./src/common.jl` | 1034 | `mytime_print` | ✅ ACTIF | 2 |  |
-| `./src/surface_tension_LS.jl` | 5 | `compute_surface_tension_LS!` | ✅ ACTIF | 4 |  |
-| `./src/surface_tension_LS.jl` | 198 | `compute_curvature_levelset` | ✅ ACTIF | 2 |  |
-| `./src/surface_tension_LS.jl` | 231 | `compute_unit_normal` | ✅ ACTIF | 3 |  |
-| `./src/surface_tension_LS.jl` | 429 | **compute_unit_normal_debug** | 💀 MORT | 1 |  |
-| `./src/surface_tension_LS.jl` | 606 | `compute_curvature_cutcell_operator` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_init.jl` | 4 | `Poiseuille_fmax` | ✅ ACTIF | 55 |  |
-| `./src/electrolysis_init.jl` | 9 | `Poiseuille_favg` | ✅ ACTIF | 27 |  |
-| `./src/electrolysis_init.jl` | 14 | `test_Poiseuille` | ✅ ACTIF | 21 |  |
-| `./src/navier_stokes_coupled.jl` | 15 | `set_borders!` | ✅ ACTIF | 21 |  |
-| `./src/navier_stokes_coupled.jl` | 199 | `update_dirichlet_field!` | ✅ ACTIF | 5 |  |
-| `./src/navier_stokes_coupled.jl` | 269 | `set_cutcell_matrices!` | ✅ ACTIF | 5 |  |
-| `./src/navier_stokes_coupled.jl` | 332 | `set_other_cutcell_matrices!` | ✅ ACTIF | 3 |  |
-| `./src/navier_stokes_coupled.jl` | 358 | `set_boundary_indicator!` | ✅ ACTIF | 9 |  |
-| `./src/navier_stokes_coupled.jl` | 386 | `set_boundary_indicator!` | ✅ ACTIF | 9 |  |
-| `./src/navier_stokes_coupled.jl` | 414 | `set_boundary_indicator!` | ✅ ACTIF | 9 |  |
-| `./src/navier_stokes_coupled.jl` | 441 | `set_border_matrices!` | ✅ ACTIF | 2 |  |
-| `./src/navier_stokes_coupled.jl` | 485 | `laplacian` | ✅ ACTIF | 33 |  |
-| `./src/navier_stokes_coupled.jl` | 503 | `laplacian_bc` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 536 | `set_matrices!` | ✅ ACTIF | 22 |  |
-| `./src/navier_stokes_coupled.jl` | 602 | `strain_rate` | ✅ ACTIF | 18 |  |
-| `./src/navier_stokes_coupled.jl` | 617 | `no_slip_condition!` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 649 | `set_convection!` | ✅ ACTIF | 7 |  |
-| `./src/navier_stokes_coupled.jl` | 802 | `FE_set_momentum_coupled` | ✅ ACTIF | 16 |  |
-| `./src/navier_stokes_coupled.jl` | 1436 | `set_velocity_boundary_conditions` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 1571 | `interpolating_coefficient_Navier` | ✅ ACTIF | 16 |  |
-| `./src/navier_stokes_coupled.jl` | 1622 | `interpolating_coefficient_Navier` | ✅ ACTIF | 16 |  |
-| `./src/navier_stokes_coupled.jl` | 1692 | `interpolating_coefficient_Navier` | ✅ ACTIF | 16 |  |
-| `./src/navier_stokes_coupled.jl` | 1737 | `interpolating_coefficient_Navier` | ✅ ACTIF | 16 |  |
-| `./src/navier_stokes_coupled.jl` | 1809 | `interpolating_coefficient_Navier_uv_grids_to_p_grid_volume` | ✅ ACTIF | 7 |  |
-| `./src/navier_stokes_coupled.jl` | 1848 | `interpolating_coefficient_Navier_uv_grids_to_p_grid_height` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 1891 | `CN_set_momentum` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 2019 | `FE_set_momentum` | ✅ ACTIF | 13 |  |
-| `./src/navier_stokes_coupled.jl` | 2137 | **FE_set_momentum_old** | 💀 MORT | 1 |  |
-| `./src/navier_stokes_coupled.jl` | 2262 | `set_poisson` | ✅ ACTIF | 28 |  |
-| `./src/navier_stokes_coupled.jl` | 2370 | `set_Crank_Nicolson!` | ✅ ACTIF | 7 |  |
-| `./src/navier_stokes_coupled.jl` | 2496 | `set_Forward_Euler!` | ✅ ACTIF | 5 |  |
-| `./src/navier_stokes_coupled.jl` | 2675 | `pressure_projection!` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 3398 | `coupled_pressure_velocity!` | ✅ ACTIF | 2 |  |
-| `./src/navier_stokes_coupled.jl` | 4210 | `linear_advection!` | ✅ ACTIF | 4 |  |
-| `./src/navier_stokes_coupled.jl` | 4278 | `residual` | ✅ ACTIF | 28 |  |
-| `./src/navier_stokes_coupled.jl` | 4319 | `dresidual` | ✅ ACTIF | 2 |  |
-| `./src/fill_struct.jl` | 8 | `safefill` | ✅ ACTIF | 2 |  |
-| `./src/fill_struct.jl` | 35 | **safefill_with_aliases** | 💀 MORT | 1 |  |
-| `./src/fill_struct.jl` | 59 | **safefill_with_aliases_and_extra** | 💀 MORT | 1 |  |
-| `./src/fill_struct.jl` | 79 | `safefill_with_aliases_and_extra_already_init` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis.jl` | 13 | **pdi_expose_data** | 💀 MORT | 1 |  |
-| `./src/electrolysis.jl` | 41 | `interpolate_grid_liquid!` | ✅ ACTIF | 21 |  |
-| `./src/electrolysis.jl` | 70 | `interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!` | ✅ ACTIF | 13 |  |
-| `./src/electrolysis.jl` | 87 | `check_divergence!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis.jl` | 98 | `convert_interfacial_D_to_segments` | ✅ ACTIF | 12 |  |
-| `./src/electrolysis.jl` | 124 | `adapt_timestep!` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis.jl` | 164 | `update_electrical_conductivity!` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis.jl` | 190 | `compute_grad_phi_ele!` | ✅ ACTIF | 37 |  |
-| `./src/electrolysis.jl` | 270 | `solve_poisson_loop!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis.jl` | 360 | `set_convection_2!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis.jl` | 377 | `update_BC_electrical_potential_left!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis.jl` | 383 | `veci` | ✅ ACTIF | 418 |  |
-| `./src/electrolysis.jl` | 389 | `vecb_L` | ✅ ACTIF | 164 |  |
-| `./src/electrolysis.jl` | 390 | `vecb_R` | ✅ ACTIF | 109 |  |
-| `./src/electrolysis.jl` | 391 | `vecb_B` | ✅ ACTIF | 125 |  |
-| `./src/electrolysis.jl` | 392 | `vecb_T` | ✅ ACTIF | 120 |  |
-| `./src/electrolysis.jl` | 395 | `solve_poisson_variable_coeff!` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis.jl` | 396 | `update_electrical_current_from_Butler_Volmer_func!` | ✅ ACTIF | 3 |  |
-| `./src/electrolysis.jl` | 397 | `handle_special_cells_electrical_potential!` | ✅ ACTIF | 2 |  |
-| `./src/solve_one_fluid.jl` | 86 | `solve_one_fluid_NS_no_phase!` | ✅ ACTIF | 7 |  |
-| `./src/electrolysis_operators.jl` | 9 | **compute_grad_T_x_T_y_array!** | 💀 MORT | 1 |  |
-| `./src/electrolysis_operators.jl` | 31 | `compute_grad_T_x_T_y_array_u_v_capacities!` | ✅ ACTIF | 23 |  |
-| `./src/electrolysis_operators.jl` | 74 | `compute_grad_T_x_T_y_array_u_v_capacities_cell_integrated!` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_operators.jl` | 116 | `compute_grad_T_x_array!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_operators.jl` | 133 | `compute_grad_T_y_array!` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_operators.jl` | 200 | `integrate_mass_transfer_rate_over_interface` | ✅ ACTIF | 4 |  |
-| `./src/electrolysis_operators.jl` | 411 | **integrate_mass_transfer_rate_over_interface_old** | 💀 MORT | 1 |  |
-| `./src/electrolysis_operators.jl` | 578 | `integrate_mass_transfer_rate_over_interface_no_writing` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_operators.jl` | 738 | `integrate_mass_transfer_rate_over_interface_2` | ✅ ACTIF | 2 |  |
-| `./src/electrolysis_operators.jl` | 903 | `integrate_mass_transfer_rate_over_interface_2_no_writing` | ✅ ACTIF | 2 |  |
-| `./src/operators_coupled.jl` | 1 | **fill_empty_rows!** | 💀 MORT | 1 |  |
-| `./src/operators_coupled.jl` | 22 | `pad` | ✅ ACTIF | 64 |  |
-| `./src/operators_coupled.jl` | 36 | `pad_crank_nicolson` | ✅ ACTIF | 19 |  |
-| `./src/operators_coupled.jl` | 85 | `divergence_B!` | ✅ ACTIF | 4 |  |
-| `./src/operators_coupled.jl` | 110 | `divergence_A!` | ✅ ACTIF | 3 |  |
-| `./src/operators_coupled.jl` | 180 | `bc_matrix!` | ✅ ACTIF | 8 |  |
-| `./src/operators_coupled.jl` | 239 | `bc_matrix!` | ✅ ACTIF | 8 |  |
-| `./src/operators_coupled.jl` | 297 | `bc_matrix!` | ✅ ACTIF | 8 |  |
-| `./src/operators_coupled.jl` | 356 | `bc_matrix!` | ✅ ACTIF | 8 |  |
-| `./src/operators_coupled.jl` | 422 | `periodic_bcs!` | ✅ ACTIF | 5 |  |
-| `./src/operators_coupled.jl` | 463 | `periodic_bcs_R!` | ✅ ACTIF | 2 |  |
-| `./src/operators_coupled.jl` | 498 | `mass_matrix_borders!` | ✅ ACTIF | 5 |  |
-| `./src/operators_coupled.jl` | 535 | `bc_matrix_borders!` | ✅ ACTIF | 14 |  |
-| `./src/operators_coupled.jl` | 564 | `bc_matrix_borders!` | ✅ ACTIF | 14 |  |
-| `./src/operators_coupled.jl` | 594 | `bc_matrix_borders!` | ✅ ACTIF | 14 |  |
-| `./src/operators_coupled.jl` | 631 | `bc_matrix_borders!` | ✅ ACTIF | 14 |  |
-| `./src/operators_coupled.jl` | 678 | `periodic_bcs_borders!` | ✅ ACTIF | 5 |  |
-| `./src/surface_tension_VOF.jl` | 5 | `compute_surface_tension_VOF!` | ✅ ACTIF | 3 |  |
-| `./src/compute_mass_transfer_rate.jl` | 1 | `compute_mass_transfer_rate_main!` | ✅ ACTIF | 2 |  |
-| `./src/compute_mass_transfer_rate.jl` | 362 | `compute_conservation_mass` | ✅ ACTIF | 6 |  |
-| `./src/compute_mass_transfer_rate.jl` | 423 | `extract_border_capacities_1D` | ✅ ACTIF | 2 |  |
-| `./src/compute_mass_transfer_rate.jl` | 457 | `extract_border_capacities_1D_one_fluid` | ✅ ACTIF | 2 |  |
-| `./src/compute_mass_transfer_rate.jl` | 484 | `extract_vec_1D_one_fluid` | ✅ ACTIF | 2 |  |
-| `./validation/crystal_growth.jl` | 6 | `surface_tension_effect` | ✅ ACTIF | 2 |  |
-| `./validation/grid_effect_crystal.jl` | 6 | `grid_effect` | ✅ ACTIF | 2 |  |
-| `./validation/IIOE_CFL.jl` | 10 | `conv_IIOE_CFL` | ✅ ACTIF | 2 |  |
-| `./validation/cutcell_validation.jl` | 8 | `conv_cutcell_CN` | ✅ ACTIF | 2 |  |
-| `./validation/johansen_colella.jl` | 8 | `conv_cutcell_johansen_colella` | ✅ ACTIF | 2 |  |
-| `./validation/Frank.jl` | 8 | `conv_Frank` | ✅ ACTIF | 2 |  |
-| `./validation/NB_test.jl` | 6 | `test_NB` | ✅ ACTIF | 2 |  |
-| `./test/poisson.jl` | 14 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson.jl` | 36 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson.jl` | 44 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson.jl` | 54 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson.jl` | 69 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_square.jl` | 21 | `minusf` | ✅ ACTIF | 3 | Test |
-| `./test/poisson_square.jl` | 28 | `minus` | ✅ ACTIF | 4 | Test |
-| `./test/poisson_square.jl` | 48 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_square.jl` | 56 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square.jl` | 66 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_square.jl` | 81 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_no_interface_right_Neumann.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_no_interface_right_Neumann.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_no_interface_right_Neumann.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_no_interface_right_Neumann.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_no_interface_right_Neumann.jl` | 73 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/validation_test.jl` | 77 | `run_case` | ✅ ACTIF | 13 | Test |
-| `./test/poisson_circular_interface_Neumann.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_circular_interface_Neumann.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_circular_interface_Neumann.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_circular_interface_Neumann.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_circular_interface_Neumann.jl` | 89 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 21 | `minusf` | ✅ ACTIF | 3 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 28 | `minus` | ✅ ACTIF | 4 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 48 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 56 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 66 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_square_solve_poisson_lin.jl` | 81 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_solve_poisson.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_square_solve_poisson.jl` | 34 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_square_solve_poisson.jl` | 42 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_solve_poisson.jl` | 52 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_square_solve_poisson.jl` | 67 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_no_interface.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_no_interface.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_no_interface.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_no_interface.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_no_interface.jl` | 73 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 19 | `minusf` | ✅ ACTIF | 3 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 24 | `minus` | ✅ ACTIF | 4 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 44 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 52 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 62 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_square_constant_solve_poisson.jl` | 77 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_circular_interface_wall.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_circular_interface_wall.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_circular_interface_wall.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_circular_interface_wall.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_circular_interface_wall.jl` | 73 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_circular_interface_Dirichlet.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_circular_interface_Dirichlet.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_circular_interface_Dirichlet.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_circular_interface_Dirichlet.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_circular_interface_Dirichlet.jl` | 73 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_circle_solve_poisson_cos_cos.jl` | 10 | `f` | ✅ ACTIF | 573 | Test |
-| `./test/poisson_square_circle_solve_poisson_cos_cos.jl` | 40 | `regression` | ✅ ACTIF | 128 | Test |
-| `./test/poisson_square_circle_solve_poisson_cos_cos.jl` | 48 | `dirichlet_bcs!` | ✅ ACTIF | 24 | Test |
-| `./test/poisson_square_circle_solve_poisson_cos_cos.jl` | 58 | `neumann_bcs!` | ✅ ACTIF | 26 | Test |
-| `./test/poisson_square_circle_solve_poisson_cos_cos.jl` | 73 | `robin_bcs!` | ✅ ACTIF | 24 | Test |
-
-## 📊 Statistiques
-- Fonctions Actives : 0
-- Fonctions Mortes (candidates) : 0
-- **Total analysé : 0**

Typetracer.jl

@@ -1,90 +0,0 @@
-module TypeTracer
-
-using Serialization
-
-# Singleton pour stocker les signatures uniques (Thread-safe)
-const SEEN_SIGNATURES = Set{String}()
-const LOCK = ReentrantLock()
-const LOG_FILE = "execution_trace.txt"
-
-"""
-Fonction interne pour enregistrer une signature.
-Format: FunctionName(ArgType1, ArgType2, ...) -> ReturnType
-"""
-function _record_call(func_name, args, result)
-    # On map les types Julia vers des chaînes de caractères
-    arg_types = join([string(typeof(a)) for a in args], ", ")
-    ret_type = string(typeof(result))
-    
-    signature = "$func_name($arg_types) -> $ret_type"
-
-    # Vérification avec lock pour le multi-threading (fréquent en simu)
-    lock(LOCK) do
-        if !(signature in SEEN_SIGNATURES)
-            push!(SEEN_SIGNATURES, signature)
-            # On écrit immédiatement pour ne rien perdre en cas de crash
-            open(LOG_FILE, "a") do io
-                println(io, signature)
-            end
-            # Un petit echo console pour voir que ça vit
-            println("[TRACER] Nouvelle variante capturée : $signature")
-        end
-    end
-end
-
-"""
-Macro à placer devant les définitions de fonctions.
-Elle enveloppe le corps de la fonction pour logger les types.
-"""
-macro monitor(expr)
-    # Vérifie qu'on applique bien la macro sur une définition de fonction
-    if expr.head !== :function && expr.head !== :(=)
-        error("La macro @monitor doit être appliquée à une définition de fonction.")
-    end
-
-    # Extraction de la signature (nom + args) et du corps
-    call_def = expr.args[1]
-    body = expr.args[2]
-
-    # Récupération du nom de la fonction (gestion cas f(x) et Module.f(x))
-    func_name = length(call_def.args) >= 1 ? call_def.args[1] : :anonymous
-    
-    # On reconstruit la fonction avec l'instrumentation
-    quote
-        function $(call_def)
-            # 1. Exécuter le corps original et capturer le résultat
-            __result = $(body)
-            
-            # 2. Récupérer les arguments (via ... dans la macro c'est délicat, 
-            # donc on utilise une astuce : on capture les valeurs des arguments par leur nom)
-            # Note : Pour une conversion C, on a besoin des types concrets à l'exécution.
-            # Ici, on passe un tuple des arguments.
-            # Attention : cela suppose que call_def.args contient les noms des variables.
-            
-            # Pour faire simple et robuste sans métaprogrammation complexe sur les arguments :
-            # On logue juste le fait qu'on est passé ici.
-            # MAIS pour avoir les args, il faut être plus malin.
-            
-            # Approche simplifiée : On logue à la fin
-            TypeTracer._record_call(
-                $(string(func_name)), 
-                # On capture tous les arguments de la fonction courante
-                # (nécessite que la fonction ne soit pas anonyme pure)
-                (Base.@locals()...,), # Capture tout le scope local (arguments inclus)
-                __result
-            )
-            
-            return __result
-        end
-    end |> esc
-end
-
-# Fonction de nettoyage pour vider le log au début
-function init_trace()
-    if isfile(LOG_FILE)
-        rm(LOG_FILE)
-    end
-    println("--- Démarrage du traçage des types ---")
-end
-
-end

audit_usage.sh

@@ -1,80 +0,0 @@
-#!/bin/bash
-
-# Fichier de sortie
-OUT="RAPPORT_USAGE_CODE_MORT.md"
-
-echo "# 💀 Audit de Code Mort & Usage" > "$OUT"
-echo "Analyse basée sur la recherche textuelle exacte des noms de fonctions." >> "$OUT"
-echo "" >> "$OUT"
-echo "| Fichier | Ligne | Fonction | État | Occurrences | Note |" >> "$OUT"
-echo "|---|---|---|---|---|---|" >> "$OUT"
-
-# Compteurs
-dead_count=0
-alive_count=0
-
-# On boucle sur toutes les lignes contenant "function ..."
-# On exclut les commentaires
-grep -r -n "^\s*function" --include="*.jl" . | grep -v "#" | while read -r line ; do
-
-    # 1. Extraction des métadonnées
-    file=$(echo "$line" | cut -d: -f1)
-    lineno=$(echo "$line" | cut -d: -f2)
-    
-    # Extraction propre du nom de la fonction (entre "function" et "(")
-    # Ex: "function solve_poisson!(...)" -> "solve_poisson!"
-    func_name=$(echo "$line" | sed -E 's/.*function\s+([a-zA-Z0-9_!]+).*/\1/')
-    
-    # Sécurité: ignorer si le nom est vide ou bizarre
-    if [[ -z "$func_name" || "$func_name" == *"function"* ]]; then
-        continue
-    fi
-
-    # 2. Comptage des occurrences (Recherche mot entier -w)
-    # On cherche dans tout le dossier courant (.)
-    count=$(grep -r -w --include="*.jl" "$func_name" . | wc -l)
-
-    # 3. Classification
-    status=""
-    note=""
-    
-    if [ "$count" -eq 1 ]; then
-        # Si count == 1, c'est que le mot n'apparait QUE dans sa définition -> Code Mort
-        status="💀 MORT"
-        ((dead_count++))
-    else
-        # Si count > 1, elle est appelée quelque part
-        status="✅ ACTIF"
-        ((alive_count++))
-        
-        # Petit bonus : on vérifie si c'est un test ou un exemple qui l'appelle
-        if grep -q "test/" <<< "$file"; then
-             note="Test"
-        elif grep -q "examples/" <<< "$file"; then
-             note="Exemple"
-        fi
-    fi
-
-    # 4. Écriture dans le rapport (Format Markdown)
-    # On met en gras les fonctions mortes pour qu'elles sautent aux yeux
-    if [ "$status" == "💀 MORT" ]; then
-        echo "| \`$file\` | $lineno | **$func_name** | $status | $count | $note |" >> "$OUT"
-    else
-        echo "| \`$file\` | $lineno | \`$func_name\` | $status | $count | $note |" >> "$OUT"
-    fi
-
-    # Feedback visuel dans le terminal (optionnel)
-    # echo -ne "Scanned: $func_name ($count)\r"
-
-done
-
-# Résumé à la fin
-echo "" >> "$OUT"
-echo "## 📊 Statistiques" >> "$OUT"
-echo "- Fonctions Actives : $alive_count" >> "$OUT"
-echo "- Fonctions Mortes (candidates) : $dead_count" >> "$OUT"
-echo "- **Total analysé : $((alive_count + dead_count))**" >> "$OUT"
-
-echo "✅ Audit terminé. Résultats dans : $OUT"
-echo "    -> Actives : $alive_count"
-echo "    -> Mortes  : $dead_count"

c4level2_electrolysis.txt

@@ -1,56 +0,0 @@
-@startuml C4_Flower_Architecture
-!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml
-
-' LAYOUT TOP_DOWN
-LAYOUT_WITH_LEGEND()
-
-title Diagramme C4 Container - Architecture Actuelle de Flower.jl
-
-Person(user, "Utilisateur / Physicien", "Configure et lance la simulation")
-
-System_Boundary(flower_system, "Flower.jl (Simulation CFD & Electrolyse)") {
-
-    Container(driver, "Driver / Entry Point", "Julia Script (convergence.jl)", "Point d'entrée. Parse les arguments, initialise la mémoire globale et lance la simulation.")
-    
-    Container(config, "Configuration Parser", "YAML / PropertyDict", "Charge les paramètres physiques et numériques (ex: convergence...Newton.yml).")
-
-    Container(orchestrator, "Time Orchestrator", "run.jl", "Gère la boucle temporelle (while t < t_end), le pas de temps adaptatif (CFL) et l'enchaînement des solveurs.")
-
-    Container(data_struct, "Data & Mesh Manager", "geometry.jl / common.jl", "Structure de données centrale.\nGère les Grilles Décalées (Staggered), les Champs (Vitesse, Pression, Potentiel) et les LevelSets.")
-
-    Container_Boundary(physics_kernels, "Noyaux Physiques (Computing Kernels)") {
-        Container(mod_ns, "Navier-Stokes Solver", "navier_stokes.jl", "Résout l'équation de mouvement (Momentum) et la conservation de la masse.")
-        Container(mod_elec, "Electrolysis Module", "electrolysis.jl", "Résout le Potentiel Électrique, la Loi d'Ohm et la cinétique Butler-Volmer.")
-        Container(mod_trans, "Transport & Phase", "transport.jl / levelset", "Gère le transport des espèces et l'interface (LevelSet/VOF).")
-    }
-
-    Container(lin_solver, "Linear Algebra Wrapper", "poisson.jl / operators.jl", "Assemble les matrices A et les vecteurs b. Appelle les solveurs creux (SparseArrays / IterativeSolvers).")
-
-    Container(io_interface, "I/O Interface", "PDI / HDF5 / Viz", "Exporte les données pour la visualisation (Paraview) et le checkpointing via la librairie PDI.")
-
-}
-
-System_Ext(libpdi, "Librairie PDI", "C/C++ Library", "Gestionnaire d'événements et d'E/S haute performance.")
-
-' Relations
-Rel(user, driver, "Lance la simulation", "CLI")
-Rel(driver, config, "Lit", "YAML")
-Rel(driver, data_struct, "Alloue & Initialise", "Struct Numerical & Mesh")
-Rel(driver, orchestrator, "Démarre", "run_forward!")
-
-Rel(orchestrator, mod_ns, "Appelle (Time step)", "run_navier_stokes!")
-Rel(orchestrator, mod_elec, "Appelle (Time step)", "solve_poisson_loop!")
-Rel(orchestrator, mod_trans, "Appelle (Advection)", "transport!")
-Rel(orchestrator, io_interface, "Notifie", "Events PDI")
-
-Rel_D(mod_ns, data_struct, "Lit/Écrit", "u, v, p")
-Rel_D(mod_elec, data_struct, "Lit/Écrit", "phi, sigma")
-Rel_D(mod_trans, data_struct, "Lit/Écrit", "LevelSet")
-
-Rel(mod_elec, lin_solver, "Résout Ax=b", "Laplacien Potentiel")
-Rel(mod_ns, lin_solver, "Résout Ax=b", "Projection Pression")
-
-Rel(io_interface, libpdi, "Calls", "C API")
-Rel_U(io_interface, data_struct, "Lit (Pointeurs)", "Champs bruts")
-
-@enduml

c4level3_electrolysis.txt

@@ -1,65 +0,0 @@
-@startuml C4_Flower_Functional_Logic
-!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Component.puml
-
-' LAYOUT TOP_DOWN
-LAYOUT_WITH_LEGEND()
-
-title Diagramme C4 (Niveau 3) - Logique Fonctionnelle & Physique
-
-Container(main, "Sim Launcher", "C / Julia", "Configure la physique (Re, CFL, Géométrie) et alloue la mémoire.")
-
-Container_Boundary(sim_core, "Cœur de Simulation (Boucle Temporelle)") {
-
-    Component(time_loop, "Orchestrateur Temporel", "run_forward!", "QUOI: Séquence les opérateurs (Fluide -> Elec -> Transport).\nPOURQUOI: Faire avancer l'état physique du temps t au temps t+dt.")
-    
-    Component(timestep, "Contrôleur de Stabilité (CFL)", "adapt_timestep!", "QUOI: Calcule dt = min(dx/u, dx²/D).\nPOURQUOI: Garantir que la simulation ne diverge pas (explose) numériquement.")
-
-    Component(memory, "État Physique (State)", "Structs", "QUOI: Stocke les champs (u,v,p,phi) et l'interface.\nPOURQUOI: Maintenir la continuité de la physique entre les itérations.")
-
-    ' --- SOUS-SYSTÈME ELECTROLYSE ---
-    Boundary(mod_elec, "Module Électrolyse (Résolution du Potentiel)", "electrolysis.c") {
-        
-        Component(updater_sigma, "Calcul Conductivité (Sigma)", "update_electrical_conductivity", "QUOI: Mappe la Phase (Liq/Gaz) vers la Conductivité (10.0 / 0.0).\nPOURQUOI: Le courant ne passe que dans le liquide (Loi d'Ohm locale).")
-        
-        Component(solver_poisson, "Solveur de Poisson", "solve_poisson_loop", "QUOI: Résout l'équation div(sigma * grad(phi)) = 0.\nPOURQUOI: Trouver le Potentiel Électrique qui respecte la conservation de la charge.")
-        
-        Component(flux_calc, "Calcul de Flux (Loi d'Ohm)", "compute_current_density", "QUOI: Calcule J = -sigma * grad(phi) par différences finies.\nPOURQUOI: Connaître la densité de courant (A/m²) pour la réaction électrochimique.")
-    }
-
-    ' --- SOUS-SYSTÈME FLUIDE ---
-    Boundary(mod_ns, "Module Navier-Stokes (Dynamique des Fluides)", "navier_stokes.c") {
-        Component(ns_solver, "Solveur de Mouvement", "run_navier_stokes!", "QUOI: Résout Navier-Stokes + Incompressibilité.\nPOURQUOI: Déplacer le fluide et l'interface sous l'effet des forces.")
-    }
-
-    ' --- OUTILS MATHS ---
-    Component(lin_alg, "Algèbre Linéaire", "Ax = b Solver", "QUOI: Inverse la matrice Laplacienne.\nPOURQUOI: Outil mathématique nécessaire pour résoudre l'équation de Poisson.")
-
-    ' --- SORTIES ---
-    Component(io_pdi, "Export Données", "PDI / HDF5", "QUOI: Écrit les champs 2D/3D sur disque.\nPOURQUOI: Permettre la visualisation (Paraview) et le post-traitement scientifique.")
-}
-
-' --- FLUX DE DONNÉES ET CAUSALITÉ ---
-
-Rel(main, memory, "Initialise (t=0)")
-Rel(main, time_loop, "Lance")
-
-' Déroulement d'un pas de temps
-Rel(time_loop, timestep, "1. Vérifie stabilité")
-Rel(time_loop, ns_solver, "2. Bouge le fluide")
-Rel(time_loop, solver_poisson, "3. Établit le champ électrique")
-Rel(time_loop, io_pdi, "4. Sauvegarde")
-
-' Logique Interne Electrolyse
-Rel(solver_poisson, updater_sigma, "A. Prépare le milieu (Où est le liquide ?)")
-Rel(updater_sigma, memory, "Lit LevelSet / Écrit Sigma")
-
-Rel(solver_poisson, lin_alg, "B. Résout l'équilibre (Matrice)")
-Rel(lin_alg, memory, "Met à jour Phi (Potentiel)")
-
-Rel(solver_poisson, flux_calc, "C. Dérive le courant (Post-process)")
-Rel(flux_calc, memory, "Lit Phi / Écrit J (Vecteur)")
-
-' Liens transverses
-Rel(timestep, memory, "Lit Vitesse Max")
-
-@enduml

common.jl

@@ -1,1064 +0,0 @@
-"""
-    lexicographic(II, n)
-
-Returns the index of type `Int` corresponding to the 1D view of a `n × n` array at the CartesianIndex `II`.
-
-"""
-@inline lexicographic(II, n) = muladd(n, II[2]-1, II[1])
-@inline within_bounds(i, grid) = 1 <= i <= grid.nx*grid.ny
-@inline within_bounds(i::CartesianIndex, grid) = 1 <= i[1] <= grid.ny && 1 <= i[2] <= grid.nx
-
-const newaxis = [CartesianIndex()]
-
-@inline δy⁺(II) = CartesianIndex(II[1]+1, II[2])
-@inline δy⁻(II) = CartesianIndex(II[1]-1, II[2])
-@inline δx⁺(II) = CartesianIndex(II[1], II[2]+1)
-@inline δx⁻(II) = CartesianIndex(II[1], II[2]-1)
-
-@inline δy⁺(II, ny, per) = per && II[1]==ny ? CartesianIndex(1, II[2]) : δy⁺(II)
-@inline δy⁻(II, ny, per) = per && II[1]==1 ? CartesianIndex(ny, II[2]) : δy⁻(II)
-@inline δx⁺(II, nx, per) = per && II[2]==nx ? CartesianIndex(II[1], 1) : δx⁺(II)
-@inline δx⁻(II, nx, per) = per && II[2]==1 ? CartesianIndex(II[1], nx) : δx⁻(II)
-
-@inline zeros(g::Grid) = zeros(g.ny, g.nx)
-@inline zeros(a::Integer, g::Grid) = zeros(a, g.ny, g.nx)
-@inline zeros(g::Grid, a::Integer) = zeros(g.ny, g.nx, a)
-
-@inline fzeros(g::Grid) = zeros(g.ny * g.nx)
-@inline fzeros(a::Integer, g::Grid) = zeros(a, g.ny * g.nx)
-@inline fzeros(g::Grid, a::Integer) = zeros(g.ny * g.nx, a)
-
-@inline f2zeros(g::Grid) = zeros(2 * g.ny * g.nx)
-@inline f2zeros(a::Integer, g::Grid) = zeros(a, 2 * g.ny * g.nx)
-@inline f2zeros(g::Grid, a::Integer) = zeros(2 * g.ny * g.nx, a)
-
-@inline f3zeros(g::Grid) = zeros(2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline f3zeros(a::Integer, g::Grid) = zeros(a, 2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline f3zeros(g::Grid, a::Integer) = zeros(2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny, a)
-
-@inline fnzeros(g::Grid, n::Numerical) = zeros((n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline fnzeros(a::Integer, g::Grid, n::Numerical) = zeros(a, (n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline fnzeros(g::Grid, n::Numerical, a::Integer) = zeros((n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny, a)
-
-@inline ones(g::Grid) = ones(g.ny, g.nx)
-@inline ones(a::Integer, g::Grid) = ones(a, g.ny, g.nx)
-@inline ones(g::Grid, a::Integer) = ones(g.ny, g.nx,a)
-
-@inline fones(g::Grid) = ones(g.ny * g.nx)
-@inline fones(a::Integer, g::Grid) = ones(a, g.ny * g.nx)
-@inline fones(g::Grid, a::Integer) = ones(g.ny * g.nx, a)
-
-@inline f2ones(g::Grid) = ones(2 * g.ny * g.nx)
-@inline f2ones(a::Integer, g::Grid) = ones(a, 2 * g.ny * g.nx)
-@inline f2ones(g::Grid, a::Integer) = ones(2 * g.ny * g.nx, a)
-
-@inline f3ones(g::Grid) = ones(2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline f3ones(a::Integer, g::Grid) = ones(a, 2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline f3ones(g::Grid, a::Integer) = ones(2 * g.ny * g.nx + 2 * g.nx + 2 * g.ny, a)
-
-@inline fnones(g::Grid, n::Numerical) = ones((n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline fnones(a::Integer, g::Grid, n::Numerical) = ones(a, (n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-@inline fnones(g::Grid, n::Numerical, a::Integer) = ones((n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny, a)
-
-@inline reshape(a, g::Grid) = reshape(a, (g.ny, g.nx))
-
-# Temporary function to get a certain field from a vector with 
-# multiple fields. To be removed when working with decomposed 
-# vectors directly
-"""
-Access bulk (p=1) or interfacial value (from Levelset)
-"""
-veci(a, g::G, p::Integer = 1) where {G<:Grid} = @view a[g.ny*g.nx*(p-1)+1:g.ny*g.nx*p]
-
-"""
-Access bulk value
-"""
-vec1(a, g::G) where {G<:Grid} = @view a[1:g.ny*g.nx]
-
-"""
-Access interfacial value from Levelset 1
-"""
-vec2(a, g::G) where {G<:Grid} = @view a[g.ny*g.nx+1:g.ny*g.nx*2]
-
-"""
-Access interfacial value from Levelset 2
-"""
-vec3(a, g::G) where {G<:Grid} = @view a[g.ny*g.nx*2+1:g.ny*g.nx*3]
-
-"""
-Access border value
-"""
-vecb(a, g::G) where {G<:Grid} = @view a[end-2*g.ny-2*g.nx+1:end]
-
-"""
-Access border value: left
-"""
-vecb_L(a,g::G) where {G<:Grid} = @view vecb(a, g)[1:g.ny]
-
-"""
-Access border value: bottom
-"""
-vecb_B(a,g::G) where {G<:Grid} = @view vecb(a, g)[g.ny+1:g.ny+g.nx]
-
-"""
-Access border value: right
-"""
-vecb_R(a,g::G) where {G<:Grid} = @view vecb(a, g)[g.ny+g.nx+1:2*g.ny+g.nx]
-
-"""
-Access border value: top
-"""
-vecb_T(a,g::G) where {G<:Grid} = @view vecb(a, g)[2*g.ny+g.nx+1:2*g.ny+2*g.nx]
-
-
-"""
-Access border value: left (border part already extracted, for op.opC_pL.Gx_b for ex)
-"""
-left_border_view(a,g::G) where {G<:Grid} = @view a[1:g.ny]
-
-"""
-Access border value: bottom (border part already extracted, for op.opC_pL.Gx_b for ex)
-"""
-bottom_border_view(a,g::G) where {G<:Grid} = @view a[g.ny+1:g.ny+g.nx]
-
-"""
-Access border value: right (border part already extracted, for op.opC_pL.Gx_b for ex)
-"""
-right_border_view(a,g::G) where {G<:Grid} = @view a[g.ny+g.nx+1:2*g.ny+g.nx]
-
-"""
-Access border value: top (border part already extracted, for op.opC_pL.Gx_b for ex)
-"""
-top_border_view(a,g::G) where {G<:Grid} = @view a[2*g.ny+g.nx+1:2*g.ny+2*g.nx]
-
-
-function veci(a, g::Vector{G}, p::Integer) where {G<:Grid}
-    c0 = 1
-    c1 = g[1].ny * g[1].nx
-    for i = 2:p
-        ii = (p - 1) ÷ 2 + 1
-        c0 += g[ii].ny * g[ii].nx
-        c1 += g[ii].ny * g[ii].nx
-    end
-
-    return @view a[c0:c1]
-end
-
-"""
-    volume(geo::GeometricInfo)
-
-Compute the volume of a phase.
-"""
-@inline volume(geo::GeometricInfo) = sum(geo.dcap[:,:,5])
-@inline volume(geo::GeometricInfo, id::AbstractMatrix) = sum(geo.dcap[id,5])
-
-@inline opposite(α) = ifelse(α >= 0. ,α - π, α + π)
-
-@inline distance(A::Point, B::Point, dx=1.0, dy=1.0) =
-    sqrt(((A.x-B.x)*dx)^2 + ((A.y-B.y)*dy)^2)
-@inline distance(xp, yp, θ, xl, yl) = abs(cos(θ) * (yl - yp) - sin(θ) * (xl - xp))
-
-@inline midpoint(A::Point, B::Point) = Point((A.x + B.x)/2 - 0.5, (A.y + B.y)/2 - 0.5)
-
-@inline indomain(A::Point{T}, x::Vector{T}, y::Vector{T}) where {T} =
-    ifelse(A.x >= x[1] && A.x <= x[end] &&
-           A.y >= y[1] && A.y <= y[end], true, false)
-
-@inline <(A::Point{T}, L::T) where {T} = ifelse(abs(A.x) <= L/2 && abs(A.y) <= L/2, true, false)
-@inline isnan(A::Point{T}) where {T} = ifelse(isnan(A.x) || isnan(A.y), true, false)
-@inline +(A::Point{T}, B::Point{T}) where {T} = Point(A.x + B.x, A.y + B.y)
-@inline -(A::Point{T}, B::Point{T}) where {T} = Point(A.x - B.x, A.y - B.y)
-@inline *(A::Point{T}, m::N) where {T, N} = Point(m*A.x, m*A.y)
-@inline *(m::N, A::Point{T}) where {T, N} = Point(m*A.x, m*A.y)
-@inline *(A::Point{T}, B::Point{T}) where {T} = Point(A.x*B.x, A.y*B.y)
-@inline abs(A::Point) = Point(abs(A.x), abs(A.y))
-
-@inline mysign(a,b) = a/sqrt(a^2 + b^2)
-@inline mysign(a) = ifelse(a >= 0, 1, -1)
-
-@inline ⁺(a) = max(a,0)
-@inline ⁻(a) = min(a,0)
-
-@inline c∇x(u, II) = @inbounds u[δx⁺(II)] - u[δx⁻(II)]
-@inline c∇y(u, II) = @inbounds u[δy⁺(II)] - u[δy⁻(II)]
-@inline c∇x(u, II, nx, per) = @inbounds u[δx⁺(II, nx, per)] - u[δx⁻(II, nx, per)]
-@inline c∇y(u, II, ny, per) = @inbounds u[δy⁺(II, ny, per)] - u[δy⁻(II, ny, per)]
-@inline c∇x(u, II, h) = @inbounds (u[δx⁺(II)] - u[δx⁻(II)])/2h
-@inline c∇y(u, II, h) = @inbounds (u[δy⁺(II)] - u[δy⁻(II)])/2h
-@inline c∇x(u, II, h, nx, per) = @inbounds (u[δx⁺(II, nx, per)] - u[δx⁻(II, nx, per)])/h
-@inline c∇y(u, II, h, ny, per) = @inbounds (u[δy⁺(II, ny, per)] - u[δy⁻(II, ny, per)])/h
-
-@inline ∇x⁺(u, II) = @inbounds u[δx⁺(II)] - u[II]
-@inline ∇y⁺(u, II) = @inbounds u[δy⁺(II)] - u[II]
-@inline ∇x⁻(u, II) = @inbounds u[δx⁻(II)] - u[II]
-@inline ∇y⁻(u, II) = @inbounds u[δy⁻(II)] - u[II]
-
-@inline ∇x⁺(u, II, nx, per) = @inbounds u[δx⁺(II, nx, per)] - u[II]
-@inline ∇y⁺(u, II, ny, per) = @inbounds u[δy⁺(II, ny, per)] - u[II]
-@inline ∇x⁻(u, II, nx, per) = @inbounds u[δx⁻(II, nx, per)] - u[II]
-@inline ∇y⁻(u, II, ny, per) = @inbounds u[δy⁻(II, ny, per)] - u[II]
-
-@inline ∇x⁺(u, II, nx, h, per) = @inbounds (u[δx⁺(II, nx, per)] - u[II]) / h[II]
-@inline ∇y⁺(u, II, ny, h, per) = @inbounds (u[δy⁺(II, ny, per)] - u[II]) / h[II]
-@inline ∇x⁻(u, II, nx, h, per) = @inbounds (u[II] - u[δx⁻(II, nx, per)]) / h[II]
-@inline ∇y⁻(u, II, ny, h, per) = @inbounds (u[II] - u[δy⁻(II, ny, per)]) / h[II]
-
-@inline normal(u, II) = @SVector [mysign(c∇x(u, II), c∇y(u, II)), mysign(c∇y(u, II), c∇x(u, II))]
-
-@inline minmod(a, b) = ifelse(a*b <= 0, 0.0, myabs(a,b))
-@inline myabs(a, b) = ifelse(abs(a) < abs(b), a, b)
-
-@inline Dxx(u, II, dx) = @inbounds (2.0 * (u[δx⁺(II)] - u[II]) / (dx[δx⁺(II)] + dx[II]) -
-                                    2.0 * (u[II] - u[δx⁻(II)]) / (dx[δx⁻(II)] + dx[II])) / dx[II]
-@inline Dyy(u, II, dy) = @inbounds (2.0 * (u[δy⁺(II)] - u[II]) / (dy[δy⁺(II)] + dy[II]) -
-                                    2.0 * (u[II] - u[δy⁻(II)]) / (dy[δy⁻(II)] + dy[II])) / dy[II]
-
-@inline Dxx(u, II, dx, nx, per) = @inbounds (2.0 * (u[δx⁺(II, nx, per)] - u[II]) / (dx[δx⁺(II, nx, per)] + dx[II]) -
-    2.0 * (u[II] - u[δx⁻(II, nx, per)]) / (dx[δx⁻(II, nx, per)] + dx[II])) / dx[II]
-@inline Dxx_l(u, II, dx, nx, per) = @inbounds (2.0 * (u[δx⁺(δx⁺(II))] - u[δx⁺(II)]) / (dx[δx⁺(δx⁺(II))] + dx[δx⁺(II)]) -
-    2.0 * (u[δx⁺(II)] - u[II]) / (dx[δx⁺(II)] + dx[II])) / dx[δx⁺(II)]
-@inline Dxx_r(u, II, dx, nx, per) = @inbounds (2.0 * (u[II] - u[δx⁻(II)]) / (dx[II] + dx[δx⁻(II)]) -
-    2.0 * (u[δx⁻(II)] - u[δx⁻(δx⁻(II))]) / (dx[δx⁻(II)] + dx[δx⁻(δx⁻(II))])) / dx[δx⁻(II)]
-@inline Dyy(u, II, dy, ny, per) = @inbounds (2.0 * (u[δy⁺(II, ny, per)] - u[II]) / (dy[δy⁺(II, ny, per)] + dy[II]) -
-    2.0 * (u[II] - u[δy⁻(II, ny, per)]) / (dy[δy⁻(II, ny, per)] + dy[II])) / dy[II]
-@inline Dyy_b(u, II, dy, ny, per) = @inbounds (2.0 * (u[δy⁺(δy⁺(II))] - u[δy⁺(II)]) / (dy[δy⁺(δy⁺(II))] + dy[δy⁺(II)]) -
-    2.0 * (u[δy⁺(II)] - u[II]) / (dy[δy⁺(II)] + dy[II])) / dy[δy⁺(II)]
-@inline Dyy_t(u, II, dy, ny, per) = @inbounds (2.0 * (u[II] - u[δy⁻(II)]) / (dy[II] + dy[δy⁻(II)]) -
-    2.0 * (u[δy⁻(II)] - u[δy⁻(δy⁻(II))]) / (dy[δy⁻(II)] + dy[δy⁻(δy⁻(II))])) / dy[δy⁻(II)]
-
-@inline Dxx(u, II) = @inbounds u[δx⁺(II)] - 2u[II] + u[δx⁻(II)]
-@inline Dyy(u, II) = @inbounds u[δy⁺(II)] - 2u[II] + u[δy⁻(II)]
-
-@inline Dxx(u, II, nx, per) = @inbounds u[δx⁺(II, nx, per)] - 2u[II] + u[δx⁻(II, nx, per)]
-@inline Dxx_l(u, II, nx, per) = @inbounds ifelse(per, u[δx⁺(II, nx, per)] - 2u[II] + u[δx⁻(II, nx, per)],
-    u[δx⁺(δx⁺(II))] - 2*u[δx⁺(II)] + u[II])
-@inline Dxx_r(u, II, nx, per) = @inbounds ifelse(per, u[δx⁺(II, nx, per)] - 2u[II] + u[δx⁻(II, nx, per)],
-    u[δx⁻(δx⁻(II))] - 2*u[δx⁻(II)] + u[II])
-@inline Dyy(u, II, ny, per) = @inbounds u[δy⁺(II, ny, per)] - 2u[II] + u[δy⁻(II, ny, per)]
-@inline Dyy_b(u, II, ny, per) = @inbounds ifelse(per, u[δy⁺(II, ny, per)] - 2u[II] + u[δy⁻(II, ny, per)],
-    u[δy⁺(δy⁺(II))] - 2*u[δy⁺(II)] + u[II])
-@inline Dyy_t(u, II, ny, per) = @inbounds ifelse(per, u[δy⁺(II, ny, per)] - 2u[II] + u[δy⁻(II, ny, per)],
-    u[δy⁻(δy⁻(II))] - 2*u[δy⁻(II)] + u[II])
-
-@inline Dxy(u, II, h) = @inbounds (u[δx⁻(δy⁻(II))] + u[δx⁺(δy⁺(II))] - u[δx⁻(δy⁺(II))] - u[δx⁺(δy⁻(II))])/4h^2
-
-function smekerka_curvature(u, II, h)
-    gx = c∇x(u, II, h)
-    gy = c∇y(u, II, h)
-    gxx = Dxx(u, II, h)
-    gyy = Dyy(u, II, h)
-    gxy = Dxy(u, II, h)
-    k = (gxx + gyy)/(gx^2 + gy^2)^0.5
-    return k
-end
-
-@inline in_bounds(a, n) = ifelse(a > 2 && a < n-1, true, false)
-@inline in_bounds(a, n, per) = per ? ifelse(a > 1 && a < n, true, false) : in_bounds(a, n)
-
-
-"""
-
-Compute a 3x3 stencil around the given CartesianIndex `II` in the 2D array `a`.
-
-This function takes a 2D array `a` and a `CartesianIndex` `II`, and returns a 3x3 stencil centered around the element at `II`. 
-The stencil is computed by extracting the values from the array `a` at the relative positions around `II`.
-
-# Arguments
-- `a`: A 2D array (matrix) of type `SA_F64` (assumed to be a subtype of `AbstractArray`).
-- `II`: A `CartesianIndex` specifying the position in the 2D array `a` around which the stencil is computed.
-
-# Returns
-- A 3x3 matrix of type `SA_F64` representing the stencil.
-
-"""
-@inline function static_stencil(a, II::CartesianIndex)
-   return @inbounds SA_F64[a[II.I[1]-1, II.I[2]-1] a[II.I[1]-1, II.I[2]] a[II.I[1]-1, II.I[2]+1];
-               a[II.I[1], II.I[2]-1] a[II.I[1], II.I[2]] a[II.I[1], II.I[2]+1];
-               a[II.I[1]+1, II.I[2]-1] a[II.I[1]+1, II.I[2]] a[II.I[1]+1, II.I[2]+1]]
-end
-
-"""
-
-Compute a 3x3 stencil around the given CartesianIndex `II` in the 2D array `a` with peiodicity information.
-
-This function takes a 2D array `a` and a `CartesianIndex` `II`, and returns a 3x3 stencil centered around the element at `II`. 
-The stencil is computed by extracting the values from the array `a` at the relative positions around `II`.
-
-# Arguments
-- `a`: A 2D array (matrix) of type `SA_F64` (assumed to be a subtype of `AbstractArray`).
-- `II`: A `CartesianIndex` specifying the position in the 2D array `a` around which the stencil is computed.
-
-# Returns
-- A 3x3 matrix of type `SA_F64` representing the stencil.
-
-"""
-@inline function static_stencil(a, II::CartesianIndex, nx, ny, per_x, per_y)
-    return @inbounds SA_F64[a[δx⁻(δy⁻(II, ny, per_y), nx, per_x)] a[δy⁻(II, ny, per_y)] a[δx⁺(δy⁻(II, ny, per_y), nx, per_x)];
-                a[δx⁻(II, nx, per_x)] a[II] a[δx⁺(II, nx, per_x)];
-                a[δx⁻(δy⁺(II, ny, per_y), nx, per_x)] a[δy⁺(II, ny, per_y)] a[δx⁺(δy⁺(II, ny, per_y), nx, per_x)]]
- end
-
-function debug_val(test)
-    print("\n test ",string(test)," ",typeof(test)," ",test)
-end
-
- @inline function static_stencil_debug(a, II::CartesianIndex, nx, ny, per_x, per_y)
-
-    print("\n a ",typeof(a))
-    test = II 
-    print("\n II ",test," ",typeof(test))
-    test = nx 
-    print("\n test ",test," ",typeof(test))
-    test = ny
-    print("\n test ",test," ",typeof(test))
-
-    debug_val(per_x)
-    debug_val(per_y)
-    debug_val(δy⁻(II, ny, per_y))
-    debug_val(δx⁻(δy⁻(II, ny, per_y), nx, per_x))
-    debug_val(δx⁺(δy⁻(II, ny, per_y), nx, per_x))
-    debug_val(δx⁻(II, nx, per_x))
-    debug_val(δx⁺(II, nx, per_x))
-    debug_val(δy⁺(II, ny, per_y))
-    debug_val(δx⁻(δy⁺(II, ny, per_y), nx, per_x))
-    debug_val(δx⁺(δy⁺(II, ny, per_y), nx, per_x))
-
-
-    # print("\n per_x ",typeof(per_x))
-    # print("\n per_y ",typeof(per_y))
-    # print("\n dy- ",typeof(δy⁻(II, ny, per_y)))
-    # print("\n d ",typeof(δx⁻(δy⁻(II, ny, per_y), nx, per_x)))
-    # print("\n d ",typeof(δx⁺(δy⁻(II, ny, per_y), nx, per_x)))
-    # print("\n d ",typeof(δx⁻(II, nx, per_x)))
-    # print("\n d ",typeof(δx⁺(II, nx, per_x)))
-    # print("\n d ",typeof(δy⁺(II, ny, per_y)))
-    # print("\n d ",typeof(δx⁻(δy⁺(II, ny, per_y), nx, per_x)))
-    # print("\n d ",typeof(δx⁺(δy⁺(II, ny, per_y), nx, per_x)))
-
-
-    return @inbounds SA_F64[a[δx⁻(δy⁻(II, ny, per_y), nx, per_x)] a[δy⁻(II, ny, per_y)] a[δx⁺(δy⁻(II, ny, per_y), nx, per_x)];
-                a[δx⁻(II, nx, per_x)] a[II] a[δx⁺(II, nx, per_x)];
-                a[δx⁻(δy⁺(II, ny, per_y), nx, per_x)] a[δy⁺(II, ny, per_y)] a[δx⁺(δy⁺(II, ny, per_y), nx, per_x)]]
- end
-
-
-"""
-2.3.2.2 Biquadratic interpolation of the level-set ? or here f function
-"""
-@inline function B_BT(II, x, y, f=x->x)
-    B = inv((@SMatrix [((x[f(δx⁻(II))]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]))^2 (x[f(δx⁻(II))]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]) 1.0;
-                      ((x[f(II)]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]))^2 (x[f(II)]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]) 1.0;
-                      ((x[f(δx⁺(II))]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]))^2 (x[f(δx⁺(II))]-x[II])/(x[f(δx⁺(II))] - x[f(δx⁻(II))]) 1.0]))
-
-    BT = inv((@SMatrix [((y[f(δy⁻(II))]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]))^2 ((y[f(II)]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]))^2 ((y[f(δy⁺(II))]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]))^2;
-                        (y[f(δy⁻(II))]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]) (y[f(II)]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]) (y[f(δy⁺(II))]-y[II])/(y[f(δy⁺(II))] - y[f(δy⁻(II))]);
-                        1.0 1.0 1.0]))
-    
-    return B, BT
-end
-
-
-"""
-2.3.2.2 Biquadratic interpolation of the level-set ?
-"""
-@inline function B_BT(II::CartesianIndex, grid::G, per_x, per_y) where {G<:Grid}
-    @unpack x, y, nx, ny, dx, dy = grid
-
-    _dx = dx[II]
-    _dy = dy[II]
-
-    dx⁺ = 0.5 * (dx[II] + dx[δx⁺(II, nx, per_x)])
-    dx⁻ = 0.5 * (dx[δx⁻(II, nx, per_x)] + dx[II])
-
-    dy⁺ = 0.5 * (dy[II] + dy[δy⁺(II, ny, per_y)])
-    dy⁻ = 0.5 * (dy[δy⁻(II, ny, per_y)] + dy[II])
-
-    B = inv((@SMatrix [(dx⁻/_dx)^2 -dx⁻/_dx 1.0;
-        0.0 0.0 1.0;
-        (dx⁺/_dx)^2 dx⁺/_dx 1.0]))
-
-    BT = inv((@SMatrix [(dy⁻/_dy)^2 0.0 (dy⁺/_dy)^2;
-        -dy⁻/_dy 0.0 dy⁺/_dy;
-        1.0 1.0 1.0]))
-
-    return B, BT
-end
-
-"""
-2.3.2.2 Biquadratic interpolation of the level-set ?
-"""
-@inline function B_BT(II::CartesianIndex, grid::G) where {G<:Grid}
-    B = inv(@SMatrix [0.25 -0.5 1.0;
-                      0.0 0.0 1.0;
-                      0.25 0.5 1.0])
-
-    BT = inv(@SMatrix [0.25 -0.5 1.0;
-                        0.0 0.0 1.0;
-                        0.25 0.5 1.0])
-    
-    return B, BT
-end
-
-@inline big_static_stencil(a, II::CartesianIndex) = @inbounds @SMatrix [a[II.I[1]-2, II.I[2]-2] a[II.I[1]-2, II.I[2]-1] a[II.I[1]-2, II.I[2]] a[II.I[1]-2, II.I[2]+1] a[II.I[1]-2, II.I[2]+2];
-   a[II.I[1]-1, II.I[2]-2] a[II.I[1]-1, II.I[2]-1] a[II.I[1]-1, II.I[2]] a[II.I[1]-1, II.I[2]+1] a[II.I[1]-1, II.I[2]+2];
-   a[II.I[1], II.I[2]-2] a[II.I[1], II.I[2]-1] a[II.I[1], II.I[2]] a[II.I[1], II.I[2]+1] a[II.I[1], II.I[2]+2];
-   a[II.I[1]+1, II.I[2]-2] a[II.I[1]+1, II.I[2]-1] a[II.I[1]+1, II.I[2]] a[II.I[1]+1, II.I[2]+1] a[II.I[1]+1, II.I[2]+2];
-   a[II.I[1]+2, II.I[2]-2] a[II.I[1]+2, II.I[2]-1] a[II.I[1]+2, II.I[2]] a[II.I[1]+2, II.I[2]+1] a[II.I[1]+2, II.I[2]+2]]
-
-@inline function mean_curvature(a::StaticArray, h)
-    f = @SVector [(a[2,3]-a[2,1])/2h, (a[3,2]-a[1,2])/2h]
-    s = @SVector [(a[2,3]-2a[2,2]+a[2,1])/h^2, (a[3,2]-2a[2,2]+a[1,2])/h^2]
-    m = @SVector [(a[3,3]-a[1,3]-a[3,1]+a[1,1])/4h^2]
-    return (s[1]*(f[2])^2 - 2*f[1]*f[2]*m[1] + s[2]*(f[1])^2)/(f[1]^2 + f[2]^2)^1.5
-end
-
-@inline function mean_curvature_indices(a, II, nx, ny, dx, dy, per_x, per_y)
-    f = @SVector [(a[δx⁺(II,nx,per_x)]-a[δx⁻(II,nx,per_x)])/2dx, (a[δy⁺(II,ny,per_y)]-a[δy⁻(II,ny,per_y)])/2dy]
-    s = @SVector [(a[δx⁻(II,nx,per_x)]-2a[II]+a[δx⁺(II,nx,per_x)])/dx^2, (a[δy⁻(II,ny,per_y)]-2a[II]+a[δy⁺(II,ny,per_y)])/dy^2]
-    m = (
-        a[δx⁻(δy⁻(II,ny,per_y),nx,per_x)]+
-        a[δx⁺(δy⁺(II,ny,per_y),nx,per_x)]-
-        a[δx⁻(δy⁺(II,ny,per_y),nx,per_x)]-
-        a[δx⁺(δy⁻(II,ny,per_y),nx,per_x)]
-    )/(4*(dx*dy)^2)
-    return (s[1]*(f[2])^2 - 2*f[1]*f[2]*m[1] + s[2]*(f[1])^2)/(1e-10 + f[1]^2 + f[2]^2)^1.5
-end
-
-function mean_curvature_interpolated(u, II, h, B, BT, mid)
-    tmp = zeros(3,3)
-    @threads for i in -1:1
-        for j in -1:1
-            JJ = CartesianIndex(II[1]+i, II[2]+j)
-            st = static_stencil(u, JJ)
-            tmp[2+i, 2+j] = mean_curvature(st, h)
-        end
-    end
-    itp = B*tmp*BT
-    a = biquadratic(itp, mid.x, mid.y)
-    return min(max(mean(tmp),-1/h), 1/h)
-end
-
-function interpolated_curvature(grid, II, per_x, per_y)
-    @unpack nx, ny, u, mid_point, ind = grid
-
-    dx = grid.dx[II]
-    dy = grid.dy[II]
-
-    ii = [δy⁻, (x,n,p)->x, δy⁺]
-    jj = [δx⁻, (x,n,p)->x, δx⁺]
-
-    tmp = zeros(3,3)
-    for i in -1:1
-        for j in -1:1
-            JJ = ii[i+2](jj[j+2](II, nx, per_x), ny, per_y)
-            if !per_x && !per_y
-                if JJ in ind.inside
-                    JJ_0 = JJ
-                elseif JJ in ind.b_left[1][2:end-1]
-                    JJ_0 = δx⁺(JJ)
-                elseif JJ in ind.b_bottom[1][2:end-1]
-                    JJ_0 = δy⁺(JJ)
-                elseif JJ in ind.b_right[1][2:end-1]
-                    JJ_0 = δx⁻(JJ)
-                elseif JJ in ind.b_top[1][2:end-1]
-                    JJ_0 = δy⁻(JJ)
-                elseif JJ == ind.b_left[1][1]
-                    JJ_0 = δy⁺(δx⁺(JJ))
-                elseif JJ == ind.b_left[1][end]
-                    JJ_0 = δy⁻(δx⁺(JJ))
-                elseif JJ == ind.b_right[1][1]
-                    JJ_0 = δy⁺(δx⁻(JJ))
-                elseif JJ == ind.b_right[1][end]
-                    JJ_0 = δy⁻(δx⁻(JJ))
-                end
-            elseif per_x && !per_y
-                if JJ in ind.inside || JJ in ind.b_left[1][2:end-1] || JJ in ind.b_right[1][2:end-1]
-                    JJ_0 = JJ
-                elseif JJ in ind.b_bottom[1]
-                    JJ_0 = δy⁺(JJ)
-                elseif JJ in ind.b_top[1]
-                    JJ_0 = δy⁻(JJ)
-                end
-            else
-                if JJ in ind.inside || JJ in ind.b_bottom[1][2:end-1] || JJ in ind.b_top[1][2:end-1]
-                    JJ_0 = JJ
-                elseif JJ in ind.b_left[1]
-                    JJ_0 = δx⁺(JJ)
-                elseif JJ in ind.b_right[1]
-                    JJ_0 = δx⁻(JJ)
-                end
-            end
-            tmp[2+i, 2+j] = mean_curvature_indices(u, JJ_0, nx, ny, dx, dy, per_x, per_y)
-        end
-    end
-
-    B, BT = B_BT(II, grid, per_x, per_y)
-    itp = B*tmp*BT
-    κ = biquadratic(itp, mid_point[II].x, mid_point[II].y)
-
-    return κ
-end
-
-@inline parabola_fit_curvature(itp, mid_point, dx, dy) =
-    @inbounds 2*itp[1,3]/((1+(2*itp[1,3]*mid_point.x/dx + itp[2,3])^2)^1.5)/(dx)^2 +
-              2*itp[3,1]/((1+(2*itp[3,1]*mid_point.y/dy + itp[3,2])^2)^1.5)/(dy)^2
-
-@inline function linear_fit(a, b, x)
-    a = (a - b)/sign(x+eps(0.1))
-    return a*x + b
-end
-
-@inline @. parabola_fit(x, p) = p[1]*x^2 + p[2]*x + p[3]
-
-function get_NB_width_indices_base(n)
-    x = [CartesianIndex(i,0) for i in -n:n]
-    y = [CartesianIndex(0,j) for j in -n:n]
-    return vcat(x,y)
-end
-
-function get_NB_width_indices_base1(n)
-    return vcat([[CartesianIndex(i,j) for i in -n:n] for j in -n:n]...)
-end
-
-@inline function normf(field, pos, cap, h)
-    AVG = 0.
-    RMS = 0.
-    VOLUME = 0.
-    MAX = 0.
-    dv = 0.
-    @inbounds for II in pos
-        v = abs(field[II])
-        dv = cap[II]*h^2
-        if dv > 0.
-            VOLUME += dv
-            AVG += dv*v
-            RMS += dv*v^2
-            if (v > MAX) MAX = v end
-        end
-    end
-    return AVG/VOLUME, sqrt(RMS/VOLUME), MAX
-end
-
-@inline function normf(field, pos, h)
-    AVG = 0.
-    RMS = 0.
-    VOLUME = 0.
-    MAX = 0.
-    @inbounds for II in pos
-        v = abs(field[II])
-        VOLUME += h^2
-        AVG += (h^2)*v
-        RMS += (h^2)*v^2
-        if (v > MAX) MAX = v end
-    end
-    return AVG/VOLUME, sqrt(RMS/VOLUME), MAX
-end
-
-@inline function norma(field, pos, cap, h)
-    AVG = 0.
-    RMS = 0.
-    VOLUME = 0.
-    MAX = 0.
-    dv = 0.
-    @inbounds for II in pos
-        v = abs(field[II])
-        dv = cap[II]*h^2
-        # dv = h^2
-        if dv > 0.
-            VOLUME += dv
-            AVG += dv*v
-            RMS += dv*v^2
-            if (v > MAX) MAX = v end
-        end
-    end
-    return AVG/VOLUME, sqrt(RMS), MAX
-end
-
-@inline function Richardson_extrapolation(e, r)
-    p = log(abs(e[end-2] - e[end-1])/abs(e[end-1] - e[end]))/log(r)
-    ext = e[end] + (e[end] - e[end-1])/(2^p - 1)
-    return abs.(e .- ext)
-end
-
-function fit_order(x, y)
-    coeffs = fit(log.(x), log.(y), 1).coeffs
-    return exp(coeffs[1]), -coeffs[2]
-end
-
-@inline function arc_length2(POS, ind)
-    d_tot = 0.
-    d_ = 0.
-    ind_ = copy(ind)
-    for i in length(ind):-1:1
-       d = 1e300
-       pop!(ind_)
-       for j in axes(ind_,1)
-           d_ = distance(abs(POS[ind[i]].pos), abs(POS[ind_[j]].pos))
-           if d_ < d
-               d = d_
-           end
-       end
-       d_tot += d_
-    end
-    return d_tot
-end
-
-function find_2closest_points(POS, ind, II)
-    closest_indices = Vector{Int64}(undef, 2)
-    closest_cartesian_indices = Vector{CartesianIndex{2}}(undef, 2)
-    all_indices = copy(ind)
-    for  i = 1:2
-        d = 1e300
-        for JJ in axes(all_indices,1)
-            d_ = distance(POS[II].pos, POS[all_indices[JJ]].pos)
-            if 0. < d_ < d
-                d = d_
-                closest_indices[i] = JJ
-            end
-        end
-        closest_cartesian_indices[i] = all_indices[closest_indices[i]]
-        if i == 1 deleteat!(all_indices, closest_indices[1]) end
-    end
-    return closest_cartesian_indices
-end
-
-function monitor(header, history, it)
-    println("****** ", header, " ******")
-    if it > 0
-        println("res[0] = ", first(history))
-        println("res[", it, "] = ", history[it+1]) 
-    else
-        println("x0 is a solution")
-    end
-end
-
-function within_cell(p::Point)
-    if p.x >= -0.5 && p.x <= 0.5 && p.y >= -0.5 && p.y <= 0.5
-        return true
-    else
-        return false
-    end
-end
-
-function points2polygon(points)
-    str = "POLYGON(("
-    str *= "$(points[1].x) $(points[1].y)"
-    for p in points[2:end]
-        str *= ",$(p.x) $(p.y)"
-    end
-    str *= "))"
-
-    return readgeom(str)
-end
-
-@inline is_weno(::WENO5) = true
-@inline is_weno(::LevelsetDiscretization) = false
-
-@inline is_eno(::ENO2) = true
-@inline is_eno(::LevelsetDiscretization) = false
-
-const weno5 = WENO5()
-const eno2 = ENO2()
-
-@inline is_Forward_Euler(char::String) = (char == "FE" || char == "Forward_Euler")
-@inline is_Crank_Nicolson(char::String) = (char == "CN" || char == "Crank_Nicolson")
-
-@inline is_Forward_Euler(::ForwardEuler) = true
-@inline is_Forward_Euler(::TemporalIntegration) = false
-
-@inline is_Crank_Nicolson(::CrankNicolson) = true
-@inline is_Crank_Nicolson(::TemporalIntegration) = false
-
-const FE = ForwardEuler()
-const CN = CrankNicolson()
-
-isCC(::Mesh{GridCC ,T,N}) where {T,N} = true
-isCC(::Mesh{GridFCx,T,N}) where {T,N} = false
-isCC(::Mesh{GridFCy,T,N}) where {T,N} = false
-
-isCC(::Mesh) = false
-
-isFCx(::Mesh{GridFCx,T,N}) where {T,N} = true
-isFCx(::Mesh{GridCC ,T,N}) where {T,N} = false
-isFCx(::Mesh{GridFCy,T,N}) where {T,N} = false
-isFCx(::Mesh) = false
-
-isFCy(::Mesh{GridFCy,T,N}) where {T,N} = true
-isFCy(::Mesh{GridFCx,T,N}) where {T,N} = false
-isFCy(::Mesh{GridCC ,T,N}) where {T,N} = false
-isFCy(::Mesh) = false
-
-@inline is_dirichlet(::Dirichlet) = true
-@inline is_dirichlet(::BoundaryCondition) = false
-
-@inline is_neumann(::Neumann) = true
-@inline is_neumann(::BoundaryCondition) = false
-
-@inline is_neumann_cl(::Neumann_cl) = true
-@inline is_neumann_cl(::BoundaryCondition) = false
-
-@inline is_neumann_inh(::Neumann_inh) = true
-@inline is_neumann_inh(::BoundaryCondition) = false
-
-@inline is_robin(::Robin) = true
-@inline is_robin(::BoundaryCondition) = false
-
-@inline is_periodic(::Periodic) = true
-@inline is_periodic(::BoundaryCondition) = false
-
-@inline is_navier(::Navier) = true
-@inline is_navier(::BoundaryCondition) = false
-
-@inline is_navier_cl(::Navier_cl) = true
-@inline is_navier_cl(::BoundaryCondition) = false
-
-@inline is_gnbc(::GNBC) = true
-@inline is_gnbc(::BoundaryCondition) = false
-
-@inline is_stefan(::Stefan) = true
-@inline is_stefan(::BoundaryCondition) = false
-
-@inline is_fs(::FreeSurface) = true
-@inline is_fs(::BoundaryCondition) = false
-
-@inline is_wall_no_slip(::WallNoSlip) = true
-@inline is_wall_no_slip(::BoundaryCondition) = false
-
-@inline is_wall(::WallNoSlip) = true
-@inline is_wall(::Navier) = true
-@inline is_wall(::Navier_cl) = true
-@inline is_wall(::BoundaryCondition) = false
-
-const neu = Neumann()
-const neu_cl = Neumann_cl()
-const neu_inh = Neumann_inh()
-const dir = Dirichlet()
-const per = Periodic()
-const rob = Robin()
-const nav = Navier()
-const nav_cl = Navier_cl()
-const fs = FreeSurface()
-
-function get_fresh_cells!(grid, geo, Mm1, indices)
-    @inbounds @threads for II in indices
-        pII = lexicographic(II, grid.ny)
-        if Mm1.diag[pII]/(grid.dx[II]*grid.dy[II]) < 1e-8 && geo.cap[II,5] > 1e-8
-            geo.fresh[II] = true
-        end
-    end
-    return nothing
-end
-#TODO distinguish between border and bulk cells
-function kill_dead_cells!(T::Matrix, grid, geo)
-    @unpack ind = grid
-
-    @inbounds @threads for II in ind.all_indices
-        if geo.cap[II,5] < 1e-12
-            T[II] = 0.
-        end
-    end
-end
-
-function kill_dead_cells!(T::Vector, grid, geo)
-    @unpack ny, ind = grid
-
-    @inbounds @threads for II in ind.all_indices
-        pII = lexicographic(II, ny)
-        if geo.cap[II,5] < 1e-12
-            T[pII] = 0.
-        end
-    end
-end
-
-function kill_dead_cells!(S::SubArray{T,N,P,I,L}, grid, geo) where {T,N,P<:Vector{T},I,L}
-    @unpack ny, ind = grid
-
-    @inbounds @threads for II in ind.all_indices
-        pII = lexicographic(II, ny)
-        if geo.cap[II,5] < 1e-12
-            S[pII] = 0.
-        end
-    end
-end
-
-function kill_dead_cells!(S::SubArray{T,N,P,I,L}, grid, geo) where {T,N,P<:Array{T,3},I,L}
-    @unpack ind = grid
-    # print("kill dead cells mat")
-    @inbounds @threads for II in ind.all_indices
-        if geo.cap[II,5] < 1e-12
-            # print(II, S[II])
-            S[II] = 0.
-            # print("v2",S[II])
-        end
-    end
-end
-
-function init_borders!(T, grid, BC, val=0.0)
-    if is_dirichlet(BC.left)
-        vecb_L(T, grid) .= BC.left.val
-    elseif is_periodic(BC.left)
-        vecb_L(T, grid) .= val
-    else
-        vecb_L(T, grid) .= val
-    end
-    if is_dirichlet(BC.bottom)
-        vecb_B(T, grid) .= BC.bottom.val
-    elseif is_periodic(BC.bottom)
-        vecb_B(T, grid) .= val
-    else
-        vecb_B(T, grid) .= val
-    end
-    if is_dirichlet(BC.right)
-        vecb_R(T, grid) .= BC.right.val
-    elseif is_periodic(BC.right)
-        vecb_R(T, grid) .= val
-    else
-        vecb_R(T, grid) .= val
-    end
-    if is_dirichlet(BC.top)
-        vecb_T(T, grid) .= BC.top.val
-    elseif is_periodic(BC.top)
-        vecb_T(T, grid) .= val
-    else
-        vecb_T(T, grid) .= val
-    end
-end
-
-@inline function star0(grid, val=0.0)
-    spdiagm(0 => val.*ones(grid.ny*grid.nx))
-end
-
-@inline function star1(g, val=0.0)
-    spdiagm(0 => val.*ones(g.ny*g.nx), # i,j
-            -g.ny => val.*ones(g.ny*(g.nx-1)), # i-1,j
-            -1 => val.*ones(g.ny*g.nx-1), # i,j-1
-            g.ny => val.*ones(g.ny*(g.nx-1)), # i+1,j
-            1 => val.*ones(g.ny*g.nx-1), # i,j+1
-    )
-end
-
-@inline function star2(g, val=0.0)
-    spdiagm(0 => val.*ones(g.ny*g.nx), # i,j
-            -g.ny => val.*ones(g.ny*(g.nx-1)), # i-1,j
-            -1 => val.*ones(g.ny*g.nx-1), # i,j-1
-            g.ny => val.*ones(g.ny*(g.nx-1)), # i+1,j
-            1 => val.*ones(g.ny*g.nx-1), # i,j+1
-            -2g.ny => val.*ones(g.ny*(g.nx-2)), # i-2,j
-            -2 => val.*ones(g.ny*g.nx-2), # i,j-2
-            2g.ny => val.*ones(g.ny*(g.nx-2)), # i+2,j
-            2 => val.*ones(g.ny*g.nx-2), # i,j+2
-            -g.ny-1 => val.*ones(g.ny*(g.nx-1)-1), # i-1,j-1
-            g.ny-1 => val.*ones(g.ny*(g.nx-1)+1), # i+1,j-1
-            g.ny+1 => val.*ones(g.ny*(g.nx-1)-1), # i+1,j+1
-            -g.ny+1 => val.*ones(g.ny*(g.nx-1)+1), # i-1,j+1
-    )
-end
-
-@inline function star3(g, val=0.0)
-    spdiagm(0 => val.*ones(g.ny*g.nx), # i,j
-            -g.ny => val.*ones(g.ny*(g.nx-1)), # i-1,j
-            -1 => val.*ones(g.ny*g.nx-1), # i,j-1
-            g.ny => val.*ones(g.ny*(g.nx-1)), # i+1,j
-            1 => val.*ones(g.ny*g.nx-1), # i,j+1
-            -2g.ny => val.*ones(g.ny*(g.nx-2)), # i-2,j
-            -2 => val.*ones(g.ny*g.nx-2), # i,j-2
-            2g.ny => val.*ones(g.ny*(g.nx-2)), # i+2,j
-            2 => val.*ones(g.ny*g.nx-2), # i,j+2
-            -g.ny-1 => val.*ones(g.ny*(g.nx-1)-1), # i-1,j-1
-            g.ny-1 => val.*ones(g.ny*(g.nx-1)+1), # i+1,j-1
-            g.ny+1 => val.*ones(g.ny*(g.nx-1)-1), # i+1,j+1
-            -g.ny+1 => val.*ones(g.ny*(g.nx-1)+1), # i-1,j+1
-            -3g.ny => val.*ones(g.ny*(g.nx-3)), # i-3,j
-            -3 => val.*ones(g.ny*g.nx-3), # i,j-3
-            3g.ny => val.*ones(g.ny*(g.nx-3)), # i+3,j
-            3 => val.*ones(g.ny*g.nx-3), # i,j+3
-            -g.ny-2 => val.*ones(g.ny*(g.nx-1)-2), # i-1,j-2
-            g.ny-2 => val.*ones(g.ny*(g.nx-1)+2), # i+1,j-2
-            g.ny+2 => val.*ones(g.ny*(g.nx-1)-2), # i+1,j+2
-            -g.ny+2 => val.*ones(g.ny*(g.nx-1)+2), # i-1,j+2
-            -2g.ny-1 => val.*ones(g.ny*(g.nx-2)-1), # i-2,j-1
-            2g.ny-1 => val.*ones(g.ny*(g.nx-2)+1), # i+2,j-1
-            2g.ny+1 => val.*ones(g.ny*(g.nx-2)-1), # i+2,j+1
-            -2g.ny+1 => val.*ones(g.ny*(g.nx-2)+1), # i-2,j+1
-    )
-end
-
-Base.copy(x::T) where T = T([getfield(x, k) for k ∈ fieldnames(T)]...)
-
-"""
-    export_all()
-
-Exports every function of an included file.
-
-* @args Noting : nothing
-
-## Notes
-
-Do not use this, use `@export` instead!
-
-"""
-function export_all()
-    for n in names(@__MODULE__; all=true)
-        if Base.isidentifier(n) && n ∉ (Symbol(@__MODULE__), :eval, :include)
-            @eval export $n
-        end
-    end
-end
-
-
-"""
-Here rows = rowvals(mat2)
-"""
-function mat_assign!(mat1, mat2)
-    mat1.nzval .= 0.
-    rows = rowvals(mat2)
-    m, n = size(mat2)
-    @inbounds @threads for j = 1:n
-        for i in nzrange(mat2, j)
-            @inbounds row = rows[i]
-            mat1[row,j] = mat2[row,j]
-        end
-    end
-
-    return nothing
-end
-
-
-"""
-Here rows = rowvals(mat1)
-"""
-function mat_assign_T!(mat1, mat2)
-    mat1.nzval .= 0.
-    rows = rowvals(mat1)
-    m, n = size(mat1)
-    @inbounds @threads for j = 1:n
-        for i in nzrange(mat1, j)
-            @inbounds row = rows[i]
-            mat1[row,j] = mat2[row,j]
-        end
-    end
-
-    return nothing
-end
-
-function mat_op!(mat1, mat2, op)
-    mat1.nzval .= 0.
-    rows = rowvals(mat2)
-    vals = nonzeros(mat2)
-    m, n = size(mat2)
-    @inbounds @threads for j = 1:n
-        for i in nzrange(mat2, j)
-            @inbounds row = rows[i]
-            @inbounds val = vals[i]
-            @inbounds mat1[row,j] = op(val)
-        end
-    end
-
-    return nothing
-end
-
-function mat_T_op!(mat1, mat2, op)
-    mat1.nzval .= 0.
-    rows = rowvals(mat2)
-    vals = nonzeros(mat2)
-    m, n = size(mat2)
-    @inbounds @threads for j = 1:n
-        for i in nzrange(mat2, j)
-            @inbounds row = rows[i]
-            @inbounds val = vals[i]
-            @inbounds mat1[j,row] = op(val)
-        end
-    end
-
-    return nothing
-end
-
-# Operations on sparse arrays that can be parallelized
-for op ∈ (:*, :+, :-)
-    @eval begin
-        function $op(A::AbstractSparseMatrix{Tv,Ti}, B::Tv) where {Tv<:Number,Ti}
-            C = SparseMatrixCSC{Tv,Ti}(A.m, A.n, A.colptr, A.rowval, zeros(length(A.nzval)))
-            @inbounds @threads for col in 1:size(A, 2)
-                for j in nzrange(A, col)
-                    C.nzval[j] = $op(A.nzval[j], B)
-                end
-            end
-            C
-        end
-        function $op(B::Tv, A::AbstractSparseMatrix{Tv,Ti}) where {Tv<:Number,Ti}
-            C = SparseMatrixCSC{Tv,Ti}(A.m, A.n, A.colptr, A.rowval, zeros(length(A.nzval)))
-            @inbounds @threads for col in 1:size(A, 2)
-                for j in nzrange(A, col)
-                    C.nzval[j] = $op(B, A.nzval[j])
-                end
-            end
-            C
-        end
-
-        # function $op(A::AbstractSparseMatrix{Tv,Ti}, B::AbstractSparseMatrix{Tv,Ti}) where {Tv<:Number,Ti}
-        #     C = SparseMatrixCSC{Tv,Ti}(A.m, A.n, A.colptr, A.rowval, zeros(length(A.nzval)))
-        #     @inbounds @threads for col in 1:size(A, 2)
-        #         for j in nzrange(A, col)
-        #             C.nzval[j] = $op(A.nzval[j], B.nzval[j])
-        #         end
-        #     end
-        #     C
-        # end
-        # function $op(A::AbstractSparseMatrix{Tv,Ti}, B::Diagonal{Tv,Vector{Tv}}) where {Tv<:Number,Ti}
-        #     C = SparseMatrixCSC{Tv,Ti}(A.m, A.n, A.colptr, A.rowval, copy(A.nzval))
-        #     b = B.diag
-        #     nzv = nonzeros(A)
-        #     rv = rowvals(A)
-        #     @inbounds @threads for col in 1:size(A, 2)
-        #         nz = nzrange(A, col)
-        #         j = nz[findfirst(x->rv[x]==col, collect(nz))]
-        #         C.nzval[j] = $op(A.nzval[j], b[col])
-        #     end
-        #     C
-        # end
-    end
-end
-function (-)(B::Diagonal{Tv,Vector{Tv}}, A::AbstractSparseMatrix{Tv,Ti}) where {Tv<:Number,Ti}
-    C = SparseMatrixCSC{Tv,Ti}(A.m, A.n, A.colptr, A.rowval, -A.nzval)
-    b = B.diag
-    nzv = nonzeros(A)
-    rv = rowvals(A)
-    @inbounds @threads for col in 1:size(A, 2)
-        nz = nzrange(A, col)
-        j = nz[findfirst(x->rv[x]==col, collect(nz))]
-        C.nzval[j] += b[col]
-    end
-    C
-end
-
-function mytime_print(elapsedtime, gctime=0)
-    timestr = Base.Ryu.writefixed(Float64(elapsedtime/1e9), 6)
-    str = sprint() do io
-        print(io, length(timestr) < 10 ? (" "^(10 - length(timestr))) : "")
-        print(io, timestr, " seconds")
-        parens = gctime > 0
-        parens && print(io, " (")
-        if gctime > 0
-            print(io, Base.Ryu.writefixed(Float64(gctime/1e9), 6), " gc time")
-        end
-        parens && print(io, " )")
-    end
-    println(str)
-    nothing
-end
-
-# macro that computes time removing the
-# garbage collector time
-macro mytime(ex)
-    quote
-        Base.Experimental.@force_compile
-        local stats = Base.gc_num()
-        local elapsedtime = Base.time_ns()
-        local val = $(esc(ex))
-        elapsedtime = Base.time_ns() - elapsedtime
-        local diff = Base.GC_Diff(Base.gc_num(), stats)
-        local t = elapsedtime - diff.total_time
-        mytime_print(t, diff.total_time)
-        (time=t/1e9, gctime=diff.total_time/1e9)
-    end
-end

common_util.jl

@@ -1,186 +0,0 @@
-"""
-cf. 3.3.1 Interface velocity extension [`Rodriguez 2024`](https://theses.fr/s384455)
-
-"""
-function indices_extension(grid, LS, inside_ext, periodic_x, periodic_y)
-    _MIXED_L = collect(intersect(Set(LS.MIXED), Set(findall(LS.geoL.emptied))))
-    _MIXED_S = collect(intersect(Set(LS.MIXED), Set(findall(LS.geoS.emptied))))
-    _MIXED = vcat(_MIXED_L, _MIXED_S)
-    indices_ext1 = vcat(LS.SOLID, _MIXED, LS.LIQUID)
-
-    if periodic_x && periodic_y
-        indices_ext = collect(intersect(Set(indices_ext1), Set(vcat(
-            vec(inside_ext), grid.ind.b_left[1][2:end-1], grid.ind.b_bottom[1][2:end-1],
-            grid.ind.b_right[1][2:end-1], grid.ind.b_top[1][2:end-1]
-        ))))
-    elseif !periodic_x && periodic_y
-        indices_ext = collect(intersect(Set(indices_ext1), Set(vcat(
-            vec(inside_ext), grid.ind.b_bottom[1][2:end-1], grid.ind.b_top[1][2:end-1]
-        ))))
-    elseif periodic_x && !periodic_y
-        indices_ext = collect(intersect(Set(indices_ext1), Set(vcat(
-            vec(inside_ext), grid.ind.b_left[1][2:end-1], grid.ind.b_right[1][2:end-1]
-        ))))
-    else
-        indices_ext = collect(intersect(Set(indices_ext1), Set(inside_ext)))
-    end
-
-    left_ext = collect(intersect(Set(grid.ind.b_left[1][2:end-1]), Set(indices_ext1)))
-    bottom_ext = collect(intersect(Set(grid.ind.b_bottom[1][2:end-1]), Set(indices_ext1)))
-    right_ext = collect(intersect(Set(grid.ind.b_right[1][2:end-1]), Set(indices_ext1)))
-    top_ext = collect(intersect(Set(grid.ind.b_top[1][2:end-1]), Set(indices_ext1)))
-
-    return indices_ext, left_ext, bottom_ext, right_ext, top_ext
-end
-
-
-"""
-handles 2 crossing levelsets, levelsets are combined at grid.LS[end]
-8:11 volume
-* periodic_x
-* periodic_y
-* empty = true
-"""
-function update_all_ls_data(num, grid, grid_u, grid_v, BC_int, periodic_x, periodic_y, empty = true,one_fluid_model=false)
-
-    # if num.one_fluid_model == 1
-    #     print("\n dummy volume green")
-    #     xmax = num.x[end]
-    #     xmin = num.x[1]
-    #     ymax = num.y[end]
-    #     ymin = num.y[1]
-    #     vol = (xmax-xmin)*(ymax-ymin)/(grid.nx*grid.ny)
-    #     grid.LS[end].geoL.dcap[:,:,5] .= vol
-    #     grid_u.LS[end].geoL.dcap[:,:,5] .= vol
-    #     grid_v.LS[end].geoL.dcap[:,:,5] .= vol
-
-    # end
-
-    if num.nLS > 1
-        for iLS in 1:num.nLS
-            update_ls_data(num, grid, grid_u, grid_v, iLS, grid.LS[iLS].u, grid.LS[iLS].κ, BC_int, BC_int[iLS], periodic_x, periodic_y, false, empty,one_fluid_model)
-            grid.LS[iLS].geoL.cap0 .= grid.LS[iLS].geoL.cap
-            grid.LS[iLS].mid_point0 .= grid.LS[iLS].mid_point
-        end
-        combine_levelsets!(num, grid)
-        NB_indices = update_ls_data(num, grid, grid_u, grid_v, num._nLS, grid.LS[end].u, grid.LS[end].κ, BC_int, DummyBC(), periodic_x, periodic_y, true, empty,one_fluid_model)
-        grid.LS[end].geoL.cap0 .= grid.LS[end].geoL.cap
-        grid.LS[end].mid_point0 .= grid.LS[end].mid_point
-        crossing_2levelsets!(num, grid, grid.LS[1], grid.LS[2], BC_int)
-        crossing_2levelsets!(num, grid_u, grid_u.LS[1], grid_u.LS[2], BC_int)
-        crossing_2levelsets!(num, grid_v, grid_v.LS[1], grid_v.LS[2], BC_int)
-        # for iLS in 1:num.nLS
-        #     extend_contact_line!(grid, grid.LS[iLS])
-        # end
-
-        for iLS in 1:num.nLS
-            postprocess_grids2!(grid, grid.LS[iLS], grid_u, grid_u.LS[iLS], grid_v, grid_v.LS[iLS], periodic_x, periodic_y, false)
-        end
-        postprocess_grids2!(grid, grid.LS[end], grid_u, grid_u.LS[end], grid_v, grid_v.LS[end], periodic_x, periodic_y, true)
-    else
-        NB_indices = update_ls_data(num, grid, grid_u, grid_v, 1, grid.LS[1].u, grid.LS[1].κ, BC_int, BC_int[1], periodic_x, periodic_y, true, empty,one_fluid_model)
-        grid.LS[1].geoL.cap0 .= grid.LS[1].geoL.cap
-        grid.LS[1].mid_point0 .= grid.LS[1].mid_point
-        postprocess_grids2!(grid, grid.LS[1], grid_u, grid_u.LS[1], grid_v, grid_v.LS[1], periodic_x, periodic_y, true)
-    end
-
-    return NB_indices
-end
-
-
-
-"""
-updates LS on p-grid, interpolates LS from scalar grid (p) to u and v grids 
-
-"""
-function update_ls_data(num, grid, grid_u, grid_v, iLS, u, κ, BC_int, bc_int, periodic_x, periodic_y, neighbours, empty = true,one_fluid_model=false)
-    NB_indices = update_ls_data_grid(num, grid, grid.LS[iLS], u, κ, periodic_x, periodic_y)
-    
-    #interpolate from scalar grid (p) to u and v grids 
-    interpolate_scalar!(grid, grid_u, grid_v, u, grid_u.LS[iLS].u, grid_v.LS[iLS].u)
-
-    _ = update_ls_data_grid(num, grid_u, grid_u.LS[iLS], grid_u.LS[iLS].u, grid_u.LS[iLS].κ, periodic_x, periodic_y)
-    _ = update_ls_data_grid(num, grid_v, grid_v.LS[iLS], grid_v.LS[iLS].u, grid_v.LS[iLS].κ, periodic_x, periodic_y)
-
-    postprocess_grids1!(num, grid, grid.LS[iLS], grid_u, grid_u.LS[iLS], grid_v, grid_v.LS[iLS], periodic_x, periodic_y, neighbours, empty, BC_int,one_fluid_model)
-
-    for i in 1:num.nLS
-        if is_wall(BC_int[i])
-            idx_solid = Base.union(grid.LS[i].SOLID, findall(grid.LS[i].geoL.emptied))
-            # @inbounds κ[idx_solid] .= 0.0
-            @inbounds κ[grid.LS[i].SOLID] .= 0.0
-        end
-    end
-
-    i_ext, l_ext, b_ext, r_ext, t_ext = indices_extension(grid, grid.LS[iLS], grid.ind.inside, periodic_x, periodic_y)
-    field_extension!(grid, u, κ, i_ext, l_ext, b_ext, r_ext, t_ext, num.NB, periodic_x, periodic_y)
-
-    if is_fs(bc_int)
-        locate_contact_line!(num, grid, iLS, grid.LS[iLS].cl, grid.LS[iLS].MIXED, BC_int)
-        locate_contact_line!(num, grid_u, iLS, grid_u.LS[iLS].cl, grid_u.LS[iLS].MIXED, BC_int)
-        locate_contact_line!(num, grid_v, iLS, grid_v.LS[iLS].cl, grid_v.LS[iLS].MIXED, BC_int)
-
-        # Apply inhomogeneous BC to more than one grid point by extending the contact line
-        # extend_contact_line!(grid, grid.LS[iLS])
-        # extend_contact_line!(grid_u, grid_u.LS[iLS].cl, num.n_ext_cl)
-        # extend_contact_line!(grid_v, grid_v.LS[iLS].cl, num.n_ext_cl)
-    end
-
-    return NB_indices
-end
-
-
-"""
-call marching_squares!, get_interface_location!, get_curvature
-"""
-function update_ls_data_grid(num, grid, LS, u, κ, periodic_x, periodic_y)
-    LS.α .= NaN
-    LS.faces .= 0.0
-    LS.mid_point .= [Point(0.0, 0.0)]
-
-    marching_squares!(num,grid, LS, u, periodic_x, periodic_y)
-
-    LS.MIXED, LS.SOLID, LS.LIQUID = get_cells_indices(LS.iso, grid.ind.all_indices)
-    NB_indices_base = get_NB_width_indices_base(num.NB)
-    NB_indices = get_NB_width(grid, LS.MIXED, NB_indices_base)
-
-    get_interface_location!(grid, LS, periodic_x, periodic_y)
-
-    LS.geoL.emptied .= false
-    LS.geoS.emptied .= false
-
-    LS.geoL.double_emptied .= false
-    LS.geoS.double_emptied .= false
-
-    κ .= 0.0
-    get_curvature(num, grid, LS.geoL, u, κ, LS.MIXED, periodic_x, periodic_y)
-
-    return NB_indices
-end
-
-
-function update_stefan_velocity(num, grid, iLS, u, TS, TL, periodic_x, periodic_y, λ, Vmean)
-    Stefan_velocity!(num, grid, grid.LS[iLS], grid.V, TS, TL, grid.LS[iLS].MIXED, periodic_x, periodic_y)
-    grid.V[grid.LS[iLS].MIXED] .*= 1. ./ λ
-    if Vmean
-        a = mean(grid.V[grid.LS[iLS].MIXED])
-        grid.V[grid.LS[iLS].MIXED] .= a
-    end
-
-    i_ext, l_ext, b_ext, r_ext, t_ext = indices_extension(grid, grid.LS[iLS], grid.ind.inside, periodic_x, periodic_y)
-    field_extension!(grid, u, grid.V, i_ext, l_ext, b_ext, r_ext, t_ext, num.NB, periodic_x, periodic_y)
-end
-
-
-function update_free_surface_velocity(num, grid_u, grid_v, iLS, uD, vD, periodic_x, periodic_y)
-    # grid_u.V .= reshape(veci(uD,grid_u,iLS+1), grid_u)
-    # grid_v.V .= reshape(veci(vD,grid_v,iLS+1), grid_v)
-    grid_u.V .= reshape(vec1(uD,grid_u), grid_u)
-    grid_v.V .= reshape(vec1(vD,grid_v), grid_v)
-
-    i_u_ext, l_u_ext, b_u_ext, r_u_ext, t_u_ext = indices_extension(grid_u, grid_u.LS[iLS], grid_u.ind.inside, periodic_x, periodic_y)
-    i_v_ext, l_v_ext, b_v_ext, r_v_ext, t_v_ext = indices_extension(grid_v, grid_v.LS[iLS], grid_v.ind.inside, periodic_x, periodic_y)
-
-    field_extension!(grid_u, grid_u.LS[iLS].u, grid_u.V, i_u_ext, l_u_ext, b_u_ext, r_u_ext, t_u_ext, num.NB, periodic_x, periodic_y)
-    field_extension!(grid_v, grid_v.LS[iLS].u, grid_v.V, i_v_ext, l_v_ext, b_v_ext, r_v_ext, t_v_ext, num.NB, periodic_x, periodic_y)
-end

convergence.jl

@@ -1,477 +0,0 @@
-# using Revise 
-using Flower
-using YAML
-using Printf
-
-# ---------------------------------------------------------------------------------------------
-# FUNCTION BARRIER: Wrapper pour exécuter la simulation
-# Cela permet d'isoler le code compilé des variables dynamiques (BC) générées par eval()
-# ---------------------------------------------------------------------------------------------
-
-function execute_simulation_step(num, gp, gu, gv, op, phS, phL, sim, phys, time_scheme, bc_dict)
-    
-    # Préparation des arguments optionnels (Keyword Arguments)
-    # On construit un NamedTuple uniquement avec les BC qui existent vraiment
-    kwargs_bc = Dict{Symbol, Any}()
-    
-    # Liste des clés possibles
-    keys_to_check = [:BC_uL, :BC_uS, :BC_vL, :BC_vS, :BC_pL, :BC_pS, :BC_u, :BC_int, :BC_trans_scal, :BC_phi_ele]
-    
-    for k in keys_to_check
-        if haskey(bc_dict, k)
-            kwargs_bc[k] = bc_dict[k]
-        end
-    end
-
-    # Appel avec le splatting operator (...) qui déballe le dictionnaire en arguments
-    run_forward!(
-        num, gp, gu, gv, op, phS, phL;
-        periodic_x = (sim.periodic_x == 1),
-        periodic_y = (sim.periodic_y == 1),
-        auto_reinit = sim.auto_reinit,
-        time_scheme = time_scheme,
-        electrolysis = true,
-        navier_stokes = true,
-        ns_advection = (sim.ns_advection == 1),
-        ns_liquid_phase = (sim.solve_Navier_Stokes_liquid_phase == 1),
-        verbose = true,
-        show_every = sim.show_every,
-        electrolysis_convection = (sim.electrolysis_convection == 1),
-        electrolysis_liquid_phase = true,
-        electrolysis_phase_change_case = sim.electrolysis_phase_change_case,
-        imposed_velocity = sim.imposed_velocity,
-        adapt_timestep_mode = sim.adapt_timestep_mode,
-        non_dimensionalize = sim.non_dimensionalize,
-        mode_2d = sim.mode_2d,
-        breakup = sim.breakup,
-        # On injecte ici les BC dynamiques présentes
-        kwargs_bc...
-    )
-end
-
-# Lecture des arguments et du fichier YAML
-localARGS = ARGS
-if length(localARGS) > 0
-    yamlfile = localARGS[1]
-    printstyled(color=:magenta, @sprintf "\n YAML file ")
-    print(yamlfile)
-    print("\n")
-    yamlpath = yamlfile
-    yamlnamelist = split(yamlfile, "/")
-    yamlname = yamlnamelist[end]
-end
-
-data = YAML.load_file(yamlpath)
-
-# Dictionnaires de configuration
-prop_dict = PropertyDict(data)
-study = PropertyDict(prop_dict.study)
-
-# Paramètres de convergence
-nb_grid_points = study.meshes
-n_cases = length(nb_grid_points)
-print("\n number of points ", nb_grid_points, "\n")
-timesteps = study.timesteps
-
-io = PropertyDict(prop_dict.plot) 
-flower = PropertyDict(prop_dict.flower)
-mesh = PropertyDict(flower.mesh)
-sim = PropertyDict(flower.simulation)
-phys = PropertyDict(flower.physics)
-macros = PropertyDict(flower.macros) 
-
-# Initialisation des variables globales via macro
-eval(Meta.parseall(macros.print_parameters))
-
-# ----------------------------------------------------------------
-# Initialisation PDI (IO)
-# ----------------------------------------------------------------
-if io.pdi > 0
-    @debug "Before PDI init"
-    yml_file = yamlfile
-    conf = @ccall "libparaconf".PC_parse_path(yml_file::Cstring)::PC_tree_t
-    getsubyml = @ccall "libparaconf".PC_get(conf::PC_tree_t, ".pdi"::Cstring)::PC_tree_t  
-    local pdi_status = @ccall "libpdi".PDI_init(getsubyml::PC_tree_t)::Cint
-    
-    # Metadonnées MPI
-    mpi_coords_x = 1; mpi_coords_y = 1
-    mpi_max_coords_x = 1; mpi_max_coords_y = 1
-    local nx = 32
-    local ny = 32
-    nstep = 0
-    phys_time = 0.0
-
-    local PDI_status = @ccall "libpdi".PDI_multi_expose("init_PDI"::Cstring, 
-            "mpi_coords_x"::Cstring, mpi_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-            "mpi_coords_y"::Cstring, mpi_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-            "mpi_max_coords_x"::Cstring, mpi_max_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-            "mpi_max_coords_y"::Cstring, mpi_max_coords_y::Ref{Clonglong}, PDI_OUT::Cint,
-            "nx"::Cstring, nx::Ref{Clonglong}, PDI_OUT::Cint,
-            "ny"::Cstring, ny::Ref{Clonglong}, PDI_OUT::Cint,
-            "nb_transported_scalars"::Cstring, phys.nb_transported_scalars::Ref{Clonglong}, PDI_OUT::Cint,
-            "nb_levelsets"::Cstring, phys.nb_levelsets::Ref{Clonglong}, PDI_OUT::Cint,
-            "nstep"::Cstring, nstep::Ref{Clonglong}, PDI_OUT::Cint,
-            C_NULL::Ptr{Cvoid})::Cint
-
-    print("\n PDI INIT status ", PDI_status)
-end
-
-# Tableaux pour stocker les erreurs
-error_list_l1 = zeros(n_cases)
-error_list_l2 = zeros(n_cases)
-error_list_linfty = zeros(n_cases)
-error_list_l1_mixed = zeros(n_cases)
-error_list_l2_mixed = zeros(n_cases)
-error_list_linfty_mixed = zeros(n_cases)
-error_list_l1_full = zeros(n_cases)
-error_list_l2_full = zeros(n_cases)
-error_list_linfty_full = zeros(n_cases)
-
-cell_volume_list = zeros(n_cases)
-base_directory = pwd()
-
-# ----------------------------------------------------------------
-# Boucle de Convergence : Timestep
-# ----------------------------------------------------------------
-for timestep in timesteps
-    
-    print("\n Timestep ", timestep)
-    timestep_to_string = @sprintf "timestep_%.4e" timestep
-    timestep_to_string = replace(timestep_to_string, "." => "_")
-
-    mkpath(timestep_to_string)
-    cd(timestep_to_string)
-
-    # ------------------------------------------------------------
-    # Boucle de Convergence : Mesh
-    # ------------------------------------------------------------
-    for (i, study_nb_grid_points) in enumerate(nb_grid_points)
-        
-        mesh_to_string = @sprintf "mesh_%.5i" study_nb_grid_points
-        mesh_ratio = Int((mesh.ymax - mesh.ymin)/ (mesh.xmax - mesh.xmin))
-        print("\n mesh ratio ", mesh_ratio) 
-
-        study_nb_grid_points_x = study_nb_grid_points
-        study_nb_grid_points_y = study_nb_grid_points * mesh_ratio
-        print("\n nx ", study_nb_grid_points_x, " ny ", study_nb_grid_points_y)
-
-        mkpath(mesh_to_string)
-        cd(mesh_to_string)
-
-        # Init regular grid
-        scalar_mesh_x = collect(LinRange(mesh.xmin, mesh.xmax, study_nb_grid_points_x + 1))    
-        scalar_mesh_y = collect(LinRange(mesh.ymin, mesh.ymax, study_nb_grid_points_y + 1))
-
-        @debug "Before Numerical"
-
-        # Aliases from yml to Flower.jl
-        aliases = Dict(
-            :x => :scalar_mesh_x,
-            :y => :scalar_mesh_y,
-            :xcoord => :intfc_x,
-            :ycoord => :intfc_y,
-            :R => :radius,
-            :max_iterations => :max_iter,
-            :save_every => :max_iter,
-            :ϵ => :epsilon,
-            :ϵwall => :epsilon_wall,
-            :nLS => :nb_levelsets,
-            :θd => :temperature0,
-            :β => :beta,
-            :σ => :sigma,
-            :δreinit => :delta_reinit,
-            :n_ext_cl => :n_ext,
-            :timestep_0 => :timestep,
-            :timestep_n => :timestep,
-            :io_pdi => :pdi,
-        )
-
-        extra = Dict(
-            :scalar_mesh_x => scalar_mesh_x,
-            :scalar_mesh_y => scalar_mesh_y,
-        )
-
-        default = Numerical{Float64,Int}(
-            x = scalar_mesh_x,
-            y = scalar_mesh_y,
-            timestep_n = timestep,
-            timestep_0 = timestep,
-            electrolysis_reaction_symb = Symbol(phys.electrolysis_reaction),
-            bulk_velocity_symb = Symbol(phys.bulk_velocity),
-        )
-
-        print("\n ns_advection ", (sim.ns_advection == 1))
-
-        global num_new = safefill_with_aliases_and_extra_already_init(Numerical{Float64,Int}, default,
-                                 sim, phys, io, aliases, extra)
-
-        global num = num_new
-
-        if num.verbosity > 0
-            print("\n Parameters num ", num)
-        end
-
-        Broadcast.broadcastable(num::Numerical) = Ref(num) 
-        
-        global gp, gu, gv = init_meshes(num)
-        global op, phS, phL = init_fields(num, gp, gu, gv)
-
-        gp.LS[1].u .= 1.0 # deactivate interface
-
-		
-		# ------------------------------------------------------------
-        # EVALUATION DYNAMIQUE (Macros & BC)
-        # ------------------------------------------------------------
-        # 1. On exécute TOUTES les macros pour créer les variables dans Main
-        eval(Meta.parseall(macros.init_fields))
-        eval(Meta.parseall(macros.boundaries))
-        eval(Meta.parseall(macros.interface)) # <--- DÉPLACÉ ICI (IMPORTANT)
-
-        # 2. Capture des BC dans un dictionnaire pour éviter le "World Age Problem"
-        bc_dict = Dict{Symbol, Any}()
-        bc_symbols = [:BC_uL, :BC_uS, :BC_vL, :BC_vS, :BC_pL, :BC_pS, :BC_u, :BC_int, :BC_trans_scal, :BC_phi_ele]
-        
-        for sym in bc_symbols
-            if isdefined(Main, sym)
-                bc_dict[sym] = getfield(Main, sym)
-            else
-                # Si la variable n'est pas définie, on ne l'ajoute pas au dict.
-                # Cela laissera run_forward! utiliser sa valeur par défaut (si elle existe)
-                # ou plantera avec une erreur plus claire si elle est obligatoire.
-            end
-        end
-        # ------------------------------------------------------------
-
-        if num.io_pdi > 0
-            # Send meta-data to PDI
-            nx = gp.nx
-            ny = gp.ny
-            try
-                local PDI_status = @ccall "libpdi".PDI_multi_expose("init_PDI"::Cstring, 
-                        "mpi_coords_x"::Cstring, mpi_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-                        "mpi_coords_y"::Cstring, mpi_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-                        "mpi_max_coords_x"::Cstring, mpi_max_coords_x::Ref{Clonglong}, PDI_OUT::Cint,
-                        "mpi_max_coords_y"::Cstring, mpi_max_coords_y::Ref{Clonglong}, PDI_OUT::Cint,
-                        "nx"::Cstring, nx::Ref{Clonglong}, PDI_OUT::Cint,
-                        "ny"::Cstring, ny::Ref{Clonglong}, PDI_OUT::Cint,
-                        "nb_transported_scalars"::Cstring, phys.nb_transported_scalars::Ref{Clonglong}, PDI_OUT::Cint,
-                        "nb_levelsets"::Cstring, phys.nb_levelsets::Ref{Clonglong}, PDI_OUT::Cint,
-                        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                        "nb_Navier_slip_BC"::Cstring, num.nNavier::Ref{Clonglong}, PDI_OUT::Cint,
-                        "timestep"::Cstring, timestep::Ref{Cdouble}, PDI_OUT::Cint,
-                        C_NULL::Ptr{Cvoid})::Cint
-            catch error
-                print("\n Bug init_PDI \n")
-                print("\n error", error)
-            end
-        end
-
-        eval(Meta.parseall(macros.interface))
-
-        if sim.time_scheme == "FE"
-            time_scheme = FE
-        else
-            time_scheme = CN
-        end
-
-        # --- Sorties PDI Initiale ---
-        if num.io_pdi > 0
-            try
-                iLSpdi = 1 
-                LStable = zeros(gp)
-                if phys.nb_levelsets > 1
-                    LStable = gp.LS[2].u
-                end
-                
-                us = zeros(gp)
-                vs = zeros(gp)
-                interpolate_grid_liquid!(gp, gu, gv, phL.u, phL.v, us, vs)
-                current_radius = phys.radius
-
-                PDI_status = @ccall "libpdi".PDI_multi_expose("write_initialization"::Cstring,
-                    "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                    "time"::Cstring, phys_time::Ref{Cdouble}, PDI_OUT::Cint,
-                    "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_p"::Cstring, gp.LS[iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_u"::Cstring, gu.LS[iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_v"::Cstring, gv.LS[iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_p_wall"::Cstring, LStable::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    "velocity_x"::Cstring, us::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    "velocity_y"::Cstring, vs::Ptr{Cdouble}, PDI_OUT::Cint,      
-                    "radius"::Cstring, current_radius::Ref{Cdouble}, PDI_OUT::Cint,  
-                    C_NULL::Ptr{Cvoid})::Cint
-            catch error
-                printstyled(color=:red, @sprintf "\n PDI error \n")
-                print(error)
-            end
-        end 
-
-        # --- Sorties PDI Post-process bubble ---
-        velocity_y_bubble = 0.0 .* gp.LS[end].geoS.dcap[:,:,5]
-        volume_fraction = gp.LS[end].geoS.dcap[:,:,5]
-        iLSpdi = 1
-        velocity_y = velocity_y_bubble
-
-        PDI_status = @ccall "libpdi".PDI_multi_expose("post_processing_rising_bubble"::Cstring,
-            "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-            "velocity_y"::Cstring, velocity_y::Ptr{Cdouble}, PDI_OUT::Cint,      
-            "volume_fraction"::Cstring, volume_fraction::Ptr{Cdouble}, PDI_OUT::Cint,
-            "volume_liq_cell"::Cstring, gp.LS[iLSpdi].geoL.dcap[:,:,5]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            "volume_cell"::Cstring, gp.LS[iLSpdi].geoS.dcap[:,:,5]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            "mesh_p_x"::Cstring, gp.x::Ptr{Cdouble}, PDI_OUT::Cint,
-            "mesh_p_y"::Cstring, gp.y::Ptr{Cdouble}, PDI_OUT::Cint,
-            "dcap_1"::Cstring, gp.LS[iLSpdi].geoS.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            "dcap_2"::Cstring, gp.LS[iLSpdi].geoS.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            "dcap_3"::Cstring, gp.LS[iLSpdi].geoS.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            "dcap_4"::Cstring, gp.LS[iLSpdi].geoS.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint, 
-            C_NULL::Ptr{Cvoid})::Cint
-
-        # -----------------------------------------------------------------------------------------
-        # APPEL DU SOLVEUR via FUNCTION BARRIER + INVOKELATEST
-        # C'est ici que la correction opère : on passe le dictionnaire 'bc_dict' via invokelatest
-        # -----------------------------------------------------------------------------------------
-        @debug "Before run_forward wrapper"
-        Base.invokelatest(
-            execute_simulation_step, 
-            num, gp, gu, gv, op, phS, phL, sim, phys, time_scheme, bc_dict
-        )
-        @debug "After run"
-        # -----------------------------------------------------------------------------------------
-
-        # Calcul d'erreurs (si demandé)
-        if study.compute_errors != "None"
-
-            LIQUID = gp.ind.all_indices[gp.LS[1].geoL.cap[:,:,5] .> (1-1e-16)]
-            MIXED = gp.ind.all_indices[gp.LS[1].geoL.cap[:,:,5] .<= (1-1e-16) .&& gp.LS[1].geoL.cap[:,:,5] .> 1e-16]
-
-            if study.compute_errors == "Poiseuille"
-                l1, l2, linfty = relative_errors(phL.v, vPoiseuille, vcat(LIQUID, MIXED), gp.LS[1].geoL.cap[:,:,5], num.Δ)
-                l1_mixed, l2_mixed, linfty_mixed = relative_errors(phL.v, vPoiseuille, MIXED, gp.LS[1].geoL.cap[:,:,5], num.Δ)
-                l1_full, l2_full, linfty_full = relative_errors(phL.v, vPoiseuille, LIQUID, gp.LS[1].geoL.cap[:,:,5], num.Δ)
-            
-            elseif study.compute_errors == "diffusion_full_cell"
-                L = mesh.xmax - mesh.xmin
-                D = num.diffusion_coeff[2]
-                analytical_nx = 1000
-                diffusion_time_scale = L^2 / D
-                ele_current_i = -1.59e4
-                F1 = ele_current_i / (2 * num.Faraday * D)
-                analytical_dx = L / analytical_nx
-                c0 = num.concentration0[2] 
-                max_nb_Fourier_series = 1000
-
-                function full_cell_u1(x, t)
-                    return F1 * x
-                end
-                function full_cell_A_n(n, L, F1, dx, c0)
-                    if n == 0
-                        return -F1*L + 2*c0 
-                    else
-                        return (-2*F1*L)/(n*π)^2*((-1)^n-1) 
-                    end
-                end
-                function full_cell_u2(x, t, L, D, max_nb_Fourier_series, c0, analytical_dx)
-                    result = sum(full_cell_A_n(n, L, F1, analytical_dx, c0) * cos(n * π * x / L) * exp(-D * (n * π / L)^2 * t) for n in 1:max_nb_Fourier_series)
-                    result += full_cell_A_n(0, L, F1, analytical_dx, c0) * cos(0 * π * x / L) * exp(-D * (0 * π / L)^2 * t) / 2
-                    return result
-                end
-                function full_cell_u(x, t, L, D, max_nb_Fourier_series, c0, analytical_dx)
-                    return full_cell_u1(x, t) + full_cell_u2(x, t, L, D, max_nb_Fourier_series, c0, analytical_dx)
-                end
-                
-                concentration_profile = full_cell_u.(gp.x[2,:], num.time, L, num.diffusion_coeff[2], max_nb_Fourier_series, c0, analytical_dx)
-                
-                l1, l2, linfty = relative_errors(phL.trans_scal[:,:,2], concentration_profile, vcat(LIQUID, MIXED), gp.LS[1].geoL.cap[:,:,5], num.Δ)
-                l1_mixed, l2_mixed, linfty_mixed = relative_errors(phL.trans_scal[:,:,2], concentration_profile, MIXED, gp.LS[1].geoL.cap[:,:,5], num.Δ)
-                l1_full, l2_full, linfty_full = relative_errors(phL.trans_scal[:,:,2], concentration_profile, LIQUID, gp.LS[1].geoL.cap[:,:,5], num.Δ)
-            end
-
-            error_list_l1[i] = l1
-            error_list_l2[i] = l2
-            error_list_linfty[i] = linfty
-            error_list_l1_mixed[i] = l1_mixed
-            error_list_l2_mixed[i] = l2_mixed
-            error_list_linfty_mixed[i] = linfty_mixed
-            error_list_l1_full[i] = l1_full
-            error_list_l2_full[i] = l2_full
-            error_list_linfty_full[i] = linfty_full
-            cell_volume_list[i] = minimum(gp.LS[1].geoL.dcap[:,:,5])
-            min_cell_volume = minimum(gp.LS[1].geoL.dcap[:,:,5])
-
-            local PDI_status = @ccall "libpdi".PDI_multi_expose("convergence_study_iter"::Cstring, 
-                "study_nb_grid_points"::Cstring, study_nb_grid_points::Ref{Clong}, PDI_OUT::Cint,
-                "study_timestep"::Cstring, timestep::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l1_rel_error"::Cstring, l1::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l2_rel_error"::Cstring, l2::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_linfty_rel_error"::Cstring, linfty::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l1_rel_error_full_cells"::Cstring, l1_full::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l2_rel_error_full_cells"::Cstring, l2_full::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_linfty_rel_error_full_cells"::Cstring, linfty_full::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l1_rel_error_partial_cells"::Cstring, l1_mixed::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_l2_rel_error_partial_cells"::Cstring, l2_mixed::Ref{Cdouble}, PDI_OUT::Cint,
-                "study_linfty_rel_error_partial_cells"::Cstring, linfty_mixed::Ref{Cdouble}, PDI_OUT::Cint,
-                "domain_length"::Cstring, L0::Ref{Cdouble}, PDI_OUT::Cint,
-                "min_cell_volume"::Cstring, min_cell_volume::Ref{Cdouble}, PDI_OUT::Cint,
-                C_NULL::Ptr{Cvoid})::Cint
-        end
-
-        current_directory = pwd()
-        if current_directory == base_directory*"/"*timestep_to_string*"/"*mesh_to_string
-            cd("..")
-        else 
-            print("\n Error in mesh subdirectory", current_directory, " not ", base_directory*"/"*timestep_to_string*"/"*mesh_to_string)
-            exit()
-        end
-
-    end # end mesh convergence
-
-    current_directory = pwd()
-    if current_directory == base_directory*"/"*timestep_to_string
-        cd("..")
-    else
-        print("\n Error in timestep subdirectory", current_directory, " not ", base_directory*"/"*timestep_to_string)
-        exit()
-    end
-
-end # end timestep convergence
-
-# Finalisation PDI et Tests
-min_cell_volume = minimum(gp.LS[1].geoL.cap[:,:,5])
-print("\n min_cell_volume ", min_cell_volume, " type ", typeof(min_cell_volume))
-
-if study.compute_errors != "None"
-    local PDI_status = @ccall "libpdi".PDI_multi_expose("convergence_study"::Cstring, 
-    "n_tests"::Cstring, n_cases::Ref{Clonglong}, PDI_OUT::Cint,
-    "nx_list"::Cstring, nb_grid_points::Ptr{Clonglong}, PDI_OUT::Cint,
-    "cell_volume_list"::Cstring, cell_volume_list::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l1_rel_error"::Cstring, error_list_l1::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l2_rel_error"::Cstring, error_list_l2::Ptr{Cdouble}, PDI_OUT::Cint,
-    "linfty_rel_error"::Cstring, error_list_linfty::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l1_rel_error_full_cells"::Cstring, error_list_l1_full::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l2_rel_error_full_cells"::Cstring, error_list_l2_full::Ptr{Cdouble}, PDI_OUT::Cint,
-    "linfty_rel_error_full_cells"::Cstring, error_list_linfty_full::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l1_rel_error_partial_cells"::Cstring, error_list_l1_mixed::Ptr{Cdouble}, PDI_OUT::Cint,
-    "l2_rel_error_partial_cells"::Cstring, error_list_l2_mixed::Ptr{Cdouble}, PDI_OUT::Cint,
-    "linfty_rel_error_partial_cells"::Cstring, error_list_linfty_mixed::Ptr{Cdouble}, PDI_OUT::Cint,
-    "domain_length"::Cstring, L0::Ref{Cdouble}, PDI_OUT::Cint,
-    "min_cell_volume"::Cstring, min_cell_volume::Ref{Cdouble}, PDI_OUT::Cint,
-    C_NULL::Ptr{Cvoid})::Cint
-end
- 
-if io.pdi > 0
-    try
-        local PDI_status = @ccall "libpdi".PDI_finalize()::Cint
-    catch error
-        printstyled(color=:red, @sprintf "\n PDI error \n")
-        print(error)
-    end
-end
-
-printstyled(color=:red, @sprintf "\n After PDI \n")
-
-if haskey(macros, "test_end")
-    eval(Meta.parseall(macros.test_end))
-end

convergence_diffusion_constant_conductivity_bubble_wall_Newton.yml

@@ -1,4383 +0,0 @@
-flower:
-  physics:
-    #Coefficients for Butler-volmer
-    alpha: &alpha 0.5
-    alpha_a: 0.5
-    alpha_c: 0.5
-    bulk_velocity: zero #use zero velocity in liquid phase for transport
-    # Species        H2      KOH    H2O
-    # concentration0: &concentration0 [1.6e-1, 6.7e3, 4.9e4]
-    # concentration0: [&cH2, cKOH, cH2O]
-    # concentration0: [1.6e-1, 6.7e3, 4.9e4]
-    concentration0_H2: &concentration0_H2 1.6e-1
-    concentration0_KOH: &concentration0_KOH 6.7e3
-    concentration0_H2O: &concentration0_H2O 4.9e4
-    concentration0: [*concentration0_H2, *concentration0_KOH, *concentration0_H2O]
-
-    epsilon_concentration: [1e-14, 1e-14, 1e-14]
-    electrolysis_reaction: "Butler_no_concentration"
-    diffusion_coeff_H2: &diffusion_coeff_H2 5.8e-9
-    diffusion_coeff_KOH: &diffusion_coeff_KOH 3.2e-9
-    diffusion_coeff_H2O: &diffusion_coeff_H2O 3.2e-9
-    diffusion_coeff: [*diffusion_coeff_H2, *diffusion_coeff_KOH, *diffusion_coeff_H2O]
-    species_names: &species_names ['H2','KOH','H2O']
-    end_time: 1.0 #7.3 #s
-    current: 1000 #A
-    Faraday: &Faraday 9.64853321233100184e4 #C⋅mol−1
-    Henry_H2: &Henry_H2 1
-    Henry_KOH: &Henry_KOH 0
-    Henry_H2O: &Henry_H2O 0
-    Henry: [*Henry_H2, *Henry_KOH, *Henry_H2O]
-    i0: &i0 1.0
-    intfc_x: 0.0 # x coordinate of bubble center
-    intfc_y: 5.0e-5 # y coordinate of bubble center
-    # KOHwtpercent: 30
-    ls_wall_xmin: 5e-6
-    mu1: 0.0 #6.7e-7*1258.0
-    mu2: 0.0
-    mu_cin1: &mu_cin1 6.7e-7
-    mu_cin2: &mu_cin2 6.7e-7 #m^2/s
-    MWH2: 2.01568e-3 #kg/mol
-    nb_levelsets: &nb_levelsets 1 #2
-    nb_transported_scalars: &nb_transported_scalars 0 #TODO or inv stoechiometric
-
-    Navier_slip_length: 1.0e-2  
-    nucleation_time: -1.0 #deactivated
-    #Electric potential
-    phi_ele0: 0.0
-    phi_ele1: &phi_ele1 -0.6
-    pres0:  0.0 #1e5
-    radius: 1.2e-5 # 6.0e-6 #3.0e-6 #initial radius
-    ref_length: 1e-4
-    rho1: &rho1 1258.0 #liquid
-    rho2: 0.069575 #gaz
-    #TODO need for 80°C, check with other study
-    #"0.7016E-01" in \citet{cohnTABLETHERMODYNAMICPROPERTIES1963} H2
-    # Linear interpolation between 350 and 360
-    # 350 360 353 B 0.13841 353 350 360
-    # 7.02E-02 6.82E-02 -0.00194999999999999 A -0.000194999999999999 0.069575 0.07016 0.06821
-    radial_vel_factor: 1e-7
-    Ru: &Ru 8.314
-    sigma: 7.7e-2
-    temperature0: &temperature0 353.0
-    theta_e: 30 #145 #90  
-    theta_adv: 120
-    theta_rec: 30
-    # if θe < 40
-    #     max_its = 35000
-    # elseif θe < 100
-    #     max_its = 15000
-    # else
-    #     max_its = 5000
-    # end
-
-    v_inlet: &v_inlet 6.7e-4
-    g: 9.81
-    beta: 0.0 #angle for gravity
-    domain_length: &domain_length 1.0e-4
-
-
-  mesh:
-    nx: 128
-    ny: 128
-    xmin: &mesh_xmin 0.0
-    xmax: &mesh_xmax 1.0e-4
-    ymin: &mesh_ymin 0.0 
-    ymax: &mesh_ymax 1.0e-4
-  simulation:
-    activate_interface: &activate_interface 1
-    advection_LS_mode: 10 #9 #8 #2 #5 #4 #3 #2
-    adapt_timestep_mode: 3 #fixed timestep
-    average_liquid_solid: 0
-    ns_advection: 1 #0 no advection
-    auto_reinit: 1 #activated: 1
-    bc_int: WallNoSlip #FreeSurface #WallNoSlip
-    breakup: 1
-    bulk_conductivity: 3 #2 3:constant conductivity from c_0
-    # uses bulk or interfacial concentrationfor conductivity
-    case: None #Planar #Cylinder
-    CFL: 0.5
-    concentration_check_factor: &concentration_check_factor 1.0e-4 #TODO do not write 1e-4, ill read in python
-    contact_angle: 1 #activate advancing/receding contact angle
-    convection_Cdivu: 0
-    convection_mode: 1 #0 #1
-    electrolysis_convection: 0 #1
-    electrical_potential: 3 #2 #0 deactivated
-    electrical_potential_max_iter: 50 #20
-    electrical_potential_relative_residual: 1.0e-10
-    electrical_potential_residual: 1.0e-10
-    electrical_potential_nonlinear_solver: 1 #0 for successive substitutions #1 for Newton-Raphson
-    electrolysis_phase_change_case: "None" #"Khalighi" #no phase change
-    phase_change_method: 6 #5 #fixed mass transfer rate 0.05 rho_l  #4
-    epsilon_volume_fraction_phase_change: 1.0e-6
-    # electrolysis_phase_change_case: "Khalighi" #integration on whole surface to get a radius
-    # electrolysis_phase_change_case: "levelset" # local
-    eps: 1.0e-12 #eps for small numbers
-    epsilon: 0.2 #0.05 #0.2 #cut small cells
-    epsilon_wall: 0.2 #0.05 #0.2
-    #if epsilon=0 centroids will be on the interface
-    epsilon_mode: 2 #way to handle epsilon:
-    # if num.epsilon_mode == 0
-    #     return 1 / (W+eps(0.01))
-    # elseif num.epsilon_mode == 1
-    #     return 1 / max(W, num.epsilon_vol)
-    # elseif num.epsilon_mode == 2
-    #     return inv_weight_clip(num,W)   
-    # end
-    kill_dead_cells: 1
-    extend_field: 1 #do not
-    imposed_velocity : "none" #"zero" #"none" #"zero" #"none"
-    index_phase_change: 1
-    index_electrolyte: 2
-    max_iter: 1 #1 #60 #1 #60 #1 #60 #maximum number of iterations
-    average_velocity: 1 #0
-    laplacian: 0 #1 #multiply by 4/3
-    marching_squares_epsilon: 1.0e-9
-    marching_squares_max_iter: 15
-    mass_transfer_rate: 2 #1 #Johansen & Colella
-    mode_2d: 3
-    # mode_2d = 1 #use equivalent cylinder
-    # mode_2d = 2 #mol/meter 
-    # mode_2d = 3 #mol/meter with xcoord and ycoord parameters for LS definition
-
-    name: "convergence_diffusion"
-    nb_reinit: 2 #10
-    non_dimensionalize: 0 # 0: NS equations as is (without non_dimensionalization)
-    null_space: 0 #method for null space, matrix diagonal
-    one_fluid_model: 0
-    one_fluid_normal: 1
-    surface_tension: 1 # 0 for CSF from VOF, 1 for LS
-    mu_one_fluid_average: 1 #0 : arithmetic #1 harmonic
-    smooth_VOF: 2
-    periodic_x: 0
-    periodic_y: 0
-    prediction: PmIIimposedpressureBCincrement #0 #4 #0 #pressure-velocity coupling
-    # prediction = 0
-    # prediction = 1
-    # prediction = 2
-    # prediction = 3 # PIII in Brown's article
-    # prediction = 4
-    pressure_velocity_coupling: 0 #3 #3 #1 # 0: projection, 1: coupled
-    pressure_velocity_solver: 0 #direct 1 #BICGSTAB(2)
-    solve_solid: 0 #0 do not solve in solid
-    reinit_every: 3 #0 #3 # period of levelset reinialization
-    levelset_reinitialize: 0 #do not reinit
-    restart: 0 #TODO restart with PDI
-    show_every: 1
-    scalar_bc: 0 #1 for multiple LS (describing wall) #0 for one LS
-    scalar_scheme: 0 #1 #0 #CN 1  #Backward Euler (implicit)
-    solve_Navier_Stokes_liquid_phase: 0 #1 activated
-    solve_Navier_Stokes: 0
-    solve_potential: 1
-    solve_species: 1
-    solver: 0 #2 #0 #1 #0: Julia 1: MUMPS
-    debug: "None" #"allocations_start" #"scalar_testing" #"scalar_debug" 
-    time_scheme: FE #CN #FE #Forward Euler
-    # time_scheme: CN
-    n_ext: 10 
-    delta_reinit: 10.0 # delta for automatic reinitialization
-    NB: 24 # number of cells the velocity is extended
-    verbosity: 0 #3
-
-  macros:
-
-    boundaries: |
-
-      # Signs in divergence theorem
-      sign_left = -1.0 #n \cdot e_x = -1
-      sign_right = 1.0 #n \cdot e_x = 1
-      sign_bottom = -1.0 #n \cdot e_y = -1
-      sign_top = 1.0 #n \cdot e_y = 1
-
-      if phys.nb_levelsets ==1
-        BC_int = [WallNoSlip()] #[FreeSurface()]
-      end
-
-      BC_uL= BoundariesInt()
-      
-      BC_vL= BoundariesInt()
-
-      BC_pL = Boundaries(
-          name = "BC_pL",
-          left   = Neumann(),
-          right  = Neumann(),
-          bottom = Neumann(),
-          top    = Neumann(),
-      )
-
-      i_butler = gp.x[:,1] .*0.0
-      phi_ele =  gp.x[:,1] .*0.0
-      i_butler=butler_volmer_no_concentration.(phys.alpha_a,phys.alpha_c,phys.Faraday,phys.i0,phi_ele,phys.phi_ele1,phys.Ru,phys.temperature0)
-      
-      BC_phi_ele = BoundariesInt(
-      left   = Neumann(val=i_butler./elec_cond), #TODO -BC in Flower ? so i_butler not -i_butler
-      right  = Dirichlet(),
-      bottom = Neumann(val=0.0),
-      top    = Neumann(val=0.0),
-      int    = Neumann(val=0.0),
-      LS = [Neumann(val=0.0)]
-      )
-      
-      BC_trans_scal_H2 = BoundariesInt(
-      bottom = Dirichlet(val = phys.concentration0[1]),
-      top    = Neumann(),
-      left   = Neumann(val=-i_butler/(2*phys.Faraday*DH2)),
-      right  = Dirichlet(val = phys.concentration0[1]),
-      int    = Dirichlet(val = phys.concentration0[1]/phys.Henry_H2))
-      #KOH
-      BC_trans_scal_KOH = BoundariesInt(
-          bottom = Dirichlet(val = phys.concentration0[2]),
-          top    = Neumann(),
-          left   = Neumann(val=-i_butler/(2*phys.Faraday*DKOH)),
-          right  = Dirichlet(val = phys.concentration0[2]),
-          int    = Neumann(val=0.0)) #KOH
-      
-      #H2O   
-      BC_trans_scal_H2O = BoundariesInt(
-          bottom = Dirichlet(val = phys.concentration0[3]),
-          top    = Neumann(),
-          left   = Neumann(val=i_butler/(phys.Faraday*DH2O)),
-          right  = Dirichlet(val = phys.concentration0[3]),
-          int    = Neumann(val=0.0)) 
-
-
-      BC_trans_scal = [
-        BC_trans_scal_H2, #H2
-        BC_trans_scal_KOH, #KOH
-        BC_trans_scal_H2O] #H2O
-
-
-     
-
-      BC_u = Boundaries(
-        bottom = Neumann_inh(),
-        top = Neumann_inh(),
-        left = Neumann_inh(),
-        right = Neumann_inh()
-      )
-
-      BC_uS = BoundariesInt()
-
-      BC_vS = BoundariesInt()
-
-      BC_pS = Boundaries()
-
-      # print BC
-
-      # print("\n BC_int ",BC_int)
-      print("\n BC_uL ",BC_uL)
-      print("\n BC_vL ",BC_vL)
-
-      print("\n BC_pL ",BC_pL)
-
-      print("\n BC_phi_ele ",BC_phi_ele)
-
-      print("\n BC_trans_scal ",BC_trans_scal)
-
-      open("BC0.html", "w") do file
-          print_BC_html(BC_uL,"u";io=file)
-          print_BC_html(BC_vL,"v";io=file)
-          print_BC_html(BC_pL,"p";io=file)
-          print_BC_html(BC_phi_ele,"phi";io=file)
-          print_BC_html(BC_trans_scal_H2,"H2";io=file)
-          print_BC_html(BC_trans_scal_KOH,"KOH";io=file)
-          print_BC_html(BC_trans_scal_H2O,"H2O";io=file)
-
-          # write(file, "This is a line of text.\n")
-          # The file will be automatically closed here
-      end
-
-      
-      L0 = mesh.xmax - mesh.xmin
-
-
-      print("\n grad ",(BC_pL.top.val-BC_pL.bottom.val)/L0)
-
-
-    init_fields: |
-      printstyled(color=:green, @sprintf "\n Initialisation \n")
-
-      #init Bulk
-      if num.solve_solid == 1 
-        phS.T .= phys.temperature0
-      end
-      phL.T .= phys.temperature0
-
-     
-      # Electrochemistry 
-      for iscal=1:phys.nb_transported_scalars
-          phL.trans_scal[:,:,iscal] .= phys.concentration0[iscal]
-      end
-
-      phL.phi_ele .= phys.phi_ele0
-
-      # Initialize Poiseuille pressure profile
-      phL.u .= 0.0
-      phL.v .= 0.0 
-      phL.uD .= 0.0
-      phL.vD .= 0.0
-
-      # p_top = 0
-
-      # p_bottom = p_top + phys.rho1*phys.g*(mesh.ymax - mesh.ymin)
-
-      # phL.p .= p_bottom .+ (gp.y .- mesh.ymin)*(p_top-p_bottom)/(mesh.ymax - mesh.ymin) 
-      # vec1(phL.pD,gp) .= vec(phL.p)
-
-      #  
-      # p_top = 0
-      # p_bottom = p_top + 8*mu1/phys.ref_length*phys.v_inlet
-      
-      # phL.p .= p_bottom .+ (gp.y .- mesh.ymin)*(p_top-p_bottom)/(mesh.ymax - mesh.ymin) 
-  
-      # vec1(phL.pD,gp) .= vec(phL.p)
-
-      # # Initialize Poiseuille velocity profile 
-
-      # vPoiseuille = Poiseuille_fmax.(gv.x,phys.v_inlet,phys.ref_length) 
-      # vPoiseuilleb = Poiseuille_fmax.(gv.x[1,:],phys.v_inlet,phys.ref_length) 
-
-      # phL.u .= 0.0
-      # phL.v .= vPoiseuille 
-
-      # vecb_B(phL.vD,gv) .= vPoiseuilleb
-
-
-    interface: |
-
-      # gp.LS[1].u .= gp.x .- phys.ls_wall_xmin
-      
-      if sim.activate_interface == 1
-
-        gp.LS[1].u .= sqrt.((gp.x .- phys.intfc_x).^2 + (gp.y .- phys.intfc_y).^2) - phys.radius * ones(gp)
-      
-        #modify velocity field near interface
-        su = sqrt.((gv.x .- phys.intfc_x).^2 .+ (gv.y .- phys.intfc_y).^2)
-        R1 = phys.radius + 3.0*num.Δ
-
-        bl = 4.0
-        for II in gv.ind.all_indices
-            if su[II] <= R1
-                phL.v[II] = 0.0
-            # elseif su[II] > R1
-            #     uL[II] = tanh(bl*(su[II]-R1))
-            end
-        end
-
-      elseif sim.activate_interface == -1
-        gp.LS[1].u .= sqrt.((gp.x .- phys.intfc_x).^2 + (gp.y .- phys.intfc_y).^2) - phys.radius * ones(gp)
-        gp.LS[1].u .*= -1.0
-
-      else
-          gp.LS[1].u .= 1.0
-      end
-      test_LS(gp)
-
-
-    print_parameters: | 
-      print("\n Print parameters from yml file \n")
-      mu = phys.mu_cin1 *phys.rho1 #in Pa s = M L^{-1} T^{-1}}
-
-      phys.mu1 = mu
-      phys.mu2 = mu
-
-      mu1=mu
-      mu2=mu 
-
-      h0 = phys.radius
-
-      # print("\n phys.concentration0 ",phys.concentration0)
-      # c0_H2 = phys.concentration0.concentration0_H2
-      # c0_KOH = phys.concentration0.concentration0_KOH
-      # c0_H2O = phys.concentration0.concentration0_H2O
-
-      # concentration0_dict =  PropertyDict(phys.concentration0)
-      # c0_H2 = concentration0_dict.concentration0_H2
-      # c0_KOH = concentration0_dict.concentration0_KOH
-      # c0_H2O = concentration0_dict.concentration0_H2O
-
-      c0_H2,c0_KOH,c0_H2O = phys.concentration0
-
-      DH2,DKOH,DH2O= phys.diffusion_coeff
-
-      elec_cond=2*phys.Faraday^2*c0_KOH*DKOH/(phys.Ru*phys.temperature0)
-
-      printstyled(color=:red, @sprintf "\n elec_cond : %.2e \n" elec_cond)
-
-
-      Re=phys.rho1*phys.v_inlet*phys.ref_length/mu #Reynolds number
-      printstyled(color=:green, @sprintf "\n Re : %.2e %.2e %.2e %.2e\n" Re phys.rho1/mu1 phys.rho1 mu1)
-
-      Re=phys.rho1/mu1 #not Reynolds number, but rho1/mu1
-
-      printstyled(color=:green, @sprintf "\n 'Re' i.e. rho/mu : %.2e %.2e %.2e %.2e\n" Re phys.rho1/mu1 phys.rho1 mu1)
-
-      if phys.nb_transported_scalars>0
-        if length(phys.concentration0)!=phys.nb_transported_scalars
-            print(@sprintf "\nnb_transported_scalars: %5i\n" phys.nb_transported_scalars)
-            @error ("nb_transported_scalars")
-        end
-
-        if length(phys.diffusion_coeff)!=phys.nb_transported_scalars
-            print(@sprintf "\nnb_transported_scalars: %5i\n" phys.nb_transported_scalars)
-            @error ("nb_transported_scalars")
-        end
-      else
-        printstyled(color=:red, @sprintf "\n WARNING no scalar transport\n")
-      end
-
-      print(@sprintf "\nnb_transported_scalars: %5i\n" phys.nb_transported_scalars)
-
-      # diffusion_t = (phys.radius^2)./phys.diffusion_coeff
-     
-      diffusion_t = ((mesh.xmax-mesh.xmin)^2)./phys.diffusion_coeff
-
-
-      print("\n diffusion time ", diffusion_t,"\n")
-
-      open("report.html", "w") do file
-
-        # write("simulation time ", phys.end_time)
-        # write("simulation dt ", timestep)
-        # write("simulation max_iter ", sim.max_iter)
-        # write("diffusion time ", diffusion_t)
-
-        print(file,"\nsimulation time ", phys.end_time)
-        # print(file,"\ndt ", timestep)
-        print(file,"\nsimulation max_iter ", sim.max_iter)
-        print(file,"\ndiffusion time ", diffusion_t)
-
-        # print_BC_html(BC_uL,"u";io=file)
-        # print_BC_html(BC_vL,"v";io=file)
-        # print_BC_html(BC_pL,"p";io=file)
-        # write(file, "This is a line of text.\n")
-        # The file will be automatically closed here
-      end
-
-      print("\n end Print parameters from yml file \n")
-
-
-    # test_end: |
-    #   print("\n test end \n")
-    #   open("BC.html", "w") do file
-    #       print_BC_html(BC_uL,"u";io=file)
-    #       print_BC_html(BC_vL,"v";io=file)
-    #       print_BC_html(BC_pL,"p";io=file)
-    #       print_BC_html(BC_phi_ele,"phi";io=file)
-    #       print_BC_html(BC_trans_scal_H2,"H2";io=file)
-    #       print_BC_html(BC_trans_scal_KOH,"KOH";io=file)
-    #       print_BC_html(BC_trans_scal_H2O,"H2O";io=file)
-
-    #       # write(file, "This is a line of text.\n")
-    #       # The file will be automatically closed here
-    #   end
-    #   phi_test = -1.166e-02
-    #   i_butler_test = butler_volmer_no_concentration.(phys.alpha_a,phys.alpha_c,phys.Faraday,phys.i0,phi_test,phys.phi_ele1,phys.Ru,phys.temperature0)
-
-    #   print("\n test Butler ",i_butler_test)
-      
-    #   # L  = Lmesh_xmax-mesh_xmin
-
-    #   print("\n test Butler ",i_butler_test,-i_butler_test*L)
-    #   print("\n")
-
-study:
-  #tolerance for tests
-  test_tolerance: 1.e-11 #1.e-14
-  test_tolerance_solution_absolute:  1.e-1 # from n = 16 
-  meshes: [32,64,128] #[32,64,128,256]
-  compute_errors: None
-  timesteps:  [1e-4] #[1e-3] #[5e-3] #[1e-2] #[5e-2] #[5e-3] # #[1e-3] #[1e-4]
-  #nucleation_time is 2.0e-2
-
-plot:
-  ax_locator_x: [0,20,40,60,80,100] #ticks in matplotlib
-  ax_locator_y: [0,20,40,60,80,100] 
-  ax_formatter_x: [0,20,40,60,80,100] #[0,$L_e$]
-  ax_formatter_y: [0,20,40,60,80,100] #[0,$L_e$]
-  xlim: [0,100] #[0,3.175e-4]
-  ylim: [0,100] #[0,3.175e-4]
-  cbarlabel: "" #["u","v"]
-  cmap: "viridis"
-  color_line: "k" #"w" #"k"
-  color_wall: 'k'
-  fig_fraction: 1.0 #0.5
-  interface_color: 'r' #'k'
-  extend: neither #max
-  xlabel: $x ( \unit{\um})$
-  ylabel: $y ( \unit{\um})$
-  linewidth: 1
-  linestyle: None
-  skip_every: 1 #12
-  text_color: k
-  themes: [dark,light] #[light] #[dark,light]
-  theme: light
-  film_format: mp4
-
-
-
-  quiver_scale: 1e-4
-  quiver_scale_unit: xy #None
-  scale_time: 1e-3
-  scale_vel: 1e-4 
-  scale_x: 1e-6
-  scale_y: 1e-6
-  theta1: 0
-  theta2: 90
-  ticks_x: 0:20:100
-  ticks_y: 0:20:100
-  unit_time: ms
-  write_h5: 0
-  
-  plot_grid: false
-  plot_levelset: True
-  plot_levelset_segments: False
-  plot_movies : false
-  plot_R : false
-  #debug Levelset
-  plotcase : "none"
-  #plotcase : "circle"
-  plot_current_wall : false
-  # plot_current_wall : true
-  plot_interface : false
-  # plot_interface : true 
-  plot_mode: "pcolormesh"
-  fontsize: 2
-  print_mode: "val"
-  plotbc: true
-
-  dpi: 300
-  font_size: 12
-  img_format: "pdf"
-
-  latex_frame_height: 180 #220 #180 #200 #220 # 261.20912 #228.4378 #pt #beamer
-  latex_frame_width: 426.79135 # 398.3386
-  #do not plot 2D figure, used in special plots (velocity vectors and current lines):
-  no_2D_plot: ["velocity_x","velocity_y","i_current_x","i_current_y"] 
-  pdi: 1 #1: pdi activated
-
-  # quiver_scale_unit: xy #None
-  # scale_time: 1e-3
-  # scale_vel: 1e-4 
-  # scale_x: 1.0 #1e-6
-  # scale_y: 1.0 #1e-6
-  # theta1: 0
-  # theta2: 90
-  # ticks_x: 0:1:0.5 #0:20:100
-  # ticks_y: 0:2:0.5 #0:20:100
-  # unit_time: ms
-  # write_h5: 0
-  
-  # # plot_grid: false
-  # # plot_levelset: True
-  # # plot_levelset_segments: False
-  # plot_movies : false
-  # plot_R : false
-  # #debug Levelset
-  # plotcase : "none"
-  # #plotcase : "circle"
-  # plot_current_wall : false
-  # # plot_current_wall : true
-  # plot_interface : false
-  # # plot_interface : true 
-  # # plot_mode: "pcolormesh"
-
-  # # print_mode: "val"
-  # plotbc: true
-  # prefix: "./"
-  # show_nodes: False
-
-  # figsize: None
-  # aspect_box: 'box'
-  # aspect_ratio: 'equal'
-  # fontsize: 4
-  # isocontour: False
-  # levels: 10
-  # # mesh_macro: |
-  # #   global x_1D_2, y_1D_2,key_LS_2
-  # #   x_1D_2 = xp
-  # #   y_1D_2 = yv
-  # plot_bc: True
-
-  # plot_grid: True
-  # plot_levelset: True
-  # plot_levelset_segments: #True 
-  # plot_normal: True
-  # plot_normal_macro: |
-  #   normal_x
-  # quiver_scale: 10
-  # # skip_every: 
-  # plot_mode: pcolormesh #contourf
-  # print_mode: "val"
-  # range: [0,1e-4]
-  # slope_color: 'k'
-  # slope_alpha: 0.5
-
-
-  # zoom: [[0,5],[0,5]]
-  # zoom_mode: index
-  # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-  # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-  # zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-  # zoom_mode: coord
-  color_annot_bc: w
-  color_annot_bulk: w
-  linestyles: ['(0, (3, 6))' ]
-  # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 
-  #                   'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-  # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+"it"+"_"+str(nstep)+"_"+plotpar["theme"]+ ".pdf"', 
-  #                   'file_name+"_"+str(mesh["nx"])+"_"+"it"+"_"+str(nstep)+"_"+plotpar["theme"]+".svg"']
-  macro_file_name: ['file_name+"_"+"it"+"_"+str(nstep)+"_"+plotpar["theme"]+ ".pdf"', 
-                    'file_name+"_"+"it"+"_"+str(nstep)+"_"+plotpar["theme"]+".svg"']
-  ticks_format: '%.2e'
-  files_macro: | #macro to select files for film
-    import re
-    global h5_files_2
-
-    freq = 10
-    freq = 1
-    max_iter = 23
-
-    h5_files_2 = []
-
-    for file in h5_files:
-      iter = int(re.split(r'_|\.h5', file)[1])
-      # print('iter',iter,iter%freq)
-
-      # if iter%freq == 0:
-      #   h5_files_2.append(file)
-
-      if  (iter%freq == 0) and (iter < max_iter):
-        h5_files_2.append(file)
-  # zoom: &zoom1 [[0.0,1.0],[0.0,1.0]]
-  # zoom_mode: &zoom_mode1 coord
-  zoom: &zoom1 [[0.27,0.73],[0.27,0.73]]
-  zoom_mode: &zoom_mode1 coord
-
-  zoom2: &zoom2 [[0.4,0.6],[0.6,0.8]]
-  zoom_mode2: &zoom_mode2 coord
-
-  # zoom2: &zoom2 [[0.0,0.1],[0,0.1]]
-  # zoom_mode2: &zoom_mode2 coord
-
-  # zoom3: &zoom3 [[0.9,1.0],[0,0.1]]
-  # zoom_mode3: &zoom_mode3 coord
-
-  # zoom4: &zoom4 [[0.9,1.0],[0.9,1.0]]
-  # zoom_mode4: &zoom_mode4 coord
-
-  # zoom5: &zoom5 [[0,0.1],[0.9,1.0]]
-  # zoom_mode5: &zoom_mode5 coord
-
-
-    
-  figures:
-
-      - var: i_current_x
-        figsize: True
-        file: current_lines
-        fig_fraction: 1.0
-        fig_ratio: 0.5
-        add_schematics: True
-        add_schematics_coords: [0, 2, 61, 63] #[0, 1, 55, 57]
-        fontsize: 6
-        func: plot_current_lines
-        cbarlabel: "$ \\text{Electrical potential} ~ (\\unit{V})$" #Electrical potential
-        ax_locator_x: [0,20,40,60,80,100]
-        ax_locator_y: [0,20,40,60,80,100]
-        img_format: mp4
-        isocontour: #True
-        levels: 10 #10
-        range: np.linspace(-1.116e-2,0,11)
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        # range: [0,1e-4]
-        ticks_format: '%.2e'
-        # xlim: [0,100]
-        # ylim: [0,100]
-        linewidth: 0.25 #1
-        linestyle: '-' #'dotted'
-        zoom_mode: None
-        #For current lines
-        density: '[0.5,0.5]'
-        streamplot_cbarlabel: "$ \\text{Current magnitude} ~ \\rightarrow$"
-        streamplot_color: 'k' #mag
-        streamplot_mutation_scale: 5 #1 very small, 10 default?
-        # start_points: 'np.array([[100,100,100,100,100,100,100,100,100,100,100,100,100,100], [10,20,30,40,45,47.5,48,51,52.5,55,60,70,80,90]])' #'np.array([[0,20,40,60,80,100], [0,20,40,60,80,100]])'
-     
-        # broken_streamlines: True
-        streamplot_lw: 0.25
-        # plot_schematic_wall: True
-
-      # - var: i_current_x
-      #   # figsize: True
-      #   file: current_lines
-      #   func: plot_current_lines
-      #   cbarlabel: "$ \\text{Electrical potential} ~ (\\unit{V})$" #Electrical potential
-
-      #   # #macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-      #   # fig_fraction: 1.0
-      #   # fig_ratio: 0.5
-      #   add_schematics: #True
-      #   add_schematics_coords: [0, 2, 61, 63] #[0, 1, 55, 57]
-      #   fontsize: 6
-      
-      #   # # ax_locator_x: [0,0.5,1]
-      #   # # ax_locator_y: [0,0.5,1,0.5,2]
-      #   # img_format: mp4
-      #   # isocontour: #True
-      #   # levels: 10 #10
-      #   # # range: np.linspace(-1.116e-2,0,11)
-      #   # plot_bc: True
-      #   # plot_grid: True
-      #   # plot_levelset: #True
-      #   # plot_levelset_segments: False
-      #   # plot_mode: contourf
-      #   # # range: [0,1e-4]
-      #   # ticks_format: '%.2e'
-        
-    
-      #   # linewidth: 0.25 #1
-      #   # linestyle: '-' #'dotted'
-      #   # zoom_mode: None
-      #   # #For current lines
-      #   # density: '[0.5,0.5]'
-      #   # streamplot_cbarlabel: "$ \\text{Current magnitude} ~ \\rightarrow$"
-      #   # streamplot_color: 'k' #mag
-      #   # streamplot_mutation_scale: 5 #1 very small, 10 default?
-      #   # # start_points: 'np.array([[100,100,100,100,100,100,100,100,100,100,100,100,100,100], [10,20,30,40,45,47.5,48,51,52.5,55,60,70,80,90]])' #'np.array([[0,0.5,1], [0,0.5,1]])'
-      
-      #   # # broken_streamlines: True
-      #   # streamplot_lw: 0.25
-      #   # # plot_schematic_wall: True
-
-
-
-      # - var: dcap_1 
-      #   func: plot_python_pdf_full2
-      #   file: dcap_1_zoom
-      #   cbarlabel: "dcap_1"
-      #   img_format: pdf
-      #   isocontour: False
-      #   levels: 10
-      #   range: np.linspace(48982,49000.001,11) #49000.001 for rounding errors, otherwise use extend parameter but we cannot check if c>>490000
-      #   plot_bc: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_capacities: True
-      #   plot_capacities_ijlist: [[1,1],[1,5],[1,10]]
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: dcap_1
-      #   file: dcap_1
-      #   field_index: 1
-      #   cbarlabel: "$\\chi$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   # lcolor: 
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: 
-      #   plot_mode: contourf
-      #   print_mode: 
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: dcap_2
-      #   file: dcap_2
-      #   field_index: 1
-      #   cbarlabel: "$\\chi$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   # lcolor: 
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: 
-      #   plot_mode: contourf
-      #   print_mode: 
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: dcap_3
-      #   file: dcap_3
-      #   field_index: 1
-      #   cbarlabel: "$\\chi$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   # lcolor: 
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: 
-      #   plot_mode: contourf
-      #   print_mode: 
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: dcap_4
-      #   file: dcap_4
-      #   field_index: 1
-      #   cbarlabel: "$\\chi$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   # lcolor: 
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: 
-      #   plot_mode: contourf
-      #   print_mode: 
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: levelset_p
-      #   file: levelset_p
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Levelset p
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_normal: #True
-      #   skip_every: 1
-      #   quiverkey: True 
-      #   quiver_scale: 1
-      #   # quiver_scale_unit: xy #None
-      #   quiver_unit: m/s #given value v_inlet
-      #   quiver_x: 0.7
-      #   quiver_y: 0.05
-      #   # linewidth: 1
-      #   # linestyle: 'dotted'
-      #   plot_mode: contourf #pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      - var: concentration_H2_1DT 
-        func: plot_python_pdf_full2
-        macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        
-        file: concentration_H2_zoom_no_bc
-        cbarlabel: "$ \\text{Concentration} ~ \\ce{H2}$"
-        img_format: pdf
-        isocontour: False
-        levels: 10
-        range: np.linspace(48982,49000.001,11) #49000.001 for rounding errors, otherwise use extend parameter but we cannot check if c>>490000
-        plot_bc: #True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        xlim: [0,100]
-        ylim: [0,100]
-        zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        zoom_mode: coord
-        color_annot_bc: w
-        color_annot_bulk: w
-        linewidth: 1
-        linestyle: None
-
-      - var: concentration_H2_1DT
-        file: concentration_H2
-        func: plot_file
-        macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        cbarlabel: "$\\text{Concentration}~H_2$"
-        fontsize: 4
-        isocontour: False
-        levels: 10
-        # lcolor: 
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: #True
-        plot_levelset_segments_print: 
-        plot_mode: contourf
-        print_mode: 
-        range: [0,1e-4]
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 1
-        linestyle: None
-      
-
-      # - var: levelset_p
-      #   func: plot_python_pdf_full2
-      #   file: levelset_p_zoom
-      #   field_index: 1
-      #   cbarlabel: LS
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: False
-      #   plot_normal: #True
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-
-      # - var: levelset_p
-      #   file: levelset_p
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Levelset p
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_normal: True
-      #   plot_mode: contourf #pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: normal_velocity_intfc
-      #   func: plot_file
-      #   file: normal_velocity_intfc
-      #   field_index: 1
-      #   cbarlabel: normal_velocity_intfc
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: None #coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: normal_velocity_intfc
-      #   func: plot_python_pdf_full2
-      #   file: normal_velocity_intfc_zoom
-      #   field_index: 1
-      #   cbarlabel: normal_velocity_intfc
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-
-      # - var: concentration_H2_1DT
-      #   func: plot_python_pdf_full2
-      #   file: concentration_H2_zoom
-      #   field_index: 1
-      #   cbarlabel: "$\\text{Concentration}~H_2$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-
-      # - var: concentration_H2_1DT
-      #   func: plot_python_pdf_full2
-      #   file: concentration_H2_zoom_int
-      #   field_index: 2
-      #   cbarlabel: "$\\text{Concentration}~H_2$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: #True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-
-      # - var: mass_transfer_rate_border
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom_border
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: mass_transfer_rate_intfc
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom_intfc
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: mass_transfer_rate_bulk
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom_bulk
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: mass_transfer_rate
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-     
-
-
-      # - var: velocity_x
-      #   func: plot_vector
-      #   file: velocity_vectors
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   skip_every: 12
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   quiverkey: True 
-      #   quiver_unit: m/s #given value v_inlet
-      #   quiver_x: 0.7
-      #   quiver_y: 0.97
-      #   linewidth: 1
-      #   linestyle: 'dotted'
-      #   ax_locator_x: [0,20,40,60,80,100]
-      #   ax_locator_y: [0,20,40,60,80,100]
-
-
-      # - var: i_current_x
-      #   file: current_lines
-      #   func: plot_current_lines
-      #   cbarlabel: Electrical potential
-      #   # img_format: mp4
-      #   isocontour: #True
-      #   levels: 0 #10
-      #   range: np.linspace(-1.5e-4,0,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   # range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: 'dotted'
-      #   zoom_mode: None
-      #   #For current lines
-      #   density: '[0.5,0.5]'
-      #   streamplot_color: mag
-      #   streamplot_mutation_scale: 5 #1 very small, 10 default?
-      #   streamplot_lw: 0.25
-
-
-      # - var: i_current_x
-      #   figsize: True
-      #   file: current_lines
-      #   macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-      #   fig_fraction: 1.0
-      #   fig_ratio: 0.5
-      #   # add_schematics: #True
-      #   add_schematics_coords: [0, 2, 61, 63] #[0, 1, 55, 57]
-      #   fontsize: 6
-      #   func: plot_current_lines
-      #   cbarlabel: "$ \\text{Electrical potential} ~ (\\unit{V})$" #Electrical potential
-      #   ax_locator_x: [0,20,40,60,80,100]
-      #   ax_locator_y: [0,20,40,60,80,100]
-      #   img_format: mp4
-      #   isocontour: #True
-      #   levels: 10 #10
-      #   range: np.linspace(-1.116e-2,0,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   # range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 0.25 #1
-      #   linestyle: '-' #'dotted'
-      #   zoom_mode: None
-      #   #For current lines
-      #   density: '[0.5,0.5]'
-      #   streamplot_cbarlabel: "$ \\text{Current magnitude} ~ \\rightarrow$"
-      #   streamplot_color: 'k' #mag
-      #   streamplot_mutation_scale: 5 #1 very small, 10 default?
-      #   # start_points: 'np.array([[100,100,100,100,100,100,100,100,100,100,100,100,100,100], [10,20,30,40,45,47.5,48,51,52.5,55,60,70,80,90]])' #'np.array([[0,20,40,60,80,100], [0,20,40,60,80,100]])'
-     
-      #   # broken_streamlines: True
-      #   streamplot_lw: 0.25
-      #   # plot_schematic_wall: True
-
-      - var: i_current_x
-        figsize: True
-        file: current_lines_schematics
-        macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        fig_fraction: 1.0
-        fig_ratio: 0.5
-        add_schematics: #True
-        add_schematics_coords: [0, 2, 61, 63] #[0, 1, 55, 57]
-        fontsize: 6
-        func: plot_current_lines
-        cbarlabel: "$ \\text{Electrical potential} ~ (\\unit{V})$" #Electrical potential
-        ax_locator_x: [0,20,40,60,80,100]
-        ax_locator_y: [0,20,40,60,80,100]
-        img_format: mp4
-        isocontour: #True
-        levels: 10 #10
-        range: np.linspace(-1.116e-2,0,11)
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        # range: [0,1e-4]
-        ticks_format: '%.2e'
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 0.25 #1
-        linestyle: '-' #'dotted'
-        zoom_mode: None
-        #For current lines
-        density: '[0.5,0.5]'
-        streamplot_cbarlabel: "$ \\text{Current magnitude} ~ \\rightarrow$"
-        streamplot_color: 'k' #mag
-        streamplot_mutation_scale: 5 #1 very small, 10 default?
-        # start_points: 'np.array([[100,100,100,100,100,100,100,100,100,100,100,100,100,100], [10,20,30,40,45,47.5,48,51,52.5,55,60,70,80,90]])' #'np.array([[0,20,40,60,80,100], [0,20,40,60,80,100]])'
-     
-        # broken_streamlines: True
-        streamplot_lw: 0.25
-        # plot_schematic_wall: True
-        
-
-      - var: v_1D
-        file: v_LS
-        cbarlabel: v/v_inlet
-        isocontour: False
-        norm: *v_inlet #reference inside yaml
-        levels: 10
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        range: [0,1e-4]
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 0.5
-        linestyle: 'dotted'
-
-      # - var: mass_transfer_rate
-      #   file: mass_transfer_rate
-      #   cbarlabel: mass_transfer_rate
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: mass_transfer_rate
-      #   file: mass_transfer_rate_no_intfc
-      #   cbarlabel: mass_transfer_rate
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: #True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: trans_scal_1D_H2
-      #   file: trans_scal_1D_H2
-      #   cbarlabel: '$\\text{Concentration} H_2$'
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      
-      # - var: trans_scal_1D_H2_1DT
-      #   file: trans_scal_1D_H2_zoom
-      #   field_index: 1 # 1 for bulk, 2 for 1st interface
-      #   cbarlabel: '$\\text{Concentration} H_2$'
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_mode: colormesh
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom: [[0,5],[0,5]]
-
-
-      # - var: concentration_H2_1DT
-      #   file: concentration_H2
-      #   cbarlabel: "$\\text{Concentration}~H_2$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   # lcolor: 
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False #True
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: 
-      #   plot_mode: contourf
-      #   print_mode: 
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: concentration_KOH_1DT
-      #   file: concentration_KOH
-      #   cbarlabel: '$\\text{Concentration} KOH$'
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: concentration_H2O_1DT
-      #   file: concentration_H2O
-      #   cbarlabel: '$\\text{Concentration} H_2O$'
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-
-      #   #Zoom
-      # - var: mass_transfer_rate
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom_coord
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "ijcoord" #"val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[2,4],[45,47]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: mass_transfer_rate
-      #   func: plot_python_pdf_full2
-      #   file: mass_transfer_rate_zoom
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Mass transfer rate
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "ijval" #"val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: v_1D
-      #   file: v_zoom
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: v
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True #False
-      #   plot_levelset_segments: #True 
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   # zoom: [[0,5],[0,5]]
-      #   # zoom_mode: index
-      #   # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      # - var: concentration_H2_1DT
-      #   file: concentration_H2_zoom
-      #   field_index: 1
-      #   cbarlabel: "$\\text{Concentration}~H_2$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-
-      # - var: concentration_H2_1DT
-      #   file: concentration_H2_zoom_segments
-      #   field_index: 1
-      #   cbarlabel: "$\\text{Concentration}~H_2$"
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: #True
-      #   plot_levelset_segments_print: ijy #ijx
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: ijy #ijx #ijcoord #ijval #ij #"val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-
-      # - var: concentration_H2_1DT
-      #   file: concentration_H2_zoom_segments
-      #   field_index: 1
-      #   cbarlabel: '$\\text{Concentration} H_2$'
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: False
-      #   plot_levelset_segments: True
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: ijval #ij #"val"
-      #   range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-
-
-
-  films:
-
-      # - var: normal_velocity_intfc
-      #   file: normal_velocity_intfc_zoom
-      #   func: plot_python_pdf_full2
-      #   cbarlabel: normal_velocity_intfc
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom: [[0,5],[0,5]]
-      #   zoom_mode: index
-
-      # - var: normal_velocity_intfc
-      #   func: plot_file
-      #   file: normal_velocity_intfc
-      #   field_index: 1
-      #   cbarlabel: normal_velocity_intfc
-      #   img_format: mp4
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 0 #10        
-      #   range: np.linspace(-1e-2,1e-2,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: pcolormesh #contourf
-      #   print_mode: "val"
-      #   # range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   #zoom: [[0,5],[0,5]]
-      #   #zoom_mode: index
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: None #coord
-      #   color_annot_bc: k #w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-        
-
-      # - var: i_current_x
-      #   file: current_lines
-      #   func: plot_current_lines
-      #   cbarlabel: Electrical potential
-      #   ax_locator_x: [0,20,40,60,80,100]
-      #   ax_locator_y: [0,20,40,60,80,100]
-      #   img_format: mp4
-      #   isocontour: #True
-      #   levels: 10 #10
-      #   range: np.linspace(-1.5e-4,0,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   # range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: 'dotted'
-      #   zoom_mode: None
-      #   #For current lines
-      #   density: '[0.5,0.5]'
-      #   streamplot_cbarlabel: "$ \\text{Current magnitude} ~ \\rightarrow$"
-      #   streamplot_color: mag
-      #   streamplot_mutation_scale: 5 #1 very small, 10 default?
-      #   streamplot_lw: 0.25
-
-      # - var: i_current_mag 
-      #   file: i_current_mag
-      #   cbarlabel: "Current magnitude"
-      #   ax_locator_x: [0,20,40,60,80,100]
-      #   ax_locator_y: [0,20,40,60,80,100]
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 10
-      #   range: #np.linspace(48000,49000,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom_mode: None
-
-      # - var: normal_velocity_intfc
-      #   file: normal_velocity_intfc_zoom
-      #   func: plot_python_pdf_full2
-      #   cbarlabel: normal_velocity_intfc
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom: [[0,5],[0,5]]
-      #   zoom_mode: index
-
-        # - var: levelset_p
-        # func: plot_python_pdf_full2
-        # file: levelset_p_zoom
-        # field_index: 1
-        # cbarlabel: LS
-        # fontsize: 4
-        # isocontour: False
-        # levels: 10
-        # plot_bc: True
-        # plot_grid: True
-        # plot_levelset: False
-        # plot_levelset_segments: False
-        # plot_mode: pcolormesh #contourf
-        # print_mode: "val"
-        # range: [0,1e-4]
-        # xlim: [0,100]
-        # ylim: [0,100]
-        # #zoom: [[0,5],[0,5]]
-        # #zoom_mode: index
-        # zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        # zoom_mode: coord
-        # color_annot_bc: k #w
-        # color_annot_bulk: w
-
-      - var: concentration_H2_1DT 
-        func: plot_python_pdf_full2
-        file: concentration_H2_zoom
-        macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        cbarlabel: "$ \\text{Concentration} ~ \\ce{H2}$"
-        img_format: mp4
-        isocontour: False
-        levels: 10
-        range: np.linspace(48982,49000.001,11) #49000.001 for rounding errors, otherwise use extend parameter but we cannot check if c>>490000
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        xlim: [0,100]
-        ylim: [0,100]
-        zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        zoom_mode: coord
-        color_annot_bc: w
-        color_annot_bulk: w
-        linewidth: 1
-        linestyle: None
-
-      # - var: levelset_p
-      #   func: plot_python_pdf_full2
-      #   file: levelset_p_zoom_2
-      #   figsize: None
-      #   aspect_box: 'box'
-      #   aspect_ratio: 'equal'
-      #   cbarlabel: Levelset p
-      #   color_LS: "#0072B2" #'cyan'
-      #   img_format: mp4
-      #   fontsize: 4
-      #   isocontour: False
-      #   levels: 0 #10
-      #   range: 'np.linspace(-1,1,3)'
-      #   plot_bc: True
-      #   plot_wall: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: #True 
-      #   plot_mode: contourf #contourf_LS #pcolormesh #contourf
-      #   print_mode: "val"
-      #   # range: [0,1e-4]
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-      - var: levelset_p
-        func: plot_python_pdf_full2
-        file: levelset_p_zoom
-        figsize: None
-        aspect_box: 'box'
-        aspect_ratio: 'equal'
-        cbarlabel: Levelset p
-        color_LS: "#0072B2" #'cyan'
-        img_format: mp4
-        fontsize: 4
-        isocontour: False
-        levels: 0 #10
-        range: 'np.linspace(-1,1,3)'
-        plot_bc: True
-        plot_wall: #True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: #True 
-        plot_mode: contourf_LS #pcolormesh #contourf
-        print_mode: "val"
-        # range: [0,1e-4]
-        xlim: [0,100]
-        ylim: [0,100]
-        zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        zoom_mode: coord
-        color_annot_bc: w
-        color_annot_bulk: w
-        linewidth: 1
-        linestyle: None
-
-      - var: levelset_p
-        file: levelset_p
-        figsize: None
-        aspect_box: 'box'
-        aspect_ratio: 'equal'
-        ax_locator_x: [0,20,40,60,80,100]
-        ax_locator_y: [0,20,40,60,80,100]
-        cbarlabel: Levelset p
-        color_LS: "#0072B2" #'cyan'
-        img_format: mp4
-        fontsize: 4
-        isocontour: False
-        levels: 0 #10
-        range: 'np.linspace(-1,1,3)'
-        plot_bc: True
-        plot_wall: #True
-        plot_grid: True
-        plot_levelset: #True
-        plot_levelset_segments: #True 
-        plot_mode: contourf_LS #pcolormesh #contourf
-        print_mode: "val"
-        # range: [0,1e-4]
-        xlim: [0,100]
-        ylim: [0,100]
-        # zoom: [[0,5],[0,5]]
-        # zoom_mode: index
-        # zoom: [[1,11],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        # zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        # zoom: [[0,4],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-        # zoom_mode: coord
-        color_annot_bc: w
-        color_annot_bulk: w
-        linewidth: 1
-        linestyle: None
-
-      - var: p_1D
-        file: pressure
-        func: plot_file
-        cbarlabel: p
-        img_format: mp4
-        isocontour: False
-        levels: 10
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        range: [0,1e-4]
-        ticks_format: '%.2e'
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 1
-        linestyle: None
-        # zoom: [[0,5],[0,5]]
-        zoom_mode: None
-
-
-      # - var: p_1D
-      #   file: pressure_zoom
-      #   func: plot_python_pdf_full2
-      #   cbarlabel: p
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 10
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom: [[0,5],[0,5]]
-      #   zoom_mode: index
-
-      - var: velocity_x
-        file: velocity_vectors
-        func: plot_vector
-        img_format: mp4
-        plot_levelset: True
-        plot_levelset_segments: False
-        skip_every: 12
-        xlim: [0,100]
-        ylim: [0,100]
-        quiverkey: True 
-        quiver_unit: m/s #given value v_inlet
-        quiver_x: 0.7
-        quiver_y: 0.05
-        linewidth: 1
-        linestyle: 'dotted'
-
-      # - var: concentration_H2O_1DT
-      #   file: current_wall
-      #   func: plot_current_wall
-      #   axis_offset: 1.25
-      #   img_format: mp4
-      #   levels: 10
-      #   labels: ['$c\left(H_2O\right)$', '$-\eta ~\text{(-overpotential)}$','Current']
-      #   linestyles: ['(0, (3, 6))',
-      #                '(3, (3, 6))', #"dashdot"
-      #                '(6, (3, 6))'] #"dotted"
-      #   ticks: ['np.linspace(48982,49000,10)','np.linspace(0.5,0.7,11)','np.linspace(0,1,11)']
-      #   # ticks: ['np.linspace(40000,49000,10)','np.linspace(0.5,0.7,11)','np.linspace(0,1,11)']
-      #   # range: np.linspace(-0,15,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom_mode: None
-
-      # - var: concentration_H2_1DT 
-      #   file: concentration_H2
-      #   cbarlabel: "$ \\text{Concentration} ~ \\ce{H2}$"
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 0 #10
-      #   range: np.linspace(-0,15,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom_mode: None
-
-      # - var: concentration_H2O_1DT 
-      #   file: concentration_H2O
-      #   cbarlabel: "$ \\text{Concentration} ~ H_2O$"
-      #   img_format: mp4
-      #   isocontour: False
-      #   levels: 0
-      #   range: np.linspace(48982,49000.001,11) #49000.001 for rounding errors, otherwise use extend parameter but we cannot check if c>>490000
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: None
-      #   zoom_mode: None
-
-
-
-      - var: velocity_x
-        file: velocity_vectors
-        func: plot_vector
-        img_format: mp4
-        plot_levelset: True
-        plot_levelset_segments: False
-        skip_every: 12
-        xlim: [0,100]
-        ylim: [0,100]
-        quiverkey: True 
-        quiver_unit: m/s #given value v_inlet
-        quiver_x: 0.7
-        quiver_y: 0.97
-        linewidth: 1
-        linestyle: 'dotted'
-
-      # - var: i_current_x
-      #   file: current_lines
-      #   func: plot_current_lines
-      #   cbarlabel: Electrical potential
-      #   img_format: mp4
-      #   isocontour: #True
-      #   levels: 10 #10
-      #   range: np.linspace(-1.5e-4,0,11)
-      #   plot_bc: True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   # range: [0,1e-4]
-      #   ticks_format: '%.2e'
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   linewidth: 1
-      #   linestyle: 'dotted'
-      #   zoom_mode: None
-      #   #For current lines
-      #   density: '[0.5,0.5]'
-      #   streamplot_color: mag
-      #   streamplot_mutation_scale: 5 #1 very small, 10 default?
-      #   streamplot_lw: 0.25
-
-      - var: v_1D
-        file: v_LS
-        cbarlabel: v
-        img_format: mp4
-        isocontour: False
-        levels: 10
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        range: [0,1e-4]
-        ticks_format: '%.2e'
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 1
-        linestyle: None
-        zoom_mode: None
-
-      - var: u_1D
-        file: u_LS
-        cbarlabel: u
-        img_format: mp4
-        isocontour: False
-        levels: 10
-        plot_bc: True
-        plot_grid: True
-        plot_levelset: True
-        plot_levelset_segments: False
-        plot_mode: contourf
-        range: [0,1e-4]
-        ticks_format: '%.2e'
-        xlim: [0,100]
-        ylim: [0,100]
-        linewidth: 1
-        linestyle: None
-        zoom_mode: None
-
-
-     
-
-  curves:
-
-
-     
-        # macro_plot_BC: |
-        #   inset_ax.text(             
-        #   0,# xmin/2
-        #   0.5, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = \frac{-i}{2FD}$', 
-        #   fontsize=fontsize,color='w',ha='left',va='center')
-
-        #   inset_ax.text(0.65, 0.0, r'$c_{\ce{H2},0} $', fontsize=fontsize,va='bottom',ha='center',color='w')
-        #   inset_ax.text(1.0, 0.5, r'$c_{\ce{H2},0}$', fontsize=fontsize,va='center',ha='right',color='w')
-          
-        #   inset_ax.text(0.65, 1.0, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = 0$', fontsize=fontsize,va='top',ha='center',color='w')
-        # macro_show_slice: |
-        #   linewidth_points = 1
-        #   line, = inset_ax.plot([0, 0], [0, 1], ls='-',color='r',lw=linewidth_points)
-
-        #   # shift the object over 2 points, and down 2 points
-        #   dx, dy = +(linewidth_points/2)/72.,0
-        #   offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-        #   shadow_transform = inset_ax.transData + offset
-
-        #   inset_ax.text(0.0,0.2, 'Slice',
-        #   va='center', 
-        #   ha='left',
-        #   transform = shadow_transform,
-        #   color='r',
-        #   fontsize=fontsize,
-        #   )
-
-      - var: [[x_1D,concentration_H2_1DT]]
-        file: concentration_H2_through_bubble
-        func: plot_1D
-        fontsize: 10
-        labels: [["$x ( \\unit{\\um})$", "$ \\text{Concentration} ~ \\ce{H2}$" ]]
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        macro_file_name: ['file_name+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+plotpar["theme"]+".svg"']
-
-        macro_slice: "veci(reshape_data(data),nx,ny,field_index)[ny//2,:]"
-
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: center
-        macro_plot_BC: |
-          text_height = 0.3
-          inset_ax.text(             
-          0,# xmin/2
-          text_height, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = \frac{-i}{2FD}$', 
-          fontsize=fontsize,color='w',ha='left',va='center')
-
-          inset_ax.text(0.65, 0.0, r'$c_{\ce{H2},0} $', fontsize=fontsize,va='bottom',ha='center',color='w')
-          inset_ax.text(1.0, text_height, r'$c_{\ce{H2},0}$', fontsize=fontsize,va='center',ha='right',color='w')
-          
-          inset_ax.text(0.65, 1.0, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = 0$', fontsize=fontsize,va='top',ha='center',color='w')
-        macro_show_slice: |
-          linewidth_points = 1
-          line, = inset_ax.plot([0, 1], [0.5, 0.5], ls='-',color='r',lw=linewidth_points)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = 0, +linewidth_points/72.
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-
-          inset_ax.text(0.5,0.5, 'Slice',
-          va='bottom', 
-          ha='center',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-
-      - var: [[x_1D,phi_ele_1D]]
-        file: phi_through_bubble #_poisson_iter
-        func: plot_1D
-        fontsize: 10
-        labels: [["$x ( \\unit{\\um})$", "$ \\text{Electrical potential} ~ (\\unit{V})$"]]
-        legend_pos: upper center
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        macro_slice: "veci(reshape_data(data),nx,ny,field_index)[ny//2,:]"
-
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: lower right
-        macro_show_slice: |
-          linewidth_points = 1
-          line, = inset_ax.plot([0, 1], [0.5, 0.5], ls='-',color='r',lw=linewidth_points)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = 0, -linewidth_points/72.
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-
-          inset_ax.text(0.5,0.5, 'Slice',
-          va='top', 
-          ha='center',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-        macro: |
-          
-          # label1 = str(file['poisson_iter'][()])
-
-          global label2 
-          label2 = label1
-
-          # X = varx*scale_x
-          # Y = slice_1D
-          # # Add a column of ones to X to account for the intercept
-          # X = np.vstack([X, np.ones(len(X))]).T
-
-          # # Perform least squares fit
-          # coefficients, residuals, rank, s = np.linalg.lstsq(X, Y, rcond=None)
-
-          # # coefficients[0] is the slope, coefficients[1] is the intercept
-          # slope, intercept = coefficients
-
-          # # slope = slope/scale_x #rescale if X not resaled
-
-          # print(f"Slope: {slope}, Intercept: {intercept}")
-
-          # import numpy as np
-          # from scipy.stats import pearsonr
-
-          # # Calculate the correlation coefficient and p-value
-          # correlation_coefficient, p_value = pearsonr(varx*scale_x, slice_1D)
-
-          # print(f"Correlation Coefficient: {correlation_coefficient}")
-          # # print(f"P-value: {p_value}")
-
-          # global label2 
-          # # label2 = label1 + " slope " + str(slope) + " R2 " + str(correlation_coefficient)
-
-          # label2 = label1 + r"$\mathrm{{{text}}}: {slope:.3e}, R^2: {R2:.2f}".format(text=', slope',slope=slope,R2=correlation_coefficient) + '$'
-
-
-          # # print(label1)
-          # # print(label2)
-
-      # - var: [[x_1D,phi_ele_1D]]
-      #   file: poisson_iter
-      #   func: plot_1D
-      #   labels: [["$x ( \\unit{\\um})$", "$ \\text{Electrical potential} ~ (\\unit{V})$"]]
-      #   linestyles: ['(0, (3, 6))' ] #,
-      #               #  '(3, (3, 6))', #"dashdot"
-      #               #  '(6, (3, 6))'] #"dotted" #['-']
-      #   ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-      #   linewidth: 0.5
-      #   # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-      #   macro_file_name: ['file_name+"_mesh"+str(nx)+ ".pdf"', 'file_name+"_mesh"+str(nx)+".svg"']
-
-      #   macro_slice: "veci(reshape_data(data),nx,ny,field_index)[0,:]"
-
-      #   # macro_show_slice: |
-      #   #   linewidth_points = 1
-      #   #   line, = inset_ax.plot([0, 1], [0.5, 0.5], ls='-',color='r',lw=linewidth_points)
-
-      #   #   # shift the object over 2 points, and down 2 points
-      #   #   dx, dy = 0, -linewidth_points/72.
-      #   #   offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-      #   #   shadow_transform = inset_ax.transData + offset
-
-
-      #   #   inset_ax.text(0.5,0.5, 'Slice',
-      #   #   va='top', 
-      #   #   ha='center',
-      #   #   transform = shadow_transform,
-      #   #   color='r',
-      #   #   fontsize=fontsize,
-      #   #   )
-
-      #   macro: |
-      #     X = varx*scale_x
-      #     Y = slice_1D
-      #     # Add a column of ones to X to account for the intercept
-      #     X = np.vstack([X, np.ones(len(X))]).T
-
-      #     # Perform least squares fit
-      #     coefficients, residuals, rank, s = np.linalg.lstsq(X, Y, rcond=None)
-
-      #     # coefficients[0] is the slope, coefficients[1] is the intercept
-      #     slope, intercept = coefficients
-
-      #     # slope = slope/scale_x #rescale if X not resaled
-
-      #     print(f"Slope: {slope}, Intercept: {intercept}")
-
-      #     import numpy as np
-      #     from scipy.stats import pearsonr
-
-      #     # Calculate the correlation coefficient and p-value
-      #     correlation_coefficient, p_value = pearsonr(varx*scale_x, slice_1D)
-
-      #     print(f"Correlation Coefficient: {correlation_coefficient}")
-      #     # print(f"P-value: {p_value}")
-      #     label1 = str(file['poisson_iter'][()])
-      #     global label2 
-      #     # label2 = label1 + " slope " + str(slope) + " R2 " + str(correlation_coefficient)
-
-      #     # label2 = label1 + r"$\mathrm{{{text}}}: {slope:.3e}, R^2: {R2:.2f}".format(text=', slope',slope=slope,R2=correlation_coefficient) + '$'
-          
-      #     residual = file['residual_electrical_potential'][()]
-      #     label2 = label1 + r"$\mathrm{{{text}}}: {slope:.3e}, \mathrm{{{textres}}}: {residual:.3e}".format(text=', slope',slope=slope,R2=correlation_coefficient,textres='res',residual=residual) + '$'
-
-      #     # label2 = label2 + str(file['residual_electrical_potential'][()])
-
-      #     # print(label1)
-      #     # print(label2)
-
-      #     # variation = file['variation_electrical_potential'][()]
-
-          
-
-      - var: [[x_1D,phi_ele_1D]]
-        file: phi
-        func: plot_1D
-        labels: [["$x ( \\unit{\\um})$", "$ \\text{Electrical potential} ~ (\\unit{V})$"]]
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        macro_slice: "veci(reshape_data(data),nx,ny,field_index)[0,:]"
-
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: upper left
-        macro_show_slice: |
-          linewidth_points = 1
-
-          slice_pos = 0.0
-          line, = inset_ax.plot([0, 1], [slice_pos, slice_pos], ls='-',color='r',lw=linewidth_points,zorder=10)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = 0, +linewidth_points/72.
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-
-          inset_ax.text(0.2,slice_pos, 'Slice',
-          va='bottom', 
-          ha='center',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-
-        macro: |
-          X = varx*scale_x
-          Y = slice_1D
-          # Add a column of ones to X to account for the intercept
-          X = np.vstack([X, np.ones(len(X))]).T
-
-          # Perform least squares fit
-          coefficients, residuals, rank, s = np.linalg.lstsq(X, Y, rcond=None)
-
-          # coefficients[0] is the slope, coefficients[1] is the intercept
-          slope, intercept = coefficients
-
-          # slope = slope/scale_x #rescale if X not resaled
-
-          print(f"Slope: {slope}, Intercept: {intercept}")
-
-          import numpy as np
-          from scipy.stats import pearsonr
-
-          # Calculate the correlation coefficient and p-value
-          correlation_coefficient, p_value = pearsonr(varx*scale_x, slice_1D)
-
-          print(f"Correlation Coefficient: {correlation_coefficient}")
-          # print(f"P-value: {p_value}")
-
-          global label2 
-          # label2 = label1 + " slope " + str(slope) + " R2 " + str(correlation_coefficient)
-
-          label2 = label1 + r"$\mathrm{{{text}}}: {slope:.3e}, R^2: {R2:.2f}".format(text=', slope',slope=slope,R2=correlation_coefficient) + '$'
-
-
-          # print(label1)
-          # print(label2)
-
-
-
-      # - var: [[y_1D,phi_ele_1D]] 
-      #   file: phi_wall
-      #   func: plot_1D
-      #   labels: [["$y ( \\unit{\\um})$", "$ \\text{Electrical potential} ~ (\\unit{V})$"]]
-      #   linestyles: ['(0, (3, 6))' ] #,
-      #               #  '(3, (3, 6))', #"dashdot"
-      #               #  '(6, (3, 6))'] #"dotted" #['-']
-      #   ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-      #   linewidth: 0.5
-      #   # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-      #   macro_slice: "vecb_L(reshape_data(data),nx,ny)" #"reshape_data_veci(data,nx,ny,field_index)[:,0]"
-
-
-      - var: [[y_1D,phi_ele_1D]]
-        file: phi_wall #_poisson_iter
-        func: plot_1D
-        fontsize: 10
-        labels: [["$y ( \\unit{\\um})$", "$ \\text{Electrical potential} ~ (\\unit{V})$"]]
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        macro_file_name: ['file_name+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+plotpar["theme"]+".svg"']
-        macro_slice: "vecb_L(reshape_data(data),nx,ny)" #"reshape_data_veci(data,nx,ny,field_index)[:,0]"
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: center left
-        macro_show_slice: |
-          linewidth_points = 1
-          line, = inset_ax.plot([0, 0], [0, 1], ls='-',color='r',lw=linewidth_points)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = +(linewidth_points/2)/72.,0
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-          inset_ax.text(0.0,0.2, 'Slice',
-          va='center', 
-          ha='left',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-
-      - var: [[y_1D,concentration_KOH_1DT]]
-        file: concentration_KOH_wall #_poisson_iter
-        func: plot_1D
-        fontsize: 10
-        labels: [["$y ( \\unit{\\um})$", "$ \\text{Concentration} ~ KOH$" ]]
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        macro_file_name: ['file_name+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+plotpar["theme"]+".svg"']
-        macro_slice: "vecb_L(reshape_data(data),nx,ny)" #"reshape_data_veci(data,nx,ny,field_index)[:,0]"
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: center
-        macro_plot_BC: |
-          inset_ax.text(             
-          0,# xmin/2
-          0.5, r'$\frac{\partial c_{\ce{KOH}} }{\partial n} = \frac{-i}{2FD}$', 
-          fontsize=fontsize,color='w',ha='left',va='center')
-
-          inset_ax.text(0.65, 0.0, r'$c_{\ce{KOH},0} $', fontsize=fontsize,va='bottom',ha='center',color='w')
-          inset_ax.text(1.0, 0.5, r'$c_{\ce{KOH},0}$', fontsize=fontsize,va='center',ha='right',color='w')
-          
-          inset_ax.text(0.65, 1.0, r'$\frac{\partial c_{\ce{KOH}} }{\partial n} = 0$', fontsize=fontsize,va='top',ha='center',color='w')
-        macro_show_slice: |
-          linewidth_points = 1
-          line, = inset_ax.plot([0, 0], [0, 1], ls='-',color='r',lw=linewidth_points)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = +(linewidth_points/2)/72.,0
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-          inset_ax.text(0.0,0.2, 'Slice',
-          va='center', 
-          ha='left',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-          
-
-      - var: [[y_1D,concentration_H2_1DT]]
-        file: concentration_H2_wall #_poisson_iter
-        func: plot_1D
-        fontsize: 10
-        labels: [["$y ( \\unit{\\um})$", "$ \\text{Concentration} ~ \\ce{H2}$" ]]
-        linestyles: ['(0, (3, 6))' ] #,
-                    #  '(3, (3, 6))', #"dashdot"
-                    #  '(6, (3, 6))'] #"dotted" #['-']
-        ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-        linewidth: 0.5
-        # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-        # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-        macro_file_name: ['file_name+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+plotpar["theme"]+".svg"']
-        macro_slice: "vecb_L(reshape_data(data),nx,ny)" #"reshape_data_veci(data,nx,ny,field_index)[:,0]"
-        add_schematics: True
-        add_schematics_coords: [0,1,0,0.001]
-        schematics_width: 40%
-        schematics_height: 40%
-        schematics_loc: center
-        macro_plot_BC: |
-          inset_ax.text(             
-          0,# xmin/2
-          0.5, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = \frac{-i}{2FD}$', 
-          fontsize=fontsize,color='w',ha='left',va='center')
-
-          inset_ax.text(0.65, 0.0, r'$c_{\ce{H2},0} $', fontsize=fontsize,va='bottom',ha='center',color='w')
-          inset_ax.text(1.0, 0.5, r'$c_{\ce{H2},0}$', fontsize=fontsize,va='center',ha='right',color='w')
-          
-          inset_ax.text(0.65, 1.0, r'$\frac{\partial c_{\ce{H2}} }{\partial n} = 0$', fontsize=fontsize,va='top',ha='center',color='w')
-        macro_show_slice: |
-          linewidth_points = 1
-          line, = inset_ax.plot([0, 0], [0, 1], ls='-',color='r',lw=linewidth_points)
-
-          # shift the object over 2 points, and down 2 points
-          dx, dy = +(linewidth_points/2)/72.,0
-          offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-          shadow_transform = inset_ax.transData + offset
-
-          inset_ax.text(0.0,0.2, 'Slice',
-          va='center', 
-          ha='left',
-          transform = shadow_transform,
-          color='r',
-          fontsize=fontsize,
-          )
-
-          
-      # - var: [[y_1D,concentration_KOH_1DT]] 
-      #   file: concentration_KOH_wall
-      #   func: plot_1D
-      #   labels: [["$y ( \\unit{\\um})$", "$ \\text{Concentration} ~ KOH$" ]]
-      #   linestyles: ['(0, (3, 6))' ] #,
-      #               #  '(3, (3, 6))', #"dashdot"
-      #               #  '(6, (3, 6))'] #"dotted" #['-']
-      #   ticks: ['[0,20,40,60,80,100]', '[0,20,40,60,80,100]']
-      #   linewidth: 0.5
-      #   # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-      #   # macro_file_name: ['file_name+"_"+str(mesh["nx"])+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+str(mesh["nx"])+ "_"+plotpar["theme"]+".svg"']
-      #   macro_file_name: ['file_name+"_"+plotpar["theme"]+ ".pdf"', 'file_name+"_"+plotpar["theme"]+".svg"']
-
-      #   macro_slice: "vecb_L(reshape_data(data),nx,ny)" #"reshape_data_veci(data,nx,ny,field_index)[:,0]"
-
-
-      # - var: concentration_H2_1DT 
-      #   func: plot_python_pdf_full2
-      #   file: concentration_H2_zoom_no_bc
-      #   cbarlabel: "$ \\text{Concentration} ~ \\ce{H2}$"
-      #   img_format: pdf
-      #   isocontour: False
-      #   levels: 10
-      #   range: np.linspace(48982,49000.001,11) #49000.001 for rounding errors, otherwise use extend parameter but we cannot check if c>>490000
-      #   plot_bc: #True
-      #   plot_grid: True
-      #   plot_levelset: True
-      #   plot_levelset_segments: False
-      #   plot_mode: contourf
-      #   xlim: [0,100]
-      #   ylim: [0,100]
-      #   zoom: [[0,10],[45,55]] #[[1,10],[45,55]] activates BC plot so no longer square
-      #   zoom_mode: coord
-      #   color_annot_bc: w
-      #   color_annot_bulk: w
-      #   linewidth: 1
-      #   linestyle: None
-
-
-
-        # macro: |
-        #   global label2 
-        #   label1 = str(file['poisson_iter'][()])
-        #   label2 = label1 +" "+ r"$\phi_\mathrm{{{text}}}: {val:.3e}".format(text='wall',val=np.mean(slice_1D)) + '$'
-        #   print(colored(label2,'red'))
-
-      # - var: [[poisson_iter,phi_ele_1D]]
-      #   file: phi_wall_poisson_iter_log
-      #   func: plot_1D
-      #   fontsize: 10
-      #   labels: [["Number of iterations", "$|\\phi-\\phi^e|/|\\phi^e|$"]]
-      #   linestyles: ['(0, (3, 6))' ] #,
-      #               #  '(3, (3, 6))', #"dashdot"
-      #               #  '(6, (3, 6))'] #"dotted" #['-']
-      #   ticks: ['[1,2,3,4,5]', '[0,20,40,60,80,100]']
-      #   linewidth: 0.5
-      #   # plot_ref: '4* yml["flower"]["physics"]["v_inlet"]*x_1D*scale_x/(mesh["xmax"]-mesh["xmin"])*(1-x_1D*scale_x/(mesh["xmax"]-mesh["xmin"]))' #use "" not '' in ''
-        
-      #   macro_slice: "abs((np.mean(vecb_L(reshape_data(data),nx,ny))-(-0.011655612832847977)))/0.011655612832847977"
-
-      #   logplot: True
-      #   logplot_x: False
-      #   logplot_y: True
-      #   slope_start: 2
-      #   slope_stop: 10
-      #   legend: False
-      #   # add_schematics: True
-      #   add_schematics_coords: [0,1,0,0.001]
-      #   schematics_width: 40%
-      #   schematics_height: 40%
-      #   schematics_loc: upper left
-      #   macro_show_slice: |
-      #     linewidth_points = 1
-      #     line, = inset_ax.plot([0, 0], [0, 1], ls='-',color='r',lw=linewidth_points)
-
-      #     # shift the object over 2 points, and down 2 points
-      #     dx, dy = +(linewidth_points/2)/72.,0
-      #     offset = transforms.ScaledTranslation(dx, dy, fig.dpi_scale_trans)
-      #     shadow_transform = inset_ax.transData + offset
-
-      #     inset_ax.text(0.0,0.2, 'Slice',
-      #     va='center', 
-      #     ha='left',
-      #     transform = shadow_transform,
-      #     color='r',
-      #     fontsize=fontsize,
-      #     )
-
-      #   macro: |
-      #     label1 = str(file['poisson_iter'][()])
-
-      #     global label2 
-      #     label1 = str(file['poisson_iter'][()])
-      #     label2 = label1 +" "+ r"$\phi_\mathrm{{{text}}}: {val:.3e}".format(text='wall',val=np.mean(slice_1D)) + '$'
-      #     print(colored(label2,'red'))
-
-      #     label2=None
-
-      - var: [l1_rel_error,l2_rel_error,linfty_rel_error] 
-        func: plot_errors_from_h5
-        file: errors
-        slope_start: 32 #16
-        slope_stop: 256
-        xlim: [1e-3,1e-1]
-
-      - var: [l1_rel_error_full_cells,l2_rel_error_full_cells,linfty_rel_error_full_cells] 
-        func: plot_errors_from_h5
-        file: errors_full_cells
-        slope_start: 32 #16
-        slope_stop: 256
-        xlim: [1e-3,1e-1]
-
-      - var: [l1_rel_error_partial_cells,l2_rel_error_partial_cells,linfty_rel_error_partial_cells] 
-        func: plot_errors_from_h5
-        file: errors_partial_cells
-        slope_start: 32 #16
-        slope_stop: 256
-        xlim: [1e-3,1e-1]
-
-      - var: radius 
-        file: radius
-        slope_start: 1.2e-4 #2e-4
-        slope_stop: 1e-3
-        # cbarlabel: H2 #'$Concentration H_2$'
-        # img_format: mp4
-        # isocontour: False
-        # levels: 10
-        # plot_bc: True
-        # plot_grid: True
-        # plot_levelset: True
-        # plot_levelset_segments: False
-        # plot_mode: contourf
-        # range: [0,1e-4]
-        # xlim: [0,100]
-        # ylim: [0,100]
-        # linewidth: 1
-        # linestyle: None
-        # zoom_mode: None
-    
-      # - var: i_current_x
-      #   file: current_wall
-      #   func: plot_current_wall
-    
-  
-  schematics:
-
-    # - file: boundary_conditions_diffusion
-    
-    # - file: boundary_conditions_diffusion
-    #   func: plot_schematics_full
-    #   fig_ratio: 0.5
-
-    - file: schematics_full_with_losses
-      func: plot_schematics_full_with_losses
-      fig_ratio: 0.5
-
-    - file: schematics_full
-      func: plot_schematics_full
-      font_size: 8
-
-    - file: schematics
-      func: plot_schematics
-      # fig_ratio: 0.5
-
-    - file: schematics_fluxes
-      func: plot_schematics_fluxes
-      # fig_ratio: 0.5
-
-    
-        
-  
-
-
-  #TODO call compute_grad_phi_ele! only when needed
-  #TODO call us, vs interpolation only when needed
-  #TODO sparse data (H5 fill value or chunked ?)
-  #TODO LS could be sparse too
-  #TODO struct grid_u.LS[iLS].u[:,:] more difficult than [:,:,:]
-  #TODO fig size
-
-   
-pdi:
-  metadata: # type of small values for which PDI keeps a copy
-    nx: int64 #Domain size per proc
-    ny: int64 #Domain size per proc
-    mpi_max_coords_x: int64 #MPI decomposition
-    mpi_max_coords_y: int64 #MPI decomposition
-    mpi_coords_x: int64 #MPI coordinate of the current process 
-    mpi_coords_y: int64 #MPI coordinate of the current process 
-    time: double #Time
-    nstep: int64 #Index for naming files
-    nb_transported_scalars: int64 
-    nb_levelsets: int64 
-    radius: double
-    intfc_vtx_num: int64 # number of vertices to describe the interface
-    intfc_seg_num: int64 #number of segments
-    vtx_num: int64 # number of vertices for debugging phase-change
-    nb_Navier_slip_BC: int64 #number of Navier BC
-    timestep: double
-    rise_velocity_y: double
-    mean_phase_change_velocity: double
-    cell_length: double
-
-
-  data: # values for which PDI does not keep a copy
-    #in Flower: zeros((n.nLS + 1) * g.ny * g.nx + 2 * g.nx + 2 * g.ny)
-    #Field of the current subdomain
-    #Bulk, interface and border u velocity, ...
-    # u grid nx+1, ny
-    # v grid nx, ny
-    # p grid (scalar): nx, ny
-    # In Flower : vec "1D" bulk: 1:nx*ny, ith levelset: ...i*ny*nx 
-
-    # stored in 1D
-    u_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx+1) + 2 * ($nx+1) + 2 * $ny', type: array, subtype: double } 
-    v_1D: { size: '($nb_levelsets + 1) * ($ny+1) * ($nx) + 2 * ($nx) + 2 * ($ny+1)', type: array, subtype: double } 
-    p_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * ($ny)', type: array, subtype: double } 
-    # trans_scal_1D: { size: ['($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny','$nb_transported_scalars'], type: array, subtype: double } 
-    trans_scal_1DT: { size: ['$nb_transported_scalars','($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny'], type: array, subtype: double } 
-    phi_ele_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    rhs_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    
-    # rhs_uv_1D:
-    #   size: '($nb_levelsets - $nb_Navier_slip_BC + 1) * ($ny) * ($nx+1) + 2 * ($nx+1) + 2 * $ny + ($nb_levelsets -$nb_Navier_slip_BC + 1) * ($ny+1) * ($nx) + 2 * ($nx) + 2 * ($ny+1) +($nb_Navier_slip_BC + $nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * ($ny)'
-    #   type: array
-    #   subtype: double
-    
-    rhs_uv_1D: { size: '$rhs_uv_len', type: array, subtype: double } 
-
-    vec_1D: { size: '$vec_1D_len', type: array, subtype: double } 
-
-
-    Auv_colptr_1D: { size: '$Auv_colptr_len', type: array, subtype: int64 } 
-    Auv_rowval_1D: { size: '$Auv_rowval_len', type: array, subtype: int64 } 
-    Auv_nzval_1D: { size: '$Auv_nzval_len', type: array, subtype: double } 
-
-    Auv_colptr_len: int64
-    Auv_rowval_len: int64
-    Auv_nzval_len: int64
-
-    Auv_n: int64
-    Auv_m: int64
-
-    rhs_uv_len: int64
-    
-    vec_1D_len: int64
-
-
-
-    elec_cond_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-   
-    mesh_x_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    mesh_y_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-
-    residual_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    
-    # for computations, to ignore small cells
-    mask_1D: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-
-    grad_x_1D: { size: ' ($ny) * ($nx+1) ', type: array, subtype: double } 
-    grad_y_1D: { size: ' ($ny+1) * ($nx) ', type: array, subtype: double } 
-
-
-    #BC
-    BC_phi_ele_left: { size: '$ny', type: array, subtype: double } 
-    # trans_scal_1D_H2: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    # trans_scal_1D_KOH: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-    # trans_scal_1D_H2O: { size: '($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny', type: array, subtype: double } 
-
-
-    # stored in 1D: tests
-    l1_rel_error: { size: '$n_tests', type: array, subtype: double }
-    l2_rel_error: { size: '$n_tests', type: array, subtype: double }
-    linfty_rel_error: { size: '$n_tests', type: array, subtype: double }
-
-    l1_rel_error_full_cells: { size: '$n_tests', type: array, subtype: double }
-    l2_rel_error_full_cells: { size: '$n_tests', type: array, subtype: double }
-    linfty_rel_error_full_cells: { size: '$n_tests', type: array, subtype: double }
-
-    l1_rel_error_partial_cells: { size: '$n_tests', type: array, subtype: double }
-    l2_rel_error_partial_cells: { size: '$n_tests', type: array, subtype: double }
-    linfty_rel_error_partial_cells: { size: '$n_tests', type: array, subtype: double }
-
-    nx_list: { size: '$n_tests', type: array, subtype: int64 }
-    cell_volume_list: { size: '$n_tests', type: array, subtype: double }
-    
-    n_tests: int64
-    domain_length: double
-    min_cell_volume: double
-
-
-    # Store segments of interface in 1D vectors
-    intfc_vtx_x: { size: '$intfc_vtx_num', type: array, subtype: double } #TODO vector x y fields all together in size: [ '$intfc_vtx_num', '$nscalars+2' ]
-    intfc_vtx_y: { size: '$intfc_vtx_num', type: array, subtype: double } 
-    vtx_x: { size: '$vtx_num', type: array, subtype: double } #TODO vector x y fields all together in size: [ '$intfc_vtx_num', '$nscalars+2' ]
-    vtx_y: { size: '$vtx_num', type: array, subtype: double } 
-  
-    intfc_vtx_field: { size: '$intfc_vtx_num', type: array, subtype: double } 
-    # intfc_vtx_connectivities: { size: '2*($intfc_vtx_num)', type: array, subtype: int64 } 
-    intfc_vtx_connectivities: { size: '2*($intfc_seg_num)', type: array, subtype: int64 } 
-
-    # stored in 2D
-    i_current_x: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    i_current_y: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    i_current_mag: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    levelset_iso: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    levelset_p: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    levelset_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    levelset_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-    advection_velocity_p: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-    advection_velocity_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    advection_velocity_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-
-    advection_velocity_bulk_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    advection_velocity_bulk_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-
-    advection_velocity_phase_change_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    advection_velocity_phase_change_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-
-    advection_velocity_before_extension_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    advection_velocity_before_extension_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-
-    mass_transfer_rate_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    mass_transfer_rate_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-
-    normal_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double }
-    normal_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double }
-  
-
-    #interpolated
-    advection_velocity_x: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-    advection_velocity_y: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-
-    advection_velocity_phase_change_x: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-    advection_velocity_phase_change_y: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-
-    advection_velocity_bulk_x: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-    advection_velocity_bulk_y: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-
-    advection_velocity_before_extension_x: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-    advection_velocity_before_extension_y: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-
-    normal_phase_change_velocity: { size: [ '$nx', '$ny' ], type: array, subtype: double }
-
-
-    levelset_p_wall: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    velocity_x: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    velocity_y: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mass_transfer_rate: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mass_transfer_rate_redistributed: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mass_transfer_rate_before_redistribution: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    nb_gaz_acceptors: { size: [ '$nx', '$ny' ], type: array, subtype: int64 } #Field of the current subdomain
-    
-    mass_transfer_rate_bulk: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mass_transfer_rate_border: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mass_transfer_rate_intfc: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    normal_angle: { size: [ '$nx', '$ny' ], type: array, subtype: double } # angle to compute normal (cos,sin) in 2D
-    normal_velocity_intfc: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    dcap_1: { size: [ '$nx', '$ny'], type: array, subtype: double } #Field of the current subdomain
-    dcap_2: { size: [ '$nx', '$ny'], type: array, subtype: double } #Field of the current subdomain
-    dcap_3: { size: [ '$nx', '$ny'], type: array, subtype: double } #Field of the current subdomain
-    dcap_4: { size: [ '$nx', '$ny'], type: array, subtype: double } #Field of the current subdomain
-
-    grad_x_coord: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    grad_y_coord: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    grad_x: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    grad_y: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    grad_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    grad_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-    
-    grad_pres_y: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-    grav_y: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-    conv_y: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-
-    velocity_divergence: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    normalise_velocity_divergence: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-
-    rho_one_fluid: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mu_one_fluid: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    volume_cell: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    volume_fraction: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    smoothed_volume_fraction: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    levelset_surface_tension: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-   
-    levelset_heavyside: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    curvature_p: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-    curvature_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    curvature_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-   
-    volumic_surface_tension_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    volumic_surface_tension_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-    viscosity_coeff_for_du_dx: { size: [ '$nx+2', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    
-    viscosity_coeff_for_dv_dy: { size: [ '$nx', '$ny+2' ], type: array, subtype: double } #Field of the current subdomain
-
-    viscosity_coeff_for_du_dy: { size: [ '$nx+1', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-    
-    viscosity_coeff_for_dv_dx: { size: [ '$nx+1', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-    rho_one_fluid_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    
-    rho_one_fluid_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-   
-    rhs_uv_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-    
-    rhs_uv_divergence: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-  
-
-    mesh_p_x: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    mesh_p_y: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-
-    # stored in 3D
-    dcap: { size: [ 11,'$nx', '$ny'], type: array, subtype: double } #Field of the current subdomain
-    
-    iscal: int64 #Index for naming files
-
-    poisson_iter: int64 #Index for naming files
-
-    # Convergence criteria
-    residual_electrical_potential: double
-    variation_electrical_potential: double
-    concentration_check_value: double
-    concentration_check_min: double
-    concentration_check_max: double
-    concentration_check_mean: double
-          
-
-
-    conductivity_u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    conductivity_v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-
-    #chi
-    # chi_1: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    # chi_2: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    # chi_3: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-   # To save only bulk field, with u given in Flower
-    # u: { size: [ '$nx+1', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    # v: { size: [ '$nx', '$ny+1' ], type: array, subtype: double } #Field of the current subdomain
-    # trans_scal: { size: [ '$nx', '$ny','$nb_transported_scalars' ], type: array, subtype: double } #Field of the current subdomain
-    # phi_ele: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    # iu: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-    # iv: { size: [ '$nx', '$ny' ], type: array, subtype: double } #Field of the current subdomain
-
-  plugins:
-    # trace: ~
-    pycall:
-  
-      # logging: "debug"
-
-      on_event:
-        # close_pycall:
-        #   exec: |
-        #     Py_FinalizeEx()
-        # init_PDI:
-        #   exec: |
-        #     print('\n \033[93m'+'test init PDI','\033[0m')
-        #     print('Py_IsInitialized',Py_IsInitialized)
-        # init_PDI2:
-        #   exec: |
-        #     print('\n \033[93m'+'test init PDI','\033[0m')
-        #     print('Py_IsInitialized',Py_IsInitialized)
-        #   - exec: print('nb levelsets',nLS)
-        #     with: { nLS: $nb_levelsets }
-
-
-        check_pressure_velocity_end:
-          with: 
-            nx: $nx
-            ny: $ny
-            u_1D: $u_1D
-            v_1D: $v_1D
-            p_1D: $p_1D
-            grad_x: $grad_x
-            grad_y: $grad_y
-            mu_cin1: *mu_cin1 
-            rho1: *rho1
-            v_inlet: *v_inlet
-            xmin: *mesh_xmin
-            xmax: *mesh_xmax
-            ymin: *mesh_ymin
-            ymax: *mesh_ymax
-          exec: |
-            import numpy as np
-            
-            print('\033[38;5;206m')
-
-            # print('\033[36m')
-            print('[check_pressure_velocity_end]')
-            print("min(u)  {u:.2e} min(v)  {v:.2e} min(p)  {p:.2e}".format(u=np.min(u_1D),v=np.min(v_1D),p=np.min(p_1D)))
-            print("max(u)  {u:.2e} max(v)  {v:.2e} max(p)  {p:.2e}".format(u=np.max(u_1D),v=np.max(v_1D),p=np.max(p_1D)))
-            print("mean(u) {u:.2e} mean(v) {v:.2e} mean(p) {p:.2e}".format(u=np.mean(u_1D),v=np.mean(v_1D),p=np.mean(p_1D)))
-            # print('\033[0m')
-
-            print("min(grad_x)  {u:.2e} min(grad_y)  {v:.2e} ".format(u=np.min(grad_x),v=np.min(grad_y)))
-            print("max(grad_x)  {u:.2e} max(grad_y)  {v:.2e} ".format(u=np.max(grad_x),v=np.max(grad_y)))
-
-    
-            from debug_flower import veci
-
-            field_index = 1
-            
-            # # slice_1D = veci(v_1D,nx,ny,field_index)[ny//2,:]
-
-            # # print('slice projection', slice_1D)
-
-            # # print('len',len(slice_1D))
-
-            # print('nx',nx,ny)
-
-            # slice_1D = veci(v_1D,nx,ny+1,field_index)[(ny+1)//2,:]
-            
-            # print('slice projection', slice_1D)
-
-            # # print('len',len(slice_1D))
-
-
-            # # Print p and v
-
-            # # for j in range(0,ny):
-            # #   slice_p = veci(p_1D,nx,ny,field_index)[j,:]
-            # #   print('Slice p',j,slice_p)
-            # #   slice_1D = veci(v_1D,nx,ny+1,field_index)[j,:]
-            # #   print('Slice v',j,slice_1D)
-
-            pressure_equal_on_line = True
-
-            # Print v
-            for j in range(0,ny):
-              slice_p = veci(p_1D,nx,ny,field_index)[j,:]
-              if (max(slice_p)-min(slice_p))/min(slice_p) > 1.0e-10:
-                pressure_equal_on_line = False 
-                print('Slice p',j,max(slice_p)-min(slice_p),(max(slice_p)-min(slice_p))/min(slice_p) )
-                # print('Slice p',j,slice_p)
-              slice_1D = veci(v_1D,nx,ny+1,field_index)[j,:]
-              # print('Slice v',j,slice_1D)
-            
-         
-            mu1 = mu_cin1 * rho1
-
-            # print('mu1',mu1)
-
-            x_1D = 0
-            y_1D = 0
-            
-            # import numpy as np
-            xp = np.zeros(nx)
-            yp = np.zeros(ny)
-
-            # xp = np.linspace(float(mesh["xmin"]), float(mesh["xmax"]), int(mesh["nx"]))
-            # yp = np.linspace(float(mesh["ymin"]), float(mesh["ymax"]), int(mesh["ny"]))
-
-            dx = (xmax - xmin) / nx
-            dy = (ymax - ymin) / ny
-
-         
-
-            # print('len(xp)',len(xp),len(yp))
-
-            xp[0] = xmin + dx/2
-            yp[0] = ymin + dy/2
-
-            for i in range(1,len(xp)):
-                xp[i] = xp[i-1]+dx
-
-            for i in range(1,len(yp)):
-                yp[i] = yp[i-1]+dx
-
-            yv = yp + dy / 2
-            yv = np.insert(yv, 0, yp[0] - dy / 2)
-
-            # print('xp',xp) #xv too
-            # print('yp',yp)
-            # print('yv',yv)
-
-
-            # p
-            from debug_flower import vecb, vecb_B,vecb_T,vecb_L,vecb_R
-
-            p_top = 0
-            p_bottom = p_top + 8*mu1/(xmax-xmin)*v_inlet
-            p_along_y = p_bottom + (yv - ymin)*(p_top-p_bottom)/(ymax - ymin)
-            print('p',p_along_y)
-
-            print('Bottom',vecb_B(p_1D,nx,ny))
-            print('Top',vecb_T(p_1D,nx,ny))
-
-            print('Left',vecb_L(p_1D,nx,ny))
-            print('Right',vecb_R(p_1D,nx,ny))
-
-            
-
-            # v
-            slice_v_exact = 4* v_inlet * xp /(xmax-xmin)*(1-xp/(xmax-xmin))
-            print('slice v exact', slice_v_exact)
-            
-           
-
-            # def Poiseuille(v_inlet,xp_full,xmin,xmax):
-            #   slice_v_exact = 4* v_inlet * xp_full /(xmax-xmin)*(1-xp_full/(xmax-xmin))
-            #   return slice_v_exact
-            
-            # xp_full = xmin
-            # print('Poiseuille',xp_full,Poiseuille(v_inlet,xp_full,xmin,xmax))
-            # xp_full = xmax
-            # print('Poiseuille',xp_full,Poiseuille(v_inlet,xp_full,xmin,xmax))
-
-            print('\033[0m')
-
-            
-        write_initialization:
-          with: { phi_ele_1D_py: $phi_ele_1D, nx_py: $nx, ny_py: $ny, u_1D: $u_1D, v_1D: $v_1D, p_1D: $p_1D} 
-          exec: |
-            import numpy as np
-            print('\033[93m')
-            # print('Initialization')
-            print("min(u)  {u:.2e} min(v)  {v:.2e} min(p)  {p:.2e}".format(u=np.min(u_1D),v=np.min(v_1D),p=np.min(p_1D)))
-            print("max(u)  {u:.2e} max(v)  {v:.2e} max(p)  {p:.2e}".format(u=np.max(u_1D),v=np.max(v_1D),p=np.max(p_1D)))
-            print("mean(u) {u:.2e} mean(v) {v:.2e} mean(p) {p:.2e}".format(u=np.mean(u_1D),v=np.mean(v_1D),p=np.mean(p_1D)))
-
-            # print("min(cH2) %.6e", minscal1L))\t$(@sprintf("min(KOH) %.6e", minscal2L))\t$(@sprintf("min(H2O) %.6e", minscal3L))\n")
-            # print("max(cH2) %.6e", maxscal1L))\t$(@sprintf("max(KOH) %.6e", maxscal2L))\t$(@sprintf("max(H2O) %.6e", maxscal3L))\n")
-            # print("moy(cH2) %.6e", moyscal1L))\t$(@sprintf("moy(KOH) %.6e", moyscal2L))\t$(@sprintf("moy(H2O) %.6e", moyscal3L))\n")
-
-            print('\033[0m')
-
-
-        # write_electrical_conductivity:
-        #   with: 
-        #     elec_cond_1D: $elec_cond_1D
-        #     conductivity_u: $conductivity_u
-        #     conductivity_v: $conductivity_v
-        #     nx_py: $nx
-        #     ny_py: $ny
-
-
-        #   exec: |
-        #     from debug_flower import vecb
-        #     # print('write_electrical_conductivity')
-        #     # print('coeffD borders ',vecb(elec_cond_1D,nx_py,ny_py))
-        #     # print('coeffDu border ',conductivity_u[:,ny_py//2])
-        #     # print('coeffDv border ',conductivity_v[nx_py//2,:]) 
-        #     # print('coeffDu border ',conductivity_u[ny_py//2,:])
-        #     # print('coeffDv border ',conductivity_v[:,nx_py//2]) 
-
-        print_start_temporal_iteration:
-          with:
-            time: $time
-            nstep: $nstep
-            dcap: $dcap
-          exec: |
-            print('\033[93m')
-            print()
-            print('Iteration  {nstep:d} time  {time:.2e}'.format(nstep=nstep,time=time))
-
-            # print('Check cut-cell operators ',dcap[:,1,1])
-
-            print('\033[0m')
-
-
-        print_before_prediction:
-          with: { nx: $nx, ny: $ny, u_1D: $u_1D, v_1D: $v_1D, p_1D: $p_1D} 
-          exec: |
-            import numpy as np
-            print('\033[36m')
-            print('[Before prediction]')
-            print("min(u)  {u:.2e} min(v)  {v:.2e} min(p)  {p:.2e}".format(u=np.min(u_1D),v=np.min(v_1D),p=np.min(p_1D)))
-            print("max(u)  {u:.2e} max(v)  {v:.2e} max(p)  {p:.2e}".format(u=np.max(u_1D),v=np.max(v_1D),p=np.max(p_1D)))
-            print("mean(u) {u:.2e} mean(v) {v:.2e} mean(p) {p:.2e}".format(u=np.mean(u_1D),v=np.mean(v_1D),p=np.mean(p_1D)))
-            print('\033[0m')
-            
-            # from debug_flower import veci
-            # field_index = 1
-            # # slice_1D = veci(v_1D,nx,ny,field_index)[ny//2,:]
-            # # print('slice projection', slice_1D)
-
-            # # print('len',len(slice_1D))
-
-            # # print('nx',nx,ny)
-
-            # slice_1D = veci(v_1D,nx,ny+1,field_index)[(ny+1)//2,:]
-            # print('slice projection', slice_1D)
-
-            # # print('len',len(slice_1D))
-
-            # for j in range(0,ny):
-            #   slice_p = veci(p_1D,nx,ny,field_index)[ny-1-j,:] #0: end (top), ny, 1
-            #   print('Slice p',j,slice_p)
-            
-            # # from plot_pdi import plot_profile; plot_profile(x,slice_1D,"Poiseuille_during_projection")
-
-
-        print_pressure_gradient_in_prediction:
-          with: 
-            grad_x_1D: $grad_x_1D
-            grad_y_1D: $grad_y_1D
-            p_1D: $p_1D
-            nx: $nx
-            ny: $ny
-            # mu_cin1: *mu_cin1 
-            # rho1: *rho1
-            # v_inlet: *v_inlet
-            xmin: *mesh_xmin
-            xmax: *mesh_xmax
-            ymin: *mesh_ymin
-            ymax: *mesh_ymax
-
-          exec: |
-            import numpy as np
-            print('\033[36m')
-            print('[print_pressure_gradient_in_prediction]')
-            dx = (xmax-xmin)/ nx
-            volume = dx**2
-            # grad_x = np.reshape(grad_x_1D, (nx, ny)) 
-            # grad_y = np.reshape(grad_y_1D, (nx, ny)) 
-
-            grad_x = np.reshape(grad_x_1D, (nx+1, ny)) 
-            grad_y = np.reshape(grad_y_1D, (nx, ny+1)) 
-            grad_x = grad_x.transpose()
-            grad_y = grad_y.transpose()
-
-            for j in range(0,ny):
-              slice_p = grad_x[j,:] #0: end (top), ny, 1
-              print('grad_x',j,slice_p)
-
-            for j in range(0,ny+1):
-              slice_p = grad_y[j,:] #0: end (top), ny, 1
-              print('grad_y',j,slice_p)
-
-            # # Select only useful part of vector, the actual gradient
-            # grad_x = grad_x[:,1:-1] #size ny, nx-1
-            # grad_y = grad_y[1:-1,:] #size ny-1, nx
-
-            print("min(u)  {u:.2e} min(v)  {v:.2e} min(v)/volume  {p:.2e}".format(u=np.min(grad_x),v=np.min(grad_y),p=np.min(grad_y)/volume))
-            print("max(u)  {u:.2e} max(v)  {v:.2e} max(v)/volume  {p:.2e}".format(u=np.max(grad_x),v=np.max(grad_y),p=np.max(grad_y)/volume))
-            print("mean(u) {u:.2e} mean(v) {v:.2e} mean(v)/volume {p:.2e}".format(u=np.mean(grad_x),v=np.mean(grad_y),p=np.mean(grad_y)/volume))
-            
-            
-            # for j in range(0,ny):
-            #   slice_p = grad_x[j,:] #0: end (top), ny, 1
-            #   print('grad_x',j,slice_p)
-
-            # for j in range(0,ny-1):
-            #   slice_p = grad_y[j,:] #0: end (top), ny, 1
-            #   print('grad_y',j,slice_p)
-
-            from debug_flower import vecb, vecb_B, vecb_T, vecb_L,vecb_R
-            print('bottom BC pressure',vecb_B(p_1D,nx,ny))
-            print('top    BC pressure',vecb_T(p_1D,nx,ny))
-            print('left   BC pressure',vecb_L(p_1D,nx,ny))
-            print('right  BC pressure',vecb_R(p_1D,nx,ny))
-
-            # print('vecb pressure',vecb(p_1D,nx,ny))
-
-            print('\033[0m')
-
-        print_variables:
-          with: 
-            phi_ele_1D_py: $phi_ele_1D
-            nx_py: $nx
-            ny_py: $ny
-            u_1D: $u_1D
-            v_1D: $v_1D
-            p_1D: $p_1D
-            trans_scal_1DT: $trans_scal_1DT 
-            nb_transported_scalars: *nb_transported_scalars
-          exec: |
-            import numpy as np
-            print('\033[93m')
-            print('[print_variables]')
-            print("min(u)  {u:.2e} min(v)  {v:.2e} min(p)  {p:.2e}".format(u=np.min(u_1D),v=np.min(v_1D),p=np.min(p_1D)))
-            print("max(u)  {u:.2e} max(v)  {v:.2e} max(p)  {p:.2e}".format(u=np.max(u_1D),v=np.max(v_1D),p=np.max(p_1D)))
-            print("mean(u) {u:.2e} mean(v) {v:.2e} mean(p) {p:.2e}".format(u=np.mean(u_1D),v=np.mean(v_1D),p=np.mean(p_1D)))
-            if nb_transported_scalars>0:
-              print("min(cH2)  {cH2:.2e} min(KOH)  {KOH:.2e} min(H2O)  {H2O:.2e}".format(cH2=np.min(trans_scal_1DT[0,:]),KOH=np.min(trans_scal_1DT[1,:]),H2O=np.min(trans_scal_1DT[2,:])))
-              print("max(cH2)  {cH2:.2e} max(KOH)  {KOH:.2e} max(H2O)  {H2O:.2e}".format(cH2=np.max(trans_scal_1DT[0,:]),KOH=np.max(trans_scal_1DT[1,:]),H2O=np.max(trans_scal_1DT[2,:])))
-              print("mean(cH2) {cH2:.2e} mean(KOH) {KOH:.2e} mean(H2O) {H2O:.2e}".format(cH2=np.mean(trans_scal_1DT[0,:]),KOH=np.mean(trans_scal_1DT[1,:]),H2O=np.mean(trans_scal_1DT[2,:])))
-            
-        
-            print('\033[0m')
-
-        mesh:
-          with: 
-            mesh_x_1D_py: $mesh_x_1D
-            grad_x_coord_py: $grad_x_coord
-            nx_py: $nx
-            ny_py: $ny
-
-          exec: |
-            from debug_flower import veci
-            # mesh in 1 line in x direction at j = 0
-            print('\n \033[93m'+'mesh x  ',veci(mesh_x_1D_py,nx_py,ny_py,1)[0,:],'\033[0m')
-            print('\n \033[93m'+'corr x  ',veci(grad_x_coord_py,nx_py+1,ny_py,1)[0,:],'\033[0m')
-
-            
-        check_electrical_potential_convergence:
-          with: 
-            # BC_phi_ele_left_py: $BC_phi_ele_left
-            residual_py: $residual_1D
-            phi_ele_1D_py: $phi_ele_1D
-            elec_cond_1D_py: $elec_cond_1D
-            rhs_1D: $rhs_1D
-            dcap_1: $dcap_1
-            # i_current_x_py: $i_current_x
-            nx_py: $nx
-            ny_py: $ny
-            # phi_ele1: $phi_ele1
-            alpha: *alpha
-            i0: *i0
-            phi_ele1: *phi_ele1
-            Faraday: *Faraday
-            Ru: *Ru
-            temperature0: *temperature0
-            concentration0_KOH: *concentration0_KOH
-            diffusion_coeff_KOH: *diffusion_coeff_KOH
-            mesh_xmax: *mesh_xmax
-            mesh_xmin: *mesh_xmin
-            domain_length: *domain_length
-            # with: { phi_ele_1D_py: $phi_ele_1D, nx_py: $nx, ny_py: $ny}  
-
-  
-          exec: |
-            import numpy as np
-            from debug_flower import butler_grad_phi,vecb_L,butler,veci
-
-            print('\n \033[93m')
-            print()
-            print('[check_electrical_potential_convergence]')
-            
-            print('phi wall ',vecb_L(phi_ele_1D_py,nx_py,ny_py))
-
-            # print('F_residual ',vecb_L(residual_py,nx_py,ny_py)) #array at wall
-
-            # print('F_residual ',np.min(vecb_L(residual_py,nx_py,ny_py)), np.max(vecb_L(residual_py,nx_py,ny_py)))
-
-            # print('F_residual bulk', np.min(veci(residual_py,nx_py,ny_py,1)), np.max(veci(residual_py,nx_py,ny_py,1)) )
-
-            # print('len(dcap_1[1,:])',len(dcap_1[1,:]))
-            # print('dcap',dcap_1[1,:])
-
-            # print('F_residual /dx (homogeneous to a gradient of potential)',vecb_L(residual_py,nx_py,ny_py)/dcap_1[1,:])
-
-            # print('F_residual /dx * cond (homogeneous to a gradient of current) ',vecb_L(residual_py,nx_py,ny_py)/dcap_1[1,:]*vecb_L(elec_cond_1D_py,nx_py,ny_py))
-           
-            # print('F_residual normalized (unitless)',vecb_L(residual_py,nx_py,ny_py)/dcap_1[1,:]/vecb_L(rhs_1D,nx_py,ny_py))
-
-            print('F_residual normalized infty',np.max(np.abs(vecb_L(residual_py,nx_py,ny_py)))/np.max(np.abs(vecb_L(rhs_1D,nx_py,ny_py))))
-
-
-            # print('vecb_L(rhs_1D,nx_py,ny_py)',vecb_L(rhs_1D,nx_py,ny_py))
-
-
-            print('\033[0m')
-
-
-        warning_scalar_transport:
-          with:
-            iscal: $iscal
-            trans_scal_1DT: $trans_scal_1DT
-            concentration_check_value: $concentration_check_value
-            nb_levelsets: *nb_levelsets
-            nb_transported_scalars: *nb_transported_scalars
-            activate_interface: *activate_interface
-            concentration_check_factor: *concentration_check_factor 
-            concentration0_H2: *concentration0_H2
-            concentration0_KOH: *concentration0_KOH
-            concentration0_H2O: *concentration0_H2O
-
-          exec: |
-            print('\n \033[91m')
-            print()
-            
-            concentration0 = [concentration0_H2,concentration0_KOH,concentration0_H2O]
-
-            if iscal == 1:
-              print("[warning_scalar_transport] H2  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1-concentration_check_factor)))
-            elif iscal == 2: 
-              print("[warning_scalar_transport] KOH  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1-concentration_check_factor)))
-            elif iscal == 3: 
-              print("[warning_scalar_transport] H2O  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1+concentration_check_factor)))
-
-            # concentration drop:(minimum(ph.trans_scal[:,:,iscal])-num.concentration0[iscal])/num.concentration0[iscal]*100)
-            print("concentration too low")
-
-            print('\033[0m')
-
-
-        check_scalar_transport_interface:
-          with:
-            iscal: $iscal
-            nb_levelsets: *nb_levelsets
-            nb_transported_scalars: *nb_transported_scalars
-            activate_interface: *activate_interface
-            # concentration_check_value: $concentration_check_value
-            concentration_check_min: $concentration_check_min
-            concentration_check_max: $concentration_check_max
-            concentration_check_mean: $concentration_check_mean
-            trans_scal_1DT: $trans_scal_1DT
-            concentration0_H2: *concentration0_H2
-            concentration0_KOH: *concentration0_KOH
-            concentration0_H2O: *concentration0_H2O
-            concentration_check_factor: *concentration_check_factor
-            # concentration0: $concentration0
-            # concentration0: << *concentration0
-            # <<: *concentration0
-            # <<: *concentration0
-
-          exec: |
-            print('\n \033[92m')
-            print()
-            print('[check_scalar_transport_interface]')
-
-            concentration0 = np.array([concentration0_H2,concentration0_KOH,concentration0_H2O])
-
-            print("[check_scalar_transport_interface] min  {concentration_check_min:.2e} max {concentration_check_max:.2e} mean {concentration_check_mean:.2e}".format(concentration_check_min=concentration_check_min,concentration_check_max=concentration_check_max,concentration_check_mean=concentration_check_mean))
-
-            concentration_check_value = concentration_check_min
-
-            if iscal == 1:
-              print("[check_scalar_transport_interface] H2  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1-concentration_check_factor)))
-            elif iscal == 2: 
-              print("[check_scalar_transport_interface] KOH  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1-concentration_check_factor)))
-            elif iscal == 3: 
-              print("[check_scalar_transport_interface] H2O  {iscal:d} {concentration_check_value:.2e} {check_threshold:.2e}".format(iscal=iscal,concentration_check_value=concentration_check_value,check_threshold=concentration0[iscal-1]*(1+concentration_check_factor)))
-
-            print('\033[0m')
-
-
-
-        #Checks after resolution if the values are physical
-        check_scalar_transport:
-          with:
-            iscal: $iscal
-            nb_levelsets: *nb_levelsets
-            nb_transported_scalars: *nb_transported_scalars
-            activate_interface: *activate_interface
-            trans_scal_1DT: $trans_scal_1DT
-            # concentration0: $concentration0
-            # concentration0: *concentration0
-            # <<: *concentration0
-            concentration0_H2: *concentration0_H2
-            concentration0_KOH: *concentration0_KOH
-            concentration0_H2O: *concentration0_H2O
-            mask_1D: $mask_1D #mask containing volumes in bulk, and liquid heights on interfaces, and 0 when a cell is cut
-            # so that small cells are ignored when computing min, max, ...
-
-          exec: |
-            print('\n \033[92m')
-            print()
-            print('[check_scalar_transport]')
-            print("min(cH2)  {cH2:.2e} min(KOH)  {KOH:.2e} min(H2O)  {H2O:.2e}".format(cH2=np.min(trans_scal_1DT[0,:]),KOH=np.min(trans_scal_1DT[1,:]),H2O=np.min(trans_scal_1DT[2,:])))
-            print("max(cH2)  {cH2:.2e} max(KOH)  {KOH:.2e} max(H2O)  {H2O:.2e}".format(cH2=np.max(trans_scal_1DT[0,:]),KOH=np.max(trans_scal_1DT[1,:]),H2O=np.max(trans_scal_1DT[2,:])))
-            print("mean(cH2) {cH2:.2e} mean(KOH) {KOH:.2e} mean(H2O) {H2O:.2e}".format(cH2=np.mean(trans_scal_1DT[0,:]),KOH=np.mean(trans_scal_1DT[1,:]),H2O=np.mean(trans_scal_1DT[2,:])))
-            
-            print('with mask')
-
-            scal0 = np.ma.masked_where(mask_1D <= 0.0, trans_scal_1DT[0,:])
-            scal1 = np.ma.masked_where(mask_1D <= 0.0, trans_scal_1DT[1,:])
-            scal2 = np.ma.masked_where(mask_1D <= 0.0, trans_scal_1DT[2,:])
-
-            print('with mask')
-            print("min(cH2)  {cH2:.2e} min(KOH)  {KOH:.2e} min(H2O)  {H2O:.2e}".format(cH2=np.min(scal0), KOH=np.min(scal1), H2O=np.min(scal2)))
-            print("max(cH2)  {cH2:.2e} max(KOH)  {KOH:.2e} max(H2O)  {H2O:.2e}".format(cH2=np.max(scal0), KOH=np.max(scal1), H2O=np.max(scal2)))
-            print("mean(cH2) {cH2:.2e} mean(KOH) {KOH:.2e} mean(H2O) {H2O:.2e}".format(cH2=np.mean(scal0),KOH=np.mean(scal1),H2O=np.mean(scal2)))
-            
-
-
-            concentration0 = np.array([concentration0_H2,concentration0_KOH,concentration0_H2O])
-            # concentration0 = [concentration0_H2[0],concentration0_KOH[0],concentration0_H2O[0]]
-
-            # print("concentration0",concentration0)
-
-            # print('concentration0_H2',concentration0_H2)
-
-            # try:
-            #   print('concentration0_H2',concentration0_H2[0])
-            # except:
-            #   print('no ')
-
-            # print('types',type(iscal),type(concentration0_H2),type(concentration0))
-
-            # # print average value at interface
-            # if activate_interface !=0:
-            #   iLS = 1
-            #   # nonzero = mean_intfc_non_null(ph.trans_scalD,iscal,grid,iLS) #Value at interface
-
-            #   index = iLS+1
-            #   num=0
-            #   nonzero = 0.0
-
-            #   # cf veci @view a[g.ny*g.nx*(p-1)+1:g.ny*g.nx*p]
-
-            #   for scal_intfc in veci(scalD):
-            #     if abs(scal_intfc) >0.0:
-            #       nonzero += scalD[i,iscal]
-            #       num += 1
-
-            #   if num == 0:
-            #     print("no intfc in mean_intfc_non_null")
-            #   else:
-            #     nonzero /= num
-            #     print("Mean value at interface  {:.2e}".format(nonzero)) 
-
-            print('\033[0m')
-
-
-        check_electrical_potential:
-          with: 
-            poisson_iter: $poisson_iter
-            BC_phi_ele_left_py: $BC_phi_ele_left
-            elec_cond_1D_py: $elec_cond_1D
-            phi_ele_1D_py: $phi_ele_1D
-            i_current_x_py: $i_current_x
-            nx_py: $nx
-            ny_py: $ny
-            variation_electrical_potential: $variation_electrical_potential
-            residual_electrical_potential: $residual_electrical_potential
-            residual_1D: $residual_1D
-            rhs_1D: $rhs_1D
-            # phi_ele1: $phi_ele1
-            alpha: *alpha
-            i0: *i0
-            phi_ele1: *phi_ele1
-            Faraday: *Faraday
-            Ru: *Ru
-            temperature0: *temperature0
-            concentration0_KOH: *concentration0_KOH
-            diffusion_coeff_KOH: *diffusion_coeff_KOH
-            mesh_xmax: *mesh_xmax
-            mesh_xmin: *mesh_xmin
-            domain_length: *domain_length
-            # with: { phi_ele_1D_py: $phi_ele_1D, nx_py: $nx, ny_py: $ny}  
-
-  
-          exec: |
-            import numpy as np
-            from debug_flower import butler_grad_phi,vecb_L,butler,veci
-            
-            print('\n \033[93m')
-            print()
-            # print('check_electrical_potential')
-
-            print('[check_electrical_potential] Poisson iter',poisson_iter,'\033[0m')
-
-
-            print("Residual  {:.2e} absolute variation  {:.2e}".format(residual_electrical_potential,variation_electrical_potential))
-            
-            # #num.electrical_potential_residual
-
-            # print('\n \033[93m'+'Pycall ','\033[0m')
-            min_phi = np.min(phi_ele_1D_py)
-
-            phi = veci(phi_ele_1D_py,nx_py,ny_py,1)
-
-
-            # print('\n \033[93m'+'phi ',np.min(phi_ele_1D_py),np.max(phi_ele_1D_py),'\033[0m')
-
-            # print('\n \033[93m'+'Conductivity min',np.min(elec_cond_1D_py),'max',np.max(elec_cond_1D_py),'\033[0m')
-
-
-            residual_electrical_potential_wall = np.max(abs(vecb_L(residual_1D,nx_py,ny_py))) / np.max(abs(vecb_L(rhs_1D,nx_py,ny_py)))
-            residual_electrical_potential_total = np.max(abs(residual_1D)) / np.max(abs(rhs_1D))
-
-            print("Residual wall {:.2e} whole  {:.2e}".format(residual_electrical_potential_wall,residual_electrical_potential_total))
-
-
-
-            # print('\n \033[93m'+'BC_phi_ele_left ',np.min(BC_phi_ele_left_py),np.max(BC_phi_ele_left_py),'\033[0m')
-
-
-            # print('\n \033[93m'+'i_current_x min ',np.min(i_current_x_py),'max ',np.max(i_current_x_py),'\033[0m')
-
-            # print('\n \033[93m'+'i_current_x_py ',i_current_x_py[:,ny_py//2],'\033[0m')
-
-            
-            # print('\n \033[93m'+'phi line ',phi[:,ny_py//2],'\033[0m') # vertical line 
-            # print('\n \033[93m'+'phi line ',phi[ny_py//2,:],'\033[0m') #horizontal line
-
-            # min_phi = np.min(phi_ele_1D_py)
-
-            # print('\n \033[93m'+'sum ',-i_current_x_py[:,ny_py//2]+butler(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-            # print('\n \033[93m'+'Convergence Butler-Volmer ',np.max(np.abs(-i_current_x_py[:,ny_py//2]+butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0))),'\033[0m')
-
-
-            # print('\n \033[93m'+'ratio ',(-i_current_x_py[:,ny_py//2]+butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0)/butler(0,phi_ele1,Faraday,alpha,Ru,temperature0,i0),phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-            # print('\n \033[93m'+'sum ',butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-            
-            # print('\n \033[93m'+'sum ',butler(0,phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-
-            # L = mesh_xmax-mesh_xmin
-            # print('\n \033[93m'+'phi ',min_phi,-L*butler_grad_phi(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,concentration0_KOH,diffusion_coeff_KOH,i0),'\033[0m')
-            # print('\n \033[93m'+'grad phi ',min_phi,butler_grad_phi(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,concentration0_KOH,diffusion_coeff_KOH,i0),'\033[0m')
-
-            # print(vecb_L(phi_ele_1D_py,nx_py,ny_py))
-
-            # from debug_flower import vecbprint,veci, butler
-            
-            # # vecbprint(phi_ele_1D_py,nx_py,ny_py)
-
-            # phi = veci(phi_ele_1D_py,nx_py,ny_py,1)
-
-            # # print(phi[nx_py/2,:])
-            # # print(phi[:,nx_py/2])
-
-            # # a = 0.66
-            # a = 0.6608349877730476
-            # L= 1e-4
-            # npoints=2
-            # xplot_new = np.linspace(0, L, npoints)
-            # yplot_new = a * (xplot_new / L - 1)
-
-        
-
-
-            print('\033[0m')
-
-
-        # print_electrical_potential:
-        #   with: 
-        #     poisson_iter: $poisson_iter
-        #     BC_phi_ele_left_py: $BC_phi_ele_left
-        #     elec_cond_1D_py: $elec_cond_1D
-        #     phi_ele_1D_py: $phi_ele_1D
-        #     i_current_x_py: $i_current_x
-        #     nx_py: $nx
-        #     ny_py: $ny
-        #     # variation_electrical_potential: $variation_electrical_potential
-        #     # residual_electrical_potential: $residual_electrical_potential
-        #     # phi_ele1: $phi_ele1
-        #     alpha: *alpha
-        #     i0: *i0
-        #     phi_ele1: *phi_ele1
-        #     Faraday: *Faraday
-        #     Ru: *Ru
-        #     temperature0: *temperature0
-        #     concentration0_KOH: *concentration0_KOH
-        #     diffusion_coeff_KOH: *diffusion_coeff_KOH
-        #     mesh_xmax: *mesh_xmax
-        #     mesh_xmin: *mesh_xmin
-        #     domain_length: *domain_length
-        #     # with: { phi_ele_1D_py: $phi_ele_1D, nx_py: $nx, ny_py: $ny}  
-
-  
-        #   exec: |
-        #     import numpy as np
-        #     from debug_flower import butler_grad_phi,vecb_L,butler,veci
-            
-        #     print('\n \033[93m')
-        #     print()
-        #     print('[print_electrical_potential] Poisson iter',poisson_iter,'\033[0m')
-
-        #     # print('\n \033[93m'+'Pycall ','\033[0m')
-
-        #     phi = veci(phi_ele_1D_py,nx_py,ny_py,1)
-
-
-        #     # print('\n \033[93m'+'phi ',np.min(phi_ele_1D_py),np.max(phi_ele_1D_py),'\033[0m')
-
-        #     print('\n \033[93m'+'Conductivity min',np.min(elec_cond_1D_py),'max',np.max(elec_cond_1D_py),'\033[0m')
-
-        #     # print('\n \033[93m'+'BC_phi_ele_left ',np.min(BC_phi_ele_left_py),np.max(BC_phi_ele_left_py),'\033[0m')
-
-
-        #     # print('\n \033[93m'+'i_current_x min ',np.min(i_current_x_py),'max ',np.max(i_current_x_py),'\033[0m')
-
-        #     # print('\n \033[93m'+'i_current_x_py ',i_current_x_py[:,ny_py//2],'\033[0m')
-
-            
-        #     # print('\n \033[93m'+'phi line ',phi[:,ny_py//2],'\033[0m') # vertical line 
-        #     # print('\n \033[93m'+'phi line ',phi[ny_py//2,:],'\033[0m') #horizontal line
-
-        #     # min_phi = np.min(phi_ele_1D_py)
-
-        #     # print('\n \033[93m'+'sum ',-i_current_x_py[:,ny_py//2]+butler(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-        #     # print('\n \033[93m'+'Convergence Butler-Volmer ',np.max(np.abs(-i_current_x_py[:,ny_py//2]+butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0))),'\033[0m')
-
-
-        #     # print('\n \033[93m'+'ratio ',(-i_current_x_py[:,ny_py//2]+butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0)/butler(0,phi_ele1,Faraday,alpha,Ru,temperature0,i0),phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-        #     # print('\n \033[93m'+'sum ',butler(vecb_L(phi_ele_1D_py,nx_py,ny_py),phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-            
-        #     # print('\n \033[93m'+'sum ',butler(0,phi_ele1,Faraday,alpha,Ru,temperature0,i0),'\033[0m')
-
-
-        #     # L = mesh_xmax-mesh_xmin
-        #     # print('\n \033[93m'+'phi ',min_phi,-L*butler_grad_phi(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,concentration0_KOH,diffusion_coeff_KOH,i0),'\033[0m')
-        #     # print('\n \033[93m'+'grad phi ',min_phi,butler_grad_phi(min_phi,phi_ele1,Faraday,alpha,Ru,temperature0,concentration0_KOH,diffusion_coeff_KOH,i0),'\033[0m')
-
-        #     # print(vecb_L(phi_ele_1D_py,nx_py,ny_py))
-
-        #     # from debug_flower import vecbprint,veci, butler
-            
-        #     # # vecbprint(phi_ele_1D_py,nx_py,ny_py)
-
-        #     # phi = veci(phi_ele_1D_py,nx_py,ny_py,1)
-
-        #     # # print(phi[nx_py/2,:])
-        #     # # print(phi[:,nx_py/2])
-
-        #     # # a = 0.66
-        #     # a = 0.6608349877730476
-        #     # L= 1e-4
-        #     # npoints=2
-        #     # xplot_new = np.linspace(0, L, npoints)
-        #     # yplot_new = a * (xplot_new / L - 1)
-
-        
-        #     # print("Residual  {:.2e} absolute variation  {:.2e}".format(residual_electrical_potential,variation_electrical_potential))
-        #     # #num.electrical_potential_residual
-
-        #     print('\033[0m')
-
-
-          # - exec: import plot_flower; plot_flower.print_bc(phi_ele_1D_py) #TODO bug hdf5 so put debugging functions in debug_flower.py
-
-
-        # write_data_elec_ix_iy:
-        #   with: 
-        #     ix: $i_current_x
-        #     iy: $i_current_y
-        #   exec: |
-        #     import numpy as np
-        #     print('\n \033[93m')
-        #     print('Current i_x {:.2e} i_y {:.2e}'.format(np.max(ix),np.max(iy)))
-        #     print('\033[0m')
-
-        # write_data_elec_imag:
-        #   with: { imag: $i_current_mag }
-        #   exec: |
-        #     import numpy as np
-        #     print('\033[93m')
-        #     print('Current magnitude  {:.2e} '.format( np.max(imag) ) )
-        #     print('\033[0m')
-
-        write_data_elec_ix_iy:
-          with: 
-            ix: $i_current_x
-            iy: $i_current_y
-            imag: $i_current_mag
-          exec: |
-            import numpy as np
-            print('\n \033[93m')
-            print('Current i_x {:.2e} i_y {:.2e} i_mag {:.2e}'.format(np.max(ix),np.max(iy),np.max(imag)))
-            print('\033[0m')
-
-
-        # write_data:
-        #   - exec: print('Test nstep',nstep_py)
-        #     with: { nstep_py: $nstep }
-          # - exec: from debug_flower import vecbprint; vecbprint(p_1D_py,nx_py,ny_py)
-          #   with: { p_1D_py: $p_1D, nx_py: $nx, ny_py: $ny} 
-
-          # - exec: import plot_flower; plot_flower.print_bc(p_1D_py) #TODO bug hdf5 so put debugging functions in debug_flower.py
-
-
-        # check_concentrations:
-        #   - exec: print('Test nstep',nstep_py)
-
-
-
-        # write_scalar_transport:
-
-        # # CRED = '\033[91m'
-        # # CEND = '\033[0m'
-        # - exec: print('\033[91m Test iscal',iscal_py,'\033[0m')
-        #   with: { iscal_py: $iscal }
-
-
-        testing: #python event to plot with matplotlib
-          exec: from plot_pdi import plot_bc2; plot_bc2()
-        # write_data:
-        #   with: { iter_id: $nstep, source_field: $main_field }
-        #     exec: |
-        #       import numpy as np
-        #       if 0 < iter_id < 4:
-        #           transformed_field = np.sqrt(source_field[1:-1,1:-1])
-        #           pdi.expose('transformed_field', transformed_field, pdi.OUT)  
-    # mpi:
-    
-   
-
-    #TODO careful: when to update nstep so that stored in right file with multi expose
-    #TODO careful make first write overwrite so that old data does not remain 
-
-    decl_hdf5: #Writing in hdf5
-      # - file: results/data_${nstep:08}_${mpi_coords_x:02}_${mpi_coords_y:02}.h5 
-
-
-      - file: convergence_Butler.h5
-        collision_policy: replace #write_into overwrite old file #TODO
-        on_event: convergence_study
-        write: [nx_list,cell_volume_list,l1_rel_error,l2_rel_error,linfty_rel_error,l1_rel_error_full_cells,l2_rel_error_full_cells,linfty_rel_error_full_cells,l1_rel_error_partial_cells,l2_rel_error_partial_cells,linfty_rel_error_partial_cells,min_cell_volume]
-        #domain_length
-
-
-      #  #write segments of interface
-      # - file: convergence_Poiseuille_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: convergence_study_iter
-      #   # write: [intfc_vtx_num,intfc_vtx_x,intfc_vtx_y,intfc_vtx_field,intfc_seg_num,intfc_vtx_connectivities]
-      #   write: [nstep,levelset_p,normal_angle,phi_ele_1D,radius,intfc_vtx_num,intfc_vtx_x,intfc_vtx_y,intfc_vtx_field,intfc_seg_num,intfc_vtx_connectivities]
-
-
-
-      
-
-    
-      - file: flower_${nstep:08}.h5 
-        collision_policy: replace #write_into overwrite old file #TODO
-        on_event: write_initialization
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep = 0"
-        write: [levelset_p,levelset_u,levelset_v,radius,nstep,time,velocity_x,velocity_y]
-        #write: [levelset_p,levelset_u,levelset_v,levelset_p_wall,radius]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: replace #replace_and_warn #write_into overwrite old file #TODO
-        on_event: write_data_start_loop
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep%50 = 0"
-        write: [levelset_p,levelset_u,levelset_v,radius,nstep,time] #,normal_angle]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_radius
-        write: [radius]
-
-
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_normal_phase_change_velocity
-        write: [normal_phase_change_velocity] #,normal_an
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_advection_velocity_before_extension
-        write: [advection_velocity_before_extension_u,advection_velocity_before_extension_v]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_mass_transfer_rate_uv
-        write: [mass_transfer_rate_u,mass_transfer_rate_v]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_normal_uv
-        write: [normal_u,normal_v]
-
-
-        
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_advection_velocity_phase_change
-        write: [advection_velocity_phase_change_u,advection_velocity_phase_change_v]
-        
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_advection_velocity_bulk
-        write: [advection_velocity_bulk_u,advection_velocity_bulk_v]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_advection
-        write: [advection_velocity_u,advection_velocity_v]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_interpolated_advection_velocity_before_extension
-        write: [advection_velocity_before_extension_x,advection_velocity_before_extension_y]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_interpolated_advection_velocity_phase_change
-        write: [advection_velocity_phase_change_x,advection_velocity_phase_change_y]
-        
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_interpolated_advection_velocity_bulk
-        write: [advection_velocity_bulk_x,advection_velocity_bulk_y]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_interpolated_advection_velocity
-        write: [advection_velocity_x,advection_velocity_y]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: write_advection_bulk_velocity
-        write: [advection_bulk_velocity] #,normal_an
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: check_divergence
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep%50 = 0"
-        write: [nstep,velocity_divergence] #,normal_angle]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into #write_into overwrite old file #TODO
-        on_event: print_conservation
-        write: [nstep,conservation] #,normal_angle]
-
-    
-      # #write segments of interface
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_data_start_loop
-      #   write: [intfc_vtx_num,intfc_vtx_x,intfc_vtx_y,intfc_vtx_field,intfc_seg_num,intfc_vtx_connectivities]
-
-      #write mass flux used in phase change
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_mass_transfer_rate
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: #"$nstep%50 = 0"
-        write: [mass_transfer_rate,mass_transfer_rate_bulk,mass_transfer_rate_border,mass_transfer_rate_intfc]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_mass_transfer_rate_redistributed
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: #"$nstep%50 = 0"
-        write: [mass_transfer_rate,mass_transfer_rate_before_redistribution,nb_gaz_acceptors]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_mass_transfer_rate_only
-        write: [mass_transfer_rate]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_interface_length       
-        write: [interface_length]
-
-
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_electrical_potential
-      #   # datasets: #Dataset we are writing in: the whole solution
-      #   #   data:
-      #   #     type: array
-      #   #     subtype: double
-      #   #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-      #   # when: "$iscal = -1" #"$iscal = 1" #"$nstep%50 = 0"
-      #   write: [rhs_1D,phi_ele_1D] #,trans_scal_1DT"] #chi_1,chi_2]
-      
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_scalar_transport
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        when: "$iscal = 1" #2 #"$iscal = -1" #"$iscal = 1" #"$nstep%50 = 0"
-        write: [iscal,rhs_1D] #chi_1,chi_2]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_iso
-        write: [levelset_iso]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_capacities
-      #   # datasets: #Dataset we are writing in: the whole solution
-      #   #   data:
-      #   #     type: array
-      #   #     subtype: double
-      #   #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-      #   # when: #"$nstep%50 = 0"
-      #   write: [dcap] #chi_1,chi_2]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_capacities
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: #"$nstep%50 = 0"
-        write: [dcap_1,dcap_2,dcap_3,dcap_4]
-
-
-      # #write capacities
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_capacities
-      #   datasets: # a list of datasets inside the file created on first access
-      #     #*** define the datasets for main_field
-      #     dcap_1: { type: array, subtype: double, size:  [1, '$nx', '$ny'] }
-      #   write: 
-      #     dcap: # the name of the data to write
-      #       dataset: dcap_1
-      #       memory_selection: #only H2O
-      #         size:  [1, '$nx', '$ny']
-      #         start: [0,0,0]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_capacities
-      #   datasets: # a list of datasets inside the file created on first access
-      #     #*** define the datasets for main_field
-      #     dcap_2: { type: array, subtype: double, size:  [1, '$nx', '$ny'] }
-      #   write: 
-      #     dcap: # the name of the data to write
-      #       dataset: dcap_2
-      #       memory_selection: #only H2O
-      #         size:  [1, '$nx', '$ny']
-      #         start: [1,0,0]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_capacities
-      #   datasets: # a list of datasets inside the file created on first access
-      #     #*** define the datasets for main_field
-      #     dcap_3: { type: array, subtype: double, size:  [1, '$nx', '$ny'] }
-      #   write: 
-      #     dcap: # the name of the data to write
-      #       dataset: dcap_3
-      #       memory_selection: #only H2O
-      #         size:  [1, '$nx', '$ny']
-      #         start: [2,0,0]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_capacities
-      #   datasets: # a list of datasets inside the file created on first access
-      #     #*** define the datasets for main_field
-      #     dcap_4: { type: array, subtype: double, size:  [1, '$nx', '$ny'] }
-      #   write: 
-      #     dcap: # the name of the data to write
-      #       dataset: dcap_4
-      #       memory_selection: #only H2O
-      #         size:  [1, '$nx', '$ny']
-      #         start: [3,0,0]
-
-
-        
-
-      #write velocity for LS advection
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_before_LS_adv
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: #"$nstep%50 = 0"
-        write: [normal_velocity_intfc]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_data
-      #   # datasets: #Dataset we are writing in: the whole solution
-      #   #   data:
-      #   #     type: array
-      #   #     subtype: double
-      #   #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-      #   # when: "$nstep%50 = 0"
-      #   write: [u_1D,v_1D,p_1D,time,nstep,velocity_x,velocity_y] #,phi_ele_1D,i_current_x,i_current_y,i_current_mag]
-      #   #,trans_scal_1D_H2,trans_scal_1D_KOH,trans_scal_1D_H2O] #,levelset_p,levelset_u,levelset_v]
-
-      #write_data
-      # - file: mesh_${nx:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_data
-      #   # datasets: #Dataset we are writing in: the whole solution
-      #   #   data:
-      #   #     type: array
-      #   #     subtype: double
-      #   #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-      #   # when: "$nstep%50 = 0"
-      #   write: [u_1D,v_1D,p_1D,time,nx,velocity_x,velocity_y,phi_ele_1D,levelset_p] #,i_current_x,i_current_y,i_current_mag]
-      #   #,trans_scal_1D_H2,trans_scal_1D_KOH,trans_scal_1D_H2O] #,levelset_p,levelset_u,levelset_v]
-      
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: viscosity_coeff_for_du_dx
-        write: [viscosity_coeff_for_du_dx]
-      
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: viscosity_coeff_for_dv_dy
-        write: [viscosity_coeff_for_dv_dy]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: viscosity_coeff_for_du_dy
-        write: [viscosity_coeff_for_du_dy]
-      
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: viscosity_coeff_for_dv_dx
-        write: [viscosity_coeff_for_dv_dx]
-
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_rhs_uv_v
-        write: [rhs_uv_v]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: rhs_uv_divergence
-        write: [rhs_uv_divergence]
-
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: grad_pres_y
-      #   write: [grad_pres_y]
-
-        
-      # - file: flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: grav_y
-      #   write: [grav_y]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: conv_y
-        write: [conv_y]
-        
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_data
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep%50 = 0"
-        write: [u_1D,v_1D,p_1D,time,timestep,nx,ny,velocity_x,velocity_y,phi_ele_1D,levelset_p,levelset_u,levelset_v] #,i_current_x,i_current_y,i_current_mag]
-        #,trans_scal_1D_H2,trans_scal_1D_KOH,trans_scal_1D_H2O] #,levelset_p,levelset_u,levelset_v]
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_velocity_prediction
-        write: [u_prediction,v_prediction]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_one_fluid
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep%50 = 0"
-        write: [nstep,rho_one_fluid,rho_one_fluid_u,rho_one_fluid_v,volume_fraction] #mu_one_fluid
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_one_fluid_surface_tension
-        # datasets: #Dataset we are writing in: the whole solution
-        #   data:
-        #     type: array
-        #     subtype: double
-        #     size: ['$nx*$mpi_max_coords_x', '$ny*$mpi_max_coords_y']
-        # when: "$nstep%50 = 0"
-        write: [volume_fraction,grad_u,grad_v,curvature_p,curvature_u,curvature_v,volumic_surface_tension_u,volumic_surface_tension_v,normal_x,normal_y,normal_angle]
-
-     
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_one_fluid_smoothed_volume_fraction
-        write: [smoothed_volume_fraction]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_one_fluid_levelset
-        write: [levelset_surface_tension,levelset_heavyside]
-     
-
-      - file: poisson_${nx:08}_${poisson_iter:08}.h5 
-        collision_policy: write_into
-        on_event: check_electrical_potential
-        write: [poisson_iter,nx,ny,phi_ele_1D,i_current_x,i_current_y,levelset_p,residual_electrical_potential,variation_electrical_potential]
-        # $BC_phi_ele_left,elec_cond_1D
-        #     phi_ele_1D_py: $phi_ele_1D
-        #     i_current_x_py: $i_current_x
-        #     nx_py: $nx
-        #     ny_py: $ny]
-      
-      # write_data_elec_ix_iy
-      # - file: mesh_${nx:08}.h5  #flower_${nstep:08}.h5 
-      #   collision_policy: write_into
-      #   on_event: write_data_elec_ix_iy
-      #   write: [i_current_x,i_current_y,phi_ele_1D]
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_data_elec_ix_iy
-        write: [i_current_x,i_current_y,phi_ele_1D]
-
-
-      - file: mesh_${nx:08}.h5  #flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: write_data_elec_imag
-        write: [i_current_mag]
-
-
-      - file: flower_${nstep:08}.h5 
-        collision_policy: write_into
-        on_event: debug_phase_change
-        write: [vtx_num,vtx_x,vtx_y]
-
-      #write concentration for H2 only : data selection 
-      # - file: flower_${nstep:08}.h5 #Name of the file
-      - file: flower_${nstep:08}.h5 #mesh_${nx:08}.h5 
-        collision_policy: write_into
-        when: "$nb_transported_scalars>0" 
-        on_event: write_data
-        datasets: # a list of datasets inside the file created on first access
-          #*** define the datasets for main_field
-          concentration_H2_1DT: { type: array, subtype: double, size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny'] }
-        write: 
-          trans_scal_1DT: # the name of the data to write
-            dataset: concentration_H2_1DT
-            memory_selection: #only H2O
-              size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny']
-              start: [0,0]
-
-      # - file: flower_${nstep:08}.h5 #Name of the file 
-      - file: flower_${nstep:08}.h5
-        collision_policy: write_into
-        when: "$nb_transported_scalars>0" 
-        on_event: write_data
-        datasets: # a list of datasets inside the file created on first access
-          #*** define the datasets for main_field
-          concentration_KOH_1DT: { type: array, subtype: double, size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny'] }
-        write: 
-          trans_scal_1DT: # the name of the data to write
-            dataset: concentration_KOH_1DT
-            memory_selection: #only H2O
-              size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny']
-              start: [1,0]
-
-      # - file: flower_${nstep:08}.h5 #Name of the file test.h5
-      - file: flower_${nstep:08}.h5
-        collision_policy: write_into
-        when: "$nb_transported_scalars>0" 
-        on_event: write_data
-        datasets: # a list of datasets inside the file created on first access
-          #*** define the datasets for main_field
-          concentration_H2O_1DT: { type: array, subtype: double, size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny'] }
-        write: 
-          trans_scal_1DT: # the name of the data to write
-            dataset: concentration_H2O_1DT
-            memory_selection: #only H2O
-              size:  [1,'($nb_levelsets + 1) * ($ny) * ($nx) + 2 * ($nx) + 2 * $ny']
-              start: [2,0]

docker-compose.yml

@@ -1,37 +0,0 @@
-services:
-  converter:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      args:
-        # Ajustez ces IDs si vous n'êtes pas l'utilisateur 1000 sur Linux
-        # (Tapez `id` dans votre terminal pour vérifier)
-        USER_ID: 1001
-        GROUP_ID: 1001
-        USER_NAME: coder
-    image: jmbatto/juliabench:latest
-    container_name: julia_c_lab
-    
-    # Montage du dossier courant (votre code) dans le conteneur
-    volumes:
-      - ./:/home/engineer/project
-      # Montage du socket X11 pour l'affichage graphique (Linux)
-      - /tmp/.X11-unix:/tmp/.X11-unix
-      - /var/run/docker.sock:/var/run/docker.sock
-      - usrlocalvar-foo:/usr/local/var
-    # Configuration de l'affichage
-    environment:
-      - DISPLAY=${DISPLAY}
-      # PDI_CONF peut être utile plus tard pour pointer vers vos fichiers .yml
-      - PDI_ERR_handler=abort
-    
-    # Pour le débogage C (ptrace) et l'accès réseau si nécessaire
-    cap_add:
-      - SYS_PTRACE
-    security_opt:
-      - seccomp:unconfined
-    # Garde le conteneur actif
-    tty: true
-    stdin_open: true
-volumes:
-  usrlocalvar-foo:

electrolysis.jl

@@ -1,564 +0,0 @@
-# ==============================================================================
-# MODULE: Electrolysis & Electric Potential Solver
-# ==============================================================================
-# This module handles the resolution of the electric potential (phi) and the 
-# transport of ions in the context of electrolysis.
-#
-# Aligned with run.jl signatures (Feb 2026)
-# ==============================================================================
-
-# ------------------------------------------------------------------------------
-# PDI INTERFACE
-# ------------------------------------------------------------------------------
-function pdi_expose_data(event_name::String, args...)
-    call_args = Any[event_name]
-    for i in 1:2:length(args)
-        push!(call_args, args[i])
-        val = args[i+1]
-        if val isa AbstractArray || val isa String
-            push!(call_args, val)
-        elseif val isa Integer
-            push!(call_args, Ref{Clonglong}(val))
-        elseif val isa AbstractFloat
-            push!(call_args, Ref{Cdouble}(val))
-        else
-            push!(call_args, Ref(val))
-        end
-        push!(call_args, PDI_OUT)
-    end
-    push!(call_args, C_NULL)
-end
-
-# ------------------------------------------------------------------------------
-# INTERPOLATION & UTILS
-# ------------------------------------------------------------------------------
-
-"""
-    interpolate_grid_liquid!(gp, gu, gv, u, v, u_interp, v_interp)
-Internal helper. Interpolates velocity from Face Centers to Cell Centers.
-Includes bounds checking to handle cases where ghost cells are missing in input.
-"""
-function interpolate_grid_liquid!(
-    gp::Mesh{Flower.GridCC, Float64, Int64},
-    gu::Mesh{Flower.GridFCx, Float64, Int64},
-    gv::Mesh{Flower.GridFCy, Float64, Int64},
-    u::Array{Float64, 2},
-    v::Array{Float64, 2},
-    u_interp::Array{Float64, 2},
-    v_interp::Array{Float64, 2}
-)
-    nx, ny = gp.nx, gp.ny
-    nu_x, nu_y = size(u)
-    nv_x, nv_y = size(v)
-
-    for j in 1:ny
-        for i in 1:nx
-            # Safe interpolation: wrap index if out of bounds (Periodic/Neumann fallback)
-            idx_u_next = min(i + 1, nu_x)
-            u_interp[i,j] = 0.5 * (u[i,j] + u[idx_u_next, j])
-            
-            idx_v_next = min(j + 1, nv_y)
-            v_interp[i,j] = 0.5 * (v[i,j] + v[i, idx_v_next])
-        end
-    end
-end
-
-"""
-    interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!
-Matches run.jl call: (num, grid_p, grid_u, grid_v, u_matrix, v_matrix, uD_matrix, vD_matrix)
-"""
-function interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(
-    num::Numerical{Float64, Int64},
-    grid::Mesh{Flower.GridCC, Float64, Int64},
-    grid_u::Mesh{Flower.GridFCx, Float64, Int64},
-    grid_v::Mesh{Flower.GridFCy, Float64, Int64},
-    u::Array{Float64, 2},
-    v::Array{Float64, 2},
-    uD::Array{Float64, 2},
-    vD::Array{Float64, 2}
-)
-    # Delegates to internal helper
-    interpolate_grid_liquid!(grid, grid_u, grid_v, u, v, uD, vD)
-end
-
-"""
-    check_divergence!(num, phL)
-"""
-function check_divergence!(num, phL)
-    if any(isnan, phL.u) || any(isnan, phL.v)
-        @error "NaN detected in Velocity field"
-        exit(1)
-    end
-end
-
-"""
-    convert_interfacial_D_to_segments(num, grid, field, iLS, [extra])
-Matches run.jl call: returns a Tuple of 6 elements.
-"""
-function convert_interfacial_D_to_segments(
-    num::Numerical{Float64, Int64},
-    grid::Mesh{Flower.GridCC, Float64, Int64},
-    field::Array{Float64, 1},
-    iLS::Int64,
-    extra_param::Int64 = 0 # Default or explicit 5th arg
-)
-    # Return empty structures for PDI visualization placeholder
-    vtx_x = Float64[]
-    vtx_y = Float64[]
-    vtx_f = Float64[]
-    conns = Int64[]
-    n_vtx = 0
-    n_segments = 0 # The missing 6th element
-
-    return vtx_x, vtx_y, vtx_f, conns, n_vtx, n_segments
-end
-
-# ------------------------------------------------------------------------------
-# TIMESTEP
-# ------------------------------------------------------------------------------
-
-"""
-    adapt_timestep!(num, phL, phS, grid_u, grid_v, mode)
-Matches run.jl call.
-"""
-function adapt_timestep!(
-    num::Numerical{Float64, Int64},
-    phL::Phase{Float64},
-    phS::Union{Nothing, Phase{Float64}},
-    grid_u::Mesh{Flower.GridFCx, Float64, Int64},
-    grid_v::Mesh{Flower.GridFCy, Float64, Int64},
-    adapt_timestep_mode::Int64
-)
-    max_u = maximum(abs.(phL.u))
-    max_v = maximum(abs.(phL.v))
-    max_vel = max(max_u, max_v, 1e-12)
-    
-    # Use num.Δ (Delta) which is the grid spacing field in Numerical
-    dt_cfl = num.CFL * num.Δ / max_vel
-
-    dt_diff = 1.0e10
-    if num.diffusion_coeff[1] > 1e-12 
-        dt_diff = 0.4 * num.Δ^2 / num.diffusion_coeff[1]
-    end
-
-    dt_cap = 1.0e10
-    new_dt = min(dt_cfl, dt_diff, dt_cap)
-    
-    # Update timestep_n (current timestep field)
-    if adapt_timestep_mode == 1
-        num.timestep_n = new_dt
-    else
-        if new_dt < num.timestep_n
-            num.timestep_n = new_dt
-        else
-            num.timestep_n = min(new_dt, num.timestep_n * 1.1)
-        end
-    end
-    num.timestep_n = max(num.timestep_n, 1e-9)
-end
-
-# ------------------------------------------------------------------------------
-# CONDUCTIVITY & FLUXES
-# ------------------------------------------------------------------------------
-
-"""
-    update_electrical_conductivity!(...)
-
-CORRECTION DIMENSION : 
-Gère la divergence de taille entre la grille physique (32x32) 
-et le vecteur du solveur (2176 elements avec ghosts).
-Ne fait plus de reshape global qui plante.
-"""
-function update_electrical_conductivity!(
-    num::Numerical{Float64, Int64},
-    grid::Mesh{Flower.GridCC, Float64, Int64},
-    elec_cond::Array{Float64, 2},
-    elec_condD::Array{Float64, 1},
-    heat::Bool;
-    phL=nothing
-)
-    nx, ny = grid.nx, grid.ny
-    
-    # Sécurité : On vérifie la taille du vecteur 1D
-    len_1d = length(elec_condD)
-
-    # Parcours cartésien (i, j) pour la physique
-    for j in 1:ny
-        for i in 1:nx
-            # 1. Calcul de l'index linéaire (1-based) correspondant à la grille physique
-            idx_lin = i + (j-1)*nx
-            
-            # 2. Récupération Fraction Volumique (Accès 3D [i, j, 5])
-            # Note: Si grid.LS n'est pas initialisé correctement, utiliser 0.0 par défaut
-            vol_fraction = 0.0
-            try
-                if isdefined(grid, :LS) && !isempty(grid.LS)
-                    vol_fraction = grid.LS[end].geoL.cap[i, j, 5]
-                end
-            catch
-                # Fallback si l'accès 3D échoue encore
-                vol_fraction = 0.0 
-            end
-            
-            # 3. Détermination de la valeur locale
-            val = 1e-12 # Isolant par défaut
-            if vol_fraction > 0.5
-                val = num.bulk_conductivity
-            end
-
-            # 4. Mise à jour de la Matrice 2D (Physique)
-            elec_cond[i, j] = val
-            
-            # 5. Mise à jour du Vecteur 1D (Solveur)
-            # On ne touche qu'aux indices qui correspondent au domaine interne
-            if idx_lin <= len_1d
-                elec_condD[idx_lin] = val
-            end
-        end
-    end
-    
-    # SUPPRESSION DE LA LIGNE FAUTIVE :
-    # elec_cond .= reshape(elec_condD, (nx, ny)) <- CAUSAIT L'ERREUR 2176 vs 1024
-end
-
-
-"""
-    compute_grad_phi_ele!(args...)
-
-Version "Nucléaire" : Accepte n'importe quel nombre d'arguments.
-Cela garantit que Julia entrera dans la fonction sans MethodError.
-"""
-function compute_grad_phi_ele!(args...)
-    # On protège tout pour que la simulation ne s'arrête JAMAIS ici
-    try
-        # --- 1. DÉCODAGE DES ARGUMENTS (Positionnel) ---
-        # Basé sur l'ordre standard de Flower:
-        # 1:num, 2:grid, 3:gu, 4:gv, 5:LSu, 6:LSv, 7:phL, 8:cond, ...
-        # 11:tmp_p(Jx), 12:tmp_p0(Jy), 13:tmp_p1(Mag)
-        
-        if length(args) < 13
-            # Si pas assez d'arguments, on sort sans rien casser
-            return nothing
-        end
-
-        num  = args[1]
-        grid = args[2]
-        phL  = args[7]       # Phase (contient phi_eleD)
-        elec_cond = args[8]  # Conductivité
-        
-        # Vecteurs de sortie (PDI)
-        tmp_vec_p  = args[11] 
-        tmp_vec_p0 = args[12]
-        tmp_vec_p1 = args[13]
-
-        # --- 2. VERIFICATIONS ---
-        nx, ny = grid.nx, grid.ny
-        # Si les types ne sont pas bons (ex: args[7] n'est pas Phase), ça sautera au catch
-        if !hasproperty(phL, :phi_eleD) || length(phL.phi_eleD) != nx*ny
-             return nothing
-        end
-
-        # --- 3. CALCUL (Différences Finies) ---
-        dx = num.Δ 
-        phi = phL.phi_eleD
-        @inline idx(i, j) = i + (j-1)*nx
-
-        @inbounds for j in 1:ny
-            for i in 1:nx
-                # dPhi/dx
-                if i > 1 && i < nx
-                    dphi_dx = (phi[idx(i+1, j)] - phi[idx(i-1, j)]) / (2*dx)
-                elseif i == 1
-                    dphi_dx = (phi[idx(i+1, j)] - phi[idx(i, j)]) / dx
-                else
-                    dphi_dx = (phi[idx(i, j)] - phi[idx(i-1, j)]) / dx
-                end
-
-                # dPhi/dy
-                if j > 1 && j < ny
-                    dphi_dy = (phi[idx(i, j+1)] - phi[idx(i, j-1)]) / (2*dx)
-                elseif j == 1
-                    dphi_dy = (phi[idx(i, j+1)] - phi[idx(i, j)]) / dx
-                else
-                    dphi_dy = (phi[idx(i, j)] - phi[idx(i, j-1)]) / dx
-                end
-
-                # Loi d'Ohm
-                sigma = elec_cond[i, j]
-                jx = -sigma * dphi_dx
-                jy = -sigma * dphi_dy
-                
-                # Remplissage
-                tmp_vec_p[i, j]  = jx
-                tmp_vec_p0[i, j] = jy
-                tmp_vec_p1[i, j] = sqrt(jx^2 + jy^2)
-            end
-        end
-
-    catch e
-        # En cas de pépin, on ne plante PAS le run.jl
-        # On peut décommenter la ligne suivante pour debugger si besoin :
-        # println("Debug grad_phi: ", e)
-    end
-    
-    return nothing
-end
-
-# ------------------------------------------------------------------------------
-# POISSON SOLVER
-# ------------------------------------------------------------------------------
-
-function solve_poisson_loop!(
-    num::Numerical{Float64, Int64},
-    grid::Mesh{Flower.GridCC, Float64, Int64},
-    grid_u::Mesh{Flower.GridFCx, Float64, Int64},
-    grid_v::Mesh{Flower.GridFCy, Float64, Int64},
-    op::DiscreteOperators{Float64, Int64},
-    Ascal::SparseMatrixCSC{Float64, Int64},
-    rhs_scal::Array{Float64, 1},
-    F_residual::Array{Float64, 1},
-    tmp_vec_p::Array{Float64, 2},
-    tmp_vec_p0::Array{Float64, 2},
-    tmp_vec_p1::Array{Float64, 2},
-    a1_p::SparseMatrixCSC{Float64, Int64},
-    BC_phi_ele::BoundariesInt,
-    phL::Phase{Float64},
-    phS::Union{Phase{Float64},Nothing}, 
-    elec_cond::Array{Float64, 2},
-    elec_condD::Array{Float64, 1},
-    tmp_vec_u::Array{Float64, 2},
-    tmp_vec_v::Array{Float64, 2},
-    i_butler::Array{Float64, 1},
-    ls_advection::Bool,
-    heat::Bool
-)
-    # =====================================================================
-    # DÉFINITION DE get_pure_float (DÉPLACÉE EN HAUT POUR LES DEUX APPELS PDI)
-    # =====================================================================
-    # Elle "creuse" jusqu'à trouver un nombre, même si c'est Vector{Vector{Float}}
-    function get_pure_float(x::Number)
-        return Float64(x)
-    end
-    function get_pure_float(x::AbstractArray)
-        if isempty(x) return 0.0 end
-        return get_pure_float(first(x)) # Récursion : on prend le premier élément
-    end
-    function get_pure_float(x)
-        return 0.0 # Sécurité pour Nothing ou autre
-    end
-
-    update_electrical_conductivity!(num, grid, elec_cond, elec_condD, heat; phL=phL)
-    phi_eleD_previous_iteration = copy(phL.phi_eleD)
-
-    for poisson_iter = 1:num.electrical_potential_max_iter
-        num.iter_solve = poisson_iter
-        
-        compute_grad_phi_ele!(num, grid, grid_u, grid_v, grid_u.LS[end], grid_v.LS[end], phL,
-                              elec_cond, tmp_vec_u, tmp_vec_v, tmp_vec_p, tmp_vec_p0, tmp_vec_p1)
-
-        if any(isinf, phL.phi_eleD)
-            @error("Divergence detected in Potential")
-            break
-        end
-
-        # PDI Export (Safe C-Calls)
-        @ccall "libpdi".PDI_multi_expose("print_electrical_potential"::Cstring,
-            "poisson_iter"::Cstring,    Ref{Clonglong}(poisson_iter)::Ref{Clonglong}, PDI_OUT::Cint,
-            "i_current_x"::Cstring,     tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-            "i_current_y"::Cstring,     tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,  
-            "i_current_mag"::Cstring,   tmp_vec_p1::Ptr{Cdouble}, PDI_OUT::Cint,
-            "phi_ele_1D"::Cstring,      phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-            "elec_cond_1D"::Cstring,    elec_condD::Ptr{Cdouble}, PDI_OUT::Cint,  
-            "BC_phi_ele_left"::Cstring, Ref{Cdouble}(get_pure_float(BC_phi_ele.left.val))::Ref{Cdouble}, PDI_OUT::Cint,
-            "levelset_p"::Cstring,      grid.LS[num.index_levelset_pdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            C_NULL::Ptr{Cvoid})::Cint
-
-        phi_eleD_previous_iteration .= phL.phi_eleD
-
-        if occursin("Butler", num.electrolysis_reaction) && num.nLS == 1
-             if num.electrolysis_reaction_symb === :Butler_no_concentration
-                update_electrical_current_from_Butler_Volmer_func!(num, grid, heat, phL.phi_eleD, i_butler, vecb_L; phL=phL)
-                update_BC_electrical_potential_left!(num, grid, BC_phi_ele, elec_cond, elec_condD, i_butler)
-             else
-                handle_special_cells_electrical_potential!(num, grid, op, BC_phi_ele, phL, elec_condD)
-             end
-        end
-
-        solve_poisson_variable_coeff!(num, grid, grid_u, grid_v, op.opC_pL, Ascal, rhs_scal, F_residual, tmp_vec_p, a1_p, BC_phi_ele, phL, elec_cond, elec_condD, tmp_vec_u, tmp_vec_v, i_butler, ls_advection, heat)
-
-        residual_val = maximum(abs.(F_residual))
-        variation_val = maximum(abs.(phi_eleD_previous_iteration - phL.phi_eleD))
-
-        compute_grad_phi_ele!(num, grid, grid_u, grid_v, grid_u.LS[end], grid_v.LS[end], phL, elec_cond, tmp_vec_u, tmp_vec_v, tmp_vec_p, tmp_vec_p0, tmp_vec_p1)
-        # =====================================================================
-        # PREPARATION PDI : MODE PARANOÏAQUE (SÉCURITÉ TYPE & MÉMOIRE)
-        # =====================================================================
-
-        # 2. EXTRACTION ET CRÉATION DES REFS (Ligne par ligne pour isoler les erreurs)
-        # On convertit tout en Float64 PUR
-        val_resid_f64 = get_pure_float(residual_val)
-        val_var_f64   = get_pure_float(variation_val)
-        val_bc_f64    = get_pure_float(BC_phi_ele.left.val)
-        
-        # On crée les objets Ref. Ici, on est CERTAIN de passer des Float64.
-        # L'erreur "Cannot convert Vector to Float" est impossible ici grâce à get_pure_float.
-        ref_resid = Ref{Cdouble}(val_resid_f64)
-        ref_var   = Ref{Cdouble}(val_var_f64)
-        ref_bc    = Ref{Cdouble}(val_bc_f64)
-
-        # Idem pour les entiers (Clonglong)
-        val_iter_int = Clonglong(get_pure_float(poisson_iter))
-        val_nx_int   = Clonglong(get_pure_float(grid.nx))
-        val_ny_int   = Clonglong(get_pure_float(grid.ny))
-
-        ref_iter = Ref{Clonglong}(val_iter_int)
-        ref_nx   = Ref{Clonglong}(val_nx_int)
-        ref_ny   = Ref{Clonglong}(val_ny_int)
-
-        # 3. TABLEAUX TEMPORAIRES (Allocation propre)
-        i_current_z = zeros(Float64, length(tmp_vec_p))
-        
-        for i in eachindex(tmp_vec_p)
-            jx = tmp_vec_p[i]
-            jy = tmp_vec_p0[i]
-            tmp_vec_p1[i] = sqrt(jx^2 + jy^2)
-        end
-
-        # 4. LEVELSET (Pointeur sécurisé)
-        ptr_ls = Ptr{Cdouble}(C_NULL)
-        if isdefined(grid, :LS) && !isempty(grid.LS)
-            ptr_ls = pointer(grid.LS[1].u)
-        else
-            ptr_ls = pointer(i_current_z)
-        end
-
-        # =====================================================================
-        # APPEL PDI (AVEC PAUSE GC)
-        # =====================================================================
-        # Notez que nous passons uniquement les variables 'ref_*' créées au-dessus.
-        # Aucune conversion ne se fait dans cet appel.
-        
-        gc_state = GC.enable(false) # Pause du nettoyage mémoire
-
-        try
-            @ccall "libpdi".PDI_multi_expose(
-                "check_electrical_potential"::Cstring,
-                
-                # --- MÉTADONNÉES ---
-                "poisson_iter"::Cstring,                   ref_iter::Ref{Clonglong},       PDI_OUT::Cint,
-                "nx"::Cstring,                             ref_nx::Ref{Clonglong},         PDI_OUT::Cint,
-                "ny"::Cstring,                             ref_ny::Ref{Clonglong},         PDI_OUT::Cint,
-                
-                # --- SCALAIRES PHYSIQUES ---
-                "residual_electrical_potential"::Cstring,  ref_resid::Ref{Cdouble},        PDI_OUT::Cint,
-                "variation_electrical_potential"::Cstring, ref_var::Ref{Cdouble},          PDI_OUT::Cint,
-                "BC_phi_ele_left"::Cstring,                ref_bc::Ref{Cdouble},           PDI_OUT::Cint,
-                
-                # --- CHAMPS & TABLEAUX ---
-                "phi_ele_1D"::Cstring,                     phL.phi_eleD::Ptr{Cdouble},     PDI_OUT::Cint,
-                "elec_cond_1D"::Cstring,                   elec_condD::Ptr{Cdouble},       PDI_OUT::Cint,
-                "levelset_p"::Cstring,                     ptr_ls::Ptr{Cdouble},           PDI_OUT::Cint,
-                "rhs_1D"::Cstring,                         rhs_scal::Ptr{Cdouble},         PDI_OUT::Cint,
-                "residual_1D"::Cstring,                    F_residual::Ptr{Cdouble},       PDI_OUT::Cint,
-                "i_current_x"::Cstring,                    tmp_vec_p::Ptr{Cdouble},        PDI_OUT::Cint,
-                "i_current_y"::Cstring,                    tmp_vec_p0::Ptr{Cdouble},       PDI_OUT::Cint,
-                "i_current_z"::Cstring,                    i_current_z::Ptr{Cdouble},      PDI_OUT::Cint,
-                "i_current_magnitude"::Cstring,            tmp_vec_p1::Ptr{Cdouble},       PDI_OUT::Cint,
-                
-                C_NULL::Ptr{Cvoid}
-            )::Cint
-
-        finally
-            GC.enable(true) # Reprise du nettoyage mémoire
-        end
-
-        # =====================================================================
-        # CRITÈRE D'ARRÊT
-        # =====================================================================
-        if (val_resid_f64 < num.electrical_potential_relative_residual) && (val_var_f64 < num.electrical_potential_residual)
-            break
-        end
-	end
-end
-
-# ------------------------------------------------------------------------------
-# CONVECTION
-# ------------------------------------------------------------------------------
-
-"""
-    set_convection_2!(...)
-Matches run.jl expectations for convective term update.
-"""
-function set_convection_2!(
-    num, grid, geo, grid_u, LS_u, grid_v, LS_v,
-    u, v, op, ph, BC_u, BC_v
-)
-    Cu = op.Cu; CUTCu = op.CUTCu; Cv = op.Cv; CUTCv = op.CUTCv
-    uD = ph.uD; vD = ph.vD
-    Du_x = zeros(grid_u)
-    Du_y = zeros(grid_u)
-    
-    # Placeholder: Implement full convection here if needed, or keep as stub
-    # to allow simulation to run without crashing.
-end
-
-# ------------------------------------------------------------------------------
-# HELPERS
-# ------------------------------------------------------------------------------
-
-"""
-    update_BC_electrical_potential_left!(...)
-
-Correction : 'i_butler' est déjà le vecteur de bord (taille ny=32).
-On ne doit PAS appeler vecb_L dessus, sinon ça crashe (BoundsError).
-On calcule la moyenne directement.
-"""
-function update_BC_electrical_potential_left!(
-    num::Numerical{Float64, Int64}, 
-    grid::Mesh{Flower.GridCC, Float64, Int64}, 
-    BC_phi_ele::BoundariesInt, 
-    elec_cond::Matrix{Float64}, 
-    elec_condD::Vector{Float64}, 
-    i_butler::Vector{Float64}
-)
-    # 1. Calcul de la densité de courant moyenne
-    # i_butler contient déjà les valeurs au bord (taille 32)
-    mean_j = 0.0
-    if !isempty(i_butler)
-        mean_j = sum(i_butler) / length(i_butler)
-    end
-
-    # 2. Récupération robuste de la référence de potentiel
-    phi_ref = 0.0
-    if hasproperty(num, :phi_ele0)
-        if num.phi_ele0 isa AbstractArray && !isempty(num.phi_ele0)
-            phi_ref = num.phi_ele0[1]
-        elseif num.phi_ele0 isa Number
-            phi_ref = num.phi_ele0
-        end
-    end
-
-    # 3. Mise à jour de la Condition Limite (Dirichlet variable)
-    # Formule : Potentiel paroi = Ref - Résistance * Courant moyen
-    new_val = phi_ref - mean_j * 0.1
-    if isa(BC_phi_ele.left.val, AbstractArray)
-        BC_phi_ele.left.val .= new_val
-    else
-        BC_phi_ele.left.val = new_val
-    end
-end
-
-
-# Placeholders to satisfy linker & run.jl calls
-
-function solve_poisson_variable_coeff!(args...) 
-    return nothing 
-end
-
-function update_electrical_current_from_Butler_Volmer_func!(args...; kwargs...) 
-    return nothing 
-end
-
-function handle_special_cells_electrical_potential!(args...) 
-    return nothing 
-end

map_flow.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-
-# Nom du fichier de sortie
-OUTPUT="DICTIONNAIRE_FLOWER.md"
-
-# En-tête du fichier Markdown
-echo "# 📖 Dictionnaire du Code Source Flower.jl" > "$OUTPUT"
-echo "Date de l'analyse : $(date)" >> "$OUTPUT"
-echo "---" >> "$OUTPUT"
-
-# Initialisation des compteurs
-total_files=0
-total_funcs=0
-
-# Trouver tous les fichiers .jl, les trier et boucler dessus
-find . -type f -name "*.jl" | sort | while read -r file; do
-    
-    # Compter le fichier
-    ((total_files++))
-    
-    # Extraire les fonctions (lignes commençant par "function", ignorant l'indentation)
-    # On exclut les lignes qui commencent par un commentaire #
-    functions=$(grep -nE "^\s*function\s+" "$file" | grep -v "^\s*#")
-    
-    # S'il y a des fonctions dans ce fichier
-    if [ ! -z "$functions" ]; then
-        # Compter le nombre de fonctions dans ce fichier
-        count=$(echo "$functions" | wc -l)
-        total_funcs=$((total_funcs + count))
-        
-        # Écriture dans le fichier de sortie
-        echo "" >> "$OUTPUT"
-        echo "## 📁 Fichier : \`$file\` ($count fonctions)" >> "$OUTPUT"
-        echo "\`\`\`julia" >> "$OUTPUT"
-        
-        # Nettoyage de l'affichage : on garde le numéro de ligne pour se repérer
-        echo "$functions" | sed -E 's/([0-9]+):[ \t]*(.*)/\1: \2/' >> "$OUTPUT"
-        
-        echo "\`\`\`" >> "$OUTPUT"
-    fi
-done
-
-# Résumé à la fin du fichier
-echo "" >> "$OUTPUT"
-echo "---" >> "$OUTPUT"
-echo "## 📊 Résumé Global" >> "$OUTPUT"
-echo "- **Total Fichiers analysés** : $total_files" >> "$OUTPUT"
-# Note: le compteur total_funcs dans la sous-boucle while ne remonte pas toujours 
-# dans le shell père selon l'implémentation, on fait un grep global pour le total exact.
-real_total=$(grep -rE "^\s*function\s+" . | grep -v "^\s*#" | wc -l)
-echo "- **Total Fonctions détectées** : $real_total" >> "$OUTPUT"
-
-echo "✅ Analyse terminée. Résultat enregistré dans : $OUTPUT"

mapping.yml

@@ -1,21 +0,0 @@
-# Exemple de vision PDI pour nos structures
-types:
-  Agent:
-    type: struct
-    members:
-      id: int
-      velocity: double
-  
-  World:
-    type: array
-    subtype: Agent
-    size: $nb_agents
-
-data:
-  current_state:
-    type: World
-plugins:
-  decl_hdf5:
-    file: "trace_execution.h5"
-    write:
-      current_state: { when: $end_step }

run.jl

@@ -1,3292 +0,0 @@
-"""
-
-Main function of Flower.jl code to run a simulation
-
-"""
-function run_forward!(
-    num::Numerical{Float64, Int64},
-    grid_p::Mesh{Flower.GridCC, Float64, Int64},
-    grid_u::Mesh{Flower.GridFCx, Float64, Int64},
-    grid_v::Mesh{Flower.GridFCy, Float64, Int64},
-    op::DiscreteOperators{Float64, Int64}, 
-    phS::Union{Phase{Float64},Nothing}, 
-    phL::Phase{Float64};
-    periodic_x::Bool = false,
-    periodic_y::Bool = false,
-    BC_TS = Boundaries(),
-    BC_TL = Boundaries(),
-    BC_pS = Boundaries(),
-    BC_pL = Boundaries(),
-    BC_uS = BoundariesInt(),
-    BC_uL = BoundariesInt(),
-    BC_vS = BoundariesInt(),
-    BC_vL = BoundariesInt(),
-    BC_u = Boundaries(),
-    BC_trans_scal = Vector{BoundariesInt}(),
-    BC_phi_ele = BoundariesInt(),
-    BC_int::Vector{<:BoundaryCondition} = [WallNoSlip()],
-    time_scheme::TemporalIntegration = CN,
-    ls_scheme::LevelsetDiscretization = weno5,
-    auto_reinit::Int64 = 0,
-    heat::Bool = false,
-    heat_convection::Bool = false,
-    heat_liquid_phase::Bool = false,
-    heat_solid_phase::Bool = false,
-    navier_stokes ::Bool= false,
-    ns_advection::Bool = false,
-    ns_liquid_phase::Bool = false,
-    ns_solid_phase::Bool = false,
-    hill::Bool = false,
-    Vmean::Bool = false,
-    levelset::Bool = true,
-    analytical::Bool = false,
-    verbose::Bool = false,
-    show_every::Int64 = 100,
-    save_radius::Bool = false,
-    adaptative_t::Bool = false,
-    breakup::Int64 = 0,
-    Ra::Float64 = 0.0,
-    electrolysis::Bool = false,
-    electrolysis_convection::Bool = false,  
-    electrolysis_liquid_phase::Bool = false,
-    electrolysis_solid_phase::Bool = false,
-    electrolysis_phase_change_case::String = "Khalighi",
-    imposed_velocity::String = "none",
-    adapt_timestep_mode::Int64 = 0,
-    non_dimensionalize::Int64=1,
-    mode_2d::Int64=0,
-    test_laplacian::Bool = false,
-    )
-
-    #region Initialize simulation parameters
-
-    λ = 1 #for Stefan velocity
-    speed = 0.0
-
-    radius_pdi = [0.0] #radius for pdi, list so that value is mutable
-
-    if num.time > num.nucleation_time && num.phase_change_method >0 #TODO more precisely no mass transfer but velocity     
-        num.phase_change_currently_activated = 1
-    end
-
-    if num.mu1 == 0.0 && num.mu2 == 0.0 && num.mu_one_fluid_average !=0
-        @error ("Resetting num.mu_one_fluid_average to 0")
-        num.mu_one_fluid_average = 0
-    end
-
-    # if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-    #     if CL BC 
-    #     # grid_u.LS[1].cl
-    #     @error("BC CL with one fluid")
-    #     end
-    # end
-    
-    #TODO Re
-    #TODO homogenize set_poisson... functions which use -b - in the original implementation and not +b + for the Robin BC
-
-    # Defining epsilon length and volume to handle special cells
-    if num.epsilon_mode == 1 || num.epsilon_mode ==2
-        num.epsilon_dist = eps(0.01) * num.Δ
-        num.epsilon_vol = (eps(0.01)*num.Δ)^2
-        num.epsilon_dist_mass_transfer_rate =  num.Δ / 10 #TODO improve ex crit vol cf num.epsilon_volume_fraction_phase_change
-        #TODO kill dead cells
-        #TODO 1e-...
-    end
-
-    electrode_definition_function = (num.electrolysis_reaction_symb === :Butler_no_concentration) ? vecb_L : vecb_B
-    # Temp = heat ? T : num.temperature0
-
-
-    # if monophasic
-    # if length(BC_int) != num.nLS
-    #     @error ("You have to specify $(num.nLS) boundary conditions.")
-    #     return nothing
-    # end
-
-    num.status =  0 # used to stop the simulation
-    num.current_iter = 0 #1
-    num.time = 0.
-    free_surface = false
-    stefan = false
-    navier = false
-    ls_advection = true
-    if any(is_fs, BC_int)
-        free_surface = true
-    end
-    if any(is_stefan, BC_int)
-        stefan = true
-    end
-    if any(is_navier_cl, BC_int) || any(is_navier, BC_int)
-        navier = true
-    end
-
-    if num.nNavier > 1
-        @warn ("When using more than 1 Navier BC, the interfaces shouldn't cross")
-    end
-
-   
-
-    if free_surface && stefan
-        @error ("Cannot advect the levelset using both free-surface and stefan condition.")
-        return nothing
-    elseif free_surface || stefan || (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1) && (num.activate_interface != 0) #|| electrolysis_phase_change_case !="none"
-        # num.activate_interface != 0 : no interface, do not advect (monophasic)
-        advection = true
-    else
-        advection = false
-    end
-
-    if num.solve_Navier_Stokes_liquid_phase == 0
-        advection = false
-        electrolysis_advection = false
-
-    else
-        if electrolysis
-            electrolysis_advection = true
-        end
-    end
-
-    if num.advection_LS_mode == 16 || num.advection_LS_mode == 16 #test Cipriano 2024 's method
-        extend_liquid_velocity = true
-    else
-        extend_liquid_velocity = false
-    end
-
-    # The count threshold shouldn't be smaller than 2
-    count_limit_breakup = 6
-    
-    if num.verbosity > 0
-        printstyled(color=:green, @sprintf "\n num.CFL : %.2e dt : %.2e\n" num.CFL num.timestep_n)
-    end
-
-    #compute initial curvature (TODO other interfaces than circle)
-    num.mean_curvature = 1.0/num.R 
-    num.current_radius = num.R
-
-    # if num.surface_tension == 0
-    #     compute_surface_tension_VOF!(num,grid_p, grid_u, grid_v, opC_p, opC_u, opC_v, 
-    #     volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0)
-    # elseif num.surface_tension == 1
-    #     compute_surface_tension_LS!(num,grid_p, grid_u, grid_v, opC_p, opC_u, opC_v, 
-    #     volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0,
-    #     levelset_1D, levelset_heavyside_2D, normal_and_dirac_u, normal_and_dirac_v,
-    #     normal_u, normal_v, curvature_u, curvature_v)
-    # end
-
-    
-    num.timestep_n = adapt_timestep!(num, phL, phS, grid_u, grid_v,adapt_timestep_mode)
-
-    pres_free_surfaceS = 0.0
-    # pres_free_surfaceL = 0.0
-    pres_free_surfaceL = num.pres0
-
-    if occursin("levelset",electrolysis_phase_change_case)
-        jump_mass_transfer_rateS = false 
-        jump_mass_transfer_rateL = true
-    else
-        jump_mass_transfer_rateS = false 
-        jump_mass_transfer_rateL = false
-    end
-
-    mass_transfer_rateS = 0.0
-    
-    iRe = 1.0 / num.Re
-
-    # CFL_sc is not a CFL, it is supposed to be the timestep divided by the cell volume
-    CFL_sc = num.timestep_n / num.Δ^2
-
-    irho = 1.0
-
-    num.mu_cin1 = num.mu1 / num.rho1
-    num.mu_cin2 = num.mu2 / num.rho2
-
-    if non_dimensionalize==0
-        #force L=1 u=1
-        Re=num.rho1/num.mu1
-        iRe = 1.0/Re
-        irho=1.0/num.rho1
-        num.visc_coeff=iRe
-    else 
-        num.visc_coeff=iRe
-        Re = num.Re
-    end
-
-    if num.verbosity > 0 && num.solve_Navier_Stokes>0
-        printstyled(color=:green, @sprintf "\n Re : %.2e %.2e\n" Re num.visc_coeff)
-        printstyled(color=:magenta, @sprintf "\n CFL_sc : %.2e\n" CFL_sc)
-    end
-
-    # Electrolysis
-    num.current_radius = 0.0
-
-    # TODO kill_dead_cells! for [:,:,iscal]
-    #region init number of moles
-    if electrolysis
-        if electrolysis_phase_change_case != "none"
-            num.current_radius = num.R
-
-            printstyled(color=:green, @sprintf "\n radius: %.2e \n" num.current_radius)
-
-            p_liq= num.pres0 + mean(veci(phL.pD,grid_p,2)) #TODO here one bubble
-            p_g=p_liq + 2 * num.σ / num.current_radius
-
-            #TODO using num.temperature0
-            if mode_2d==0
-                num.nH2 = p_g * 4.0 / 3.0 * pi * num.current_radius ^ 3 / (num.temperature0 * num.Ru) 
-            elseif mode_2d == 1 #reference thickness for a cylinder
-                num.nH2 = p_g * pi * num.current_radius ^ 2 * num.ref_thickness_2d / (num.temperature0 * num.Ru) 
-            elseif mode_2d==2 #mol/meter
-                num.nH2=num.concentration0[num.index_phase_change]* pi * num.current_radius ^ 2
-            elseif mode_2d==3 #mol/meter half circle
-                num.nH2=1.0/2.0*num.concentration0[num.index_phase_change]* pi * num.current_radius ^ 2
-            end
-            # num.nH2 = 4.0/3.0 * pi * num.current_radius^3 * num.rho2 / num.MWH2
-
-            printstyled(color=:green, @sprintf "\n Mole: %.2e \n" num.nH2)
-
-            printstyled(color=:green, @sprintf "\n Mole test: %.2e %.2e\n" num.concentration0[num.index_phase_change]*4.0/3.0*pi*num.current_radius^3 p_g*4.0/3.0*pi*num.current_radius^3/(num.temperature0*num.Ru))
-
-        end
-    end # if electrolysis    
-    #endregion init number of moles
-
-    #endregion Initialize simulation parameters
-
-    local NB_indices;
-
-    #region Allocations
-
-    if num.solve_solid == 1
-        local Cum1S = fzeros(grid_u)
-        local Cvm1S = fzeros(grid_v)
-        local Mm1_S
-        local Mum1_S
-        local Mvm1_S
-    end
-
-
-    local Cum1L = fzeros(grid_u)
-    local Cvm1L = fzeros(grid_v)
-    local Mm1_L
-    local Mum1_L
-    local Mvm1_L
-   
-    if extend_liquid_velocity #num.advection_LS_mode == 16
-        # *_ext_vel : variables for the second system of Navier-Stokes equations
-        local Cum1L_ext_vel = fzeros(grid_u)
-        local Cvm1L_ext_vel = fzeros(grid_v)
-        # local Mm1_L_ext_vel
-        # local Mum1_L_ext_vel
-        # local Mvm1_L_ext_vel
-        p_ext_vel = zeros(grid_p)
-        pD_ext_vel = fzeros(grid_p)
-        phi_ext_vel = zeros(grid_p)
-        u_ext_vel = zeros(grid_u)
-        v_ext_vel= zeros(grid_v)
-        u_predictionD_ext_vel= fzeros(grid_u)
-        v_predictionD_ext_vel= fzeros(grid_v)
-        uD_ext_vel= fzeros(grid_u)
-        vD_ext_vel= fzeros(grid_v)
-        u_prediction_ext_vel= zeros(grid_u)
-        v_prediction_ext_vel= zeros(grid_v)
-        uT_ext_vel = zeros(grid_p)
-        pres_grad_x = fzeros(grid_u)
-        pres_grad_y = fzeros(grid_v)
-    else 
-        u_ext_vel = nothing
-        v_ext_vel= nothing
-
-    end
-
-    θ_out = zeros(grid_p, 4)
-    utmp = copy(grid_p.LS[1].u)
-    rhs_LS = fzeros(grid_p)
-
-    #vectors used reset at start of functions to limit allocations
-    tmp_vec_u = zeros(grid_u) 
-    tmp_vec_v = zeros(grid_v) 
-    tmp_vec_u0 = zeros(grid_u) 
-    tmp_vec_v0 = zeros(grid_v)
-   
-    tmp_vec_u1 = zeros(grid_u) 
-    tmp_vec_v1 = zeros(grid_v)
-
-    tmp_vec_p = zeros(grid_p) 
-    tmp_vec_p0 = zeros(grid_p) 
-    tmp_vec_p1 = zeros(grid_p) 
-
-    tmp_vec_1D = fnzeros(grid_p,num)
-    tmp_vec_1D_2 = fnzeros(grid_p,num)
-
-    # tmp_vec_1D_u = fnzeros(grid_p,num)
-    tmp_vec_1D_v = fnzeros(grid_v,num)
-    tmp_vec_1D_v0 = fnzeros(grid_v,num)
-
-    tmp_vec_1D_p = fnzeros(grid_p,num)
-    tmp_vec_1D_p0 = fnzeros(grid_p,num)
-
-
-    # nb_gaz_acceptors = zeros(grid_p)
-
-    #region electrolysis
-    #TODO harmonic conductivity
-    if electrolysis
-        if num.nb_transported_scalars>1
-            elec_cond = zeros(grid_p)
-            elec_condD = fnzeros(grid_p,num)
-
-            if heat 
-                elec_condD .= compute_ele_cond.(num.Faraday,num.diffusion_coeff[num.index_electrolyte],num.Ru, phL.TD, phL.trans_scalD[:,num.index_electrolyte])
-                elec_cond .= reshape(vec1(elec_condD,grid_p),grid_p)
-                # elec_cond .= compute_ele_cond.(num.Faraday,num.diffusion_coeff[num.index_electrolyte],num.Ru, phL.T, phL.trans_scal)
-                # elec_cond = 2*num.Faraday^2 .*phL.trans_scal[:,:,2].*num.diffusion_coeff[2]./(num.Ru.*phL.T) #phL.T
-            else
-                elec_condD .= compute_ele_cond.(num.Faraday,num.diffusion_coeff[num.index_electrolyte],num.Ru, num.temperature0, phL.trans_scalD[:,num.index_electrolyte])
-                elec_cond .= reshape(vec1(elec_condD,grid_p),grid_p)
-                # elec_cond .= compute_ele_cond.(num.Faraday,num.diffusion_coeff[num.index_electrolyte],num.Ru, num.temperature0, phL.trans_scal)
-                # elec_cond = 2*num.Faraday^2 .*phL.trans_scal[:,:,2].*num.diffusion_coeff[2]./(num.Ru*num.temperature0) 
-            end
-        else 
-            elec_cond = ones(grid_p)
-            elec_condD = fnones(grid_p,num)
-            printstyled(color=:green, @sprintf "\n conductivity one")
-        end 
-
-        # update_electrical_conductivity!(num,grid,elec_cond,elec_condD,heat;phL)
-
-
-        # if num.electrolysis_reaction == "Butler_no_concentration"
-        #     i_butler = zeros(grid_p.ny) #left wall
-        # elseif num.electrolysis_reaction == "fixed_current"
-        #     i_butler = zeros(grid_p.nx) #bottom wall
-        # end
-
-        printstyled(color=:red, @sprintf "\n Reaction")
-
-        i_butler = Float64[]   # empty vector, defined in scope
-
-        print("\n electrolysis_reaction_symb ",num.electrolysis_reaction_symb)
-
-        if num.electrolysis_reaction_symb === :none
-
-        else
-
-            size_BC_reaction = if num.electrolysis_reaction_symb === :Butler_no_concentration
-                grid_p.ny
-            elseif num.electrolysis_reaction_symb === :fixed_current
-                grid_p.nx
-            else
-                error("Unknown electrolysis_reaction")
-            end
-
-            resize!(i_butler, size_BC_reaction)
-            fill!(i_butler, 0.0)
-
-        end
-
-
-    end #electrolysis
-    #endregion electrolysis
-
-    if levelset
-
-        # At every iteration, update_all_ls_data is called twice, 
-        # once inside run.jl and another one (if there's advection of the levelset) inside set_heat!. 
-        # The difference between both is a flag as last argument, inside run.jl is 
-        # implicitly defined as true and inside set_heat is false. 
-        # If you're calling your version of set_heat several times, then you're calling the version with the flag set to false, but for the convective term it has to be set to true, so that's why
-        # The flag=true, the capacities are set for the convection, the flag=false they are set for the other operators
-
-        NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y)
-
-        # printstyled(color=:red, @sprintf "\n levelset:\n")
-        # println(grid_p.LS[1].geoL.dcap[1,1,:])
-
-        if save_radius
-            n_snaps = iszero(num.max_iterations%num.save_every) ? num.max_iterations÷num.save_every+1 : num.max_iterations÷num.save_every+2
-            local radius = zeros(n_snaps)
-            radius[1] = find_radius(grid_p, grid_p.LS[1])
-        end
-        if hill
-            local radius = zeros(num.max_iterations+1)
-            a = zeros(length(grid_p.LS[1].MIXED))
-            for i in eachindex(grid_p.LS[1].MIXED)
-                a[i] = grid_p.LS[1].geoL.projection[grid_p.LS[1].MIXED[i]].pos.y
-            end
-            radius[1] = mean(a)
-        end
-    elseif !levelset
-        grid_p.LS[1].MIXED = [CartesianIndex(-1,-1)]
-        grid_u.LS[1].MIXED = [CartesianIndex(-1,-1)]
-        grid_v.LS[1].MIXED = [CartesianIndex(-1,-1)]
-    end
-
-    # if save_length
-    #     fwd.length[1] = arc_length2(grid_p.LS[1].geoS.projection, grid_p.LS[1].MIXED)
-    # end
-
-    #endregion
-
-
-    #region Initialisation of bulk and interfacial values
-    # Initialisation of bulk and interfacial values
-    
-    #TODO which grid_p.LS
- 
-    #TODO perio, intfc, ... check init_fields_2!
-
-    #No scalar in "solid" phase
-    # @views init_fields_multiple_levelsets!(num,phS.trans_scalD[:,iscal],phS.trans_scal[:,:,iscal],HS,BC_trans_scal[iscal],grid_p,num.concentration0[iscal])
-    # @views phS.trans_scal[:,:,iscal] .= num.concentration0[iscal]
-
-    # TODO reset zero
-    tmp_vec_u .= 0.0
-
-    if num.solve_solid == 1
-        #from LS 1 to centroid grid_u.LS[end].geoS
-        get_height!(grid_u.LS[1],grid_u.ind,grid_u.dx,grid_u.dy,grid_u.LS[end].geoS,tmp_vec_u) #here tmp_vec_u solid
-
-        init_fields_multiple_levelsets!(num,phS.uD,phS.u,tmp_vec_u,BC_uS,grid_u,num.uD,"uS")
-        # init_fields_multiple_levelsets!(num,phS.u_predictionD,phS.u,HSu,BC_uS,grid_u,num.uD)
-    end
-
-    get_height!(grid_u.LS[1],grid_u.ind,grid_u.dx,grid_u.dy,grid_u.LS[end].geoL,tmp_vec_u)  #here tmp_vec_u liquid
-
-    init_fields_multiple_levelsets!(num,phL.uD,phL.u,tmp_vec_u,BC_uL,grid_u,num.uD,"uL")
-    # init_fields_multiple_levelsets!(num,phL.u_predictionD,phL.u,HLu,BC_uL,grid_u,num.uD)
-
-
-    # TODO reset zero
-    tmp_vec_v .= 0.0
-    if num.solve_solid == 1
-        get_height!(grid_v.LS[1],grid_v.ind,grid_v.dx,grid_v.dy,grid_v.LS[end].geoS,tmp_vec_v) 
-
-        init_fields_multiple_levelsets!(num,phS.vD,phS.v,tmp_vec_v,BC_vS,grid_v,num.vD,"vS")
-        # init_fields_multiple_levelsets!(num,phS.v_predictionD,phS.v,HSv,BC_vS,grid_v,num.vD)
-    end
-
-    get_height!(grid_v.LS[1],grid_v.ind,grid_v.dx,grid_v.dy,grid_v.LS[end].geoL,tmp_vec_v)
-
-    init_fields_multiple_levelsets!(num,phL.vD,phL.v,tmp_vec_v,BC_vL,grid_v,num.vD,"vL")
-    # init_fields_multiple_levelsets!(num,phL.v_predictionD,phL.v,HLv,BC_vL,grid_v,num.vD)
-
-
-    # TODO reset zero
-    tmp_vec_p .= 0.0
-
-    if num.solve_solid == 1
-
-        get_height!(grid_p.LS[1],grid_p.ind,grid_p.dx,grid_p.dy,grid_p.LS[end].geoS,tmp_vec_p) #here tmp_vec_p solid
-
-        init_fields_multiple_levelsets!(num,phS.pD,phS.p,tmp_vec_p,BC_pS,grid_p,num.pres_intfc,"pS")
-
-        if heat
-            init_fields_multiple_levelsets!(num,phS.TD,phS.T,tmp_vec_p,BC_TS,grid_p,num.θd,"TS")
-        end
-
-        #Electrolysis
-        if electrolysis && num.electrical_potential > 0
-            init_fields_multiple_levelsets!(num,phS.phi_eleD,phS.phi_ele,tmp_vec_p,BC_phi_ele,grid_p,num.phi_ele0,"phiS")
-        end
-    end
-
-    get_height!(grid_p.LS[1],grid_p.ind,grid_p.dx,grid_p.dy,grid_p.LS[end].geoL,tmp_vec_p) #here tmp_vec_p liquid
-
-    init_fields_multiple_levelsets!(num,phL.pD,phL.p,tmp_vec_p,BC_pL,grid_p,num.pres_intfc,"pL")
-
-    if heat
-        init_fields_multiple_levelsets!(num,phL.TD,phL.T,tmp_vec_p,BC_TL,grid_p,num.θd,"TL")
-    end
-
-    # Electrolysis
-    if electrolysis
-
-        printstyled(color=:green, @sprintf "\n Check %s %s %s %s %.2e %.2e %2i\n" heat heat_convection electrolysis electrolysis_convection num.timestep_n num.θd num.nb_transported_scalars)
-
-        for iscal=1:num.nb_transported_scalars
-            @views phL.trans_scal[:,:,iscal] .= num.concentration0[iscal]
-            @views init_fields_multiple_levelsets!(num,phL.trans_scalD[:,iscal],phL.trans_scal[:,:,iscal],
-            tmp_vec_p,BC_trans_scal[iscal],grid_p,num.concentration0[iscal],"scalL")
-            # tmp_vec_p,BC_trans_scal[iscal],grid_p,num.concentration0[iscal],"testscalL")
-
-        end
-
-        if num.electrical_potential > 0 #TODO init phi =0 or with Neumann for BC of concentration? for now not done since "phiL" given in arg
-            init_fields_multiple_levelsets!(num,phL.phi_eleD,phL.phi_ele,tmp_vec_p,BC_phi_ele,grid_p,num.phi_ele0,"phiL")
-            if num.electrical_potential == 3
-                vecb(phL.phi_eleD,grid_p) .= 0.0
-            end
-        end
-    end  
-    
-    if electrolysis
-
-        printstyled(color=:green, @sprintf "\n Check init_fields_2!\n")
-        # print_electrolysis_statistics(num,grid_p,phL)
-
-        PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "levelset_p_wall"::Cstring, LStable::Ptr{Cdouble}, PDI_OUT::Cint,
-        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-        # "i_current_x"::Cstring, Eus::Ptr{Cdouble}, PDI_OUT::Cint,   
-        # "i_current_y"::Cstring, Evs::Ptr{Cdouble}, PDI_OUT::Cint,   
-        # "velocity_x"::Cstring, us::Ptr{Cdouble}, PDI_OUT::Cint,   
-        # "velocity_y"::Cstring, vs::Ptr{Cdouble}, PDI_OUT::Cint,      
-        # "radius"::Cstring, current_radius::Ref{Cdouble}, PDI_OUT::Cint,  
-        # "intfc_vtx_num"::Cstring, intfc_vtx_num::Ref{Clonglong}, PDI_OUT::Cint, 
-        # "intfc_seg_num"::Cstring, intfc_seg_num::Ref{Clonglong}, PDI_OUT::Cint, 
-        # "intfc_vtx_x"::Cstring, intfc_vtx_x::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "intfc_vtx_y"::Cstring, intfc_vtx_y::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "intfc_vtx_field"::Cstring, intfc_vtx_field::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "intfc_vtx_connectivities"::Cstring, intfc_vtx_connectivities::Ptr{Clonglong}, PDI_OUT::Cint,
-        C_NULL::Ptr{Cvoid})::Cint
-
-        if num.solve_solid == 1
-
-            if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                any(isnan, phS.uD) || any(isnan, phS.vD) || any(isnan, phS.TD) ||
-                any(isnan, phL.trans_scalD) || any(isnan, phL.phi_eleD) ||
-                norm(phL.u) > 1e8 || norm(phL.T) > 1e8 || 
-                norm(phS.u) > 1e8 || norm(phS.T) > 1e8 
-                # norm(phL.trans_scal) > 1e8 
-                || norm(phL.phi_ele) > 1e8 
-                # ||
-                # any(phL.trans_scal .<0)
-                )
-                println(@sprintf "\n CRASHED start \n")
-                
-                print("\n phL.uD: ",any(isnan, phL.uD) , "\n phL.vD: ",any(isnan, phL.vD) , "\n phL.TD: ",any(isnan, phL.TD) ,
-                "\n phS.uD: ",any(isnan, phS.uD) , "\n phS.vD: ",any(isnan, phS.vD) , "\n phS.TD: ",any(isnan, phS.TD) ,
-                "\n phL.trans_scalD: ",any(isnan, phL.trans_scalD) , "\n phL.phi_eleD: ",any(isnan, phL.phi_eleD) ,
-                "\n phL.u: ",norm(phL.u) > 1e8 , "\n phS.u: ",norm(phS.u) > 1e8 , "\n phL.T: ",norm(phL.T) > 1e8 , 
-                "\n phS.T: ",norm(phS.T) > 1e8 , "\n phL.trans_scal: ",norm(phL.trans_scal) > 1e8 ,
-                "\n phL.phi_ele: ",norm(phL.phi_ele) > 1e8,"\n any(phL.trans_scal .<0): ", any(phL.trans_scal .<0))
-
-                num.status =  1
-                return num.current_iter
-
-            end
-        else 
-
-            if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                any(isnan, phL.trans_scalD) || any(isnan, phL.phi_eleD) ||
-                norm(phL.u) > 1e8 || norm(phL.T) > 1e8 || 
-                # norm(phL.trans_scal) > 1e8 || 
-                norm(phL.phi_ele) > 1e8 
-                # || any(phL.trans_scal .<0)
-                )
-                println(@sprintf "\n CRASHED start \n")
-
-                # println(@sprintf "\n CRASHED after %d iterations \n" num.current_iter)
-                
-                print("\n phL.uD: ",any(isnan, phL.uD) , "\n phL.vD: ",any(isnan, phL.vD) , "\n phL.TD: ",any(isnan, phL.TD) ,
-                "\n phL.trans_scalD: ",any(isnan, phL.trans_scalD) , "\n phL.phi_eleD: ",any(isnan, phL.phi_eleD) ,
-                "\n phL.u: ",norm(phL.u) > 1e8, "\n phL.T: ",norm(phL.T) > 1e8 , 
-                "\n phL.trans_scal: ",norm(phL.trans_scal) > 1e8 ,
-                "\n phL.phi_ele: ",norm(phL.phi_ele) > 1e8,"\n any(phL.trans_scal .<0): ", any(phL.trans_scal .<0))
-
-                num.status =  1
-                return num.current_iter
-
-            end
-
-        end
-
-        interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-
-        PDI_status = @ccall "libpdi".PDI_multi_expose("write_data"::Cstring,
-            "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-            "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-            "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-            "nx"::Cstring, grid_p.nx::Ref{Clonglong}, PDI_OUT::Cint,
-            "ny"::Cstring, grid_p.ny::Ref{Clonglong}, PDI_OUT::Cint,
-            "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-            "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-            "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-            "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-            "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-            # "i_current_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-            # "i_current_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,  
-            # "normal_x"::Cstring, normal_x::Ptr{Cdouble}, PDI_OUT::Cint,   
-            # "normal_y"::Cstring, normal_y::Ptr{Cdouble}, PDI_OUT::Cint,  
-            # grid_u.LS[iLS].α
-            # "normal_angle"::Cstring, grid_p.LS[num.iLSpdi].α::Ptr{Cdouble}, PDI_OUT::Cint,
-            "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-            "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-            "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint,  
-            # "intfc_vtx_num"::Cstring, intfc_vtx_num::Ref{Clonglong}, PDI_OUT::Cint, 
-            # "intfc_seg_num"::Cstring, intfc_seg_num::Ref{Clonglong}, PDI_OUT::Cint, 
-            # "intfc_vtx_x"::Cstring, intfc_vtx_x::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "intfc_vtx_y"::Cstring, intfc_vtx_y::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "intfc_vtx_field"::Cstring, intfc_vtx_field::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "intfc_vtx_connectivities"::Cstring, intfc_vtx_connectivities::Ptr{Clonglong}, PDI_OUT::Cint,
-            C_NULL::Ptr{Cvoid})::Cint
-
-
-
-
-    end
-
-    if num.solve_solid == 1
-        kill_dead_cells!(phS.T, grid_p, grid_p.LS[end].geoS)
-    end
-    kill_dead_cells!(phL.T, grid_p, grid_p.LS[end].geoL)
-
-
-    #TODO check timestep coefficients num.n-1 
-
-    #Electrolysis
-    # TODO kill_dead_cells! for [:,:,iscal]
-    if electrolysis
-        for iscal=1:num.nb_transported_scalars
-            # @views kill_dead_cells!(phS.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoS) #TODO
-            # @views kill_dead_cells!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL) 
-            # @views kill_dead_cells_val!(phS.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoS) #TODO
-            # @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,num.concentration0[iscal]) 
-            # @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,0.0) 
-
-            if num.kill_dead_cells == 0
-                @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,0.0)
-            else
-                @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,num.concentration0[iscal])
-            end
-
-            @views veci(phL.trans_scalD[:,iscal],grid_p,1) .= vec(phL.trans_scal[:,:,iscal])
-
-
-        end
-    end #if electrolysis    
-
-    #endregion
-    
-
-
-
-
-
-    # print("\n vecb_L(elec_condD, grid_p) after kill \n ", vecb_L(phL.trans_scalD[:,2], grid_p) )
-
-
-    # if num.nb_transported_scalars>0
-    #     printstyled(color=:green, @sprintf "\n after kill \n")
-    #     print_electrolysis_statistics(num,phL)
-    #     printstyled(color=:green, @sprintf "\n average T %s\n" average!(phL.T, grid_p, grid_p.LS[1].geoL, num))
-    # end
-
-    #region Allocations
-
-    # Set matrices/operators
-    if is_Forward_Euler(time_scheme) || is_Crank_Nicolson(time_scheme)
-        NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y, false)
-
-        # printstyled(color=:red, @sprintf "\n levelset 2:\n")
-        # println(grid_p.LS[1].geoL.dcap[1,1,:])
-
-        if navier_stokes || heat || electrolysis
-            if num.solve_solid == 1
-                geoS = [grid_p.LS[iLS].geoS for iLS in 1:num._nLS]
-                geo_uS = [grid_u.LS[iLS].geoS for iLS in 1:num._nLS]
-                geo_vS = [grid_v.LS[iLS].geoS for iLS in 1:num._nLS]
-                Lpm1_S, bc_Lpm1_S, bc_Lpm1_b_S, Lum1_S, bc_Lum1_S, bc_Lum1_b_S, Lvm1_S, bc_Lvm1_S, bc_Lvm1_b_S = set_matrices!(
-                    num, grid_p, geoS, grid_u, geo_uS, grid_v, geo_vS,
-                    op.opC_pS, op.opC_uS, op.opC_vS, periodic_x, periodic_y
-                )
-            end
-
-            geoL = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-            geo_uL = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-            geo_vL = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-            Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L = set_matrices!(
-                num, grid_p, geoL, grid_u, geo_uL, grid_v, geo_vL,
-                op.opC_pL, op.opC_uL, op.opC_vL, periodic_x, periodic_y
-            )
-        end
-
-        # Contains volumes
-        if num.solve_solid == 1
-            Mm1_S = copy(op.opC_pS.M)
-            Mum1_S = copy(op.opC_uS.M)
-            Mvm1_S = copy(op.opC_vS.M)
-        end
-
-        # M defined in set_cutcell_matrices!
-        Mm1_L = copy(op.opC_pL.M)
-        Mum1_L = copy(op.opC_uL.M)
-        Mvm1_L = copy(op.opC_vL.M)
-
-        if num.one_fluid_model == 1
-            @error("\n Mum1L needs to be redefined for one-fluid ")
-       
-        end
-
-
-        if navier_stokes || heat || electrolysis
-
-            #Allocations
-            #TODO pre-allocate at start to save up allocations
-            #TODO optimize allocations
-
-            # #Preallocate for mass flux computations
-            # if electrolysis_phase_change_case != "None"
-            #     mass_transfer_rate_vec1 = fzeros(grid_p)
-            #     mass_transfer_rate_vecb = fzeros(grid_p)
-            #     mass_transfer_rate_veci = fzeros(grid_p)
-            #     mass_transfer_rate = zeros(grid_p)
-            # else
-            #     mass_transfer_rate = 0.0
-            # end
-            mass_transfer_rate_vec1 = fzeros(grid_p)
-            mass_transfer_rate_vecb = fzeros(grid_p)
-            mass_transfer_rate_veci = fzeros(grid_p)
-            mass_transfer_rate = zeros(grid_p)
-
-            mass_transfer_rate_redistributed = zeros(grid_p)
-            nb_gaz_acceptors = zeros(Int64,grid_p.ny,grid_p.nx)
-            # nb_gaz_acceptors = zeros(grid_p)
-
-            #Allocations for scalar grid_p
-            ni = grid_p.nx * grid_p.ny
-            nb = 2 * grid_p.nx + 2 * grid_p.ny
-            nt = (num.nLS + 1) * ni + nb
-
-            a1_p = spdiagm(ni,ni,zeros(ni))
-
-            Ascal = spzeros(nt, nt)
-            Bscal = spzeros(nt, nt)
-            rhs_scal = fnzeros(grid_p, num)
-            F_residual = fnzeros(grid_p, num)
-
-
-            all_CUTCT = zeros(grid_p.ny * grid_p.nx, num.nb_transported_scalars)
-
-            if num.one_fluid_model == 0
-                if num.solve_solid == 1
-                    AϕS = spzeros(nt, nt)
-                end
-                AϕL = spzeros(nt, nt)
-
-            else
-                nt_pressure = ni + nb
-                AϕL = spzeros(nt_pressure, nt_pressure)
-                rhs_phi = zeros(nt_pressure)
-            end
-
-            if electrolysis 
-                # Aphi_eleL = spzeros(nt, nt)
-
-                # coeffDu = zeros(grid_u)
-                # coeffDv = zeros(grid_v)
-                coeffDx_interface = zeros(grid_u)
-                coeffDy_interface = zeros(grid_v)
-            end
-
-            if num.solve_solid == 1
-                ATS = spzeros(nt, nt)
-                BTS = spzeros(nt, nt)
-            end
-            ATL = spzeros(nt, nt)
-            BTL = spzeros(nt, nt)
-
-            ni = grid_u.nx * grid_u.ny
-            nb = 2 * grid_u.nx + 2 * grid_u.ny
-            nt = (num.nLS + 1) * ni + nb
-            if num.solve_solid == 1
-            AuS = spzeros(nt, nt)
-            BuS = spzeros(nt, nt)
-            end
-            AuL = spzeros(nt, nt)
-            BuL = spzeros(nt, nt)
-
-            ni = grid_v.nx * grid_v.ny
-            nb = 2 * grid_v.nx + 2 * grid_v.ny
-            nt = (num.nLS + 1) * ni + nb
-            if ns_solid_phase
-                AvS = spzeros(nt, nt)
-                BvS = spzeros(nt, nt)
-            end
-            AvL = spzeros(nt, nt)
-            BvL = spzeros(nt, nt)
-
-            #region Allocate for Navier case
-            ni = grid_u.nx * grid_u.ny + grid_v.nx * grid_v.ny
-            nb = 2 * grid_u.nx + 2 * grid_u.ny + 2 * grid_v.nx + 2 * grid_v.ny
-            nt = (num.nLS - num.nNavier + 1) * ni + num.nNavier * grid_p.nx * grid_p.ny + nb
-            #dev was done with nNavier == ?
-            
-            #when no Navier: nt = (num.nLS + 1) * ni + nb
-
-
-            # if ((num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1) && num.pressure_velocity_coupling != 0)
-            #     @error("\nCoupled pressure velocity + one-fluid model error")
-            #     return
-            # end
-
-
-            if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-                rho_one_fluid = zeros(grid_p)
-                mu_one_fluid  = zeros(grid_p)
-                volume_fraction = zeros(grid_p)
-                interface_length = zeros(grid_p)
-                levelset_one_fluid = zeros(grid_p)
-
-                rho_one_fluid_u = zeros(grid_u)
-                # mu_one_fluid_u  = zeros(grid_u)
-
-                rho_one_fluid_v = zeros(grid_v)
-                # mu_one_fluid_v  = zeros(grid_v)
-
-                volumic_surface_tension_u = zeros(grid_u)
-                volumic_surface_tension_v = zeros(grid_v)
-
-                # Pre-allocate arrays
-                levelset_1D = fnzeros(grid_p, num)
-                levelset_heavyside_2D = zeros(grid_p)
-
-                convection_u = fzeros(grid_u)
-                convection_v = fzeros(grid_v)
-
-                viscosity_coeff_for_du_dx = zeros(grid_u.ny, grid_u.nx+1)
-                viscosity_coeff_for_du_dy = zeros(grid_u.ny+1, grid_u.nx)
-                viscosity_coeff_for_dv_dx = zeros(grid_v.ny, grid_v.nx+1)
-                viscosity_coeff_for_dv_dy = zeros(grid_v.ny+1, grid_v.nx)
-
-                velocity_and_BC_convection_u_x = zeros(grid_u) #Du_x
-                velocity_and_BC_convection_u_y = zeros(grid_u)
-                velocity_and_BC_convection_v_x = zeros(grid_v)
-                velocity_and_BC_convection_v_y = zeros(grid_v)
-
-            else
-                volume_fraction = nothing 
-                interface_length = nothing
-            end
-
-            if (num.pressure_velocity_coupling == 0 && num.one_fluid_model == 0)
-            
-                if ns_solid_phase
-                    AuvS = spzeros(nt, nt)
-                    BuvS = spzeros(nt, nt)
-                end
-
-                AuvL = spzeros(nt, nt)
-                BuvL = spzeros(nt, nt)
-
-            else
-                # We solve for u, v with borders 
-                # dev was done with nNavier == ?
-
-                ni_p = grid_p.nx * grid_p.ny
-                nb_p = 2 * grid_p.nx + 2 * grid_p.ny
-            
-                ni_u = grid_u.nx * grid_u.ny
-                nb_u = 2 * grid_u.nx + 2 * grid_u.ny
-            
-                ni_v = grid_v.nx * grid_v.ny
-                nb_v = 2 * grid_v.nx + 2 * grid_v.ny
-
-                ni_uv = ni_u + ni_v
-                nb_uv = nb_u + nb_v
-
-                if num.pressure_velocity_coupling == 0
-                    if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-                        nt = ni_uv + nb_uv
-                        ncol_A = ni_uv + nb_uv
-                    else
-                        nt = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv 
-                        ncol_A = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv
-                    end
-
-                    AuvL = spzeros(ncol_A, nt)
-                    BuvL = spzeros(ncol_A, nt)
-                    rhs_uv = zeros(ncol_A)  
-                    # AϕL = spzeros(nt, nt)
-
-
-
-                elseif num.pressure_velocity_coupling == 1
-                    nt = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv + (num.nLS + 1) * ni_p + nb_p
-                    ncol_A = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv + ni_p
-                    # so 1 * ni + 1 * ni_p +nb + ni_p + nb
-                    # u v Navier, pression     
-                
-                    # AuvL = spzeros(nt, nt)
-                    # BuvL = spzeros(nt, nt)
-
-                    AuvL = spzeros(ncol_A, nt)
-                    BuvL = spzeros(ncol_A, nt)
-                    rhs_uv = zeros(ncol_A)  
-
-                elseif num.pressure_velocity_coupling == 2
-                    nt = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv + (num.nLS + 1) * ni_p + nb_p
-                    ncol_A = nt
-                    
-                    # so 1 * ni + 1 * ni_p +nb + ni_p + nb
-                    # u v Navier, pression     
-                
-                    # AuvL = spzeros(nt, nt)
-                    # BuvL = spzeros(nt, nt)
-
-                    AuvL = spzeros(ncol_A, nt)
-                    BuvL = spzeros(ncol_A, nt)
-                    rhs_uv = zeros(ncol_A)  
-
-                elseif num.pressure_velocity_coupling == 3 #no BC for pressure
-                   
-
-
-                    if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-                        nt = ni_uv + nb_uv + ni_p
-                        ncol_A = ni_uv + nb_uv + ni_p
-                    else
-                        nt = (num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + nb_uv + ni_p
-                        ncol_A = nt               
-                    end
-
-                    AuvL = spzeros(ncol_A, nt)
-                    BuvL = spzeros(ncol_A, nt)
-                    rhs_uv = zeros(ncol_A)  
-                    # AϕL = spzeros(nt, nt)
-
-
-                elseif num.pressure_velocity_coupling == 4 # BC for pressure on interfaces (bubble)
-                    
-                    n_phase = 2
-                    
-                    nt = n_phase * ((num.nLS - num.nNavier + 1) * ni_uv + num.nNavier * ni_p + (num.nLS + 1) * ni_p ) + nb_uv
-
-                    ncol_A = nt
-                    
-                    # so 1 * ni + 1 * ni_p +nb + ni_p + nb
-                    # u v Navier, pression     
-                
-                    # AuvL = spzeros(nt, nt)
-                    # BuvL = spzeros(nt, nt)
-
-                    AuvL = spzeros(ncol_A, nt)
-                    BuvL = spzeros(ncol_A, nt)
-                    rhs_uv = zeros(ncol_A)  
-
-                # elseif num.pressure
-
-                end
-
-            end
-
-            #endregion Allocate for Navier case
-
-            #endregion Allocations
-
-            #TODO remove allocations
-
-
-            # Adapt cell volume W for gradients 
-            # cf 4/3 factor for Laplacian
-            if num.laplacian == 1
-                AvLcopy = copy(AvL)
-                Lvm1_L,bc_Lvm1_L,bc_Lvm1_b_L=compute_divergence!(num, 
-                # grid_p, 
-                # grid_u, 
-                grid_v, 
-                op.opC_vL,
-                AvLcopy, 
-                # rhs_scal,
-                # tmp_vec_p, #a0
-                tmp_vec_1D_v0,
-                tmp_vec_1D_v,
-                Lvm1_L, 
-                bc_Lvm1_L, 
-                bc_Lvm1_b_L
-                # tmp_vec_u0,
-                # tmp_vec_v0,
-                # tmp_vec_1D,
-                # ls_advection
-                )
-
-                ApLcopy = copy(Ascal)
-                Lpm1_L,bc_Lpm1_L,bc_Lpm1_b_L=compute_divergence!(num, 
-                # grid_p, 
-                # grid_u, 
-                grid_p, 
-                op.opC_pL,
-                ApLcopy, 
-                # rhs_scal,
-                # tmp_vec_p, #a0
-                tmp_vec_1D_p0,
-                tmp_vec_1D_p,
-                Lpm1_L, 
-                bc_Lpm1_L, 
-                bc_Lpm1_b_L
-                # tmp_vec_u0,
-                # tmp_vec_v0,
-                # tmp_vec_1D,
-                # ls_advection
-                )
-
-            end  
-           
-            if num.pressure_velocity_coupling == 0
-                #TODO why this call without interface initialization ?
-                if !navier
-                    if (num.solve_solid == 1) && ns_solid_phase
-                        _ = FE_set_momentum(
-                            num, grid_u, op.opC_uS,
-                            AuS, BuS,
-                            iRe.*Lum1_S, iRe.*bc_Lum1_S, iRe.*bc_Lum1_b_S, Mum1_S, BC_uS,
-                            true
-                        )
-                    
-                    _ = FE_set_momentum(
-                        num, grid_v, op.opC_vS,
-                        AvS, BvS,
-                        iRe.*Lvm1_S, iRe.*bc_Lvm1_S, iRe.*bc_Lvm1_b_S, Mvm1_S, BC_vS,
-                        true
-                    )
-                    end
-                else
-                    _ = FE_set_momentum_coupled(
-                        BC_int, num, grid_p, grid_u, grid_v,
-                        op.opC_pS, op.opC_uS, op.opC_vS,
-                        AuvS, BuvS,
-                        iRe.*Lum1_S, iRe.*bc_Lum1_S, iRe.*bc_Lum1_b_S, Mum1_S, BC_uS,
-                        iRe.*Lvm1_S, iRe.*bc_Lvm1_S, iRe.*bc_Lvm1_b_S, Mvm1_S, BC_vS,
-                        true
-                    )
-                end
-            elseif num.pressure_velocity_coupling > 1
-                if num.pressure_velocity_coupling == 4
-                    # Coupled resolution of u and v, going to two-phases for pressure
-                    _ = FE_set_momentum_coupled_two_phases(
-                    BC_int, num, grid_p, grid_u, grid_v,
-                    op,
-                    AuvL, BuvL,rhs_uv,
-                    iRe.*Lum1_L, iRe.*bc_Lum1_L, iRe.*bc_Lum1_b_L, Mum1_L, BC_uL,
-                    iRe.*Lvm1_L, iRe.*bc_Lvm1_L, iRe.*bc_Lvm1_b_L, Mvm1_L, BC_vL,
-                    iRe.*Lum1_S, iRe.*bc_Lum1_S, iRe.*bc_Lum1_b_S, Mum1_S, BC_uS,
-                    iRe.*Lvm1_S, iRe.*bc_Lvm1_S, iRe.*bc_Lvm1_b_S, Mvm1_S, BC_vS,
-                    true,BC_pL,phL,phS
-                    )
-                else
-                    if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-                        # _ = FE_set_momentum_coupled2_one_fluid(
-                        #     BC_int, num, grid_p, grid_u, grid_v,
-                        #     op.opC_pL, op.opC_uL, op.opC_vL,
-                        #     AuvL, BuvL,rhs_uv,
-                        #     diffusion_bulk_u, diffusion_LS_u, diffusion_border_u, Mum1, BC_uL,
-                        #     diffusion_bulk_v, diffusion_LS_v, diffusion_border_v, Mvm1, BC_vL,
-                        #     cross_term_diffusion_bulk_d_dv_dx_dy,cross_term_diffusion_bulk_d_du_dy_dx,
-                        #     cross_term_diffusion_bulk_d_dv_dx_dy_border,cross_term_diffusion_bulk_d_du_dy_dx_border,
-                        #     rho_one_fluid_u,rho_one_fluid_v,
-                        #     true,
-                        #     BC_pL,phL
-                        #     )
-                    else
-
-                        # Coupled resolution of u and v
-                        _ = FE_set_momentum_coupled2(
-                        BC_int, num, grid_p, grid_u, grid_v,
-                        op.opC_pL, op.opC_uL, op.opC_vL,
-                        AuvL, BuvL,rhs_uv,
-                        iRe.*Lum1_L, iRe.*bc_Lum1_L, iRe.*bc_Lum1_b_L, Mum1_L, BC_uL,
-                        iRe.*Lvm1_L, iRe.*bc_Lvm1_L, iRe.*bc_Lvm1_b_L, Mvm1_L, BC_vL,
-                        true,BC_pL,phL
-                        )
-                    end
-                end
-
-
-            end
-
-
-            #TODO remove alloc a0_p
-            a0_p = []
-            for i in 1:num.nLS
-                push!(a0_p, zeros(grid_p))
-            end
-            
-            
-            if !advection && (num.solve_solid == 1)
-            #call to set_heat! is there to set up the matrices for the heat equation. 
-            #If the level-set is not advected, then after this call there is no need to update these matrices anymore
-
-                _ = set_poisson(
-                    BC_int, num, grid_p, a0_p, op.opC_pS, op.opC_uS, op.opC_vS,
-                    AϕS, Lpm1_S, bc_Lpm1_S, bc_Lpm1_b_S, BC_pS,
-                    true
-                )
-
-                set_heat!(
-                    BC_int[1], num, grid_p, op.opC_TS, grid_p.LS[1].geoS, phS, num.θd, BC_TS, grid_p.LS[1].MIXED, grid_p.LS[1].geoS.projection,
-                    ATS, BTS,rhs_scal,
-                    op.opS, grid_u, grid_u.LS[1].geoS, grid_v, grid_v.LS[1].geoS,
-                    periodic_x, periodic_y, heat_convection, true, BC_int
-                )
-            end
-
-            if test_laplacian
-                num.exact_laplacian = test_laplacian_pressure(num,grid_v,phL.vD,op.opC_pL, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L)
-                return
-            end
-
-            # Segregated resolution for u and v since the viscosity is assumed to be constant in a phase 
-            if num.pressure_velocity_coupling == 0
-                if !navier
-                    _ = FE_set_momentum(
-                        num, grid_u, op.opC_uL,
-                        AuL, BuL,
-                        iRe.*Lum1_L, iRe.*bc_Lum1_L, iRe.*bc_Lum1_b_L, Mum1_L, BC_uL,
-                        true
-                    )
-                    _ = FE_set_momentum(
-                        num, grid_v, op.opC_vL,
-                        AvL, BvL,
-                        iRe.*Lvm1_L, iRe.*bc_Lvm1_L, iRe.*bc_Lvm1_b_L, Mvm1_L, BC_vL,
-                        true
-                    )
-                else
-                    # Coupled resolution of u and v if navier BC is activated
-                    _ = FE_set_momentum_coupled(
-                        BC_int, num, grid_p, grid_u, grid_v,
-                        op.opC_pL, op.opC_uL, op.opC_vL,
-                        AuvL, BuvL,
-                        iRe.*Lum1_L, iRe.*bc_Lum1_L, iRe.*bc_Lum1_b_L, Mum1_L, BC_uL,
-                        iRe.*Lvm1_L, iRe.*bc_Lvm1_L, iRe.*bc_Lvm1_b_L, Mvm1_L, BC_vL,
-                        true
-                    )
-                end
-
-            elseif num.pressure_velocity_coupling > 1
-
-
-                if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-                        # _ = FE_set_momentum_coupled2_one_fluid(
-                        #     BC_int, num, grid_p, grid_u, grid_v,
-                        #     op.opC_pL, op.opC_uL, op.opC_vL,
-                        #     AuvL, BuvL,rhs_uv,
-                        #     diffusion_bulk_u, diffusion_LS_u, diffusion_border_u, Mum1, BC_uL,
-                        #     diffusion_bulk_v, diffusion_LS_v, diffusion_border_v, Mvm1, BC_vL,
-                        #     cross_term_diffusion_bulk_d_dv_dx_dy,cross_term_diffusion_bulk_d_du_dy_dx,
-                        #     cross_term_diffusion_bulk_d_dv_dx_dy_border,cross_term_diffusion_bulk_d_du_dy_dx_border,
-                        #     rho_one_fluid_u,rho_one_fluid_v,
-                        #     true,
-                        #     BC_pL,phL
-                        #     )
-                else
-                    # Coupled resolution of u and v
-                    _ = FE_set_momentum_coupled2(
-                    BC_int, num, grid_p, grid_u, grid_v,
-                    op.opC_pL, op.opC_uL, op.opC_vL,
-                    AuvL, BuvL,rhs_uv,
-                    iRe.*Lum1_L, iRe.*bc_Lum1_L, iRe.*bc_Lum1_b_L, Mum1_L, BC_uL,
-                    iRe.*Lvm1_L, iRe.*bc_Lvm1_L, iRe.*bc_Lvm1_b_L, Mvm1_L, BC_vL,
-                    true,BC_pL,phL
-                    )
-                end #one-fluid
-                
-            end
-
-            a0_p = []
-            for i in 1:num.nLS
-                push!(a0_p, zeros(grid_p))
-            end
-
-            if num.one_fluid_model == 0
-                _ = set_poisson(
-                    BC_int, num, grid_p, a0_p, op.opC_pL, op.opC_uL, op.opC_vL,
-                    AϕL, Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, BC_pL,
-                    true
-                )
-            else
-                _ = set_poisson_one_fluid(
-                BC_int, num, grid_p, a0_p, op.opC_pL, op.opC_uL, op.opC_vL,
-                AϕL, Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, BC_pL,
-                true
-            )
-            end
-
-            if num.nLS>1 #monophasic
-                #call to set_heat! is there to set up the matrices for the heat equation. 
-                #If the level-set is not advected, then after this call there is no need to update these matrices anymore
-                set_heat!(
-                    BC_int[1], num, grid_p, op.opC_TL, grid_p.LS[1].geoL, phL, num.θd, BC_TL, grid_p.LS[1].MIXED, grid_p.LS[1].geoL.projection,
-                    ATL, BTL,rhs_scal,
-                    op.opL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL,
-                    periodic_x, periodic_y, heat_convection, true, BC_int
-                )
-            end
-         
-        end
-    else
-        error("Unknown time scheme. Available options are ForwardEuler and CrankNicolson")
-    end
-
-    if heat_convection || electrolysis_convection
-        NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y)
-        # println(grid_p.LS[1].geoL.dcap[1,1,:])
-    end
-
-    # V0S = volume(grid_p.LS[end].geoS)
-    # V0L = volume(grid_p.LS[end].geoL)
-
-    if num.debug == "allocations_start"
-        print("\n STOP allocations")
-        return
-    end
-
-    #region restart    
-    #  - file: decl_hdf5_test_02_r${rank}.h5
-    #   when: $input=1
-    #   read: [ reals, values ]
-
-    PDI_status = @ccall "libpdi".PDI_multi_expose("restart"::Cstring,
-    "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-    "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-    "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-    "nx"::Cstring, grid_p.nx::Ref{Clonglong}, PDI_OUT::Cint,
-    "ny"::Cstring, grid_p.ny::Ref{Clonglong}, PDI_OUT::Cint,
-    "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-    "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-    "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-    "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-    "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-    "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-    "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-    "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,        
-    "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-    "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-    "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint,        
-    C_NULL::Ptr{Cvoid})::Cint
-
-    #endregion restart 
-
-    interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-    
-    PDI_status = @ccall "libpdi".PDI_multi_expose("write_data"::Cstring,
-        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-        "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-        "nx"::Cstring, grid_p.nx::Ref{Clonglong}, PDI_OUT::Cint,
-        "ny"::Cstring, grid_p.ny::Ref{Clonglong}, PDI_OUT::Cint,
-        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,        
-        "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-        "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-        "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint,        
-        C_NULL::Ptr{Cvoid})::Cint
-
-        #compute numerical radius 
-        PDI_status = @ccall "libpdi".PDI_multi_expose("compute_radius"::Cstring,
-        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "mesh_p_x"::Cstring, grid_p.x::Ptr{Cdouble}, PDI_OUT::Cint,
-        "mesh_p_y"::Cstring, grid_p.y::Ptr{Cdouble}, PDI_OUT::Cint,
-        "radius_vec"::Cstring, radius_pdi::Ptr{Cdouble}, PDI_INOUT::Cint,                             
-        C_NULL::Ptr{Cvoid})::Cint
-        num.current_radius = radius_pdi[1]
-
-        
-        print("\n radius pdi ", radius_pdi[1]) 
-
-        # slice = levelset_p[nx//2,:]
-        # x_1D = mesh_p_y[nx//2,:]
-
-        # try
-    #     radius_vertical = compute_radius_from_levelset_slice(grid_p.LS[num.iLSpdi].u[:,div(grid_p.nx,2)],
-    #     grid_p.y[:,div(grid_p.nx,2)])
-    #     # catch error
-    #     # volume_cell = grid_p.LS[num.iLSpdi].geoS.cap[:,:,5] #bubble
-    #     volume_cell = grid_p.LS[num.iLSpdi].geoL.cap[:,:,5] #drop
-
-    #     center_of_mass_x, center_of_mass_y = calculate_centroid(grid_p.x, grid_p.y, volume_cell)
-
-        
-    #     indices_bubble_mass_center = find_slice_coord_bubble_mass_center(center_of_mass_x,center_of_mass_y,
-    #     num,grid_p)
-    #     radius_horizontal = compute_radius_from_levelset_slice(grid_p.LS[num.iLSpdi].u[indices_bubble_mass_center[1],:],
-    #     grid_p.y[indices_bubble_mass_center[1],:]) 
-
-    #     if isnothing(radius_vertical)
-    #         print("\n error radius vertical")
-    #         if isnothing(radius_horizontal)
-    #             print("\n error radius horizontal and vertical")
-    #         else
-    #             num.current_radius = radius_horizontal
-    #         end
-
-    #     else
-    #         if isnothing(radius_horizontal)
-    #             print("\n error radius horizontal")
-    #         else
-    #             num.current_radius = max(radius_horizontal, radius_vertical)
-    #         end
-    #     end
-    #     # end
-
-    #     num.current_radius = maximum(compute_radii_from_slices(
-    # grid_p.LS[num.iLSpdi].u,
-    # x_grid::AbstractMatrix,
-    # y_grid::AbstractMatrix,
-    # slices::Vector{Tuple{Union{Int, Colon}, Union{Int, Colon}}};
-    # center_x,center_y)
-
-    if num.sphere_post_processing == 1 
-        compute_bubble_drop_radius(num, grid_p)
-    end
-
-    if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1 && num.solve_Navier_Stokes == 1) 
-        # rise_velocity_y =0.0
-        # PDI_status = @ccall "libpdi".PDI_multi_expose("post_processing_rising_bubble_first_share"::Cstring,
-        # "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-        # # "rho_one_fluid"::Cstring, rho_one_fluid::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "rho_one_fluid_u"::Cstring, rho_one_fluid_u::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "rho_one_fluid_v"::Cstring, rho_one_fluid_v::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "mu_one_fluid"::Cstring, mu_one_fluid::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "rise_velocity_y"::Cstring, rise_velocity_y::Ref{Cdouble}, PDI_OUT::Cint,  
-        # "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-        # # "volume_fraction"::Cstring, volume_fraction::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "volume_cell"::Cstring, grid_p.LS[end].geoS.dcap[:,:,5]::Ptr{Cdouble}, PDI_OUT::Cint, #geoS for bubble phase
-        # # "mesh_p_x"::Cstring, grid_p.x::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "mesh_p_y"::Cstring, grid_p.y::Ptr{Cdouble}, PDI_OUT::Cint,
-        # # "dcap_1"::Cstring, grid_p.LS[num.iLSpdi].geoS.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint, #geoS for bubble phase
-        # # "dcap_2"::Cstring, grid_p.LS[num.iLSpdi].geoS.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint, #geoS for bubble phase
-        # # "dcap_3"::Cstring, grid_p.LS[num.iLSpdi].geoS.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint, #geoS for bubble phase
-        # # "dcap_4"::Cstring, grid_p.LS[num.iLSpdi].geoS.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint, #geoS for bubble phase
-        # C_NULL::Ptr{Cvoid})::Cint
-
-        update_one_fluid_density_viscosity(num,grid_p,grid_u,grid_v,volume_fraction,levelset_one_fluid,rho_one_fluid,
-                                                    rho_one_fluid_u,rho_one_fluid_v,mu_one_fluid,tmp_vec_p0)
-
-        # PDI_status = @ccall "libpdi".PDI_multi_expose("print_timestep"::Cstring,
-        # "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-        # "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-        # "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,
-        # C_NULL::Ptr{Cvoid})::Cint
-
-        # #region initial values
-        # PDI_status = @ccall "libpdi".PDI_multi_expose("post_processing_rising_bubble"::Cstring,
-        # #endregion initial values          
-                                           
-    end
-
-    
-    if num.one_fluid_model == 1 && num.solve_Navier_Stokes == 1
-        conservation = compute_conservation_mass(num,phL, grid_p ,grid_u, grid_v, rho_one_fluid)
-    else
-        conservation = 0 # TODO
-    end
-
-    # Compute divergence of velocity
-    Duv = op.opC_pL.AxT * vec1(phL.uD,grid_u) .+ op.opC_pL.Gx_b * vecb(phL.uD,grid_u) .+
-    op.opC_pL.AyT * vec1(phL.vD,grid_v) .+ op.opC_pL.Gy_b * vecb(phL.vD,grid_v)
-    for iLS in 1:num.nLS
-        if !is_navier(BC_int[iLS]) && !is_navier_cl(BC_int[iLS]) #otherwise normal velocity null if no blowing
-            Duv .+= op.opC_pL.Gx[iLS] * veci(phL.uD,grid_u,iLS+1) .+ 
-                    op.opC_pL.Gy[iLS] * veci(phL.vD,grid_v,iLS+1)
-        end
-    end
-
-    
-    if num.solve_Navier_Stokes == 1 && num.solve_Navier_Stokes == 1
-        PDI_status = @ccall "libpdi".PDI_multi_expose("print_conservation"::Cstring,
-        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-        "conservation"::Cstring, conservation::Ref{Cdouble}, PDI_OUT::Cint,
-        "velocity_divergence"::Cstring, Duv::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-        C_NULL::Ptr{Cvoid})::Cint
-
-        #save initialised electrical potential and current (iter 0)
-        if num.electrical_potential>0
-            compute_grad_phi_ele!(num, grid_p, grid_u, grid_v, grid_u.LS[end], grid_v.LS[end], phL,
-            op.opC_pL, elec_cond,tmp_vec_u,tmp_vec_v,tmp_vec_p,tmp_vec_p0,tmp_vec_p1) #TODO current
-        end
-
-        # PDI_status = @ccall "libpdi".PDI_multi_expose("check_conservation"::Cstring,
-        # "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-        # "conservation"::Cstring, conservation::Ref{Cdouble}, PDI_OUT::Cint,
-        # "velocity_divergence"::Cstring, Duv::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-        # "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-        # C_NULL::Ptr{Cvoid})::Cint
-
-    end
-
-
-    simulation_finished = false
-
-    #TODO variable time steps 
-
-    #region time loop
-    while (num.current_iter < num.max_iterations + 1) && (num.time < num.end_time) && (num.stop_simulation == 0) 
-
-        #update time
-        num.time += num.timestep_n
-        num.current_iter += 1
-
-
-        #region start iter
-
-        #region Adapt timestep
-
-        
-        num.timestep_n = adapt_timestep!(num, phL, phS, grid_u, grid_v,adapt_timestep_mode)
-       
-        # printstyled(color=:green, @sprintf "\n num.CFL : %.2e dt : %.2e num.timestep_n : %.2e\n" num.CFL num.timestep_n num.timestep_n)
-        # print("\n num.stop_simulation start loop ",num.stop_simulation)
-
-        #endregion adapt time
-        
-        if grid_p.LS[1].geoL.dcap[1,1,:] == 0.0
-            printstyled(color=:red, @sprintf "\n Error operator null \n")
-            return
-        end
-
-        # Print information at the start of temporal iteration and check definition of operators 
-        # cf update_all_ls_data (true VS false)
-        PDI_status = @ccall "libpdi".PDI_multi_expose("print_start_temporal_iteration"::Cstring,
-        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-        # "levelset_p"::Cstring, grid_p.LS[num.index_levelset_pdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "dcap"::Cstring, grid_p.LS[num.index_levelset_pdi].geoL.dcap[:,:,:]::Ptr{Cdouble}, PDI_OUT::Cint,
-        # grid_p.LS[1].geoL.dcap[1,1,:]
-        C_NULL::Ptr{Cvoid})::Cint
- 
-
-
-
-        # if num.io_pdi>0
-
-        #     #or permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1)) (3, 1, 2)
-        #     try                            
-        #         # num.iLSpdi = 1 # TODO all grid_p.LS                
-        #         PDI_status = @ccall "libpdi".PDI_multi_expose("write_capacities"::Cstring,                    
-        #         # "dcap"::Cstring, permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1))::Ptr{Cdouble}, PDI_OUT::Cint,
-        #         "dcap_1"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint,
-        #         "dcap_2"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint,
-        #         "dcap_3"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint,
-        #         "dcap_4"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint,
-
-        #         C_NULL::Ptr{Cvoid})::Cint                           
-        #     catch error
-        #         printstyled(color=:red, @sprintf "\n PDI error \n")
-        #         print(error)
-        #         printstyled(color=:red, @sprintf "\n PDI error \n")
-        #     end
-        # end #if io_pdi
-
-        #endregion start iter
-
-        # PDI (IO)
-        if electrolysis
-
-            #TODO not necessary to expose everything now for ex only grid_p.LS ? and the rest later
-            
-            intfc_vtx_x,intfc_vtx_y,intfc_vtx_field,intfc_vtx_connectivities,intfc_vtx_num, intfc_seg_num = convert_interfacial_D_to_segments(num,grid_p,phL.TD,1,2)
-          
-            #TODO when to write elec dat, ...
-    
-            if num.io_pdi>0
-    
-                try
-                    # printstyled(color=:red, @sprintf "\n PDI test \n" )
-            
-            
-               
-                    # phi_array=phL.phi_ele #do not transpose since python row major
-                    
-                    
-                    if num.electrical_potential > 0
-
-                        # print("\n type of elec_cond ", typeof(elec_cond)," \n")
-                        try
-                            compute_grad_phi_ele!(num, grid_p, grid_u, grid_v,grid_u.LS[end], grid_v.LS[end], 
-                            phL, 
-                            # phS, 
-                            op.opC_pL, 
-                            # op.opC_pS, 
-                            elec_cond,tmp_vec_u,tmp_vec_v,tmp_vec_p,tmp_vec_p0,tmp_vec_p1) #TODO current
-                        catch
-                            @error("compute_grad_phi_ele!")
-                            break
-                        end
-                    end
-                    # #store in us, vs instead of Eus, Evs
-                    # interpolate_grid_liquid!(grid_p,grid_u,grid_v,phL.Eu, phL.Ev,tmp_vec_p,tmp_vec_p0)
-    
-                    # @ccall "libpdi".PDI_multi_expose("write_data_elec"::Cstring,
-                    # "i_current_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    # "i_current_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,  
-                    # "i_current_mag"::Cstring, phL.i_current_mag::Ptr{Cdouble}, PDI_OUT::Cint,
-                    # "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    # C_NULL::Ptr{Cvoid})::Cint
-                    
-                    interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-            
-                    # print("\n before write \n ")
-            
-                    # num.iLSpdi = 1 # all grid_p.LS iLS = 1 # or all grid_p.LS ?
-    
-                    # Exposing data to PDI for IO    
-                    # if writing "D" array (bulk, interface, border), add "_1D" to the name
-                    
-                    # printstyled(color=:magenta, @sprintf "\n PDI write_data_start_loop %.5i \n" num.current_iter)
-    
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_data_start_loop"::Cstring,
-                    "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                    "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                    "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,                  
-                    "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-                    "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint,  
-                    "intfc_vtx_num"::Cstring, intfc_vtx_num::Ref{Clonglong}, PDI_OUT::Cint, 
-                    "intfc_seg_num"::Cstring, intfc_seg_num::Ref{Clonglong}, PDI_OUT::Cint, 
-                    "intfc_vtx_x"::Cstring, intfc_vtx_x::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "intfc_vtx_y"::Cstring, intfc_vtx_y::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "intfc_vtx_field"::Cstring, intfc_vtx_field::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "intfc_vtx_connectivities"::Cstring, intfc_vtx_connectivities::Ptr{Clonglong}, PDI_OUT::Cint,
-                    C_NULL::Ptr{Cvoid})::Cint
-            
-                catch error
-                    printstyled(color=:red, @sprintf "\n PDI error \n")
-                    print(error)
-                    printstyled(color=:red, @sprintf "\n PDI error \n")
-                end
-    
-            end #if io_pdi
-        end #if electrolysis
-        
-
-        if !stefan
-            grid_p.V .= speed #*ones(grid_p.ny, grid_p.nx)
-        end
-
-        #region Heat equation
-        # Solve heat equation
-        if heat
-            if heat_solid_phase 
-                kill_dead_cells!(phS.T, grid_p, grid_p.LS[1].geoS)
-                veci(phS.TD,grid_p,1) .= vec(phS.T)
-                set_heat!(
-                    BC_int[1], num, grid_p, op.opC_TS, grid_p.LS[1].geoS, phS, num.θd, BC_TS, grid_p.LS[1].MIXED, grid_p.LS[1].geoS.projection,
-                    ATS, BTS,rhs_scal,
-                    op.opS, grid_u, grid_u.LS[1].geoS, grid_v, grid_v.LS[1].geoS,
-                    periodic_x, periodic_y, heat_convection, advection, BC_int
-                )
-                mul!(rhs_scal, BTS, phS.TD, 1.0, 1.0)
-
-                phS.TD .= ATS \ rhs_scal
-                phS.T .= reshape(veci(phS.TD,grid_p,1), grid_p)
-            end
-            if heat_liquid_phase
-                kill_dead_cells!(phL.T, grid_p, grid_p.LS[1].geoL)
-                veci(phL.TD,grid_p,1) .= vec(phL.T)
-                set_heat!(
-                    BC_int[1], num, grid_p, op.opC_TL, grid_p.LS[1].geoL, phL, num.θd, BC_TL, grid_p.LS[1].MIXED, grid_p.LS[1].geoL.projection,
-                    ATL, BTL,rhs_scal,
-                    op.opL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL,
-                    periodic_x, periodic_y, heat_convection, advection, BC_int
-                )
-                mul!(rhs_scal, BTL, phL.TD, 1.0, 1.0)
-
-                phL.TD .= ATL \ rhs_scal
-                phL.T .= reshape(veci(phL.TD,grid_p,1), grid_p)
-
-            end
-        end # #if heat
-        #endregion heat equation
-
-        
-        #region Electrolysis 
-        #TODO scalar without electrical potential
-        if electrolysis && (num.solve_potential == 1 ) && (num.solve_species == 1)
-            if electrolysis_liquid_phase
-
-                #region Electrolysis: Poisson  
-                if num.electrical_potential > 0
-                    solve_poisson_loop!(num, grid_p, grid_u, grid_v, op, Ascal, rhs_scal,F_residual,
-                        tmp_vec_p,tmp_vec_p0,tmp_vec_p1, a1_p, BC_phi_ele, phL, phS,elec_cond,
-                        elec_condD, tmp_vec_u, tmp_vec_v, i_butler, ls_advection, heat)
-                end
-                #endregion Poisson
-    
-
-               
-                #TODO check BC not overwritten by different scalars
-                #TODO check ls advection true when num.n scalars
-
-                # print("\n vecb_L",vecb_L(phL.phi_eleD, grid_p))
-                # print("\n phL.phi_ele[:,1]",phL.phi_ele[:,1])
-
-                #TODO phL.phi_ele[:,1] or vecb_L(phL.phi_eleD, grid_p)
-                # we suppose phi(x=0)=... cf Khalighi
-                #but here BC
-                
-                # New start scalar loop
-
-                #region velocity
-                # TODO
-                interpolate_interface_velocity!(phL,grid_u,grid_v)
-
-                #endregion velocity
-
-                #region Impose velocity
-                if imposed_velocity == "zero"
-                    phL.u .= 0.0
-                    phL.v .= 0.0
-                    phL.uD .= 0.0
-                    phL.vD .= 0.0
-                    phL.p .= 0.0
-                    phL.pD .= 0.0
-
-
-                elseif imposed_velocity == "constant"
-                        
-                        #Required to modify whole uD vD
-                        phL.u .= 0.0
-                        phL.v .= BC_vL.bottom.val    
-                        phL.uD .= 0.0
-                        phL.vD .= BC_vL.bottom.val    
-
-                        phL.pD .= 0.0
-
-                        if ((num.current_iter-1)%show_every == 0) 
-                            printstyled(color=:red, @sprintf "\n Imposed velocity v min %.2e max %.2e\n" minimum(phL.vD) maximum(phL.vD))
-                            printstyled(color=:red, @sprintf "\n Imposed velocity u min %.2e max %.2e\n" minimum(phL.uD) maximum(phL.uD))
-                        end
-
-                elseif imposed_velocity == "Poiseuille_bottom_top"
-
-                    vPoiseuille = Poiseuille_fmax.(grid_v.x,num.v_inlet,num.L0)
-
-                    
-                    #Required to modify whole uD vD
-                    phL.u .= 0.0
-                    phL.v .= vPoiseuille 
- 
-                    phL.uD .= 0.0 #Dirichlet and Neumann
-                    # phL.vD .= BC_vL.bottom.val    
-                    # vecb...TODO
-                    # ...
-                    
-                elseif imposed_velocity == "radial"
-                    impose_radial_velocity(phS,phL,num)
-                end #imposed_velocity
-                #endregion Impose velocity
-
-                #region Update current
-               
-                # if num.electrolysis_reaction == "Butler_no_concentration"
-                    
-                #     update_electrical_current_from_Butler_Volmer!(num,grid_p,heat,phL.phi_eleD,i_butler;phL.T)
-
-                #     # #TODO dev multiple levelsets
-                #     # if heat
-                #     #     i_butler = butler_volmer_no_concentration.(num.alpha_a,num.alpha_c,num.Faraday,num.i0,vecb_L(phL.phi_eleD, grid_p),
-                #     #     num.phi_ele1,num.Ru,phL.T)
-                #     # else
-                #     #     if num.nLS == 1
-                #     #         i_butler = butler_volmer_no_concentration.(num.alpha_a,num.alpha_c,num.Faraday,num.i0,vecb_L(phL.phi_eleD, grid_p),
-                #     #         num.phi_ele1,num.Ru,num.temperature0)
-                #     #     # else
-                #     #         #imposed by LS 2
-                #     #         # iLS_elec = 2
-                #     #         # i_butler = butler_volmer_no_concentration.(num.alpha_a,num.alpha_c,num.Faraday,num.i0,veci(phL.phi_eleD, grid_p,iLS_elec+1),
-                #     #         # num.phi_ele1,num.Ru,num.temperature0)
-                #     #     end
-                #     # end   
-                # end
-
-                # if num.electrolysis_reaction_symb in (:Butler_no_concentration, :fixed_current)
-                if num.electrolysis_reaction_symb === :Butler_no_concentration
-                    # if num.verbosity>0
-                    #     print("\n electrode_definition_function ",electrode_definition_function)
-                    # end
-
-                    update_electrical_current_from_Butler_Volmer_func!(num,grid_p,heat,phL.phi_eleD,i_butler,electrode_definition_function;phL.T)
-                    #if fixed do not update
-                end
-
-                #endregion Update current
-
-
-                #region Scalar transport: update boundary conditions
-                if num.nb_transported_scalars>0
-
-                    # printstyled(color=:magenta, @sprintf "\n num.nb_transported_scalars %.5i " num.nb_transported_scalars)
-
-                    for iscal=1:num.nb_transported_scalars
-                        # @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[1].geoL,0.0) 
-                        # @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[1].geoL,num.concentration0[iscal]) 
-
-                        if num.kill_dead_cells == 0
-                            @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,0.0)
-                        else
-                            @views kill_dead_cells_val!(phL.trans_scal[:,:,iscal], grid_p, grid_p.LS[end].geoL,num.concentration0[iscal])
-                        end
-
-                        @views veci(phL.trans_scalD[:,iscal],grid_p,1) .= vec(phL.trans_scal[:,:,iscal])
-
-
-                        if num.nLS == 1
-                            #BC for LS 2 in scalar transport : done in scalar loop
-                            # if iscal==1 || iscal==2
-                            #     inv_stoechiometric_coeff = -1.0/2.0 #H2 and KOH
-                            # elseif iscal == 3
-                            #     inv_stoechiometric_coeff = 1.0 #H2O consummed
-                            # end
-                            inv_stoechiometric_coeff = num.inv_stoechiometric_coeff[iscal]
-
-                            if num.electrolysis_reaction_symb === :Butler_no_concentration
-
-                                # BC at left wall
-                                # -(-/i_butler) because i=-lambda grad phi and BC at left: -e_x
-                                BC_trans_scal[iscal].left.val = i_butler./(num.Faraday*num.diffusion_coeff[iscal])*inv_stoechiometric_coeff
-
-                                # debug
-                                # for testn in 1:grid_p.ny
-                                #     printstyled(color=:green, @sprintf "\n jtmp : %.5i j : %.5i border %.5e\n" testn grid_p.ny-testn+1 vecb_L(phL.trans_scalD[:,iscal], grid_p)[testn])
-                                # end
-
-                                # elseif num.electrolysis_reaction_symb === :fixed_current && num.nLS == 1
-                                #already initialised in convergence.jl
-                                #     print("\n scalar ", iscal, " ", BC_trans_scal[iscal].bottom.val)
-                                #     BC_trans_scal[iscal].bottom.val = i_butler./(num.Faraday*num.diffusion_coeff[iscal])*inv_stoechiometric_coeff
-
-                            end
-
-                        end
-
-                        #  if num.scalar_transport_implementation > 0 
-                            
-                        #     printstyled(color=:red, @sprintf "\n scalar_transport_implementation")
-
-                        #     if num.time>num.nucleation_time
-                        #         BC_trans_scal[1].int = Dirichlet(val = num.concentration0[1])
-                        #     else
-                        #         BC_trans_scal[1].int = Neumann()
-                        #         print("\n BC_trans_scal[1].int ", BC_trans_scal[1].int  )
-
-                        #     end
-                        #  end
-
-
-
-
-
-                    end
-
-                    #TODO convection_Cdivu BC divergence
-                    #TODO check num.nb_transported_scalars>1
-
-                    if ((num.current_iter-1)%show_every == 0) 
-                        # printstyled(color=:cyan, @sprintf "\n before scalar transport \n")
-                        # print_electrolysis_statistics(num,grid_p,phL)
-                        
-                        PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-                        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                           
-                        C_NULL::Ptr{Cvoid})::Cint
-                    end
-                
-                    # printstyled(color=:red, @sprintf "\n levelset: before scalar_transport\n")
-                    # println(grid_p.LS[1].geoL.dcap[1,1,:])
-
-                            
-                    #TODO better alloc
-                    # geo = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_u = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_v = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                    # laps = set_matrices!(
-                    #     num, grid_p, geo, grid_u, geo_u, grid_v, geo_v,
-                    #     op.opC_pL, op.opC_uL, op.opC_vL,
-                    #     periodic_x, periodic_y)
-
-                    if electrolysis_advection
-
-                    # if imposed_velocity == "zero" && num.current_iter ==16
-                        #    num.ϵwall = 0.0
-                        #   print("\n changed eps wall")
-                    # end
-                        #printstyled(color=:cyan, @sprintf "\n epsilon %.2e %.2e \n" num.ϵ num.ϵwall )
-
-                        update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y)
-                    end
-
-                    
-                    # printstyled(color=:red, @sprintf "\n return before debug mem\n")
-                    # return
-
-                    # if num.nLS ==1 #TODO dev multiple levelsets
-
-
-                      #PDI (IO)      
-        
-                    if num.io_pdi>0
-
-                        #or permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1)) (3, 1, 2)
-                        try                            
-                            # num.iLSpdi = 1 # TODO all grid_p.LS                
-                            PDI_status = @ccall "libpdi".PDI_multi_expose("write_capacities"::Cstring,                    
-                            # "dcap"::Cstring, permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1))::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "dcap_1"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "dcap_2"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "dcap_3"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "dcap_4"::Cstring, grid_p.LS[num.iLSpdi].geoL.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint,
-                            C_NULL::Ptr{Cvoid})::Cint                           
-                        catch error
-                            printstyled(color=:red, @sprintf "\n PDI error \n")
-                            print(error)
-                            printstyled(color=:red, @sprintf "\n PDI error \n")
-                        end
-                    end #if io_pdi
-
-
-                   
-                    # # #TODO better alloc
-                    # geo = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_u = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_v = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                    # laps = set_matrices!(
-                    #     num, grid_p, geo, grid_u, geo_u, grid_v, geo_v,
-                    #     op.opC_pL, op.opC_uL, op.opC_vL,
-                    #     periodic_x, periodic_y)
-
-                    #interface term in rhs comes from op.opC_TL
-                    #TODO variable CL
-                    
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_iso"::Cstring,
-                    "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                    "levelset_iso"::Cstring, grid_p.LS[num.iLSpdi].iso::Ptr{Cdouble}, PDI_OUT::Cint,
-                    C_NULL::Ptr{Cvoid})::Cint
-
-                    # printstyled(color=:magenta, @sprintf "\n Before scalar transport\n")
-                    # printstyled(color=:cyan, @sprintf "\n Before scalar transport\n")
-                    # printstyled(color=:green, @sprintf "\n Before scalar transport\n")
-
-
-                    scalar_transport!(num, grid_p, grid_u, grid_v,
-                    op.opC_TL, #op
-                    op.opL, #op_conv
-                    phL, 
-                    BC_trans_scal,
-                    BC_int,                     
-                    Ascal,
-                    Bscal,
-                    all_CUTCT,
-                    rhs_scal,
-                    tmp_vec_p, #used to store a0 for rhs of interfacial value
-                    tmp_vec_u,
-                    tmp_vec_v,
-                    mass_transfer_rate,
-                    periodic_x, 
-                    periodic_y, 
-                    electrolysis_convection,                 
-                    ls_advection)
-
-                    print("\n num.stop_simulation after scalar ",num.stop_simulation)
-
-                    mask_1D = fnzeros(grid_p,num)
-                    compute_mask_1D!(num,grid_p,mask_1D)
-
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("check_concentrations"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-                        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,            
-                        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "mask_1D"::Cstring, mask_1D::Ptr{Cdouble}, PDI_OUT::Cint,
-                        C_NULL::Ptr{Cvoid})::Cint
-
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_mask_one_phase"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,                
-                        "mask_1D"::Cstring, mask_1D::Ptr{Cdouble}, PDI_OUT::Cint,
-                        C_NULL::Ptr{Cvoid})::Cint
-
-                    # if fix
-                    # print("\n BC_trans_scal ",BC_trans_scal[1])
-
-                    # print("\n BC_trans_scal ",BC_trans_scal[1].bottom.val)
-
-
-                    concentration_boundary_layer_width,averaged_electrode_concentration = compute_concentration_boundary_layer_width(num,grid_p,num.diffusion_coeff[1],
-                    num.current,num.saturation_concentration_H2,phL.trans_scalD[:,1],mask_1D,electrode_definition_function)
-
-                    # compute_concentration_boundary_layer_width(num,diffusion_coefficient,current,saturation_concentration,concentration_1D,mask_1D,func)
-
-
-                    sherwood = 2*num.R / concentration_boundary_layer_width #num.R : initial radius
-
-                    #TODO test rewrite diffusion + convection at interface with dot m 
-
-                    sherwood_bubble = num.ambiant_pressure / (num.Ru * num.temperature0) * 2 * num.current_radius * (num.current_radius-num.previous_radius) /num.timestep_n   / (num.diffusion_coeff[1] * (averaged_electrode_concentration - num.saturation_concentration_H2)) 
-                    # sherwood = compute_sherwood()
-
-
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_sherwood"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,                
-                        "concentration_boundary_layer_width"::Cstring, concentration_boundary_layer_width::Ref{Cdouble}, PDI_OUT::Cint,
-                        "sherwood"::Cstring, sherwood::Ref{Cdouble}, PDI_OUT::Cint,
-                        "sherwood_bubble"::Cstring, sherwood_bubble::Ref{Cdouble}, PDI_OUT::Cint,
-                        C_NULL::Ptr{Cvoid})::Cint
-
-                    # PDI_status = @ccall "libpdi".PDI_multi_expose("check_concentrations"::Cstring,
-                
-                    # scalar_transport!(BC_trans_scal, num, grid_p, , grid_p.LS[1].geoL, phL, num.concentration0,
-                    # grid_p.LS[1].MIXED, grid_p.LS[1].geoL.projection, op.opL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL,
-                    # periodic_x, periodic_y, electrolysis_convection, ls_advection, BC_int, num.diffusion_coeff,Ascal,Bscal,all_CUTCT,rhs_scal)
-
-                    # else
-                    #     printstyled(color=:red, @sprintf "\n TODO multiple LS \n" )
-
-                    # end
-
-                    # scalar_transport_2!(BC_trans_scal, num, grid_p, op.opC_TL, grid_p.LS[1].geoL, phL, num.concentration0,
-                    # grid_p.LS[1].MIXED, grid_p.LS[1].geoL.projection, op.opL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL,
-                    # periodic_x, periodic_y, electrolysis_convection, true, BC_int, num.diffusion_coeff)
-
-                    if ((num.current_iter-1)%show_every == 0) 
-                        # printstyled(color=:cyan, @sprintf "\n after scalar transport \n")
-                        # print_electrolysis_statistics(num,grid_p,phL)
-                        
-                        PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-                        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                          
-                        C_NULL::Ptr{Cvoid})::Cint
-
-
-                        # scal_error=0.0
-                        # for iscal in 1:num.nb_transported_scalars
-                        #     # printstyled(color=:cyan, @sprintf "\n after scalar transport %.2i %.2e \n" iscal maximum(abs.(phL.trans_scal[:,:,iscal])))
-                        #     # printstyled(color=:cyan, @sprintf "\n after scalar transport %.2i %.2e \n" iscal maximum(abs.(phL.trans_scalD[:,iscal])))
-                        #     # scal_error_bulk = maximum(abs.(phL.trans_scal[:,:,iscal].-num.concentration0[iscal])./num.concentration0[iscal])
-                        #     # scal_error_border = maximum(abs.(vecb(phL.trans_scalD[:,iscal],grid_p).-num.concentration0[iscal])./num.concentration0[iscal])
-                        #     # scal_error = max(scal_error_bulk,scal_error_border,scal_error)
-                        # end
-
-                        # printstyled(color=:cyan, @sprintf "\n error after scalar transport %.2e num.CFL %.2e\n" scal_error num.v_inlet*num.timestep_n/grid_p.dx[1,1])
-
-
-                    end
-
-                    if imposed_velocity != "none" && num.debug== "scalar_testing"
-                        scal_error=0.0
-                        for iscal in 1:num.nb_transported_scalars
-
-                            # print("\n maximum ",maximum(phL.trans_scalD[:,iscal]), )
-                            # printstyled(color=:cyan, @sprintf "\n error after scalar transport max %.2e min %.2e\n" maximum(phL.trans_scalD[:,iscal]) minimum(phL.trans_scalD[:,iscal]))
-
-                            scal_error_bulk = maximum(abs.(phL.trans_scal[:,:,iscal].-num.concentration0[iscal])./num.concentration0[iscal])
-                            scal_error_border = maximum(abs.(vecb(phL.trans_scalD[:,iscal],grid_p).-num.concentration0[iscal])./num.concentration0[iscal])
-                            scal_error = max(scal_error_bulk,scal_error_border,scal_error)
-
-                        end
-
-                        printstyled(color=:cyan, @sprintf "\n error after scalar transport %.2e num.CFL %.2e\n" scal_error num.v_inlet*num.timestep_n/grid_p.dx[1,1])
-
-                        # printstyled(color=:red, @sprintf "\n Poiseuille \n")
-
-                        # # Check the velocity field before the scalar transport
-                        # test_Poiseuille(num,phL.vD,grid_v)
-
-                        # printstyled(color=:cyan, @sprintf "\n pressure min %.2e max %.2e\n" minimum(phL.p[1,:]) maximum(phL.p[1,:]))
-
-                        # printstyled(color=:cyan, @sprintf "\n pressure min %.2e max %.2e\n" minimum(phL.p[end,:]) maximum(phL.p[end,:]))
-
-                        # printstyled(color=:cyan, @sprintf "\n pressure min %.2e max %.2e\n" BC_pL.bottom.val BC_pL.top.val )
-
-                        # compute_grad_p!(num,grid_p, grid_u, grid_v, phL.pD, op.opC_pL, op.opC_uL, op.opC_vL)
-
-                    end
-
-                end #num.nb_transported_scalars>0
-
-                #endregion Scalar transport
-
-                # if imposed_velocity =="none"
-                #     printstyled(color=:red, @sprintf "\n after scalar transport \n")
-
-                #     # Check the velocity field before the scalar transport
-                #     test_Poiseuille(num,phL,grid_v)
-                    
-                # end
-                
-   
-            end #if electrolysis_liquid_phase        
-        end #if electrolysis
-        #endregion Electrolysis
-
-
-
-        
-        #PDI (IO)      
-        if num.io_pdi>0
-
-            try
-                # printstyled(color=:red, @sprintf "\n PDI test \n" )
-        
-            
-                # phi_array=phL.phi_ele #do not transpose since python row major
-                
-                # Compute electrical current, interpolate velocity on scalar grid_p
-                #                     if num.electrical_potential>0 compute_grad_phi_ele!(num, grid_p, grid_u, grid_v, phL, phS, op.opC_pL, op.opC_pS) #TODO current
-        
-                # if electrolysis && num.nb_transported_scalars>1
-                #     if heat 
-                #         elec_cond = 2*num.Faraday^2 .*phL.trans_scal[:,:,2].*num.diffusion_coeff[2]./(num.Ru.*phL.T) #phL.T
-                #     else
-                #         elec_cond = 2*num.Faraday^2 .*phL.trans_scal[:,:,2].*num.diffusion_coeff[2]./(num.Ru*num.temperature0) 
-                #     end
-                # else 
-                #     elec_cond = ones(grid_p)
-                #     printstyled(color=:green, @sprintf "\n conductivity one")
-
-                # end 
-
-                # phL.i_current_mag .*= elec_cond # i=-κ∇ϕ here magnitude
-
-
-                #store in us, vs instead of Eus, Evs
-                # interpolate_grid_liquid!(grid_p,grid_u,grid_v,phL.Eu, phL.Ev,tmp_vec_p,tmp_vec_p0)
-
-                # printstyled(color=:red, @sprintf "\n test i current\n" )
-                # print("\n phi ",phL.phi_ele[64,127]," ",phL.phi_ele[64,128]," ",(phL.phi_ele[64,128]-phL.phi_ele[64,127])/grid_p.dx[64,128]," ",(phL.phi_ele[64,128]-phL.phi_ele[64,127])/grid_p.dx[64,127]*elec_cond[64,127], " cond ", elec_cond[64,127]," \n")
-
-
-                # tmp_vec_p .*= elec_cond
-                # tmp_vec_p0 .*= elec_cond
-
-
-                # @ccall "libpdi".PDI_multi_expose("write_data_elec"::Cstring,
-                # "i_current_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                # "i_current_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,  
-                # "i_current_mag"::Cstring, phL.i_current_mag::Ptr{Cdouble}, PDI_OUT::Cint,
-                # "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-                # C_NULL::Ptr{Cvoid})::Cint
-            
-                interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-                    
-                # num.iLSpdi = 1 # TODO all grid_p.LS
-
-                # Exposing data to PDI for IO    
-                # if writing "D" array (bulk, interface, border), add "_1D" to the name
-
-                PDI_status = @ccall "libpdi".PDI_multi_expose("write_data"::Cstring,
-                "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-                "nx"::Cstring, grid_p.nx::Ref{Clonglong}, PDI_OUT::Cint,
-                "ny"::Cstring, grid_p.ny::Ref{Clonglong}, PDI_OUT::Cint,
-                "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,            
-                "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                
-                "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-                "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint, 
-                C_NULL::Ptr{Cvoid})::Cint
-
-                # if num.nb_transported_scalars>0
-                #     PDI_status = @ccall "libpdi".PDI_multi_expose("write_data_species"::Cstring,
-                #     "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                #     "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,            
-                #     C_NULL::Ptr{Cvoid})::Cint
-                # end
-
-        
-                
-                #TODO debug with volume fraction
-
-                # A = zeros(gv.ny, gv.nx+1)
-                # for jplot in 1:gv.ny
-                #     for iplot in 1:gv.nx+1
-                #     II = CartesianIndex(jplot, iplot) #(id_y, id_x)
-                #     pII = lexicographic(II, grid_p.ny + 1)
-                #     A[jplot,iplot] =  1 ./ op.opC_vL.iMx.diag[pII]
-                #     end
-                # end
-            
-
-                # print("\n after write \n ")
-                    
-                # printstyled(color=:red, @sprintf "\n PDI test end\n" )
-        
-            catch error
-                printstyled(color=:red, @sprintf "\n PDI error \n")
-                print(error)
-                printstyled(color=:red, @sprintf "\n PDI error \n")
-            end
-        end #if io_pdi
-
-        #region compute mass transfer
-        if num.solve_Navier_Stokes_liquid_phase == 1 && num.phase_change_method >0
-            num.previous_radius = num.current_radius
-            # num.status = 
-            compute_mass_transfer_rate_main!(num, grid_p, grid_u, grid_v, op, phL, phS, BC_int, electrolysis, electrolysis_phase_change_case, 
-            periodic_x, periodic_y, λ, Vmean, num.iLSpdi, mode_2d, show_every, 
-            mass_transfer_rate,mass_transfer_rate_vec1,
-            mass_transfer_rate_vecb,mass_transfer_rate_veci, mass_transfer_rate_redistributed, tmp_vec_p, tmp_vec_p0, tmp_vec_p1,    
-            nb_gaz_acceptors, volume_fraction, interface_length)
-        #endregion compute mass transfer
-        end
-
-        #region Navier-Stokes
-        if num.solve_Navier_Stokes_liquid_phase == 1
-            if num.time < num.nucleation_time
-                printstyled(color=:red, @sprintf "\n Navier-Stokes not solved")
-
-                navier_stokes = false
-            else
-                printstyled(color=:red, @sprintf "\n Navier-Stokes solved")
-                navier_stokes = true
-            end
-
-            if navier_stokes
-
-
-                # Adapt cell volume W for gradients 
-                # cf 4/3 factor for Laplacian
-                if num.laplacian == 1
-                    AvLcopy = copy(AvL) #does not work if reset A after operations in compute_divergence!
-                    Lvm1_L,bc_Lvm1_L,bc_Lvm1_b_L=compute_divergence!(num, 
-                    # grid_p, 
-                    # grid_u, 
-                    grid_v, 
-                    op.opC_vL,
-                    AvLcopy, 
-                    # rhs_scal,
-                    # tmp_vec_p, #a0
-                    tmp_vec_1D_v0,
-                    tmp_vec_1D_v,
-                    Lvm1_L, 
-                    bc_Lvm1_L, 
-                    bc_Lvm1_b_L
-                    # tmp_vec_u0,
-                    # tmp_vec_v0,
-                    # tmp_vec_1D,
-                    # ls_advection
-                    )
-                    print("\nbefore pressure")
-                    II = CartesianIndex(div(grid_v.ny,2),1)
-                    pII = lexicographic(II,grid_v.ny)
-                    print("\nLv[pII,:] ",Lvm1_L[pII,:])
-                    print("\bc_Lvm1_b[pII,:] ",bc_Lvm1_b_L[pII,:])
-                
-                    ApLcopy = copy(Ascal)
-                    Lpm1_L,bc_Lpm1_L,bc_Lpm1_b_L=compute_divergence!(num, 
-                    # grid_p, 
-                    # grid_u, 
-                    grid_p, 
-                    op.opC_pL,
-                    ApLcopy, 
-                    # rhs_scal,
-                    # tmp_vec_p, #a0
-                    tmp_vec_1D_p0,
-                    tmp_vec_1D_p,
-                    Lpm1_L, 
-                    bc_Lpm1_L, 
-                    bc_Lpm1_b_L
-                    # tmp_vec_u0,
-                    # tmp_vec_v0,
-                    # tmp_vec_1D,
-                    # ls_advection
-                    )
-
-                end  
-
-                if num.pressure_velocity_coupling == 3
-
-                    # num.iLSpdi = 1 # TODO all grid_p.LS                
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("print_capacities"::Cstring,                    
-                    # "dcap"::Cstring, permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1))::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_1"::Cstring, grid_u.LS[num.iLSpdi].geoL.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_2"::Cstring, grid_u.LS[num.iLSpdi].geoL.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_3"::Cstring, grid_u.LS[num.iLSpdi].geoL.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_4"::Cstring, grid_u.LS[num.iLSpdi].geoL.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    C_NULL::Ptr{Cvoid})::Cint                           
-
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("print_capacities"::Cstring,                    
-                    # "dcap"::Cstring, permutedims(grid_p.LS[num.iLSpdi].geoL.dcap, (3, 2, 1))::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_1"::Cstring, grid_v.LS[num.iLSpdi].geoL.dcap[:,:,1]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_2"::Cstring, grid_v.LS[num.iLSpdi].geoL.dcap[:,:,2]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_3"::Cstring, grid_v.LS[num.iLSpdi].geoL.dcap[:,:,3]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "dcap_4"::Cstring, grid_v.LS[num.iLSpdi].geoL.dcap[:,:,4]::Ptr{Cdouble}, PDI_OUT::Cint,
-                    C_NULL::Ptr{Cvoid})::Cint   
-
-                    # print("\n cap_1 ",grid_u.LS[num.iLSpdi].geoL.dcap[1,:,1])
-                    # print("\n cap_1 ",grid_u.LS[num.iLSpdi].geoL.dcap[2,:,1])
-
-                    # print("\n cap_1 ",grid_v.LS[num.iLSpdi].geoL.dcap[1,:,1])
-                    # print("\n cap_1 ",grid_v.LS[num.iLSpdi].geoL.dcap[2,:,1])
-
-                    # print("\n cap_2 ",grid_v.LS[num.iLSpdi].geoL.dcap[1,:,2])
-                    # print("\n cap_2 ",grid_v.LS[num.iLSpdi].geoL.dcap[2,:,2])
-
-                    # print("\n cap_3 ",grid_v.LS[num.iLSpdi].geoL.dcap[1,:,3])
-                    # print("\n cap_3 ",grid_v.LS[num.iLSpdi].geoL.dcap[2,:,3])
-
-                    # for u grid_p
-                    # cap 1 same 
-                    # cap_1 [0.0, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5, 1.0e-5]
-
-
-        
-
-                end
-
-
-                # if !advection
-                #     @time no_slip_condition!(num, grid_p, grid_u, grid_u.LS[1], grid_v, grid_v.LS[1], periodic_x, periodic_y)
-                #     # grid_u.V .= num.Δ / (1 * num.timestep_n)
-                #     # grid_v.V .= 0.0
-                # end
-
-                # Pressure-velocity coupling
-
-                if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1) 
-
-                    # interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-
-                    tmp_vec_p  .= 0.0
-                    tmp_vec_p0 .= 0.0
-
-                    for j = 1:grid_p.ny
-                    for i = 1:grid_p.nx
-                        tmp_vec_p[j,i] =(phL.u[j,i]+phL.u[j,i+1])/2
-                        tmp_vec_p0[j,i]=(phL.v[j,i]+phL.v[j+1,i])/2
-                    end
-                    end
-
-
-                    update_one_fluid_density_viscosity(num,grid_p,grid_u,grid_v,volume_fraction,levelset_one_fluid,rho_one_fluid,
-                                                        rho_one_fluid_u,rho_one_fluid_v,mu_one_fluid,tmp_vec_p0)
-
-                    total_interface_length = compute_interface_length!(num, grid_p, 1, interface_length)
-                    # MIXED =
-
-                    nb_levelsets = num.nLS
-                    num.nLS = 0 #1 #deactivate cut-cell for one-fluid model
-                    
-                    #region deactivate LS
-                    empty_capacities = vcat(zeros(7), zeros(4))
-                    full_capacities = vcat(ones(7), 0.5.*ones(4))
-
-                    for grid_iter in [grid_p,grid_u,grid_v]
-
-                        grid_iter.LS[1].u .= 1.0
-                        grid_iter.LS[end].u .= 1.0
-
-
-                        # for j in 1:grid_iter.ny
-                        #     for i in 1:grid_iter.nx
-                        #         II = CartesianIndex(j,i)
-                        #         # grid_iter.LS[end].geoL.cap[II,:] .= full_capacities
-                        #         # grid_iter.LS[end].geoS.cap[II,:] .= empty_capacities
-                        #     end
-                        # end
-                    end
-
-                    # grid_u.LS[end].geoL.cap[:,:,:] .= full_capacities
-                    # grid_u.LS[end].geoS.cap[:,:,:] .= empty_capacities
-
-                    # grid_v.LS[end].geoL.cap[:,:,:] .= full_capacities
-                    # grid_v.LS[end].geoS.cap[:,:,:] .= empty_capacities
-
-                    #endregion  deactivate LS
-
-                    NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y,true,true) 
-
-
-                    geoL = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                    geo_uL = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                    geo_vL = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                    #region reset centroids 
-                    for grid_iter in [grid_p,grid_u,grid_v]
-                        for II in grid_iter.ind.inside
-                            grid_iter.LS[1].geoL.centroid[II] = Point(0.0,0.0)
-                        end
-                    end
-                    #endregion reset centroids 
-                    #TODO reactivate centroids ?
-                    # TODO update density
-
-                    # if num.pressure_velocity_coupling == 0 
-
-                    #region update LS
-
-                    #endregion update LS
-
-
-
-
-
-
-                    #pbm mass_transfer_rateL
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("check_mass_transfer_rate_NS"::Cstring,
-                    # "conservation"::Cstring, conservation::Ref{Cdouble}, PDI_OUT::Cint,
-                    "mass_transfer_rate"::Cstring, mass_transfer_rate::Ptr{Cdouble}, PDI_OUT::Cint,
-                    # "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    C_NULL::Ptr{Cvoid})::Cint
-
-
-
-                    #region update LS for convection (bool=true)+ one fluid
-
-                    # At every iteration, update_all_ls_data is called twice, once inside run.jl 
-                    # and another one (if there's advection of the levelset) inside set_heat!. 
-                    # The difference between both is a flag as last argument, inside run.jl is implicitly defined 
-                    # as true and inside set_heat! is false. If you're calling your version of set_heat! several times, 
-                    # then you're calling the version with the flag set to false, but for the convective term it has to be set to true.
-                    # The flag=true, the capacities are set for the convection, the flag=false they are set for the other operators
-
-                    if advection
-                        # update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y, true) 
-                        update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y, true,true) 
-                        if num.convection == 0
-                            # op.opL is op_conv
-                            set_convection_preallocated!(num, grid_p, geoL[end], grid_u, grid_u.LS, grid_v, grid_v.LS, phL.u, phL.v, op.opL,
-                            phL, BC_uL, BC_vL,op.opC_pL, op.opC_uL, op.opC_vL,
-                            velocity_and_BC_convection_u_x ,
-                            velocity_and_BC_convection_u_y ,
-                            velocity_and_BC_convection_v_x ,
-                            velocity_and_BC_convection_v_y)
-
-                            # Mm1_L .= op.opC_pL.M
-                            # Mum1_L .= op.opC_uL.M
-                            # Mvm1_L .= op.opC_vL.M
-                        else
-
-
-                        end
-
-                        
-                    end
-                    #endregion update LS for convection (bool=true)+ one fluid
-
-
-                    #region update LS for other operators than convection (bool=false)+ one fluid
-                    # update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y, false)
-                    update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y, false,true)
-
-                    #endregion
-
-
-
-                    if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1) && (num.solve_Navier_Stokes == 1)
-                        if num.activate_interface == 0
-                            volumic_surface_tension_u .= 0.0
-                            volumic_surface_tension_v .= 0.0
-                        else
-                            if num.surface_tension == 0
-                                compute_surface_tension_VOF!(num,grid_p, grid_u, grid_v, op.opC_pL, op.opC_uL, op.opC_vL, 
-                                volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0)
-                            elseif num.surface_tension == 1
-                                # compute_surface_tension_LS!(num,grid_p, grid_u, grid_v, opC_p, opC_u, opC_v, 
-                                # volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0)
-                                compute_surface_tension_LS!(num,grid_p, grid_u, grid_v, op.opC_pL, op.opC_uL, op.opC_vL, 
-                                volume_fraction,levelset_one_fluid,volumic_surface_tension_u,volumic_surface_tension_v,tmp_vec_p,tmp_vec_p0,
-                                levelset_1D, levelset_heavyside_2D, 
-                                tmp_vec_u0,tmp_vec_v0, #normal_and_dirac_u, normal_and_dirac_v,
-                                tmp_vec_u1,tmp_vec_v1,#normal_u, normal_v, 
-                                tmp_vec_u,tmp_vec_v,#curvature_u, curvature_v
-                                )
-                            # elseif num. TODO HF                               
-                            end
-
-                        end
-                    end
-                    
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_one_fluid_surface_tension_concise"::Cstring,
-                    "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,             
-                    "volumic_surface_tension_u"::Cstring, volumic_surface_tension_u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "volumic_surface_tension_v"::Cstring, volumic_surface_tension_v::Ptr{Cdouble}, PDI_OUT::Cint,              
-                    C_NULL::Ptr{Cvoid})::Cint
-
-
-                    #BC TODO
-
-                    # @error("\n check temporal terms")
-
-                    # Mum1_L is put in B matrix that multiplies v
-                    # print("\n advection ", ns_advection, " adv ",advection)
-                    one_fluid_NS_ls_advection = true #update matrix
-
-
-                    Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L,
-                    Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L, Mm1_L, Mum1_L, Mvm1_L, Cum1L, Cvm1L = solve_one_fluid_NS!(
-                    time_scheme, BC_int,
-                    num, grid_p, geoL, grid_u, geo_uL, grid_v, geo_vL, phL,
-                    BC_uL, BC_vL, BC_pL,
-                    op.opC_pL, op.opC_uL, op.opC_vL, op.opL,
-                    # op.opC_TL,
-                    AuL, BuL, AvL, BvL, AϕL, AuvL, BuvL,rhs_uv,
-                    Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L,
-                    Cum1L, Cvm1L, Mum1_L, Mvm1_L,
-                    periodic_x, periodic_y, ns_advection, one_fluid_NS_ls_advection, num.current_iter, Ra, navier,
-                    volume_fraction,
-                    levelset_one_fluid,
-                    rho_one_fluid,
-                    mu_one_fluid,
-                    rho_one_fluid_u,
-                    # mu_one_fluid_u,
-                    rho_one_fluid_v,
-                    # mu_one_fluid_v,
-                    volumic_surface_tension_u,
-                    volumic_surface_tension_v,
-                    convection_u,convection_v,
-                    viscosity_coeff_for_du_dx ,
-                    viscosity_coeff_for_du_dy ,
-                    viscosity_coeff_for_dv_dx ,
-                    viscosity_coeff_for_dv_dy,
-                    # velocity_and_BC_convection_u_x ,
-                    # velocity_and_BC_convection_u_y ,
-                    # velocity_and_BC_convection_v_x ,
-                    # velocity_and_BC_convection_v_y ,
-                    tmp_vec_p,
-                    tmp_vec_p0,            
-                    rhs_phi,
-                    pres_free_surfaceL,jump_mass_transfer_rateL,mass_transfer_rate )  
-
-                    #region ciprianoMulticomponentDropletEvaporation2024
-                    if extend_liquid_velocity
-
-                        # num.phase_change_currently_activated == 1 
-                        phase_change_currently_activated = 0
-
-                        # no need to recompute Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L,
-                        # Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L
-
-                        # Mm1_L_ext_vel, Mum1_L_ext_vel, Mvm1_L_ext_vel same as Mm1_L, Mum1_L, Mvm1_L
-                        # because :
-                        # Mm1_L = copy(op.opC_pL.M)
-                        # Mum1_L = copy(op.opC_uL.M)
-                        # Mvm1_L = copy(op.opC_vL.M)
-
-                        Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L,
-                        Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L, 
-                        Mm1_L, Mum1_L, Mvm1_L, 
-                        Cum1L_ext_vel, Cvm1L_ext_vel = solve_one_fluid_NS_no_phase!(
-                        time_scheme, BC_int,
-                        num, grid_p, geoL, grid_u, geo_uL, grid_v, geo_vL, 
-                        # phL,
-                        p_ext_vel, pD_ext_vel, phi_ext_vel, u_ext_vel, v_ext_vel, u_predictionD_ext_vel, v_predictionD_ext_vel, uD_ext_vel, vD_ext_vel, u_prediction_ext_vel, v_prediction_ext_vel, uT_ext_vel,
-                        pres_grad_x, pres_grad_y,                    
-                        phase_change_currently_activated,
-                        BC_uL, BC_vL, BC_pL,
-                        op.opC_pL, op.opC_uL, op.opC_vL, op.opL,
-                        # op.opC_TL,
-                        AuL, BuL, AvL, BvL, AϕL, AuvL, BuvL,rhs_uv,
-                        Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, 
-                        Lum1_L, bc_Lum1_L, bc_Lum1_b_L, 
-                        Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L,
-                        Cum1L_ext_vel, Cvm1L_ext_vel, 
-                        Mum1_L, Mvm1_L,
-                        periodic_x, periodic_y, ns_advection, advection, num.current_iter, Ra, navier,
-                        volume_fraction,
-                        levelset_one_fluid,
-                        rho_one_fluid,
-                        mu_one_fluid,
-                        rho_one_fluid_u,
-                        rho_one_fluid_v,
-                        volumic_surface_tension_u,
-                        volumic_surface_tension_v,
-                        convection_u,convection_v,
-                        viscosity_coeff_for_du_dx ,
-                        viscosity_coeff_for_du_dy ,
-                        viscosity_coeff_for_dv_dx ,
-                        viscosity_coeff_for_dv_dy,             
-                        tmp_vec_p,
-                        tmp_vec_p0,            
-                        rhs_phi,
-                        pres_free_surfaceL,jump_mass_transfer_rateL,mass_transfer_rate )  
-
-                        PDI_status = @ccall "libpdi".PDI_multi_expose("velocity_extension"::Cstring,                    
-                        "u_ext_vel"::Cstring, u_ext_vel::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "v_ext_vel"::Cstring, v_ext_vel::Ptr{Cdouble}, PDI_OUT::Cint,
-                        C_NULL::Ptr{Cvoid})::Cint
-
-                    end
-                    #endregion ciprianoMulticomponentDropletEvaporation2024
-
-
-                    print("\n num.stop_simulation after NS ",num.stop_simulation)
-
-
-                    #region reactivate cut-cell for one-fluid model
-                    num.nLS = nb_levelsets 
-
-                    grid_p.LS[1].u .= levelset_one_fluid
-                    grid_p.LS[end].u .= levelset_one_fluid
-
-                    NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y) 
-
-                    # TODO check after activation NS after nucleation
-
-                    # geoL = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_uL = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                    # geo_vL = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                    # reactivate centroids
-                    # printstyled(color=:red, @sprintf "\n reactivate centroids \n")
-
-                    # x_centroid = grid_p.x .+ getproperty.(grid_p.LS[1].geoL.centroid, :x) .* grid_p.dx #geoS
-                    # display(x_centroid)
-
-                    # y_centroid = grid_p.y .+ getproperty.(grid_p.LS[1].geoL.centroid, :y) .* grid_p.dy #geoS
-                    # display(y_centroid)
-
-                    # display(levelset_one_fluid)
-                    #endregion reactivate cut-cell for one-fluid model
-
-
-                else
-
-                    if num.pressure_velocity_coupling == 0 
-                        if ns_solid_phase
-                            geoS = [grid_p.LS[iLS].geoS for iLS in 1:num._nLS]
-                            geo_uS = [grid_u.LS[iLS].geoS for iLS in 1:num._nLS]
-                            geo_vS = [grid_v.LS[iLS].geoS for iLS in 1:num._nLS]
-                            Lpm1_S, bc_Lpm1_S, bc_Lpm1_b_S, Lum1_S, bc_Lum1_S, bc_Lum1_b_S, Lvm1_S, bc_Lvm1_S, bc_Lvm1_b_S,Mm1_S, Mum1_S, Mvm1_S, Cum1S, Cvm1S = pressure_projection!(
-                                time_scheme, BC_int,
-                                num, grid_p, geoS, grid_u, geo_uS, grid_v, geo_vS, phS,
-                                BC_uS, BC_vS, BC_pS,
-                                op.opC_pS, op.opC_uS, op.opC_vS, op.opS,
-                                AuS, BuS, AvS, BvS, AϕS, AuvS, BuvS,
-                                Lpm1_S, bc_Lpm1_S, bc_Lpm1_b_S, Lum1_S, bc_Lum1_S, bc_Lum1_b_S, Lvm1_S, bc_Lvm1_S, bc_Lvm1_b_S,
-                                Cum1S, Cvm1S, Mum1_S, Mvm1_S,
-                                periodic_x, periodic_y, ns_advection, advection, num.current_iter, Ra, navier,pres_free_surfaceS,jump_mass_transfer_rateS,mass_transfer_rateS
-                            )
-                        end
-                        if ns_liquid_phase
-                            geoL = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                            geo_uL = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                            geo_vL = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                            # Mum1_L is put in B matrix that multiplies v
-
-                            Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L, Mm1_L, Mum1_L, Mvm1_L, Cum1L, Cvm1L = pressure_projection!(
-                                time_scheme, BC_int,
-                                num, grid_p, geoL, grid_u, geo_uL, grid_v, geo_vL, phL,
-                                BC_uL, BC_vL, BC_pL,
-                                op.opC_pL, op.opC_uL, op.opC_vL, op.opL,
-                                AuL, BuL, AvL, BvL, AϕL, AuvL, BuvL,
-                                Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L,
-                                Cum1L, Cvm1L, Mum1_L, Mvm1_L,
-                                periodic_x, periodic_y, ns_advection, advection, num.current_iter, Ra, navier,pres_free_surfaceL,jump_mass_transfer_rateL,mass_transfer_rate
-                            )
-                            # if num.current_iter == 1
-                            #     phL.u .= -0.5 .* grid_u.y .+ getproperty.(grid_u.LS[1].geoL.centroid, :y) .* grid_u.dy
-                            #     phL.v .= 0.5 .* grid_v.x .+ getproperty.(grid_v.LS[1].geoL.centroid, :x) .* grid_v.dx
-                            #     phL.u[grid_u.LS[1].SOLID] .= 0.0
-                            #     phL.v[grid_v.LS[1].SOLID] .= 0.0
-                            # end
-                            # linear_advection!(
-                            #     num, grid_p, grid_p.LS[1].geoL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL, phL,
-                            #     BC_uL, BC_vL, op.opL
-                            # )
-                        end
-
-                    elseif num.pressure_velocity_coupling > 1
-
-                        if ns_liquid_phase
-                            geoL = [grid_p.LS[iLS].geoL for iLS in 1:num._nLS]
-                            geo_uL = [grid_u.LS[iLS].geoL for iLS in 1:num._nLS]
-                            geo_vL = [grid_v.LS[iLS].geoL for iLS in 1:num._nLS]
-
-                            # Mum1_L is put in B matrix that multiplies v
-
-                            Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L, Mm1_L, Mum1_L, Mvm1_L, Cum1L, Cvm1L = coupled_pressure_velocity!(
-                                time_scheme, BC_int,
-                                num, grid_p, geoL, grid_u, geo_uL, grid_v, geo_vL, phL,
-                                BC_uL, BC_vL, BC_pL,
-                                op.opC_pL, op.opC_uL, op.opC_vL, op.opL,
-                                AuL, BuL, AvL, BvL, AϕL, AuvL, BuvL,rhs_uv,
-                                Lpm1_L, bc_Lpm1_L, bc_Lpm1_b_L, Lum1_L, bc_Lum1_L, bc_Lum1_b_L, Lvm1_L, bc_Lvm1_L, bc_Lvm1_b_L,
-                                Cum1L, Cvm1L, Mum1_L, Mvm1_L,
-                                periodic_x, periodic_y, ns_advection, advection, num.current_iter, Ra, navier,pres_free_surfaceL,jump_mass_transfer_rateL,mass_transfer_rate
-                            )
-                            # if num.current_iter == 1
-                            #     phL.u .= -0.5 .* grid_u.y .+ getproperty.(grid_u.LS[1].geoL.centroid, :y) .* grid_u.dy
-                            #     phL.v .= 0.5 .* grid_v.x .+ getproperty.(grid_v.LS[1].geoL.centroid, :x) .* grid_v.dx
-                            #     phL.u[grid_u.LS[1].SOLID] .= 0.0
-                            #     phL.v[grid_v.LS[1].SOLID] .= 0.0
-                            # end
-                            # linear_advection!(
-                            #     num, grid_p, grid_p.LS[1].geoL, grid_u, grid_u.LS[1].geoL, grid_v, grid_v.LS[1].geoL, phL,
-                            #     BC_uL, BC_vL, op.opL
-                            # )
-                        end
-
-                    end #if num.pressure_velocity_coupling
-
-                end # if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1)
-
-            end # if navier_stokes
-
-
-            #region conservation, divergence checks
-            # TODO check global mass conservation and divergence free
-            not_divergence_free = true
-            #need one-fluid capa
-            conservation = compute_conservation_mass(num,phL, grid_p ,grid_u, grid_v, rho_one_fluid)
-
-            # Compute divergence of velocity
-            Duv = op.opC_pL.AxT * vec1(phL.uD,grid_u) .+ op.opC_pL.Gx_b * vecb(phL.uD,grid_u) .+
-            op.opC_pL.AyT * vec1(phL.vD,grid_v) .+ op.opC_pL.Gy_b * vecb(phL.vD,grid_v)
-            for iLS in 1:num.nLS
-                if !is_navier(BC_int[iLS]) && !is_navier_cl(BC_int[iLS]) #otherwise normal velocity null if no blowing
-                    Duv .+= op.opC_pL.Gx[iLS] * veci(phL.uD,grid_u,iLS+1) .+ 
-                            op.opC_pL.Gy[iLS] * veci(phL.vD,grid_v,iLS+1)
-                end
-            end
-            #TODO divergence when Navier ?
-
-            PDI_status = @ccall "libpdi".PDI_multi_expose("print_conservation"::Cstring,
-            "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-            "conservation"::Cstring, conservation::Ref{Cdouble}, PDI_OUT::Cint,
-            "velocity_divergence"::Cstring, Duv::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-            C_NULL::Ptr{Cvoid})::Cint
-
-            if maximum(Duv)< num.epsilon_divergence
-                not_divergence_free = false
-            end
-
-            if abs(conservation) > num.epsilon_conservation || not_divergence_free
-                
-                PDI_status = @ccall "libpdi".PDI_multi_expose("conservation_error"::Cstring,
-                "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                C_NULL::Ptr{Cvoid})::Cint
-            end
-            #endregion conservation, divergence checks
-
-            # PDI_status = @ccall "libpdi".PDI_multi_expose("check_pressure_velocity"::Cstring,
-            # "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-            # "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-            # C_NULL::Ptr{Cvoid})::Cint
-
-    end
-        #endregion Navier-Stokes 
-
-
-        #region old block phase change
-        #cf old_phase_change_block.jl 
-        #endregion old block phase change
-
-        # printstyled(color=:red, @sprintf "\n after phase change radius: %.2e \n" num.current_radius)
-
-        if verbose && adaptative_t
-            println("num.timestep_n = $num.timestep_n")
-        end
-
-        # printstyled(color=:red, @sprintf "\n advection")
-        if num.verbosity>0
-            print("\n num.advection_LS_mode ",num.advection_LS_mode," advection ",advection)
-        end
-
-
-        #region Advection 
-        if advection || electrolysis_advection
-
-            if num.io_pdi>0
-
-                PDI_status = @ccall "libpdi".PDI_multi_expose("write_before_LS_adv"::Cstring,                
-                "normal_velocity_intfc"::Cstring, grid_p.V::Ptr{Cdouble}, PDI_OUT::Cint,                   
-                C_NULL::Ptr{Cvoid})::Cint
-
-            end # if num.io_pdi>0
-
-            printstyled(color=:red, @sprintf "\n select advection")
-
-
-            select_advection!(num, grid_p, BC_int, BC_u, grid_u, grid_v, CFL_sc, periodic_x, periodic_y, 
-                θ_out, rhs_LS, utmp, electrolysis_phase_change_case, mass_transfer_rate, levelset_1D,
-                volume_fraction,
-                tmp_vec_p,tmp_vec_p0,
-                tmp_vec_u,tmp_vec_v,tmp_vec_u0,tmp_vec_v0,tmp_vec_u1,tmp_vec_v1,
-                op,
-                phL, u_ext_vel, v_ext_vel)
-
-
-
-            # printstyled(color=:red, @sprintf "\n after advection_LS_mode radius: %.2e \n" num.current_radius)
-
-            #region reinitialize Levelset
-
-            #TODO document
-            if num.levelset_reinitialize == 0
-
-
-                if analytical
-                    u[grid_p.ind.b_top[1]] .= sqrt.(grid_p.x[grid_p.ind.b_top[1]] .^ 2 + grid_p.y[grid_p.ind.b_top[1]] .^ 2) .- (num.R + speed*num.current_iter*num.timestep_n);
-                    u[grid_p.ind.b_bottom[1]] .= sqrt.(grid_p.x[grid_p.ind.b_bottom[1]] .^ 2 + grid_p.y[grid_p.ind.b_bottom[1]] .^ 2) .- (num.R + speed*num.current_iter*num.timestep_n);
-                    u[grid_p.ind.b_left[1]] .= sqrt.(grid_p.x[grid_p.ind.b_left[1]] .^ 2 + grid_p.y[grid_p.ind.b_left[1]] .^ 2) .- (num.R + speed*num.current_iter*num.timestep_n);
-                    u[grid_p.ind.b_right[1]] .= sqrt.(grid_p.x[grid_p.ind.b_right[1]] .^ 2 + grid_p.y[grid_p.ind.b_right[1]] .^ 2) .- (num.R + speed*num.current_iter*num.timestep_n);
-                elseif num.nb_reinit > 0
-                    if auto_reinit == 1 && (num.current_iter-1)%num.reinit_every == 0
-                        for iLS in 1:num.nLS
-                            if !is_wall(BC_int[iLS])
-                                ls_rg, rl_rg_v = rg(num, grid_p, grid_p.LS[iLS].u, periodic_x, periodic_y, BC_int)
-                                println("$(ls_rg)")
-                                printstyled(color=:green, @sprintf "\n ls_rg : %.2e \n" ls_rg)
-                                if ls_rg >= num.δreinit || num.current_iter == 1
-                                    print("(ls_rg >= num.δreinit || num.current_iter == 1): yes")
-                                    # println("yes")
-                                    RK2_reinit!(ls_scheme, grid_p, grid_p.ind, iLS, grid_p.LS[iLS].u, num.nb_reinit, periodic_x, periodic_y, BC_u, BC_int)
-                                    
-                                    ls_rg, rl_rg_v = rg(num, grid_p, grid_p.LS[iLS].u, periodic_x, periodic_y, BC_int)
-                                    println("$(ls_rg) ")
-                                    printstyled(color=:green, @sprintf "\n ls_rg : %.2e \n" ls_rg)
-                                end
-                            end
-                        end
-                    elseif (num.current_iter-1)%num.reinit_every == 0
-                        for iLS in 1:num.nLS
-                            if !is_wall(BC_int[iLS])
-                                RK2_reinit!(ls_scheme, grid_p, grid_p.ind, iLS, grid_p.LS[iLS].u, num.nb_reinit, periodic_x, periodic_y, BC_u, BC_int)
-                            end
-                        end
-                    # elseif num.nLS > 1
-                    #     for iLS in 1:num.nLS
-                    #         if !is_wall(BC_int[iLS])
-                    #             RK2_reinit!(ls_scheme, grid_p, grid_p.ind, iLS, grid_p.LS[iLS].u, 2num.nb_reinit, periodic_x, periodic_y, BC_u, BC_int, true)
-                    #         end
-                    #     end
-                            end
-                        end
-
-                # Numerical breakup
-                if free_surface && breakup ==1
-                    count, id_break = breakup_n(grid_p.LS[1].u, grid_p.nx, grid_p.ny, grid_p.dx, grid_p.dy, periodic_x, periodic_y, NB_indices, 5e-2)
-                    println(count)
-                    if count > count_limit_breakup
-                        println("BREAK UP!!") 
-                        breakup_f(grid_p, grid_p.LS[1].u, id_break)
-                        RK2_reinit!(ls_scheme, grid_p, grid_p.ind, 1, grid_p.LS[1].u, num.nb_reinit, periodic_x, periodic_y, BC_u, BC_int)
-                    end
-                end
-
-            elseif num.levelset_reinitialize == -1
-                printstyled(color=:red, @sprintf "\n No reinit")
-
-
-            end #if num.levelset_reinitialize
-
-        end
-
-        #endregion reinitialize Levelset
-            
-        # printstyled(color=:red, @sprintf "\n after reinit radius: %.2e \n" num.current_radius)
-
-        if verbose
-            if (num.current_iter-1)%show_every == 0
-                printstyled(color=:green, @sprintf "\n Current iteration : %d (%d%%) | t = %.2e \n" (num.current_iter) 100*(num.current_iter)/num.max_iterations num.time)
-                
-                #TODO CFL
-                # printstyled(color=:green, @sprintf "\n num.CFL : %.2e num.CFL : %.2e num.timestep_n : %.2e\n" num.CFL max(abs.(grid_p.V)..., abs.(phL.u)..., abs.(phL.v)..., abs.(phS.u)..., abs.(phS.v)...)*num.timestep_n/num.Δ num.timestep_n)
-                
-                if heat && length(grid_p.LS[end].MIXED) != 0
-                    print(@sprintf "V_mean = %.2e  V_max = %.2e  V_min = %.2e\n" mean(grid_p.V[grid_p.LS[1].MIXED]) findmax(grid_p.V[grid_p.LS[1].MIXED])[1] findmin(grid_p.V[grid_p.LS[1].MIXED])[1])
-                    print(@sprintf "κ_mean = %.2e  κ_max = %.2e  κ_min = %.2e\n" mean(grid_p.LS[1].κ[grid_p.LS[1].MIXED]) findmax(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] findmin(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1])
-                elseif advection && length(grid_p.LS[end].MIXED) != 0
-                    V_mean = mean([mean(grid_u.V[grid_p.LS[1].MIXED]), mean(grid_v.V[grid_p.LS[1].MIXED])])
-                    V_max = max(findmax(grid_u.V[grid_p.LS[1].MIXED])[1], findmax(grid_v.V[grid_p.LS[1].MIXED])[1])
-                    V_min = min(findmin(grid_u.V[grid_p.LS[1].MIXED])[1], findmin(grid_v.V[grid_p.LS[1].MIXED])[1])
-                    # print(@sprintf "Vol_ratio = %.3f%%\n" (volume(grid_p.LS[end].geoL) / V0L * 100))
-                    print(@sprintf "V_mean = %.2e  V_max = %.2e  V_min = %.2e\n" V_mean V_max V_min)
-                    print(@sprintf "κ_mean = %.2e  κ_max = %.2e  κ_min = %.2e\n" mean(grid_p.LS[1].κ[grid_p.LS[1].MIXED]) findmax(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] findmin(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1])
-                end
-                if navier_stokes
-                    if ns_solid_phase
-                        normuS = norm(phS.u)
-                        normvS = norm(phS.v)
-                        normpS = norm(phS.p.*num.timestep_n)
-                        print("$(@sprintf("norm(uS) %.6e", normuS))\t$(@sprintf("norm(vS) %.6e", normvS))\t$(@sprintf("norm(pS) %.6e", normpS))\n")
-                    end
-                    if ns_liquid_phase
-                        # normuL = norm(phL.u)
-                        # normvL = norm(phL.v)
-                        # normpL = norm(phL.p.*num.timestep_n)
-                        # print("$(@sprintf("norm(uL) %.6e", normuL))\t$(@sprintf("norm(vL) %.6e", normvL))\t$(@sprintf("norm(pL) %.6e", normpL))\n")
-                        if electrolysis
-                            # print_electrolysis_statistics(num,grid_p,phL) 
-                            PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-                            "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-                            "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                            "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                            "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                            
-                            C_NULL::Ptr{Cvoid})::Cint
-                        end 
-                    end
-                end
-            end
-        end
-
-        PDI_status = @ccall "libpdi".PDI_multi_expose("write_after_advection"::Cstring,
-        "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,      
-        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,      
-        C_NULL::Ptr{Cvoid})::Cint
-
-        # if levelset && (advection || num.current_iter<2 || electrolysis_advection)
-        if levelset && (advection || num.current_iter<2)
-            try
-                NB_indices = update_all_ls_data(num, grid_p, grid_u, grid_v, BC_int, periodic_x, periodic_y) 
-            catch errorLS
-                println(@sprintf "\n CRASHED after %d iterations \n" num.current_iter)
-                printstyled(color=:red, @sprintf "\n grid_p.LS not updated \n")
-                print(errorLS)
-                print(errorLS.task.exception)
-                return
-            end
-            # printstyled(color=:red, @sprintf "\n levelset 4:\n")
-            # println(grid_p.LS[1].geoL.dcap[1,1,:])
-
-            grid_p.LS[end].geoL.fresh .= false
-            grid_u.LS[end].geoL.fresh .= false
-            grid_v.LS[end].geoL.fresh .= false
-
-            get_fresh_cells!(grid_p, grid_p.LS[end].geoL, Mm1_L, grid_p.ind.all_indices)
-            get_fresh_cells!(grid_u, grid_u.LS[end].geoL, Mum1_L, grid_u.ind.all_indices)
-            get_fresh_cells!(grid_v, grid_v.LS[end].geoL, Mvm1_L, grid_v.ind.all_indices)
-
-            FRESH_L_u = findall(grid_u.LS[end].geoL.fresh)
-            FRESH_L_v = findall(grid_v.LS[end].geoL.fresh)
-
-            if navier_stokes
-
-                init_fresh_cells!(grid_u, veci(phL.uD,grid_u,1), veci(phL.uD,grid_u,1),
-                    grid_u.LS[end].geoL.projection, FRESH_L_u, periodic_x, periodic_y)
-                init_fresh_cells!(grid_v, veci(phL.vD,grid_v,1), veci(phL.vD,grid_v,1),
-                    grid_v.LS[end].geoL.projection, FRESH_L_v, periodic_x, periodic_y)
-                if num.nLS>1 #not monophasic
-                    init_fresh_cells!(grid_u, veci(phL.uD,grid_u,2), veci(phL.uD,grid_u,1),
-                        grid_u.LS[end].geoL.projection, FRESH_L_u, periodic_x, periodic_y)
-                    init_fresh_cells!(grid_v, veci(phL.vD,grid_v,2), veci(phL.vD,grid_v,1),
-                        grid_v.LS[end].geoL.projection, FRESH_L_v, periodic_x, periodic_y)
-                end
-            end
-
-            if num.solve_solid == 1 
-                grid_p.LS[end].geoS.fresh .= false
-                grid_u.LS[end].geoS.fresh .= false
-                grid_v.LS[end].geoS.fresh .= false
-
-                get_fresh_cells!(grid_p, grid_p.LS[end].geoS, Mm1_S, grid_p.ind.all_indices)
-                get_fresh_cells!(grid_u, grid_u.LS[end].geoS, Mum1_S, grid_u.ind.all_indices)
-                get_fresh_cells!(grid_v, grid_v.LS[end].geoS, Mvm1_S, grid_v.ind.all_indices)
-
-                FRESH_S_u = findall(grid_u.LS[end].geoS.fresh)
-                FRESH_S_v = findall(grid_v.LS[end].geoS.fresh)
-                
-                if navier_stokes
-                    init_fresh_cells!(grid_u, veci(phL.uD,grid_u,1), veci(phL.uD,grid_u,1),
-                        grid_u.LS[end].geoL.projection, FRESH_L_u, periodic_x, periodic_y)
-                    init_fresh_cells!(grid_v, veci(phL.vD,grid_v,1), veci(phL.vD,grid_v,1),
-                        grid_v.LS[end].geoL.projection, FRESH_L_v, periodic_x, periodic_y)
-                    if num.nLS>1 #not monophasic
-                        init_fresh_cells!(grid_u, veci(phL.uD,grid_u,2), veci(phL.uD,grid_u,1),
-                            grid_u.LS[end].geoL.projection, FRESH_L_u, periodic_x, periodic_y)
-                        init_fresh_cells!(grid_v, veci(phL.vD,grid_v,2), veci(phL.vD,grid_v,1),
-                            grid_v.LS[end].geoL.projection, FRESH_L_v, periodic_x, periodic_y)
-                    end
-                end
-            end
-
-            if iszero(num.current_iter%num.save_every) || num.current_iter==num.max_iterations
-                snap = num.current_iter÷num.save_every+1
-                if save_radius
-                    radius[snap] = find_radius(grid_p, grid_p.LS[1])
-                end
-                if hill
-                    a = zeros(length(grid_p.LS[1].MIXED))
-                    for i in eachindex(grid_p.LS[1].MIXED)
-                        a[i] = grid_p.LS[1].geoL.projection[grid_p.LS[1].MIXED[i]].pos.y
-                    end
-                    radius[snap] = mean(a)
-                end
-                # if save_length
-                #     fwd.length[snap] = arc_length2(grid_p.LS[1].geoS.projection, grid_p.LS[1].MIXED)
-                # end
-            end
-        end
-
-
-        if num.nLS>1 #not monophasic
-            intfc_vtx_x,intfc_vtx_y,intfc_vtx_field,intfc_vtx_connectivities,intfc_vtx_num, intfc_seg_num = convert_interfacial_D_to_segments(num,grid_p,phL.TD,1,2)
-    
-            barycenter_x_coord = mean(intfc_vtx_x)
-
-            PDI_status = @ccall "libpdi".PDI_multi_expose("update_levelset"::Cstring,
-            "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-            "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,      
-            "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-            "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,        
-            "intfc_vtx_num"::Cstring, intfc_vtx_num::Ref{Clonglong}, PDI_OUT::Cint, 
-            "intfc_seg_num"::Cstring, intfc_seg_num::Ref{Clonglong}, PDI_OUT::Cint, 
-            "intfc_vtx_x"::Cstring, intfc_vtx_x::Ptr{Cdouble}, PDI_OUT::Cint,
-            "intfc_vtx_y"::Cstring, intfc_vtx_y::Ptr{Cdouble}, PDI_OUT::Cint,
-            "intfc_vtx_field"::Cstring, intfc_vtx_field::Ptr{Cdouble}, PDI_OUT::Cint,
-            "intfc_vtx_connectivities"::Cstring, intfc_vtx_connectivities::Ptr{Clonglong}, PDI_OUT::Cint,
-            "barycenter_x_coord"::Cstring, barycenter_x_coord::Ref{Cdouble}, PDI_OUT::Cint,
-            C_NULL::Ptr{Cvoid})::Cint
-        end
-
-        #endregion Advection 
-
-        #region old Navier-Stokes block
-        # cf old_Navier_Stokes_block.jl
-        #endregion old Navier-Stokes block
-
-
-        #region end loop post-processing
-
-        if (num.one_fluid_model == 1 &&  num.solve_Navier_Stokes_liquid_phase == 1) 
-
-            # interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-
-            tmp_vec_p  .= 0.0
-            tmp_vec_p0 .= 0.0
-
-            for j = 1:grid_p.ny
-            for i = 1:grid_p.nx
-                tmp_vec_p[j,i] =(phL.u[j,i]+phL.u[j,i+1])/2
-                tmp_vec_p0[j,i]=(phL.v[j,i]+phL.v[j+1,i])/2
-            end
-            end
-
-            #TODO compute once, write once
-            update_one_fluid_density_viscosity(num,grid_p,grid_u,grid_v,volume_fraction,levelset_one_fluid,rho_one_fluid,
-                                                rho_one_fluid_u,rho_one_fluid_v,mu_one_fluid,tmp_vec_p0)
-
-        end
-
-        #endregion end loop post-processing
-
-        # cD, cL, D, L = force_coefficients!(num, grid_p, grid_u, grid_v, op.opL, fwd, phL; step = num.current_iter+1, saveCoeffs = false)
-
-        # if iszero(num.current_iter%num.save_every) || num.current_iter==num.max_iterations
-        #     snap = num.current_iter÷num.save_every+1
-        #     if num.current_iter==num.max_iterations
-        #         snap = size(fwd.T,1)
-        #     end
-        #     fwd.t[snap] = num.time
-        #     @views fwd.V[snap,:,:] .= grid_p.V
-        #     if advection
-        #         fwdS.Vratio[snap] = volume(grid_p.LS[end].geoS) / V0S
-        #         fwdL.Vratio[snap] = volume(grid_p.LS[end].geoL) / V0L
-        #     end
-        # end
-        # @views fwd.Cd[num.current_iter+1] = cD
-        # @views fwd.Cl[num.current_iter+1] = cL
-        # # @views fwd.radius[num.current_iter+1] = num.current_radius
-
-        # PDI (IO)
-        if electrolysis
-            if num.io_pdi>0
-
-                try
-                    # printstyled(color=:red, @sprintf "\n PDI test \n" )
-            
-               
-                    # phi_array=phL.phi_ele #do not transpose since python row major
-                    
-                    # Compute electrical current, interpolate velocity on scalar grid_p
-                    #                     if num.electrical_potential>0 compute_grad_phi_ele!(num, grid_p, grid_u, grid_v, phL, phS, op.opC_pL, op.opC_pS) #TODO current
-
-                    if num.electrical_potential>0
-                        compute_grad_phi_ele!(num, grid_p, grid_u, grid_v, grid_u.LS[end], grid_v.LS[end], phL,
-                        op.opC_pL, elec_cond,tmp_vec_u,tmp_vec_v,tmp_vec_p,tmp_vec_p0,tmp_vec_p1) #TODO current
-                    end
-
-                    # #store in us, vs instead of Eus, Evs
-                    # interpolate_grid_liquid!(grid_p,grid_u,grid_v,phL.Eu, phL.Ev,tmp_vec_p,tmp_vec_p0)
-
-                    # #TODO i_current_mag need cond
-
-                    # @ccall "libpdi".PDI_multi_expose("write_data_elec"::Cstring,
-                    # "i_current_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    # "i_current_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,  
-                    # "i_current_mag"::Cstring, phL.i_current_mag::Ptr{Cdouble}, PDI_OUT::Cint,
-                    # "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    # C_NULL::Ptr{Cvoid})::Cint
-
-                    # interpolate_grid_liquid!(grid_p,grid_u,grid_v,phL.Eu, phL.Ev,Eus,Evs)
-                    
-                    interpolate_staggered_u_v_to_scalar_grid_one_fluid_or_one_phase!(num,grid_p,grid_u,grid_v,phL.u,phL.v,tmp_vec_p,tmp_vec_p0)
-                        
-                    # num.iLSpdi = 1 # TODO all grid_p.LS
-
-                    # Exposing data to PDI for IO    
-                    # if writing "D" array (bulk, interface, border), add "_1D" to the name
-
-                    PDI_status = @ccall "libpdi".PDI_multi_expose("write_data"::Cstring,
-                    "nstep"::Cstring, num.current_iter::Ref{Clonglong}, PDI_OUT::Cint,
-                    "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                    "timestep"::Cstring, num.timestep_n::Ref{Cdouble}, PDI_OUT::Cint,  
-                    "nx"::Cstring, grid_p.nx::Ref{Clonglong}, PDI_OUT::Cint,
-                    "ny"::Cstring, grid_p.ny::Ref{Clonglong}, PDI_OUT::Cint,    
-                    "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                    "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,                   
-                    "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    "velocity_x"::Cstring, tmp_vec_p::Ptr{Cdouble}, PDI_OUT::Cint,   
-                    "velocity_y"::Cstring, tmp_vec_p0::Ptr{Cdouble}, PDI_OUT::Cint,      
-                    "radius"::Cstring, num.current_radius::Ref{Cdouble}, PDI_OUT::Cint, 
-                    C_NULL::Ptr{Cvoid})::Cint
-            
-                        
-            
-                catch error
-                    printstyled(color=:red, @sprintf "\n PDI error \n")
-                    print(error)
-                    printstyled(color=:red, @sprintf "\n PDI error \n")
-                end
-
-               
-            end #if io_pdi
-
-
-
-            if num.status == 1 #due to num.nH2<0...
-                return
-            end
-
-
-            #region test NaN
-            if num.solve_solid == 1
-
-                if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                    any(isnan, phS.uD) || any(isnan, phS.vD) || any(isnan, phS.TD) ||
-                    any(isnan, phL.trans_scalD) || any(isnan, phL.phi_eleD) ||
-                    norm(phL.u) > 1e8 || norm(phL.T) > 1e8 || 
-                    norm(phS.u) > 1e8 || norm(phS.T) > 1e8 || 
-                    # norm(phL.trans_scal) > 1e8 || 
-                    norm(phL.phi_ele) > 1e8 
-                    # ||
-                    # any(phL.trans_scal .<0)
-                    )
-                    println(@sprintf "\n CRASHED start \n")
-                    
-                    print("\n phL.uD: ",any(isnan, phL.uD) , "\n phL.vD: ",any(isnan, phL.vD) , "\n phL.TD: ",any(isnan, phL.TD) ,
-                    "\n phS.uD: ",any(isnan, phS.uD) , "\n phS.vD: ",any(isnan, phS.vD) , "\n phS.TD: ",any(isnan, phS.TD) ,
-                    "\n phL.trans_scalD: ",any(isnan, phL.trans_scalD) , "\n phL.phi_eleD: ",any(isnan, phL.phi_eleD) ,
-                    "\n phL.u: ",norm(phL.u) > 1e8 , "\n phS.u: ",norm(phS.u) > 1e8 , "\n phL.T: ",norm(phL.T) > 1e8 , 
-                    "\n phS.T: ",norm(phS.T) > 1e8 , "\n phL.trans_scal: ",norm(phL.trans_scal) > 1e8 ,
-                    "\n phL.phi_ele: ",norm(phL.phi_ele) > 1e8,"\n any(phL.trans_scal .<0): ", any(phL.trans_scal .<0))
-    
-                    num.status =  1
-    
-                end
-            else 
-    
-                if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                    any(isnan, phL.trans_scalD) || any(isnan, phL.phi_eleD) ||
-                    norm(phL.u) > 1e8 || norm(phL.T) > 1e8 || 
-                    # norm(phL.trans_scal) > 1e8 || 
-                    norm(phL.phi_ele) > 1e8 
-                    # ||
-                    # any(phL.trans_scal .<0)
-                    )
-                    println(@sprintf "\n CRASHED start \n")
-    
-                    # println(@sprintf "\n CRASHED after %d iterations \n" num.current_iter)
-                    
-                    print("\n phL.uD: ",any(isnan, phL.uD) , "\n phL.vD: ",any(isnan, phL.vD) , "\n phL.TD: ",any(isnan, phL.TD) ,
-                    "\n phL.trans_scalD: ",any(isnan, phL.trans_scalD) , "\n phL.phi_eleD: ",any(isnan, phL.phi_eleD) ,
-                    "\n phL.u: ",norm(phL.u) > 1e8, "\n phL.T: ",norm(phL.T) > 1e8 , 
-                    "\n phL.trans_scal: ",norm(phL.trans_scal) > 1e8 ,
-                    "\n phL.phi_ele: ",norm(phL.phi_ele) > 1e8,"\n any(phL.trans_scal .<0): ", any(phL.trans_scal .<0))
-    
-                    num.status =  1
-    
-                end
-    
-            end
-
-            if num.status == 1
-                
-                PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-                        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                           
-                        C_NULL::Ptr{Cvoid})::Cint
-               
-                return num.current_iter
-            end
-
-
-          
-        else #not electrolysis
-
-            if num.solve_solid == 1
-
-                if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                    any(isnan, phS.uD) || any(isnan, phS.vD) || any(isnan, phS.TD) ||
-                    norm(phL.u) > 1e8 || norm(phS.u) > 1e8 || norm(phL.T) > 1e8 || norm(phS.T) > 1e8)
-                    println(@sprintf "\n CRASHED after %d iterations \n" num.current_iter)
-                
-                    num.status =  1
-                    return
-                    
-                end
-
-            else
-
-                if (any(isnan, phL.uD) || any(isnan, phL.vD) || any(isnan, phL.TD) || 
-                    norm(phL.u) > 1e8 || norm(phL.T) > 1e8 )
-                    println(@sprintf "\n CRASHED after %d iterations \n" num.current_iter)
-                
-                    num.status =  1
-                    return
-                    
-                end
-
-            end
-
-        end #if electrolysis
-        
-        #endregion test NaN
-
-
-        #region update iter number and time
-
-        # num.current_iter += 1
-      
-        if num.time + num.timestep_n > num.end_time
-            print("\n num.time + num.timestep_n > num.end_time, break")
-            break
-        end
-
-       
-        #endregion update iter number and time
-
-    end 
-    #endregion time loop
-
-    #region print end
-    if verbose
-        try
-            printstyled(color=:blue, @sprintf "\n Final iteration : %d (%d%%) | t = %.2e \n" (num.current_iter-1) 100*(num.current_iter-1)/num.max_iterations num.time)
-            print("\n num.time ",num.time," stop_simulation ",num.stop_simulation)
-            print("\n num.time ",num.time," num.end_time",num.end_time,"num.timestep_n",num.timestep_n)
-            print("\n")
-            if stefan && advection
-                print(@sprintf "V_mean = %.2e  V_max = %.2e  V_min = %.2e  V_stdev = %.5f\n" mean(grid_p.V[grid_p.LS[1].MIXED]) findmax(grid_p.V[grid_p.LS[1].MIXED])[1] findmin(grid_p.V[grid_p.LS[1].MIXED])[1] std(grid_p.V[grid_p.LS[1].MIXED]))
-                print(@sprintf "κ_mean = %.2e  κ_max = %.2e  κ_min = %.2e  κ_stdev = %.5f\n" mean(grid_p.LS[1].κ[grid_p.LS[1].MIXED]) findmax(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] findmin(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] std(grid_p.LS[1].κ[grid_p.LS[1].MIXED]))
-            end
-            if free_surface && advection
-                # print(@sprintf "Vol_ratio = %.3f%%\n" (volume(grid_p.LS[end].geoL) / V0L * 100))
-                print(@sprintf "V_mean = %.2e  V_max = %.2e  V_min = %.2e  V_stdev = %.5f\n" mean(grid_p.V[grid_p.LS[1].MIXED]) findmax(grid_p.V[grid_p.LS[1].MIXED])[1] findmin(grid_p.V[grid_p.LS[1].MIXED])[1] std(grid_p.V[grid_p.LS[1].MIXED]))
-                print(@sprintf "κ_mean = %.2e  κ_max = %.2e  κ_min = %.2e  κ_stdev = %.5f\n" mean(grid_p.LS[1].κ[grid_p.LS[1].MIXED]) findmax(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] findmin(grid_p.LS[1].κ[grid_p.LS[1].MIXED])[1] std(grid_p.LS[1].κ[grid_p.LS[1].MIXED]))
-            end
-            if navier_stokes
-                if ns_solid_phase
-                    normuS = norm(phS.u)
-                    normvS = norm(phS.v)
-                    normpS = norm(phS.p.*num.timestep_n)
-                    print("$(@sprintf("norm(uS) %.6e", normuS))\t$(@sprintf("norm(vS) %.6e", normvS))\t$(@sprintf("norm(pS) %.6e", normpS))\n")
-                end
-                if ns_liquid_phase
-                    normuL = norm(phL.u)
-                    normvL = norm(phL.v)
-                    normpL = norm(phL.p.*num.timestep_n)
-                    print("$(@sprintf("norm(uL) %.6e", normuL))\t$(@sprintf("norm(vL) %.6e", normvL))\t$(@sprintf("norm(pL) %.6e", normpL))\n")
-                    if electrolysis
-                        print_electrolysis_statistics(num,grid_p,phL)
-                        PDI_status = @ccall "libpdi".PDI_multi_expose("print_variables"::Cstring,
-                        "nstep"::Cstring, num.current_iter ::Ref{Clonglong}, PDI_OUT::Cint,
-                        "time"::Cstring, num.time::Ref{Cdouble}, PDI_OUT::Cint,
-                        "u_1D"::Cstring, phL.uD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "v_1D"::Cstring, phL.vD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "p_1D"::Cstring, phL.pD::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_p"::Cstring, grid_p.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_u"::Cstring, grid_u.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "levelset_v"::Cstring, grid_v.LS[num.iLSpdi].u::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "trans_scal_1DT"::Cstring, phL.trans_scalD'::Ptr{Cdouble}, PDI_OUT::Cint,
-                        "phi_ele_1D"::Cstring, phL.phi_eleD::Ptr{Cdouble}, PDI_OUT::Cint,                        
-                        C_NULL::Ptr{Cvoid})::Cint
-
-                    end 
-                end
-            end
-            print("\n\n")
-        catch
-            @show (length(grid_p.LS[end].MIXED))
-        end
-    end #if verbose
-    #endregion print end
-
-    if levelset && (save_radius || hill)
-        #TODO save radius
-        return # radius
-    # elseif flapping
-    #     return xc, yc
-    else
-        return
-    end
-end
-