FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
CFSTRDB.h
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5/*
6 CFSTRDB Ver. 3.6
7 --------------------------------------------
8 Control Data of FRONT-STR( pSAN )
9*/
10
11#ifndef CFSTRDBH
12#define CFSTRDBH
13
14#include "CHECDataBlock.h"
15#include "CHECDB.h"
16#include <string.h>
17
18#ifndef TRUE
19#define TRUE 1
20#define FALSE 0
21#endif
22
23#ifndef YES
24#define YES 1
25#define NO 0
26#endif
27
28enum {
34
41
43
53};
54
55CHECDataBlock* CreateFSTRDataBlock(const char* header_name);
56bool IsFSTRDataBlockName(const char* name);
57
59 public:
60 CFSTRDataBlock(int dtype) : CHECDataBlock(dtype) {}
61 virtual bool IsMesh() { return false; }
62};
63
64//-----------------------------------------------
65// For Common Used
66//-----------------------------------------------
67
69 public:
70 int type;
72
74 virtual ~CFSTRDB_Solution();
75 virtual void Clear();
76 virtual void Write(class CHECData* hecd);
77 virtual bool Read(class CHECData* hecd, char* header_line);
78};
79
81 public:
82 // header line ---------------------
83
84 char method[30];
85 int precond; // 1,2,3,10,11,12 or 21
86 int nset; // 0,-1 or 1
87 int iterlog; // 1:Yes, 0:No
88 int timelog; // 1:Yes, 0:No
89
90 // 2nd line ------------------------
91
93
94 // 3rd line ------------------------
95
97
98 // 4th line ------------------------
99
100 double thresh, filter;
101
103 virtual ~CFSTRDB_Solver();
104 virtual void Clear();
105 virtual void Write(class CHECData* hecd);
106 virtual bool Read(class CHECData* hecd, char* header_line);
107};
108
110 public:
111 int result; // 1:Yes, 0:No
112 int visual; // 1:Yes, 0:No
113
115 virtual ~CFSTRDB_Write();
116 virtual void Clear();
117 virtual void Write(class CHECData* hecd);
118 virtual bool Read(class CHECData* hecd, char* header_line);
119};
120
122 public:
123 int echo;
124
125 CFSTRDB_Echo();
126 virtual ~CFSTRDB_Echo();
127 virtual void Clear();
128 virtual void Write(class CHECData* hecd);
129 virtual bool Read(class CHECData* hecd, char* header_line);
130};
131
133 public:
134 int type;
137
138 CFSTRDB_Step();
139 virtual ~CFSTRDB_Step();
140 virtual void Clear();
141 virtual void Write(class CHECData* hecd);
142 virtual bool Read(class CHECData* hecd, char* header_line);
143};
144
145//-----------------------------------------------
146// For Elastic Static Structual Analysis
147//-----------------------------------------------
148
150 public:
151 // 2nd line -----------------
152 double dtime, etime, itmax, eps;
153
155 virtual ~CFSTRDB_Static();
156 virtual void Clear();
157 virtual void Write(class CHECData* hecd);
158 virtual bool Read(class CHECData* hecd, char* header_line);
159};
160
162 public:
163 class CItem {
164 public:
165 char ngrp[hec_name_size]; // ngrp name or node id
168 double value;
169 CItem() : dof_ids(0), dof_ide(0), value(0) { ngrp[0] = 0; }
170 CItem(const char* name, int s, int e, double v = 0)
171 : dof_ids(s), dof_ide(e), value(v) {
172 strcpy(ngrp, name);
173 }
174 CItem(const CItem& item)
175 : dof_ids(item.dof_ids), dof_ide(item.dof_ide), value(item.value) {
176 strcpy(ngrp, item.ngrp);
177 }
178 };
179
180 // data line -----------------
181
182 std::vector<CItem> ItemList;
183
185 virtual ~CFSTRDB_Boundary();
186 virtual void Clear();
187 virtual void Write(class CHECData* hecd);
188 virtual bool Read(class CHECData* hecd, char* header_line);
189};
190
192 public:
193 class CItem {
194 public:
197 double value;
198 CItem() : dof_id(-1), value(0) { ngrp[0] = 0; }
199 CItem(const char* name, int id, double v = 0) : dof_id(id), value(v) {
200 strcpy(ngrp, name);
201 }
202 CItem(const CItem& item) : dof_id(item.dof_id), value(item.value) {
203 strcpy(ngrp, item.ngrp);
204 }
205 };
206
207 // data line -----------------
208
209 std::vector<CItem> ItemList;
210
212 virtual ~CFSTRDB_CLoad();
213 virtual void Clear();
214 virtual void Write(class CHECData* hecd);
215 virtual bool Read(class CHECData* hecd, char* header_line);
216};
217
219 public:
220 enum {
234 };
235 static int TypeNumber() { return 12; }
236 static int ParamNumber(int type);
237 static const char* LoadTypeName(int type);
238
239 class CItem {
240 public:
242 int type;
243 double param[7];
245 egrp[0] = 0;
246 init_param();
247 }
248 CItem(const char* name, int t) : type(t) {
249 strcpy(egrp, name);
250 init_param();
251 }
252 CItem(const CItem& item) : type(item.type) {
253 strcpy(egrp, item.egrp);
254 param[0] = item.param[0];
255 param[1] = item.param[1];
256 param[2] = item.param[2];
257 param[3] = item.param[3];
258 param[4] = item.param[4];
259 param[5] = item.param[5];
260 param[6] = item.param[6];
261 }
262 void init_param() {
263 param[0] = param[1] = param[2] = param[3] = param[4] = param[5] =
264 param[6] = 0.0;
265 }
266 };
267
268 // data line -----------------
269
270 std::vector<CItem> ItemList;
271
273 virtual ~CFSTRDB_DLoad();
274 virtual void Clear();
275 virtual void Write(class CHECData* hecd);
276 virtual bool Read(class CHECData* hecd, char* header_line);
277};
278
280 public:
281 class CItem {
282 public:
284 int value;
285 CItem() : value(0) { ngrp[0] = 0; }
286 CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
287 CItem(const char* name, int v = 0) : value(v) { strcpy(ngrp, name); }
288 };
289
290 // data line -----------------
291
292 std::vector<CItem> ItemList;
293
295 virtual ~CFSTRDB_Temperature();
296 virtual void Clear();
297 virtual void Write(class CHECData* hecd);
298 virtual bool Read(class CHECData* hecd, char* header_line);
299};
300
302 public:
303 // data line -----------------
304
305 double value;
306
308 virtual ~CFSTRDB_Reftemp();
309 virtual void Clear();
310 virtual void Write(class CHECData* hecd);
311 virtual bool Read(class CHECData* hecd, char* header_line);
312};
313
314//-----------------------------------------------
315// For Eigen Analysis
316//-----------------------------------------------
317
319 public:
320 // data line -----------------
321
322 int nset;
323 double lcztol;
325
327 virtual ~CFSTRDB_Eigen();
328 virtual void Clear();
329 virtual void Write(class CHECData* hecd);
330 virtual bool Read(class CHECData* hecd, char* header_line);
331};
332
333//-----------------------------------------------
334// For Heat Transfer Analysis
335//-----------------------------------------------
336
338 public:
339 // header line -----------------
340
341 int restart; // TRUE/FALSE
342
343 // 2nd line -------------------
344
345 double dt, etime, dtime, deltmx;
346 int itmax;
347 double eps;
348
349 CFSTRDB_Heat();
350 virtual ~CFSTRDB_Heat();
351 virtual void Clear();
352 virtual void Write(class CHECData* hecd);
353 virtual bool Read(class CHECData* hecd, char* header_line);
354};
355
357 public:
358 class CItem {
359 public:
361 double value;
362 CItem() : value(0) { ngrp[0] = 0; }
363 CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
364 CItem(const char* name, double v) : value(v) { strcpy(ngrp, name); }
365 };
366
367 // header line --------------------
368
370
371 // data line ----------------------
372
373 std::vector<CItem> ItemList;
374
376 virtual ~CFSTRDB_Fixtemp();
377 virtual void Clear();
378 virtual void Write(class CHECData* hecd);
379 virtual bool Read(class CHECData* hecd, char* header_line);
380};
381
383 public:
384 class CItem {
385 public:
387 double value;
388 CItem() : value(0) { ngrp[0] = 0; }
389 CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
390 CItem(const char* name, double v) : value(v) { strcpy(ngrp, name); }
391 };
392
393 // header line --------------------
394
396
397 // data line ----------------------
398
399 std::vector<CItem> ItemList;
400
402 virtual ~CFSTRDB_CFlux();
403 virtual void Clear();
404 virtual void Write(class CHECData* hecd);
405 virtual bool Read(class CHECData* hecd, char* header_line);
406};
407
409 public:
410 enum {
420 };
421
422 static int TypeNumber() { return 8; }
423 static const char* LoadTypeName(int type);
424
425 class CItem {
426 public:
428 int type;
429 double value;
430 CItem() : type(TYPE_UNKNOWN), value(0) { egrp[0] = 0; }
431 CItem(const CItem& item) : type(item.type), value(item.value) {
432 strcpy(egrp, item.egrp);
433 }
434 CItem(const char* name, int t, double v) : type(t), value(v) {
435 strcpy(egrp, name);
436 }
437 };
438
439 // header line --------------------
440
442
443 // data line ----------------------
444
445 std::vector<CItem> ItemList;
446
448 virtual ~CFSTRDB_DFlux();
449 virtual void Clear();
450 virtual void Write(class CHECData* hecd);
451 virtual bool Read(class CHECData* hecd, char* header_line);
452};
453
455 public:
456 class CItem {
457 public:
459 double value;
460 CItem() : value(0) { sgrp[0] = 0; }
461 CItem(const CItem& item) : value(item.value) { strcpy(sgrp, item.sgrp); }
462 CItem(const char* name, double v) : value(v) { strcpy(sgrp, name); }
463 };
464
465 // header line --------------------
466
468
469 // data line ----------------------
470
471 std::vector<CItem> ItemList;
472
474 virtual ~CFSTRDB_SFlux();
475 virtual void Clear();
476 virtual void Write(class CHECData* hecd);
477 virtual bool Read(class CHECData* hecd, char* header_line);
478};
479
481 public:
482 enum {
491 };
492
493 static int TypeNumber() { return 7; }
494 static const char* LoadTypeName(int type);
495
496 class CItem {
497 public:
499 int type;
500 double value;
501 double sink;
502 CItem() : type(TYPE_UNKNOWN), value(0), sink(0) { egrp[0] = 0; }
503 CItem(const CItem& item)
504 : type(item.type), value(item.value), sink(item.sink) {
505 strcpy(egrp, item.egrp);
506 }
507 CItem(const char* name, int t, double v, double s)
508 : type(t), value(v), sink(s) {
509 strcpy(egrp, name);
510 }
511 };
512
513 // header line --------------------
514
517
518 // data line ----------------------
519
520 std::vector<CItem> ItemList;
521
522 CFSTRDB_Film();
523 virtual ~CFSTRDB_Film();
524 virtual void Clear();
525 virtual void Write(class CHECData* hecd);
526 virtual bool Read(class CHECData* hecd, char* header_line);
527};
528
530 public:
531 class CItem {
532 public:
534 double value;
535 double sink;
536 CItem() : value(0), sink(0) { sgrp[0] = 0; }
537 CItem(const CItem& item) : value(item.value), sink(item.sink) {
538 strcpy(sgrp, item.sgrp);
539 }
540 CItem(const char* name, double v, double s) : value(v), sink(s) {
541 strcpy(sgrp, name);
542 }
543 };
544
545 // header line --------------------
546
549
550 // data line ----------------------
551
552 std::vector<CItem> ItemList;
553
555 virtual ~CFSTRDB_SFilm();
556 virtual void Clear();
557 virtual void Write(class CHECData* hecd);
558 virtual bool Read(class CHECData* hecd, char* header_line);
559};
560
562 public:
563 enum {
572 };
573
574 static int TypeNumber() { return 7; }
575 static const char* LoadTypeName(int type);
576
577 class CItem {
578 public:
580 int type;
581 double value;
582 double sink;
583 CItem() : type(TYPE_UNKNOWN), value(0), sink(0) { egrp[0] = 0; }
584 CItem(const CItem& item)
585 : type(item.type), value(item.value), sink(item.sink) {
586 strcpy(egrp, item.egrp);
587 }
588 CItem(const char* name, int t, double v, double s)
589 : type(t), value(v), sink(s) {
590 strcpy(egrp, name);
591 }
592 };
593
594 // header line --------------------
595
598
599 // data line ----------------------
600
601 std::vector<CItem> ItemList;
602
604 virtual ~CFSTRDB_Radiate();
605 virtual void Clear();
606 virtual void Write(class CHECData* hecd);
607 virtual bool Read(class CHECData* hecd, char* header_line);
608};
609
611 public:
612 class CItem {
613 public:
615 double value;
616 double sink;
617 CItem() : value(0), sink(0) { sgrp[0] = 0; }
618 CItem(const CItem& item) : value(item.value), sink(item.sink) {
619 strcpy(sgrp, item.sgrp);
620 }
621 CItem(const char* name, double v, double s) : value(v), sink(s) {
622 strcpy(sgrp, name);
623 }
624 };
625
626 // header line --------------------
627
630
631 // data line ----------------------
632
633 std::vector<CItem> ItemList;
634
636 virtual ~CFSTRDB_SRadiate();
637 virtual void Clear();
638 virtual void Write(class CHECData* hecd);
639 virtual bool Read(class CHECData* hecd, char* header_line);
640};
641
642#endif
CHECDataBlock * CreateFSTRDataBlock(const char *header_name)
Definition: FSTRDB_util.cpp:16
@ FSTRDB_EIGEN
Definition: CFSTRDB.h:42
@ FSTRDB_ECHO
Definition: CFSTRDB.h:32
@ FSTRDB_SFILM
Definition: CFSTRDB.h:50
@ FSTRDB_WRITE
Definition: CFSTRDB.h:31
@ FSTRDB_SFLUX
Definition: CFSTRDB.h:48
@ FSTRDB_REFTEMP
Definition: CFSTRDB.h:40
@ FSTRDB_BOUNDARY
Definition: CFSTRDB.h:36
@ FSTRDB_CFLUX
Definition: CFSTRDB.h:46
@ FSTRDB_DLOAD
Definition: CFSTRDB.h:38
@ FSTRDB_STEP
Definition: CFSTRDB.h:33
@ FSTRDB_STATIC
Definition: CFSTRDB.h:35
@ FSTRDB_FIXTEMP
Definition: CFSTRDB.h:45
@ FSTRDB_HEAT
Definition: CFSTRDB.h:44
@ FSTRDB_TEMPERATURE
Definition: CFSTRDB.h:39
@ FSTRDB_RADIATE
Definition: CFSTRDB.h:51
@ FSTRDB_SOLVER
Definition: CFSTRDB.h:30
@ FSTRDB_DFLUX
Definition: CFSTRDB.h:47
@ FSTRDB_CLOAD
Definition: CFSTRDB.h:37
@ FSTRDB_SRADIATE
Definition: CFSTRDB.h:52
@ FSTRDB_SOLUTION
Definition: CFSTRDB.h:29
@ FSTRDB_FILM
Definition: CFSTRDB.h:49
bool IsFSTRDataBlockName(const char *name)
Definition: FSTRDB_util.cpp:67
const int hec_name_size
Definition: CHECDataBlock.h:14
CItem(const CItem &item)
Definition: CFSTRDB.h:174
CItem(const char *name, int s, int e, double v=0)
Definition: CFSTRDB.h:170
char ngrp[hec_name_size]
Definition: CFSTRDB.h:165
std::vector< CItem > ItemList
Definition: CFSTRDB.h:182
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Write(class CHECData *hecd)
virtual void Clear()
virtual ~CFSTRDB_Boundary()
char ngrp[hec_name_size]
Definition: CFSTRDB.h:386
CItem(const CItem &item)
Definition: CFSTRDB.h:389
CItem(const char *name, double v)
Definition: CFSTRDB.h:390
virtual ~CFSTRDB_CFlux()
char amp[hec_name_size]
Definition: CFSTRDB.h:395
std::vector< CItem > ItemList
Definition: CFSTRDB.h:399
virtual void Write(class CHECData *hecd)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
CItem(const CItem &item)
Definition: CFSTRDB.h:202
CItem(const char *name, int id, double v=0)
Definition: CFSTRDB.h:199
char ngrp[hec_name_size]
Definition: CFSTRDB.h:195
virtual void Write(class CHECData *hecd)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CFSTRDB_CLoad()
std::vector< CItem > ItemList
Definition: CFSTRDB.h:209
virtual void Clear()
CItem(const CItem &item)
Definition: CFSTRDB.h:431
char egrp[hec_name_size]
Definition: CFSTRDB.h:427
CItem(const char *name, int t, double v)
Definition: CFSTRDB.h:434
static const char * LoadTypeName(int type)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CFSTRDB_DFlux()
virtual void Clear()
std::vector< CItem > ItemList
Definition: CFSTRDB.h:445
static int TypeNumber()
Definition: CFSTRDB.h:422
char amp[hec_name_size]
Definition: CFSTRDB.h:441
virtual void Write(class CHECData *hecd)
CItem(const CItem &item)
Definition: CFSTRDB.h:252
CItem(const char *name, int t)
Definition: CFSTRDB.h:248
double param[7]
Definition: CFSTRDB.h:243
char egrp[hec_name_size]
Definition: CFSTRDB.h:241
static const char * LoadTypeName(int type)
static int TypeNumber()
Definition: CFSTRDB.h:235
virtual void Clear()
virtual ~CFSTRDB_DLoad()
std::vector< CItem > ItemList
Definition: CFSTRDB.h:270
virtual void Write(class CHECData *hecd)
static int ParamNumber(int type)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Write(class CHECData *hecd)
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CFSTRDB_Echo()
virtual void Clear()
virtual void Write(class CHECData *hecd)
virtual ~CFSTRDB_Eigen()
virtual bool Read(class CHECData *hecd, char *header_line)
double lcztol
Definition: CFSTRDB.h:323
CItem(const char *name, int t, double v, double s)
Definition: CFSTRDB.h:507
char egrp[hec_name_size]
Definition: CFSTRDB.h:498
CItem(const CItem &item)
Definition: CFSTRDB.h:503
static const char * LoadTypeName(int type)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
@ TYPE_UNKNOWN
Definition: CFSTRDB.h:490
virtual ~CFSTRDB_Film()
virtual void Write(class CHECData *hecd)
static int TypeNumber()
Definition: CFSTRDB.h:493
char amp1[hec_name_size]
Definition: CFSTRDB.h:515
std::vector< CItem > ItemList
Definition: CFSTRDB.h:520
char amp2[hec_name_size]
Definition: CFSTRDB.h:516
char ngrp[hec_name_size]
Definition: CFSTRDB.h:360
CItem(const CItem &item)
Definition: CFSTRDB.h:363
CItem(const char *name, double v)
Definition: CFSTRDB.h:364
virtual ~CFSTRDB_Fixtemp()
std::vector< CItem > ItemList
Definition: CFSTRDB.h:373
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
char amp[hec_name_size]
Definition: CFSTRDB.h:369
virtual void Write(class CHECData *hecd)
double dt
Definition: CFSTRDB.h:345
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
virtual void Write(class CHECData *hecd)
double eps
Definition: CFSTRDB.h:347
double dtime
Definition: CFSTRDB.h:345
int restart
Definition: CFSTRDB.h:341
virtual ~CFSTRDB_Heat()
double deltmx
Definition: CFSTRDB.h:345
double etime
Definition: CFSTRDB.h:345
CItem(const CItem &item)
Definition: CFSTRDB.h:584
CItem(const char *name, int t, double v, double s)
Definition: CFSTRDB.h:588
char egrp[hec_name_size]
Definition: CFSTRDB.h:579
char amp2[hec_name_size]
Definition: CFSTRDB.h:597
std::vector< CItem > ItemList
Definition: CFSTRDB.h:601
virtual bool Read(class CHECData *hecd, char *header_line)
static const char * LoadTypeName(int type)
virtual void Write(class CHECData *hecd)
virtual void Clear()
static int TypeNumber()
Definition: CFSTRDB.h:574
char amp1[hec_name_size]
Definition: CFSTRDB.h:596
virtual ~CFSTRDB_Radiate()
virtual void Write(class CHECData *hecd)
double value
Definition: CFSTRDB.h:305
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
virtual ~CFSTRDB_Reftemp()
char sgrp[hec_name_size]
Definition: CFSTRDB.h:533
CItem(const char *name, double v, double s)
Definition: CFSTRDB.h:540
CItem(const CItem &item)
Definition: CFSTRDB.h:537
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Write(class CHECData *hecd)
virtual ~CFSTRDB_SFilm()
virtual void Clear()
char amp1[hec_name_size]
Definition: CFSTRDB.h:547
char amp2[hec_name_size]
Definition: CFSTRDB.h:548
std::vector< CItem > ItemList
Definition: CFSTRDB.h:552
char sgrp[hec_name_size]
Definition: CFSTRDB.h:458
CItem(const char *name, double v)
Definition: CFSTRDB.h:462
CItem(const CItem &item)
Definition: CFSTRDB.h:461
std::vector< CItem > ItemList
Definition: CFSTRDB.h:471
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Write(class CHECData *hecd)
char amp[hec_name_size]
Definition: CFSTRDB.h:467
virtual ~CFSTRDB_SFlux()
char sgrp[hec_name_size]
Definition: CFSTRDB.h:614
CItem(const char *name, double v, double s)
Definition: CFSTRDB.h:621
CItem(const CItem &item)
Definition: CFSTRDB.h:618
virtual void Write(class CHECData *hecd)
virtual void Clear()
virtual ~CFSTRDB_SRadiate()
char amp1[hec_name_size]
Definition: CFSTRDB.h:628
virtual bool Read(class CHECData *hecd, char *header_line)
char amp2[hec_name_size]
Definition: CFSTRDB.h:629
std::vector< CItem > ItemList
Definition: CFSTRDB.h:633
virtual void Write(class CHECData *hecd)
virtual void Clear()
virtual ~CFSTRDB_Solution()
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
double thresh
Definition: CFSTRDB.h:100
int iterPREmax
Definition: CFSTRDB.h:92
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Write(class CHECData *hecd)
virtual ~CFSTRDB_Solver()
double sigma
Definition: CFSTRDB.h:96
double filter
Definition: CFSTRDB.h:100
double fsigma_diag
Definition: CFSTRDB.h:96
char method[30]
Definition: CFSTRDB.h:84
double resid
Definition: CFSTRDB.h:96
virtual void Write(class CHECData *hecd)
virtual void Clear()
double dtime
Definition: CFSTRDB.h:152
virtual bool Read(class CHECData *hecd, char *header_line)
double etime
Definition: CFSTRDB.h:152
double itmax
Definition: CFSTRDB.h:152
virtual ~CFSTRDB_Static()
double eps
Definition: CFSTRDB.h:152
virtual bool Read(class CHECData *hecd, char *header_line)
@ TYPE_STANDARD
Definition: CFSTRDB.h:135
@ TYPE_UNKNOWN
Definition: CFSTRDB.h:135
int incmax
Definition: CFSTRDB.h:136
virtual void Clear()
virtual void Write(class CHECData *hecd)
virtual ~CFSTRDB_Step()
CItem(const char *name, int v=0)
Definition: CFSTRDB.h:287
char ngrp[hec_name_size]
Definition: CFSTRDB.h:283
CItem(const CItem &item)
Definition: CFSTRDB.h:286
std::vector< CItem > ItemList
Definition: CFSTRDB.h:292
virtual void Write(class CHECData *hecd)
virtual bool Read(class CHECData *hecd, char *header_line)
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CFSTRDB_Write()
virtual void Write(class CHECData *hecd)
virtual bool IsMesh()
Definition: CFSTRDB.h:61
CFSTRDataBlock(int dtype)
Definition: CFSTRDB.h:60