const Variable* ReactantList::GetNthReactant(size_t n) const
{
if (n>=m_components.size()) return NULL;
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
return module->GetVariable(m_components[n].second);
}
void ReactantList::SetComponentCompartments(Variable* compartment, var_type supercomp)
{
for (size_t component=0; component<m_components.size(); component++) {
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
Variable* var = module->GetVariable(m_components[component].second);
if (var != NULL) {
var->SetSuperCompartment(compartment, supercomp);
}
}
}
bool ReactantList::SetComponentFormulasTo(Formula form)
{
for (size_t component=0; component<m_components.size(); component++) {
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
Variable* var = module->GetVariable(m_components[component].second);
if (var != NULL) {
if (var->SetFormula(&form)) return true;
}
}
return false;
}
double ReactantList::GetStoichiometryFor(const Variable* var) const
{
double stoich = 0;
for (size_t component=0; component<m_components.size(); component++) {
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
Variable* compvar = module->GetVariable(m_components[component].second);
assert(compvar != NULL);
if (compvar->GetIsEquivalentTo(var)) {
stoich += m_components[component].first;
}
}
return stoich;
}
string AntimonyEvent::ToStringDelimitedBy(std::string cc) const
{
if (IsEmpty()) return "";
string retval;
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
Variable* actualvar = module->GetVariable(m_name);
if (actualvar == NULL) {
//um what?
assert(false);
return "";
}
retval += actualvar->GetNameDelimitedBy(cc) + ": at ";
if (!m_delay.IsEmpty()) {
retval += m_delay.ToDelimitedStringWithEllipses(cc) + " after ";
}
retval += m_trigger.ToDelimitedStringWithEllipses(cc);
if (!m_priority.IsEmpty()) {
retval += ", priority = " + m_priority.ToDelimitedStringWithEllipses(cc);
}
if (m_initialValue == false) {
retval += ", t0=false";
}
if (m_persistent == false) {
retval += ", persistent=false";
}
if (m_useValuesFromTriggerTime == false) {
retval += ", fromTrigger=false";
}
retval += ": ";
for (size_t result=0; result<m_varresults.size(); result++) {
if (result>0) {
retval += ", ";
}
Variable* resultvar = g_registry.GetModule(m_module)->GetVariable(m_varresults[result]);
if (resultvar == NULL) {
assert(false);
return "";
}
retval += resultvar->GetNameDelimitedBy(cc);
retval += " = ";
retval += m_formresults[result].ToDelimitedStringWithEllipses(cc);
}
retval += ";";
return retval;
}
bool AntimonyEvent::ClearReferencesTo(Variable* deletedvar, set<pair<vector<string>, deletion_type> >* ret)
{
if (IsEmpty()) return false;
if (m_trigger.ClearReferencesTo(deletedvar)) {
//Can't (yet?) have an event with no trigger: delete the event
return true;
}
if (m_delay.ClearReferencesTo(deletedvar)) {
ret->insert(make_pair(m_name, delEventDelay));
}
if (m_priority.ClearReferencesTo(deletedvar)) {
ret->insert(make_pair(m_name, delEventPriority));
}
vector<Formula>::iterator form = m_formresults.begin();
vector<vector<string> >::iterator varresult = m_varresults.begin();
Module* module = g_registry.GetModule(m_module);
assert(module != NULL);
while (form != m_formresults.end()) {
if (form->ClearReferencesTo(deletedvar) ||
module->GetVariable(*varresult)->GetIsEquivalentTo(deletedvar)) {
vector<string> longername = m_name;
longername.push_back((*varresult)[varresult->size()-1]);
ret->insert(make_pair(longername, delEventAssignment));
form = m_formresults.erase(form);
varresult = m_varresults.erase(varresult);
}
else {
form++;
varresult++;
}
}
if (m_formresults.size() == 0) {
//Can't (yet?) have an event with no event assignments: delete the event
return true;
}
return false; //Didn't have to delete ourselves.
}
bool Registry::SynchronizeCellMLConnection(nsCOMPtr<cellml_apiIConnection> connection)
{
nsString cellmltext;
string cellmlname;
nsresult rv;
nsCOMPtr<cellml_apiIModel> topmodel; //used when the encapsulation parent is null (in GetNameAccordingToEncapsulationParent)
rv = connection->GetModelElement(getter_AddRefs(topmodel));
nsCOMPtr<cellml_apiICellMLElement> parentel;
rv = topmodel->GetParentElement(getter_AddRefs(parentel));
while (parentel != NULL) {
rv = parentel->GetModelElement(getter_AddRefs(topmodel));
rv = topmodel->GetParentElement(getter_AddRefs(parentel));
}
//rv = topmodel->GetName(cellmltext);
//cout << "Top model: " << ToThinString(cellmltext.get()) << endl;
//First we get the list of the component and any/all encapsulation parents
vector<string> comp1moduleparents, comp2moduleparents;
vector<string> comp1modulenames, comp2modulenames;
nsCOMPtr<cellml_apiIMapComponents> compmap;
rv = connection->GetComponentMapping(getter_AddRefs(compmap));
nsCOMPtr<cellml_apiICellMLComponent> component;
//First
rv = compmap->GetFirstComponent(getter_AddRefs(component));
while (component != NULL) {
string modname = GetModuleNameFrom(component);
comp1moduleparents.insert(comp1moduleparents.begin(), modname);
modname = GetNameAccordingToEncapsulationParent(component, topmodel);
FixName(modname);
comp1modulenames.insert(comp1modulenames.begin(), modname);
rv = component->GetEncapsulationParent(getter_AddRefs(component));
}
comp1moduleparents.insert(comp1moduleparents.begin(), CurrentModule()->GetModuleName());
//Second
rv = compmap->GetSecondComponent(getter_AddRefs(component));
while (component != NULL) {
string modname = GetModuleNameFrom(component);
comp2moduleparents.insert(comp2moduleparents.begin(), modname);
modname = GetNameAccordingToEncapsulationParent(component, topmodel);
FixName(modname);
comp2modulenames.insert(comp2modulenames.begin(), modname);
rv = component->GetEncapsulationParent(getter_AddRefs(component));
}
comp2moduleparents.insert(comp2moduleparents.begin(), CurrentModule()->GetModuleName());
//cout << "First component's parents: " << ToStringFromVecDelimitedBy(comp1moduleparents, '.') << endl << "Second component's parents: " << ToStringFromVecDelimitedBy(comp2moduleparents, '.') << endl;
//cout << "First component's names: " << ToStringFromVecDelimitedBy(comp1modulenames, '.') << endl << "Second component's names: " << ToStringFromVecDelimitedBy(comp2modulenames, '.') << endl;
//Now figure out the 'lowest' common parent in the encapsulation tree:
string commonparent = "";
assert(comp1moduleparents.size() > 0 && comp2moduleparents.size() > 0 && comp1moduleparents[0] == comp2moduleparents[0]);
size_t pnum = 0;
while (comp1modulenames.size() > 0 && comp2modulenames.size() > 0 &&
comp1modulenames[0] == comp2modulenames[0]) {
comp1modulenames.erase(comp1modulenames.begin());
comp2modulenames.erase(comp2modulenames.begin());
pnum++;
}
commonparent = comp1moduleparents[pnum];
//At this point, we have the name of the module where the encapsulation happens:
Module* topmod = CurrentModule();
if (commonparent != "") {
topmod = GetModule(commonparent);
}
assert(topmod != NULL);
// cout << "Top module: " << commonparent << endl;
// cout << "first compartment submodule name: " << ToStringFromVecDelimitedBy(comp1modulenames, '.') << endl;
// cout << "second compartment submodule name: " << ToStringFromVecDelimitedBy(comp2modulenames, '.') << endl;
//And we have the full names of the submodules whose variables need to be synchronized. But there might be multiple variables, so we go through them all:
nsCOMPtr<cellml_apiIMapVariablesSet> mvs;
rv = connection->GetVariableMappings(getter_AddRefs(mvs));
nsCOMPtr<cellml_apiIMapVariablesIterator> mvsi;
rv = mvs->IterateMapVariables(getter_AddRefs(mvsi));
nsCOMPtr<cellml_apiIMapVariables> mapvars;
rv = mvsi->NextMapVariable(getter_AddRefs(mapvars));
bool somefalse = false;
while (mapvars != NULL) {
rv = mapvars->GetFirstVariableName(cellmltext);
cellmlname = ToThinString(cellmltext.get());
FixName(cellmlname);
vector<string> fullvarname = comp1modulenames;
fullvarname.push_back(cellmlname);
Variable* firstvar = topmod->GetVariable(fullvarname);
assert(firstvar != NULL);
firstvar = firstvar->GetSameVariable();
rv = mapvars->GetSecondVariableName(cellmltext);
cellmlname = ToThinString(cellmltext.get());
FixName(cellmlname);
fullvarname = comp2modulenames;
fullvarname.push_back(cellmlname);
Variable* secondvar = topmod->GetVariable(fullvarname);
assert(secondvar != NULL);
secondvar = secondvar->GetSameVariable();
//Now we create a local name for the variables to be synchronized if one doesn't already exist.
vector<string> firstvarname = firstvar->GetName();
vector<string> secondvarname = secondvar->GetName();
if (firstvarname.size() > 1 && secondvarname.size() > 1) {
//Create a local variable
vector<string> newvarname;
newvarname.push_back(secondvarname[secondvarname.size()-1]);
Variable* newvar = topmod->GetVariable(newvarname);
if (newvar == NULL) {
newvar = topmod->AddOrFindVariable(&newvarname[0]);
}
else {
newvar = topmod->AddNewNumberedVariable(newvarname[0]);
}
if (firstvar->Synchronize(newvar)) {
g_registry.AddWarning("In module '" + topmod->GetModuleName() + "', the variables " + firstvar->GetNameDelimitedBy('.') + " and " + newvar->GetNameDelimitedBy('.') + " were unable to be set as equivalent: " + g_registry.GetError());
somefalse = true;
}
if (secondvar->Synchronize(newvar)) {
g_registry.AddWarning("In module '" + topmod->GetModuleName() + "', the variables " + secondvar->GetNameDelimitedBy('.') + " and " + newvar->GetNameDelimitedBy('.') + " were unable to be set as equivalent: " + g_registry.GetError());
somefalse = true;
}
}
else {
if (firstvar->Synchronize(secondvar)) {
g_registry.AddWarning("In module '" + topmod->GetModuleName() + "', the variables " + firstvar->GetNameDelimitedBy('.') + " and " + secondvar->GetNameDelimitedBy('.') + " were unable to be set as equivalent: " + g_registry.GetError());
somefalse = true;
}
}
rv = mvsi->NextMapVariable(getter_AddRefs(mapvars));
}
return somefalse;
}
