def test_UnitDefinition_isVariantOfSubstancePerTime_4(self):
ud = libsbml.UnitDefinition(2,2)
dim = ud.createUnit()
dim.setKind(libsbml.UnitKind_forName("dimensionless"))
perTime = ud.createUnit()
perTime.setKind(libsbml.UnitKind_forName("second"))
perTime.setExponent(-1)
u = ud.createUnit()
self.assertEqual( False, ud.isVariantOfSubstancePerTime() )
u.setKind(libsbml.UNIT_KIND_KILOGRAM)
u.setExponent(1)
self.assertEqual( True, ud.isVariantOfSubstancePerTime() )
u.setScale(-1)
perTime.setScale(-1)
self.assertEqual( True, ud.isVariantOfSubstancePerTime() )
u.setMultiplier(2)
self.assertEqual( True, ud.isVariantOfSubstancePerTime() )
u.setOffset(3)
self.assertEqual( True, ud.isVariantOfSubstancePerTime() )
u.setExponent(-3)
self.assertEqual( False, ud.isVariantOfSubstancePerTime() )
u.setExponent(1)
perTime.setExponent(-3)
self.assertEqual( False, ud.isVariantOfSubstancePerTime() )
perTime.setExponent(-1)
ud.addUnit(dim)
self.assertEqual( True, ud.isVariantOfSubstancePerTime() )
_dummyList = [ ud ]; _dummyList[:] = []; del _dummyList
pass
def test_UnitDefinition_isVariantOfSubstancePerTime_2(self):
dim = libsbml.Unit(2,4)
dim.setKind(libsbml.UnitKind_forName("dimensionless"))
perTime = self.UD.createUnit()
perTime.setKind(libsbml.UnitKind_forName("second"))
perTime.setExponent(-1)
u = self.UD.createUnit()
self.assertEqual( False, self.UD.isVariantOfSubstancePerTime() )
u.setKind(libsbml.UNIT_KIND_ITEM)
u.setExponent(1)
self.assertEqual( True, self.UD.isVariantOfSubstancePerTime() )
u.setScale(-1)
perTime.setScale(-1)
self.assertEqual( True, self.UD.isVariantOfSubstancePerTime() )
u.setMultiplier(2)
self.assertEqual( True, self.UD.isVariantOfSubstancePerTime() )
u.setOffset(3)
self.assertEqual( True, self.UD.isVariantOfSubstancePerTime() )
u.setExponent(-3)
self.assertEqual( False, self.UD.isVariantOfSubstancePerTime() )
u.setExponent(1)
perTime.setExponent(-3)
self.assertEqual( False, self.UD.isVariantOfSubstancePerTime() )
perTime.setExponent(-1)
self.UD.addUnit(dim)
self.assertEqual( True, self.UD.isVariantOfSubstancePerTime() )
_dummyList = [ dim ]; _dummyList[:] = []; del _dummyList
pass
def test_UnitDefinition_getUnit(self):
mole = libsbml.Unit(2,4)
litre = libsbml.Unit(2,4)
second = libsbml.Unit(2,4)
mole.setKind(libsbml.UnitKind_forName("mole"))
litre.setKind(libsbml.UnitKind_forName("litre"))
second.setKind(libsbml.UnitKind_forName("second"))
mole.setScale(-3)
litre.setExponent(-1)
second.setExponent(-1)
self.UD.addUnit(mole)
self.UD.addUnit(litre)
self.UD.addUnit(second)
_dummyList = [ mole ]; _dummyList[:] = []; del _dummyList
_dummyList = [ litre ]; _dummyList[:] = []; del _dummyList
_dummyList = [ second ]; _dummyList[:] = []; del _dummyList
self.assert_( self.UD.getNumUnits() == 3 )
mole = self.UD.getUnit(0)
litre = self.UD.getUnit(1)
second = self.UD.getUnit(2)
self.assert_( mole.getKind() == libsbml.UNIT_KIND_MOLE )
self.assert_( litre.getKind() == libsbml.UNIT_KIND_LITRE )
self.assert_( second.getKind() == libsbml.UNIT_KIND_SECOND )
self.assert_( mole.getScale() == -3 )
self.assert_( litre.getExponent() == -1 )
self.assert_( second.getExponent() == -1 )
pass
def test_L3_Unit_kind(self): kind = "mole"; self.assertEqual( False, self.U.isSetKind() ) self.U.setKind(libsbml.UnitKind_forName(kind)) self.assert_( self.U.getKind() == libsbml.UNIT_KIND_MOLE ) self.assertEqual( True, self.U.isSetKind() ) pass
def __addUnits(self, model, enzmldoc):
for key, unitdef in enzmldoc.getUnitDict().items():
unit = model.createUnitDefinition()
unit.setId(key)
unit.setMetaId(unitdef.getMetaid())
unit.setName(unitdef.getName())
cvterm = CVTerm()
cvterm.addResource(unitdef.getOntology())
cvterm.setQualifierType(BIOLOGICAL_QUALIFIER)
cvterm.setBiologicalQualifierType(BQB_IS)
unit.addCVTerm(cvterm)
for baseunit in unitdef.getUnits():
u = unit.createUnit()
try:
u.setKind(libsbml.UnitKind_forName(baseunit[0]))
except TypeError:
u.setKind(baseunit[0])
u.setExponent(baseunit[1])
u.setScale(baseunit[2])
u.setMultiplier(baseunit[3])
def test_WriteL3SBML_UnitDefinition(self):
expected = wrapString(
"<unitDefinition id=\"myUnit\">\n" + " <listOfUnits>\n" +
" <unit kind=\"mole\" exponent=\"1\" scale=\"0\" multiplier=\"1.8\"/>\n"
+ " </listOfUnits>\n" + "</unitDefinition>")
ud = self.D.createModel().createUnitDefinition()
ud.setId("myUnit")
u1 = ud.createUnit()
u1.setKind(libsbml.UnitKind_forName("mole"))
u1.setMultiplier(1.8)
u1.setScale(0)
u1.setExponent(1)
self.assertEqual(True, self.equals(expected, ud.toSBML()))
pass
def test_SBMLDocument_setLevelAndVersion_Error(self):
d = libsbml.SBMLDocument()
d.setLevelAndVersion(2, 1, True)
m1 = libsbml.Model(2, 1)
u = libsbml.Unit(2, 1)
u.setKind(libsbml.UnitKind_forName("mole"))
u.setOffset(3.2)
ud = libsbml.UnitDefinition(2, 1)
ud.setId("ud")
ud.addUnit(u)
m1.addUnitDefinition(ud)
d.setModel(m1)
self.assert_(d.setLevelAndVersion(2, 2, True) == False)
self.assert_(d.setLevelAndVersion(2, 3, True) == False)
self.assert_(d.setLevelAndVersion(1, 2, True) == False)
self.assert_(d.setLevelAndVersion(1, 1, True) == False)
_dummyList = [d]
_dummyList[:] = []
del _dummyList
pass
def test_UnitDefinition_isVariantOfVolume_2(self):
dim = libsbml.Unit(2,4)
dim.setKind(libsbml.UnitKind_forName("dimensionless"))
u = self.UD.createUnit()
self.assertEqual( False, self.UD.isVariantOfVolume() )
u.setKind(libsbml.UNIT_KIND_METRE)
u.setExponent(3)
self.assertEqual( True, self.UD.isVariantOfVolume() )
u.setScale(100)
self.assertEqual( True, self.UD.isVariantOfVolume() )
u.setMultiplier(5)
self.assertEqual( True, self.UD.isVariantOfVolume() )
u.setOffset(-5)
self.assertEqual( True, self.UD.isVariantOfVolume() )
u.setExponent(2)
self.assertEqual( False, self.UD.isVariantOfVolume() )
u.setExponent(3)
self.UD.addUnit(dim)
self.assertEqual( True, self.UD.isVariantOfVolume() )
pass
def test_UnitDefinition_isVariantOfSubstance_1(self):
dim = libsbml.Unit(2,4)
dim.setKind(libsbml.UnitKind_forName("dimensionless"))
u = self.UD.createUnit()
self.assertEqual( False, self.UD.isVariantOfSubstance() )
u.setKind(libsbml.UNIT_KIND_MOLE)
u.setExponent(1)
self.assertEqual( True, self.UD.isVariantOfSubstance() )
u.setScale(-1)
self.assertEqual( True, self.UD.isVariantOfSubstance() )
u.setMultiplier(2)
self.assertEqual( True, self.UD.isVariantOfSubstance() )
u.setOffset(3)
self.assertEqual( True, self.UD.isVariantOfSubstance() )
u.setExponent(-3)
self.assertEqual( False, self.UD.isVariantOfSubstance() )
u.setExponent(1)
self.UD.addUnit(dim)
self.assertEqual( True, self.UD.isVariantOfSubstance() )
pass
def handleUnits(self, line, name):
# expect a unit or a new context
if (line[0] == "$"):
self.handleNewContext(line, name)
else:
bits = line.split("=")
if (len(bits) < 2):
sys.stderr.write('Error: expected a "=" in: ' + line)
sys.stderr.write(' at line ' + str(self.count) + '\n')
raise ParseError
id = bits[0]
units = "=".join(bits[1:])
ud = self.m.createUnitDefinition()
ud.setId(id)
units = units.split(";")
for unit in units:
bits = unit.split(":")
if (len(bits) != 2):
id = bits[0]
mods = ""
else:
(id, mods) = bits
u = self.m.createUnit()
u.setKind(libsbml.UnitKind_forName(id))
u.setExponent(1)
u.setMultiplier(1)
u.setScale(0)
mods = mods.split(",")
for mod in mods:
if (mod[:2] == "e="):
u.setExponent(eval(mod[2:]))
elif (mod[:2] == "m="):
u.setMultiplier(eval(mod[2:]))
elif (mod[:2] == "s="):
u.setScale(eval(mod[2:]))
elif (mod[:2] == "o="):
u.setOffset(eval(mod[2:]))
if (name != ""):
ud.setName(name)
def test_UnitDefinition_printUnits(self):
ud = libsbml.UnitDefinition(2,4)
ud.setId( "mmls")
perTime = ud.createUnit()
perTime.setKind(libsbml.UnitKind_forName("second"))
perTime.setExponent(-1)
ud_str = libsbml.UnitDefinition.printUnits(ud,False)
self.assert_(( "second (exponent = -1, multiplier = 1, scale = 0)" == ud_str ))
ud_str1 = libsbml.UnitDefinition.printUnits(ud,True)
self.assert_(( "(1 second)^-1" == ud_str1 ))
ud1 = libsbml.UnitDefinition(2,4)
ud1.setId( "mmls")
u = ud1.createUnit()
u.setKind(libsbml.UNIT_KIND_KILOGRAM)
u.setExponent(1)
u.setScale(2)
u.setMultiplier(3.0)
ud_str2 = libsbml.UnitDefinition.printUnits(ud1,False)
self.assert_(( "kilogram (exponent = 1, multiplier = 3, scale = 2)" == ud_str2 ))
ud_str3 = libsbml.UnitDefinition.printUnits(ud1,True)
self.assert_(( "(300 kilogram)^1" == ud_str3 ))
pass
def test_UnitKind_forName(self):
self.assert_( libsbml.UnitKind_forName("ampere") == libsbml.UNIT_KIND_AMPERE )
self.assert_( libsbml.UnitKind_forName("becquerel") == libsbml.UNIT_KIND_BECQUEREL )
self.assert_( libsbml.UnitKind_forName("candela") == libsbml.UNIT_KIND_CANDELA )
self.assert_( libsbml.UnitKind_forName("Celsius") == libsbml.UNIT_KIND_CELSIUS )
self.assert_( libsbml.UnitKind_forName("coulomb") == libsbml.UNIT_KIND_COULOMB )
self.assert_( libsbml.UnitKind_forName("dimensionless") == libsbml.UNIT_KIND_DIMENSIONLESS )
self.assert_( libsbml.UnitKind_forName("farad") == libsbml.UNIT_KIND_FARAD )
self.assert_( libsbml.UnitKind_forName("gram") == libsbml.UNIT_KIND_GRAM )
self.assert_( libsbml.UnitKind_forName("gray") == libsbml.UNIT_KIND_GRAY )
self.assert_( libsbml.UnitKind_forName("henry") == libsbml.UNIT_KIND_HENRY )
self.assert_( libsbml.UnitKind_forName("hertz") == libsbml.UNIT_KIND_HERTZ )
self.assert_( libsbml.UnitKind_forName("item") == libsbml.UNIT_KIND_ITEM )
self.assert_( libsbml.UnitKind_forName("joule") == libsbml.UNIT_KIND_JOULE )
self.assert_( libsbml.UnitKind_forName("katal") == libsbml.UNIT_KIND_KATAL )
self.assert_( libsbml.UnitKind_forName("kelvin") == libsbml.UNIT_KIND_KELVIN )
self.assert_( libsbml.UnitKind_forName("kilogram") == libsbml.UNIT_KIND_KILOGRAM )
self.assert_( libsbml.UnitKind_forName("liter") == libsbml.UNIT_KIND_LITER )
self.assert_( libsbml.UnitKind_forName("litre") == libsbml.UNIT_KIND_LITRE )
self.assert_( libsbml.UnitKind_forName("lumen") == libsbml.UNIT_KIND_LUMEN )
self.assert_( libsbml.UnitKind_forName("lux") == libsbml.UNIT_KIND_LUX )
self.assert_( libsbml.UnitKind_forName("meter") == libsbml.UNIT_KIND_METER )
self.assert_( libsbml.UnitKind_forName("metre") == libsbml.UNIT_KIND_METRE )
self.assert_( libsbml.UnitKind_forName("mole") == libsbml.UNIT_KIND_MOLE )
self.assert_( libsbml.UnitKind_forName("newton") == libsbml.UNIT_KIND_NEWTON )
self.assert_( libsbml.UnitKind_forName("ohm") == libsbml.UNIT_KIND_OHM )
self.assert_( libsbml.UnitKind_forName("pascal") == libsbml.UNIT_KIND_PASCAL )
self.assert_( libsbml.UnitKind_forName("radian") == libsbml.UNIT_KIND_RADIAN )
self.assert_( libsbml.UnitKind_forName("second") == libsbml.UNIT_KIND_SECOND )
self.assert_( libsbml.UnitKind_forName("siemens") == libsbml.UNIT_KIND_SIEMENS )
self.assert_( libsbml.UnitKind_forName("sievert") == libsbml.UNIT_KIND_SIEVERT )
self.assert_( libsbml.UnitKind_forName("steradian") == libsbml.UNIT_KIND_STERADIAN )
self.assert_( libsbml.UnitKind_forName("tesla") == libsbml.UNIT_KIND_TESLA )
self.assert_( libsbml.UnitKind_forName("volt") == libsbml.UNIT_KIND_VOLT )
self.assert_( libsbml.UnitKind_forName("watt") == libsbml.UNIT_KIND_WATT )
self.assert_( libsbml.UnitKind_forName("weber") == libsbml.UNIT_KIND_WEBER )
self.assert_( libsbml.UnitKind_forName(None) == libsbml.UNIT_KIND_INVALID )
self.assert_( libsbml.UnitKind_forName("") == libsbml.UNIT_KIND_INVALID )
self.assert_( libsbml.UnitKind_forName("foobar") == libsbml.UNIT_KIND_INVALID )
pass
def udef_to_string(
udef: Optional[Union[libsbml.UnitDefinition, str]],
model: Optional[libsbml.Model] = None,
format: str = "latex",
) -> Optional[str]:
"""Render formatted string for units.
Format can be either 'str' or 'latex'
Units have the general format
(multiplier * 10^scale *ukind)^exponent
(m * 10^s *k)^e
Returns None if udef is None or no units in UnitDefinition.
:param udef: unit definition which is to be converted to string
"""
if udef is None:
return None
ud: libsbml.UnitDefinition
if isinstance(udef, str):
# check for internal unit
if libsbml.UnitKind_forName(udef) != libsbml.UNIT_KIND_INVALID:
return short_names.get(udef, udef)
else:
ud = model.getUnitDefinition(udef) # type: ignore
else:
ud = udef
# collect nominators and denominators
nom: str = ""
denom: str = ""
if ud:
for u in ud.getListOfUnits():
m = u.getMultiplier()
s: int = u.getScale()
e = u.getExponent()
k = libsbml.UnitKind_toString(u.getKind())
# (m * 10^s *k)^e
# parse with pint
term = Q_(float(m) * 10**s, k)**float(abs(e))
try:
term = term.to_compact()
except KeyError:
pass
if np.isclose(term.magnitude, 1.0):
term = Q_(1, term.units)
us = f"{term:~}" # short formating
# handle min and hr
us = us.replace("60.0 s", "1 min")
us = us.replace("3600.0 s", "1 hr")
us = us.replace("3.6 ks", "1 hr")
us = us.replace("86.4 ks", "1 day")
us = us.replace("10.0 mm", "1 cm")
# remove 1.0 prefixes
us = us.replace("1 ", "")
# exponent
us = us.replace(" ** ", "^")
if e >= 0.0:
nom = us if nom == "" else f"{nom}*{us}"
else:
denom = us if denom == "" else f"{denom}*{us}"
else:
nom = "-"
if format == "str":
denom = denom.replace("*", "/")
if nom and denom:
ustr = f"{nom}/{denom}"
elif nom and not denom:
ustr = nom
elif not nom and denom:
ustr = f"1/{denom}"
elif not nom and not denom:
ustr = "-"
elif format == "latex":
nom = nom.replace("*", " \\cdot ")
denom = denom.replace("*", " \\cdot ")
if nom and denom:
ustr = f"\\frac{{{nom}}}{{{denom}}}"
elif nom and not denom:
ustr = nom
elif not nom and denom:
ustr = f"\\frac{{1}}{{{denom}}}"
elif not nom and not denom:
ustr = "-"
else:
raise ValueError
if ustr == "1":
ustr = "-"
# json escape
return ustr
def test_Unit_setKind2(self):
i = self.U.setKind(libsbml.UnitKind_forName("litre"))
self.assert_(i == libsbml.LIBSBML_OPERATION_SUCCESS)
self.assertEqual(True, self.U.isSetKind())
pass
def test_Unit_setKind1(self):
i = self.U.setKind(libsbml.UnitKind_forName("cell"))
self.assert_(i == libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE)
self.assertEqual(False, self.U.isSetKind())
pass
