# 📖 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