FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
CHECDB.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 CHECDB Ver. 3.6
7*/
8
9#ifndef CHECDBH
10#define CHECDBH
11
12#include <set>
13#include <vector>
14#include "CHECDataBlock.h"
15#include "CHECDB_Visual.h"
16
17enum {
29};
30
32 public:
33 int ID;
34 checdb_id_class(int id = -1) : ID(id) {}
35 virtual ~checdb_id_class() {}
36};
37
38inline bool operator==(const checdb_id_class& a, const checdb_id_class& b) {
39 return a.ID == b.ID;
40}
41inline bool operator<(const checdb_id_class& a, const checdb_id_class& b) {
42 return a.ID < b.ID;
43}
44inline bool operator>(const checdb_id_class& a, const checdb_id_class& b) {
45 return a.ID > b.ID;
46}
47
48CHECDataBlock* CreateHECDataBlock(const char* header_name);
49bool IsHECDataBlockName(const char* name);
50
52 public:
54
56 virtual ~CHECDB_Header();
57 virtual void Clear();
58 virtual void Write(class CHECData* hecd);
59 virtual bool Read(class CHECData* hecd, char* header_line);
60};
61
63 public:
64 static int NodeNumber(int type);
65 static int FaceNumber(int type);
66 static int DOFNumber(int type);
67 static const int* Connectivity(int face_id);
68 static bool CheckType(int type);
69
70 public:
71 int type;
72 // for generate SECTION
73 int sec_id;
74 int option;
75
76 class CElemItem : public checdb_id_class {
77 public:
78 int* node;
79 int node_n;
81 CElemItem(int type, int id = -1) : checdb_id_class(id), node(0), node_n(0) {
82 Init(type);
83 }
86 for (int i = 0; i < node_n; i++) node[i] = e.node[i];
87 }
88 virtual ~CElemItem() { delete[] node; }
89 void Init(int type) { InitNode(NodeNumber(type)); }
90 void InitNode(int n) {
91 delete[] node;
92 node_n = n;
93 node = new int[node_n];
94 }
95 };
96 std::set<CElemItem> ElemList;
97
99 virtual ~CHECDB_Element();
100 virtual void Clear();
101 virtual void Write(class CHECData* hecd);
102 virtual bool Read(class CHECData* hecd, char* header_line);
103
104 int ElemNumber() { return ElemList.size(); }
105 CElemItem* GetElem(int id);
106};
107
109 public:
110 class CNodeItem : public checdb_id_class {
111 public:
112 // int ID;
113 double x, y, z;
114 CNodeItem(int id = -1, double X = 0, double Y = 0, double Z = 0)
115 : checdb_id_class(id), x(X), y(Y), z(Z) {}
116 };
117 std::set<CNodeItem> NodeList;
118
119 CHECDB_Node();
120 virtual ~CHECDB_Node();
121 virtual void Clear();
122 virtual void Write(class CHECData* hecd);
123 virtual bool Read(class CHECData* hecd, char* header_line);
124
125 int NodeNumber() { return NodeList.size(); }
126 CNodeItem* GetNode(int id);
127};
128
130 public:
132
133 class CItem {
134 public:
135 int ID;
136 CItem() : ID(-1) {}
137 class CItemRec {
138 public:
140 std::vector<double> params;
141 CItemRec() : last_is_temp(false), params() {}
142 };
143 std::vector<CItemRec> RecList;
144 int RecNumber() { return RecList.size(); }
146 if (RecNumber() > 0) {
147 std::vector<CItemRec>::iterator i = RecList.begin();
148 if (i->last_is_temp)
149 return i->params.size() - 1;
150 else
151 return i->params.size();
152 } else
153 return 0;
154 }
155 bool LastIsTemp() {
156 if (RecNumber() > 0) {
157 std::vector<CItemRec>::iterator i = RecList.begin();
158 return i->last_is_temp;
159 } else
160 return false;
161 }
162 void Clear() { RecList.clear(); }
163 void Write(class CHECData* hecd);
164 bool Read(class CHECData* hecd);
165 };
166 std::vector<CItem> ItemList;
167
169 virtual ~CHECDB_Material();
170 virtual void Clear();
171 virtual void Write(class CHECData* hecd);
172 virtual bool Read(class CHECData* hecd, char* header_line);
173};
174
176 public:
177 // type
179
180 int type;
185
186 // type == TYPE_SOLID, TYPE_SHELL or TYPE_INTERFACE
187 double thickness;
188
189 // type == TYPE_SHELL
191
192 // type == TYPE_INTERFACE
193 double gapcon;
194 double gaprad1;
195 double gaprad2;
196
198 virtual ~CHECDB_Section();
199 virtual void Clear();
200 virtual void Write(class CHECData* hecd);
201 virtual bool Read(class CHECData* hecd, char* header_line);
202};
203
205 public:
207 std::set<int> NodeList;
208
210 virtual ~CHECDB_NGroup();
211 virtual void Clear();
212 virtual void Write(class CHECData* hecd);
213 virtual bool Read(class CHECData* hecd, char* header_line);
214};
215
217 public:
219 std::set<int> ElemList;
220
222 virtual ~CHECDB_EGroup();
223 virtual void Clear();
224 virtual void Write(class CHECData* hecd);
225 virtual bool Read(class CHECData* hecd, char* header_line);
226};
227
229 public:
231
232 class CItem {
233 public:
234 int elem, surf;
235 CItem(int eid = -1, int sid = 0) : elem(eid), surf(sid) {}
236 };
237 std::vector<CItem> ItemList;
238
240 virtual ~CHECDB_SGroup();
241 virtual void Clear();
242 virtual void Write(class CHECData* hecd);
243 virtual bool Read(class CHECData* hecd, char* header_line);
244};
245
247 public:
252
253 class CItem {
254 public:
255 double val, t;
256 CItem(double v = 0, double T = 0) : val(v), t(T) {}
257 };
258 std::vector<CItem> ItemList;
259
261 virtual ~CHECDB_Amplitude();
262 virtual void Clear();
263 virtual void Write(class CHECData* hecd);
264 virtual bool Read(class CHECData* hecd, char* header_line);
265};
266
268 public:
269 double zero;
270
271 CHECDB_Zero();
272 virtual ~CHECDB_Zero();
273 virtual void Clear();
274 virtual void Write(class CHECData* hecd);
275 virtual bool Read(class CHECData* hecd, char* header_line);
276};
277
278#endif
bool operator<(const checdb_id_class &a, const checdb_id_class &b)
Definition: CHECDB.h:41
bool operator==(const checdb_id_class &a, const checdb_id_class &b)
Definition: CHECDB.h:38
bool IsHECDataBlockName(const char *name)
Definition: HECDB_util.cpp:57
bool operator>(const checdb_id_class &a, const checdb_id_class &b)
Definition: CHECDB.h:44
CHECDataBlock * CreateHECDataBlock(const char *header_name)
Definition: HECDB_util.cpp:16
@ HECDB_SECTION
Definition: CHECDB.h:22
@ HECDB_EGROUP
Definition: CHECDB.h:24
@ HECDB_VISUAL
Definition: CHECDB.h:28
@ HECDB_MATERIAL
Definition: CHECDB.h:21
@ HECDB_NODE
Definition: CHECDB.h:19
@ HECDB_ZERO
Definition: CHECDB.h:27
@ HECDB_AMPLITUDE
Definition: CHECDB.h:26
@ HECDB_SGROUP
Definition: CHECDB.h:25
@ HECDB_ELEMENT
Definition: CHECDB.h:20
@ HECDB_HEADER
Definition: CHECDB.h:18
@ HECDB_NGROUP
Definition: CHECDB.h:23
const int hec_name_size
Definition: CHECDataBlock.h:14
const int hec_str_size
Definition: CHECDataBlock.h:15
CItem(double v=0, double T=0)
Definition: CHECDB.h:256
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CHECDB_Amplitude()
char name[hec_name_size]
Definition: CHECDB.h:248
virtual void Write(class CHECData *hecd)
char definition[hec_name_size]
Definition: CHECDB.h:249
char value[hec_name_size]
Definition: CHECDB.h:251
std::vector< CItem > ItemList
Definition: CHECDB.h:258
char time[hec_name_size]
Definition: CHECDB.h:250
char name[hec_name_size]
Definition: CHECDB.h:218
virtual void Clear()
virtual bool Read(class CHECData *hecd, char *header_line)
std::set< int > ElemList
Definition: CHECDB.h:219
virtual void Write(class CHECData *hecd)
virtual ~CHECDB_EGroup()
void InitNode(int n)
Definition: CHECDB.h:90
virtual ~CElemItem()
Definition: CHECDB.h:88
void Init(int type)
Definition: CHECDB.h:89
CElemItem(const CElemItem &e)
Definition: CHECDB.h:84
CElemItem(int type, int id=-1)
Definition: CHECDB.h:81
virtual bool Read(class CHECData *hecd, char *header_line)
CElemItem * GetElem(int id)
int ElemNumber()
Definition: CHECDB.h:104
static int DOFNumber(int type)
static int NodeNumber(int type)
virtual ~CHECDB_Element()
static int FaceNumber(int type)
static bool CheckType(int type)
int sec_id
Definition: CHECDB.h:73
std::set< CElemItem > ElemList
Definition: CHECDB.h:96
static const int * Connectivity(int face_id)
virtual void Clear()
virtual void Write(class CHECData *hecd)
int option
Definition: CHECDB.h:74
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CHECDB_Header()
virtual void Clear()
char title[hec_str_size]
Definition: CHECDB.h:53
virtual void Write(class CHECData *hecd)
std::vector< double > params
Definition: CHECDB.h:140
bool Read(class CHECData *hecd)
std::vector< CItemRec > RecList
Definition: CHECDB.h:143
void Write(class CHECData *hecd)
virtual void Write(class CHECData *hecd)
virtual void Clear()
virtual ~CHECDB_Material()
std::vector< CItem > ItemList
Definition: CHECDB.h:166
virtual bool Read(class CHECData *hecd, char *header_line)
char name[hec_name_size]
Definition: CHECDB.h:131
virtual void Clear()
std::set< int > NodeList
Definition: CHECDB.h:207
char name[hec_name_size]
Definition: CHECDB.h:206
virtual bool Read(class CHECData *hecd, char *header_line)
virtual ~CHECDB_NGroup()
virtual void Write(class CHECData *hecd)
CNodeItem(int id=-1, double X=0, double Y=0, double Z=0)
Definition: CHECDB.h:114
CNodeItem * GetNode(int id)
Definition: CHECDB_Node.cpp:31
int NodeNumber()
Definition: CHECDB.h:125
virtual void Clear()
Definition: CHECDB_Node.cpp:18
virtual bool Read(class CHECData *hecd, char *header_line)
Definition: CHECDB_Node.cpp:48
virtual ~CHECDB_Node()
Definition: CHECDB_Node.cpp:16
virtual void Write(class CHECData *hecd)
Definition: CHECDB_Node.cpp:20
std::set< CNodeItem > NodeList
Definition: CHECDB.h:117
CItem(int eid=-1, int sid=0)
Definition: CHECDB.h:235
virtual void Write(class CHECData *hecd)
virtual bool Read(class CHECData *hecd, char *header_line)
char name[hec_name_size]
Definition: CHECDB.h:230
std::vector< CItem > ItemList
Definition: CHECDB.h:237
virtual void Clear()
virtual ~CHECDB_SGroup()
virtual bool Read(class CHECData *hecd, char *header_line)
char egrp[hec_name_size]
Definition: CHECDB.h:181
char material[hec_name_size]
Definition: CHECDB.h:182
@ TYPE_INTERFACE
Definition: CHECDB.h:178
double gapcon
Definition: CHECDB.h:193
virtual void Clear()
double thickness
Definition: CHECDB.h:187
virtual void Write(class CHECData *hecd)
int integpoints
Definition: CHECDB.h:190
virtual ~CHECDB_Section()
double gaprad1
Definition: CHECDB.h:194
double gaprad2
Definition: CHECDB.h:195
virtual bool Read(class CHECData *hecd, char *header_line)
Definition: CHECDB_Zero.cpp:23
virtual ~CHECDB_Zero()
Definition: CHECDB_Zero.cpp:14
virtual void Write(class CHECData *hecd)
Definition: CHECDB_Zero.cpp:18
virtual void Clear()
Definition: CHECDB_Zero.cpp:16
double zero
Definition: CHECDB.h:269
virtual ~checdb_id_class()
Definition: CHECDB.h:35
checdb_id_class(int id=-1)
Definition: CHECDB.h:34