void Module::CreateSBMLModel()
{
Model* sbmlmod = m_sbml.createModel();
sbmlmod->setId(m_modulename);
sbmlmod->setName(m_modulename);
sbmlmod->setNotes("<body xmlns=\"http://www.w3.org/1999/xhtml\"><p> Originally created by libAntimony " VERSION_STRING " (using libSBML " LIBSBML_DOTTED_VERSION ") </p></body>");
char cc = g_registry.GetCC();
//User-defined functions
for (size_t uf=0; uf<g_registry.GetNumUserFunctions(); uf++) {
const UserFunction* userfunction = g_registry.GetNthUserFunction(uf);
assert(userfunction != NULL);
FunctionDefinition* fd = sbmlmod->createFunctionDefinition();
fd->setId(userfunction->GetModuleName());
ASTNode* math = parseStringToASTNode(userfunction->ToSBMLString());
fd->setMath(math);
delete math;
}
//Compartments
Compartment* defaultCompartment = sbmlmod->createCompartment();
defaultCompartment->setId(DEFAULTCOMP);
defaultCompartment->setConstant(true);
defaultCompartment->setSize(1);
defaultCompartment->setSBOTerm(410); //The 'implicit compartment'
size_t numcomps = GetNumVariablesOfType(allCompartments);
for (size_t comp=0; comp<numcomps; comp++) {
const Variable* compartment = GetNthVariableOfType(allCompartments, comp);
Compartment* sbmlcomp = sbmlmod->createCompartment();
sbmlcomp->setId(compartment->GetNameDelimitedBy(cc));
if (compartment->GetDisplayName() != "") {
sbmlcomp->setName(compartment->GetDisplayName());
}
sbmlcomp->setConstant(compartment->GetIsConst());
formula_type ftype = compartment->GetFormulaType();
assert (ftype == formulaINITIAL || ftype==formulaASSIGNMENT || ftype==formulaRATE);
if (ftype != formulaINITIAL) {
sbmlcomp->setConstant(false);
}
const Formula* formula = compartment->GetFormula();
if (formula->IsDouble()) {
sbmlcomp->setSize(atof(formula->ToSBMLString().c_str()));
}
SetAssignmentFor(sbmlmod, compartment);
}
//Species
size_t numspecies = GetNumVariablesOfType(allSpecies);
for (size_t spec=0; spec < numspecies; spec++) {
const Variable* species = GetNthVariableOfType(allSpecies, spec);
Species* sbmlspecies = sbmlmod->createSpecies();
sbmlspecies->setId(species->GetNameDelimitedBy(cc));
if (species->GetDisplayName() != "") {
sbmlspecies->setName(species->GetDisplayName());
}
sbmlspecies->setConstant(false); //There's no need to try to distinguish between const and var for species.
if (species->GetIsConst()) {
sbmlspecies->setBoundaryCondition(true);
}
else {
sbmlspecies->setBoundaryCondition(false);
}
const Variable* compartment = species->GetCompartment();
if (compartment == NULL) {
sbmlspecies->setCompartment(defaultCompartment->getId());
}
else {
sbmlspecies->setCompartment(compartment->GetNameDelimitedBy(cc));
}
const Formula* formula = species->GetFormula();
if (formula->IsDouble()) {
sbmlspecies->setInitialConcentration(atof(formula->ToSBMLString().c_str()));
}
else if (formula->IsAmountIn(species->GetCompartment())) {
sbmlspecies->setInitialAmount(formula->ToAmount());
}
SetAssignmentFor(sbmlmod, species);
}
//Formulas
size_t numforms = GetNumVariablesOfType(allFormulas);
for (size_t form=0; form < numforms; form++) {
const Variable* formvar = GetNthVariableOfType(allFormulas, form);
const Formula* formula = formvar->GetFormula();
Parameter* param = sbmlmod->createParameter();
param->setId(formvar->GetNameDelimitedBy(cc));
if (formvar->GetDisplayName() != "") {
param->setName(formvar->GetDisplayName());
}
param->setConstant(formvar->GetIsConst());
if (formula->IsDouble()) {
param->setValue(atof(formula->ToSBMLString().c_str()));
}
SetAssignmentFor(sbmlmod, formvar);
formula_type ftype = formvar->GetFormulaType();
assert (ftype == formulaINITIAL || ftype==formulaASSIGNMENT || ftype==formulaRATE);
if (ftype != formulaINITIAL) {
param->setConstant(false);
}
}
//Reactions
size_t numrxns = GetNumVariablesOfType(allReactions);
for (size_t rxn=0; rxn < numrxns; rxn++) {
const Variable* rxnvar = GetNthVariableOfType(allReactions, rxn);
const AntimonyReaction* reaction = rxnvar->GetReaction();
if (reaction->IsEmpty()) {
continue; //Reactions that involve no species are illegal in SBML.
}
Reaction* sbmlrxn = sbmlmod->createReaction();
sbmlrxn->setId(rxnvar->GetNameDelimitedBy(cc));
if (rxnvar->GetDisplayName() != "") {
sbmlrxn->setName(rxnvar->GetDisplayName());
}
if (reaction->GetType() == rdBecomes) {
sbmlrxn->setReversible(true);
}
else {
assert(reaction->GetType() == rdBecomesIrreversibly);
sbmlrxn->setReversible(false);
}
const Formula* formula = reaction->GetFormula();
string formstring = formula->ToSBMLString(rxnvar->GetStrandVars());
if (!formula->IsEmpty()) {
KineticLaw* kl = sbmlmod->createKineticLaw();
ASTNode* math = parseStringToASTNode(formstring);
kl->setMath(math);
delete math;
}
const ReactantList* left = reaction->GetLeft();
for (size_t lnum=0; lnum<left->Size(); lnum++) {
const Variable* nthleft = left->GetNthReactant(lnum);
double nthstoich = left->GetStoichiometryFor(lnum);
SpeciesReference* sr = sbmlmod->createReactant();
sr->setSpecies(nthleft->GetNameDelimitedBy(cc));
sr->setStoichiometry(nthstoich);
}
const ReactantList* right = reaction->GetRight();
for (size_t rnum=0; rnum<right->Size(); rnum++) {
const Variable* nthright = right->GetNthReactant(rnum);
double nthstoich = right->GetStoichiometryFor(rnum);
SpeciesReference* sr = sbmlmod->createProduct();
sr->setSpecies(nthright->GetNameDelimitedBy(cc));
sr->setStoichiometry(nthstoich);
}
//Find 'modifiers' and add them.
vector<const Variable*> subvars = formula->GetVariablesFrom(formstring, m_modulename);
for (size_t v=0; v<subvars.size(); v++) {
if (subvars[v] != NULL && subvars[v]->GetType() == varSpeciesUndef) {
if (left->GetStoichiometryFor(subvars[v]) == 0 &&
right->GetStoichiometryFor(subvars[v]) == 0) {
ModifierSpeciesReference* msr = sbmlmod->createModifier();
msr->setSpecies(subvars[v]->GetNameDelimitedBy(cc));
}
}
}
}
//Events
size_t numevents = GetNumVariablesOfType(allEvents);
for (size_t ev=0; ev < numevents; ev++) {
const Variable* eventvar = GetNthVariableOfType(allEvents, ev);
const AntimonyEvent* event = eventvar->GetEvent();
Event* sbmlevent = sbmlmod->createEvent();
sbmlevent->setId(eventvar->GetNameDelimitedBy(cc));
if (eventvar->GetDisplayName() != "") {
sbmlevent->setName(eventvar->GetDisplayName());
}
Trigger* trig = sbmlevent->createTrigger();
ASTNode* ASTtrig = parseStringToASTNode(event->GetTrigger()->ToSBMLString());
trig->setMath(ASTtrig);
delete ASTtrig;
const Formula* delay = event->GetDelay();
if (!delay->IsEmpty()) {
ASTtrig = parseStringToASTNode(delay->ToSBMLString());
Delay* sbmldelay = sbmlevent->createDelay();
sbmldelay->setMath(ASTtrig);
delete ASTtrig;
}
long numasnts = static_cast<long>(event->GetNumAssignments());
for (long asnt=numasnts-1; asnt>=0; asnt--) {
//events are stored in reverse order. Don't ask...
EventAssignment* sbmlasnt = sbmlmod->createEventAssignment();
sbmlasnt->setVariable(event->GetNthAssignmentVariableName(asnt, cc));
ASTNode* ASTasnt = parseStringToASTNode(event->GetNthAssignmentFormulaString(asnt, '_', true));
sbmlasnt->setMath(ASTasnt);
delete ASTasnt;
}
}
//Interactions
size_t numinteractions = GetNumVariablesOfType(allInteractions);
for (size_t irxn=0; irxn<numinteractions; irxn++) {
const Variable* arxnvar = GetNthVariableOfType(allInteractions, irxn);
const AntimonyReaction* arxn = arxnvar->GetReaction();
Reaction* rxn = sbmlmod->getReaction(arxn->GetRight()->GetNthReactant(0)->GetNameDelimitedBy(cc));
if (rxn != NULL) {
for (size_t interactor=0; interactor<arxn->GetLeft()->Size(); interactor++) {
ModifierSpeciesReference* msr = rxn->createModifier();
msr->setSpecies(arxn->GetLeft()->GetNthReactant(interactor)->GetNameDelimitedBy(cc));
msr->setName(arxnvar->GetNameDelimitedBy(cc));
}
}
}
//Unknown variables (turn into parameters)
size_t numunknown = GetNumVariablesOfType(allUnknown);
for (size_t form=0; form < numunknown; form++) {
const Variable* formvar = GetNthVariableOfType(allUnknown, form);
Parameter* param = sbmlmod->createParameter();
param->setId(formvar->GetNameDelimitedBy(cc));
if (formvar->GetDisplayName() != "") {
param->setName(formvar->GetDisplayName());
}
switch(formvar->GetConstType()) {
case constVAR:
param->setConstant(true);
break;
case constCONST:
param->setConstant(false);
break;
case constDEFAULT:
break;
}
}
}
