7.1
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 
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 /*----------------------------------------------------------------------------*/
213 /*----------------------------------------------------------------------------*/
214 
215 typedef void
216 (cs_hodge_compute_t)(const cs_cell_mesh_t *cm,
217  cs_hodge_t *hodge,
218  cs_cell_builder_t *cb);
219 
220 /*============================================================================
221  * Static inline public function definitions
222  *============================================================================*/
223 
224 /*----------------------------------------------------------------------------*/
234 /*----------------------------------------------------------------------------*/
235 
236 static inline bool
237 cs_hodge_param_is_similar(const cs_hodge_param_t h1_info,
238  const cs_hodge_param_t h2_info)
239 {
240  if (h1_info.type != h2_info.type)
241  return false;
242  if (h1_info.algo != h2_info.algo)
243  return false;
244  if (h1_info.algo == CS_HODGE_ALGO_COST ||
245  h1_info.algo == CS_HODGE_ALGO_BUBBLE) {
246  if (fabs(h1_info.coef - h2_info.coef) > 0)
247  return false;
248  else
249  return true;
250  }
251  else
252  return true;
253 }
254 
255 /*============================================================================
256  * Public function definitions
257  *============================================================================*/
258 
259 /*----------------------------------------------------------------------------*/
271 /*----------------------------------------------------------------------------*/
272 
273 cs_hodge_t *
274 cs_hodge_create(const cs_cdo_connect_t *connect,
275  const cs_property_t *property,
276  const cs_hodge_param_t *hp,
277  bool need_tensor,
278  bool need_eigen);
279 
280 /*----------------------------------------------------------------------------*/
294 /*----------------------------------------------------------------------------*/
295 
296 cs_hodge_t **
297 cs_hodge_init_context(const cs_cdo_connect_t *connect,
298  const cs_property_t *property,
299  const cs_hodge_param_t *hp,
300  bool need_tensor,
301  bool need_eigen);
302 
303 /*----------------------------------------------------------------------------*/
309 /*----------------------------------------------------------------------------*/
310 
311 void
312 cs_hodge_free(cs_hodge_t **p_hodge);
313 
314 /*----------------------------------------------------------------------------*/
320 /*----------------------------------------------------------------------------*/
321 
322 void
323 cs_hodge_free_context(cs_hodge_t ***p_hodges);
324 
325 /*----------------------------------------------------------------------------*/
334 /*----------------------------------------------------------------------------*/
335 
336 cs_hodge_compute_t *
337 cs_hodge_get_func(const char *calling_func,
338  const cs_hodge_param_t hp);
339 
340 /*----------------------------------------------------------------------------*/
354 /*----------------------------------------------------------------------------*/
355 
356 cs_hodge_algo_t
357 cs_hodge_set_mass_algo(const char *eqname,
358  cs_hodge_algo_t reac_algo,
359  cs_hodge_algo_t time_algo,
360  cs_hodge_algo_t srct_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 /*----------------------------------------------------------------------------*/
441 /*----------------------------------------------------------------------------*/
442 
443 void
444 cs_hodge_fb_cost_get_stiffness(const cs_cell_mesh_t *cm,
445  cs_hodge_t *hodge,
446  cs_cell_builder_t *cb);
447 
448 /*----------------------------------------------------------------------------*/
460 /*----------------------------------------------------------------------------*/
461 
462 void
463 cs_hodge_fb_bubble_get_stiffness(const cs_cell_mesh_t *cm,
464  cs_hodge_t *hodge,
465  cs_cell_builder_t *cb);
466 
467 /*----------------------------------------------------------------------------*/
478 /*----------------------------------------------------------------------------*/
479 
480 void
481 cs_hodge_fb_voro_get_stiffness(const cs_cell_mesh_t *cm,
482  cs_hodge_t *hodge,
483  cs_cell_builder_t *cb);
484 
485 /*----------------------------------------------------------------------------*/
496 /*----------------------------------------------------------------------------*/
497 
498 void
499 cs_hodge_vb_cost_get_iso_stiffness(const cs_cell_mesh_t *cm,
500  cs_hodge_t *hodge,
501  cs_cell_builder_t *cb);
502 
503 /*----------------------------------------------------------------------------*/
514 /*----------------------------------------------------------------------------*/
515 
516 void
517 cs_hodge_vb_cost_get_aniso_stiffness(const cs_cell_mesh_t *cm,
518  cs_hodge_t *hodge,
519  cs_cell_builder_t *cb);
520 
521 /*----------------------------------------------------------------------------*/
532 /*----------------------------------------------------------------------------*/
533 
534 void
535 cs_hodge_vb_bubble_get_iso_stiffness(const cs_cell_mesh_t *cm,
536  cs_hodge_t *hodge,
537  cs_cell_builder_t *cb);
538 
539 /*----------------------------------------------------------------------------*/
550 /*----------------------------------------------------------------------------*/
551 
552 void
553 cs_hodge_vb_bubble_get_aniso_stiffness(const cs_cell_mesh_t *cm,
554  cs_hodge_t *hodge,
555  cs_cell_builder_t *cb);
556 
557 /*----------------------------------------------------------------------------*/
570 /*----------------------------------------------------------------------------*/
571 
572 void
573 cs_hodge_vb_ocs2_get_aniso_stiffness(const cs_cell_mesh_t *cm,
574  cs_hodge_t *hodge,
575  cs_cell_builder_t *cb);
576 
577 /*----------------------------------------------------------------------------*/
588 /*----------------------------------------------------------------------------*/
589 
590 void
591 cs_hodge_vb_cost_get_stiffness(const cs_cell_mesh_t *cm,
592  cs_hodge_t *hodge,
593  cs_cell_builder_t *cb);
594 
595 /*----------------------------------------------------------------------------*/
606 /*----------------------------------------------------------------------------*/
607 
608 void
609 cs_hodge_vb_voro_get_stiffness(const cs_cell_mesh_t *cm,
610  cs_hodge_t *hodge,
611  cs_cell_builder_t *cb);
612 
613 /*----------------------------------------------------------------------------*/
624 /*----------------------------------------------------------------------------*/
625 
626 void
627 cs_hodge_vb_wbs_get_stiffness(const cs_cell_mesh_t *cm,
628  cs_hodge_t *hodge,
629  cs_cell_builder_t *cb);
630 
631 /*----------------------------------------------------------------------------*/
641 /*----------------------------------------------------------------------------*/
642 
643 void
644 cs_hodge_vcb_get_stiffness(const cs_cell_mesh_t *cm,
645  cs_hodge_t *hodge,
646  cs_cell_builder_t *cb);
647 
648 /*----------------------------------------------------------------------------*/
659 /*----------------------------------------------------------------------------*/
660 
661 void
662 cs_hodge_fb_get(const cs_cell_mesh_t *cm,
663  cs_hodge_t *hodge,
664  cs_cell_builder_t *cb);
665 
666 /*----------------------------------------------------------------------------*/
677 /*----------------------------------------------------------------------------*/
678 
679 void
680 cs_hodge_vcb_voro_get(const cs_cell_mesh_t *cm,
681  cs_hodge_t *hodge,
682  cs_cell_builder_t *cb);
683 
684 /*----------------------------------------------------------------------------*/
694 /*----------------------------------------------------------------------------*/
695 
696 void
697 cs_hodge_vcb_wbs_get(const cs_cell_mesh_t *cm,
698  cs_hodge_t *hodge,
699  cs_cell_builder_t *cb);
700 
701 /*----------------------------------------------------------------------------*/
712 /*----------------------------------------------------------------------------*/
713 
714 void
715 cs_hodge_vpcd_wbs_get(const cs_cell_mesh_t *cm,
716  cs_hodge_t *hodge,
717  cs_cell_builder_t *cb);
718 
719 /*----------------------------------------------------------------------------*/
730 /*----------------------------------------------------------------------------*/
731 
732 void
733 cs_hodge_vpcd_voro_get(const cs_cell_mesh_t *cm,
734  cs_hodge_t *hodge,
735  cs_cell_builder_t *cb);
736 
737 /*----------------------------------------------------------------------------*/
748 /*----------------------------------------------------------------------------*/
749 
750 void
751 cs_hodge_epfd_voro_get(const cs_cell_mesh_t *cm,
752  cs_hodge_t *hodge,
753  cs_cell_builder_t *cb);
754 
755 /*----------------------------------------------------------------------------*/
766 /*----------------------------------------------------------------------------*/
767 
768 void
769 cs_hodge_epfd_cost_get(const cs_cell_mesh_t *cm,
770  cs_hodge_t *hodge,
771  cs_cell_builder_t *cb);
772 
773 /*----------------------------------------------------------------------------*/
785 /*----------------------------------------------------------------------------*/
786 
787 void
788 cs_hodge_epfd_bubble_get(const cs_cell_mesh_t *cm,
789  cs_hodge_t *hodge,
790  cs_cell_builder_t *cb);
791 
792 /*----------------------------------------------------------------------------*/
805 /*----------------------------------------------------------------------------*/
806 
807 void
808 cs_hodge_epfd_ocs2_get(const cs_cell_mesh_t *cm,
809  cs_hodge_t *hodge,
810  cs_cell_builder_t *cb);
811 
812 /*----------------------------------------------------------------------------*/
823 /*----------------------------------------------------------------------------*/
824 
825 void
826 cs_hodge_fped_voro_get(const cs_cell_mesh_t *cm,
827  cs_hodge_t *hodge,
828  cs_cell_builder_t *cb);
829 
830 /*----------------------------------------------------------------------------*/
841 /*----------------------------------------------------------------------------*/
842 
843 void
844 cs_hodge_fped_cost_get(const cs_cell_mesh_t *cm,
845  cs_hodge_t *hodge,
846  cs_cell_builder_t *cb);
847 
848 /*----------------------------------------------------------------------------*/
859 /*----------------------------------------------------------------------------*/
860 
861 void
862 cs_hodge_fped_bubble_get(const cs_cell_mesh_t *cm,
863  cs_hodge_t *hodge,
864  cs_cell_builder_t *cb);
865 
866 /*----------------------------------------------------------------------------*/
877 /*----------------------------------------------------------------------------*/
878 
879 void
880 cs_hodge_edfp_voro_get(const cs_cell_mesh_t *cm,
881  cs_hodge_t *hodge,
882  cs_cell_builder_t *cb);
883 
884 /*----------------------------------------------------------------------------*/
894 /*----------------------------------------------------------------------------*/
895 
896 void
897 cs_hodge_edfp_cost_get(const cs_cell_mesh_t *cm,
898  cs_hodge_t *hodge,
899  cs_cell_builder_t *cb);
900 
901 /*----------------------------------------------------------------------------*/
912 /*----------------------------------------------------------------------------*/
913 
914 void
915 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
916  cs_hodge_t *hodge,
917  cs_cell_builder_t *cb);
918 
919 /*----------------------------------------------------------------------------*/
929 /*----------------------------------------------------------------------------*/
930 
931 void
932 cs_hodge_edfp_cost_get_opt(const cs_cell_mesh_t *cm,
933  cs_hodge_t *hodge,
934  cs_cell_builder_t *cb);
935 
936 /*----------------------------------------------------------------------------*/
947 /*----------------------------------------------------------------------------*/
948 
949 void
950 cs_hodge_edfp_bubble_get(const cs_cell_mesh_t *cm,
951  cs_hodge_t *hodge,
952  cs_cell_builder_t *cb);
953 
954 /*----------------------------------------------------------------------------*/
967 /*----------------------------------------------------------------------------*/
968 
969 void
970 cs_hodge_matvec(const cs_cdo_connect_t *connect,
971  const cs_cdo_quantities_t *quant,
972  const cs_hodge_param_t hodgep,
973  const cs_property_t *pty,
974  const cs_real_t in_vals[],
975  cs_real_t t_eval,
976  cs_real_t result[]);
977 
978 /*----------------------------------------------------------------------------*/
991 /*----------------------------------------------------------------------------*/
992 
993 void
994 cs_hodge_circulation_from_flux(const cs_cdo_connect_t *connect,
995  const cs_cdo_quantities_t *quant,
996  cs_real_t t_eval,
997  const cs_hodge_param_t hodgep,
998  const cs_property_t *pty,
999  const cs_real_t flux[],
1000  cs_real_t circul[]);
1001 
1002 /*----------------------------------------------------------------------------*/
1011 /*----------------------------------------------------------------------------*/
1012 
1013 void
1014 cs_hodge_compute_wbs_surfacic(const cs_face_mesh_t *fm,
1015  cs_sdm_t *hf);
1016 
1017 /*----------------------------------------------------------------------------*/
1018 
1019 END_C_DECLS
1020 
1021 #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:3334
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:3784
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:3724
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:4319
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_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:2022
cs_hodge_param_t::type
cs_hodge_type_t type
Definition: cs_hodge.h:165
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:1963
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:3216
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
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:3584
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:3855
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:2076
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:202
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:1760
cs_cdo_connect_t
Definition: cs_cdo_connect.h:79
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:2130
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:2487
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:144
cs_hodge_t
Structure associated to a discrete Hodge operator *.
Definition: cs_hodge.h:186
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:3524
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:129
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:3923
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:3656
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:216
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:3099
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:2975
cs_hodge_param_t::coef
double coef
Scaling coefficient value.
Definition: cs_hodge.h:168
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:2240
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:1532
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:1357
CS_HODGE_ALGO_VORONOI
Definition: cs_hodge.h:137
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:2909
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:3269
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:1840
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:1902
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:2578
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: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:1677
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:2698
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_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:3408
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:1229
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
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:3476
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:2284
cs_hodge_t::param
const cs_hodge_param_t * param
Definition: cs_hodge.h:188
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:4213
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_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:3993
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:2832
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:270
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_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:1612
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_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:1651
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:2184