8.0
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-2023 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 
84 typedef enum {
85 
86  CS_HODGE_TYPE_VPCD,
87  CS_HODGE_TYPE_EPFD,
88  CS_HODGE_TYPE_FPED,
89  CS_HODGE_TYPE_EDFP,
90  CS_HODGE_TYPE_CPVD,
91  CS_HODGE_TYPE_VDCP,
92  CS_HODGE_TYPE_FB,
93  CS_HODGE_TYPE_VC,
94 
95  CS_HODGE_N_TYPES
96 
97 } cs_hodge_type_t;
98 
133 typedef enum {
134 
135  CS_HODGE_ALGO_VORONOI,
136  CS_HODGE_ALGO_WBS,
137  CS_HODGE_ALGO_COST,
138  CS_HODGE_ALGO_BUBBLE,
139  CS_HODGE_ALGO_AUTO,
140 
141  CS_HODGE_N_ALGOS
142 
143 } cs_hodge_algo_t;
144 
151 typedef struct {
152 
153  bool inv_pty;
154 
162  cs_hodge_type_t type;
163  cs_hodge_algo_t algo;
165  double coef;
166 
173 } cs_hodge_param_t;
174 
175 /* DISCRETE HODGE OPERATORS */
176 /* ======================== */
177 
183 typedef struct {
184 
185  const cs_hodge_param_t *param;
187  cs_property_data_t *pty_data;
188 
195  cs_sdm_t *matrix;
197 } cs_hodge_t;
198 
199 /*----------------------------------------------------------------------------*/
215 /*----------------------------------------------------------------------------*/
216 
217 typedef bool
218 (cs_hodge_compute_t)(const cs_cell_mesh_t *cm,
219  cs_hodge_t *hodge,
220  cs_cell_builder_t *cb);
221 
222 /*============================================================================
223  * Static inline public function definitions
224  *============================================================================*/
225 
226 /*----------------------------------------------------------------------------*/
236 /*----------------------------------------------------------------------------*/
237 
238 static inline bool
239 cs_hodge_param_is_similar(const cs_hodge_param_t h1_info,
240  const cs_hodge_param_t h2_info)
241 {
242  if (h1_info.type != h2_info.type)
243  return false;
244  if (h1_info.algo != h2_info.algo)
245  return false;
246  if (h1_info.algo == CS_HODGE_ALGO_COST ||
247  h1_info.algo == CS_HODGE_ALGO_BUBBLE) {
248  if (fabs(h1_info.coef - h2_info.coef) > 0)
249  return false;
250  else
251  return true;
252  }
253  else
254  return true;
255 }
256 
257 /*============================================================================
258  * Public function definitions
259  *============================================================================*/
260 
261 /*----------------------------------------------------------------------------*/
273 /*----------------------------------------------------------------------------*/
274 
275 cs_hodge_t *
276 cs_hodge_create(const cs_cdo_connect_t *connect,
277  const cs_property_t *property,
278  const cs_hodge_param_t *hp,
279  bool need_tensor,
280  bool need_eigen);
281 
282 /*----------------------------------------------------------------------------*/
296 /*----------------------------------------------------------------------------*/
297 
298 cs_hodge_t **
299 cs_hodge_init_context(const cs_cdo_connect_t *connect,
300  const cs_property_t *property,
301  const cs_hodge_param_t *hp,
302  bool need_tensor,
303  bool need_eigen);
304 
305 /*----------------------------------------------------------------------------*/
311 /*----------------------------------------------------------------------------*/
312 
313 void
314 cs_hodge_free(cs_hodge_t **p_hodge);
315 
316 /*----------------------------------------------------------------------------*/
322 /*----------------------------------------------------------------------------*/
323 
324 void
325 cs_hodge_free_context(cs_hodge_t ***p_hodges);
326 
327 /*----------------------------------------------------------------------------*/
336 /*----------------------------------------------------------------------------*/
337 
338 cs_hodge_compute_t *
339 cs_hodge_get_func(const char *calling_func,
340  const cs_hodge_param_t hp);
341 
342 /*----------------------------------------------------------------------------*/
355 /*----------------------------------------------------------------------------*/
356 
357 cs_hodge_algo_t
358 cs_hodge_set_mass_algo(const char *eqname,
359  cs_hodge_algo_t reac_algo,
360  cs_hodge_algo_t time_algo);
361 
362 /*----------------------------------------------------------------------------*/
370 /*----------------------------------------------------------------------------*/
371 
372 void
373 cs_hodge_param_log(const char *prefix,
374  const cs_property_t *property,
375  const cs_hodge_param_t hp);
376 
377 /*----------------------------------------------------------------------------*/
385 /*----------------------------------------------------------------------------*/
386 
387 void
388 cs_hodge_copy_parameters(const cs_hodge_param_t *h_ref,
389  cs_hodge_param_t *h_cpy);
390 
391 /*----------------------------------------------------------------------------*/
402 /*----------------------------------------------------------------------------*/
403 
404 void
405 cs_hodge_set_property_value(const cs_lnum_t c_id,
406  const cs_real_t t_eval,
407  const cs_flag_t c_flag,
408  cs_hodge_t *hodge);
409 
410 /*----------------------------------------------------------------------------*/
422 /*----------------------------------------------------------------------------*/
423 
424 void
425 cs_hodge_set_property_value_cw(const cs_cell_mesh_t *cm,
426  const cs_real_t t_eval,
427  const cs_flag_t c_flag,
428  cs_hodge_t *hodge);
429 
430 /*----------------------------------------------------------------------------*/
443 /*----------------------------------------------------------------------------*/
444 
445 bool
446 cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm,
447  cs_hodge_t *hodge,
448  cs_cell_builder_t *cb);
449 
450 /*----------------------------------------------------------------------------*/
464 /*----------------------------------------------------------------------------*/
465 
466 bool
467 cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm,
468  cs_hodge_t *hodge,
469  cs_cell_builder_t *cb);
470 
471 /*----------------------------------------------------------------------------*/
484 /*----------------------------------------------------------------------------*/
485 
486 bool
487 cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm,
488  cs_hodge_t *hodge,
489  cs_cell_builder_t *cb);
490 
491 /*----------------------------------------------------------------------------*/
504 /*----------------------------------------------------------------------------*/
505 
506 bool
507 cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm,
508  cs_hodge_t *hodge,
509  cs_cell_builder_t *cb);
510 
511 /*----------------------------------------------------------------------------*/
524 /*----------------------------------------------------------------------------*/
525 
526 bool
527 cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm,
528  cs_hodge_t *hodge,
529  cs_cell_builder_t *cb);
530 
531 /*----------------------------------------------------------------------------*/
544 /*----------------------------------------------------------------------------*/
545 
546 bool
547 cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm,
548  cs_hodge_t *hodge,
549  cs_cell_builder_t *cb);
550 
551 /*----------------------------------------------------------------------------*/
564 /*----------------------------------------------------------------------------*/
565 
566 bool
567 cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm,
568  cs_hodge_t *hodge,
569  cs_cell_builder_t *cb);
570 
571 /*----------------------------------------------------------------------------*/
584 /*----------------------------------------------------------------------------*/
585 
586 bool
587 cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm,
588  cs_hodge_t *hodge,
589  cs_cell_builder_t *cb);
590 
591 /*----------------------------------------------------------------------------*/
604 /*----------------------------------------------------------------------------*/
605 
606 bool
607 cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm,
608  cs_hodge_t *hodge,
609  cs_cell_builder_t *cb);
610 
611 /*----------------------------------------------------------------------------*/
623 /*----------------------------------------------------------------------------*/
624 
625 bool
626 cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
627  cs_hodge_t *hodge,
628  cs_cell_builder_t *cb);
629 
630 /*----------------------------------------------------------------------------*/
642 /*----------------------------------------------------------------------------*/
643 
644 bool
645 cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
646  cs_hodge_t *hodge,
647  cs_cell_builder_t *cb);
648 
649 /*----------------------------------------------------------------------------*/
662 /*----------------------------------------------------------------------------*/
663 
664 bool
665 cs_hodge_fb_get(const cs_cell_mesh_t *cm,
666  cs_hodge_t *hodge,
667  cs_cell_builder_t *cb);
668 
669 /*----------------------------------------------------------------------------*/
682 /*----------------------------------------------------------------------------*/
683 
684 bool
685 cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
686  cs_hodge_t *hodge,
687  cs_cell_builder_t *cb);
688 
689 /*----------------------------------------------------------------------------*/
701 /*----------------------------------------------------------------------------*/
702 
703 bool
704 cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
705  cs_hodge_t *hodge,
706  cs_cell_builder_t *cb);
707 
708 /*----------------------------------------------------------------------------*/
721 /*----------------------------------------------------------------------------*/
722 
723 bool
724 cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
725  cs_hodge_t *hodge,
726  cs_cell_builder_t *cb);
727 
728 /*----------------------------------------------------------------------------*/
741 /*----------------------------------------------------------------------------*/
742 
743 bool
744 cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
745  cs_hodge_t *hodge,
746  cs_cell_builder_t *cb);
747 
748 /*----------------------------------------------------------------------------*/
761 /*----------------------------------------------------------------------------*/
762 
763 bool
764 cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
765  cs_hodge_t *hodge,
766  cs_cell_builder_t *cb);
767 
768 /*----------------------------------------------------------------------------*/
781 /*----------------------------------------------------------------------------*/
782 
783 bool
784 cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
785  cs_hodge_t *hodge,
786  cs_cell_builder_t *cb);
787 
788 /*----------------------------------------------------------------------------*/
802 /*----------------------------------------------------------------------------*/
803 
804 bool
805 cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
806  cs_hodge_t *hodge,
807  cs_cell_builder_t *cb);
808 
809 /*----------------------------------------------------------------------------*/
822 /*----------------------------------------------------------------------------*/
823 
824 bool
825 cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
826  cs_hodge_t *hodge,
827  cs_cell_builder_t *cb);
828 
829 /*----------------------------------------------------------------------------*/
842 /*----------------------------------------------------------------------------*/
843 
844 bool
845 cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
846  cs_hodge_t *hodge,
847  cs_cell_builder_t *cb);
848 
849 /*----------------------------------------------------------------------------*/
862 /*----------------------------------------------------------------------------*/
863 
864 bool
865 cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
866  cs_hodge_t *hodge,
867  cs_cell_builder_t *cb);
868 
869 /*----------------------------------------------------------------------------*/
882 /*----------------------------------------------------------------------------*/
883 
884 bool
885 cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
886  cs_hodge_t *hodge,
887  cs_cell_builder_t *cb);
888 
889 /*----------------------------------------------------------------------------*/
901 /*----------------------------------------------------------------------------*/
902 
903 bool
904 cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
905  cs_hodge_t *hodge,
906  cs_cell_builder_t *cb);
907 
908 /*----------------------------------------------------------------------------*/
921 /*----------------------------------------------------------------------------*/
922 
923 bool
924 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
925  cs_hodge_t *hodge,
926  cs_cell_builder_t *cb);
927 
928 /*----------------------------------------------------------------------------*/
940 /*----------------------------------------------------------------------------*/
941 
942 bool
943 cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
944  cs_hodge_t *hodge,
945  cs_cell_builder_t *cb);
946 
947 /*----------------------------------------------------------------------------*/
960 /*----------------------------------------------------------------------------*/
961 
962 bool
963 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
964  cs_hodge_t *hodge,
965  cs_cell_builder_t *cb);
966 
967 /*----------------------------------------------------------------------------*/
980 /*----------------------------------------------------------------------------*/
981 
982 void
983 cs_hodge_matvec(const cs_cdo_connect_t *connect,
984  const cs_cdo_quantities_t *quant,
985  const cs_hodge_param_t hodgep,
986  const cs_property_t *pty,
987  const cs_real_t in_vals[],
988  cs_real_t t_eval,
989  cs_real_t result[]);
990 
991 /*----------------------------------------------------------------------------*/
1004 /*----------------------------------------------------------------------------*/
1005 
1006 void
1007 cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
1008  const cs_cdo_quantities_t *quant,
1009  cs_real_t t_eval,
1010  const cs_hodge_param_t hodgep,
1011  const cs_property_t *pty,
1012  const cs_real_t flux[],
1013  cs_real_t circul[]);
1014 
1015 /*----------------------------------------------------------------------------*/
1024 /*----------------------------------------------------------------------------*/
1025 
1026 void
1027 cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
1028  cs_sdm_t *hf);
1029 
1030 /*----------------------------------------------------------------------------*/
1031 
1032 END_C_DECLS
1033 
1034 #endif /* __CS_HODGE_H__ */
cs_cdo_connect.h
cs_cdo_local.h
cs_cdo_quantities.h
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:509
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:319
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:510
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:313
cs_flag_t
unsigned short int cs_flag_t
Definition: cs_defs.h:321
fm
@ fm
Definition: cs_field_pointer.h:128
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:218
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:1562
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:2970
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.c:1460
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:4474
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:1536
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:239
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:1224
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:1322
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:1644
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:2122
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:3300
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:3558
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:3976
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:3634
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:4062
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:1935
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:3725
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:3887
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:3109
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:1796
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:2652
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:2890
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:1289
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:4148
cs_hodge_algo_t
cs_hodge_algo_t
Type of algorithm to build a discrete Hodge operator.
Definition: cs_hodge.h:133
CS_HODGE_ALGO_WBS
@ CS_HODGE_ALGO_WBS
Definition: cs_hodge.h:136
CS_HODGE_ALGO_AUTO
@ CS_HODGE_ALGO_AUTO
Definition: cs_hodge.h:139
CS_HODGE_ALGO_BUBBLE
@ CS_HODGE_ALGO_BUBBLE
Definition: cs_hodge.h:138
CS_HODGE_ALGO_VORONOI
@ CS_HODGE_ALGO_VORONOI
Definition: cs_hodge.h:135
CS_HODGE_N_ALGOS
@ CS_HODGE_N_ALGOS
Definition: cs_hodge.h:141
CS_HODGE_ALGO_COST
@ CS_HODGE_ALGO_COST
Definition: cs_hodge.h:137
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:1998
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:1725
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:1866
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.c:3474
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:4369
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:2184
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:1159
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:3382
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:2515
cs_hodge_type_t
cs_hodge_type_t
Type of discrete Hodge operators.
Definition: cs_hodge.h:84
CS_HODGE_N_TYPES
@ CS_HODGE_N_TYPES
Definition: cs_hodge.h:95
CS_HODGE_TYPE_VPCD
@ CS_HODGE_TYPE_VPCD
Definition: cs_hodge.h:86
CS_HODGE_TYPE_EDFP
@ CS_HODGE_TYPE_EDFP
Definition: cs_hodge.h:89
CS_HODGE_TYPE_VDCP
@ CS_HODGE_TYPE_VDCP
Definition: cs_hodge.h:91
CS_HODGE_TYPE_VC
@ CS_HODGE_TYPE_VC
Definition: cs_hodge.h:93
CS_HODGE_TYPE_FPED
@ CS_HODGE_TYPE_FPED
Definition: cs_hodge.h:88
CS_HODGE_TYPE_CPVD
@ CS_HODGE_TYPE_CPVD
Definition: cs_hodge.h:90
CS_HODGE_TYPE_EPFD
@ CS_HODGE_TYPE_EPFD
Definition: cs_hodge.h:87
CS_HODGE_TYPE_FB
@ CS_HODGE_TYPE_FB
Definition: cs_hodge.h:92
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.c:2804
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:3238
cs_hodge_free
void cs_hodge_free(cs_hodge_t **p_hodge)
Free a cs_hodge_t structure.
Definition: cs_hodge.c:1263
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:3811
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:2409
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:1500
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:2060
cs_param_cdo.h
cs_property.h
cs_sdm.h
cs_cdo_connect_t
Definition: cs_cdo_connect.h:61
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:137
cs_cell_builder_t
Set of local and temporary buffers.
Definition: cs_cdo_local.h:60
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:203
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_param_t
Structure storing all metadata/parameters related to the usage of a discrete Hodge operator.
Definition: cs_hodge.h:151
cs_hodge_param_t::coef
double coef
Scaling coefficient value.
Definition: cs_hodge.h:165
cs_hodge_param_t::type
cs_hodge_type_t type
Definition: cs_hodge.h:162
cs_hodge_param_t::inv_pty
bool inv_pty
Inversion of the property evaluation or not.
Definition: cs_hodge.h:153
cs_hodge_param_t::algo
cs_hodge_algo_t algo
Definition: cs_hodge.h:163
cs_hodge_t
Structure associated to a discrete Hodge operator *.
Definition: cs_hodge.h:183
cs_hodge_t::matrix
cs_sdm_t * matrix
Definition: cs_hodge.h:195
cs_hodge_t::param
const cs_hodge_param_t * param
Definition: cs_hodge.h:185
cs_hodge_t::pty_data
cs_property_data_t * pty_data
Data evaluation.
Definition: cs_hodge.h:187
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:211
cs_property_t
Structure associated to the definition of a property relying on the cs_xdef_t structure.