def run(self): cName = self.parser.getArgs()[0] if self.opts.cloneCase: if self.opts.autoCasename: cName = path.join( cName, path.basename(self.opts.cloneCase) + buildFilenameExtension(self.opts.valuesDicts, self.opts.values)) if path.exists(cName): self.error( cName, "already existing (case should not exist when used with --clone-case)" ) if self.checkCase(self.opts.cloneCase, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(self.opts.cloneCase) orig = SolutionDirectory(self.opts.cloneCase, archive=None, paraviewLink=False) sol = orig.cloneCase(cName) else: if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) try: self.__lastMessage = None self.prepare(sol, cName=cName) except: if self.__lastMessage: self.__writeToStateFile(sol, self.__lastMessage + " failed") raise
def run(self): cName = self.parser.casePath() self.checkCase(cName) self.processPlotLineOptions(autoPath=cName) sol = SolutionDirectory(cName, archive=None) lam = self.getParallel(sol) self.clearCase( SolutionDirectory(cName, archive=None, parallel=lam is not None)) self.setLogname() self.checkAndCommit(sol) run = ConvergenceRunner(BoundingLogAnalyzer( progress=self.opts.progress, doFiles=self.opts.writeFiles, singleFile=self.opts.singleDataFilesOnly, doTimelines=True), silent=self.opts.progress or self.opts.silent, argv=self.parser.getArgs(), restart=self.opts.restart, server=self.opts.server, logname=self.opts.logname, compressLog=self.opts.compress, lam=lam, logTail=self.opts.logTail, noLog=self.opts.noLog, remark=self.opts.remark, parameters=self.getRunParameters(), echoCommandLine=self.opts.echoCommandPrefix, jobId=self.opts.jobId) run.createPlots(customRegexp=self.lines_, writeFiles=self.opts.writeFiles) if self.cursesWindow: self.cursesWindow.setAnalyzer(run.analyzer) self.cursesWindow.setRunner(run) run.analyzer.addTimeListener(self.cursesWindow) self.addSafeTrigger(run, sol) self.addWriteAllTrigger(run, sol) self.addToCaseLog(cName, "Starting") run.start() self.addToCaseLog(cName, "Ending") self.setData(run.data) self.reportUsage(run) self.reportRunnerData(run) return run.data
def run(self): sName = self.parser.getArgs()[0] if sName[-1] == path.sep: sName = sName[:-1] if self.parser.getOptions().tarname != None: dName = self.parser.getOptions().tarname else: if sName == path.curdir: dName = path.basename(path.abspath(sName)) else: dName = sName dName += ".tgz" if self.parser.getOptions().pyfoam: self.parser.getOptions().additional.append("PyFoam*") sol = SolutionDirectory(sName, archive=None, addLocalConfig=True, paraviewLink=False) if not sol.isValid(): self.error(sName, "does not look like real OpenFOAM-case because", sol.missingFiles(), "are missing or of the wrong type") if self.parser.getOptions().chemkin: sol.addToClone("chemkin") if self.opts.noPloyMesh: self.parser.getOptions().exclude.append("polyMesh") sol.packCase(dName, last=self.parser.getOptions().last, additional=self.parser.getOptions().additional, exclude=self.parser.getOptions().exclude, base=self.parser.getOptions().basename)
def run(self): sol = SolutionDirectory(self.parser.getArgs()[0]) if not self.opts.init: vcs = sol.determineVCS() if vcs == None: self.error("not under version control") if not vcs in self.vcsChoices: self.error("Unsupported VCS", vcs) else: vcs = self.opts.vcs vcsInter = getVCS(vcs, path=sol.name, init=self.opts.init) vcsInter.addPath(path.join(sol.name, "constant"), rules=ruleList) vcsInter.addPath(path.join(sol.name, "system"), rules=ruleList) if sol.initialDir() != None: vcsInter.addPath(sol.initialDir(), rules=ruleList) else: self.warning("No initial-directory found") # special PyFoam-files for f in ["customRegexp", "LocalConfigPyFoam"]: p = path.join(sol.name, f) if path.exists(p): vcsInter.addPath(p, rules=ruleList) # Add the usual files from the tutorials for g in ["Allrun*", "Allclean*"]: for f in glob(path.join(sol.name, g)): vcsInter.addPath(f, rules=ruleList) for a in self.opts.additional: vcsInter.addPath(a, rules=ruleList) vcsInter.commit(self.opts.commitMessage)
def run(self): if not self.opts.keepPostprocessing: self.opts.additional.append("postProcessing") for cName in self.parser.getArgs(): if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.silent): self.addLocalConfig(cName) if self.opts.verbose: print_("Clearing", cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) sol.clear( after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, removeAnalyzed=self.parser.getOptions().removeAnalyzed, keepRegular=self.parser.getOptions().keepRegular, keepParallel=self.parser.getOptions().keepParallel, keepLast=self.parser.getOptions().latest, keepInterval=self.parser.getOptions().keepInterval, clearHistory=self.parser.getOptions().clearHistory, clearParameters=self.parser.getOptions().clearParameters, additional=self.parser.getOptions().additional, functionObjectData=self.parser.getOptions( ).functionObjectData) self.addToCaseLog(cName)
def run(self): if len(self.parser.getArgs())>2: error("Too many arguments:",self.parser.getArgs()[2:],"can not be used") sName=self.parser.getArgs()[0] dName=self.parser.getArgs()[1] if path.exists(dName): if self.parser.getOptions().force: warning("Replacing",dName,"(--force option)") elif path.exists(path.join(dName,"system","controlDict")): error("Destination",dName,"already existing and a Foam-Case") elif path.isdir(dName): dName=path.join(dName,path.basename(sName)) if path.exists(dName) and not self.parser.getOptions().force: error(dName,"already existing") elif not path.exists(path.dirname(dName)): warning("Directory",path.dirname(dName),"does not exist. Creating") sol=SolutionDirectory(sName, archive=None, paraviewLink=False, addLocalConfig=True, parallel=self.opts.parallel) if sol.determineVCS()!=None and self.opts.vcs: if self.opts.chemkin or self.opts.additional or self.opts.latest: self.error("Using an unimplemented option together with VCS") vcsInter=getVCS(sol.determineVCS(), path=sol.name) vcsInter.clone(dName) return if self.parser.getOptions().chemkin: sol.addToClone("chemkin") if self.parser.getOptions().dopyfoam: sol.addToClone("customRegexp") for a in self.parser.getOptions().additional: sol.addToClone(a) if self.parser.getOptions().latest: sol.addToClone(sol.getLast()) if self.opts.symlinkMode: sol.symlinkCase( dName, followSymlinks=self.parser.getOptions().followSymlinks, maxLevel=self.opts.symlinkLevel, relPath=self.opts.symlinkRelative ) else: sol.cloneCase( dName, followSymlinks=self.parser.getOptions().followSymlinks ) self.addToCaseLog(dName,"Cloned to",dName)
def set_name(self, name): ''' handle the case renaming ''' new_path = os.path.join(os.path.dirname(self._path), name) os.rename(self._path, new_path) self._case = SolutionDirectory(new_path) self._path = new_path self.name = name
def case_setup(ci): template_case = SolutionDirectory( "template", archive=None, paraviewLink=False) case = template_case.cloneCase( "{0}{1}".format(ci.name, ci.quadrature_order) ) phase_properties = ParsedParameterFile( path.join("./diffs", ci.phase_properties_name)) phase_properties["air"]["PBEDiameterCoeffs"]["QMOMCoeffs"]["quadratureOrder"] = ci.quadrature_order # manually fix bad pyfoam parsing phase_properties["blending"]["default"]["type"] = "none" phase_properties["drag"][1]["swarmCorrection"]["type"] = "none" phase_properties.writeFileAs(path.join( case.name, "constant", "phaseProperties" )) m0 = ParsedParameterFile(path.join(template_case.name, "0", "m0")) for i in range(ci.number_of_moments): m0.header["object"] = "m" + str(i) m0["internalField"].setUniform(ci.initial_moments[i]) m0["dimensions"] = "[0 {0} 0 0 0 0 0]".format(3 * i) m0.writeFileAs(path.join(case.name, "0", "m" + str(i))) controlDict = ParsedParameterFile( path.join(case.name, "system", "controlDict") ) controlDict["functions"]["probes"]["fields"] = [ "m{0}".format(m) for m in range(ci.number_of_moments)] controlDict["endTime"] = ci.end_time controlDict["deltaT"] = ci.delta_t controlDict.writeFile()
def solution(self): """Access to a SolutionDirectory-object that represents the current solution""" if not hasattr(self,"_solution"): self._solution=SolutionDirectory(self.caseDir, archive=None) return self._solution
def recursiveCompress(self, dirName): if self.verbose > 1: print_("Recursively checking", dirName) if path.isdir(dirName): s = SolutionDirectory(dirName, archive=None, paraviewLink=False, parallel=True) if s.isValid(): try: self.compressCase(dirName) except OSError: e = sys.exc_info()[ 1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing", dirName, ":", e) return for f in listdir(dirName): name = path.join(dirName, f) try: if path.isdir(name): self.recursiveCompress(name) except OSError: e = sys.exc_info()[ 1] # Needed because python 2.5 does not support 'as e' self.warning("Problem processing", name, ":", e)
def case_setup(ci): template_case = SolutionDirectory("template", archive=None, paraviewLink=False) case = template_case.cloneCase("{0}{1}".format(ci.name, ci.nr_classes)) phase_properties = ParsedParameterFile( path.join("./diffs", ci.phase_properties_name)) phase_properties["air"]["PBEDiameterCoeffs"]["MOCCoeffs"][ "numberOfClasses"] = ci.nr_classes phase_properties["air"]["PBEDiameterCoeffs"]["MOCCoeffs"]["xi1"] = ci.dv # manually fix bad pyfoam parsing phase_properties["blending"]["default"]["type"] = "none" phase_properties["drag"][1]["swarmCorrection"]["type"] = "none" phase_properties.writeFileAs( path.join(case.name, "constant", "phaseProperties")) v = ci.dv + ci.dv * arange(ci.nr_classes) n0 = ParsedParameterFile(path.join(template_case.name, "0", "n0")) for i in range(ci.nr_classes): n0.header["object"] = "n" + str(i) n0["internalField"].setUniform(ci.Ninit(v[i])) n0.writeFileAs(path.join(case.name, "0", "n" + str(i))) controlDict = ParsedParameterFile( path.join(case.name, "system", "controlDict")) controlDict["functions"]["probes"]["fields"] = [ "n{0}".format(n) for n in range(ci.nr_classes) ] controlDict["endTime"] = ci.end_time controlDict["deltaT"] = ci.delta_t controlDict.writeFile()
def testRoundtripBlockMesh(self): blk = ParsedBlockMeshDict(SolutionDirectory(self.dest).blockMesh()) txt = str(blk) try: i = int(txt.split("blocks")[1].split("(")[0]) self.assertTrue(False) except ValueError: pass
def run(self): cName = self.parser.getArgs()[0] if self.checkCase(cName, fatal=self.opts.fatal, verbose=not self.opts.noComplain): self.addLocalConfig(cName) sol = SolutionDirectory(cName, archive=None, paraviewLink=False) self.prepare(sol, cName=cName)
def run(self): cName = self.parser.getArgs()[0] sol = SolutionDirectory(cName, archive=None) self.addLocalConfig(cName) initial = sol[0] if "U" not in initial or "p" not in initial: error("Either 'p' or 'U' missing from the initial directory", initial.baseName()) if self.opts.writep: initial["p.prepotential"] = initial["p"] initial["U.prepotential"] = initial["U"] lam = self.getParallel(sol) if self.opts.writep: writep = ["-writep"] else: writep = [] argv = ["potentialFoam"] if oldApp(): argv += [".", cName] else: argv += ["-case", cName] self.setLogname(default="Potential", useApplication=False) self.checkAndCommit(sol) run = BasicRunner(argv=argv + writep, server=self.opts.server, logname=self.opts.logname, compressLog=self.opts.compress, silent=self.opts.progress or self.opts.silent, lam=lam, logTail=self.opts.logTail, echoCommandLine=self.opts.echoCommandPrefix, noLog=self.opts.noLog) print_("Setting system-directory for potentialFoam") trig = PotentialTrigger(sol, self.opts.noCorr, self.opts.tolerance, self.opts.relTol, pRefCell=self.opts.pRefCell, pRefValue=self.opts.pRefValue, removeLibs=self.opts.removeLibs, removeFunctions=self.opts.removeFunctions) run.addEndTrigger(trig.resetIt) self.addToCaseLog(cName, "Starting") run.start() self.setData(run.data) self.addToCaseLog(cName, "Ending")
def caseDirectory(): """The directory in which the case is stored""" try: # old school paraview fName = path.dirname(paraFoamReader().FileName.GetData()) except AttributeError: fName = path.dirname(paraFoamReader().FileName) return SolutionDirectory(fName, archive=None, paraviewLink=False)
def run(self): if len(self.parser.getArgs()) != 2: error("Need two arguments.", len(self.parser.getArgs()), "found") sName = self.parser.getArgs()[0] dName = self.parser.getArgs()[1] if self.opts.include == None: include = ["*"] else: include = self.opts.include if self.opts.exclude == None: exclude = [] else: exclude = self.opts.exclude source = SolutionDirectory(sName, archive=None, paraviewLink=False) dest = SolutionDirectory(dName, archive=None, paraviewLink=False) sDir = source[-1] dDir = dest[0] if self.opts.verbose: print_(" Copying from source-time", sDir.baseName(), "to destination-time", dDir.baseName()) copied = dDir.copy(sDir, include=include, exclude=exclude, overwrite=self.opts.overwrite, mustExist=self.opts.mustExist, purge=self.opts.purge) if self.opts.verbose: if len(copied) > 0: print_(" Copied the fields", end=" ") for v in copied: print_(v, end=" ") print_() else: print_(" Nothing copied") self.addToCaseLog(dest.name, "From", sDir.name, "to", dDir.name)
def reset(self): pid = self.worker_index #os.getpid() # logger_g.info(f'{pid}') self.casename = 'baseCase_'+str(pid) self.csvfile = 'progress_'+str(pid)+'.csv' orig = SolutionDirectory(origcase,archive=None,paraviewLink=False) case = orig.cloneCase(self.casename ) control_dict = ParsedParameterFile(path.join(self.casename,"system", "controlDict")) control_dict["endTime"] = self.end_time control_dict["writeInterval"] = self.write_interval control_dict.writeFile() # remove old log files with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm {self.casename}/log.*', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm -r {self.casename}/0.* {self.casename}/[1-9]*', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories with open(f'{self.casename}/logr.remove', 'a') as fp: subprocess.run( f'rm -r {self.casename}/VTK', shell=True, stdout=fp, stderr=subprocess.STDOUT ) # remove old solution directories # subprocess.run( # f'rm -r postProcessing', # shell=True, # stderr=subprocess.STDOUT # ) self.count_parameters = 0 if self.states_type == 1: #self.actions[self.count_parameters] = self.a1[0] self.state = np.array([self.a1[0]]) elif self.states_type == 2: self.state = np.hstack((self.a1,self.reward)) return np.array(self.state)
def run(self): files = self.parser.getArgs()[0:] if len(files) == 1 and path.isdir(files[0]): sol = SolutionDirectory(self.parser.getArgs()[0], archive=None, parallel=self.opts.parallelTimes, paraviewLink=False) self.processTimestepOptions(sol) if len(self.opts.time) < 1: self.error("No time specified") globStr = self.parser.getArgs()[0] if self.opts.parallelTimes: globStr = path.join(globStr, "processor*") usedTime = sol.timeName(self.opts.time[0]) globStr = path.join(globStr, usedTime, "uniform", "profiling*") files = glob(globStr) print_("Profiling info from time", usedTime) if len(files) < 1: self.error("No profiling data found") elif len(files) > 1: lst = [] for f in files: lst.append(self.readProfilingInfo(f)) dataAll, children0, root0 = lst[0] for i in dataAll: d = dataAll[i] d["totalTimeMin"] = d["totalTime"] d["totalTimeMax"] = d["totalTime"] d["callsMin"] = d["calls"] d["callsMax"] = d["calls"] for data, children, root in lst[1:]: if root0 != root or children != children0 or data.keys( ) != dataAll.keys(): self.error( "Inconsistent profiling data. Probably not from same run/timestep" ) for i in data: d = data[i] s = dataAll[i] s["totalTime"] += d["totalTime"] s["totalTimeMin"] = min(s["totalTimeMin"], d["totalTime"]) s["totalTimeMax"] = max(s["totalTimeMax"], d["totalTime"]) s["calls"] += d["calls"] s["callsMin"] = min(s["callsMin"], d["calls"]) s["callsMax"] = max(s["callsMax"], d["calls"]) s["childTime"] += d["childTime"] for i in dataAll: d = dataAll[i] d["totalTime"] = d["totalTime"] / len(lst) d["childTime"] = d["childTime"] / len(lst) d["calls"] = d["calls"] / len(lst) self.printProfilingInfo(dataAll, children, root, True) else: data, children, root = self.readProfilingInfo(files[0]) self.printProfilingInfo(data, children, root)
def testBoundaryRead(self): blk = ParsedBlockMeshDict(SolutionDirectory(self.dest).blockMesh()) self.assertEqual(blk.convertToMeters(), 1.) self.assertEqual(len(blk.vertices()), 22) self.assertEqual(len(blk.blocks()), 5) self.assertEqual(len(blk.patches()), 6) self.assertEqual(len(blk.arcs()), 8) self.assertEqual(blk.typicalLength(), 1.25) self.assertEqual(str(blk.getBounds()), "([0.0, 0.0, 0.0], [2.0, 2.0, 0.5])")
def testTimeReplacingZippedFile(self): test = SolutionDirectory(self.theFile)["0"] self.assertEqual(len(test), 4) if foamFork() in ["openfoam", "openfoamplus" ] and foamVersionNumber() >= (4, ): extension = ".orig" else: extension = ".org" test[gammaName()] = test[gammaName() + extension] self.assertEqual(len(test), 4)
def testTimeCopy(self): test=SolutionDirectory(self.theFile) self.assertEqual(len(test),1) test["42"]=test[0] self.assertEqual(len(test),2) self.assertEqual(len(test["42"]),len(test[0])) del test["42"] self.assertEqual(len(test),1) del test[-1] self.assertEqual(len(test),0)
def additionalReconstruct(self, parameters): sol = SolutionDirectory(self.casename()) if len(sol.processorDirs()) > 0: for t in listdir(path.join(self.casename(), sol.processorDirs()[0])): try: tm = float(t) self.foamRun("reconstructParMesh", foamArgs=["-time", t]) self.foamRun("reconstructPar", foamArgs=["-time", t]) except ValueError: print "Skipping", t
def __init__(self, input): """:param input: either a SolutionDirectory-instance or a string with a pathname""" if isinstance(input, SolutionDirectory): self.__sol = input elif isinstance(input, string_types): self.__sol = SolutionDirectory(input, paraviewLink=False, archive=None) else: error(type(input), "not supported")
def testTimeDirectoryAdding(self): test = SolutionDirectory(self.theFile)["0"] self.assertEqual(len(test), 4) test["U2"] = test["U"] self.assertEqual(len(test), 5) test["nix"] = 23 self.assertEqual(len(test), 6) del test["nix"] self.assertEqual(len(test), 5) del test["U2"] self.assertEqual(len(test), 4)
def run(self): cName = self.parser.casePath() times = self.processTimestepOptions( SolutionDirectory(cName, archive=None)) if len(times) < 1: self.warning("Can't continue without time-steps") return lam = self.getParallel(SolutionDirectory(cName, archive=None)) data = [] for i, t in enumerate(times): print_(" Running for t=", t) run = UtilityRunner( argv=self.parser.getArgs() + ["-time", t], silent=self.opts.progress or self.opts.silent, server=self.opts.server, logname="%s.%s.t=%s" % (self.opts.logname, self.parser.getApplication(), t), compressLog=self.opts.compress, logTail=self.opts.logTail, noLog=self.opts.noLog, echoCommandLine=self.opts.echoCommandPrefix, lam=lam) self.addToCaseLog(cName, "Starting for t=%s", t) run.start() self.setData({t: run.data}) self.addToCaseLog(cName, "Ending") self.reportUsage(run) self.reportRunnerData(run) data.append(run.data) return data
def run(self): if not self.opts.keepPostprocessing: self.opts.additional.append("postProcessing") notCleared=[] if self.opts.dryRun: self.opts.verbose=True self.opts.verboseClear=True for cName in self.parser.getArgs(): if self.checkCase(cName,fatal=self.opts.fatal,verbose=not self.opts.silent): if self.opts.allcleanScript: scr=path.join(cName,"Allclean") if(path.exists(scr)): if self.opts.verbose or self.opts.verboseClear: print("Executing",scr) execute(scr,workdir=cName) try: self.addLocalConfig(cName) if self.opts.verbose: print_("Clearing",cName) sol=SolutionDirectory(cName, archive=None, parallel=True, paraviewLink=False) sol.clear(after=self.parser.getOptions().after, processor=self.parser.getOptions().processor, pyfoam=self.parser.getOptions().pyfoam, vtk=self.parser.getOptions().vtk, verbose=self.parser.getOptions().verboseClear, removeAnalyzed=self.parser.getOptions().removeAnalyzed, keepRegular=self.parser.getOptions().keepRegular, keepParallel=self.parser.getOptions().keepParallel, keepLast=self.parser.getOptions().latest, keepInterval=self.parser.getOptions().keepInterval, keepTimes=self.opts.keepTimes, clearHistory=self.parser.getOptions().clearHistory, clearParameters=self.parser.getOptions().clearParameters, additional=self.parser.getOptions().additional, dryRun=self.opts.dryRun, functionObjectData=self.parser.getOptions().functionObjectData) self.addToCaseLog(cName) except OSError: e = sys.exc_info()[1] # compatible with 2.x and 3.x self.warning("Can not clear",cName,"because of OSError",e) notCleared.append(cName) if len(notCleared)>0: self.warning("These case not cleared because of OS-problems:", ", ".join(notCleared))
def run(self): cName = self.parser.casePath() self.checkCase(cName) sol = SolutionDirectory(cName, archive=None) print_("Clearing out old timesteps ....") sol.clearResults() self.checkAndCommit(SolutionDirectory(cName, archive=None)) run = BasicRunner(argv=self.parser.getArgs(), server=self.opts.server, logname="PyFoamMeshUtility") self.addLibFunctionTrigger(run, sol) self.addToCaseLog(cName, "Starting") run.start() self.setData(run.data) sol.reread(force=True) self.addToCaseLog(cName, "Ending") if sol.latestDir() != sol.initialDir(): for f in listdir(path.join(sol.latestDir(), "polyMesh")): system("mv -f " + path.join(sol.latestDir(), "polyMesh", f) + " " + sol.polyMeshDir()) print_("\nClearing out new timesteps ....") sol.clearResults() else: print_("\n\n No new timestep. Utility propably failed")
def setUp(self): self.dest = mktemp() SolutionDirectory(damBreakTutorial(), archive=None, paraviewLink=False).cloneCase(self.dest) if oldApp(): pathSpec = [path.dirname(self.dest), path.basename(self.dest)] else: pathSpec = ["-case", self.dest] run = UtilityRunner(argv=["blockMesh"] + pathSpec, silent=False, server=False) run.start()
def __init__(self, folder): self._folder = folder self._case = SolutionDirectory(folder) self._path = self._case.name self.name = os.path.basename(self._path) self.__dict__.update({ 'set_snappyHexMesh': partial(self.set_dictSettings, 'snappyHexMeshDict'), 'set_fvSchemes': partial(self.set_dictSettings, 'fvSchemes'), 'set_fvSolution': partial(self.set_dictSettings, 'fvSolution'), })
def testTimeDirectoryBasicContainerStuff(self): test = SolutionDirectory(self.theFile)["0"] self.assertEqual(len(test), 4) self.assert_(gammaName() in test) self.assert_("nix" not in test) tf = test["U"] self.assertEqual(type(tf), SolutionFile) self.assert_(FileBasis in tf.__class__.__mro__) self.assertRaises(KeyError, test.__getitem__, "nix") self.assertRaises(TypeError, test.__getitem__, 42) lst = [] for v in test: lst.append(v.baseName()) self.assert_(gammaName() in lst) self.assertEqual(len(lst), len(test))