9.2
general documentation
cs_hodge.h
Go to the documentation of this file.
1#ifndef CS_HODGE_H
2#define CS_HODGE_H
3
4/*============================================================================
5 * Manage discrete Hodge operators and closely related operators
6 *============================================================================*/
7
8/*
9 This file is part of code_saturne, a general-purpose CFD tool.
10
11 Copyright (C) 1998-2026 EDF S.A.
12
13 This program is free software; you can redistribute it and/or modify it under
14 the terms of the GNU General Public License as published by the Free Software
15 Foundation; either version 2 of the License, or (at your option) any later
16 version.
17
18 This program is distributed in the hope that it will be useful, but WITHOUT
19 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21 details.
22
23 You should have received a copy of the GNU General Public License along with
24 this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25 Street, Fifth Floor, Boston, MA 02110-1301, USA.
26*/
27
28/*----------------------------------------------------------------------------
29 * Standard C library headers
30 *----------------------------------------------------------------------------*/
31
32/*----------------------------------------------------------------------------
33 * Local headers
34 *----------------------------------------------------------------------------*/
35
36#include "cdo/cs_cdo_connect.h"
37#include "cdo/cs_cdo_local.h"
38#include "cdo/cs_cdo_quantities.h"
39#include "cdo/cs_param_cdo.h"
40#include "cdo/cs_property.h"
41#include "cdo/cs_sdm.h"
42
43/*============================================================================
44 * Macro and type definitions
45 *============================================================================*/
46
80typedef enum {
81
82 CS_HODGE_TYPE_VPCD,
83 CS_HODGE_TYPE_EPFD,
84 CS_HODGE_TYPE_FPED,
85 CS_HODGE_TYPE_EDFP,
86 CS_HODGE_TYPE_CPVD,
87 CS_HODGE_TYPE_VDCP,
88 CS_HODGE_TYPE_FB,
89 CS_HODGE_TYPE_VC,
90
91 CS_HODGE_N_TYPES
92
93} cs_hodge_type_t;
94
129typedef enum {
130
131 CS_HODGE_ALGO_VORONOI,
132 CS_HODGE_ALGO_WBS,
133 CS_HODGE_ALGO_COST,
134 CS_HODGE_ALGO_BUBBLE,
135 CS_HODGE_ALGO_AUTO,
136
137 CS_HODGE_N_ALGOS
138
139} cs_hodge_algo_t;
140
147typedef struct {
148
149 bool inv_pty;
150
158 cs_hodge_type_t type;
159 cs_hodge_algo_t algo;
161 double coef;
162
169} cs_hodge_param_t;
170
171/* DISCRETE HODGE OPERATORS */
172/* ======================== */
173
179typedef struct {
180
181 const cs_hodge_param_t *param;
183 cs_property_data_t *pty_data;
184
191 cs_sdm_t *matrix;
193} cs_hodge_t;
194
195/*----------------------------------------------------------------------------*/
211/*----------------------------------------------------------------------------*/
212
213typedef bool
214(cs_hodge_compute_t)(const cs_cell_mesh_t *cm,
215 cs_hodge_t *hodge,
216 cs_cell_builder_t *cb);
217
218/*============================================================================
219 * Static inline public function definitions
220 *============================================================================*/
221
222/*----------------------------------------------------------------------------*/
232/*----------------------------------------------------------------------------*/
233
234static inline bool
235cs_hodge_param_is_similar(const cs_hodge_param_t h1_info,
236 const cs_hodge_param_t h2_info)
237{
238 if (h1_info.type != h2_info.type)
239 return false;
240 if (h1_info.algo != h2_info.algo)
241 return false;
242 if (h1_info.algo == CS_HODGE_ALGO_COST ||
243 h1_info.algo == CS_HODGE_ALGO_BUBBLE) {
244 if (cs::abs(h1_info.coef - h2_info.coef) > 0)
245 return false;
246 else
247 return true;
248 }
249 else
250 return true;
251}
252
253/*============================================================================
254 * Public function definitions
255 *============================================================================*/
256
257/*----------------------------------------------------------------------------*/
269/*----------------------------------------------------------------------------*/
270
271cs_hodge_t *
272cs_hodge_create(const cs_cdo_connect_t *connect,
273 const cs_property_t *property,
274 const cs_hodge_param_t *hp,
275 bool need_tensor,
276 bool need_eigen);
277
278/*----------------------------------------------------------------------------*/
292/*----------------------------------------------------------------------------*/
293
294cs_hodge_t **
295cs_hodge_init_context(const cs_cdo_connect_t *connect,
296 const cs_property_t *property,
297 const cs_hodge_param_t *hp,
298 bool need_tensor,
299 bool need_eigen);
300
301/*----------------------------------------------------------------------------*/
307/*----------------------------------------------------------------------------*/
308
309void
310cs_hodge_free(cs_hodge_t **p_hodge);
311
312/*----------------------------------------------------------------------------*/
318/*----------------------------------------------------------------------------*/
319
320void
321cs_hodge_free_context(cs_hodge_t ***p_hodges);
322
323/*----------------------------------------------------------------------------*/
332/*----------------------------------------------------------------------------*/
333
334cs_hodge_compute_t *
335cs_hodge_get_func(const char *calling_func,
336 const cs_hodge_param_t hp);
337
338/*----------------------------------------------------------------------------*/
351/*----------------------------------------------------------------------------*/
352
353cs_hodge_algo_t
354cs_hodge_set_mass_algo(const char *eqname,
355 cs_hodge_algo_t reac_algo,
356 cs_hodge_algo_t time_algo);
357
358/*----------------------------------------------------------------------------*/
366/*----------------------------------------------------------------------------*/
367
368void
369cs_hodge_param_log(const char *prefix,
370 const cs_property_t *property,
371 const cs_hodge_param_t hp);
372
373/*----------------------------------------------------------------------------*/
381/*----------------------------------------------------------------------------*/
382
383void
384cs_hodge_copy_parameters(const cs_hodge_param_t *h_ref,
385 cs_hodge_param_t *h_cpy);
386
387/*----------------------------------------------------------------------------*/
398/*----------------------------------------------------------------------------*/
399
400void
401cs_hodge_evaluate_property(const cs_lnum_t c_id,
402 const cs_real_t t_eval,
403 const cs_flag_t c_flag,
404 cs_hodge_t *hodge);
405
406/*----------------------------------------------------------------------------*/
418/*----------------------------------------------------------------------------*/
419
420void
421cs_hodge_evaluate_property_cw(const cs_cell_mesh_t *cm,
422 const cs_real_t t_eval,
423 const cs_flag_t c_flag,
424 cs_hodge_t *hodge);
425
426/*----------------------------------------------------------------------------*/
439/*----------------------------------------------------------------------------*/
440
441bool
442cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm,
443 cs_hodge_t *hodge,
444 cs_cell_builder_t *cb);
445
446/*----------------------------------------------------------------------------*/
460/*----------------------------------------------------------------------------*/
461
462bool
463cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm,
464 cs_hodge_t *hodge,
465 cs_cell_builder_t *cb);
466
467/*----------------------------------------------------------------------------*/
480/*----------------------------------------------------------------------------*/
481
482bool
483cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm,
484 cs_hodge_t *hodge,
485 cs_cell_builder_t *cb);
486
487/*----------------------------------------------------------------------------*/
500/*----------------------------------------------------------------------------*/
501
502bool
503cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm,
504 cs_hodge_t *hodge,
505 cs_cell_builder_t *cb);
506
507/*----------------------------------------------------------------------------*/
520/*----------------------------------------------------------------------------*/
521
522bool
523cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm,
524 cs_hodge_t *hodge,
525 cs_cell_builder_t *cb);
526
527/*----------------------------------------------------------------------------*/
540/*----------------------------------------------------------------------------*/
541
542bool
543cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm,
544 cs_hodge_t *hodge,
545 cs_cell_builder_t *cb);
546
547/*----------------------------------------------------------------------------*/
560/*----------------------------------------------------------------------------*/
561
562bool
563cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm,
564 cs_hodge_t *hodge,
565 cs_cell_builder_t *cb);
566
567/*----------------------------------------------------------------------------*/
580/*----------------------------------------------------------------------------*/
581
582bool
583cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm,
584 cs_hodge_t *hodge,
585 cs_cell_builder_t *cb);
586
587/*----------------------------------------------------------------------------*/
600/*----------------------------------------------------------------------------*/
601
602bool
603cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm,
604 cs_hodge_t *hodge,
605 cs_cell_builder_t *cb);
606
607/*----------------------------------------------------------------------------*/
619/*----------------------------------------------------------------------------*/
620
621bool
622cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
623 cs_hodge_t *hodge,
624 cs_cell_builder_t *cb);
625
626/*----------------------------------------------------------------------------*/
638/*----------------------------------------------------------------------------*/
639
640bool
641cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
642 cs_hodge_t *hodge,
643 cs_cell_builder_t *cb);
644
645/*----------------------------------------------------------------------------*/
658/*----------------------------------------------------------------------------*/
659
660bool
661cs_hodge_fb_get(const cs_cell_mesh_t *cm,
662 cs_hodge_t *hodge,
663 cs_cell_builder_t *cb);
664
665/*----------------------------------------------------------------------------*/
678/*----------------------------------------------------------------------------*/
679
680bool
681cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
682 cs_hodge_t *hodge,
683 cs_cell_builder_t *cb);
684
685/*----------------------------------------------------------------------------*/
697/*----------------------------------------------------------------------------*/
698
699bool
700cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
701 cs_hodge_t *hodge,
702 cs_cell_builder_t *cb);
703
704/*----------------------------------------------------------------------------*/
717/*----------------------------------------------------------------------------*/
718
719bool
720cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
721 cs_hodge_t *hodge,
722 cs_cell_builder_t *cb);
723
724/*----------------------------------------------------------------------------*/
737/*----------------------------------------------------------------------------*/
738
739bool
740cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
741 cs_hodge_t *hodge,
742 cs_cell_builder_t *cb);
743
744/*----------------------------------------------------------------------------*/
757/*----------------------------------------------------------------------------*/
758
759bool
760cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
761 cs_hodge_t *hodge,
762 cs_cell_builder_t *cb);
763
764/*----------------------------------------------------------------------------*/
777/*----------------------------------------------------------------------------*/
778
779bool
780cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
781 cs_hodge_t *hodge,
782 cs_cell_builder_t *cb);
783
784/*----------------------------------------------------------------------------*/
798/*----------------------------------------------------------------------------*/
799
800bool
801cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
802 cs_hodge_t *hodge,
803 cs_cell_builder_t *cb);
804
805/*----------------------------------------------------------------------------*/
818/*----------------------------------------------------------------------------*/
819
820bool
821cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
822 cs_hodge_t *hodge,
823 cs_cell_builder_t *cb);
824
825/*----------------------------------------------------------------------------*/
838/*----------------------------------------------------------------------------*/
839
840bool
841cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
842 cs_hodge_t *hodge,
843 cs_cell_builder_t *cb);
844
845/*----------------------------------------------------------------------------*/
858/*----------------------------------------------------------------------------*/
859
860bool
861cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
862 cs_hodge_t *hodge,
863 cs_cell_builder_t *cb);
864
865/*----------------------------------------------------------------------------*/
878/*----------------------------------------------------------------------------*/
879
880bool
881cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
882 cs_hodge_t *hodge,
883 cs_cell_builder_t *cb);
884
885/*----------------------------------------------------------------------------*/
897/*----------------------------------------------------------------------------*/
898
899bool
900cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
901 cs_hodge_t *hodge,
902 cs_cell_builder_t *cb);
903
904/*----------------------------------------------------------------------------*/
917/*----------------------------------------------------------------------------*/
918
919bool
920cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
921 cs_hodge_t *hodge,
922 cs_cell_builder_t *cb);
923
924/*----------------------------------------------------------------------------*/
936/*----------------------------------------------------------------------------*/
937
938bool
939cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
940 cs_hodge_t *hodge,
941 cs_cell_builder_t *cb);
942
943/*----------------------------------------------------------------------------*/
956/*----------------------------------------------------------------------------*/
957
958bool
959cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
960 cs_hodge_t *hodge,
961 cs_cell_builder_t *cb);
962
963/*----------------------------------------------------------------------------*/
976/*----------------------------------------------------------------------------*/
977
978void
979cs_hodge_matvec(const cs_cdo_connect_t *connect,
980 const cs_cdo_quantities_t *quant,
981 const cs_hodge_param_t hodgep,
982 const cs_property_t *pty,
983 const cs_real_t in_vals[],
984 cs_real_t t_eval,
985 cs_real_t result[]);
986
987/*----------------------------------------------------------------------------*/
1000/*----------------------------------------------------------------------------*/
1001
1002void
1003cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
1004 const cs_cdo_quantities_t *quant,
1005 cs_real_t t_eval,
1006 const cs_hodge_param_t hodgep,
1007 const cs_property_t *pty,
1008 const cs_real_t flux[],
1009 cs_real_t circul[]);
1010
1011/*----------------------------------------------------------------------------*/
1020/*----------------------------------------------------------------------------*/
1021
1022void
1023cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
1024 cs_sdm_t *hf);
1025
1026#endif /* CS_HODGE_H */
cs_cdo_connect.h
cs_cdo_local.h
cs_cdo_quantities.h
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:332
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:325
cs_flag_t
unsigned short int cs_flag_t
Definition: cs_defs.h:334
fm
@ fm
Definition: cs_field_pointer.h:126
cs_hodge_compute_t
bool() cs_hodge_compute_t(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a discrete Hodge operator or a related operator (such as the stiffmess matrix) for a given cell...
Definition: cs_hodge.h:214
cs_hodge_vcb_wbs_get
bool cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the WBS algo. This function is specific for verte...
Definition: cs_hodge.cpp:2957
cs_hodge_set_mass_algo
cs_hodge_algo_t cs_hodge_set_mass_algo(const char *eqname, cs_hodge_algo_t reac_algo, cs_hodge_algo_t time_algo)
Check the consistency of the settings between terms related to a mass matrix and define the common al...
Definition: cs_hodge.cpp:1451
cs_hodge_compute_wbs_surfacic
void cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm, cs_sdm_t *hf)
Compute the hodge operator related to a face (i.e. a mass matrix with unity property) using a Whitney...
Definition: cs_hodge.cpp:4462
cs_hodge_copy_parameters
void cs_hodge_copy_parameters(const cs_hodge_param_t *h_ref, cs_hodge_param_t *h_cpy)
Copy the set of parameters associated to a discrete Hodge operator to another one.
Definition: cs_hodge.cpp:1527
cs_hodge_param_is_similar
static bool cs_hodge_param_is_similar(const cs_hodge_param_t h1_info, const cs_hodge_param_t h2_info)
Check if two sets of parameters related to how build a discrete Hodge operator are similar.
Definition: cs_hodge.h:235
cs_hodge_vb_bubble_get_aniso_stiffness
bool cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic Bubble algo. The computed matrix is stored in cb->lo...
Definition: cs_hodge.cpp:2109
cs_hodge_epfd_voro_get
bool cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using VORONOI algo. Hodge op. from primal edges to dual...
Definition: cs_hodge.cpp:3287
cs_hodge_fped_voro_get
bool cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using VORONOI algo. Hodge op. from primal faces to dual...
Definition: cs_hodge.cpp:3545
cs_hodge_edfp_cost_get_opt
bool cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the COST algo. Hodge op. from dual edges to prima...
Definition: cs_hodge.cpp:3964
cs_hodge_fped_cost_get
bool cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the COST algo. Hodge op. from primal faces to dua...
Definition: cs_hodge.cpp:3621
cs_hodge_edfp_bubble_get
bool cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the Bubble algo. Hodge op. from dual edges to pri...
Definition: cs_hodge.cpp:4050
cs_hodge_vb_cost_get_iso_stiffness
bool cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic COST algo. The computed matrix is stored in cb->loc ...
Definition: cs_hodge.cpp:1922
cs_hodge_fped_bubble_get
bool cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the Bubble algo. Hodge op. from primal faces to d...
Definition: cs_hodge.cpp:3712
cs_hodge_init_context
cs_hodge_t ** cs_hodge_init_context(const cs_cdo_connect_t *connect, const cs_property_t *property, const cs_hodge_param_t *hp, bool need_tensor, bool need_eigen)
Create and initialize an array of pointers to a cs_hodge_t structures. This array is of size the numb...
Definition: cs_hodge.cpp:1215
cs_hodge_edfp_cost_get
bool cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the COST algo. Hodge op. from dual edges to prima...
Definition: cs_hodge.cpp:3875
cs_hodge_create
cs_hodge_t * cs_hodge_create(const cs_cdo_connect_t *connect, const cs_property_t *property, const cs_hodge_param_t *hp, bool need_tensor, bool need_eigen)
Create and initialize a pointer to a cs_hodge_t structure.
Definition: cs_hodge.cpp:1150
cs_hodge_vpcd_wbs_get
bool cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using WBS algo. Hodge op. from primal vertices to dual ...
Definition: cs_hodge.cpp:3096
cs_hodge_fb_bubble_get_stiffness
bool cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic COST algo. with the usage of bubble stabilization....
Definition: cs_hodge.cpp:1783
cs_hodge_vcb_get_stiffness
bool cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic WBS algo. WBS means Whitney Barycentric Subdivision ...
Definition: cs_hodge.cpp:2639
cs_hodge_vcb_voro_get
bool cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the Voronoi algo. This leads to a diagonal operat...
Definition: cs_hodge.cpp:2877
cs_hodge_free_context
void cs_hodge_free_context(cs_hodge_t ***p_hodges)
Free a set of cs_hodge_t structures.
Definition: cs_hodge.cpp:1280
cs_hodge_matvec
void cs_hodge_matvec(const cs_cdo_connect_t *connect, const cs_cdo_quantities_t *quant, const cs_hodge_param_t hodgep, const cs_property_t *pty, const cs_real_t in_vals[], cs_real_t t_eval, cs_real_t result[])
Compute cellwise a discrete hodge operator and multiple it with a vector.
Definition: cs_hodge.cpp:4136
cs_hodge_algo_t
cs_hodge_algo_t
Type of algorithm to build a discrete Hodge operator.
Definition: cs_hodge.h:129
CS_HODGE_ALGO_WBS
@ CS_HODGE_ALGO_WBS
Definition: cs_hodge.h:132
CS_HODGE_ALGO_AUTO
@ CS_HODGE_ALGO_AUTO
Definition: cs_hodge.h:135
CS_HODGE_ALGO_BUBBLE
@ CS_HODGE_ALGO_BUBBLE
Definition: cs_hodge.h:134
CS_HODGE_ALGO_VORONOI
@ CS_HODGE_ALGO_VORONOI
Definition: cs_hodge.h:131
CS_HODGE_N_ALGOS
@ CS_HODGE_N_ALGOS
Definition: cs_hodge.h:137
CS_HODGE_ALGO_COST
@ CS_HODGE_ALGO_COST
Definition: cs_hodge.h:133
cs_hodge_vb_cost_get_aniso_stiffness
bool cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic COST algo. The computed matrix is stored in cb->loc ...
Definition: cs_hodge.cpp:1985
cs_hodge_fb_cost_get_stiffness
bool cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic COST algo. The computed matrix is stored in cb->loc ...
Definition: cs_hodge.cpp:1716
cs_hodge_fb_voro_get_stiffness
bool cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the Voronoi algorithm The computed matrix is stored in cb->loc a...
Definition: cs_hodge.cpp:1853
cs_hodge_epfd_bubble_get
bool cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the COST algo. with a bubble stabilization....
Definition: cs_hodge.cpp:3461
cs_hodge_circulation_from_flux
void cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect, const cs_cdo_quantities_t *quant, cs_real_t t_eval, const cs_hodge_param_t hodgep, const cs_property_t *pty, const cs_real_t flux[], cs_real_t circul[])
Compute cellwise a discrete hodge operator in order to define a circulation array from a flux array.
Definition: cs_hodge.cpp:4357
cs_hodge_evaluate_property_cw
void cs_hodge_evaluate_property_cw(const cs_cell_mesh_t *cm, const cs_real_t t_eval, const cs_flag_t c_flag, cs_hodge_t *hodge)
Set the property value (scalar- or tensor-valued) related to a discrete Hodge operator inside a cell ...
Definition: cs_hodge.cpp:1635
cs_hodge_vb_cost_get_stiffness
bool cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic COST algo. The computed matrix is stored in cb->loc ...
Definition: cs_hodge.cpp:2171
cs_hodge_evaluate_property
void cs_hodge_evaluate_property(const cs_lnum_t c_id, const cs_real_t t_eval, const cs_flag_t c_flag, cs_hodge_t *hodge)
Set the property value (scalar- or tensor-valued) related to a discrete Hodge operator inside a cell ...
Definition: cs_hodge.cpp:1553
cs_hodge_epfd_cost_get
bool cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using the COST algo. Hodge op. from primal edges to dua...
Definition: cs_hodge.cpp:3369
cs_hodge_vb_wbs_get_stiffness
bool cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic WBS algo. WBS means for Whitney Barycentric Subdivis...
Definition: cs_hodge.cpp:2502
cs_hodge_get_func
cs_hodge_compute_t * cs_hodge_get_func(const char *calling_func, const cs_hodge_param_t hp)
Retrieve a function pointer to compute a discrete Hodge operator.
Definition: cs_hodge.cpp:1313
cs_hodge_type_t
cs_hodge_type_t
Type of discrete Hodge operators.
Definition: cs_hodge.h:80
CS_HODGE_N_TYPES
@ CS_HODGE_N_TYPES
Definition: cs_hodge.h:91
CS_HODGE_TYPE_VPCD
@ CS_HODGE_TYPE_VPCD
Definition: cs_hodge.h:82
CS_HODGE_TYPE_EDFP
@ CS_HODGE_TYPE_EDFP
Definition: cs_hodge.h:85
CS_HODGE_TYPE_VDCP
@ CS_HODGE_TYPE_VDCP
Definition: cs_hodge.h:87
CS_HODGE_TYPE_VC
@ CS_HODGE_TYPE_VC
Definition: cs_hodge.h:89
CS_HODGE_TYPE_FPED
@ CS_HODGE_TYPE_FPED
Definition: cs_hodge.h:84
CS_HODGE_TYPE_CPVD
@ CS_HODGE_TYPE_CPVD
Definition: cs_hodge.h:86
CS_HODGE_TYPE_EPFD
@ CS_HODGE_TYPE_EPFD
Definition: cs_hodge.h:83
CS_HODGE_TYPE_FB
@ CS_HODGE_TYPE_FB
Definition: cs_hodge.h:88
cs_hodge_fb_get
bool cs_hodge_fb_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator on a given cell which is equivalent of a mass matrix....
Definition: cs_hodge.cpp:2791
cs_hodge_vpcd_voro_get
bool cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using VORONOI algo. Hodge op. from primal vertices to d...
Definition: cs_hodge.cpp:3225
cs_hodge_free
void cs_hodge_free(cs_hodge_t **p_hodge)
Free a cs_hodge_t structure.
Definition: cs_hodge.cpp:1254
cs_hodge_edfp_voro_get
bool cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local Hodge operator for a given cell using VORONOI algo. Hodge op. from dual edges to primal...
Definition: cs_hodge.cpp:3798
cs_hodge_vb_voro_get_stiffness
bool cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the Voronoi algorithm The computed matrix is stored in cb->loc a...
Definition: cs_hodge.cpp:2396
cs_hodge_param_log
void cs_hodge_param_log(const char *prefix, const cs_property_t *property, const cs_hodge_param_t hp)
Output the settings related to a cs_hodge_param_t structure.
Definition: cs_hodge.cpp:1491
cs_hodge_vb_bubble_get_iso_stiffness
bool cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm, cs_hodge_t *hodge, cs_cell_builder_t *cb)
Build a local stiffness matrix using the generic Bubble algo. The computed matrix is stored in cb->lo...
Definition: cs_hodge.cpp:2047
cs_param_cdo.h
cs_property.h
cs_sdm.h
cs::abs
CS_F_HOST_DEVICE T abs(const T a)
Definition: cs_defs.h:690
cs_cdo_connect_t
Definition: cs_cdo_connect.h:57
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:142
cs_cell_builder_t
Set of local and temporary buffers.
Definition: cs_cdo_local.h:56
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:242
cs_face_mesh_t
Set of local quantities and connectivities related to a mesh face Structure used to get a better memo...
Definition: cs_cdo_local.h:432
cs_hodge_param_t
Structure storing all metadata/parameters related to the usage of a discrete Hodge operator.
Definition: cs_hodge.h:147
cs_hodge_param_t::coef
double coef
Scaling coefficient value.
Definition: cs_hodge.h:161
cs_hodge_param_t::type
cs_hodge_type_t type
Definition: cs_hodge.h:158
cs_hodge_param_t::inv_pty
bool inv_pty
Inversion of the property evaluation or not.
Definition: cs_hodge.h:149
cs_hodge_param_t::algo
cs_hodge_algo_t algo
Definition: cs_hodge.h:159
cs_hodge_t
Structure associated to a discrete Hodge operator *.
Definition: cs_hodge.h:179
cs_hodge_t::matrix
cs_sdm_t * matrix
Definition: cs_hodge.h:191
cs_hodge_t::param
const cs_hodge_param_t * param
Definition: cs_hodge.h:181
cs_hodge_t::pty_data
cs_property_data_t * pty_data
Data evaluation.
Definition: cs_hodge.h:183
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:219
cs_property_t
Structure associated to the definition of a property relying on the cs_xdef_t structure.