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 {
29   FSTRDB_SOLUTION = 100,
30   FSTRDB_SOLVER,
31   FSTRDB_WRITE,
32   FSTRDB_ECHO,
33   FSTRDB_STEP,
34 
35   FSTRDB_STATIC,
36   FSTRDB_BOUNDARY,
37   FSTRDB_CLOAD,
38   FSTRDB_DLOAD,
39   FSTRDB_TEMPERATURE,
40   FSTRDB_REFTEMP,
41 
42   FSTRDB_EIGEN,
43 
44   FSTRDB_HEAT,
45   FSTRDB_FIXTEMP,
46   FSTRDB_CFLUX,
47   FSTRDB_DFLUX,
48   FSTRDB_SFLUX,
49   FSTRDB_FILM,
50   FSTRDB_SFILM,
51   FSTRDB_RADIATE,
52   FSTRDB_SRADIATE
53 };
54 
55 CHECDataBlock* CreateFSTRDataBlock(const char* header_name);
56 bool IsFSTRDataBlockName(const char* name);
57 
58 class CFSTRDataBlock : public CHECDataBlock {
59  public:
CFSTRDataBlock(int dtype)60   CFSTRDataBlock(int dtype) : CHECDataBlock(dtype) {}
IsMesh()61   virtual bool IsMesh() { return false; }
62 };
63 
64 //-----------------------------------------------
65 // For Common Used
66 //-----------------------------------------------
67 
68 class CFSTRDB_Solution : public CFSTRDataBlock {
69  public:
70   int type;
71   enum { TYPE_UNKNOWN, TYPE_STATIC, TYPE_HEAT, TYPE_EIGEN };
72 
73   CFSTRDB_Solution();
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 
80 class CFSTRDB_Solver : public CFSTRDataBlock {
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 
92   int nier, iterPREmax, nrest;
93 
94   // 3rd line ------------------------
95 
96   double resid, fsigma_diag, sigma;
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 
109 class CFSTRDB_Write : public CFSTRDataBlock {
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;
135   enum { TYPE_UNKNOWN, TYPE_STANDARD, TYPE_NLGEOM };
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 Structual Analysis
147 //-----------------------------------------------
148 
149 class CFSTRDB_Static : public CFSTRDataBlock {
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 
161 class CFSTRDB_Boundary : public CFSTRDataBlock {
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;
CItem()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)
dof_ids(s)171         : dof_ids(s), dof_ide(e), value(v) {
172       strcpy(ngrp, name);
173     }
CItem(const CItem & item)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 
184   CFSTRDB_Boundary();
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 
191 class CFSTRDB_CLoad : public CFSTRDataBlock {
192  public:
193   class CItem {
194    public:
195     char ngrp[hec_name_size];
196     int dof_id;
197     double value;
CItem()198     CItem() : dof_id(-1), value(0) { ngrp[0] = 0; }
dof_id(id)199     CItem(const char* name, int id, double v = 0) : dof_id(id), value(v) {
200       strcpy(ngrp, name);
201     }
CItem(const CItem & item)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 
218 class CFSTRDB_DLoad : public CFSTRDataBlock {
219  public:
220   enum {
221     TYPE_P0,
222     TYPE_P1,
223     TYPE_P2,
224     TYPE_P3,
225     TYPE_P4,
226     TYPE_P5,
227     TYPE_P6,
228     TYPE_BX,
229     TYPE_BY,
230     TYPE_BZ,
231     TYPE_GRAV,
232     TYPE_CENT,
233     TYPE_UNKNOWN
234   };
TypeNumber()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:
241     char egrp[hec_name_size];
242     int type;
243     double param[7];
CItem()244     CItem() : type(TYPE_UNKNOWN) {
245       egrp[0] = 0;
246       init_param();
247     }
CItem(const char * name,int t)248     CItem(const char* name, int t) : type(t) {
249       strcpy(egrp, name);
250       init_param();
251     }
CItem(const CItem & item)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     }
init_param()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 
279 class CFSTRDB_Temperature : public CFSTRDataBlock {
280  public:
281   class CItem {
282    public:
283     char ngrp[hec_name_size];
284     int value;
CItem()285     CItem() : value(0) { ngrp[0] = 0; }
CItem(const CItem & item)286     CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
value(v)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 
294   CFSTRDB_Temperature();
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 
301 class CFSTRDB_Reftemp : public CFSTRDataBlock {
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 
318 class CFSTRDB_Eigen : public CFSTRDataBlock {
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 
356 class CFSTRDB_Fixtemp : public CFSTRDataBlock {
357  public:
358   class CItem {
359    public:
360     char ngrp[hec_name_size];
361     double value;
CItem()362     CItem() : value(0) { ngrp[0] = 0; }
CItem(const CItem & item)363     CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
CItem(const char * name,double v)364     CItem(const char* name, double v) : value(v) { strcpy(ngrp, name); }
365   };
366 
367   // header line --------------------
368 
369   char amp[hec_name_size];
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 
382 class CFSTRDB_CFlux : public CFSTRDataBlock {
383  public:
384   class CItem {
385    public:
386     char ngrp[hec_name_size];
387     double value;
CItem()388     CItem() : value(0) { ngrp[0] = 0; }
CItem(const CItem & item)389     CItem(const CItem& item) : value(item.value) { strcpy(ngrp, item.ngrp); }
CItem(const char * name,double v)390     CItem(const char* name, double v) : value(v) { strcpy(ngrp, name); }
391   };
392 
393   // header line --------------------
394 
395   char amp[hec_name_size];
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 
408 class CFSTRDB_DFlux : public CFSTRDataBlock {
409  public:
410   enum {
411     TYPE_S0,
412     TYPE_S1,
413     TYPE_S2,
414     TYPE_S3,
415     TYPE_S4,
416     TYPE_S5,
417     TYPE_S6,
418     TYPE_BF,
419     TYPE_UNKNOWN
420   };
421 
TypeNumber()422   static int TypeNumber() { return 8; }
423   static const char* LoadTypeName(int type);
424 
425   class CItem {
426    public:
427     char egrp[hec_name_size];
428     int type;
429     double value;
CItem()430     CItem() : type(TYPE_UNKNOWN), value(0) { egrp[0] = 0; }
CItem(const CItem & item)431     CItem(const CItem& item) : type(item.type), value(item.value) {
432       strcpy(egrp, item.egrp);
433     }
CItem(const char * name,int t,double v)434     CItem(const char* name, int t, double v) : type(t), value(v) {
435       strcpy(egrp, name);
436     }
437   };
438 
439   // header line --------------------
440 
441   char amp[hec_name_size];
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 
454 class CFSTRDB_SFlux : public CFSTRDataBlock {
455  public:
456   class CItem {
457    public:
458     char sgrp[hec_name_size];
459     double value;
CItem()460     CItem() : value(0) { sgrp[0] = 0; }
CItem(const CItem & item)461     CItem(const CItem& item) : value(item.value) { strcpy(sgrp, item.sgrp); }
CItem(const char * name,double v)462     CItem(const char* name, double v) : value(v) { strcpy(sgrp, name); }
463   };
464 
465   // header line --------------------
466 
467   char amp[hec_name_size];
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 {
483     TYPE_F0,
484     TYPE_F1,
485     TYPE_F2,
486     TYPE_F3,
487     TYPE_F4,
488     TYPE_F5,
489     TYPE_F6,
490     TYPE_UNKNOWN
491   };
492 
TypeNumber()493   static int TypeNumber() { return 7; }
494   static const char* LoadTypeName(int type);
495 
496   class CItem {
497    public:
498     char egrp[hec_name_size];
499     int type;
500     double value;
501     double sink;
CItem()502     CItem() : type(TYPE_UNKNOWN), value(0), sink(0) { egrp[0] = 0; }
CItem(const CItem & item)503     CItem(const CItem& item)
504         : type(item.type), value(item.value), sink(item.sink) {
505       strcpy(egrp, item.egrp);
506     }
CItem(const char * name,int t,double v,double s)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 
515   char amp1[hec_name_size];
516   char amp2[hec_name_size];
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 
529 class CFSTRDB_SFilm : public CFSTRDataBlock {
530  public:
531   class CItem {
532    public:
533     char sgrp[hec_name_size];
534     double value;
535     double sink;
CItem()536     CItem() : value(0), sink(0) { sgrp[0] = 0; }
CItem(const CItem & item)537     CItem(const CItem& item) : value(item.value), sink(item.sink) {
538       strcpy(sgrp, item.sgrp);
539     }
CItem(const char * name,double v,double s)540     CItem(const char* name, double v, double s) : value(v), sink(s) {
541       strcpy(sgrp, name);
542     }
543   };
544 
545   // header line --------------------
546 
547   char amp1[hec_name_size];
548   char amp2[hec_name_size];
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 
561 class CFSTRDB_Radiate : public CFSTRDataBlock {
562  public:
563   enum {
564     TYPE_R0,
565     TYPE_R1,
566     TYPE_R2,
567     TYPE_R3,
568     TYPE_R4,
569     TYPE_R5,
570     TYPE_R6,
571     TYPE_UNKNOWN
572   };
573 
TypeNumber()574   static int TypeNumber() { return 7; }
575   static const char* LoadTypeName(int type);
576 
577   class CItem {
578    public:
579     char egrp[hec_name_size];
580     int type;
581     double value;
582     double sink;
CItem()583     CItem() : type(TYPE_UNKNOWN), value(0), sink(0) { egrp[0] = 0; }
CItem(const CItem & item)584     CItem(const CItem& item)
585         : type(item.type), value(item.value), sink(item.sink) {
586       strcpy(egrp, item.egrp);
587     }
CItem(const char * name,int t,double v,double s)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 
596   char amp1[hec_name_size];
597   char amp2[hec_name_size];
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 
610 class CFSTRDB_SRadiate : public CFSTRDataBlock {
611  public:
612   class CItem {
613    public:
614     char sgrp[hec_name_size];
615     double value;
616     double sink;
CItem()617     CItem() : value(0), sink(0) { sgrp[0] = 0; }
CItem(const CItem & item)618     CItem(const CItem& item) : value(item.value), sink(item.sink) {
619       strcpy(sgrp, item.sgrp);
620     }
CItem(const char * name,double v,double s)621     CItem(const char* name, double v, double s) : value(v), sink(s) {
622       strcpy(sgrp, name);
623     }
624   };
625 
626   // header line --------------------
627 
628   char amp1[hec_name_size];
629   char amp2[hec_name_size];
630 
631   // data line ----------------------
632 
633   std::vector<CItem> ItemList;
634 
635   CFSTRDB_SRadiate();
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
643