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