Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import subprocess
import re
import os
import numpy as np
import matplotlib.pyplot as plt
import math
import fileinput
import time
import matplotlib.ticker as tickers
import matplotlib as mpl
from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
import codecs
import sys
import threading
# # Schreibe input datei für Parameter
# def SetParametersCellProblem(ParameterSet, ParsetFilePath, outputPath):
# print('----set Parameters -----')
# with open(ParsetFilePath, 'r') as file:
# filedata = file.read()
# filedata = re.sub('(?m)^materialFunction\s?=.*','materialFunction = '+str(ParameterSet.materialFunction),filedata)
# filedata = re.sub('(?m)^gamma\s?=.*','gamma='+str(ParameterSet.gamma),filedata)
# filedata = re.sub('(?m)^numLevels\s?=.*','numLevels='+str(ParameterSet.numLevels)+' '+str(ParameterSet.numLevels) ,filedata)
# filedata = re.sub('(?m)^outputPath\s?=\s?.*','outputPath='+str(outputPath),filedata)
# f = open(ParsetFilePath,'w')
# f.write(filedata)
# f.close()
# # Ändere Parameter der MaterialFunction
# def SetParameterMaterialFunction(materialFunction, parameterName, parameterValue):
# with open(Path+"/"+materialFunction+'.py', 'r') as file:
# filedata = file.read()
# filedata = re.sub('(?m)^'+str(parameterName)+'\s?=.*',str(parameterName)+' = '+str(parameterValue),filedata)
# f = open(Path+"/"+materialFunction+'.py','w')
# f.write(filedata)
# f.close()
def SetParameterMaterialFunction(inputFunction, parameterName, parameterValue):
with open(inputFunction+'.py', 'r') as file:
filedata = file.read()
filedata = re.sub('(?m)^'+str(parameterName)+'\s?=.*',str(parameterName)+' = '+str(parameterValue),filedata)
f = open(inputFunction+'.py','w')
f.write(filedata)
f.close()
# # Rufe Programm zum Lösen des Cell-Problems auf
# def run_CellProblem(executable, parset,write_LOG):
# print('----- RUN Cell-Problem ----')
# processList = []
# LOGFILE = "Cell-Problem_output.log"
# print('LOGFILE:',LOGFILE)
# print('executable:',executable)
# if write_LOG:
# p = subprocess.Popen(executable + parset
# + " | tee " + LOGFILE, shell=True)
# else:
# p = subprocess.Popen(executable + parset
# + " | tee " + LOGFILE, shell=True)
# p.wait() # wait
# processList.append(p)
# exit_codes = [p.wait() for p in processList]
# return
# Read effective quantites
def ReadEffectiveQuantities(QFilePath = os.path.dirname(os.getcwd()) + '/outputs/QMatrix.txt', BFilePath = os.path.dirname(os.getcwd())+ '/outputs/BMatrix.txt'):
# Read Output Matrices (effective quantities)
# From Cell-Problem output Files : ../outputs/Qmatrix.txt , ../outputs/Bmatrix.txt
# -- Read Matrix Qhom
X = []
# with codecs.open(path + '/outputs/QMatrix.txt', encoding='utf-8-sig') as f:
with codecs.open(QFilePath, encoding='utf-8-sig') as f:
for line in f:
s = line.split()
X.append([float(s[i]) for i in range(len(s))])
Q = np.array([[X[0][2], X[1][2], X[2][2]],
[X[3][2], X[4][2], X[5][2]],
[X[6][2], X[7][2], X[8][2]] ])
# -- Read Beff (as Vector)
X = []
# with codecs.open(path + '/outputs/BMatrix.txt', encoding='utf-8-sig') as f:
with codecs.open(BFilePath, encoding='utf-8-sig') as f:
for line in f:
s = line.split()
X.append([float(s[i]) for i in range(len(s))])
B = np.array([X[0][2], X[1][2], X[2][2]])
return Q, B
# Function for evaluating the energy in terms of kappa, alpha and Q, B
def eval_energy(kappa,alpha,Q,B) :
G=kappa*np.array([[np.cos(alpha)**2],[np.sin(alpha)**2],[np.sqrt(2)*np.cos(alpha)*np.sin(alpha)]])-B
return np.matmul(np.transpose(G),np.matmul(Q,G))[0,0]
#-------------------------------------------------------------------------------------------------------
########################
#### SET PARAMETERS ####
########################
# ----- Setup Paths -----
# write_LOG = True # writes Cell-Problem output-LOG in "Cell-Problem_output.log"
# path='/home/klaus/Desktop/Dune_release/dune-microstructure/experiment/wood-bilayer/results/'
# pythonPath = '/home/klaus/Desktop/Dune_release/dune-microstructure/experiment/wood-bilayer'
path = os.getcwd() + '/experiment/perforated-bilayer/results/'
pythonPath = os.getcwd() + '/experiment/perforated-bilayer'
pythonModule = "perforated_wood_upper"
# pythonModule = "perforated_wood_lower"
executable = os.getcwd() + '/build-cmake/src/Cell-Problem'
# ---------------------------------
# Setup Experiment
# ---------------------------------
gamma = 1.0
# ----- Define Parameters for Material Function --------------------
# [r, h, omega_flat, omega_target, theta, experimental_kappa]
# r = (thickness upper layer)/(thickness)
# h = thickness [meter]
# omega_flat = moisture content in the flat state before drying [%]
# omega_target = moisture content in the target state [%]
# theta = rotation angle (not implemented and used)
# beta = design parameter for perforation = ratio of Volume of (cylindrical) perforation to Volume of active/passive layer
#Experiment: Perforate "active" bilayer phase
materialFunctionParameter=[
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.0 ],
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.05 ],
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.1 ],
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.15 ],
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.2 ],
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.25 ],
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
[0.22, 0.0053, 17.17547062, 8.959564147, 0.0, 0.3 ]
]
# ------ Loops through Parameters for Material Function -----------
for i in range(0,np.shape(materialFunctionParameter)[0]):
print("------------------")
print("New Loop")
print("------------------")
# Check output directory
outputPath = path + str(i)
isExist = os.path.exists(outputPath)
if not isExist:
# Create a new directory because it does not exist
os.makedirs(outputPath)
print("The new directory " + outputPath + " is created!")
# thread = threading.Thread(target=run_CellProblem(executable, pythonModule, pythonPath, LOGFILE))
# thread.start()
#TODO: apperently its not possible to pass a variable via subprocess and "calculate" another input value inside the python file.
# Therefore we use this instead.
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_r",materialFunctionParameter[i][0])
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_h",materialFunctionParameter[i][1])
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_omega_flat",materialFunctionParameter[i][2])
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_omega_target",materialFunctionParameter[i][3])
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_theta",materialFunctionParameter[i][4])
SetParameterMaterialFunction(pythonPath + "/" + pythonModule, "param_beta",materialFunctionParameter[i][5])
LOGFILE = outputPath + "/" + pythonModule + "_output" + "_" + str(i) + ".log"
processList = []
p = subprocess.Popen(executable + " " + pythonPath + " " + pythonModule
+ " -outputPath " + outputPath
+ " -gamma " + str(gamma)
+ " | tee " + LOGFILE, shell=True)
# p = subprocess.Popen(executable + " " + pythonPath + " " + pythonModule
# + " -outputPath " + outputPath
# + " -gamma " + str(gamma)
# + " -param_r " + str(materialFunctionParameter[i][0])
# + " -param_h " + str(materialFunctionParameter[i][1])
# + " -param_omega_flat " + str(materialFunctionParameter[i][2])
# + " -param_omega_target " + str(materialFunctionParameter[i][3])
# + " -phase2_angle " + str(materialFunctionParameter[i][4])
# + " | tee " + LOGFILE, shell=True)
p.wait() # wait
processList.append(p)
exit_codes = [p.wait() for p in processList]
# ---------------------------------------------------
# wait here for the result to be available before continuing
# thread.join()
f = open(outputPath+"/parameter.txt", "w")
f.write("r = "+str(materialFunctionParameter[i][0])+"\n")
f.write("h = "+str(materialFunctionParameter[i][1])+"\n")
f.write("omega_flat = "+str(materialFunctionParameter[i][2])+"\n")
f.write("omega_target = "+str(materialFunctionParameter[i][3])+"\n")
f.write("param_beta = "+str(materialFunctionParameter[i][5])+"\n")
f.close()
#