7.3
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-2022 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 "cs_cdo_connect.h"
37 #include "cs_cdo_local.h"
38 #include "cs_cdo_quantities.h"
39 #include "cs_param_cdo.h"
40 #include "cs_property.h"
41 #include "cs_sdm.h"
42 
43 /*----------------------------------------------------------------------------*/
44 
45 BEGIN_C_DECLS
46 
47 /*============================================================================
48  * Macro and type definitions
49  *============================================================================*/
50 
81 typedef enum {
82 
83  CS_HODGE_TYPE_VPCD,
84  CS_HODGE_TYPE_EPFD,
85  CS_HODGE_TYPE_FPED,
86  CS_HODGE_TYPE_EDFP,
87  CS_HODGE_TYPE_CPVD,
88  CS_HODGE_TYPE_FB,
89  CS_HODGE_TYPE_VC,
90 
91  CS_HODGE_N_TYPES
92 
93 } cs_hodge_type_t;
94 
135 typedef enum {
136 
137  CS_HODGE_ALGO_VORONOI,
138  CS_HODGE_ALGO_WBS,
139  CS_HODGE_ALGO_COST,
140  CS_HODGE_ALGO_OCS2,
141  CS_HODGE_ALGO_BUBBLE,
142  CS_HODGE_ALGO_AUTO,
143 
144  CS_HODGE_N_ALGOS
145 
146 } cs_hodge_algo_t;
147 
154 typedef struct {
155 
156  bool inv_pty;
157 
165  cs_hodge_type_t type;
166  cs_hodge_algo_t algo;
168  double coef;
169 
176 } cs_hodge_param_t;
177 
178 /* DISCRETE HODGE OPERATORS */
179 /* ======================== */
180 
186 typedef struct {
187 
188  const cs_hodge_param_t *param;
190  cs_property_data_t *pty_data;
191 
198  cs_sdm_t *matrix;
200 } cs_hodge_t;
201 
202 /*----------------------------------------------------------------------------*/
218 /*----------------------------------------------------------------------------*/
219 
220 typedef bool
221 (cs_hodge_compute_t)(const cs_cell_mesh_t *cm,
222  cs_hodge_t *hodge,
223  cs_cell_builder_t *cb);
224 
225 /*============================================================================
226  * Static inline public function definitions
227  *============================================================================*/
228 
229 /*----------------------------------------------------------------------------*/
239 /*----------------------------------------------------------------------------*/
240 
241 static inline bool
242 cs_hodge_param_is_similar(const cs_hodge_param_t h1_info,
243  const cs_hodge_param_t h2_info)
244 {
245  if (h1_info.type != h2_info.type)
246  return false;
247  if (h1_info.algo != h2_info.algo)
248  return false;
249  if (h1_info.algo == CS_HODGE_ALGO_COST ||
250  h1_info.algo == CS_HODGE_ALGO_BUBBLE) {
251  if (fabs(h1_info.coef - h2_info.coef) > 0)
252  return false;
253  else
254  return true;
255  }
256  else
257  return true;
258 }
259 
260 /*============================================================================
261  * Public function definitions
262  *============================================================================*/
263 
264 /*----------------------------------------------------------------------------*/
276 /*----------------------------------------------------------------------------*/
277 
278 cs_hodge_t *
279 cs_hodge_create(const cs_cdo_connect_t *connect,
280  const cs_property_t *property,
281  const cs_hodge_param_t *hp,
282  bool need_tensor,
283  bool need_eigen);
284 
285 /*----------------------------------------------------------------------------*/
299 /*----------------------------------------------------------------------------*/
300 
301 cs_hodge_t **
302 cs_hodge_init_context(const cs_cdo_connect_t *connect,
303  const cs_property_t *property,
304  const cs_hodge_param_t *hp,
305  bool need_tensor,
306  bool need_eigen);
307 
308 /*----------------------------------------------------------------------------*/
314 /*----------------------------------------------------------------------------*/
315 
316 void
317 cs_hodge_free(cs_hodge_t **p_hodge);
318 
319 /*----------------------------------------------------------------------------*/
325 /*----------------------------------------------------------------------------*/
326 
327 void
328 cs_hodge_free_context(cs_hodge_t ***p_hodges);
329 
330 /*----------------------------------------------------------------------------*/
339 /*----------------------------------------------------------------------------*/
340 
341 cs_hodge_compute_t *
342 cs_hodge_get_func(const char *calling_func,
343  const cs_hodge_param_t hp);
344 
345 /*----------------------------------------------------------------------------*/
359 /*----------------------------------------------------------------------------*/
360 
361 cs_hodge_algo_t
362 cs_hodge_set_mass_algo(const char *eqname,
363  cs_hodge_algo_t reac_algo,
364  cs_hodge_algo_t time_algo,
365  cs_hodge_algo_t srct_algo);
366 
367 /*----------------------------------------------------------------------------*/
375 /*----------------------------------------------------------------------------*/
376 
377 void
378 cs_hodge_param_log(const char *prefix,
379  const cs_property_t *property,
380  const cs_hodge_param_t hp);
381 
382 /*----------------------------------------------------------------------------*/
390 /*----------------------------------------------------------------------------*/
391 
392 void
393 cs_hodge_copy_parameters(const cs_hodge_param_t *h_ref,
394  cs_hodge_param_t *h_cpy);
395 
396 /*----------------------------------------------------------------------------*/
407 /*----------------------------------------------------------------------------*/
408 
409 void
410 cs_hodge_set_property_value(const cs_lnum_t c_id,
411  const cs_real_t t_eval,
412  const cs_flag_t c_flag,
413  cs_hodge_t *hodge);
414 
415 /*----------------------------------------------------------------------------*/
427 /*----------------------------------------------------------------------------*/
428 
429 void
430 cs_hodge_set_property_value_cw(const cs_cell_mesh_t *cm,
431  const cs_real_t t_eval,
432  const cs_flag_t c_flag,
433  cs_hodge_t *hodge);
434 
435 /*----------------------------------------------------------------------------*/
448 /*----------------------------------------------------------------------------*/
449 
450 bool
451 cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm,
452  cs_hodge_t *hodge,
453  cs_cell_builder_t *cb);
454 
455 /*----------------------------------------------------------------------------*/
469 /*----------------------------------------------------------------------------*/
470 
471 bool
472 cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm,
473  cs_hodge_t *hodge,
474  cs_cell_builder_t *cb);
475 
476 /*----------------------------------------------------------------------------*/
489 /*----------------------------------------------------------------------------*/
490 
491 bool
492 cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm,
493  cs_hodge_t *hodge,
494  cs_cell_builder_t *cb);
495 
496 /*----------------------------------------------------------------------------*/
509 /*----------------------------------------------------------------------------*/
510 
511 bool
512 cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm,
513  cs_hodge_t *hodge,
514  cs_cell_builder_t *cb);
515 
516 /*----------------------------------------------------------------------------*/
529 /*----------------------------------------------------------------------------*/
530 
531 bool
532 cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm,
533  cs_hodge_t *hodge,
534  cs_cell_builder_t *cb);
535 
536 /*----------------------------------------------------------------------------*/
549 /*----------------------------------------------------------------------------*/
550 
551 bool
552 cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm,
553  cs_hodge_t *hodge,
554  cs_cell_builder_t *cb);
555 
556 /*----------------------------------------------------------------------------*/
569 /*----------------------------------------------------------------------------*/
570 
571 bool
572 cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm,
573  cs_hodge_t *hodge,
574  cs_cell_builder_t *cb);
575 
576 /*----------------------------------------------------------------------------*/
591 /*----------------------------------------------------------------------------*/
592 
593 bool
594 cs_hodge_vb_ocs2_get_aniso_stiffness(const cs_cell_mesh_t *cm,
595  cs_hodge_t *hodge,
596  cs_cell_builder_t *cb);
597 
598 /*----------------------------------------------------------------------------*/
611 /*----------------------------------------------------------------------------*/
612 
613 bool
614 cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm,
615  cs_hodge_t *hodge,
616  cs_cell_builder_t *cb);
617 
618 /*----------------------------------------------------------------------------*/
631 /*----------------------------------------------------------------------------*/
632 
633 bool
634 cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm,
635  cs_hodge_t *hodge,
636  cs_cell_builder_t *cb);
637 
638 /*----------------------------------------------------------------------------*/
650 /*----------------------------------------------------------------------------*/
651 
652 bool
653 cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
654  cs_hodge_t *hodge,
655  cs_cell_builder_t *cb);
656 
657 /*----------------------------------------------------------------------------*/
669 /*----------------------------------------------------------------------------*/
670 
671 bool
672 cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
673  cs_hodge_t *hodge,
674  cs_cell_builder_t *cb);
675 
676 /*----------------------------------------------------------------------------*/
689 /*----------------------------------------------------------------------------*/
690 
691 bool
692 cs_hodge_fb_get(const cs_cell_mesh_t *cm,
693  cs_hodge_t *hodge,
694  cs_cell_builder_t *cb);
695 
696 /*----------------------------------------------------------------------------*/
709 /*----------------------------------------------------------------------------*/
710 
711 bool
712 cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
713  cs_hodge_t *hodge,
714  cs_cell_builder_t *cb);
715 
716 /*----------------------------------------------------------------------------*/
728 /*----------------------------------------------------------------------------*/
729 
730 bool
731 cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
732  cs_hodge_t *hodge,
733  cs_cell_builder_t *cb);
734 
735 /*----------------------------------------------------------------------------*/
748 /*----------------------------------------------------------------------------*/
749 
750 bool
751 cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
752  cs_hodge_t *hodge,
753  cs_cell_builder_t *cb);
754 
755 /*----------------------------------------------------------------------------*/
768 /*----------------------------------------------------------------------------*/
769 
770 bool
771 cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
772  cs_hodge_t *hodge,
773  cs_cell_builder_t *cb);
774 
775 /*----------------------------------------------------------------------------*/
788 /*----------------------------------------------------------------------------*/
789 
790 bool
791 cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
792  cs_hodge_t *hodge,
793  cs_cell_builder_t *cb);
794 
795 /*----------------------------------------------------------------------------*/
808 /*----------------------------------------------------------------------------*/
809 
810 bool
811 cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
812  cs_hodge_t *hodge,
813  cs_cell_builder_t *cb);
814 
815 /*----------------------------------------------------------------------------*/
829 /*----------------------------------------------------------------------------*/
830 
831 bool
832 cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
833  cs_hodge_t *hodge,
834  cs_cell_builder_t *cb);
835 
836 /*----------------------------------------------------------------------------*/
851 /*----------------------------------------------------------------------------*/
852 
853 bool
854 cs_hodge_epfd_ocs2_get(const cs_cell_mesh_t *cm,
855  cs_hodge_t *hodge,
856  cs_cell_builder_t *cb);
857 
858 /*----------------------------------------------------------------------------*/
871 /*----------------------------------------------------------------------------*/
872 
873 bool
874 cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
875  cs_hodge_t *hodge,
876  cs_cell_builder_t *cb);
877 
878 /*----------------------------------------------------------------------------*/
891 /*----------------------------------------------------------------------------*/
892 
893 bool
894 cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
895  cs_hodge_t *hodge,
896  cs_cell_builder_t *cb);
897 
898 /*----------------------------------------------------------------------------*/
911 /*----------------------------------------------------------------------------*/
912 
913 bool
914 cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
915  cs_hodge_t *hodge,
916  cs_cell_builder_t *cb);
917 
918 /*----------------------------------------------------------------------------*/
931 /*----------------------------------------------------------------------------*/
932 
933 bool
934 cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
935  cs_hodge_t *hodge,
936  cs_cell_builder_t *cb);
937 
938 /*----------------------------------------------------------------------------*/
950 /*----------------------------------------------------------------------------*/
951 
952 bool
953 cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
954  cs_hodge_t *hodge,
955  cs_cell_builder_t *cb);
956 
957 /*----------------------------------------------------------------------------*/
970 /*----------------------------------------------------------------------------*/
971 
972 bool
973 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
974  cs_hodge_t *hodge,
975  cs_cell_builder_t *cb);
976 
977 /*----------------------------------------------------------------------------*/
989 /*----------------------------------------------------------------------------*/
990 
991 bool
992 cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
993  cs_hodge_t *hodge,
994  cs_cell_builder_t *cb);
995 
996 /*----------------------------------------------------------------------------*/
1009 /*----------------------------------------------------------------------------*/
1010 
1011 bool
1012 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
1013  cs_hodge_t *hodge,
1014  cs_cell_builder_t *cb);
1015 
1016 /*----------------------------------------------------------------------------*/
1029 /*----------------------------------------------------------------------------*/
1030 
1031 void
1032 cs_hodge_matvec(const cs_cdo_connect_t *connect,
1033  const cs_cdo_quantities_t *quant,
1034  const cs_hodge_param_t hodgep,
1035  const cs_property_t *pty,
1036  const cs_real_t in_vals[],
1037  cs_real_t t_eval,
1038  cs_real_t result[]);
1039 
1040 /*----------------------------------------------------------------------------*/
1053 /*----------------------------------------------------------------------------*/
1054 
1055 void
1056 cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
1057  const cs_cdo_quantities_t *quant,
1058  cs_real_t t_eval,
1059  const cs_hodge_param_t hodgep,
1060  const cs_property_t *pty,
1061  const cs_real_t flux[],
1062  cs_real_t circul[]);
1063 
1064 /*----------------------------------------------------------------------------*/
1073 /*----------------------------------------------------------------------------*/
1074 
1075 void
1076 cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
1077  cs_sdm_t *hf);
1078 
1079 /*----------------------------------------------------------------------------*/
1080 
1081 END_C_DECLS
1082 
1083 #endif /* __CS_HODGE_H__ */
CS_HODGE_TYPE_EDFP
Definition: cs_hodge.h:86
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.c:3449
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.c:4759
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.c:4246
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.c:1885
cs_hodge_vb_ocs2_get_aniso_stiffness
bool cs_hodge_vb_ocs2_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 Orthogonal Consistent/Sub-Stabilization decomposition (OCS2)...
Definition: cs_hodge.c:2346
cs_hodge_param_t::inv_pty
bool inv_pty
Inversion of the property evaluation or not.
Definition: cs_hodge.h:156
CS_HODGE_TYPE_VPCD
Definition: cs_hodge.h:83
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.c:2158
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.c:3101
cs_hodge_param_t::type
cs_hodge_type_t type
Definition: cs_hodge.h:165
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:242
cs_cdo_connect.h
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.c:1435
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:211
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.c:3593
cs_hodge_epfd_ocs2_get
bool cs_hodge_epfd_ocs2_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 Orthogonal Consistent/Sub-Stabilization decom...
Definition: cs_hodge.c:3771
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:512
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.c:2726
cs_hodge_free
void cs_hodge_free(cs_hodge_t **p_hodge)
Free a cs_hodge_t structure.
Definition: cs_hodge.c:1376
CS_HODGE_TYPE_VC
Definition: cs_hodge.h:89
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.c:2095
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.c:2026
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.c:2620
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:203
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. The discrete Hodge operator is stored in hodge->matrix Hodge op. from primal edges to dual faces. This function is specific for vertex-based schemes.
Definition: cs_hodge.c:3685
cs_hodge_set_property_value_cw
void cs_hodge_set_property_value_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.c:1804
cs_cdo_connect_t
Definition: cs_cdo_connect.h:61
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.c:1337
CS_HODGE_N_ALGOS
Definition: cs_hodge.h:144
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.c:3828
cs_hodge_t
Structure associated to a discrete Hodge operator *.
Definition: cs_hodge.h:186
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:132
cs_hodge_param_t::coef
double coef
Scaling coefficient value.
Definition: cs_hodge.h:168
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.c:3181
cs_property.h
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, cs_hodge_algo_t srct_algo)
Check the consistency of the settings between terms related to a mass matrix and define the common al...
Definition: cs_hodge.c:1577
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.c:2220
fm
Definition: cs_field_pointer.h:128
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.c:1402
CS_HODGE_ALGO_VORONOI
Definition: cs_hodge.h:137
CS_HODGE_N_TYPES
Definition: cs_hodge.h:91
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.c:3995
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.c:4332
cs_hodge_type_t
cs_hodge_type_t
Type of discrete Hodge operators.
Definition: cs_hodge.h:81
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. It relies on a CO+ST algo. and is specific to CDO-Fb schemes. The discrete Hodge operator is stored in hodge->matrix.
Definition: cs_hodge.c:3015
CS_HODGE_ALGO_WBS
Definition: cs_hodge.h:138
cs_hodge_set_property_value
void cs_hodge_set_property_value(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.c:1722
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.c:2863
cs_hodge_algo_t
cs_hodge_algo_t
Type of algorithm to build a discrete Hodge operator.
Definition: cs_hodge.h:135
cs_cell_builder_t
Set of local and temporary buffers.
Definition: cs_cdo_local.h:60
cs_param_cdo.h
CS_HODGE_ALGO_OCS2
Definition: cs_hodge.h:140
CS_HODGE_ALGO_BUBBLE
Definition: cs_hodge.h:141
cs_cdo_quantities.h
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.c:1273
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.c:1956
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
cs_hodge_t::param
const cs_hodge_param_t * param
Definition: cs_hodge.h:188
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.c:3904
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.c:4648
cs_hodge_t::pty_data
cs_property_data_t * pty_data
Data evaluation.
Definition: cs_hodge.h:190
cs_cdo_local.h
cs_hodge_t::matrix
cs_sdm_t * matrix
Definition: cs_hodge.h:198
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:513
CS_HODGE_ALGO_AUTO
Definition: cs_hodge.h:142
cs_flag_t
unsigned short int cs_flag_t
Definition: cs_defs.h:324
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.c:2282
CS_HODGE_TYPE_FB
Definition: cs_hodge.h:88
CS_HODGE_ALGO_COST
Definition: cs_hodge.h:139
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.c:4418
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.c:4081
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.c:2395
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:279
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:221
cs_hodge_param_t::algo
cs_hodge_algo_t algo
Definition: cs_hodge.h:166
CS_HODGE_TYPE_FPED
Definition: cs_hodge.h:85
CS_HODGE_TYPE_EPFD
Definition: cs_hodge.h:84
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.c:3320
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.c:1657
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.c:4157
cs_property_t
Structure associated to the definition of a property relying on the cs_xdef_t structure.
cs_hodge_param_t
Structure storing all metadata/parameters related to the usage of a discrete Hodge operator...
Definition: cs_hodge.h:154
cs_sdm.h
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.c:3511
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.c:1696
CS_HODGE_TYPE_CPVD
Definition: cs_hodge.h:87