def build_case_from_brw_entry(self, std, case):
"""Add a command file from the object browser to the Aster case"""
node = self._brw_node
if node:
if ST.is_eficas_file(node):
efile = ST.attach_eficas_file(node)
case.use(aster_s.CommFile(efile.read_fname()))
else:
case.use(aster_s.CommEntry(node.entry))
def test_add_study_case_from_element_entry(self):
std = self.std
case = std.add_case("from-elt-file")
comm_file = case.use(aster_s.CommFile("fname.comm"))
case = std.add_case("from-elt-entry")
comm_ref = case.use(aster_s.CommEntry(comm_file.node.entry))
self.assertEqual(comm_ref.node.give_source(), comm_file.node)
self.assertEqual(comm_ref.read_name(), comm_file.read_name())
med_entry = aster_s.MedEntry(comm_file.node.entry)
self.assertRaises(TypeError, case.use, med_entry)
def test_build_astk_case(self):
acfg = astk.Cfg()
acfg.add("name", astk.Param("n"))
comm = __file__
mmed = UT.__file__
case = self.std.add_case("a")
case.use(aster_s.AstkParams(acfg))
case.use(aster_s.CommFile(comm))
acs = case.build_astk_case()
bld = acs.export_bld
self.assert_(bld.working_dir is None)
cfg = bld.get(astk.Cfg)
self.assert_(cfg.equal(acfg))
self.assertEqual(bld.name, "a")
self.assertEqual(bld.get(astk.CommFile).fname, comm)
self.assert_(not bld.get(astk.MedFile))
case.use(aster_s.WorkingDir("/tmp/a"))
acs = case.build_astk_case()
self.assertEqual(acs.export_bld.working_dir, "/tmp/a")
case.use(aster_s.MedFile(mmed))
case.write_name("c")
acs = case.build_astk_case()
bld = acs.export_bld
self.assertEqual(bld.name, "c")
self.assertEqual(bld.get(astk.MedFile).fname, mmed)
case.use(aster_s.HasBaseResult())
acs = case.build_astk_case()
bld = acs.export_bld
self.assert_(bld.get(astk.Base))
comm_file = case.get(aster_s.CommFile)
med_file = case.get(aster_s.MedFile)
case = self.std.add_case("d")
case.use(aster_s.CommEntry(comm_file.node.entry))
case.use(aster_s.MedEntry(med_file.node.entry))
acs = case.build_astk_case()
bld = acs.export_bld
self.assertEqual(bld.get(astk.CommFile).fname, comm)
self.assertEqual(bld.get(astk.MedFile).fname, mmed)
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 test_copy_study_case_building_objects(self):
root = AS.Elt(self.std.node.add_node("root"), AS.Elt)
dest = AS.Elt(self.std.node.add_node("dest"), AS.Elt)
sfile_fact = aster_s.CommFile("fcomm")
sfile = sfile_fact.build(root)
copy = sfile.copy_to(dest)
self.assert_(copy is not dest)
self.assert_(copy.node.parent is dest.node)
self.assertEqual(copy.read_name(), "fcomm")
self.assertEqual(copy.read_fname(), "fcomm")
self.assert_(copy.sfile.load_type() is aster_s.CommFile)
self.assert_(isinstance(copy, AS.File))
version = aster_s.Value("version", "STA10.0")
velt = version.build(root)
copy = velt.copy_to(dest)
self.assert_(ST.load_cls(copy.node) is aster_s.Value)
entry_compo = aster_s.CommEntry(sfile.node.entry)
centry = entry_compo.build(root)
copy = centry.copy_to(dest)
self.assertEqual(copy.node.give_source().entry,
centry.node.give_source().entry)
compos = [aster_s.CommFile(""), aster_s.MedFile("")]
felts = [case.use(compo) for compo in compos]
self.assert_([felt.read_fname() for felt in felts], [None, None])
editor = AM.edit(self.mod, case)
fnames = [
editor._params[key]._data_builder.fname_entry.text()
for key in ("comm", "mesh")
]
self.assertEqual(fnames, ["", ""])
def test_edit_comm_and_med_entries(self):
case = self.case
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)