bool CModelAdd::addCompartments(std::string name)
{
size_t i, imax = mmModel->getCompartments().size();
for (i = 0; i < imax; ++i)
{
const CCompartment* sourceComp = &mmModel->getCompartments()[i];
if (!sourceComp) return false;
//create new compartment
std::string newName = sourceComp->getObjectName() + "_" + name;
CCompartment* newComp = mpModel->createCompartment(newName, sourceComp->getInitialValue());
if (!newComp) return false;
newComp->setStatus(sourceComp->getStatus());
newComp->setDimensionality(sourceComp->getDimensionality());
keyMap[sourceComp->getKey()] = newComp->getKey();
nameMap[sourceComp->getObjectName()] = newName;
}
return true;
}
void CQSpecieDM::deleteSpecieRow(UndoSpeciesData *pSpecieData)
{
GET_MODEL_OR_RETURN(pModel);
switchToWidget(CCopasiUndoCommand::SPECIES);
CMetab * pSpecies = dynamic_cast< CMetab * >(pSpecieData->getObject(pModel));
if (pSpecies == NULL) return;
size_t Index = pModel->getMetabolites().getIndex(pSpecies);
removeRow((int) Index);
if (!pSpecieData->getCreatedCompartment()) return;
Index = pModel->getCompartments().getIndex(pSpecieData->getCompartment());
if (Index == C_INVALID_INDEX) return;
CCompartment* pComp = &pModel->getCompartments()[Index];
if (pComp == NULL) return;
std::string key = pComp->getKey();
pModel->removeCompartment(Index);
emit notifyGUI(ListViews::COMPARTMENT, ListViews::DELETE, key);
}
QList <UndoSpeciesData *> CQSpecieDM::insertNewSpecieRow(int position, int rows, const QModelIndex&index, const QVariant& value)
{
QList <UndoSpeciesData *> result;
GET_MODEL_OR(pModel, return result);
bool createdCompartment = false;
if (pModel->getCompartments().size() == 0)
{
CCompartment* pComp = pModel->createCompartment("compartment");
createdCompartment = true;
if (mNotify)
{
emit notifyGUI(ListViews::COMPARTMENT, ListViews::ADD, pComp->getKey());
}
}
beginInsertRows(QModelIndex(), position, position + rows - 1);
int column = index.column();
for (int row = 0; row < rows; ++row)
{
QString name = createNewName(index.isValid() && column == COL_NAME_SPECIES ? value.toString() : "species", COL_NAME_SPECIES);
QString compartment = index.isValid() && column == COL_COMPARTMENT ? value.toString() : "";
double initial = index.isValid() && column == COL_ICONCENTRATION ? value.toDouble() : 1.0;
CModelEntity::Status status = index.isValid() && column == COL_TYPE_SPECIES ?
(CModelEntity::Status) mItemToType[value.toInt()] : CModelEntity::REACTIONS;
mpSpecies =
pModel->createMetabolite(TO_UTF8(name), TO_UTF8(compartment), initial, status);
if (mpSpecies == NULL)
continue;
if (mNotify)
{
emit notifyGUI(ListViews::METABOLITE, ListViews::ADD, mpSpecies->getKey());
}
UndoSpeciesData* data = new UndoSpeciesData(mpSpecies);
data->setCreatedCompartment(row == 0 && createdCompartment);
result.append(data);
}
endInsertRows();
return result;
}
void CQCompartment::deleteCompartment(UndoCompartmentData *pCompartmentData)
{
switchToWidget(CCopasiUndoCommand::COMPARTMENTS);
CModel * pModel = mpCompartment->getModel();
assert(pModel != NULL);
CCompartment* pComp = &pModel->getCompartments()[pCompartmentData->getName()];
if (pComp == NULL) return;
std::string key = pComp->getKey();
pModel->removeCompartment(key);
mpCompartment = NULL;
#undef DELETE
protectedNotify(ListViews::COMPARTMENT, ListViews::DELETE, key);
protectedNotify(ListViews::COMPARTMENT, ListViews::DELETE, "");//Refresh all as there may be dependencies.
}
void UndoDependentData::createDependentObjects(CModel *pModel, QList<UndoCompartmentData *> *pCompartmentData)
{
if (pModel == NULL || pCompartmentData == NULL || pCompartmentData->empty())
return;
//reaction may further has dependencies, these must be taken care of
QList <UndoCompartmentData *>::const_iterator rs;
for (rs = pCompartmentData->begin(); rs != pCompartmentData->end(); ++rs)
{
UndoCompartmentData * data = *rs;
CCompartment* pCompartment = data->createObjectIn(pModel);
if (pCompartment == NULL)
continue;
updateGUI(ListViews::COMPARTMENT, ListViews::ADD, pCompartment->getKey());
}
}
void CQCompartment::deleteCompartment(UndoCompartmentData *pCompartmentData)
{
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
assert(pDataModel != NULL);
CModel * pModel = pDataModel->getModel();
assert(pModel != NULL);
CCompartment * pCompartment = pModel->getCompartments()[pCompartmentData->getName()];
std::string key = pCompartment->getKey();
pModel->removeCompartment(key);
mpCompartment = NULL;
#undef DELETE
protectedNotify(ListViews::COMPARTMENT, ListViews::DELETE, key);
protectedNotify(ListViews::COMPARTMENT, ListViews::DELETE, "");//Refresh all as there may be dependencies.
mpListView->switchToOtherWidget(111, "");
}
void CModelExpansion::duplicateCompartment(const CCompartment* source, const std::string & index, const SetOfModelElements & sourceSet, ElementsMap & emap)
{
//if the source object has already been duplicated: do nothing
if (emap.exists(source))
return;
//try creating the object until we find a name that is not yet used
CCompartment* newObj;
std::ostringstream infix;
do
{
std::ostringstream name;
name << source->getObjectName() << infix.str() << index;
newObj = mpModel->createCompartment(name.str(), source->getInitialValue());
infix << "_";
}
while (!newObj);
//add duplicated object to the map
emap.add(source, newObj);
//now copy the contents of the object
newObj->setDimensionality(source->getDimensionality());
//status
newObj->setStatus(source->getStatus());
//expression (for assignment or ODE)
newObj->setExpression(source->getExpression());
updateExpression(newObj->getExpressionPtr(), index, sourceSet, emap);
//initial expression
newObj->setInitialExpression(source->getInitialExpression());
updateExpression(newObj->getInitialExpressionPtr(), index, sourceSet, emap);
newObj->setNotes(source->getNotes());
newObj->setMiriamAnnotation(source->getMiriamAnnotation(), newObj->getKey(), source->getKey());
}
std::string CODEExporterC::KineticFunction2ODEmember(const CReaction *reac)
{
std::ostringstream equation;
if (reac->getFunction()->getType() != CEvaluationTree::MassAction)
{
const CFunctionParameters & params = reac->getFunctionParameters();
size_t k, params_size = params.size();
const std::vector<std::vector<std::string> > & keyMap = reac->getParameterMappings();
std::string name;
equation << NameMap[reac->getFunction()->getKey()] << "(";
for (k = 0; k < params_size; ++k)
{
CFunctionParameter::Role role = params[k]->getUsage();
CCopasiObject * obj = CCopasiRootContainer::getKeyFactory()->get(keyMap[k][0]);
if ((role == CFunctionParameter::SUBSTRATE)
|| (role == CFunctionParameter::PRODUCT)
|| (role == CFunctionParameter::MODIFIER))
{
if (obj)
name = NameMap[obj->getKey()];
else
name = "unknown";
}
if (role == CFunctionParameter::PARAMETER)
{
if (!(reac->isLocalParameter(k)))
{
CModelValue* modval;
modval = dynamic_cast< CModelValue * >(obj);
name = NameMap[modval->getKey()];
}
else
{
CCopasiParameter* param;
param = dynamic_cast< CCopasiParameter * >(obj);
name = NameMap[param->getKey()];
}
}
if (role == CFunctionParameter::VOLUME)
{
CCompartment* comp;
comp = dynamic_cast< CCompartment * >(obj);
name = NameMap[comp->getKey()];
}
if (role == CFunctionParameter::TIME)
{
name = "T";
}
if (name.empty())
{
std::string message = "Could not export C code, since one of the arguments could not be resolved. Please consider filing a bug with the COPASI tracker: http://www.copasi.org/tracker";
CCopasiMessage(CCopasiMessage::EXCEPTION, message.c_str());
}
equation << name;
if (k != params_size - 1)
equation << ", ";
}
equation << ")";
}
else
{
const CCopasiVector<CChemEqElement> & substrs = reac->getChemEq().getSubstrates();
const CCopasiVector<CChemEqElement> & prods = reac->getChemEq().getProducts();
const std::vector<std::vector<std::string> > & keyMap = reac->getParameterMappings();
CCopasiObject * obj;
size_t substrs_size = substrs.size(), prods_size = prods.size();
size_t k, m, mult;
const CChemEqElement* substr;
const CChemEqElement* prod;
const CMassAction & cMassAction = *static_cast<const CMassAction*>(reac->getFunction());
equation << "(";
obj = CCopasiRootContainer::getKeyFactory()->get(keyMap[0][0]);
if (!(reac->isLocalParameter(0)))
{
CModelValue* modval;
modval = dynamic_cast< CModelValue * >(obj);
equation << NameMap[modval->getKey()];
}
else
{
CCopasiParameter* param;
param = dynamic_cast< CCopasiParameter * >(obj);
equation << NameMap[param->getKey()];
}
for (k = 0; k < substrs_size; ++k)
{
substr = &substrs[k];
mult = (size_t) substr->getMultiplicity();
assert(substr->getMetabolite());
equation << " * " << NameMap[substr->getMetabolite()->getKey()];
if (mult > 1)
for (m = 1; m < mult; ++m)
equation << " * " << NameMap[substr->getMetabolite()->getKey()];
}
if (cMassAction.isReversible() == TriTrue)
{
equation << " - ";
obj = CCopasiRootContainer::getKeyFactory()->get(keyMap[2][0]);
if (!(reac->isLocalParameter(2)))
{
CModelValue* modval;
modval = dynamic_cast< CModelValue * >(obj);
equation << NameMap[modval->getKey()];
}
else
{
CCopasiParameter* param;
param = dynamic_cast< CCopasiParameter * >(obj);
equation << NameMap[param->getKey()];
}
for (k = 0; k < prods_size; ++k)
{
prod = &prods[k];
mult = (size_t) prod->getMultiplicity();
assert(prod->getMetabolite());
equation << " * " << NameMap[prod->getMetabolite()->getKey()];
if (mult > 1)
for (m = 1; m < mult; ++m)
equation << " * " << NameMap[prod->getMetabolite()->getKey()];
}
}
equation << ") ";
}
return equation.str();
}
bool CODEExporterC::preprocess(const CModel* copasiModel)
{
size_t n[3] = {0, 0, 0};
size_t n_c[3] = {0, 0, 0};
size_t i, j;
size_t dependent;
setReservedNames();
NameMap[timeKey] = translateTimeVariableName();
const CCopasiVector< CMetab > & metabs = copasiModel->getMetabolitesX();
size_t metabs_size = metabs.size();
for (i = 0; i < metabs_size; i++)
{
CMetab * metab = metabs[i];
//if (metab->isUsed())
{
std::string smname;
std::string name;
dependent = metab->isDependent();
smname = setExportName(metab->getStatus(), n, dependent);
name = setConcentrationName(metab->getStatus(), n_c, dependent);
NameMap[metab->getKey()] = name;
std::ostringstream smKey;
smKey << "sm_" << metab->getKey();
NameMap[smKey.str()] = smname;
if ((metab->getStatus() == CModelEntity::REACTIONS && !metab->isDependent()) || metab->getStatus() == CModelEntity::ODE)
{
std::ostringstream odeKey;
odeKey << "ode_" << metab->getKey();
NameMap[odeKey.str()] = setODEName(smname);
}
}
}
size_t comps_size = copasiModel->getCompartments().size();
const CCopasiVector< CCompartment > & comps = copasiModel->getCompartments();
for (i = 0; i < comps_size; i++)
{
CCompartment * comp = comps[i];
std::string name;
dependent = 0;
name = setExportName(comp->getStatus(), n, dependent);
NameMap[comp->getKey()] = name;
if (comp->getStatus() == CModelEntity::ODE)
{
std::ostringstream odeKey;
odeKey << "ode_" << comp->getKey();
NameMap[odeKey.str()] = setODEName(name);
}
}
size_t modvals_size = copasiModel->getModelValues().size();
const CCopasiVector< CModelValue > & modvals = copasiModel->getModelValues();
for (i = 0; i < modvals_size; i++)
{
CModelValue* modval = modvals[i];
std::string name = setExportName(modval->getStatus(), n, 0);
NameMap[modval->getKey()] = name;
if (modval->getStatus() == CModelEntity::ODE)
{
std::ostringstream odeKey;
odeKey << "ode_" << modval->getKey();
NameMap[odeKey.str()] = setODEName(name);
}
}
size_t reacs_size = copasiModel->getReactions().size();
const CCopasiVector< CReaction > & reacs = copasiModel->getReactions();
std::set<std::string> tmpset;
for (i = 0; i < reacs_size; ++i)
{
size_t params_size;
params_size = reacs[i]->getParameters().size();
for (j = 0; j < params_size; ++j)
{
if (!reacs[i]->isLocalParameter(reacs[i]->getParameters().getParameter(j)->getObjectName()))
continue;
std::ostringstream name;
name << "p[" << n[0] << "]";
n[0] ++;
NameMap[reacs[i]->getParameters().getParameter(j)->getKey()] = name.str();
}
const CFunction* func = reacs[i]->getFunction();
std::string name = func->getObjectName();
if (func->getRoot())
setExportNameOfFunction(func->getRoot(), tmpset);
if (func->getType() != CEvaluationTree::MassAction)
if (tmpset.find(name) == tmpset.end())
{
NameMap[func->getKey()] = translateObjectName(name);
tmpset.insert(name);
}
}
return true;
}
void CQCompartment::addCompartment(UndoCompartmentData *pSData)
{
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
assert(pDataModel != NULL);
CModel * pModel = pDataModel->getModel();
assert(pModel != NULL);
//reinsert all the Compartments
CCompartment *pCompartment = pModel->createCompartment(pSData->getName());
pCompartment->setInitialValue(pSData->getInitialValue());
pCompartment->setStatus(pSData->getStatus());
std::string key = pCompartment->getKey();
protectedNotify(ListViews::COMPARTMENT, ListViews::ADD, key);
//restore all the dependencies
//reinsert all the species
QList <UndoSpecieData *> *pSpecieData = pSData->getSpecieDependencyObjects();
QList <UndoSpecieData *>::const_iterator i;
for (i = pSpecieData->begin(); i != pSpecieData->end(); ++i)
{
UndoSpecieData * data = *i;
// beginInsertRows(QModelIndex(), 1, 1);
CMetab *pSpecie = pModel->createMetabolite(data->getName(), data->getCompartment(), data->getIConc(), data->getStatus());
protectedNotify(ListViews::METABOLITE, ListViews::ADD, pSpecie->getKey());
//endInsertRows();
}
//reinsert the dependency reaction
QList <UndoReactionData *> *pReactionData = pSData->getReactionDependencyObjects();
QList <UndoReactionData *>::const_iterator j;
for (j = pReactionData->begin(); j != pReactionData->end(); ++j)
{
//UndoReactionData * rData = dynamic_cast<UndoReactionData*>(*j);
UndoReactionData * rData = *j;
//TODO check if reaction already exist in the model, better idea may be implemented in the future
bool exist = false;
for (int ii = 0; ii < (int)pModel->getReactions().size(); ++ii)
{
if (pModel->getReactions()[ii]->getObjectName() == rData->getName())
{
exist = true;
ii = ii + pModel->getReactions().size() + 1; //jump out of the loop reaction exist already
}
else
{
exist = false;
}
}
if (!exist)
{
protectedNotify(ListViews::METABOLITE, ListViews::ADD, ""); //Refresh all dependency species.
CReaction *pRea = pModel->createReaction(rData->getName());
rData->getRi()->writeBackToReaction(pRea);
protectedNotify(ListViews::REACTION, ListViews::ADD, pRea->getKey());
}
}
mpListView->switchToOtherWidget(C_INVALID_INDEX, key);
}
CompartmentDataChangeCommand::CompartmentDataChangeCommand(
const QModelIndex& index,
const QVariant& value,
int role,
CQCompartmentDM *pCompartmentDM)
: CCopasiUndoCommand("Compartment", COMPARTMENT_DATA_CHANGE, "Change")
, mNew(value)
, mOld(index.data(Qt::DisplayRole))
, mIndex(index)
, mpCompartmentDM(pCompartmentDM)
, mRole(role)
, mPathIndex()
, mpCompartmentUndoData(NULL)
{
//set the data for UNDO history
assert(pCompartmentDM->getDataModel() != NULL);
CModel * pModel = pCompartmentDM->getDataModel()->getModel();
assert(pModel != NULL);
if (pModel->getCompartments().size() <= (size_t)index.row())
{
return;
}
CCompartment *pCompartment = &pModel->getCompartments()[index.row()];
setKey(pCompartment->getKey());
setName(pCompartment->getObjectName());
setOldValue(TO_UTF8(mOld.toString()));
setNewValue(TO_UTF8(mNew.toString()));
switch (index.column())
{
case 0:
setProperty("");
break;
case 1:
setProperty("Name");
break;
case 2:
setProperty("Type");
switch (mNew.toInt())
{
case 0:
setNewValue("fixed");
break;
case 1:
setNewValue("assignment");
break;
case 2:
setNewValue("ode");
break;
}
break;
case 3:
setProperty("Initial Volume");
// need to store additional undo data to be able to restore
// species initial concentrations / patricle numbers
mpCompartmentUndoData = new UndoCompartmentData(pCompartment);
break;
}
setText(QString(": Changed compartment %1").arg(getProperty().c_str()));
}
