programmer's documentation
Main Page
Related Pages
Modules
Data Structures
Files
File List
Globals
All
Data Structures
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
src
base
cs_field.h
Go to the documentation of this file.
1
#ifndef __CS_FIELD_H__
2
#define __CS_FIELD_H__
3
4
/*============================================================================
5
* Field management.
6
*============================================================================*/
7
8
/*
9
This file is part of Code_Saturne, a general-purpose CFD tool.
10
11
Copyright (C) 1998-2013 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
30
/*----------------------------------------------------------------------------
31
* Local headers
32
*----------------------------------------------------------------------------*/
33
34
#include "
cs_defs.h
"
35
36
/*----------------------------------------------------------------------------*/
37
38
BEGIN_C_DECLS
39
40
/*=============================================================================
41
* Macro definitions
42
*============================================================================*/
43
44
/*
45
* Field property type
46
*/
47
48
#define CS_FIELD_INTENSIVE (1 << 0)
49
#define CS_FIELD_EXTENSIVE (1 << 1)
50
51
/* Field category */
52
53
#define CS_FIELD_VARIABLE (1 << 2)
54
#define CS_FIELD_PROPERTY (1 << 3)
55
#define CS_FIELD_POSTPROCESS (1 << 4)
56
#define CS_FIELD_ACCUMULATOR (1 << 5)
57
58
#define CS_FIELD_USER (1 << 6)
59
60
/*============================================================================
61
* Type definitions
62
*============================================================================*/
63
64
/* Field handling error types */
65
/*----------------------------*/
66
67
typedef
enum
{
68
69
CS_FIELD_OK
,
70
CS_FIELD_INVALID_KEY_NAME
,
71
CS_FIELD_INVALID_KEY_ID
,
72
CS_FIELD_INVALID_CATEGORY
,
73
CS_FIELD_INVALID_TYPE
74
75
}
cs_field_error_type_t
;
76
77
/* Field boundary condition descriptor (for variables) */
78
/*-----------------------------------------------------*/
79
80
typedef
struct
{
81
82
int
location_id
;
/* Id of matching location */
83
84
cs_real_t
*
a
;
/* Explicit coefficient */
85
cs_real_t
*
b
;
/* Implicit coefficient */
86
cs_real_t
*
af
;
/* Explicit coefficient for flux */
87
cs_real_t
*
bf
;
/* Implicit coefficient for flux */
88
cs_real_t
*
ad
;
/* Explicit coefficient for divergence */
89
cs_real_t
*
bd
;
/* Implicit coefficient for divergence */
90
cs_real_t
*
ac
;
/* Explicit coefficient for convection */
91
cs_real_t
*
bc
;
/* Implicit coefficient for convection */
92
93
}
cs_field_bc_coeffs_t
;
94
95
/* Field descriptor */
96
/*------------------*/
97
98
typedef
struct
{
99
100
const
char
*
name
;
/* Canonical name */
101
102
int
id
;
/* Field id */
103
int
type
;
/* Field type flag */
104
105
int
dim
;
/* Field dimension */
106
bool
interleaved
;
/* is field interleaved ? */
107
108
int
location_id
;
/* Id of matching location */
109
110
int
n_time_vals
;
/* Number of time values (1 or 2) */
111
112
cs_real_t
*
val
;
/* For each active location, pointer
113
to matching values array */
114
115
cs_real_t
*
val_pre
;
/* For each active location, pointer
116
to matching previous values array
117
(if n_time_vals == 2) */
118
119
cs_field_bc_coeffs_t
*
bc_coeffs
;
/* Boundary condition coefficients,
120
for variable type fields */
121
122
bool
is_owner
;
/* Ownership flag for values
123
and boundary coefficients */
124
125
}
cs_field_t
;
126
127
/*----------------------------------------------------------------------------
128
* Function pointer for structure associated to field key
129
*
130
* parameters:
131
* t <-- pointer to structure
132
*----------------------------------------------------------------------------*/
133
134
typedef
void
135
(
cs_field_log_key_struct_t
) (
const
void
*t);
136
137
/*=============================================================================
138
* Public function prototypes
139
*============================================================================*/
140
141
/*----------------------------------------------------------------------------
142
* Return the number of defined fields.
143
*
144
* returns:
145
* number of defined fields.
146
*----------------------------------------------------------------------------*/
147
148
int
149
cs_field_n_fields
(
void
);
150
151
/*----------------------------------------------------------------------------
152
* Create a field descriptor.
153
*
154
* parameters:
155
* name <-- field name
156
* type_flag <-- mask of field property and category values
157
* location_id <-- id of associated location
158
* dim <-- field dimension (number of components)
159
* interleaved <-- indicate if values are interleaved
160
* (ignored if number of components < 2)
161
* has_previous <-- maintain values at the previous time step ?
162
*
163
* returns:
164
* pointer to new field.
165
*----------------------------------------------------------------------------*/
166
167
cs_field_t
*
168
cs_field_create
(
const
char
*name,
169
int
type_flag,
170
int
location_id,
171
int
dim,
172
bool
interleaved,
173
bool
has_previous);
174
175
/*----------------------------------------------------------------------------
176
* Allocate arrays for field values.
177
*
178
* parameters:
179
* f <-- pointer to field structure
180
*----------------------------------------------------------------------------*/
181
182
void
183
cs_field_allocate_values
(
cs_field_t
*f);
184
185
/*----------------------------------------------------------------------------
186
* Map existing value arrays to field descriptor.
187
*
188
* parameters:
189
* f <-> pointer to field structure
190
* val <-- pointer to array of values
191
* val_pre <-- pointer to array of previous values, or NULL
192
*----------------------------------------------------------------------------*/
193
194
void
195
cs_field_map_values
(
cs_field_t
*f,
196
cs_real_t
*val,
197
cs_real_t
*val_pre);
198
199
/*----------------------------------------------------------------------------
200
* Allocate boundary condition coefficient arrays.
201
*
202
* For fields on location CS_MESH_LOCATION_CELLS, boundary conditions
203
* are located on CS_MESH_LOCATION_BOUNDARY_FACES.
204
*
205
* Boundary condition coefficients are not currently supported for other
206
* locations (though support could be added by mapping a boundary->location
207
* indirection array in the cs_mesh_location_t structure).
208
*
209
* For multidimensional fields, arrays are assumed to have the same
210
* interleaving behavior as the field, unless components are coupled.
211
*
212
* For multidimensional fields with coupled components, interleaving
213
* is the norm, and implicit b and bf coefficient arrays are arrays of
214
* block matrices, not vectors, so the number of entries for each boundary
215
* face is dim*dim instead of dim.
216
*
217
* parameters:
218
* f <-- pointer to field structure
219
* have_flux_bc <-- if true, flux BC coefficients (af and bf) are added
220
* have_mom_bc <-- if true, div BC coefficients (ad and bd) are added
221
* have_conv_bc <-- if true, convection BC coefficients (ac and bc) are added
222
*----------------------------------------------------------------------------*/
223
224
void
225
cs_field_allocate_bc_coeffs
(
cs_field_t
*f,
226
bool
have_flux_bc,
227
bool
have_mom_bc,
228
bool
have_conv_bc);
229
230
/*----------------------------------------------------------------------------*/
231
/* Initialize boundary condition coefficients arrays.
232
*
233
* For fields on location CS_MESH_LOCATION_CELLS, boundary conditions
234
* are located on CS_MESH_LOCATION_BOUNDARY_FACES.
235
*
236
* Boundary condition coefficients are not currently supported for other
237
* locations (though support could be added by mapping a boundary->location
238
* indirection array in the cs_mesh_location_t structure).
239
*
240
* For multidimensional fields, arrays are assumed to have the same
241
* interleaving behavior as the field, unless components are coupled.
242
*
243
* For multidimensional fields with coupled components, interleaving
244
* is the norm, and implicit b and bf coefficient arrays are arrays of
245
* block matrices, not vectors, so the number of entries for each boundary
246
* face is dim*dim instead of dim.
247
*
248
* parameters:
249
* f <-> pointer to field structure
250
* have_flux_bc <-- if true, flux bc coefficients (af and bf)
251
* are initialized
252
* have_mom_bc <-- if true, div BC coefficients (ad and bd)
253
* are initialized
254
* have_conv_bc <-- if true, convection BC coefficients (ac and bc)
255
* are initialized
256
*----------------------------------------------------------------------------*/
257
258
void
259
cs_field_init_bc_coeffs
(
cs_field_t
*f,
260
bool
have_flux_bc,
261
bool
have_mom_bc,
262
bool
have_conv_bc);
263
264
/*----------------------------------------------------------------------------
265
* Map existing field boundary condition coefficient arrays.
266
*
267
* For fields on location CS_MESH_LOCATION_CELLS, boundary conditions
268
* are located on CS_MESH_LOCATION_BOUNDARY_FACES.
269
*
270
* Boundary condition coefficients are not currently supported for other
271
* locations (though support could be added by mapping a boundary->location
272
* indirection array in the cs_mesh_location_t structure).
273
*
274
* For multidimensional fields, arrays are assumed to have the same
275
* interleaving behavior as the field, unless components are coupled.
276
*
277
* For multidimensional fields with coupled components, interleaving
278
* is the norm, and implicit coefficients arrays are arrays of block matrices,
279
* not vectors, so the number of entris for each boundary face is
280
* dim*dim instead of dim.
281
*
282
* parameters:
283
* f <-> pointer to field structure
284
* a <-- explicit BC coefficients array
285
* b <-- implicit BC coefficients array
286
* af <-- explicit flux BC coefficients array, or NULL
287
* bf <-- implicit flux BC coefficients array, or NULL
288
* ad explicit div BC coefficients array, or NULL
289
* bd implicit div BC coefficients array, or NULL
290
* ac explicit convection BC coefficients array, or NULL
291
* bc implicit convection BC coefficients array, or NULL
292
*----------------------------------------------------------------------------*/
293
294
void
295
cs_field_map_bc_coeffs
(
cs_field_t
*f,
296
cs_real_t
*a,
297
cs_real_t
*b,
298
cs_real_t
*af,
299
cs_real_t
*bf,
300
cs_real_t
*ad,
301
cs_real_t
*bd,
302
cs_real_t
*ac,
303
cs_real_t
*bc);
304
305
/*----------------------------------------------------------------------------
306
* Copy current field values to previous values if applicable.
307
*
308
* For fields with only one time value, or values not allocated yet,
309
* this is a no-op.
310
*
311
* parameters:
312
* f <-> pointer to field structure
313
*----------------------------------------------------------------------------*/
314
315
void
316
cs_field_current_to_previous
(
cs_field_t
*f);
317
318
/*----------------------------------------------------------------------------
319
* Destroy all defined fields.
320
*----------------------------------------------------------------------------*/
321
322
void
323
cs_field_destroy_all
(
void
);
324
325
/*----------------------------------------------------------------------------
326
* Allocate arrays for all defined fields based on their location.
327
*
328
* Location sized must thus be known.
329
*
330
* Fields that do not own their data should all have been mapped at this
331
* stage, and are checked.
332
*----------------------------------------------------------------------------*/
333
334
void
335
cs_field_allocate_or_map_all
(
void
);
336
337
/*----------------------------------------------------------------------------
338
* Return a pointer to a field based on its id.
339
*
340
* This function requires that a field of the given id is defined.
341
*
342
* parameters:
343
* id <-- field id
344
*
345
* returns:
346
* pointer to the field structure
347
*----------------------------------------------------------------------------*/
348
349
cs_field_t
*
350
cs_field_by_id
(
int
id
);
351
352
/*----------------------------------------------------------------------------
353
* Return a pointer to a field based on its name.
354
*
355
* This function requires that a field of the given name is defined.
356
*
357
* parameters:
358
* name <-- field name
359
*
360
* returns:
361
* pointer to the field structure
362
*----------------------------------------------------------------------------*/
363
364
cs_field_t
*
365
cs_field_by_name
(
const
char
*name);
366
367
/*----------------------------------------------------------------------------
368
* Return a pointer to a field based on its name if present.
369
*
370
* If no field of the given name is defined, NULL is returned.
371
*
372
* parameters:
373
* name <-- field name
374
*
375
* returns:
376
* pointer to the field structure, or NULL
377
*----------------------------------------------------------------------------*/
378
379
cs_field_t
*
380
cs_field_by_name_try
(
const
char
*name);
381
382
/*----------------------------------------------------------------------------
383
* Return the id of a defined field based on its name.
384
*
385
* If no field with the given name exists, -1 is returned.
386
*
387
* parameters:
388
* name <-- field name
389
*
390
* returns:
391
* id the field, or -1 if not found
392
*----------------------------------------------------------------------------*/
393
394
int
395
cs_field_id_by_name
(
const
char
*name);
396
397
/*----------------------------------------------------------------------------
398
* Return an id associated with a given key name.
399
*
400
* The key must have been defined previously.
401
*
402
* parameters:
403
* name <-- key name
404
*
405
* returns:
406
* id associated with key
407
*----------------------------------------------------------------------------*/
408
409
int
410
cs_field_key_id
(
const
char
*name);
411
412
/*----------------------------------------------------------------------------
413
* Return an id associated with a given key name if present.
414
*
415
* If the key has not been defined previously, -1 is returned.
416
*
417
* parameters:
418
* name <-- key name
419
*
420
* returns:
421
* id associated with key, or -1
422
*----------------------------------------------------------------------------*/
423
424
int
425
cs_field_key_id_try
(
const
char
*name);
426
427
/*----------------------------------------------------------------------------
428
* Define a key for an integer value by its name and return an associated id.
429
*
430
* If the key has already been defined, its previous default value is replaced
431
* by the current value, and its id is returned.
432
*
433
* parameters:
434
* name <-- key name
435
* default_value <-- default value associated with key
436
* type flag <-- mask associated with field types with which the
437
* key may be associated, or 0
438
*
439
* returns:
440
* id associated with key
441
*----------------------------------------------------------------------------*/
442
443
int
444
cs_field_define_key_int
(
const
char
*name,
445
int
default_value,
446
int
type_flag);
447
448
/*----------------------------------------------------------------------------
449
* Define a key for an floating point value by its name and return an
450
* associated id.
451
*
452
* If the key has already been defined, its previous default value is replaced
453
* by the current value, and its id is returned.
454
*
455
* parameters:
456
* name <-- key name
457
* default_value <-- default value associated with key
458
* type flag <-- mask associated with field types with which the
459
* key may be associated, or 0
460
*
461
* returns:
462
* id associated with key
463
*----------------------------------------------------------------------------*/
464
465
int
466
cs_field_define_key_double
(
const
char
*name,
467
double
default_value,
468
int
type_flag);
469
470
/*----------------------------------------------------------------------------
471
* Define a key for an string point value by its name and return an
472
* associated id.
473
*
474
* If the key has already been defined, its previous default value is replaced
475
* by the current value, and its id is returned.
476
*
477
* parameters:
478
* name <-- key name
479
* default_value <-- default value associated with key
480
* type flag <-- mask associated with field types with which the
481
* key may be associated, or 0
482
*
483
* returns:
484
* id associated with key
485
*----------------------------------------------------------------------------*/
486
487
int
488
cs_field_define_key_str
(
const
char
*name,
489
const
char
*default_value,
490
int
type_flag);
491
492
/*----------------------------------------------------------------------------
493
* Define a key for a structure value by its name and return an
494
* associated id.
495
*
496
* If the key has already been defined, its previous default value is replaced
497
* by the current value, and its id is returned.
498
*
499
* parameters:
500
* name <-- key name
501
* default_value <-- pointer to default value associated with key
502
* log_funct <-- pointer to logging function
503
* size <-- sizeof structure
504
* type_flag <-- mask associated with field types with which
505
* the key may be associated, or 0
506
*
507
* returns:
508
* id associated with key
509
*----------------------------------------------------------------------------*/
510
511
int
512
cs_field_define_key_struct
(
const
char
*name,
513
const
void
*default_value,
514
cs_field_log_key_struct_t
*log_func,
515
size_t
size,
516
int
type_flag);
517
518
/*----------------------------------------------------------------------------
519
* Define a sub key.
520
*
521
* The sub key is the same type as the parent key.
522
*
523
* For a given field, when querying a sub key's value and that value has not
524
* been set, the query will return the value of the parent key.
525
*
526
* parameters:
527
* name <-- key name
528
* parent_id <-- parent key id
529
*
530
* returns:
531
* id associated with key
532
*----------------------------------------------------------------------------*/
533
534
int
535
cs_field_define_sub_key
(
const
char
*name,
536
int
parent_id);
537
538
/*----------------------------------------------------------------------------
539
* Destroy all defined field keys and associated values.
540
*----------------------------------------------------------------------------*/
541
542
void
543
cs_field_destroy_all_keys
(
void
);
544
545
/*----------------------------------------------------------------------------
546
* Get the type flag associated with a given key id.
547
*
548
* If the key has not been defined previously, -1 is returned.
549
*
550
* parameters:
551
* key_id <-- id of associated key
552
*
553
* returns:
554
* type flag associated with key, or -1
555
*----------------------------------------------------------------------------*/
556
557
int
558
cs_field_key_flag
(
int
key_id);
559
560
/*----------------------------------------------------------------------------
561
* Query if a given key has been set for a field.
562
*
563
* If the key id is not valid, or the field category is not
564
* compatible, a fatal error is provoked.
565
*
566
* parameters:
567
* f <-- pointer to field structure
568
* key_id <-- id of associated key
569
*
570
* returns:
571
* true if the key has been set for this field, false otherwise
572
*----------------------------------------------------------------------------*/
573
574
bool
575
cs_field_is_key_set
(
const
cs_field_t
*f,
576
int
key_id);
577
578
/*----------------------------------------------------------------------------
579
* Assign a integer value for a given key to a field.
580
*
581
* If the key id is not valid, CS_FIELD_INVALID_KEY_ID is returned.
582
* If the field category is not compatible with the key (as defined
583
* by its type flag), CS_FIELD_INVALID_CATEGORY is returned.
584
* If the data type does not match, CS_FIELD_INVALID_TYPE is returned.
585
*
586
* parameters:
587
* f <-- pointer to field structure
588
* key_id <-- id of associated key
589
* value <-- value associated with key
590
*
591
* returns:
592
* 0 in case of success, > 1 in case of error
593
*----------------------------------------------------------------------------*/
594
595
int
596
cs_field_set_key_int
(
cs_field_t
*f,
597
int
key_id,
598
int
value);
599
600
/*----------------------------------------------------------------------------
601
* Return a integer value for a given key associated with a field.
602
*
603
* If the key id is not valid, or the value type or field category is not
604
* compatible, a fatal error is provoked.
605
*
606
* parameters:
607
* f <-- pointer to field structure
608
* key_id <-- id of associated key
609
*
610
* returns:
611
* integer value associated with the key id for this field
612
*----------------------------------------------------------------------------*/
613
614
int
615
cs_field_get_key_int
(
const
cs_field_t
*f,
616
int
key_id);
617
618
/*----------------------------------------------------------------------------
619
* Assign a floating point value for a given key to a field.
620
*
621
* If the key id is not valid, CS_FIELD_INVALID_KEY_ID is returned.
622
* If the field category is not compatible with the key (as defined
623
* by its type flag), CS_FIELD_INVALID_CATEGORY is returned.
624
* If the data type does not match, CS_FIELD_INVALID_TYPE is returned.
625
*
626
* parameters:
627
* f <-- pointer to field structure
628
* key_id <-- id of associated key
629
* value <-- value associated with key
630
*
631
* returns:
632
* 0 in case of success, > 1 in case of error
633
*----------------------------------------------------------------------------*/
634
635
int
636
cs_field_set_key_double
(
cs_field_t
*f,
637
int
key_id,
638
double
value);
639
640
/*----------------------------------------------------------------------------
641
* Return a floating point value for a given key associated with a field.
642
*
643
* If the key id is not valid, or the value type or field category is not
644
* compatible, a fatal error is provoked.
645
*
646
* parameters:
647
* f <-- pointer to field structure
648
* key_id <-- id of associated key
649
*
650
* returns:
651
* floating point value associated with the key id for this field
652
*----------------------------------------------------------------------------*/
653
654
double
655
cs_field_get_key_double
(
const
cs_field_t
*f,
656
int
key_id);
657
658
/*----------------------------------------------------------------------------
659
* Assign a character string value for a given key to a field.
660
*
661
* If the key id is not valid, CS_FIELD_INVALID_KEY_ID is returned.
662
* If the field category is not compatible with the key (as defined
663
* by its type flag), CS_FIELD_INVALID_CATEGORY is returned.
664
* If the data type does not match, CS_FIELD_INVALID_TYPE is returned.
665
*
666
* parameters:
667
* f <-- pointer to field structure
668
* key_id <-- id of associated key
669
* str <-- string associated with key
670
*
671
* returns:
672
* 0 in case of success, > 1 in case of error
673
*----------------------------------------------------------------------------*/
674
675
int
676
cs_field_set_key_str
(
cs_field_t
*f,
677
int
key_id,
678
const
char
*str);
679
680
/*----------------------------------------------------------------------------
681
* Return a string for a given key associated with a field.
682
*
683
* If the key id is not valid, or the value type or field category is not
684
* compatible, a fatal error is provoked.
685
*
686
* parameters:
687
* f <-- pointer to field structure
688
* key_id <-- id of associated key
689
*
690
* returns:
691
* pointer to character string associated with the key id for this field
692
*----------------------------------------------------------------------------*/
693
694
const
char
*
695
cs_field_get_key_str
(
const
cs_field_t
*f,
696
int
key_id);
697
698
699
/*----------------------------------------------------------------------------
700
* Assign a simple structure for a given key to a field.
701
*
702
* If the key id is not valid, CS_FIELD_INVALID_KEY_ID is returned.
703
* If the field category is not compatible with the key (as defined
704
* by its type flag), CS_FIELD_INVALID_CATEGORY is returned.
705
*
706
* parameters:
707
* f <-- pointer to field structure
708
* key_id <-- id of associated key
709
* s <-- structure associated with key
710
*
711
* returns:
712
* 0 in case of success, > 1 in case of error
713
*----------------------------------------------------------------------------*/
714
715
int
716
cs_field_set_key_struct
(
cs_field_t
*f,
717
int
key_id,
718
void
*s);
719
720
/*----------------------------------------------------------------------------
721
* Return a structure for a given key associated with a field.
722
*
723
* If the key id is not valid, or the value type or field category is not
724
* compatible, a fatal error is provoked.
725
*
726
* parameters:
727
* f <-- pointer to field structure
728
* key_id <-- id of associated key
729
* s <-- structure associated with key
730
*
731
* returns:
732
* pointer to structure associated with the key id for this field
733
* (same as s)
734
*----------------------------------------------------------------------------*/
735
736
const
void
*
737
cs_field_get_key_struct
(
const
cs_field_t
*f,
738
int
key_id,
739
void
*s);
740
741
/*----------------------------------------------------------------------------
742
* Print info relative to all field definitions to log file.
743
*----------------------------------------------------------------------------*/
744
745
void
746
cs_field_log_defs
(
void
);
747
748
/*----------------------------------------------------------------------------
749
* Print info relative to a given field to log file.
750
*
751
* parameters:
752
* f <-- pointer to field structure
753
* log_keywords <-- log level for keywords (0: do not log,
754
* 1: log non-default values, 2: log all)
755
*----------------------------------------------------------------------------*/
756
757
void
758
cs_field_log_info
(
const
cs_field_t
*f,
759
int
log_keywords);
760
761
/*----------------------------------------------------------------------------
762
* Print info relative to all defined fields to log file.
763
*
764
* parameters:
765
* log_keywords <-- log level for keywords (0: do not log,
766
* 1: log non-default values, 2: log all)
767
*----------------------------------------------------------------------------*/
768
769
void
770
cs_field_log_fields
(
int
log_keywords);
771
772
/*----------------------------------------------------------------------------
773
* Print info relative to all key definitions to log file.
774
*----------------------------------------------------------------------------*/
775
776
void
777
cs_field_log_key_defs
(
void
);
778
779
/*----------------------------------------------------------------------------
780
* Print info relative to a given field key to log file.
781
*
782
* parameters:
783
* int key_id <-- id of associated key
784
* log_defaults <-- if true, log default field values in addition to
785
* defined field values
786
*----------------------------------------------------------------------------*/
787
788
void
789
cs_field_log_key_vals
(
int
key_id,
790
bool
log_defaults);
791
792
/*----------------------------------------------------------------------------
793
* Print info relative to all given field keys to log file.
794
*
795
* parameters:
796
* log_defaults <-- if true, log default field values in addition to
797
* defined field values
798
*----------------------------------------------------------------------------*/
799
800
void
801
cs_field_log_all_key_vals
(
bool
log_defaults);
802
803
/*----------------------------------------------------------------------------
804
* Define base keys.
805
*
806
* Keys defined by this function are:
807
* "label" (string)
808
* "log" (integer)
809
* "post_vis" (integer)
810
* "post_probes" (integer)
811
* "coupled" (integer, restricted to CS_FIELD_VARIABLE)
812
* "moment_dt" (integer, restricted to CS_FIELD_PROPERTY);
813
*
814
* A recommened practice for different submodules would be to use
815
* "cs_<module>_key_init() functions to define keys specific to those modules.
816
*----------------------------------------------------------------------------*/
817
818
void
819
cs_field_define_keys_base
(
void
);
820
821
/*----------------------------------------------------------------------------*/
822
823
END_C_DECLS
824
825
#endif
/* __CS_FIELD_H__ */
Generated on Thu Feb 27 2014 19:21:34 by
1.8.3.1