FrontISTR  5.7.0
Large-scale structural analysis program with finit element method
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 
28 enum {
34 
41 
43 
53 };
54 
55 CHECDataBlock* CreateFSTRDataBlock(const char* header_name);
56 bool IsFSTRDataBlockName(const char* name);
57 
58 class CFSTRDataBlock : public CHECDataBlock {
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 
102  CFSTRDB_Solver();
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 
114  CFSTRDB_Write();
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 
121 class CFSTRDB_Echo : public CFSTRDataBlock {
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 
132 class CFSTRDB_Step : public CFSTRDataBlock {
133  public:
134  int type;
136  int incmax;
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 Structural Analysis
147 //-----------------------------------------------
148 
150  public:
151  // 2nd line -----------------
152  double dtime, etime, itmax, eps;
153 
154  CFSTRDB_Static();
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
166  int dof_ids;
167  int dof_ide;
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:
196  int dof_id;
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 
211  CFSTRDB_CLoad();
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 
272  CFSTRDB_DLoad();
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 
307  CFSTRDB_Reftemp();
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;
324  int lczmax;
325 
326  CFSTRDB_Eigen();
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 
337 class CFSTRDB_Heat : public CFSTRDataBlock {
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 
375  CFSTRDB_Fixtemp();
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 
401  CFSTRDB_CFlux();
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 
447  CFSTRDB_DFlux();
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 
473  CFSTRDB_SFlux();
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 
480 class CFSTRDB_Film : public CFSTRDataBlock {
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 
554  CFSTRDB_SFilm();
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 
603  CFSTRDB_Radiate();
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