7.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-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 /*----------------------------------------------------------------------------*/
651 /*----------------------------------------------------------------------------*/
652 
653 bool
654 cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
655  cs_hodge_t *hodge,
656  cs_cell_builder_t *cb);
657 
658 /*----------------------------------------------------------------------------*/
670 /*----------------------------------------------------------------------------*/
671 
672 bool
673 cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
674  cs_hodge_t *hodge,
675  cs_cell_builder_t *cb);
676 
677 /*----------------------------------------------------------------------------*/
690 /*----------------------------------------------------------------------------*/
691 
692 bool
693 cs_hodge_fb_get(const cs_cell_mesh_t *cm,
694  cs_hodge_t *hodge,
695  cs_cell_builder_t *cb);
696 
697 /*----------------------------------------------------------------------------*/
710 /*----------------------------------------------------------------------------*/
711 
712 bool
713 cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
714  cs_hodge_t *hodge,
715  cs_cell_builder_t *cb);
716 
717 /*----------------------------------------------------------------------------*/
729 /*----------------------------------------------------------------------------*/
730 
731 bool
732 cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
733  cs_hodge_t *hodge,
734  cs_cell_builder_t *cb);
735 
736 /*----------------------------------------------------------------------------*/
749 /*----------------------------------------------------------------------------*/
750 
751 bool
752 cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
753  cs_hodge_t *hodge,
754  cs_cell_builder_t *cb);
755 
756 /*----------------------------------------------------------------------------*/
769 /*----------------------------------------------------------------------------*/
770 
771 bool
772 cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
773  cs_hodge_t *hodge,
774  cs_cell_builder_t *cb);
775 
776 /*----------------------------------------------------------------------------*/
789 /*----------------------------------------------------------------------------*/
790 
791 bool
792 cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
793  cs_hodge_t *hodge,
794  cs_cell_builder_t *cb);
795 
796 /*----------------------------------------------------------------------------*/
809 /*----------------------------------------------------------------------------*/
810 
811 bool
812 cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
813  cs_hodge_t *hodge,
814  cs_cell_builder_t *cb);
815 
816 /*----------------------------------------------------------------------------*/
830 /*----------------------------------------------------------------------------*/
831 
832 bool
833 cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
834  cs_hodge_t *hodge,
835  cs_cell_builder_t *cb);
836 
837 /*----------------------------------------------------------------------------*/
852 /*----------------------------------------------------------------------------*/
853 
854 bool
855 cs_hodge_epfd_ocs2_get(const cs_cell_mesh_t *cm,
856  cs_hodge_t *hodge,
857  cs_cell_builder_t *cb);
858 
859 /*----------------------------------------------------------------------------*/
872 /*----------------------------------------------------------------------------*/
873 
874 bool
875 cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
876  cs_hodge_t *hodge,
877  cs_cell_builder_t *cb);
878 
879 /*----------------------------------------------------------------------------*/
892 /*----------------------------------------------------------------------------*/
893 
894 bool
895 cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
896  cs_hodge_t *hodge,
897  cs_cell_builder_t *cb);
898 
899 /*----------------------------------------------------------------------------*/
912 /*----------------------------------------------------------------------------*/
913 
914 bool
915 cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
916  cs_hodge_t *hodge,
917  cs_cell_builder_t *cb);
918 
919 /*----------------------------------------------------------------------------*/
932 /*----------------------------------------------------------------------------*/
933 
934 bool
935 cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
936  cs_hodge_t *hodge,
937  cs_cell_builder_t *cb);
938 
939 /*----------------------------------------------------------------------------*/
951 /*----------------------------------------------------------------------------*/
952 
953 bool
954 cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
955  cs_hodge_t *hodge,
956  cs_cell_builder_t *cb);
957 
958 /*----------------------------------------------------------------------------*/
971 /*----------------------------------------------------------------------------*/
972 
973 bool
974 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
975  cs_hodge_t *hodge,
976  cs_cell_builder_t *cb);
977 
978 /*----------------------------------------------------------------------------*/
990 /*----------------------------------------------------------------------------*/
991 
992 bool
993 cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
994  cs_hodge_t *hodge,
995  cs_cell_builder_t *cb);
996 
997 /*----------------------------------------------------------------------------*/
1010 /*----------------------------------------------------------------------------*/
1011 
1012 bool
1013 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
1014  cs_hodge_t *hodge,
1015  cs_cell_builder_t *cb);
1016 
1017 /*----------------------------------------------------------------------------*/
1030 /*----------------------------------------------------------------------------*/
1031 
1032 void
1033 cs_hodge_matvec(const cs_cdo_connect_t *connect,
1034  const cs_cdo_quantities_t *quant,
1035  const cs_hodge_param_t hodgep,
1036  const cs_property_t *pty,
1037  const cs_real_t in_vals[],
1038  cs_real_t t_eval,
1039  cs_real_t result[]);
1040 
1041 /*----------------------------------------------------------------------------*/
1054 /*----------------------------------------------------------------------------*/
1055 
1056 void
1057 cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
1058  const cs_cdo_quantities_t *quant,
1059  cs_real_t t_eval,
1060  const cs_hodge_param_t hodgep,
1061  const cs_property_t *pty,
1062  const cs_real_t flux[],
1063  cs_real_t circul[]);
1064 
1065 /*----------------------------------------------------------------------------*/
1074 /*----------------------------------------------------------------------------*/
1075 
1076 void
1077 cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
1078  cs_sdm_t *hf);
1079 
1080 /*----------------------------------------------------------------------------*/
1081 
1082 END_C_DECLS
1083 
1084 #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:3453
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:4763
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:4250
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:1888
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:2349
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:2161
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:3105
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:1438
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:199
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:3597
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:3775
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
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 standing for Whitney Barycentric Subdi...
Definition: cs_hodge.c:2730
cs_hodge_free
void cs_hodge_free(cs_hodge_t **p_hodge)
Free a cs_hodge_t structure.
Definition: cs_hodge.c:1379
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:2098
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:2029
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:2623
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:3689
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:1807
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:1340
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:3832
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:3185
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:1580
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:2223
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:1405
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:3999
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:4336
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:3019
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:1725
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 standing for Whitney Barycentric Subdi...
Definition: cs_hodge.c:2867
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:1276
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:1959
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:3908
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:4652
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:511
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:2285
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:4422
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:4085
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:2398
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:3324
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:1660
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:4161
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:3515
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:1699
CS_HODGE_TYPE_CPVD
Definition: cs_hodge.h:87