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 
17 enum {
18   HECDB_HEADER = 1,
19   HECDB_NODE,
20   HECDB_ELEMENT,
21   HECDB_MATERIAL,
22   HECDB_SECTION,
23   HECDB_NGROUP,
24   HECDB_EGROUP,
25   HECDB_SGROUP,
26   HECDB_AMPLITUDE,
27   HECDB_ZERO,
28   HECDB_VISUAL
29 };
30 
31 class checdb_id_class {
32  public:
33   int ID;
ID(id)34   checdb_id_class(int id = -1) : ID(id) {}
~checdb_id_class()35   virtual ~checdb_id_class() {}
36 };
37 
38 inline bool operator==(const checdb_id_class& a, const checdb_id_class& b) {
39   return a.ID == b.ID;
40 }
41 inline bool operator<(const checdb_id_class& a, const checdb_id_class& b) {
42   return a.ID < b.ID;
43 }
44 inline bool operator>(const checdb_id_class& a, const checdb_id_class& b) {
45   return a.ID > b.ID;
46 }
47 
48 CHECDataBlock* CreateHECDataBlock(const char* header_name);
49 bool IsHECDataBlockName(const char* name);
50 
51 class CHECDB_Header : public CHECDataBlock {
52  public:
53   char title[hec_str_size];
54 
55   CHECDB_Header();
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 
62 class CHECDB_Element : public CHECDataBlock {
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;
CElemItem()80     CElemItem() : checdb_id_class(), node(0), node_n(0) {}
checdb_id_class(id)81     CElemItem(int type, int id = -1) : checdb_id_class(id), node(0), node_n(0) {
82       Init(type);
83     }
CElemItem(const CElemItem & e)84     CElemItem(const CElemItem& e) : checdb_id_class(e.ID), node(0), node_n(0) {
85       InitNode(e.node_n);
86       for (int i = 0; i < node_n; i++) node[i] = e.node[i];
87     }
~CElemItem()88     virtual ~CElemItem() { delete[] node; }
Init(int type)89     void Init(int type) { InitNode(NodeNumber(type)); }
InitNode(int n)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 
98   CHECDB_Element();
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 
ElemNumber()104   int ElemNumber() { return ElemList.size(); }
105   CElemItem* GetElem(int id);
106 };
107 
108 class CHECDB_Node : public CHECDataBlock {
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)
checdb_id_class(id)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 
NodeNumber()125   int NodeNumber() { return NodeList.size(); }
126   CNodeItem* GetNode(int id);
127 };
128 
129 class CHECDB_Material : public CHECDataBlock {
130  public:
131   char name[hec_name_size];
132 
133   class CItem {
134    public:
135     int ID;
CItem()136     CItem() : ID(-1) {}
137     class CItemRec {
138      public:
139       bool last_is_temp;
140       std::vector<double> params;
CItemRec()141       CItemRec() : last_is_temp(false), params() {}
142     };
143     std::vector<CItemRec> RecList;
RecNumber()144     int RecNumber() { return RecList.size(); }
SubItemNumber()145     int SubItemNumber() {
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     }
LastIsTemp()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     }
Clear()162     void Clear() { RecList.clear(); }
163     void Write(class CHECData* hecd);
164     bool Read(class CHECData* hecd);
165   };
166   std::vector<CItem> ItemList;
167 
168   CHECDB_Material();
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 
175 class CHECDB_Section : public CHECDataBlock {
176  public:
177   // type
178   enum { TYPE_UNKNOWN = 0, TYPE_SOLID, TYPE_SHELL, TYPE_BEAM, TYPE_INTERFACE };
179 
180   int type;
181   char egrp[hec_name_size];
182   char material[hec_name_size];
183   int n_comp;
184   int secopt;
185 
186   // type == TYPE_SOLID, TYPE_SHELL or TYPE_INTERFACE
187   double thickness;
188 
189   // type == TYPE_SHELL
190   int integpoints;
191 
192   // type == TYPE_INTERFACE
193   double gapcon;
194   double gaprad1;
195   double gaprad2;
196 
197   CHECDB_Section();
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 
204 class CHECDB_NGroup : public CHECDataBlock {
205  public:
206   char name[hec_name_size];
207   std::set<int> NodeList;
208 
209   CHECDB_NGroup();
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 
216 class CHECDB_EGroup : public CHECDataBlock {
217  public:
218   char name[hec_name_size];
219   std::set<int> ElemList;
220 
221   CHECDB_EGroup();
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 
228 class CHECDB_SGroup : public CHECDataBlock {
229  public:
230   char name[hec_name_size];
231 
232   class CItem {
233    public:
234     int elem, surf;
elem(eid)235     CItem(int eid = -1, int sid = 0) : elem(eid), surf(sid) {}
236   };
237   std::vector<CItem> ItemList;
238 
239   CHECDB_SGroup();
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 
246 class CHECDB_Amplitude : public CHECDataBlock {
247  public:
248   char name[hec_name_size];
249   char definition[hec_name_size];
250   char time[hec_name_size];
251   char value[hec_name_size];
252 
253   class CItem {
254    public:
255     double val, t;
val(v)256     CItem(double v = 0, double T = 0) : val(v), t(T) {}
257   };
258   std::vector<CItem> ItemList;
259 
260   CHECDB_Amplitude();
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 
267 class CHECDB_Zero : public CHECDataBlock {
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
279