def create_sbml(self, sbase: libsbml.SBase,
model: libsbml.Model) -> libsbml.ReplacedBy:
"""Create SBML ReplacedBy."""
sbase_comp = sbase.getPlugin("comp") # type: libsbml.CompSBasePlugin
rby = sbase_comp.createReplacedBy() # type: libsbml.ReplacedBy
self._set_fields(rby, model)
return rby
def sbase_dict(cls, sbase: libsbml.SBase) -> Dict[str, Any]:
"""Info dictionary for SBase.
:param sbase: SBase instance for which info dictionary is to be created
:return info dictionary for item
"""
pk = cls._get_pk(sbase)
d = {
"pk": pk,
"sbmlType": cls._sbml_type(sbase),
"id": sbase.getId() if sbase.isSetId() else None,
"metaId": sbase.getMetaId() if sbase.isSetMetaId() else None,
"name": sbase.getName() if sbase.isSetName() else None,
"sbo": sbase.getSBOTermID() if sbase.isSetSBOTerm() else None,
"cvterms": cls.cvterms(sbase),
"history": cls.model_history(sbase),
"notes": sbase.getNotesString() if sbase.isSetNotes() else None,
}
# TODO: add the ports information
if sbase.getTypeCode() in {libsbml.SBML_DOCUMENT, libsbml.SBML_MODEL}:
d["xml"] = None
else:
d["xml"] = sbase.toSBML()
# comp
item_comp = sbase.getPlugin("comp")
if item_comp and type(item_comp) == libsbml.CompSBasePlugin:
# ReplacedBy
if item_comp.isSetReplacedBy():
replaced_by = item_comp.getReplacedBy()
submodel_ref = replaced_by.getSubmodelRef()
d["replacedBy"] = {
"submodelRef": submodel_ref,
"replacedBySbaseref": cls._sbaseref(replaced_by),
}
else:
d["replacedBy"] = None
# ListOfReplacedElements
if item_comp.getNumReplacedElements() > 0:
replaced_elements = []
for rep_el in item_comp.getListOfReplacedElements():
submodel_ref = rep_el.getSubmodelRef()
replaced_elements.append({
"submodelRef":
submodel_ref,
"replacedElementSbaseref":
cls._sbaseref(rep_el),
})
d["replacedElements"] = replaced_elements
else:
d["replacedElements"] = None
# distrib
sbml_distrib: libsbml.DistribSBasePlugin = sbase.getPlugin("distrib")
if sbml_distrib and isinstance(sbml_distrib,
libsbml.DistribSBasePlugin):
d["uncertainties"] = []
for uncertainty in sbml_distrib.getListOfUncertainties():
u_dict = SBMLDocumentInfo.sbase_dict(uncertainty)
u_dict["uncertaintyParameters"] = []
upar: libsbml.UncertParameter
for upar in uncertainty.getListOfUncertParameters():
param_dict = {
"var":
upar.getVar() if upar.isSetVar() else None,
"value":
upar.getValue() if upar.isSetValue() else None,
"units":
upar.getUnits() if upar.isSetUnits() else None,
"type":
upar.getTypeAsString() if upar.isSetType() else None,
"definitionURL":
upar.getDefinitionURL()
if upar.isSetDefinitionURL() else None,
"math":
astnode_to_latex(upar.getMath())
if upar.isSetMath() else None,
}
u_dict["uncertaintyParameters"].append(param_dict)
d["uncertainties"].append(u_dict)
return d
def info_sbase(sbase: libsbml.SBase) -> Dict[str, Any]:
"""Info dictionary for SBase.
:param sbase: SBase instance for which info dictionary is to be created
:return info dictionary for item
"""
info = {
"object": sbase,
"id": sbase.getId(),
"metaId": metaid_html(sbase),
"sbo": sbo(sbase),
"cvterm": cvterm(sbase),
"notes": notes(sbase),
"annotation": annotation_html(sbase),
}
if sbase.isSetName():
name = sbase.name
else:
name = empty_html()
info["name"] = name
info["id_html"] = id_html(sbase)
# comp
item_comp = sbase.getPlugin("comp")
if item_comp and type(item_comp) == libsbml.CompSBasePlugin:
# ReplacedBy
if item_comp.isSetReplacedBy():
replaced_by = item_comp.getReplacedBy()
submodel_ref = replaced_by.getSubmodelRef()
info["replaced_by"] = f"""
<br /><i class="fa fa-arrow-circle-right" aria-hidden="true"></i>
<code>ReplacedBy {submodel_ref}:{sbaseref(replaced_by)}</code>
"""
# ListOfReplacedElements
if item_comp.getNumReplacedElements() > 0:
replaced_elements = []
for rep_el in item_comp.getListOfReplacedElements():
submodel_ref = rep_el.getSubmodelRef()
replaced_elements.append(f"""
<br /><i class="fa fa-arrow-circle-left" aria-hidden="true"></i>
<code>ReplacedElement {submodel_ref}:{sbaseref(rep_el)}</code>
""")
if len(replaced_elements) == 0:
replaced_elements_combined = ""
else:
replaced_elements_combined = "".join(replaced_elements)
info["replaced_elements"] = replaced_elements_combined
# distrib
sbml_distrib: libsbml.DistribSBasePlugin = sbase.getPlugin("distrib")
if sbml_distrib and isinstance(sbml_distrib,
libsbml.DistribSBasePlugin):
info["uncertainties"] = []
info["uncert_strings"] = []
for uncertainty in sbml_distrib.getListOfUncertainties():
u_dict = SBMLModelInfo.info_sbase(uncertainty)
u_dict["uncert_parameters"] = []
u_dict["uncert_params_strings"] = []
upar: libsbml.UncertParameter
for upar in uncertainty.getListOfUncertParameters():
param_dict = {}
param_str = ""
if upar.isSetVar():
param_dict["var"] = upar.getVar()
param_str += f"{param_dict['var']}, "
if upar.isSetValue():
param_dict["value"] = upar.getValue()
param_str += f"{param_dict['value']}, "
if upar.isSetUnits():
param_dict["units"] = upar.getUnits()
param_str += f"{param_dict['units']}, "
if upar.isSetType():
param_dict["type"] = upar.getTypeAsString()
param_str += f"{param_dict['type']}, "
if upar.isSetDefinitionURL():
param_dict["definition_url"] = f"""
<a href='{upar.getDefinitionURL()}'>
{upar.getDefinitionURL()}</a>
"""
param_str += param_dict["definition_url"]
if upar.isSetMath():
param_dict["math"] = formating.math(upar.getMath())
param_str += f"{param_dict['math']}, "
# create param info string
param_str = "<li>"
for key in param_dict.keys():
param_str += f"{key}:{param_dict.get(key, '')}, "
param_str += "</li>"
u_dict["uncert_parameters"].append(param_dict)
u_dict["uncert_params_strings"].append(param_str)
info["uncertainties"].append(u_dict)
return info
def create_sbml(self, sbase: libsbml.SBase):
"""Create libsbml Uncertainty.
:param model:
:return:
"""
logger.debug(f"Create uncertainty for object: {sbase}")
sbase_distrib = sbase.getPlugin(
"distrib") # type: libsbml.DistribSBasePlugin
uncertainty = sbase_distrib.createUncertainty(
) # type: libsbml.Uncertainty
self.set_fields(uncertainty)
for uncertParameter in self.uncertParameters:
up = None
if uncertParameter.type in [
libsbml.DISTRIB_UNCERTTYPE_INTERQUARTILERANGE,
libsbml.DISTRIB_UNCERTTYPE_CREDIBLEINTERVAL,
libsbml.DISTRIB_UNCERTTYPE_CONFIDENCEINTERVAL,
libsbml.DISTRIB_UNCERTTYPE_RANGE,
]:
up = uncertainty.createUncertSpan() # type: libsbml.UncertSpan
up.setType(uncertParameter.type)
if uncertParameter.valueLower is not None:
up.setValueLower(uncertParameter.valueLower)
if uncertParameter.valueUpper is not None:
up.setValueUpper(uncertParameter.valueUpper)
if uncertParameter.varLower is not None:
up.setVarLower(uncertParameter.varLower)
if uncertParameter.varUpper is not None:
up.setValueLower(uncertParameter.varUpper)
elif uncertParameter.type in [
libsbml.DISTRIB_UNCERTTYPE_COEFFIENTOFVARIATION,
libsbml.DISTRIB_UNCERTTYPE_KURTOSIS,
libsbml.DISTRIB_UNCERTTYPE_MEAN,
libsbml.DISTRIB_UNCERTTYPE_MEDIAN,
libsbml.DISTRIB_UNCERTTYPE_MODE,
libsbml.DISTRIB_UNCERTTYPE_SAMPLESIZE,
libsbml.DISTRIB_UNCERTTYPE_SKEWNESS,
libsbml.DISTRIB_UNCERTTYPE_STANDARDDEVIATION,
libsbml.DISTRIB_UNCERTTYPE_STANDARDERROR,
libsbml.DISTRIB_UNCERTTYPE_VARIANCE,
]:
up = (uncertainty.createUncertParameter()
) # type: libsbml.UncertParameter
up.setType(uncertParameter.type)
if uncertParameter.value is not None:
up.setValue(uncertParameter.value)
if uncertParameter.var is not None:
up.setValue(uncertParameter.var)
else:
logger.error(
"Unsupported UncertParameter or UncertSpan type: %s",
uncertParameter.type,
)
if up and uncertParameter.unit:
up.setUnits(Unit.get_unit_string(uncertParameter.unit))
# create a distribution uncertainty
if self.formula:
model = sbase.getModel()
up = uncertainty.createUncertParameter(
) # type: libsbml.UncertParameter
up.setType(libsbml.DISTRIB_UNCERTTYPE_DISTRIBUTION)
for key in [
"normal",
"uniform",
"bernoulli",
"binomial",
"cauchy",
"chisquare",
"exponential",
"gamma",
"laplace",
"lognormal",
"poisson",
"raleigh",
]:
if key in self.formula:
up.setDefinitionURL(
"http://www.sbml.org/sbml/symbols/distrib/{}".format(
key))
ast = libsbml.parseL3FormulaWithModel(self.formula, model)
if ast is None:
logger.error(libsbml.getLastParseL3Error())
else:
check(up.setMath(ast), "set math in distrib formula")
return uncertainty