Example #1
0
    def __init__(self, folder, meshInstance):
        print "AcdOptiRunConfig::__init__()"
        self.folder = folder
        self.meshInstance = meshInstance
        self.status = "not_initialized"
        
        #Construct the instance name from folder
        instname = folder
        if instname[-1] == "/":
            instname = instname[0:-1]
        self.instName = instname = os.path.split(instname)[1]
        
        #Load the param file
        try:
            print os.path.join(self.folder, "paramFile.set")
            self.__paramFile = AcdOptiFileParser_simple(\
                os.path.join(self.folder, "paramFile.set"), 'rw')
        except IOError:
            raise AcdOptiException_runConfig_loadFail("File paramFile.set not found")

        if self.__paramFile.dataDict.getValSingle("fileID") != "runConfigParamFile":
            raise AcdOptiException_runConfig_loadFail\
                ("Wrong fileID, got \""+ self.__paramFile.dataDict.getValSingle("fileID")+"\" while loading paramFile")                
        if self.instName != self.__paramFile.dataDict.getValSingle("instName"):
            raise AcdOptiException_runConfig_loadFail("instName doesn't match folder name, expected='"+self.instName+"', got '"+self.__paramFile.dataDict.getValSingle("instName")+"'")
        
        self.status = self.__paramFile.dataDict.getValSingle("status")
        if not self.status in self.statuses:
            raise AcdOptiException_runConfig_loadFail("Status '" + self.status + "' not valid")
        
        self.stageName = self.__paramFile.dataDict.getValSingle("stageName")
        if self.stageName == "":
            self.stageName = None
        if self.stageName and self.status == "initialized":
            raise AcdOptiException_runConfig_loadFail("StageName != None while status='" + self.status + "'")
        
        #Generate stageFolder, stageFile, finishedFolder from stageName and status
        if self.statuses.index(self.status) >= self.statuses.index("staged"): 
            self.stageFolder = os.path.join(self.folder,"stage",self.stageName)
            if not os.path.isdir(self.stageFolder):
                raise AcdOptiException_runConfig_loadFail("StageFolder '" + self.stageFolder + "' does not exist, but status='" + self.status + "'")
            
            self.stageFile = os.path.join(self.folder, "stage", self.stageName) + ".tar.gz"
            if not os.path.isfile(self.stageFile):
                raise AcdOptiException_runConfig_loadFail("StageFile '" + self.stageFile + "' does not exist, but status='" + self.status + "'")
        if self.status == "finished":
            self.finishedFolder = os.path.join(self.folder, "finished", self.stageName)
            if not os.path.isdir(self.finishedFolder):
                raise AcdOptiException_runConfig_loadFail("FinishedFolder '" + self.finishedFolder + "' does not exist, but status='" + self.status + "'")
            
#        self.stageFolder = self.__paramFile.dataDict.getValSingle("stageFolder")
#        if self.stageFolder == "":
#            self.stageFolder = None
#        
#        self.stageFile = self.__paramFile.dataDict.getValSingle("stageFile")
#        if self.stageFile == "":
#            self.stageFile = None
#        
#        self.finishedFolder = self.__paramFile.dataDict.getValSingle("finishedFolder")
#        if self.finishedFolder == "":
#            self.finishedFolder = None
#            assert self.status != "finished"
        
        #Sanity check on folders for staged- and finished data:
        if not os.path.isdir(os.path.join(self.folder, "stage")):
            raise AcdOptiException_runConfig_loadFail("stage folder not found")
        if not os.path.isdir(os.path.join(self.folder, "finished")):
            raise AcdOptiException_runConfig_loadFail("finished folder not found")
        if not os.path.isdir(os.path.join(self.folder, "analysis")):
            raise AcdOptiException_runConfig_loadFail("analysis folder not found")
        
        #Load the solverSetups
        solverSetupNames = self.__paramFile.dataDict.getVals("solverSetup")
        self.solverSetups = []
        for ssName in solverSetupNames:
            self.solverSetups.append(AcdOptiSolverSetup(ssName, self))
        
        #Load the runner
        runnerType  = self.__paramFile.dataDict["runnerType"]
        self.runner = AcdOptiRunner.getRunner(runnerType, self)
        
        #Load any analysis specified by the paramFile
        anaDict = self.__paramFile.dataDict["analysis"]
        self.analysis = {}
        for (anaName, anaOptions) in anaDict:
            print anaName, anaOptions
            if anaName in self.analysis:
                raise KeyError("Analysis name '" + anaName + "' encountered twice")
            self.analysis[anaName] = AnalysisInterface.loadAnalysisByDict(anaOptions, os.path.join(self.folder, "analysis"), self)
    
        #Refresh lockdowns
        for solver in self.solverSetups:
            solver.refreshLockdown()
        self.runner.refreshLockdown()
        
        self.runner.write()
        
        #Check if we have an old file format, and if so write() to convert to new format
        if len(self.__paramFile.dataDict.getVals("stageFolder")):
            print "Updating to new file format without full paths specified (relocatable projects!)"
            self.__paramFile.dataDict.delItem("stageFolder")
            self.__paramFile.dataDict.delItem("stageFile")
            self.__paramFile.dataDict.delItem("finishedFolder")
            self.__paramFile.write()
