Coverage for teaser/logic/buildingobjects/buildingphysics/material.py: 67%

1# created June 2015 

2# by TEASER4 Development Team 

3 

4 

5import re 

6import uuid 

7import teaser.data.input.material_input_json as material_input 

8import teaser.data.output.material_output as material_output 

9 

10 

11class Material(object): 

12 """Material class 

13 

14 This class holds information of Material used for building element layer. 

15 

16 

17 Parameters 

18 ---------- 

19 parent : Layer 

20 The parent class of this object, the layer the material 

21 belongs to. Allows for better control of hierarchical structures. If 

22 not None this adds this Material to Layer.material. 

23 Default is None 

24 

25 Attributes 

26 ---------- 

27 name : str 

28 Name of material 

29 density : float [kg/m3] 

30 Density of material 

31 thermal_conduc : float [W/(m*K)] 

32 Thermal conductivity of material 

33 heat_capac : float [kJ/(kg*K)] 

34 Specific heat capacity of material 

35 solar_absorp : float [-] 

36 Coefficient of absorption of solar short wave 

37 ir_emissivity : float [-] 

38 Coefficient of longwave emissivity of material 

39 transmittance : float [-] 

40 Coefficient of transmittance of material 

41 thickness_default : float [m] 

42 Default value for material thickness 

43 thickness_list : list 

44 List of usual values for material thickness, float [m] 

45 material_id : str(uuid) 

46 UUID of material, this is used to have similar behaviour like foreign 

47 key in SQL data bases for use in TypeBuildingElements and Material json 

48 

49 """ 

50 

51 def __init__(self, parent=None): 

52 """Constructor of Material. 

53 """ 

54 

55 self.parent = parent 

56 self._name = "" 

57 self._density = 0.0 

58 self._thermal_conduc = 0.0 

59 self._heat_capac = 0.0 

60 self._solar_absorp = 0.0 

61 if parent is not None: 

62 if type(self.parent.parent).__name__ != "Window": 

63 self._solar_absorp = 0.7 

64 self._ir_emissivity = 0.9 

65 self._transmittance = 0.0 

66 self._thickness_default = 0.0 

67 self._thickness_list = [] 

68 

69 self.material_id = str(uuid.uuid1()) 

70 

71 def load_material_template(self, mat_name, data_class=None): 

72 """Material loader. 

73 

74 Loads Material specified in the json. 

75 

76 Parameters 

77 ---------- 

78 

79 mat_name : str 

80 Code list for Material 

81 

82 data_class : DataClass() 

83 DataClass containing the bindings for TypeBuildingElement and 

84 Material (typically this is the data class stored in prj.data, 

85 but the user can individually change that. Default is 

86 self.parent.parent.parent.parent.data which is data in project 

87 

88 """ 

89 

90 if data_class is None: 

91 data_class = self.parent.parent.parent.parent.data 

92 else: 

93 data_class = data_class 

94 

95 material_input.load_material(material=self, 

96 mat_name=mat_name, 

97 data_class=data_class) 

98 

99 def save_material_template(self, data_class): 

100 """Material saver. 

101 

102 Saves Material specified in the json. 

103 

104 Parameters 

105 ---------- 

106 

107 data_class : DataClass() 

108 DataClass containing the bindings for TypeBuildingElement and 

109 Material (typically this is the data class stored in prj.data, 

110 but the user can individually change that. Default is 

111 self.parent.parent.parent.parent.data which is data in project 

112 

113 """ 

114 

115 if data_class is None: 

116 data_class = self.parent.parent.parent.parent.data 

117 else: 

118 data_class = data_class 

119 

120 material_output.save_material( 

121 material=self, data_class=data_class) 

122 

123 def modify_material_template(self, data_class): 

124 """Material modifier. 

125 

126 Modify Material specified in the json. 

127 

128 Parameters 

129 ---------- 

130 

131 data_class : DataClass() 

132 DataClass containing the bindings for TypeBuildingElement and 

133 Material (typically this is the data class stored in prj.data, 

134 but the user can individually change that. Default is 

135 self.parent.parent.parent.parent.data which is data in project 

136 

137 """ 

138 

139 if data_class is None: 

140 data_class = self.parent.parent.parent.parent.data 

141 else: 

142 data_class = data_class 

143 

144 material_output.modify_material(material=self, data_class=data_class) 

145 

146 @property 

147 def material_id(self): 

148 return self.__material_id 

149 

150 @material_id.setter 

151 def material_id(self, value): 

152 self.__material_id = value 

153 

154 @property 

155 def parent(self): 

156 return self.__parent 

157 

158 @parent.setter 

159 def parent(self, value): 

160 

161 if value is not None: 

162 

163 ass_error_1 = "Parent has to be an instance of a layer" 

164 

