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