FrontISTR  5.7.1
Large-scale structural analysis program with finit element method
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 
17 enum {
29 };
30 
32  public:
33  int ID;
34  checdb_id_class(int id = -1) : ID(id) {}
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:
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;
81  CElemItem(int type, int id = -1) : checdb_id_class(id), node(0), node_n(0) {
82  Init(type);
83  }
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  }
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 
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)
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 
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 
176  public:
177  // type
179 
180  int type;
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
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:
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:
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:
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 
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 
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 
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
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
@ 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
CHECDataBlock * CreateHECDataBlock(const char *header_name)
Definition: HECDB_util.cpp:16
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)
static const int * Connectivity(int face_id)
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
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