Example #2
0
    def createNew(folder, runnerType, solverTypes=None):
        """
        Create a new RunConfig, if wanted with ready-made
        SolverSetups and Runners created and attached.
        
        Input:
        - Folder      : In which folder to store the setup files etc.
        - runnerType  : String with the runner type wanted (example: Hopper)
        - solverTypes : String or list of strings with the types of SolverSetups wanted
                        (as accepted by AcdOptiSolverSetup.createNew()).
                        If None, don't attach any solvers
        """
        print "AcdOptiRunConfig::createNew(), folder=" + folder
        
        #Construct the instance name from folder
        instname = folder
        if instname[-1] == "/":
            instname = instname[0:-1]
        instname = os.path.split(instname)[1]
        if os.path.isdir(folder):
            raise AcdOptiException_runConfig_createFail ("Folder \"" + folder + "\" already exists")
        os.mkdir(folder)

        #Create the SolverSetups:
        solverSetups = []
        if solverTypes == None:
            pass #To simplify the "else" at the end...
        elif type(solverTypes) == str:
            solverSetups.append(AcdOptiSolverSetup.createNew(solverTypes, folder))
        elif type(solverTypes) == list:
            for st in solverTypes:
                solverSetups.append(AcdOptiSolverSetup.createNew(st, folder))
        else:
            raise AcdOptiException_runConfig_createFail ("Expected solverTypes to be a string or list of strings, got " + str(solverTypes))

        #Create the runner
        AcdOptiRunner.createNew(runnerType, folder)

        #Create the paramFile
        paramFile = AcdOptiFileParser_simple(\
            os.path.join(folder, "paramFile.set"), 'w')
        paramFile.dataDict.pushBack("fileID", "runConfigParamFile")
        paramFile.dataDict.pushBack("instName", instname)
        if len(solverSetups):
            paramFile.dataDict.pushBack("status", "initialized")
        else:
            paramFile.dataDict.pushBack("status", "not_initialized")
        paramFile.dataDict.pushBack("stageName", "")
#        paramFile.dataDict.pushBack("stageFolder", "")
#        paramFile.dataDict.pushBack("stageFile", "")
#        paramFile.dataDict.pushBack("finishedFolder", "")

        #Pushback all solverSetups under the same key
        for ssName in solverSetups:
            paramFile.dataDict.pushBack("solverSetup", ssName)
        #Runner type
        paramFile.dataDict.pushBack("runnerType", runnerType) 
        
        #Analysis dictionary
        paramFile.dataDict.pushBack("analysis", DataDict())
        
        paramFile.write()
        
        #Create the staging folder
        os.mkdir(os.path.join(folder, "stage"))

        #Create the finished folder
        os.mkdir(os.path.join(folder, "finished"))
        
        #Create the analysis folder
        os.mkdir(os.path.join(folder,"analysis"))