def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::Omega3P_modeInfo")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
#paramFile.dataDict["export"].pushBack("modes", DataDict())
paramFile.write()
def createNew(folder):
if os.path.exists(folder):
raise TuneFreqException("Folder \"" + folder + "\" already exists")
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder,"paramFile_scan.set"), "w")
paramFile.dataDict.pushBack("fileID", "ParameterScan::TuneFreq")
#Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("baseGeomInstance_name", "")
paramFile.dataDict.pushBack("slaveGeoms", DataDict())
paramFile.dataDict.pushBack("scanParameter_name", "")
paramFile.dataDict.pushBack("predict_anaVariable","Omega3P_modeInfo.Mode.FrequencyReal_GHz")
paramFile.dataDict.pushBack("predict_targetValue", "11.9942")
paramFile.dataDict.pushBack("predict_tolerance", "0.001")
paramFile.dataDict.pushBack("predict_a", "0")
paramFile.dataDict.pushBack("predict_b", "0")
paramFile.dataDict.pushBack("predict_x", "0")
paramFile.dataDict.pushBack("predict_R2", "0")
paramFile.dataDict.pushBack("predict_ndof", "-10") #predict_ndof only positive iff have valid prediction
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.write()
def createNew(folder):
if os.path.exists(folder):
raise Scan2DException("Folder \"" + folder + "\" already exists")
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder,"paramFile_scan.set"), "w")
paramFile.dataDict.pushBack("fileID", "ParameterScan::Scan2D")
#Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("baseGeomInstance_name", "")
paramFile.dataDict.pushBack("slaveGeoms", DataDict())
paramFile.dataDict.pushBack("scanParameter1_name", "")
paramFile.dataDict.pushBack("scanParameter1_max", "0")
paramFile.dataDict.pushBack("scanParameter1_min", "0")
paramFile.dataDict.pushBack("scanParameter1_num", "0")
paramFile.dataDict.pushBack("scanParameter2_name", "")
paramFile.dataDict.pushBack("scanParameter2_max", "0")
paramFile.dataDict.pushBack("scanParameter2_min", "0")
paramFile.dataDict.pushBack("scanParameter2_num", "0")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.write()
class DummyInput(AnalysisInterface):
"""
Dummy analysis that doesn't actually do anything,
used for testing the abstract machinery of input data
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "DummyInput::__init__()"
self.type = "DummyInput"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::DummyInput":
raise DummyInputException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
self.settings = self.__paramFile.dataDict["settings"]
def runAnalysis(self):
try:
N = int(self.settings["N"])
except ValueError:
#Could raise an exception here, choose not to
N = 0
self.exportResults.setValSingle("result", "3.14")
self.exportResults.setValSingle("Nparrot", str(N))
self.exportResults.setValSingle("Npi", str(3.14*N))
self.lockdown = True
self.write()
def clearLockdown(self):
print "DummyInput::clearLockdown()"
self.exportResults.setValSingle("result", "")
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::DummyInput")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict["export"].pushBack("result", "")
paramFile.dataDict["export"].pushBack("Nparrot", "")
paramFile.dataDict["export"].pushBack("Npi", "")
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("N", "")
paramFile.write()
def createNew(folder, parentScanName=None):
if parentScanName == None:
#If parentScan, they are created in the same folder
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder,"paramFile_scanCollection.set"), 'w')
paramFile.dataDict.pushBack("fileID", "ParameterScan::ParameterScanCollection")
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("scans", DataDict())
os.mkdir(os.path.join(folder,"scans"))
if parentScanName != None:
paramFile.dataDict.pushBack("parentScan", parentScanName)
else:
paramFile.dataDict.pushBack("parentScan", "")
paramFile.write()
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::RFpost")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("RFpost_LogFileName", "acdtool.log")
paramFile.write()
class FileList(AnalysisInterface):
"""
Simple analysis that lists the files in the finished folder
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "FileList::__init__()"
self.type = "FileList"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), "rw")
if self.__paramFile.dataDict["fileID"] != "Analysis::FileList":
raise FileListException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
def runAnalysis(self):
finishedFolder = self.runConfig.finishedFolder
if finishedFolder == None:
raise FileListException_runAna("No data to analyse")
self.__recursiveDirList(self.exportResults["files"], finishedFolder)
self.lockdown = True
self.write()
def __recursiveDirList(self, storeDict, path):
dirlist = os.listdir(path)
for entry in dirlist:
path2 = os.path.join(path, entry)
if os.path.isdir(path2):
folderDict = storeDict.pushBack(entry, DataDict())
self.__recursiveDirList(folderDict, path2)
else:
storeDict.pushBack(entry, "")
def clearLockdown(self):
print "FileList::clearLockdown()"
self.exportResults["files"].clear()
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder, name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::FileList")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict["export"].pushBack("files", DataDict())
paramFile.write()
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::DummyInput")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict["export"].pushBack("result", "")
paramFile.dataDict["export"].pushBack("Nparrot", "")
paramFile.dataDict["export"].pushBack("Npi", "")
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("N", "")
paramFile.write()
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::ScMax")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("RFpostName", "RFpost_local")
paramFile.dataDict["settings"].pushBack("fieldOnSurface_basename", "fieldOnSurface_metal")
paramFile.write()
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::GroupVelocity")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("ModeInfoName", "Omega3P_modeInfo")
paramFile.dataDict["settings"].pushBack("RFpostName", "RFpost_local")
paramFile.dataDict["settings"].pushBack("SurfaceID", "")
paramFile.write()
def createNew(folder,name):
#Create a new folder to hold the stuff
os.mkdir(os.path.join(folder,name))
#Parameter file
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name,"paramFile.set"), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::ModeFileRecalc")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("ResultDir","omega3p_results")
paramFile.write()
def createNew(folder,name):
#Create a new folder to hold the stuff
os.mkdir(os.path.join(folder,name))
#Create a SolverSetup
AcdOptiSolverManager.createNew("acdtool_rfpost", os.path.join(folder,name))
#Parameter file
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name,"paramFile.set"), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::RFpost_local")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("L","")
paramFile.write()
def createNew(folder):
if os.path.exists(folder):
raise Scan2D_TuneException("Folder \"" + folder + "\" already exists")
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder,"paramFile_scan.set"), "w")
paramFile.dataDict.pushBack("fileID", "ParameterScan::Scan2D_Tune")
#Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("baseGeomInstance_name", "")
paramFile.dataDict.pushBack("slaveGeoms", DataDict())
paramFile.dataDict.pushBack("scanParameter1_name", "")
paramFile.dataDict.pushBack("scanParameter1_max", "0")
paramFile.dataDict.pushBack("scanParameter1_min", "0")
paramFile.dataDict.pushBack("scanParameter1_num", "0")
paramFile.dataDict.pushBack("scanParameter2_name", "")
paramFile.dataDict.pushBack("scanParameter2_max", "0")
paramFile.dataDict.pushBack("scanParameter2_min", "0")
paramFile.dataDict.pushBack("scanParameter2_num", "0")
paramFile.dataDict.pushBack("tune_parameter","")
paramFile.dataDict.pushBack("tune_anaVariable","Omega3P_modeInfo.Mode.FrequencyReal_GHz")
paramFile.dataDict.pushBack("tune_targetValue","11.9942")
paramFile.dataDict.pushBack("tune_initialPoints", DataDict())
paramFile.dataDict.pushBack("tune_ipModelDict", DataDict())
paramFile.dataDict.pushBack("tune_useModelPoints", "False")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.write()
#Setup the ScanCollection in the same folder
ParameterScanCollection.createNew(folder, instName)
def createNew(folder):
if os.path.exists(folder):
raise DummySubscanException('Folder "' + folder + '" already exists')
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder, "paramFile_scan.set"), "w")
paramFile.dataDict.pushBack("fileID", "ParameterScan::DummySubscan")
# Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("baseGeomInstance_name", "")
paramFile.dataDict.pushBack("slaveGeoms", DataDict())
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.write()
# Setup the ScanCollection in the same folder
ParameterScanCollection.createNew(folder, instName)
class Omega3P_modeInfo(AnalysisInterface):
"""
Analysis that presents the information
being output directly from Omega3P per mode
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "Omega3P_modeInfo::__init__()"
self.type = "Omega3P_modeInfo"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::Omega3P_modeInfo":
raise Omega3P_modeInfo_exception("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
if "modes" in self.exportResults:
#Convert to new format
print "Converting to new format..."
modes = self.exportResults["modes"].copy()
self.exportResults.clear()
for (k,v) in modes:
self.exportResults.pushBack(k,v)
self.write()
def runAnalysis(self):
finishedFolder = self.runConfig.finishedFolder
if finishedFolder == None:
raise Omega3P_modeInfo_exception_runAna("No data to analyze")
if os.path.isdir(os.path.join(finishedFolder, "omega3p_results")):
outputFilePath = os.path.join(finishedFolder, "omega3p_results", "omega3p.out")
elif os.path.isfile(os.path.join(finishedFolder,"output")):
outputFilePath = os.path.join(finishedFolder, "output")
else:
#self.exportResults.setValSingle("modes", "!!FILE_NOT_FOUND!!")
raise Omega3P_modeInfo_exception_runAna("File '" + os.path.join(finishedFolder, "omega3p_results") + "' not found")
outputFile = open(outputFilePath, "r")
#Find the lines with KVC syntax
# data = ""
# lastLineWasComment = True
# for line in outputFile.readlines():
# ls = line.strip()
# if ls.startswith("/*") and ls.endswith("*/"):
# if lastLineWasComment:
# continue #comments at beginning
# else:
# break #comments at end
# #Not a comment line
# data += line
# lastLineWasComment = False
#
#Find the lines relating to mode (else the timestamps will crash the parser due to extra ":")
thereYet=False
data = ""
for line in outputFile.readlines():
ls = line.strip()
if ls.startswith("Mode :"):
thereYet = True
elif not thereYet:
continue
elif ls.startswith("Mesh :") or ls.startswith("AMRLevel"):
break
data += line
print data
#Parse the data
dataParser = AcdOptiFileParser_KVC(data,"s")
for (modeName, mode) in dataParser.dataDict:
#print mode
if "," in mode["TotalEnergy"]:
te = mode["TotalEnergy"]
teSplit = te.split(",")
mode.delItem("TotalEnergy")
mode.pushBack("TotalEnergyReal", teSplit[0].strip())
mode.pushBack("TotalEnergyImag", teSplit[1].strip())
if "," in mode["Frequency"]:
freq = mode["Frequency"]
freqSplit = freq.split(",")
mode.delItem("Frequency")
mode.pushBack("FrequencyReal", freqSplit[0].strip())
mode.pushBack("FrequencyReal_GHz", str(float(freqSplit[0].strip())/1e9))
mode.pushBack("FrequencyImag", freqSplit[1].strip())
mode.pushBack("FrequencyImag_GHz", str(float(freqSplit[1].strip())/1e9))
else:
mode.pushBack("Frequency_GHz", str(float(mode["Frequency"])/1e9))
self.exportResults.pushBack(modeName,mode.copy())
self.lockdown = True
self.write()
def clearLockdown(self):
self.exportResults.clear()
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::Omega3P_modeInfo")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
#paramFile.dataDict["export"].pushBack("modes", DataDict())
paramFile.write()
class RFpost(AnalysisInterface, RFpostParser):
"""
Parses rfpost output files
"""
__paramFile = None
fname = None
def __init__(self, folder, name, runConfig):
print "RFpost::__init__()"
self.type = "RFpost"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::RFpost":
raise RFpostException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
self.settings = self.__paramFile.dataDict["settings"]
def runAnalysis(self):
if self.settings["RFpost_LogFileName"] == "":
raise RFpostException_runAna("Input file not set")
self.fname = fname = os.path.join(self.runConfig.finishedFolder, self.settings["RFpost_LogFileName"])
if not os.path.isfile(fname):
raise RFpostException_runAna("Could not find input file '" + fname + "'")
ifile = open(fname, 'r')
fileData = ifile.read()
ifile.close()
addDic = self.parseData(fileData)
for (k,v) in addDic:
self.exportResults.pushBack(k,v)
self.lockdown = True
self.write()
def clearLockdown(self):
print "RFpost::clearLockdown()"
self.exportResults.clear()
self.lockdown = False
self.fname = None
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::RFpost")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("RFpost_LogFileName", "acdtool.log")
paramFile.write()
class ParameterScanInterface(object):
type = None
folder = None #Folder where it stores it data
scanCollection = None #Pointer to ParameterScanCollection
instName = None #Name of this particular ParameterScan instance
_paramFile = None
baseGeomInstance = None #Geometry instance on which to base the scan
slaveGeoms = None #List of geometry instances "belonging" to this scan
slaveScanCollection = None #ParameterScanCollection with slave scans
lockdown = False #Set to true once we have slaveGeoms. When true baseGeom isn't changeable
def __init__(self,folder,collection, typ):
from ParameterScanCollection import ParameterScanCollection
assert typ in ParameterScanCollection.parameterScanTypes or "ParameterScan::"+ typ in ParameterScanCollection.parameterScanTypes
self.type = typ
self.folder = folder
self.scanCollection = collection
#Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
self.instName = instName = os.path.split(instName)[1]
#Load paramFile.set
self._paramFile = AcdOptiFileParser_simple(os.path.join(folder, "paramFile_scan.set"), 'rw')
if self._paramFile.dataDict["fileID"] != self.type:
raise ParameterScanInterfaceException_init("Got fileID='" + self._paramFile.dataDict["fileID"] + "'")
if self._paramFile.dataDict.getValSingle("instName") != self.instName:
raise ParameterScanInterfaceException_init("instName doesn't match folder name")
self.lockdown = DataDict.boolconv(self._paramFile.dataDict["lockdown"])
baseGeomInstance_name = self._paramFile.dataDict["baseGeomInstance_name"]
if baseGeomInstance_name == "":
self.baseGeomInstance = None
assert len(self._paramFile.dataDict["slaveGeoms"]) == 0
assert self.lockdown == False
else:
self.baseGeomInstance = self.getProject().geomCollection.geomInstances[baseGeomInstance_name]
self.slaveGeoms = {}
for (geomName, nothingOfInterest) in self._paramFile.dataDict["slaveGeoms"]:
#Mutal referencing
self.slaveGeoms[geomName] = self.getProject().geomCollection.geomInstances[geomName]
self.slaveGeoms[geomName].scanInstances.append(self)
if len(self.slaveGeoms) > 0:
assert self.lockdown == True
def write(self):
"Update slaveGeoms and write to paramfile"
if len(self.slaveGeoms) > 0:
assert self.lockdown == True
for geomName in self.slaveGeoms.keys():
if not geomName in self._paramFile.dataDict["slaveGeoms"]:
self._paramFile.dataDict["slaveGeoms"].pushBack(geomName, "")
if self.lockdown == True:
assert self.baseGeomInstance != None
assert self._paramFile.dataDict["baseGeomInstance_name"] == self.baseGeomInstance.instName
if self.baseGeomInstance != None:
assert self.baseGeomInstance in self.getProject().geomCollection.geomInstances.values()
self._paramFile.dataDict["baseGeomInstance_name"] = self.baseGeomInstance.instName
else:
self._paramFile.dataDict["baseGeomInstance_name"] = ""
self._paramFile.dataDict["lockdown"] = str(self.lockdown)
self._paramFile.write()
def setBaseGeom(self,baseGeomName):
assert self.lockdown == False, "Can't change baseGeomInstance once we have lockdown"
assert len(self.slaveGeoms) == 0
self.baseGeomInstance = self.getProject().geomCollection.geomInstances[baseGeomName]
self.write()
@staticmethod
def createNew(folder):
"""
Create a new ParameterScan of the implementing type
"""
raise NotImplementedError("Please implement a createNew method in your class!")
@classmethod
def createNew_clone(cls, folder, collection, cloneFrom):
"""
Clone an already existing ParameterScan
of the implementing type.
"""
print "ParameterScan::createNew_clone()"
raise NotImplementedError
# cls.createNew(folder)
# newScan = cls(folder, collection)
# if cloneFrom.settings != None:
# newScan.settings.clear()
# for (k,v) in cloneFrom.settings:
# if isinstance(v,DataDict):
# newScan.settings.pushBack(k,v.copy())
# else:
# newScan.settings.pushBack(k,v)
# newScan.write()
#
# return newScan
# # # # # # # Utility methods # # # # # # # # # # # # # # # # # # # # # # #
def getProject(self):
#Find the project's GeometryCollection:
from acdOpti.AcdOptiProject import AcdOptiProject
scanCollectionParent = self.scanCollection.parent
while True:
if isinstance(scanCollectionParent,AcdOptiProject):
return scanCollectionParent
else:
scanCollectionParent = scanCollectionParent.parent
@staticmethod
def getAnalysisResults(geom,anaVarString):
"""
For a geom, retrive all analysis results using the address anaVarString,
maximum one result per analysisInstance.
AnaVarString syntax:
key.key[idx].key....
If [idx] not present, assume [idx]=0
First key is analysis instance name
"""
anaVarSplit = anaVarString.split(".")
retVals = []
for mesh in geom.meshInsts.itervalues():
for rc in mesh.runConfigs.itervalues():
for ana in rc.analysis.itervalues():
if ana.instName == anaVarSplit[0]:
#Recursive function to find the analysis result
#Uses the usual key.key[idx].key.... syntax
#If not [idx] present, assume idx=0
#If not found, return None
def dictRecDig(avsRemaining, dictBranch):
avsParsed = re.match(r'(\w)+[(\d+)]',avsRemaining[0])
if avsParsed != None:
nextName = avsParsed.group(1)
nextNumber = int(avsParsed.group(2))
else:
nextName = avsRemaining[0]
nextNumber = 0
try:
nextBranch = dictBranch.getVals(nextName)[nextNumber]
except IndexError:
print "WARNING in dictRecDig(): Key '" + avsRemaining[0] + "' not found"
return None
if isinstance(nextBranch,DataDict):
if len(avsRemaining) == 1:
print "WARNING in dictRecDig(): More depth than keys"
return None
return dictRecDig(avsRemaining[1:],nextBranch)
else:
if len(avsRemaining) > 1:
print "WARNING in dictRecDig(): More keys than depth"
return None
return nextBranch
r = dictRecDig(anaVarSplit[1:],ana.exportResults)
if r != None:
retVals.append(r)
return retVals
@staticmethod
def fit1D(x,y, deg):
"""
For two lists of values (x,y), return a a fitted model ŷ = a0 + a1*x + a2*x^2 + ... + adeg*x^deg.
Also return number of degrees of freedom and R^2 = sum (ŷ(x_i)-y_i)^2.
Return:
((a0,a1,...,adeg), ndof, R^2)
"""
if len(x) != len(y):
raise FittingException("length of x (%i) should be equal to length of y (%i)" % ( len(x), len(y) ) )
ndof = len(y) - (deg+1)
if ndof < 0:
raise FittingException_NDOF("ndof =", ndof, "< 0, can't fit.")
A = [np.ones(len(x))]
for i in xrange(deg):
A.append(np.asarray(x)**(i+1))
A = np.vstack(A).T
model = np.linalg.lstsq(A,y)[0]
R2 = 0.0
for i in xrange(len(x)):
R2 += (y[i]-ParameterScanInterface.eval1D(x[i],model))**2
return (model, ndof, R2)
@staticmethod
def eval1D(x,model):
"""
Evaluate a polynomial y=model[0]+model[1]*x+model[2]*x**2 + ... model[n]*x**n.
Works with x both float as and ndarray.
"""
y = None
if type(x) == float:
y = 0.0
elif type(x) == np.ndarray:
y = np.zeros_like(x)
for i in xrange(len(model)):
y += model[i]*x**i
return y
class ScMax(AnalysisInterface):
"""
Calculate the peak Sc value using a fieldOnSurface file
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "ScMax::__init__()"
self.type = "ScMax"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::ScMax":
raise ScMaxException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
self.settings = self.__paramFile.dataDict["settings"]
@staticmethod
def crossProd(a,b):
r = np.array((a[1]*b[2]-a[2]*b[1], -a[0]*b[2]+a[2]*b[0], a[0]*b[1]-a[1]*b[0]))
return r
@staticmethod
def complexConjVec(a):
r = np.empty_like(a);
for i in xrange(len(a)):
r[i] = complex(a[i].real, -a[i].imag)
return r
@staticmethod
def makeComplxVec(ampl, phas):
r = np.array(map(lambda (a,p): complex(a*math.cos(p),a*math.sin(p)),zip(ampl,phas)))
return r
mu0 = (4e-7*np.pi)
def runAnalysis(self):
print "ScMax::RunAnalysis()"
assert not self.lockdown
try:
RFpost = self.runConfig.analysis[self.settings["RFpostName"]]
except KeyError:
raise ScMaxException_runAna("Key for RFpostName not found")
if not RFpost.lockdown:
RFpost.runAnalysis()
#Load the files
print "Loading files..."
basefname = os.path.join(RFpost.folder, RFpost.instName, self.settings["fieldOnSurface_basename"])
try:
file_eField = open(basefname + ".e", 'r');
file_bField = open(basefname + ".b", 'r');
except IOError:
raise ScMaxException_runAna("Could not open file(s)")
(Epos,Eampl,Ephas) = self.__readfile(file_eField)
(Bpos,Bampl,Bphas) = self.__readfile(file_bField)
file_eField.close()
file_bField.close()
#Calculate Sc in every point, find the maximum
print "Calculating..."
maxPos = None
maxSc = -1.0
for i in xrange(len(Epos)):
#Complex S-vectorfield, frequency domain definition
S = 0.5 * self.crossProd( self.makeComplxVec(Eampl[i],Ephas[i]), self.complexConjVec(self.makeComplxVec(Bampl[i]/self.mu0,Bphas[i])) )
Sc = np.sqrt(np.sum((np.abs(np.real(S))+np.abs(np.imag(S))/6.0)**2))
if Sc > maxSc:
maxSc = Sc
maxPos = Epos[i]
#assert Epos[i] == Bpos[i]
#Try to find Ez_ave for the right surface
Ez_ave = None
if "RoverQ" in RFpost.exportResults:
RoQ = RFpost.exportResults["RoverQ"]
try:
Ez_ave = float(RoQ["mode"]["Ez_ave"])
except AcdOptiException_dataDict_getValsSingle:
print "Couldn't find normalization"
self.exportResults.pushBack("maxSc", str(maxSc))
if Ez_ave != None:
self.exportResults.pushBack("maxSc_norm", str(maxSc/Ez_ave**2))
self.exportResults.pushBack("maxPos", str(maxPos))
self.lockdown = True
self.write()
def __readfile(self, fileObject):
print "ScMax::__readfile(), fileObject = " + str(fileObject)
#Create storage
pos = []
#real = []
#imag = []
ampl = []
phas = []
#Read files
for line in fileObject.readlines():
if line[0] == "!":
continue #Skip comment line at the beginning
ls = line.split()
#Get position
pos.append(map(float,ls[0:3]))
#E-field
#real.append(map(float,ls[3:6]))
real = map(float,ls[3:6])
#imag.append(map(float,ls[6:9]))
imag = map(float,ls[6:9])
ampl.append(map(lambda r,i: np.sqrt(r**2 + i**2), real, imag))
phas.append(np.arctan2(imag,real))
#Convert to numpy arrays
pos = np.asarray(pos)
#real = np.asarray(real)
#imag = np.asarray(imag)
ampl = np.asarray(ampl)
phas = np.asarray(phas)
#return (pos,real,imag,ampl,phas)
return (pos,ampl,phas)
def clearLockdown(self):
print "ScMax::clearLockdown()"
self.exportResults.clear()
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::ScMax")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("RFpostName", "RFpost_local")
paramFile.dataDict["settings"].pushBack("fieldOnSurface_basename", "fieldOnSurface_metal")
paramFile.write()
class ModeFileRecalc(AnalysisInterface):
"""
Analysis that runs acdtool postprocess eigentomode locally,
recreating the buggy modefiles you get from paralell O3P.
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "ModeFileRecalc::__init__()"
self.type = "ModeFileRecalc"
self.folder = folder
self.instName = name
self.runConfig = runConfig
#Load paramFile
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name, "paramFile.set"), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::ModeFileRecalc":
raise ModeFileRecalcException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
#Load the settings
self.settings = self.__paramFile.dataDict["settings"]
def runAnalysis(self):
print "ModeFileRecalc::runAnalysis()"
assert not self.lockdown
#Generate the setup file
self.lockdown = True
origResultDir = self.settings["ResultDir"] #Subdirectory whith the data
dataPath = os.path.join(self.folder, self.instName, "data") #Path to symlink to data folder
dataPath2 = os.path.join(dataPath, origResultDir) #Path to O3P etc. results thorough symlink
#Create a symlink to avoid long folder names (ACDtool doesn't like that)
if os.path.islink(dataPath):
os.unlink(dataPath)
os.symlink(self.runConfig.finishedFolder, dataPath) #UNIX only!
#Modify the postprocess.in file to the right path
shutil.copy(os.path.join(dataPath2, "VECTOR", "postprocess.in"),\
os.path.join(self.folder, self.instName, "postprocess.in.bak"))
postFile = AcdOptiFileParser_KVC(os.path.join(dataPath2, "VECTOR", "postprocess.in"),"rw")
postFile.dataDict["ModelInfo"].setValSingle("File", os.path.join(dataPath, "mesh.ncdf"))
postFile.dataDict["CheckPoint"].setValSingle("Directory", os.path.join(os.path.join(dataPath2, "VECTOR")))
postFile.write()
#Check that we don't destroy any data...
if os.path.isfile(os.path.join(dataPath, "acdtool.log")) or os.path.isfile(os.path.join(dataPath, "acdtool.warn")):
#Restore stuff
shutil.copy(os.path.join(self.folder, self.instName, "postprocess.in.bak"),\
os.path.join(dataPath2, "VECTOR", "postprocess.in"))
os.unlink(dataPath)
raise ModeFileRecalcException_runAna("acdtool log files already exists")
#Move the old modefile out of the way...
oldFilesFolder = os.path.join(self.folder,self.instName, "oldModes")
if os.path.isdir(oldFilesFolder):
offls = os.listdir(oldFilesFolder)
if len(offls) > 0:
shutil.copy(os.path.join(self.folder, self.instName, "postprocess.in.bak"),\
os.path.join(dataPath2, "VECTOR", "postprocess.in"))
raise ModeFileRecalcException_runAna
else:
os.mkdir(oldFilesFolder)
files = os.listdir(dataPath2)
movedFiles = []
for f in files:
if f.startswith("mode.") and f.endswith(".mod"):
shutil.move( os.path.join(dataPath2,f), os.path.join(oldFilesFolder,f) )
movedFiles.append(f)
#Run AcdTool!
try:
AcdOptiAcdtoolWrapper.eigentomode(origResultDir, dataPath)
except:
shutil.move( os.path.join(dataPath,"acdtool.log"), os.path.join(self.folder,self.instName,"acdtool.log"))
raise
#Move newly created files to results dir
files = os.listdir(dataPath2)
for f in files:
if f.startswith("mode.") and f.endswith(".mod"):
shutil.move( os.path.join(dataPath2,f), os.path.join(self.folder,self.instName,f))
shutil.move( os.path.join(dataPath,"acdtool.log"), os.path.join(self.folder,self.instName,"acdtool.log"))
shutil.move( os.path.join(dataPath,"acdtool.warn"), os.path.join(self.folder,self.instName,"acdtool.warn"))
#Restore stuff
shutil.copy(os.path.join(self.folder, self.instName, "postprocess.in.bak"),\
os.path.join(dataPath2, "VECTOR", "postprocess.in"))
for f in movedFiles:
shutil.move(os.path.join(oldFilesFolder,f), os.path.join(dataPath2,f))
os.rmdir(oldFilesFolder)
os.unlink(dataPath)
#Save results
self.exportResults.pushBack("Job", "complete")
self.write()
def clearLockdown(self):
print "ModeFileRecalc::clearLockdown()"
if not self.lockdown:
return
self.exportResults.clear()
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
#Create a new folder to hold the stuff
os.mkdir(os.path.join(folder,name))
#Parameter file
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name,"paramFile.set"), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::ModeFileRecalc")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("ResultDir","omega3p_results")
paramFile.write()
class ParameterScanCollection(object):
"""
Collection class organizing the contents of a ParameterScan folder
"""
folder = None
instName = None #Name of this instance. Set to "ParameterScanCollection" iff parent is AcdOptiProject
parent = None #AcdOptiProject OR another ParameterScanCollection (including implementations)
parentScan = None #If the scan collection is owned by a ParameterScan, this points to it
__paramfile = None
scans = None #Map of objects implementing ParameterScanInterface
parameterScanTypes = ["ParameterScan::Dummy", "ParameterScan::DummySubscan", "ParameterScan::TuneFreq",\
"ParameterScan::Scan2D", "ParameterScan::Scan2D_Tune"]
def __init__(self, folder, parent, parentScan=None):
self.folder = folder
self.parent = parent
#Construct the instance name from folder
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
self.instName = instName = os.path.split(instName)[1]
from acdOpti.AcdOptiProject import AcdOptiProject
if not isinstance(parent,ParameterScanCollection) and not isinstance(parent, AcdOptiProject):
raise ParameterScanCollectionException("Error when initializing ParameterScanCollection, "+\
"type(parent) must be AcdOptiProject or ParameterScanCollection, type was '" + str(type(parent)))
elif self.instName == "ParameterScanCollection" and not isinstance(parent, AcdOptiProject):
raise ParameterScanCollectionException("Error when initializing ParameterScanCollection, instName='"+self.instName+"', but type(parent)="+str(type(parent)))
#Load paramFile
self.__paramfile = AcdOptiFileParser_simple(os.path.join(folder, "paramFile_scanCollection.set"), 'rw')
if self.__paramfile.dataDict["fileID"] != "ParameterScan::ParameterScanCollection":
raise ParameterScanCollectionException("Error loading ParameterScanCollection: Got wrong fileID='" + self.paramFile.dataDict["fileID"] + "'")
if self.__paramfile.dataDict["instName"] != self.instName:
raise ParameterScanCollectionException("Error loading ParameterScanCollection: instName mismatch")
#Look for scans
self.scans = {}
for (scanName, scanType) in self.__paramfile.dataDict["scans"]:
childPath = os.path.join(self.folder,"scans",scanName)
if not os.path.exists(childPath):
raise ParameterScanCollectionException("Error loading ParameterScanCollection, path='" + childPath + "' does not exist")
if scanType == "ParameterScan::Dummy":
from Dummy import Dummy
self.scans[scanName] = Dummy(childPath, self)
elif scanType == "ParameterScan::DummySubscan":
from DummySubscan import DummySubscan
self.scans[scanName] = DummySubscan(childPath, self)
elif scanType == "ParameterScan::TuneFreq":
from TuneFreq import TuneFreq
self.scans[scanName] = TuneFreq(childPath,self)
elif scanType == "ParameterScan::Scan2D":
from Scan2D import Scan2D
self.scans[scanName] = Scan2D(childPath,self)
elif scanType == "ParameterScan::Scan2D_Tune":
from Scan2D_Tune import Scan2D_Tune
self.scans[scanName] = Scan2D_Tune(childPath,self)
else:
if scanType in self.parameterScanTypes or "ParameterScan::"+scanType in self.parameterScanTypes:
raise NotImplementedError("Forgot to implement support for ParameterScan '" + scanType + "'!")
raise ParameterScanCollectionException("Unknown scanType='"+scanType+"'")
#Setup parentScan
if parentScan != None:
from acdOpti.parameterScan.ParameterScanInterface import ParameterScanInterface
assert isinstance(parentScan, ParameterScanInterface)
if self.__paramfile.dataDict["parentScan"] != parentScan.instName:
raise ParameterScanCollectionException("ParentScan mismatch, got '"+self.__paramfile.dataDict["parentScan"]+"' from paramfile" )
self.parentScan = parentScan
def addNew(self, name, scanType):
"""
Try to add a new scan with the given name and tnype
ParameterScanCollectionException is raised if there is a problem (name already taken or invalid type).
Returns a reference to the newly created scan.
"""
if name in self.scans.keys():
raise ParameterScanCollectionException("Name '" + name + "' already taken")
scanFolder = os.path.join(self.folder, "scans", name)
if scanType == "ParameterScan::Dummy" or scanType == "Dummy":
from Dummy import Dummy
Dummy.createNew(scanFolder)
self.scans[name] = newScan = Dummy(scanFolder, self)
elif scanType == "ParameterScan::DummySubscan" or scanType == "DummySubscan":
from DummySubscan import DummySubscan
DummySubscan.createNew(scanFolder)
self.scans[name] = newScan = DummySubscan(scanFolder, self)
elif scanType == "ParameterScan::TuneFreq" or scanType == "TuneFreq":
from TuneFreq import TuneFreq
TuneFreq.createNew(scanFolder)
self.scans[name] = newScan = TuneFreq(scanFolder,self)
elif scanType == "ParameterScan::Scan2D" or scanType == "Scan2D":
from Scan2D import Scan2D
Scan2D.createNew(scanFolder)
self.scans[name] = newScan = Scan2D(scanFolder,self)
elif scanType == "ParameterScan::Scan2D_Tune" or scanType == "Scan2D_Tune":
from Scan2D_Tune import Scan2D_Tune
Scan2D_Tune.createNew(scanFolder)
self.scans[name] = newScan = Scan2D_Tune(scanFolder,self)
else:
if scanType in self.parameterScanTypes or "ParameterScan::"+scanType in self.parameterScanTypes:
raise NotImplementedError("Forgot to implement support for ParameterScan '" + scanType + "'!")
raise ParameterScanCollectionException("Unknown ParameterScan type '" + scanType + "'")
self.__paramfile.dataDict["scans"].pushBack(name,newScan.type)
self.__paramfile.write()
return self.scans[name]
@staticmethod
def createNew(folder, parentScanName=None):
if parentScanName == None:
#If parentScan, they are created in the same folder
os.mkdir(folder)
paramFile = AcdOptiFileParser_simple(os.path.join(folder,"paramFile_scanCollection.set"), 'w')
paramFile.dataDict.pushBack("fileID", "ParameterScan::ParameterScanCollection")
instName = folder
if instName[-1] == "/":
instName = instName[0:-1]
instName = os.path.split(instName)[1]
paramFile.dataDict.pushBack("instName", instName)
paramFile.dataDict.pushBack("scans", DataDict())
os.mkdir(os.path.join(folder,"scans"))
if parentScanName != None:
paramFile.dataDict.pushBack("parentScan", parentScanName)
else:
paramFile.dataDict.pushBack("parentScan", "")
paramFile.write()
class GroupVelocity(AnalysisInterface):
"""
Calculate the group velocity of the cell by powerFlow,
cell length (both from RFpost_local), and stored energy (Omega3P_modeInfo)
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "GroupVelocity::__init__()"
self.type = "GroupVelocity"
self.folder = folder
self.instName = name
self.runConfig = runConfig
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::GroupVelocity":
raise GroupVelocityException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
self.settings = self.__paramFile.dataDict["settings"]
def runAnalysis(self):
print "GroupVelocity::RunAnalysis()"
assert not self.lockdown
try:
surfID = int(self.settings["SurfaceID"])
except ValueError:
raise GroupVelocityException_runAna("SurfaceID setting not understood")
try:
RFpost = self.runConfig.analysis[self.settings["RFpostName"]]
except KeyError:
raise GroupVelocityException_runAna("Key for RFpostName not found")
if not RFpost.lockdown:
RFpost.runAnalysis()
try:
ModeInfo = self.runConfig.analysis[self.settings["ModeInfoName"]]
except KeyError:
raise GroupVelocityException_runAna("Key for ModeInfoName not found")
if not ModeInfo.lockdown:
ModeInfo.runAnalysis()
#So far, only analyse 1st mode
power = None
try:
powerThroughSurface = RFpost.exportResults["powerThroughSurface"]
except AcdOptiException_dataDict_getValsSingle:
raise GroupVelocityException_runAna("Couldn't find powerThroughSurface data")
if len(powerThroughSurface) == 0:
raise GroupVelocityException_runAna("powerThroughSurface data empty")
for (key, val) in powerThroughSurface:
assert key == "surf"
if val["surfaceID"] == str(surfID):
power = float(val["Power_real"])
if power == None:
raise GroupVelocityException_runAna("Surface " + str(surfID) + " not found")
#length = None
length = float(RFpost.settings["L"])/1000.0 #mm->meters
energy = None
modes = ModeInfo.exportResults.getVals("Mode")
if len(modes) == 0:
raise GroupVelocityException_runAna("No mode found")
if "TotalEnergyReal" in modes[0]:
energy = float(modes[0]["TotalEnergyReal"])
elif "TotalEnergy" in modes[0]:
energy = float(modes[0]["TotalEnergyReal"])
else:
raise GroupVelocityException_runAna("Total energy not found")
assert energy != None
#print "L =", length
#print "P =", power
#print "U =", energy
vg = length*power/energy
self.exportResults.pushBack("VG", str(vg))
self.exportResults.pushBack("VG_cp", str(100.0*vg/3e8))
self.lockdown = True
self.write()
def clearLockdown(self):
print "GroupVelocity::clearLockdown()"
self.exportResults.clear()
self.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::GroupVelocity")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("ModeInfoName", "Omega3P_modeInfo")
paramFile.dataDict["settings"].pushBack("RFpostName", "RFpost_local")
paramFile.dataDict["settings"].pushBack("SurfaceID", "")
paramFile.write()
class RFpost_local(AnalysisInterface, RFpostParser):
"""
Analysis that runs acdtool postprocess rf locally.
The output can then be parsed by the RFpost analysis.
This analysis is detected specially by the AnalysisExportedResults
GUI infoframecomponent, making it simple to edit its SolverSetup.
"""
__paramFile = None
def __init__(self, folder, name, runConfig):
print "RFpost_local::__init__()"
self.type = "RFpost_local"
self.folder = folder
self.instName = name
self.runConfig = runConfig
#Load paramFile
self.__paramFile = AcdOptiFileParser_simple(os.path.join(folder, name, "paramFile.set"), 'rw')
if self.__paramFile.dataDict["fileID"] != "Analysis::RFpost_local":
raise RFpostException("Got fileID='" + self.__paramFile.dataDict["fileID"] + "'")
self.lockdown = DataDict.boolconv(self.__paramFile.dataDict["lockdown"])
self.exportResults = self.__paramFile.dataDict["export"]
#Load RFpost solverManager
self.localSolver = AcdOptiSolverManager("rfPost.in", os.path.join(folder,name))
if self.lockdown:
self.localSolver.lockdown = True
#Load the settings
if len(self.__paramFile.dataDict.getVals("settings")) == 0:
self.__paramFile.dataDict.pushBack("settings", DataDict())
self.__paramFile.dataDict["settings"].pushBack("L","")
self.__paramFile.write()
self.settings = self.__paramFile.dataDict["settings"]
def runAnalysis(self):
print "RFpost_local::runAnalysis()"
assert not self.lockdown
#Generate the setup file
self.lockdown = True
origResultDir = self.localSolver.metaSetup['RFField']['children']['ResultDir']['value'] #Subdirectory whith the data
dataPath = os.path.join(self.folder, self.instName, "data") #Path to symlink to data folder
dataPath2 = os.path.join(dataPath, origResultDir) #Path to O3P etc. results thorough symlink
self.localSolver.metaSetup['RFField']['children']['ResultDir'].setValSingle("value", os.path.join("data", origResultDir))
self.localSolver.generateSetup()
self.localSolver.lockdown = True
#Create a symlink to avoid long folder names (ACDtool doesn't like that)
if os.path.islink(dataPath):
os.unlink(dataPath)
os.symlink(self.runConfig.finishedFolder, dataPath) #UNIX only!
#Modify the postprocess.in file to the right path
shutil.copy(os.path.join(dataPath2, "VECTOR", "postprocess.in"),\
os.path.join(self.folder, self.instName, "postprocess.in.bak"))
postFile = AcdOptiFileParser_KVC(os.path.join(dataPath2, "VECTOR", "postprocess.in"),"rw")
#print postFile.dataDict
postFile.dataDict["ModelInfo"].setValSingle("File", os.path.join(dataPath, "mesh.ncdf"))
postFile.dataDict["CheckPoint"].setValSingle("Directory", os.path.join(os.path.join(dataPath2, "VECTOR")))
postFile.write()
#Run AcdTool!
try:
AcdOptiAcdtoolWrapper.rfPost("rfPost.in", os.path.join(self.folder, self.instName))
except:
self.localSolver.metaSetup['RFField']['children']['ResultDir'].setValSingle("value", origResultDir)
self.localSolver.write()
shutil.copy(os.path.join(self.folder, self.instName, "postprocess.in.bak"),\
os.path.join(dataPath2, "VECTOR", "postprocess.in"))
os.unlink(dataPath)
raise
#Restore stuff
self.localSolver.metaSetup['RFField']['children']['ResultDir'].setValSingle("value", origResultDir)
self.localSolver.write()
shutil.copy(os.path.join(self.folder, self.instName, "postprocess.in.bak"),\
os.path.join(dataPath2, "VECTOR", "postprocess.in"))
os.unlink(dataPath)
#Parse output
ifile = open(os.path.join(self.folder, self.instName, "rfpost.out"), 'r')
fileData = ifile.read()
ifile.close()
#Save results
try:
L = float(self.settings["L"])
except ValueError:
print 'Couldnt parse self.settings["L"]'
L = -1.0;
addDic = self.parseData(fileData, L)
for (k,v) in addDic:
self.exportResults.pushBack(k,v)
self.write()
def clearLockdown(self):
print "RFpost_local::clearLockdown()"
if not self.lockdown:
return
self.exportResults.clear()
os.remove(self.localSolver.fileName)
self.lockdown = False
self.localSolver.lockdown = False
self.write()
def write(self):
self.__paramFile.dataDict.setValSingle("lockdown", str(self.lockdown))
self.__paramFile.write()
@staticmethod
def createNew(folder,name):
#Create a new folder to hold the stuff
os.mkdir(os.path.join(folder,name))
#Create a SolverSetup
AcdOptiSolverManager.createNew("acdtool_rfpost", os.path.join(folder,name))
#Parameter file
paramFile = AcdOptiFileParser_simple(os.path.join(folder,name,"paramFile.set"), "w")
paramFile.dataDict.pushBack("fileID", "Analysis::RFpost_local")
paramFile.dataDict.pushBack("lockdown", "False")
paramFile.dataDict.pushBack("export", DataDict())
paramFile.dataDict.pushBack("settings", DataDict())
paramFile.dataDict["settings"].pushBack("L","")
paramFile.write()
@classmethod
def createNew_clone(cls, folder,cloneFrom,newRunConfig):
print "RFpost_local::createNew_clone()"
#Call baseclass createNew_clone(), but don't keep the object:
#AnalysisInterface.createNew_clone(folder, cloneFrom, newRunConfig)
super(RFpost_local,cls).createNew_clone(folder,cloneFrom,newRunConfig)
#Replace the SolverSetup
os.unlink(os.path.join(folder,cloneFrom.instName,"rfPost.in.meta"))
AcdOptiSolverManager.createNew_clone(os.path.join(folder, cloneFrom.instName),cloneFrom.localSolver)
return RFpost_local(folder,cloneFrom.instName,newRunConfig)