def main():
print ""
print '====================================='
print '# STARFiSh_v0.4 Visualisation #'
print '====================================='
print ""
optionsDict = mStartUp.parseOptions(['f', 'n', 'v'],
visualisationOnly=True)
networkName = optionsDict['networkName']
dataNumber = optionsDict['dataNumber']
vizOutput = optionsDict['vizOutput']
if vizOutput == 'non':
vizOutput = "2D+3D"
string1 = ' '.join([
sys.executable, cur + '/VisualisationLib/class2dVisualisation.py',
'-f', networkName, '-n', dataNumber, '-c'
])
string2 = ' '.join([
sys.executable, cur + '/VisualisationLib/class3dVisualisation.py',
'-f', networkName, '-n', dataNumber, '-c True'
])
if vizOutput == "2D":
viz2d = subprocess.Popen(string1, shell=True)
if vizOutput == "3D":
viz3d = subprocess.Popen(string2, shell=True)
if vizOutput == "2D+3D":
viz2d = subprocess.Popen(string1, shell=True)
viz3d = subprocess.Popen(string2, shell=True)
while True:
if viz2d.poll() != None:
viz3d.terminate()
exit()
if viz3d.poll() != None:
viz2d.terminate()
exit()
from optparse import OptionParser
import cPickle
import numpy as np
from pprint import pprint as pp
__author__ = "Vinzenz Gregor Eck"
__version__ = "0.3_dev"
### file to help user post processing
### 1. open solution data file after a simulation
## use -f and -n to define solution file you want to open, or use the inbulid menu
optionsDict = moduleStartUp.parseOptions(['f', 'n', 'c'],
visualisationOnly=True)
networkName = optionsDict['networkName']
dataSetNumber = optionsDict['dataNumber']
print dataSetNumber
## open data file choosed above
try:
print " Try to open network {} with data number {}".format(
networkName, dataSetNumber)
vascularNetwork = mXML.loadNetworkFromXML(filename=networkName,
dataNumber=dataNumber)
vascularNetwork.linkSolutionData()
except:
print "Error could not open solution data with data number {} of network {}".format(
def main():
optionsDict = mStartUp.parseOptions(['f','n','d','s','v','r','w','p'])
networkName = optionsDict['networkName']
save = optionsDict['save']
dataNumber = optionsDict['dataNumber']
simulationDescription = optionsDict['simulationDescription']
vizOutput = optionsDict['vizOutput']
resimulate = optionsDict['resimulate']
filename = str(networkName+'.xml')
logger.info('____________Simulation_______________')
logger.info('%-20s %s' % ('Network name',networkName))
logger.info('%-20s %s' % ('Data number', dataNumber))
logger.info('%-20s %s' % ('Save simulation', save))
logger.info('%-20s %s' % ('Case description', simulationDescription))
logger.info('%-20s %s' % ('Resimulate', resimulate))
logger.info('%-20s %s' % ('Visualisationmode', vizOutput))
## check if template
if '_template' in networkName:
networkName = mFPH.createWorkingCopyOfTemplateNetwork(networkName)
# load network from the path!
if resimulate == False:
vascularNetwork = mXML.loadNetworkFromXML(networkName) # moved to vascularNetowrk constror
else:
# resimulate network
vascularNetwork = mXML.loadNetworkFromXML(networkName, dataNumber = dataNumber)
if simulationDescription == '':
simulationDescription = vascularNetwork.description
if vascularNetwork == None: exit()
vascularNetwork.update({'description':simulationDescription,
'dataNumber' :dataNumber})
timeSolverInitStart = time.clock()
#initialize Solver
flowSolver = c1DFlowSolv.FlowSolver(vascularNetwork)
timeSolverInit = time.clock()-timeSolverInitStart
timeSolverSolveStart = time.clock()
#solve the system
flowSolver.solve()
timeSolverSolve = time.clock()-timeSolverSolveStart
minutesInit = int(timeSolverInit/60.)
secsInit = timeSolverInit-minutesInit*60.
minutesSolve = int(timeSolverSolve/60.)
secsSolve = timeSolverSolve-minutesSolve*60.
logger.info('____________ Solver time _____________')
logger.info('Initialisation: {} min {} sec'.format(minutesInit,secsInit))
logger.info('Solving: {} min {} sec'.format(minutesSolve,secsSolve))
logger.info('=====================================')
vascularNetwork.saveSolutionData()
mXML.writeNetworkToXML(vascularNetwork, dataNumber = dataNumber) # needs to be moved to vascularNetwork
del flowSolver
gc.collect()
mFPH.updateSimulationDescriptions(networkName, dataNumber, simulationDescription)
gc.collect()
if vizOutput == "2D":
string = ' '.join([sys.executable, cur + '/VisualisationLib/class2dVisualisation.py','-f',vascularNetwork.name, '-n',str(dataNumber)])
subprocess.Popen(string, shell=True)
if vizOutput == "3D":
string = ' '.join([sys.executable, cur+'/VisualisationLib/class3dVisualisation.py','-f',vascularNetwork.name, '-n',str(dataNumber), '-c True'])
subprocess.Popen(string, shell=True)
if vizOutput == "2D+3D":
string1 = ' '.join([sys.executable, cur + '/VisualisationLib/class2dVisualisation.py', '-f', vascularNetwork.name, '-n',str(dataNumber), '-c True'])
string2 = ' '.join([sys.executable, cur + '/VisualisationLib/class3dVisualisation.py', '-f', vascularNetwork.name, '-n',str(dataNumber), '-c True'])
viz2d = subprocess.Popen(string1, shell = True )
viz3d = subprocess.Popen(string2, shell = True )
while True:
if viz2d.poll() != None:
viz3d.terminate()
exit()
if viz3d.poll() != None:
viz2d.terminate()
exit()
def uncertaintyPropagation():
'''
Perform vascular polynomial chaos
or MonteCarlo analysis for STARFiSh simulation case
# steps
# 1. load vpc case and configuration
# 2. create distributions
# 3. add dependentCase if existent
# 4. create samples
# 5. evaluate model / on local machine or on server
# 6. postprocess evaluated data, peak finding etc
# 7. create Orthogonal polynomials
# 8. calculate polynomial chaos expansion
# 9. uncertainty quantfication, sensitivity analysis
'''
print ""
print '=============================================='
print '# VascularPolynomialChaos_v0.3 #'
print '=============================================='
# steps
# 1. load vpc case and configuration
optionsDict = mStartUp.parseOptions(['f', 'n'],
vascularPolynomialChaos=True)
networkName = optionsDict['networkName']
dataNumber = optionsDict['dataNumber']
# 1.1 load configuration and locations of interest
uqsaCase = cUqsaCase.UqsaCase() #cConfigUQSA.ConfigurationUQSA()
uqsaCaseFile = mFPH_VPC.getFilePath('uqsaCaseXmlFile', networkName,
dataNumber, 'read')
uqsaCase.loadXMLFile(uqsaCaseFile)
uqsaCase.initialize(networkName, dataNumber)
# 1.2 load vascular network file polynomial chaos
vpcNetworkXmlFile = mFPH_VPC.getFilePath('vpcNetworkXmlFile', networkName,
dataNumber, 'read')
vascularNetwork = mXML.loadNetworkFromXML(networkName,
dataNumber,
networkXmlFile=vpcNetworkXmlFile)
# 1.3 initialized defined random inputs
vascularNetwork.randomInputManager.initialize(vascularNetwork)
assert len(vascularNetwork.randomInputManager.randomInputs.keys(
)) != 0, "VascularPolynomialChaos_v0.3: no random inputs defined!"
vascularNetwork.randomInputManager.printOutInfo()
# 2. create distributions
distributionManager = cDistMng.DistributionManagerChaospy(
vascularNetwork.randomInputManager.randomInputsExtDist)
distributionManager.createRandomVariables()
# 3. add dependentCase if existent
if uqsaCase.sampleManager.dependentCase == True:
# this enables dependentCase in Distribution Manager
distributionManager.createDependentDistribution(
vascularNetwork.randomInputManager.correlationMatrix)
# 4. create or load samples
uqsaCase.aquireSamples(
distributionManager,
vascularNetwork.randomInputManager.randomInputsExtDist)
# 5. evaluate model / on local machine or on server
# 5.1 create evaluation case file list
uqsaCase.createEvaluationCaseFiles()
# 5.2 save/create simulation xml files
if uqsaCase.createEvaluationXmlFiles == True:
for sampleIndex in xrange(uqsaCase.sampleManager.currentSampleSize):
# update network with current evaluation number
# get sample
sample = uqsaCase.sampleManager.getSample(sampleIndex)
# pass realisation of Z to network
distributionManager.passRealisation(sample, sampleIndex)
# save evaluation file
networkXmlFileSave = uqsaCase.evaluationCaseFiles[sampleIndex][
'networkXmlFileSave']
mXML.writeNetworkToXML(vascularNetwork,
dataNumber=dataNumber,
networkXmlFile=networkXmlFileSave)
# save evaluation to log file
evaluationLogFile = mFPH_VPC.getFilePath(
'evaluationLogFile',
networkName,
dataNumber,
mode="write",
caseName=uqsaCase.sampleManager.samplingMethod)
vascularNetwork.randomInputManager.saveRealisationLog(
evaluationLogFile,
networkName,
dataNumber,
caseName=uqsaCase.sampleManager.samplingMethod)
# 5.3 run evaluation simulations
if uqsaCase.simulateEvaluations == True:
batchFileList = uqsaCase.getSimulatioNBatchFileList()
if uqsaCase.localEvaluation == True:
if uqsaCase.multiprocessing == False:
mBSM.runBatchAsSingleProcess(batchFileList, quiet=True)
else:
mBSM.runBatchAsMultiprocessing(batchFileList,
uqsaCase.numberOfProcessors,
quiet=True)
else:
# TODO: server simulations not implemented yet
raise NotImplementedError("server simulations not implemented yet")
# 6. process quantity of interest
uqsaCase.preprocessSolutionData()
# 7. uncertainty quantification and sensitivty analysis
uqsaCase.quantifyUncertaintyAndAnalyseSensitivtiy(distributionManager)
def main():
print ""
print '====================================='
print '# STARFiSh_v0.3_development #'
print '====================================='
optionsDict = mStartUp.parseOptions(
['f', 'e', 'n', 'd', 's', 'v', 'r', 'w', 'p'])
networkName = optionsDict['networkName']
newNetworkName = optionsDict['NewNetworkName']
save = optionsDict['save']
dataNumber = optionsDict['dataNumber']
simulationDescription = optionsDict['simulationDescription']
vizOutput = optionsDict['vizOutput']
resimulate = optionsDict['resimulate']
filename = str(networkName + '.xml')
print '____________Simulation_______________'
print '%-20s %s' % ('Network name', networkName)
print '%-20s %s' % ('Data number', dataNumber)
print '%-20s %s' % ('Save simulation', save)
print '%-20s %s' % ('Case description', simulationDescription)
print '%-20s %s' % ('Resimulate', resimulate)
print '%-20s %s' % ('Visualisationmode', vizOutput)
## check if template
if '_template' in networkName:
networkName = mFPH.createWorkingCopyOfTemplateNetwork(networkName)
# load network from the path!
if resimulate == False:
vascularNetwork = mXML.loadNetworkFromXML(
networkName) # moved to vascularNetowrk constror
else:
# resimulate network
vascularNetwork = mXML.loadNetworkFromXML(networkName,
dataNumber=dataNumber)
if simulationDescription == '':
simulationDescription = vascularNetwork.description
if vascularNetwork == None: exit()
oldNetworkDirectory = mFPH.getDirectory('networkXmlFileXXXDirectory',
networkName, "xxx", 'read')
vascularNetwork.update({
'description': simulationDescription,
'dataNumber': dataNumber
})
New_network = cNred.NetworkReduction(vascularNetwork)
truncateFile = ''.join([oldNetworkDirectory, '/', 'truncate.txt'])
New_network.reduceNetwork(truncateFile)
New_network.name = newNetworkName
newNetworkXmlFile = mFPH.getFilePath('networkXmlFile', newNetworkName,
"xxx", 'write')
mXML.writeNetworkToXML(New_network,
dataNumber=dataNumber,
networkXmlFile=newNetworkXmlFile)
if New_network.initialsationMethod == 'FromSolution':
oldInitialValuePath = mFPH.getDirectory('initialValueFileDirectory',
networkName, dataNumber,
'write')
newInitialValuePath = mFPH.getDirectory('initialValueFileDirectory',
newNetworkName, dataNumber,
'write')
if os.path.isdir(newInitialValuePath):
shutil.rmtree(newInitialValuePath)
shutil.copytree(oldInitialValuePath, newInitialValuePath)
copyFlowFile = True
if copyFlowFile:
oldInflowFile = ''.join([oldNetworkDirectory, '/', 'inflow.csv'])
newNetworkDirectory = mFPH.getDirectory('networkXmlFileXXXDirectory',
newNetworkName, "xxx", 'read')
newInflowFile = ''.join([newNetworkDirectory, '/', 'inflow.csv'])
shutil.copyfile(oldInflowFile, newInflowFile)
copyTruncateFile = True
if copyTruncateFile:
newNetworkDirectory = mFPH.getDirectory('networkXmlFileXXXDirectory',
newNetworkName, "xxx", 'read')
newTruncateFile = ''.join([newNetworkDirectory, '/', 'truncate.txt'])
shutil.copyfile(truncateFile, newTruncateFile)