7.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-2021 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 
128 typedef enum {
129 
130  CS_HODGE_ALGO_VORONOI,
131  CS_HODGE_ALGO_WBS,
132  CS_HODGE_ALGO_COST,
133  CS_HODGE_ALGO_OCS2,
134  CS_HODGE_ALGO_BUBBLE,
135  CS_HODGE_ALGO_AUTO,
136 
137  CS_HODGE_N_ALGOS
138 
139 } cs_hodge_algo_t;
140 
165 typedef struct {
166 
167  /* Each Hodge operator is associated to a property */
168  bool inv_pty;
169 
170  cs_hodge_type_t type; /* type of discrete Hodge operator */
171  cs_hodge_algo_t algo; /* type of algorithm used to build this op. */
172  double coef; /* Value of the stabilization parameter
173  * if the COST or OCS2 algo. is used, otherwise 0.
174  */
175 } cs_hodge_param_t;
176 
177 /* DISCRETE HODGE OPERATORS */
178 /* ======================== */
179 
189 typedef struct {
190 
191  /* Each Hodge operator is associated to a property */
192  const cs_hodge_param_t *param; /* shared */
193 
194  cs_property_data_t *pty_data;
195  cs_sdm_t *matrix;
196 
197 } cs_hodge_t;
198 
199 /*----------------------------------------------------------------------------*/
210 /*----------------------------------------------------------------------------*/
211 
212 typedef void
213 (cs_hodge_compute_t)(const cs_cell_mesh_t *cm,
214  cs_hodge_t *hodge,
215  cs_cell_builder_t *cb);
216 
217 /*============================================================================
218  * Static inline public function definitions
219  *============================================================================*/
220 
221 /*----------------------------------------------------------------------------*/
231 /*----------------------------------------------------------------------------*/
232 
233 static inline bool
234 cs_hodge_param_is_similar(const cs_hodge_param_t h1_info,
235  const cs_hodge_param_t h2_info)
236 {
237  if (h1_info.type != h2_info.type)
238  return false;
239  if (h1_info.algo != h2_info.algo)
240  return false;
241  if (h1_info.algo == CS_HODGE_ALGO_COST ||
242  h1_info.algo == CS_HODGE_ALGO_BUBBLE) {
243  if (fabs(h1_info.coef - h2_info.coef) > 0)
244  return false;
245  else
246  return true;
247  }
248  else
249  return true;
250 }
251 
252 /*============================================================================
253  * Public function definitions
254  *============================================================================*/
255 
256 /*----------------------------------------------------------------------------*/
268 /*----------------------------------------------------------------------------*/
269 
270 cs_hodge_t *
271 cs_hodge_create(const cs_cdo_connect_t *connect,
272  const cs_property_t *property,
273  const cs_hodge_param_t *hp,
274  bool need_tensor,
275  bool need_eigen);
276 
277 /*----------------------------------------------------------------------------*/
291 /*----------------------------------------------------------------------------*/
292 
293 cs_hodge_t **
294 cs_hodge_init_context(const cs_cdo_connect_t *connect,
295  const cs_property_t *property,
296  const cs_hodge_param_t *hp,
297  bool need_tensor,
298  bool need_eigen);
299 
300 /*----------------------------------------------------------------------------*/
306 /*----------------------------------------------------------------------------*/
307 
308 void
309 cs_hodge_free(cs_hodge_t **p_hodge);
310 
311 /*----------------------------------------------------------------------------*/
317 /*----------------------------------------------------------------------------*/
318 
319 void
320 cs_hodge_free_context(cs_hodge_t ***p_hodges);
321 
322 /*----------------------------------------------------------------------------*/
331 /*----------------------------------------------------------------------------*/
332 
333 cs_hodge_compute_t *
334 cs_hodge_get_func(const char *calling_func,
335  const cs_hodge_param_t hp);
336 
337 /*----------------------------------------------------------------------------*/
345 /*----------------------------------------------------------------------------*/
346 
347 void
348 cs_hodge_param_log(const char *prefix,
349  const cs_property_t *property,
350  const cs_hodge_param_t hp);
351 
352 /*----------------------------------------------------------------------------*/
360 /*----------------------------------------------------------------------------*/
361 
362 void
363 cs_hodge_copy_parameters(const cs_hodge_param_t *h_ref,
364  cs_hodge_param_t *h_cpy);
365 
366 /*----------------------------------------------------------------------------*/
377 /*----------------------------------------------------------------------------*/
378 
379 void
380 cs_hodge_set_property_value(const cs_lnum_t c_id,
381  const cs_real_t t_eval,
382  const cs_flag_t c_flag,
383  cs_hodge_t *hodge);
384 
385 /*----------------------------------------------------------------------------*/
397 /*----------------------------------------------------------------------------*/
398 
399 void
400 cs_hodge_set_property_value_cw(const cs_cell_mesh_t *cm,
401  const cs_real_t t_eval,
402  const cs_flag_t c_flag,
403  cs_hodge_t *hodge);
404 
405 /*----------------------------------------------------------------------------*/
416 /*----------------------------------------------------------------------------*/
417 
418 void
419 cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm,
420  cs_hodge_t *hodge,
421  cs_cell_builder_t *cb);
422 
423 /*----------------------------------------------------------------------------*/
435 /*----------------------------------------------------------------------------*/
436 
437 void
438 cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm,
439  cs_hodge_t *hodge,
440  cs_cell_builder_t *cb);
441 
442 /*----------------------------------------------------------------------------*/
453 /*----------------------------------------------------------------------------*/
454 
455 void
456 cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm,
457  cs_hodge_t *hodge,
458  cs_cell_builder_t *cb);
459 
460 /*----------------------------------------------------------------------------*/
471 /*----------------------------------------------------------------------------*/
472 
473 void
474 cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm,
475  cs_hodge_t *hodge,
476  cs_cell_builder_t *cb);
477 
478 /*----------------------------------------------------------------------------*/
489 /*----------------------------------------------------------------------------*/
490 
491 void
492 cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm,
493  cs_hodge_t *hodge,
494  cs_cell_builder_t *cb);
495 
496 /*----------------------------------------------------------------------------*/
507 /*----------------------------------------------------------------------------*/
508 
509 void
510 cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm,
511  cs_hodge_t *hodge,
512  cs_cell_builder_t *cb);
513 
514 /*----------------------------------------------------------------------------*/
525 /*----------------------------------------------------------------------------*/
526 
527 void
528 cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm,
529  cs_hodge_t *hodge,
530  cs_cell_builder_t *cb);
531 
532 /*----------------------------------------------------------------------------*/
545 /*----------------------------------------------------------------------------*/
546 
547 void
548 cs_hodge_vb_ocs2_get_aniso_stiffness(const cs_cell_mesh_t *cm,
549  cs_hodge_t *hodge,
550  cs_cell_builder_t *cb);
551 
552 /*----------------------------------------------------------------------------*/
563 /*----------------------------------------------------------------------------*/
564 
565 void
566 cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm,
567  cs_hodge_t *hodge,
568  cs_cell_builder_t *cb);
569 
570 /*----------------------------------------------------------------------------*/
581 /*----------------------------------------------------------------------------*/
582 
583 void
584 cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm,
585  cs_hodge_t *hodge,
586  cs_cell_builder_t *cb);
587 
588 /*----------------------------------------------------------------------------*/
599 /*----------------------------------------------------------------------------*/
600 
601 void
602 cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
603  cs_hodge_t *hodge,
604  cs_cell_builder_t *cb);
605 
606 /*----------------------------------------------------------------------------*/
616 /*----------------------------------------------------------------------------*/
617 
618 void
619 cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
620  cs_hodge_t *hodge,
621  cs_cell_builder_t *cb);
622 
623 /*----------------------------------------------------------------------------*/
634 /*----------------------------------------------------------------------------*/
635 
636 void
637 cs_hodge_fb_get(const cs_cell_mesh_t *cm,
638  cs_hodge_t *hodge,
639  cs_cell_builder_t *cb);
640 
641 /*----------------------------------------------------------------------------*/
652 /*----------------------------------------------------------------------------*/
653 
654 void
655 cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
656  cs_hodge_t *hodge,
657  cs_cell_builder_t *cb);
658 
659 /*----------------------------------------------------------------------------*/
669 /*----------------------------------------------------------------------------*/
670 
671 void
672 cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
673  cs_hodge_t *hodge,
674  cs_cell_builder_t *cb);
675 
676 /*----------------------------------------------------------------------------*/
687 /*----------------------------------------------------------------------------*/
688 
689 void
690 cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
691  cs_hodge_t *hodge,
692  cs_cell_builder_t *cb);
693 
694 /*----------------------------------------------------------------------------*/
705 /*----------------------------------------------------------------------------*/
706 
707 void
708 cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
709  cs_hodge_t *hodge,
710  cs_cell_builder_t *cb);
711 
712 /*----------------------------------------------------------------------------*/
723 /*----------------------------------------------------------------------------*/
724 
725 void
726 cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
727  cs_hodge_t *hodge,
728  cs_cell_builder_t *cb);
729 
730 /*----------------------------------------------------------------------------*/
741 /*----------------------------------------------------------------------------*/
742 
743 void
744 cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
745  cs_hodge_t *hodge,
746  cs_cell_builder_t *cb);
747 
748 /*----------------------------------------------------------------------------*/
760 /*----------------------------------------------------------------------------*/
761 
762 void
763 cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
764  cs_hodge_t *hodge,
765  cs_cell_builder_t *cb);
766 
767 /*----------------------------------------------------------------------------*/
780 /*----------------------------------------------------------------------------*/
781 
782 void
783 cs_hodge_epfd_ocs2_get(const cs_cell_mesh_t *cm,
784  cs_hodge_t *hodge,
785  cs_cell_builder_t *cb);
786 
787 /*----------------------------------------------------------------------------*/
798 /*----------------------------------------------------------------------------*/
799 
800 void
801 cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
802  cs_hodge_t *hodge,
803  cs_cell_builder_t *cb);
804 
805 /*----------------------------------------------------------------------------*/
816 /*----------------------------------------------------------------------------*/
817 
818 void
819 cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
820  cs_hodge_t *hodge,
821  cs_cell_builder_t *cb);
822 
823 /*----------------------------------------------------------------------------*/
834 /*----------------------------------------------------------------------------*/
835 
836 void
837 cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
838  cs_hodge_t *hodge,
839  cs_cell_builder_t *cb);
840 
841 /*----------------------------------------------------------------------------*/
852 /*----------------------------------------------------------------------------*/
853 
854 void
855 cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
856  cs_hodge_t *hodge,
857  cs_cell_builder_t *cb);
858 
859 /*----------------------------------------------------------------------------*/
869 /*----------------------------------------------------------------------------*/
870 
871 void
872 cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
873  cs_hodge_t *hodge,
874  cs_cell_builder_t *cb);
875 
876 /*----------------------------------------------------------------------------*/
887 /*----------------------------------------------------------------------------*/
888 
889 void
890 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
891  cs_hodge_t *hodge,
892  cs_cell_builder_t *cb);
893 
894 /*----------------------------------------------------------------------------*/
904 /*----------------------------------------------------------------------------*/
905 
906 void
907 cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
908  cs_hodge_t *hodge,
909  cs_cell_builder_t *cb);
910 
911 /*----------------------------------------------------------------------------*/
922 /*----------------------------------------------------------------------------*/
923 
924 void
925 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
926  cs_hodge_t *hodge,
927  cs_cell_builder_t *cb);
928 
929 /*----------------------------------------------------------------------------*/
942 /*----------------------------------------------------------------------------*/
943 
944 void
945 cs_hodge_matvec(const cs_cdo_connect_t *connect,
946  const cs_cdo_quantities_t *quant,
947  const cs_hodge_param_t hodgep,
948  const cs_property_t *pty,
949  const cs_real_t in_vals[],
950  cs_real_t t_eval,
951  cs_real_t result[]);
952 
953 /*----------------------------------------------------------------------------*/
966 /*----------------------------------------------------------------------------*/
967 
968 void
969 cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
970  const cs_cdo_quantities_t *quant,
971  cs_real_t t_eval,
972  const cs_hodge_param_t hodgep,
973  const cs_property_t *pty,
974  const cs_real_t flux[],
975  cs_real_t circul[]);
976 
977 /*----------------------------------------------------------------------------*/
986 /*----------------------------------------------------------------------------*/
987 
988 void
989 cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
990  cs_sdm_t *hf);
991 
992 /*----------------------------------------------------------------------------*/
993 
994 END_C_DECLS
995 
996 #endif /* __CS_HODGE_H__ */
cs_hodge_epfd_cost_get
void 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:3244
cs_hodge_edfp_cost_get
void 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:3694
CS_HODGE_TYPE_EDFP
Definition: cs_hodge.h:86
cs_hodge_edfp_voro_get
void 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:3634
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:4229
cs_hodge_param_t::inv_pty
bool inv_pty
Definition: cs_hodge.h:168
CS_HODGE_TYPE_VPCD
Definition: cs_hodge.h:83
cs_hodge_vb_cost_get_iso_stiffness
void 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:1932
cs_hodge_param_t::type
cs_hodge_type_t type
Definition: cs_hodge.h:170
cs_hodge_fb_voro_get_stiffness
void 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:1873
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:1390
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:178
cs_hodge_vpcd_voro_get
void 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:3126
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:495
cs_hodge_fped_cost_get
void 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:3494
cs_hodge_edfp_cost_get_opt
void 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:3765
cs_hodge_free
void cs_hodge_free(cs_hodge_t **p_hodge)
Free a cs_hodge_t structure.
Definition: cs_hodge.c:1332
CS_HODGE_TYPE_VC
Definition: cs_hodge.h:89
cs_hodge_vb_cost_get_aniso_stiffness
void 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:1986
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell This is a key structure for all cel...
Definition: cs_cdo_local.h:159
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:1672
cs_cdo_connect_t
Definition: cs_cdo_connect.h:76
cs_hodge_vb_bubble_get_iso_stiffness
void 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:2040
cs_hodge_vb_voro_get_stiffness
void 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:2397
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:1293
CS_HODGE_N_ALGOS
Definition: cs_hodge.h:137
cs_hodge_t
Structure associated to a discrete Hodge operator.
Definition: cs_hodge.h:189
cs_hodge_fped_voro_get
void 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:3434
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:307
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:124
cs_hodge_edfp_bubble_get
void 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:3833
cs_hodge_fped_bubble_get
void 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:3566
cs_hodge_compute_t
void() 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:213
cs_hodge_vpcd_wbs_get
void 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:3009
cs_hodge_vcb_wbs_get
void 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:2885
cs_hodge_param_t::coef
double coef
Definition: cs_hodge.h:172
cs_hodge_vb_ocs2_get_aniso_stiffness
void 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:2150
cs_property.h
fm
Definition: cs_field_pointer.h:134
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:1357
CS_HODGE_ALGO_VORONOI
Definition: cs_hodge.h:130
CS_HODGE_N_TYPES
Definition: cs_hodge.h:91
cs_hodge_vcb_voro_get
void 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:2819
cs_hodge_epfd_voro_get
void 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:3179
cs_hodge_fb_cost_get_stiffness
void 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:1750
cs_hodge_fb_bubble_get_stiffness
void 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:1812
cs_hodge_vb_wbs_get_stiffness
void 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:2488
cs_hodge_type_t
cs_hodge_type_t
Type of discrete Hodge operators.
Definition: cs_hodge.h:81
CS_HODGE_ALGO_WBS
Definition: cs_hodge.h:131
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:1591
cs_hodge_vcb_get_stiffness
void 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:2608
cs_hodge_algo_t
cs_hodge_algo_t
Type of algorithm to build a discrete Hodge operator.
Definition: cs_hodge.h:128
cs_cell_builder_t
Set of local and temporary buffers useful for building the algebraic system with a cellwise process...
Definition: cs_cdo_local.h:69
cs_hodge_epfd_bubble_get
void 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:3318
cs_param_cdo.h
CS_HODGE_ALGO_OCS2
Definition: cs_hodge.h:133
CS_HODGE_ALGO_BUBBLE
Definition: cs_hodge.h:134
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:1229
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:301
cs_hodge_epfd_ocs2_get
void 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:3386
cs_hodge_vb_cost_get_stiffness
void 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:2194
cs_hodge_t::param
const cs_hodge_param_t * param
Definition: cs_hodge.h:192
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:4123
cs_hodge_t::pty_data
cs_property_data_t * pty_data
Definition: cs_hodge.h:194
cs_cdo_local.h
cs_hodge_t::matrix
cs_sdm_t * matrix
Definition: cs_hodge.h:195
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:496
CS_HODGE_ALGO_AUTO
Definition: cs_hodge.h:135
cs_flag_t
unsigned short int cs_flag_t
Definition: cs_defs.h:309
CS_HODGE_TYPE_FB
Definition: cs_hodge.h:88
CS_HODGE_ALGO_COST
Definition: cs_hodge.h:132
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:3903
cs_hodge_fb_get
void 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:2742
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:227
cs_hodge_param_t::algo
cs_hodge_algo_t algo
Definition: cs_hodge.h:171
CS_HODGE_TYPE_FPED
Definition: cs_hodge.h:85
CS_HODGE_TYPE_EPFD
Definition: cs_hodge.h:84
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:1526
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:165
cs_sdm.h
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:1565
CS_HODGE_TYPE_CPVD
Definition: cs_hodge.h:87
cs_hodge_vb_bubble_get_aniso_stiffness
void 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:2094