class TestPrepareASTKCase(UT.TestCase):
def setUp(self):
self.tmp_dir = TmpDir("manipulate_astk_parameters")
def tearDown(self):
self.tmp_dir.clean()
def test_be_built_with_default_params(self):
cfg_def = AS.AstkBuilder().build_default_cfg()
case = AS.build_case("forma01a")
case_cfg = case.export_bld.get(AS.Cfg)
self.assert_(case_cfg is not cfg_def)
self.assert_(case_cfg.equal(cfg_def))
def test_add_existing_comm_and_med_files(self):
case = AS.build_case("c")
bld = case.export_bld
comm = get_data("forma01a.comm")
case.use(AS.CommFile(comm))
self.assertEqual(bld.get(AS.CommFile).fname, comm)
med = get_data("forma01a.mmed")
case.use(AS.MedFile(med))
self.assertEqual(bld.get(AS.MedFile).fname, med)
self.assertRaises(IOError, AS.CommFile, "wrong-file")
self.assertRaises(IOError, AS.MedFile, "wrong-file")
def test_add_study_case_from_smesh_entry(self):
std = self.std
smesh = std.sstd.load_meshes_from(SAT.get_data("forma01a.mmed"))[0]
case = std.add_case("from-smesh-entry")
mesh_entry = case.use(aster_s.SMeshEntry(smesh.node.entry))
self.assertEqual(mesh_entry.node.give_source(), smesh.node)
self.assertEqual(mesh_entry.read_name(), smesh.read_name())
def test_build_med_file_from_smesh_entry_for_astk_case(self):
std = self.std
mesh = std.sstd.load_meshes_from(SAT.get_data("forma01a.mmed"))[0]
wdir = self.tmp_dir.add("mesh_file_for_astk")
med_fname = osp.join(wdir, "%s.mmed")
cases = []
for idx in range(3):
case = std.add_case("c%i" % idx)
case._aster_case = astk.build_case("acs")
cases.append(case)
def test_build_export_file(self):
rep = self.tmp_dir.add("build")
comm = get_data("forma01a.comm")
med = get_data("forma01a.comm")
cfg = AS.Cfg()
cfg.add("v", AS.Param("version", "STA10.0"))
cfg.add("name", AS.Param("nomjob"))
cfg.add("m", AS.Param("mode", "bash"))
cfg.add("n", AS.Attr("nb-cpu", 2))
bld = AS.ExportFileBuilder("forma01-case")
bld.working_dir = rep
bld.add(cfg)
bld.add(AS.RMessFile())
bld.add(AS.CommFile(comm))
bld.add(AS.MedFile(med))
bld.add(AS.RResuFile())
bld.add(AS.RRMedFile())
bld.add(AS.Base())
fname = bld.write().fname
fpat = osp.join(rep, "forma01-case")
self.assertEqual(fname, fpat + ".export")
res = [
"P version STA10.0",
"P nomjob forma01-case",
"P mode bash",
"A nb-cpu 2",
"F comm %s D 1" % comm,
"F mmed %s D 20" % med,
"F mess %s R 6" % (fpat + ".mess"),
"F resu %s R 8" % (fpat + ".resu"),
"F rmed %s R 80" % (fpat + ".rmed"),
"R base %s RC 0" % (fpat + "base"),
]
fid = open(fname)
expf = fid.read()
for line in res:
self.assert_(line in expf, "not found : %s" % line)
fid.close()
def test_update_case_on_new_entries(self):
std = self.std
case = self.case
comms = [aster_s.CommFile(name).build(std) for name in ("c1", "c2")]
med_fname = ST.get_data("forma01a.mmed")
mesh = std.sstd.load_meshes_from(med_fname)[0]
case.use(aster_s.CommEntry(comms[0].node.entry))
case.use(aster_s.MedFile("m"))
editor = AM.edit(self.mod, self.case)
datas = [editor._params[key] for key in ("comm", "mesh")]
for data in datas:
data._selector.setCurrentIndex(0)
blds = [data._data_builder for data in datas]
blds[0]._brw_node = comms[1].node
blds[1]._brw_node = mesh.node
editor.build_case()
centry = case.get(aster_s.CommEntry)
self.assertEqual(centry.node.give_source().entry, comms[1].node.entry)
self.assert_(not case.get(aster_s.MedFile))
self.assert_(case.get(aster_s.SMeshEntry))
def setUp(self):
self.mod = AM.GuiBuilder().give_mod()
self.std = self.mod.give_aster_study()
self.med_fname = ST.get_data("forma01a.mmed")
compos = (aster_s.CommFile("c"), aster_s.MedFile("m"))
felts = [compo.build(self.std) for compo in compos]
fentries = [felt.node.entry for felt in felts]
case.use(aster_s.CommEntry(felts[0].node.entry))
case.use(aster_s.MedEntry(felts[1].node.entry))
editor = AM.edit(self.mod, case)
sels = [editor._params[key] for key in ("comm", "mesh")]
blds = [sel._data_builder for sel in sels]
self.assertEqual([bld.brw_entry.text() for bld in blds], ["c", "m"])
self.assertEqual([bld._brw_node.entry for bld in blds], fentries)
idxs = [sel._selector.currentIndex() for sel in sels]
self.assertEqual(idxs, [0, 0])
def test_edit_mesh_entry(self):
case = self.case
med_fname = ST.get_data("forma01a.mmed")
mentry = self.std.sstd.load_meshes_from(med_fname)[0].node.entry
case.use(aster_s.SMeshEntry(mentry))
editor = AM.edit(self.mod, case)
sels = [editor._params[key] for key in ("comm", "mesh")]
bld = sels[1]._data_builder
self.assertEqual(bld.brw_entry.text(), "MeshCoude")
self.assertEqual(bld._brw_node.entry, mentry)
idxs = [sel._selector.currentIndex() for sel in sels]
self.assertEqual(idxs, [0, 0])
def test_edit_astk_parameters(self):
case = self.case
cfg = case.get(aster_s.AstkParams)
cfg["time"] = 350
cfg["mode"] = "batch"