def writeSelectedVars(data, filename):
outf = open(filename, 'w')
outf.write('PSUADE\n')
#Write inputs
outf.write('INPUT\n')
outf.write(' dimension = %d\n' % data.getNumInputs())
names = data.getInputNames()
mins = data.getInputMins()
maxs = data.getInputMaxs()
indices = range(data.getNumInputs())
for i, name, minimum, maximum in zip(indices, names, mins, maxs):
outf.write(' variable %d %s = %e %e\n' %
(i + 1, name, minimum, maximum))
distributions = data.getInputDistributions()
for i, dist in zip(indices, distributions):
distType = dist.getDistributionType()
distParams = dist.getParameterValues()
if distType != Distribution.UNIFORM:
outf.write(' PDF %d %c %e' %
(i + 1, Distribution.getPsuadeName(distType),
distParams[0]))
if distParams[1] is not None:
outf.write(' %e' % distParams[1])
outf.write('\n')
outf.write('END\n')
#Write outputs
outf.write('OUTPUT\n')
outf.write(' dimension = %d\n' % data.getNumOutputs())
names = data.getOutputNames()
indices = range(data.getNumOutputs())
for i, name in zip(indices, names):
outf.write(' variable %d %s\n' % (i + 1, name))
outf.write('END\n')
outf.write('END\n')
def readSampleFromPsuadeFile(fileName, returnModelOnly = False):
f = open(fileName, 'r')
lines = f.readlines()
f.close()
model = Model()
path, fname = os.path.split(fileName) # exclude path from file name
model.setName(fname)
namesIncludeNodes = False
hasSampleData = False
readData = False
readInputs = False
readOutputs = False
numInputs = None
driverName = None
optDriverName = None
auxDriverName = None
sampleType = None
legendreOrder = None
sampleMethod = None
inputData = None
outputData = None
runState = None
inputNames = []
outputNames = []
inputTypes = []
inputMins = []
inputMaxs = []
inputDefaults = []
inputDists = []
inputDistParam1s = []
inputDistParam2s = []
for line in lines:
if line[0] == '#' and 'NAMESHAVENODES' in line:
namesIncludeNodes = True
if len(line) > 0 and line[0] != '#': #Not comment
if line.startswith('PSUADE_IO'):
readData = not readData
hasSampleData = True
elif line.startswith('INPUT'):
readInputs = True
elif line.startswith('OUTPUT'):
readOutputs = True
elif line.startswith('END'):
if readInputs:
readInputs = False
elif readOutputs:
readOutputs = False
elif readData: # Read samples
if numInputs is None: #Have not read number of inputs
nums = line.split()
numInputs = int(nums[0])
numOutputs = int(nums[1])
numSamples = int(nums[2])
runState = [False]*numSamples
inputData = [0]*numSamples
outputData = [0]*numSamples
readSampleData = False
elif not readSampleData: # Sample number and run state
nums = line.split()
sampleNum = int(nums[0]) - 1
runState[sampleNum] = bool(int(nums[1]))
readSampleData = True
numValuesRead = 0
sampleInputs = [0] * numInputs
sampleOutputs = [0] * numOutputs
else:
if numValuesRead < numInputs: #Input value
if line.strip() in ['9.9999999999999997e+34', '9.9999999999999997e+034']:
line = 'nan'
sampleInputs[numValuesRead] = float(line)
numValuesRead = numValuesRead + 1
else: #Output value
if line.strip() in ['9.9999999999999997e+34', '9.9999999999999997e+034']:
line = 'nan'
sampleOutputs[numValuesRead - numInputs] = float(line)
numValuesRead = numValuesRead + 1
if numValuesRead - numInputs == numOutputs:
inputData[sampleNum] = sampleInputs
outputData[sampleNum] = sampleOutputs
readSampleData = False
elif readInputs: # Read inputs
stripped = line.strip()
values = stripped.split()
if values[0] == 'variable': # Variable name min max
inputNames = inputNames + [values[2]]
inputTypes = inputTypes + [Model.VARIABLE]
inputMins = inputMins + [float(values[4])]
inputMaxs = inputMaxs + [float(values[5])]
inputDefaults = inputDefaults + [(float(values[4]) + float(values[5])) / 2]
inputDists = inputDists + ['U']
inputDistParam1s = inputDistParam1s + [None]
inputDistParam2s = inputDistParam2s + [None]
elif values[0] == 'fixed': # Fixed variable
inputNames = inputNames + [values[2]]
inputTypes = inputTypes + [Model.FIXED]
fixedVal = float(values[4])
inputMins = inputMins + [fixedVal]
inputMaxs = inputMaxs + [fixedVal]
inputDefaults = inputDefaults + [fixedVal]
inputDists = inputDists + ['U']
inputDistParam1s = inputDistParam1s + [None]
inputDistParam2s = inputDistParam2s + [None]
# Insert input values
if hasSampleData:
for i in xrange(len(inputData)):
inputRow = inputData[i]
inputRow.insert(len(inputNames) - 1, fixedVal)
inputData[i] = inputRow
elif values[0] == 'PDF': # Distribution
index = int(values[1]) - 1
inputDists[index] = values[2]
if len(values) > 3:
if values[2] == Distribution.getPsuadeName(Distribution.SAMPLE):
inputDistParam1s[index] = values[3]
else:
inputDistParam1s[index] = float(values[3])
if len(values) > 4:
inputDistParam2s[index] = float(values[4])
elif readOutputs: # Read outputs
stripped = line.strip() # Variable name
if stripped.startswith('variable'):
values = stripped.split()
outputNames = outputNames + [values[2]]
else:
stripped = line.strip()
values = stripped.split()
if values[0] == 'sampling': #Sampling method
sampleMethod = values[2]
elif values[0] == 'driver': #Driver
if values[2] == 'NONE':
values[2] = None
driverName = values[2]
if values[2] is not None and values[2] != 'PSUADE_LOCAL' and not os.path.exists(driverName):
# Check if driver exists in same directory as this file
if os.path.exists(os.path.join(path, driverName)):
driverName = os.path.join(path, driverName)
else: # Don't set the name because the file does not exist
driverName = None
elif values[0] == 'opt_driver': #Optimization driver
if values[2] == 'NONE':
values[2] = None
optDriverName = values[2]
if values[2] is not None and values[2] != 'PSUADE_LOCAL' and not os.path.exists(optDriverName):
# Check if driver exists in same directory as this file
if os.path.exists(os.path.join(path, optDriverName)):
optDriverName = os.path.join(path, optDriverName)
else: # Don't set the name because the file does not exist
optDriverName = None
elif values[0] == 'aux_opt_driver': #Batch simulation driver
if values[2] == 'NONE':
values[2] = None
auxDriverName = values[2]
if values[2] is not None and not os.path.exists(auxDriverName):
# Check if driver exists in same directory as this file
if os.path.exists(os.path.join(path, auxDriverName)):
auxDriverName = os.path.join(path, auxDriverName)
else: # Don't set the name because the file does not exist
auxDriverName = None
elif values[0] == 'num_samples': #Number of samples
numSamples = int(values[2])
elif values[0] == 'analyzer': # Analysis values
if values[1] == 'rstype':
sampleType = values[3]
sampleType = ResponseSurfaces.getEnumValue(sampleType)
elif values[1] == 'rs_legendre_order':
legendreOrder = int(values[3])
model.setInputNames(inputNames)
model.setOutputNames(outputNames)
model.setNamesIncludeNodes(namesIncludeNodes)
model.setInputTypes(inputTypes)
model.setInputMins(inputMins)
model.setInputMaxs(inputMaxs)
model.setInputDefaults(inputDefaults)
model.setSelectedOutputs(range(len(outputNames)))
model.setDriverName(driverName)
model.setOptDriverName(optDriverName)
model.setAuxDriverName(auxDriverName)
model.setRunType(Model.LOCAL)
## print model.getInputNames()
## print model.getOutputNames()
## print model.getInputDistributions()
## print model.getNumSamples()
## print model.getNumInputs()
## print model.getNumOutputs()
## print model.getInputMins()
## print model.getInputMaxs()
## from SamplingMethods import SamplingMethods
## print SamplingMethods.getFullName(model.getSampleMethod())
## print model.getDriver()
if returnModelOnly:
return model
data = SampleData(model)
data.setFromFile(True)
data.setNumSamples(numSamples)
if sampleMethod is None:
data.setSampleMethod(SamplingMethods.MC)
else:
data.setSampleMethod(sampleMethod)
data.setInputDistributions(inputDists, inputDistParam1s, inputDistParam2s)
data.setSampleRSType(sampleType)
data.setLegendreOrder(legendreOrder)
if inputData:
data.setInputData(inputData)
if outputData:
data.setOutputData(outputData)
if runState:
data.setRunState(runState)
return data
def writeToPsuade(self, filename, fixedAsVariables=False):
outf = open(filename, 'w')
if self.getNamesIncludeNodes():
outf.write('# NAMESHAVENODES\n')
outf.write('PSUADE_IO (Note : inputs not true inputs if pdf ~=U)\n')
types = self.getInputTypes()
if fixedAsVariables:
numInputs = self.getNumInputs()
else:
numInputs = types.count(Model.VARIABLE)
outf.write('%d %d %d\n' %
(numInputs, self.getNumOutputs(), self.getNumSamples()))
#Write out data
hasOutputData = False
if self.outputData is not None:
if isinstance(self.outputData, numpy.ndarray):
if self.outputData.size > 0:
hasOutputData = True
elif self.outputData:
if isinstance(self.outputData[0], list) and len(
self.outputData[0]) == 0:
hasOutputData = False
else:
hasOutputData = True
for i in xrange(self.getNumSamples()):
outf.write('%d %d\n' % (i + 1, self.runState[i]))
for j in xrange(self.getNumInputs()):
if types[j] == Model.VARIABLE or fixedAsVariables:
outf.write(' % .16e\n' % self.inputData[i][j])
for j in xrange(self.getNumOutputs()):
if hasOutputData and not numpy.isnan(self.outputData[i][j]):
outf.write(' % .16e\n' % self.outputData[i][j])
else:
outf.write(' 9.9999999999999997e+34\n')
outf.write('PSUADE_IO\n')
outf.write('PSUADE\n')
#Write inputs
outf.write('INPUT\n')
numFixed = self.getNumInputs() - numInputs
if numFixed > 0:
outf.write(' num_fixed %d\n' % numFixed)
#outf.write(' dimension = %d\n' % self.getNumInputs())
outf.write(' dimension = %d\n' % numInputs)
names = self.getInputNames()
mins = self.getInputMins()
maxs = self.getInputMaxs()
defaults = self.getInputDefaults()
distributions = self.getInputDistributions()
if not distributions or len(distributions) == 0:
self.setInputDistributions([Distribution.UNIFORM] *
self.getNumInputs())
distributions = self.getInputDistributions()
self.setInputDistributions([])
fixedIndex = 1
variableIndex = 1
for name, minimum, maximum, inType, dist, default in map(
None, names, mins, maxs, types, distributions, defaults):
if not fixedAsVariables and inType == Model.FIXED:
outf.write(' fixed %d %s = % .16e\n' %
(fixedIndex, name, default))
fixedIndex = fixedIndex + 1
else:
outf.write(' variable %d %s = % .16e % .16e\n' %
(variableIndex, name, minimum, maximum))
if dist is not None:
distType = dist.getDistributionType()
distParams = dist.getParameterValues()
if distType != Distribution.UNIFORM:
outf.write(' PDF %d %c' %
(variableIndex,
Distribution.getPsuadeName(distType)))
if distType == Distribution.SAMPLE:
fileString = distParams[0]
import platform
if platform.system() == 'Windows':
import win32api
fileString = win32api.GetShortPathName(
fileString)
outf.write(' %s %d' % (fileString, distParams[1]))
else:
if distParams[0] is not None:
outf.write(' % .16e' % distParams[0])
if distParams[1] is not None:
outf.write(' % .16e' % distParams[1])
outf.write('\n')
variableIndex = variableIndex + 1
outf.write('END\n')
#Write outputs
outf.write('OUTPUT\n')
outf.write(' dimension = %d\n' % self.getNumOutputs())
names = self.getOutputNames()
indices = range(self.getNumOutputs())
for i, name in zip(indices, names):
outf.write(' variable %d %s\n' % (i + 1, name))
outf.write('END\n')
#Write Method
outf.write('METHOD\n')
if self.getSampleMethod() != None:
outf.write(' sampling = %s\n' %
SamplingMethods.getPsuadeName(self.getSampleMethod()))
outf.write(' num_samples = %d\n' % self.getNumSamples())
outf.write(' num_replications = 1\n')
outf.write(' num_refinements = 0\n')
outf.write(' refinement_size = 10000000\n')
outf.write(' reference_num_refinements = 0\n')
outf.write('END\n')
#Write Application
outf.write('APPLICATION\n')
driverString = self.getDriverName()
if driverString is None or not os.path.exists(driverString):
driverString = 'NONE'
else:
import platform
if platform.system() == 'Windows':
import win32api
driverString = win32api.GetShortPathName(driverString)
outf.write(' driver = %s\n' % driverString)
driverString = self.getOptDriverName()
if driverString != 'PSUADE_LOCAL':
if driverString is None or not os.path.exists(driverString):
driverString = 'NONE'
else:
import platform
if platform.system() == 'Windows':
import win32api
driverString = win32api.GetShortPathName(driverString)
outf.write(' opt_driver = %s\n' % driverString)
driverString = self.getEnsembleOptDriverName()
if driverString != 'PSUADE_LOCAL':
if driverString is None or not os.path.exists(driverString):
driverString = 'NONE'
else:
import platform
if platform.system() == 'Windows':
import win32api
driverString = win32api.GetShortPathName(driverString)
outf.write(' ensemble_opt_driver = %s\n' % driverString)
driverString = self.getAuxDriverName()
if driverString is None or not os.path.exists(driverString):
driverString = 'NONE'
else:
import platform
if platform.system() == 'Windows':
import win32api
driverString = win32api.GetShortPathName(driverString)
outf.write(' aux_opt_driver = %s\n' % driverString)
outf.write(' max_job_wait_time = 1000000\n')
outf.write(' save_frequency = 1\n')
outf.write('END\n')
#Write Analysis
outf.write('ANALYSIS\n')
outf.write(' analyzer output_id = 1\n')
rs = self.getSampleRSType()
if rs == None:
rs = 'MARS'
else:
rs = ResponseSurfaces.getPsuadeName(rs)
outf.write(' analyzer rstype = %s\n' % rs)
order = self.getLegendreOrder()
if order is not None:
outf.write(' analyzer rs_legendre_order = %d\n' %
self.getLegendreOrder())
outf.write(' analyzer threshold = 1.000000e+00\n')
outf.write(' diagnostics 1\n')
outf.write('END\n')
outf.write('END\n')
outf.close()
