DAMASK_EICMD/lib/damask/test/test.py

161 lines
5.4 KiB
Python

#!/usr/bin/env python
# $Id$
import os, sys
import subprocess,shutil
import damask
class Test():
'''
General class for testing.
Is sub-classed by the individual tests.
'''
#define those according to your test
modelname=None
jobname=None
test_dir=None
spectral_options=None
compile=False = None
post_txt = None
tol = 0.0
has_variants=False # False ==> A single test case is run
#has_variants=True # True ==> Need to define the test_variants generator
def test_variants(self):
'''
If has_subtests == True this method defines the generator for test variants
This generator must be defined in each test,
depending on what to change: orientations, parameters,....
Below is an EXAMPLE.
'''
#maybe get rid of has_variants through testing for None return value...
yield(None)
def test_variants_example(self):
subtest_orientations=[[0.0,90.0,0.0],[0.0,0.0,90.0]]
for i,o in enumerate(subtest_orientations):
from damask_tools import MATERIAL_CONFIG
mat=MATERIAL_CONFIG()
mat.read('material.config_base')
mat.add_texture(label='Grain001',
type ='(gauss)',
eulers = o)
mat.write(overwrite=True)
print(mat.data['texture']['Grain001'])
testlabel='orientation_%03i'%i
yield(testlabel)
def run_test(self):
res=[]
if self.has_variants:
for t in self.test_variants():
print '###############################################'
print '###############################################'
print(t)
print '###############################################'
val=self.run_single_test(t)
res.append(val==True)
else:
val=self.run_single_test()
res.append(val==True)
if all(res) is True:
return True
print(res)
return False
def run_single_test(self,variant):
self.clean_current_results()
if self.calc_current_results(variant) is False:
return False
print('simulation finished')
self.postprocess()
if self.compare_to_reference() is False:
print '++++++++ Test not OK +++++++++'
return False
print 'Test OK'
return True
def clean_current_results(self):
os.chdir(self.test_dir)
try:
shutil.rmtree('current_results')
except:
print('Could not delete current_results')
os.mkdir('current_results')
def calc_current_results(self):
'''
Should be defined in the individual tests
'''
pass
def calc_marc(self,compile=None):
'''
Calculates current results for MSC.Marc
'''
if compile is None: compile=self.compile
self.copy_from_ref_list()
self.copy_files_from_reference_results()
os.chdir('./current_results')
m = damask.solver.Marc()
m.submit_job(compile=compile, compiled_dir='../../../code/')
print('simulation submitted')
self.exit_number = m.exit_number_from_outFile(outFile=self.modelname+'_'+self.jobname+'.out')
if not self.exit_number==3004:
print('Job did not exit with No. 3004')
return False
return True
def calc_spectral(self, compile=None):
pass
def copy_from_ref_list(self):
self.copy_from_ref=[self.modelname+'_'+self.jobname+'.dat',
self.modelname+'.mfd', # for dev
'material.config',
]
def copy_files_from_reference_results(self):
for file in self.copy_from_ref:
shutil.copy2('./reference_results/%s'%file,'./current_results/%s'%file)
# Note: possibly symlinking? No, because copy is OS independent.
def read_val_from_file(self,fname=None):
file = open(fname,'r')
headerlength = int(file.readline().split()[0]) + 1
file.close
import numpy as N
val = N.loadtxt(fname,skiprows=headerlength)
return val
def compare_to_reference(self):
import string, numpy as N
print 'comparing results against reference_results...'
os.chdir(os.path.join(self.test_dir,'current_results'))
cur=self.read_val_from_file(fname='postProc/'+self.post_txt)
ref=self.read_val_from_file(fname='../reference_results/postProc/'+self.post_txt)
err=abs((ref/cur)-1.) # relative tolerance
#err=abs(ref-cur) # absolute tolerance
print 'tol', self.tol
print 'max error', N.max(err)
if N.max(err)>self.tol:
return False
return True
def postprocess(self):
print 'postprocessing results ...'
os.chdir(self.test_dir)
file=open('./postprocessing.cmd','r')
postproc=file.readlines()
file.close()
os.chdir(os.path.join(self.test_dir,'current_results'))
for cmd in postproc: # PHILIP: suggestion to just execute the script "postprocessing" directly within a shell, i.e. os.system('../postprocessing')
print(cmd)
os.system(cmd) # PHILIP: reason is that for loops and the like get broken with line by line execution from here...