165 assert type(value).__name__ == "Layer", ass_error_1 

166 

167 self.__parent = value 

168 self.__parent.material = self 

169 

170 else: 

171 self.__parent = None 

172 

173 @property 

174 def name(self): 

175 return self._name 

176 

177 @name.setter 

178 def name(self, value): 

179 if isinstance(value, str): 

180 regex = re.compile('[^a-zA-z0-9]') 

181 self._name = regex.sub('', value) 

182 else: 

183 try: 

184 value = str(value) 

185 regex = re.compile('[^a-zA-z0-9]') 

186 self._name = regex.sub('', value) 

187 except ValueError: 

188 print("Can't convert name to string") 

189 

190 @property 

191 def thermal_conduc(self): 

192 return self._thermal_conduc 

193 

194 @thermal_conduc.setter 

195 def thermal_conduc(self, value): 

196 

197 if isinstance(value, float): 

198 pass 

199 elif value is None: 

200 pass 

201 else: 

202 try: 

203 value = float(value) 

204 except: 

205 raise ValueError("Can't convert thermal conduction to float") 

206 

207 if value is not None: 

208 self._thermal_conduc = float(value) 

209 if self.parent is not None: 

210 if self.parent.parent is not None: 

211 if self.parent.thickness is not None and \ 

212 self.parent.parent.inner_convection is \ 

213 not None and \ 

214 self.parent.parent.inner_radiation is \ 

215 not None and \ 

216 self.parent.parent.area is not None: 

217 self.parent.parent.calc_ua_value() 

218 

219 @property 

220 def density(self): 

221 return self._density 

222 

223 @density.setter 

224 def density(self, value): 

225 

226 if isinstance(value, float): 

227 self._density = value 

228 elif value is None: 

229 self._density = value 

230 else: 

231 try: 

232 value = float(value) 

233 self._density = value 

234 except: 

235 raise ValueError("Can't convert density to float") 

236 

237 @property 

238 def heat_capac(self): 

239 return self._heat_capac 

240 

241 @heat_capac.setter 

242 def heat_capac(self, value): 

243 

244 if isinstance(value, float): 

245 self._heat_capac = value 

246 elif value is None: 

247 self._heat_capac = value 

248 else: 

249 try: 

250 value = float(value) 

251 self._heat_capac = value 

252 except: 

253 raise ValueError("Can't convert heat capacity to float") 

254 

255 @property 

256 def solar_absorp(self): 

257 return self._solar_absorp 

258 

259 @solar_absorp.setter 

260 def solar_absorp(self, value): 

261 

262 if isinstance(value, float): 

263 self._solar_absorp = value 

264 elif value is None: 

265 self._solar_absorp = 0.7 

266 else: 

267 try: 

268 value = float(value) 

269 self._solar_absorp = value 

270 except: 

271 raise ValueError("Can't convert solar absorption to float") 

272 

273 @property 

274 def ir_emissivity(self): 

275 return self._ir_emissivity 

276 

277 @ir_emissivity.setter 

278 def ir_emissivity(self, value): 

279 

280 if isinstance(value, float): 

281 self._ir_emissivity = value 

282 elif value is None: 

283 self._ir_emissivity = 0.9 

284 else: 

285 try: 

286 value = float(value) 

287 self._ir_emissivity = value 

288 except: 

289 raise ValueError("Can't convert emissivity to float") 

290 

291 @property 

292 def transmittance(self): 

293 return self._transmittance 

294 

295 @transmittance.setter 

296 def transmittance(self, value): 

297 

298 if isinstance(value, float): 

299 self._transmittance = value 

300 elif value is None: 

301 self._transmittance = value 

302 else: 

303 try: 

304 value = float(value) 

305 self._transmittance = value 

306 except: 

307 raise ValueError("Can't convert transmittance to float") 

308 

309 @property 

310 def thickness_default(self): 

311 return self._thickness_default 

312 

313 @thickness_default.setter 

314 def thickness_default(self, value): 

315 

316 if isinstance(value, float): 

317 self._thickness_default = value 

318 elif value is None: 

319 pass 

320 else: 

321 try: 

322 value = float(value) 

323 except: 

324 raise ValueError("Can't convert thickness to float") 

325 

326 @property 

327 def thickness_list(self): 

328 return self._thickness_list 

329 

330 @thickness_list.setter 

331 def thickness_list(self, value): 

332 

333 if value is None: 

334 self._thickness_list = [] 

335 

336 # elif type(value) != list: 

337 # raise TypeError("must be list, not ", type(value)) 

338 

339 else: 

340 for i in value: 

341 if isinstance(i, float): 

342 pass 

343 else: 

344 try: 

345 value = float(value) 

346 except: 

347 raise ValueError( 

348 "Can't convert entry of thickness_list to float") 

349 

350 self._thickness_list = value