def testExistsRedirect(self):
data = FoamStringParser(self.data, doMacroExpansion=True)
self.assertEqual("a" in data["dictA"], True)
self.assertEqual("b" in data["dictC"], True)
data = FoamStringParser(self.data, doMacroExpansion=False)
self.assertEqual("a" in data["dictA"], True)
self.assertEqual("b" in data["dictC"], False)
def testOneLineComment(self):
p1=FoamStringParser("// test dings 2;")
self.assertEqual(str(p1),"")
p1=FoamStringParser("""
// test dings 2;
test2 dings 3;""")
self.assertEqual(str(p1),"test2 dings 3 ;\n")
p1=FoamStringParser("test ding; // test dings 2;")
self.assertEqual(p1["test"],"ding")
def testParseBool(self):
p1=FoamStringParser("test yes;")
self.assertEqual(p1["test"],True)
self.assertEqual(p1["test"],"yes")
p1=FoamStringParser("test on;")
self.assertEqual(p1["test"],"on")
self.assertEqual(p1["test"],True)
p1=FoamStringParser("test off;")
self.assertEqual(p1["test"],False)
p1=FoamStringParser("test no;")
self.assertEqual(p1["test"],False)
def testMultiLineComment(self):
p=FoamStringParser("""
/* this should never be read
This too */
test dings 2;""")
self.assertEqual(str(p),"test dings 2 ;\n")
p=FoamStringParser("""
/* this should never be read
This too */
test dings 2;
/* Here goes the next comment */""")
self.assertEqual(str(p),"test dings 2 ;\n")
def testMakeDictionaryRedirect(self):
val = """
a {
b 2;
}
c {
$a;
d 3;
}
"""
d = FoamStringParser(val, doMacroExpansion=True)
self.assertEqual(str(d), "a\n{\n b 2;\n}\nc\n{\n $a;\n d 3;\n}\n")
d = FoamStringParser(val, doMacroExpansion=False)
self.assertEqual(str(d), "a\n{\n b 2;\n}\nc\n{\n $a ;\n d 3;\n}\n")
def testCommentOutElements(self):
p1=FoamStringParser("""things (
// test dings 2;
nix // Hepp
);""")
self.assertEqual(len(p1["things"]),1)
self.assertEqual(p1["things"][0],"nix")
def testSimpleSubstNoMacro(self):
p1 = FoamStringParser("""
a 10;
b $a;
""",
doMacroExpansion=False)
self.assertEqual(p1["b"], "$a")
def testPreListUniformNested(self):
p=FoamStringParser("test 2 (5 {42.1} 5 (1 2 3 4 5)) ;")
# p=FoamStringParser("test 2 (5 (42.1 42.1 42.1 42.1 42.1) 5 (1 2 3 4 5)) ;")
self.assertEqual(len(p["test"]),2)
self.assertEqual(len(p["test"][0]),5)
self.assertEqual(p["test"][0][2],42.1)
self.assertEqual(p["test"][1][2],3)
def testFalseReactionBug(self):
p1=FoamStringParser("""things (
test // test = dings 2;
nix
);""")
self.assertEqual(len(p1["things"]),2)
self.assertEqual(p1["things"][0],"test")
def testNestedComment(self):
p=FoamStringParser("""
/* this should never be read
/* that is never there */
This too */
test dings 2;""")
self.assertEqual(str(p),"test dings 2 ;\n")
def testRedirectNoMacro(self):
p1=FoamStringParser("""
a 10;
b a;
c ${${b}}; // returns 10, since $b returns 'a', and $a returns 10
""",doMacroExpansion=False)
self.assertEqual(p1["b"],"a")
self.assertEqual(p1["c"],"${${b}}")
def testNestedValues(self):
data=FoamStringParser(
self.data,
doMacroExpansion=True)
self.assertEqual(data["dictA"]["a"],data["dictB"]["d"]["a"])
data["dictB"]["d"]["a"]=42
self.assertEqual(data["dictA"]["a"],1)
self.assertEqual(42,data["dictB"]["d"]["a"])
def testSubdictSubst(self):
p1=FoamStringParser("""
subdict
{
a 10;
}
b $subdict.a;
""",doMacroExpansion=True)
self.assertEqual(p1["b"],10)
def testNestedValues(self):
data = FoamStringParser(self.data, doMacroExpansion=True)
self.assertEqual(data["dictA"]["dictB"]["d"], data["dictA"]["c"])
self.assertEqual(data["dictA"]["dictB"]["dictC"]["dictD"]["g"],
data["f"])
self.assertEqual(data["dictA"]["dictB"]["dictC"]["dictD"]["c"],
data["dictA"]["dictB"]["a"])
self.assertEqual(data["dictA"]["dictB"]["dictC"]["dictD"]["e"],
data["dictA"]["dictB"]["dictC"]["d"])
def testWriteRedirect(self):
data = FoamStringParser(self.data, doMacroExpansion=True)
self.assertEqual(data["dictA"]["a"], 1)
self.assertEqual(data["dictB"]["a"], 4)
self.assertEqual(data["dictC"]["a"], 6)
data["dictC"]["a"] = 16
self.assertEqual(data["dictA"]["a"], 1)
self.assertEqual(data["dictB"]["a"], 4)
self.assertEqual(data["dictC"]["a"], 16)
data["dictA"]["f"] = 17
self.assertEqual(data["dictA"]["f"], 17)
self.assertEqual(data["dictA"]["f"], 17)
self.assertEqual(data["dictA"]["f"], 17)
def testReactionList(self):
p=FoamStringParser("""test (
someReaction
0.5 H2 + O2 = H2O
(1000 0 10)
otherReaction
C + O2 = CO2
((1000 0 10) (3 4 5))
);""")
self.assertEqual(type(p["test"][0]),str)
self.assertEqual(type(p["test"][1]),str)
self.assertEqual(type(p["test"][2]),Vector)
self.assertEqual(type(p["test"][3]),str)
self.assertEqual(type(p["test"][4]),str)
self.assertEqual(type(p["test"][5]),list)
def testReadRedirect(self):
data = FoamStringParser(self.data, doMacroExpansion=True)
self.assertEqual(data["dictA"]["a"], 1)
self.assertEqual(data["dictB"]["a"], 4)
self.assertEqual(data["dictC"]["a"], 6)
self.assertEqual(data["dictA"]["b"], 2)
self.assertEqual(data["dictB"]["b"], 2)
self.assertEqual(data["dictC"]["b"], 2)
self.assertEqual(data["dictB"]["d"], 5)
self.assertEqual(data["dictC"]["d"], 7)
self.assertEqual(data["dictA"]["c"], 3)
self.assertEqual(data["dictB"]["c"], 3)
self.assertEqual(data["dictC"]["c"], 9)
def testParentDictNoMacro(self):
p1=FoamStringParser("""
a 10;
subdict
{
b $..a; // double-dot takes scope up 1 level, then 'a' is available
subsubdict
{
c $:a; // colon takes scope to top level, then 'a' is available
d $...a;
}
}
""",doMacroExpansion=False)
self.assertEqual(p1["subdict"]["b"],"$..a")
self.assertEqual(p1["subdict"]["subsubdict"]["c"],"$:a")
self.assertEqual(p1["subdict"]["subsubdict"]["d"],"$...a")
def readCustomPlotInfo(rawData, useName=None):
"""Determines which of the three possible formats for custom-plotting is used
and returns a list of CustomPlotInfo-objects
:param rawData: a string that contains the raw data"""
info = []
try:
data = FoamStringParser(rawData,
duplicateCheck=True,
duplicateFail=True)
for k, d in iteritems(data.data):
info.append(CustomPlotInfo(d, name=k))
except PyFoamParserError:
for i, l in enumerate(rawData.split('\n')):
if len(l) > 0:
name = useName
if i > 0 and name != None:
name += ("_%d" % i)
info.append(CustomPlotInfo(l, name=name))
return info
def run(self):
decomposeParWithRegion = (foamVersion() >= (1, 6))
if self.opts.keeppseudo and (not self.opts.regions
and self.opts.region == None):
warning(
"Option --keep-pseudocases only makes sense for multi-region-cases"
)
if decomposeParWithRegion and self.opts.keeppseudo:
warning(
"Option --keep-pseudocases doesn't make sense since OpenFOAM 1.6 because decomposePar supports regions"
)
nr = int(self.parser.getArgs()[1])
if nr < 2:
error("Number of processors", nr, "too small (at least 2)")
case = path.abspath(self.parser.getArgs()[0])
method = self.opts.method
result = {}
result["numberOfSubdomains"] = nr
result["method"] = method
coeff = {}
result[method + "Coeffs"] = coeff
if self.opts.globalFaceZones != None:
try:
fZones = eval(self.opts.globalFaceZones)
except SyntaxError:
fZones = FoamStringParser(self.opts.globalFaceZones,
listDict=True).data
result["globalFaceZones"] = fZones
if method in ["metis", "scotch", "parMetis"]:
if self.opts.processorWeights != None:
weigh = eval(self.opts.processorWeights)
if nr != len(weigh):
error("Number of processors", nr, "and length of", weigh,
"differ")
coeff["processorWeights"] = weigh
elif method == "manual":
if self.opts.dataFile == None:
error("Missing required option dataFile")
else:
coeff["dataFile"] = "\"" + self.opts.dataFile + "\""
elif method == "simple" or method == "hierarchical":
if self.opts.n == None or self.opts.delta == None:
error("Missing required option n or delta")
n = eval(self.opts.n)
if len(n) != 3:
error("Needs to be three elements, not", n)
if nr != n[0] * n[1] * n[2]:
error("Subdomains", n, "inconsistent with processor number",
nr)
coeff["n"] = "(%d %d %d)" % (n[0], n[1], n[2])
coeff["delta"] = float(self.opts.delta)
if method == "hierarchical":
if self.opts.order == None:
error("Missing reuired option order")
if len(self.opts.order) != 3:
error("Order needs to be three characters")
coeff["order"] = self.opts.order
else:
error("Method", method, "not yet implementes")
gen = FoamFileGenerator(result)
if self.opts.test:
print_(str(gen))
return -1
else:
f = open(path.join(case, "system", "decomposeParDict"), "w")
writeDictionaryHeader(f)
f.write(str(gen))
f.close()
if self.opts.clear:
print_("Clearing processors")
for p in glob(path.join(case, "processor*")):
print_("Removing", p)
rmtree(p, ignore_errors=True)
def testInputMode2(self):
p1=FoamStringParser('#inputMode overwrite\n')
p1=FoamStringParser('#inputMode overwrite;\n')
def testNewStyle(self):
data = FoamStringParser(newStyle)
ci = CustomPlotInfo(data["testit"])
self.assertEqual(ci.expr, "Integral of CO2 = (%f%)")
self.assertEqual(ci.nr, 1)
self.assertEqual(ci.accumulation, "first")
def testCustomCounter(self):
data = FoamStringParser(newStyle2)
ci = CustomPlotInfo(data["testit"])
self.assertEqual(ci.nr, 1)
ci = CustomPlotInfo(data["time"])
self.assertEqual(ci.nr, 2)
def testRemoveList(self):
p1=FoamStringParser('#remove (nix da) ;\n')
p1=FoamStringParser('#remove (nix da)\n')
def setUp(self):
self.parse=FoamStringParser("""
aValue 1;
".*Value" 2;
abValue 3;
""")
def testInputMode(self):
p1=FoamStringParser('#inputMode merge\n')
p1=FoamStringParser('#inputMode merge foobar\n')
def testParseInteger(self):
p1=FoamStringParser("test 1;")
self.assertEqual(p1["test"],1)
def testInputMode3(self):
p1=FoamStringParser('#inputMode error\n')
def testInputMode4(self):
p1=FoamStringParser('#inputMode default\n')
def testSimpleSubst(self):
p1=FoamStringParser("""
a 10;
b $a;
""",doMacroExpansion=True)
self.assertEqual(p1["b"],10)
