#include <SEDMLImporter.h>

Collaboration diagram for SEDMLImporter:

Public Member Functions
void	deleteCopasiModel ()

const std::string	getArchiveFileName ()

CProcessReport *	getImportHandlerAddr ()

CModel *	importFirstSBMLModel (CProcessReport pImportHandler, SBMLDocument &pSBMLDocument, std::map< CCopasiObject , SBase > &copasi2sbmlmap, CListOfLayouts &prLol, CCopasiDataModel pDataModel)

void	importTasks (std::map< CCopasiObject , SedBase > &copasi2sedmlmap)

CModel *	parseSEDML (const std::string &sedmlDocumentText, CProcessReport pImportHandler, SBMLDocument &pSBMLDocument, SedDocument &pSEDMLDocument, std::map< CCopasiObject , SedBase * > &copasi2sedmlmap, std::map< CCopasiObject , SBase > &copasi2sbmlmap, CListOfLayouts &prLol, COutputDefinitionVector &plotList, CCopasiDataModel *pDataModel)

void	readListOfPlotsFromSedMLOutput (COutputDefinitionVector pPlotList, CModel pModel, SedDocument pSedDocument, std::map< CCopasiObject , SedBase * > &copasi2sedmlmap)

CModel *	readSEDML (std::string filename, CProcessReport pImportHandler, SBMLDocument &pSBMLDocument, SedDocument &pSedDocument, std::map< CCopasiObject , SedBase * > &copasi2sedmlmap, std::map< CCopasiObject , SBase > &copasi2sbmlmap, CListOfLayouts &prLol, COutputDefinitionVector &plotList, CCopasiDataModel *pDataModel)

void	restoreFunctionDB ()

	SEDMLImporter ()

void	setImportHandler (CProcessReport *pHandler)

void	updateCopasiTaskForSimulation (SedSimulation sedmlsim, std::map< CCopasiObject , SedBase * > &copasi2sedmlmap)

	~SEDMLImporter ()

Static Protected Member Functions
static bool	areApproximatelyEqual (const double &x, const double &y, const double &t=1e-9)

static C_FLOAT64	round (const C_FLOAT64 &x)

Protected Attributes
std::string	mArchiveFileName

size_t	mhImportStep

std::set< unsigned int >	mIgnoredSEDMLMessages

std::string	mImportedModel

unsigned C_INT32	mImportStep

bool	mIncompleteModel

unsigned int	mLevel

unsigned int	mOriginalLevel

CModel *	mpCopasiModel

CCopasiDataModel *	mpDataModel

CProcessReport *	mpImportHandler

SedDocument *	mpSEDMLDocument

std::map< CReportDefinition *, std::string >	mReportMap

unsigned C_INT32	mTotalSteps

std::set< std::string >	mUsedSEDMLIds

bool	mUsedSEDMLIdsPopulated

unsigned int	mVersion

Detailed Description

Definition at line 37 of file SEDMLImporter.h.

Constructor & Destructor Documentation

SEDMLImporter::SEDMLImporter ( )

Constructor that initializes speciesMap and the FunctionDB object

Definition at line 953 of file SEDMLImporter.cpp.

References mIgnoredSEDMLMessages.

                             :
   mIgnoredSEDMLMessages(),
   mIncompleteModel(false),
   mLevel(0),
   mOriginalLevel(0),
   mVersion(0),
   mpDataModel(NULL),
   mpCopasiModel(NULL),
   mpSEDMLDocument(NULL),
   mpImportHandler(NULL),
   mImportStep(0),
   mhImportStep(C_INVALID_INDEX),
   mTotalSteps(0),
   mUsedSEDMLIds(),
   mUsedSEDMLIdsPopulated(false),
   mImportedModel(),
   mReportMap()
 {
 
   this->mIgnoredSEDMLMessages.insert(10501);
 }

SEDMLImporter::~SEDMLImporter ( )

Destructor that does nothing.

Definition at line 982 of file SEDMLImporter.cpp.

References mReportMap.

 {
   mReportMap.clear();
 }

Member Function Documentation

static bool SEDMLImporter::areApproximatelyEqual	(	const double &	x,
		const double &	y,
		const double &	t = `1e-9`
	)

staticprotected

void SEDMLImporter::deleteCopasiModel ( )

This call deletes an existing COPASI model. The method can e.g. be called to clean up if an import fails.

Definition at line 987 of file SEDMLImporter.cpp.

References mpCopasiModel.

 {
   if (this->mpCopasiModel != NULL)
     {
       delete this->mpCopasiModel;
       this->mpCopasiModel = NULL;
     }
 }

const std::string SEDMLImporter::getArchiveFileName ( )

Definition at line 87 of file SEDMLImporter.cpp.

References mArchiveFileName.

88 {return mArchiveFileName;}

SEDMLImporter::mArchiveFileName

std::string mArchiveFileName

Definition: SEDMLImporter.h:48

CProcessReport * SEDMLImporter::getImportHandlerAddr ( )

Definition at line 84 of file SEDMLImporter.cpp.

References mpImportHandler.

85 {return mpImportHandler;}

SEDMLImporter::mpImportHandler

CProcessReport * mpImportHandler

Definition: SEDMLImporter.h:60

CModel * SEDMLImporter::importFirstSBMLModel	(	CProcessReport *	pImportHandler,
		SBMLDocument *&	pSBMLDocument,
		std::map< CCopasiObject , SBase > &	copasi2sbmlmap,
		CListOfLayouts *&	prLol,
		CCopasiDataModel *	pDataModel
	)

Imports the first viable SBML model

Definition at line 805 of file SEDMLImporter.cpp.

References applyAttributeChange(), SBMLImporter::deleteCopasiModel(), CDirEntry::dirName(), CCopasiMessage::EXCEPTION, CDirEntry::exist(), CLocaleString::fromUtf8(), CCopasiRootContainer::getFunctionList(), CModel::getModelParameterSet(), MCSEDML, mImportedModel, mpCopasiModel, mpDataModel, mpSEDMLDocument, SBMLImporter::parseSBML(), SBMLImporter::restoreFunctionDB(), CDirEntry::Separator, SBMLImporter::setImportCOPASIMIRIAM(), SBMLImporter::setImportHandler(), CCopasiDataModel::setSBMLFileName(), and CCopasiMessage::WARNING.

Referenced by parseSEDML().

 {
   std::string SBMLFileName, fileContent;
 
   unsigned int ii, iiMax = mpSEDMLDocument->getListOfModels()->size();
 
   if (iiMax < 1)
     {
       CCopasiMessage(CCopasiMessage::EXCEPTION, MCSEDML + 2);
     }
 
   if (iiMax > 1)
     {
       CCopasiMessage(CCopasiMessage::WARNING, "COAPSI currently only supports the import of SED-ML models, that involve one model only. Only the simulations for the first model will be imported");
     }
 
   std::string modelSource = ""; //must be taken from SEDML document.
   std::string modelId = ""; // to ensure only one model is imported since only one model in SEDML file is supported
   SedModel* sedmlModel = NULL;
 
   for (ii = 0; ii < iiMax; ++ii)
     {
       sedmlModel = mpSEDMLDocument->getModel(ii);
 
       // need to also allow for the specific urns like
       // urn:sedml:language:sbml.level-3.version-1
       if (sedmlModel->getLanguage().find("urn:sedml:language:sbml") == std::string::npos)
         CCopasiMessage(CCopasiMessage::EXCEPTION,
                        "Sorry currently, only SBML models are supported.");
 
       if (sedmlModel->getSource() != modelId)
         {
           modelId = sedmlModel->getId();
 
           if ((sedmlModel->getListOfChanges()->size()) > 0)
             CCopasiMessage(CCopasiMessage::WARNING, "Currently there is only limited support for "
                            "changing model entities. Only value changes are imported into the model.");
 
           modelSource = sedmlModel->getSource();
           break;
         }
     }
 
   assert(modelSource != "");
 
   //process the archive file and get the SBML model file
   //SEDMLUtils utils;
   //int success = utils.processArchive(pDataModel->getSEDMLFileName(), SBMLFileName, fileContent);
 
   std::string FileName;
 
   if (CDirEntry::exist(modelSource))
     FileName = modelSource;
   else
     FileName = CDirEntry::dirName(pDataModel->getSEDMLFileName())
                + CDirEntry::Separator + modelSource;
 
   std::ifstream file(CLocaleString::fromUtf8(FileName).c_str());
 
   if (!file)
     {
       CCopasiMessage(CCopasiMessage::EXCEPTION, MCSEDML + 4,
                      FileName.c_str());
     }
 
   //set the SBML file name for later use
   pDataModel->setSBMLFileName(FileName);
   std::ostringstream sbmlStringStream;
   char c;
 
   while (file.get(c))
     {
       sbmlStringStream << c;
     }
 
   file.clear();
   file.close();
 
   std::ifstream File(CLocaleString::fromUtf8(FileName).c_str());
 
   SBMLImporter importer;
   // Right now we always import the COPASI MIRIAM annotation if it is there.
   // Later this will be settable by the user in the preferences dialog
   importer.setImportCOPASIMIRIAM(true);
   importer.setImportHandler(pImportHandler);
 
   mpCopasiModel = NULL;
 
   std::map<CCopasiObject*, SBase*> Copasi2SBMLMap;
 
   try
     {
       mpCopasiModel = importer.parseSBML(sbmlStringStream.str(),
                                          CCopasiRootContainer::getFunctionList(), pSBMLDocument,
                                          Copasi2SBMLMap, prLol, mpDataModel);
     }
 
   catch (CCopasiException & except)
     {
       importer.restoreFunctionDB();
       importer.deleteCopasiModel();
       //    popData();
 
       throw except;
     }
 
   if (mpCopasiModel == NULL)
     {
       importer.restoreFunctionDB();
       importer.deleteCopasiModel();
       //   popData();
       return NULL;
     }
 
   mImportedModel = modelId;
 
   // apply possible changes to the model
   if (sedmlModel != NULL && sedmlModel->getNumChanges() > 0)
     {
       CModelParameterSet& set = mpCopasiModel->getModelParameterSet();
       bool valueChanged = false;
 
       for (unsigned int i = 0; i < sedmlModel->getNumChanges(); ++i)
         {
           SedChangeAttribute* change = dynamic_cast<SedChangeAttribute*>(sedmlModel->getChange(i));
 
           if (change == NULL) continue;
 
           const std::string& target = change->getTarget();
           const std::string& newValue = change->getNewValue();
 
           if (!applyAttributeChange(mpCopasiModel, set, target, newValue))
             {
               CCopasiMessage(CCopasiMessage::WARNING, "Could not apply change for target: '%s'", target.c_str());
             }
         }
     }
 
   return mpCopasiModel;
 }

void SEDMLImporter::importTasks ( std::map< CCopasiObject *, SedBase * > & copasi2sedmlmap )

Import all tasks for the imported SBML model

Definition at line 613 of file SEDMLImporter.cpp.

References CCopasiVectorN< CType >::add(), CScanProblem::addScanItem(), CCopasiParameterGroup::getParameter(), CCopasiTask::getProblem(), CCopasiDataModel::getReportDefinitionList(), CCopasiDataModel::getTaskList(), CCopasiParameter::getValue(), mImportedModel, mpCopasiModel, mpDataModel, mpSEDMLDocument, mReportMap, CCopasiParameter::Value::pBOOL, CCopasiParameter::Value::pDOUBLE, SEDMLUtils::resolveXPath(), CScanProblem::SCAN_LINEAR, CScanProblem::SCAN_REPEAT, CReport::setAppend(), CReport::setConfirmOverwrite(), CScanProblem::setContinueFromCurrentState(), CScanProblem::setOutputInSubtask(), CReport::setReportDefinition(), CCopasiTask::setScheduled(), CScanProblem::setSubtask(), CReport::setTarget(), CCopasiTask::steadyState, CCopasiTask::timeCourse, updateCopasiTaskForSimulation(), and CCopasiMessage::WARNING.

Referenced by parseSEDML().

 {
 
   for (unsigned int i = 0; i < mpSEDMLDocument->getNumTasks(); ++i)
     {
       SedTask * current = mpSEDMLDocument->getTask(i);
 
       // skip taks for models we did not import
       if (current->isSetModelReference() && current->getModelReference() != this->mImportedModel)
         continue;
 
       switch (current->getTypeCode())
         {
           case SEDML_TASK:
           {
             SedSimulation* sedmlsim =
               mpSEDMLDocument->getSimulation(current->getSimulationReference());
             updateCopasiTaskForSimulation(sedmlsim, copasi2sedmlmap);
             break;
           }
 
           case SEDML_TASK_REPEATEDTASK:
           {
             SedRepeatedTask *repeat = static_cast<SedRepeatedTask*>(current);
             SedRange* range = repeat->getRange(repeat->getRangeId());
 
             if (range == NULL || range->getTypeCode() != SEDML_RANGE_UNIFORMRANGE)
               {
                 CCopasiMessage(CCopasiMessage::WARNING, "This version of COPASI only supports uniform ranges.");
                 continue;
               }
 
             SedUniformRange* urange = static_cast<SedUniformRange*>(range);
             CScanTask *tTask = static_cast<CScanTask*>((*mpDataModel->getTaskList())["Scan"]);
             tTask->setScheduled(true);
             CScanProblem *pProblem = static_cast<CScanProblem*>(tTask->getProblem());
 
             if (urange != NULL && repeat->getNumTaskChanges() == 0)
               {
                 pProblem->addScanItem(CScanProblem::SCAN_REPEAT, urange->getNumberOfPoints());
               }
             else
               {
                 for (unsigned int j = 0; j < repeat->getNumTaskChanges(); ++j)
                   {
                     SedSetValue* sv = repeat->getTaskChange(j);
 
                     if (SBML_formulaToString(sv->getMath()) != sv->getRange())
                       {
                         CCopasiMessage(CCopasiMessage::WARNING,
                                        "This version of COPASI only supports setValue elements that apply range values.");
                       }
 
                     std::string target = sv->getTarget();
                     const CCopasiObject * obj = SEDMLUtils::resolveXPath(mpCopasiModel, target, true);
 
                     if (obj == NULL)
                       {
                         CCopasiMessage(CCopasiMessage::WARNING, "This version of COPASI only supports modifications of initial values.");
                         continue;
                       }
 
                     CCopasiParameterGroup*group = pProblem->addScanItem(CScanProblem::SCAN_LINEAR, urange->getNumberOfPoints(), obj);
                     *group->getParameter("Minimum")->getValue().pDOUBLE = urange->getStart();
                     *group->getParameter("Maximum")->getValue().pDOUBLE = urange->getEnd();
                     *group->getParameter("log")->getValue().pBOOL =
                       (!urange->isSetType() || urange->getType().empty() ||  urange->getType() == "linear") ? false
                       : true;
                   }
               }
 
             if (repeat->getNumSubTasks() != 1)
               {
                 CCopasiMessage(CCopasiMessage::WARNING, "This version of COPASI only supports repeatedTasks with one subtask.");
                 continue;
               }
 
             pProblem->setContinueFromCurrentState(!repeat->getResetModel());
 
             SedSubTask* subTask = repeat->getSubTask(0);
 
             if (!subTask->isSetTask())
               {
                 CCopasiMessage(CCopasiMessage::WARNING, "This version of COPASI only supports repeatedTasks with one subtask that has a valid task reference.");
                 continue;
               }
 
             SedTask* actualSubTask = mpSEDMLDocument->getTask(subTask->getTask());
 
             if (actualSubTask == NULL || !actualSubTask->isSetSimulationReference())
               {
                 CCopasiMessage(CCopasiMessage::WARNING, "This version of COPASI only supports repeatedTasks with one subtask that itself is a task with simulation reference.");
                 continue;
               }
 
             int code = mpSEDMLDocument->getSimulation(actualSubTask->getSimulationReference())->getTypeCode();
 
             if (code == SEDML_SIMULATION_STEADYSTATE)
               {
                 pProblem->setSubtask(CCopasiTask::steadyState);
                 pProblem->setOutputInSubtask(false);
               }
             else if (code == SEDML_SIMULATION_ONESTEP || code == SEDML_SIMULATION_UNIFORMTIMECOURSE)
               {
                 pProblem->setSubtask(CCopasiTask::timeCourse);
               }
 
             break;
           }
 
           default:
           {
             const char* name = SedTypeCode_toString(current->getTypeCode());
             CCopasiMessage(CCopasiMessage::WARNING,
                            "Encountered unsupported Task type '%s'. This task cannot be imported in COPASI",
                            name != NULL ? name : "unknown");
           }
         }
     }
 
   std::map<CReportDefinition*, std::string>::const_iterator it = mReportMap.begin();
 
   for (; it != mReportMap.end(); ++it)
     {
       mpDataModel->getReportDefinitionList()->add(it->first);
       CReport& report = ((*mpDataModel->getTaskList())[it->second])->getReport();
       report.setReportDefinition(it->first);
       report.setTarget(it->second + ".txt");
       report.setConfirmOverwrite(false);
       report.setAppend(false);
     }
 }

CModel * SEDMLImporter::parseSEDML	(	const std::string &	sedmlDocumentText,
		CProcessReport *	pImportHandler,
		SBMLDocument *&	pSBMLDocument,
		SedDocument *&	pSEDMLDocument,
		std::map< CCopasiObject , SedBase > &	copasi2sedmlmap,
		std::map< CCopasiObject , SBase > &	copasi2sbmlmap,
		CListOfLayouts *&	prLol,
		COutputDefinitionVector *&	pPlotList,
		CCopasiDataModel *	pDataModel
	)

Function parses an SEDML document with libsedml and converts it to a COPASI CModel object which is returned. Deletion of the returned pointer is up to the caller.

Definition at line 435 of file SEDMLImporter.cpp.

References CProcessReport::addItem(), C_INT32, C_INVALID_INDEX, CCopasiMessage::ERROR, CCopasiMessage::ERROR_FILTERED, CCopasiMessage::EXCEPTION, CProcessReport::finishItem(), importFirstSBMLModel(), importTasks(), MCSEDML, MCXML, mhImportStep, mIgnoredSEDMLMessages, mImportStep, mLevel, mOriginalLevel, mpCopasiModel, mpDataModel, mpImportHandler, mpSEDMLDocument, mReportMap, mTotalSteps, mUsedSEDMLIdsPopulated, mVersion, CCopasiMessage::RAW, readListOfPlotsFromSedMLOutput(), CProcessReport::setName(), CCopasiMessage::WARNING, and CCopasiMessage::WARNING_FILTERED.

Referenced by readSEDML().

 {
   mReportMap.clear();
   this->mUsedSEDMLIdsPopulated = false;
 
   mpDataModel = pDataModel;
   assert(mpDataModel != NULL);
 
   this->mpCopasiModel = NULL;
 
   SedReader reader;
 
   mImportStep = 0;
 
   if (mpImportHandler)
     {
       mpImportHandler->setName("Importing SED-ML file...");
       mTotalSteps = 11;
       mhImportStep = mpImportHandler->addItem("Step", mImportStep,
                                               &mTotalSteps);
     }
 
   unsigned C_INT32 step = 0, totalSteps = 0;
   size_t hStep = C_INVALID_INDEX;
 
   if (this->mpImportHandler != 0)
     {
       step = 0;
       totalSteps = 1;
       hStep = mpImportHandler->addItem("Reading SED-ML file...", step,
                                        &totalSteps);
     }
 
   mpSEDMLDocument = reader.readSedMLFromString(sedmlDocumentText);
 
   assert(mpSEDMLDocument != NULL);
 
   if (mpImportHandler)
     mpImportHandler->finishItem(hStep);
 
   if (this->mpImportHandler != 0)
     {
       step = 0;
       totalSteps = 1;
       hStep = mpImportHandler->addItem("Checking consistency...", step,
                                        &totalSteps);
     }
 
   if (mpImportHandler)
     mpImportHandler->finishItem(hStep);
 
   int fatal = -1;
   unsigned int i, iMax = mpSEDMLDocument->getNumErrors();
 
   for (i = 0; (i < iMax) && (fatal == -1); ++i)
     {
       const SedError* pSEDMLError = mpSEDMLDocument->getError(i);
 
       CCopasiMessage::Type messageType = CCopasiMessage::RAW;
 
       switch (pSEDMLError->getSeverity())
         {
 
           case LIBSEDML_SEV_WARNING:
 
             // if issued as warning, this message is to be disregarded,
             // it was a bug in earlier versions of libSEDML
             if (pSEDMLError->getErrorId() == SedInvalidNamespaceOnSed)
               continue;
 
             if (mIgnoredSEDMLMessages.find(pSEDMLError->getErrorId())
                 != mIgnoredSEDMLMessages.end())
               {
                 messageType = CCopasiMessage::WARNING_FILTERED;
               }
             else
               {
                 messageType = CCopasiMessage::WARNING;
               }
 
             CCopasiMessage(messageType, MCSEDML + 6, "WARNING",
                            pSEDMLError->getErrorId(), pSEDMLError->getLine(),
                            pSEDMLError->getColumn(),
                            pSEDMLError->getMessage().c_str());
             break;
 
           case LIBSEDML_SEV_ERROR:
 
             if (mIgnoredSEDMLMessages.find(pSEDMLError->getErrorId())
                 != mIgnoredSEDMLMessages.end())
               {
                 messageType = CCopasiMessage::ERROR_FILTERED;
               }
 
             CCopasiMessage(messageType, MCSEDML + 6, "ERROR",
                            pSEDMLError->getErrorId(), pSEDMLError->getLine(),
                            pSEDMLError->getColumn(),
                            pSEDMLError->getMessage().c_str());
             break;
 
           case LIBSEDML_SEV_FATAL:
 
             // treat unknown as fatal
           default:
 
             if (pSEDMLError->getErrorId() == 10804)
               {
                 // this error indicates a problem with a notes element
                 // although libsedml flags this as fatal, we would still
                 // like to read the model
                 CCopasiMessage(messageType, MCSEDML + 6, "ERROR",
                                pSEDMLError->getErrorId(), pSEDMLError->getLine(),
                                pSEDMLError->getColumn(),
                                pSEDMLError->getMessage().c_str());
               }
             else
               {
                 fatal = i;
               }
 
             break;
         }
     }
 
   if (fatal != -1)
     {
       const XMLError* pSEDMLError = mpSEDMLDocument->getError(fatal);
       CCopasiMessage Message(CCopasiMessage::EXCEPTION, MCXML + 2,
                              pSEDMLError->getLine(), pSEDMLError->getColumn(),
                              pSEDMLError->getMessage().c_str());
 
       if (mpImportHandler)
         mpImportHandler->finishItem(mhImportStep);
 
       return NULL;
     }
 
   if (mpSEDMLDocument->getListOfModels() == NULL)
     {
       CCopasiMessage Message(CCopasiMessage::ERROR, MCSEDML + 2);
 
       if (mpImportHandler)
         mpImportHandler->finishItem(mhImportStep);
 
       return NULL;
     }
 
   //delete reader;
   pSEDMLDocument = mpSEDMLDocument;
   this->mLevel = pSEDMLDocument->getLevel();
 
   this->mOriginalLevel = this->mLevel;
   this->mVersion = pSEDMLDocument->getVersion();
 
   importFirstSBMLModel(pImportHandler, pSBMLDocument, copasi2sbmlmap, prLol, pDataModel);
 
   pPlotList = new COutputDefinitionVector("OutputDefinitions", mpDataModel);
   readListOfPlotsFromSedMLOutput(pPlotList, mpCopasiModel, pSEDMLDocument, copasi2sedmlmap);
 
   importTasks(copasi2sedmlmap);
 
   if (mpImportHandler)
     mpImportHandler->finishItem(mhImportStep);
 
   return mpCopasiModel;
 
   return NULL;
 }

void SEDMLImporter::readListOfPlotsFromSedMLOutput	(	COutputDefinitionVector *	pPlotList,
		CModel *	pModel,
		SedDocument *	pSedDocument,
		std::map< CCopasiObject , SedBase > &	copasi2sedmlmap
	)

Definition at line 233 of file SEDMLImporter.cpp.

References CPlotItem::addChannel(), CPlotSpecification::createItem(), COutputDefinitionVector::createPlotSpec(), CPlotItem::curve2d, CCopasiMessage::EXCEPTION, CReportDefinition::getBodyAddr(), CCopasiObject::getCN(), CCopasiDataModel::getCopasi2SBMLMap(), CReportDefinition::getHeaderAddr(), SEDMLUtils::getNextId(), CCopasiObject::getObjectDataModel(), CCopasiObject::getObjectDisplayName(), CCopasiDataModel::getReportDefinitionList(), CReportDefinition::getSeparator(), isScan(), isTC(), mpDataModel, mpSEDMLDocument, mReportMap, CPlotItem::plot2d, SEDMLUtils::resolveDatagenerator(), CReportDefinition::setComment(), CReportDefinition::setIsTable(), CPlotSpecification::setLogX(), CPlotSpecification::setLogY(), CReportDefinition::setSeparator(), and CCopasiParameterGroup::setValue().

Referenced by parseSEDML().

 {
   size_t i, numOutput = pSEDMLDocument->getNumOutputs();
 
   std::map<CCopasiObject*, SBase*>& copasiMap = pModel->getObjectDataModel()->getCopasi2SBMLMap();
 
   CReportDefinitionVector* pReports = mpDataModel->getReportDefinitionList();
 
   for (i = 0; i < numOutput; ++i)
     {
       SedOutput* current = pSEDMLDocument->getOutput(i);
 
       switch (current->getTypeCode())
         {
           case SEDML_OUTPUT_REPORT:
           {
             SedReport* r = static_cast<SedReport*>(current);
             std::string name = current->isSetName() ? current->getName() : current->getId();
             CReportDefinition* def = new CReportDefinition(name);
             int count = 0;
 
             // creation fails on duplicated name!
             while (def == NULL)
               {
                 def = new CReportDefinition(SEDMLUtils::getNextId(name + " ", ++count));
               }
 
             def->setComment("Import from SED-ML");
 
             def->setIsTable(false);
             def->setSeparator(CCopasiReportSeparator(", "));
 
             std::vector<CRegisteredObjectName>* pHeader = def->getHeaderAddr();
             std::vector<CRegisteredObjectName>* pBody = def->getBodyAddr();
 
             bool isTimeCourse = false;
             bool isScanTask = false;
 
             for (size_t i = 0; i < r->getNumDataSets(); ++i)
               {
                 SedDataSet* ds = r->getDataSet(i);
                 const SedDataGenerator* generator = pSEDMLDocument->getDataGenerator(ds->getDataReference());
                 const CCopasiObject * tmp = SEDMLUtils::resolveDatagenerator(pModel, generator);
 
                 if (generator == NULL || tmp == NULL) continue;
 
                 std::string title = ds->isSetLabel() ? ds->getLabel() : generator->isSetName() ? generator->getName() : ds->getId();
 
                 pHeader->push_back(CCopasiStaticString(title).getCN());
                 pHeader->push_back(def->getSeparator().getCN());
 
                 pBody->push_back(tmp->getCN());
                 pBody->push_back(def->getSeparator().getCN());
 
                 if (!isTimeCourse && !isScanTask)
                   for (size_t j = 0; j < generator->getNumVariables(); ++j)
                     {
                       const SedTask* t = mpSEDMLDocument->getTask(generator->getVariable(j)->getTaskReference());
 
                       if (t == NULL) continue;
 
                       isScanTask = t->getTypeCode() == SEDML_TASK_REPEATEDTASK && isScan((const SedRepeatedTask*)t);
                       isTimeCourse = isTC(t);
                     }
               }
 
             // assign report to scan task
             if (isScanTask)
               {
                 mReportMap[def] = "Scan";
               }
 
             // assign report to Timecourse task
             if (isTimeCourse)
               {
                 mReportMap[def] = "Time-Course";
               }
 
             break;
           }
 
           case SEDML_OUTPUT_PLOT2D: //get the curves data
           {
             SedPlot2D* p = static_cast<SedPlot2D*>(current);
             std::string name = current->isSetName() ? current->getName() :
                                current->getId();
             CPlotSpecification* pPl = pLotList->createPlotSpec(
                                         name, CPlotItem::plot2d);
 
             int count = 0;
 
             while (pPl == NULL)
               {
                 // creation fails on duplicated name!
                 pPl = pLotList->createPlotSpec(
                         SEDMLUtils::getNextId(name + " ", ++count), CPlotItem::plot2d);
               }
 
             bool logX = false;
             bool logY = false;
 
             for (unsigned int ic = 0; ic < p->getNumCurves(); ++ic)
               {
                 SedCurve *curve = p->getCurve(ic);
 
                 std::string xDataReference = curve->getXDataReference();
                 std::string yDataReference = curve->getYDataReference();
 
                 const SedDataGenerator* xGenerator = pSEDMLDocument->getDataGenerator(xDataReference);
                 const SedDataGenerator* yGenerator = pSEDMLDocument->getDataGenerator(yDataReference);
 
                 //create the curves
                 const CCopasiObject * tmpX = SEDMLUtils::resolveDatagenerator(pModel, xGenerator);
                 const CCopasiObject * tmpY = SEDMLUtils::resolveDatagenerator(pModel, yGenerator);
 
                 if (tmpX != NULL && tmpY != NULL)
                   {
 
                     std::string  itemTitle;
 
                     if (curve->isSetName())
                       itemTitle = curve->getName();
                     else if (yGenerator != NULL && yGenerator->isSetName())
                       itemTitle = yGenerator->getName();
                     else
                       itemTitle = tmpY->getObjectDisplayName();
 
                     CPlotItem * plItem = pPl->createItem(itemTitle, CPlotItem::curve2d);
                     plItem->setValue("Line width", 2.0);
                     plItem->addChannel(tmpX->getCN());
                     plItem->addChannel(tmpY->getCN());
                   }
 
                 logX = logX || (curve->isSetLogX() && curve->getLogX());
                 logY = logY || (curve->isSetLogY() && curve->getLogY());
               }
 
             pPl->setLogX(logX);
             pPl->setLogY(logY);
             break;
           }
 
           default:
             CCopasiMessage(CCopasiMessage::EXCEPTION, "SEDMLImporter Error: No support for this plot: typecode = %d", current->getTypeCode());
             break;
         }
     }
 }

CModel * SEDMLImporter::readSEDML	(	std::string	filename,
		CProcessReport *	pImportHandler,
		SBMLDocument *&	pSBMLDocument,
		SedDocument *&	pSedDocument,
		std::map< CCopasiObject , SedBase > &	copasi2sedmlmap,
		std::map< CCopasiObject , SBase > &	copasi2sbmlmap,
		CListOfLayouts *&	prLol,
		COutputDefinitionVector *&	plotList,
		CCopasiDataModel *	pDataModel
	)

Function reads an SEDML file with libsedml and converts it to a Copasi CModel

Definition at line 388 of file SEDMLImporter.cpp.

References CCopasiMessage::EXCEPTION, CLocaleString::fromUtf8(), MCSEDML, and parseSEDML().

 {
   // convert filename to the locale encoding
   std::ifstream file(CLocaleString::fromUtf8(filename).c_str());
 
   if (!file)
     {
       CCopasiMessage(CCopasiMessage::EXCEPTION, MCSEDML + 5, filename.c_str());
     }
 
   std::ostringstream stringStream;
   char c;
 
   while (file.get(c))
     {
       stringStream << c;
     }
 
   file.clear();
   file.close();
 
   //using libzip to read SEDML file
   /*  SEDMLUtils utils;
   std::string SEDMLFileName, fileContent("");
   SEDMLFileName = "sedml.xml";
 
   int success = utils.processArchive(filename, SEDMLFileName, fileContent);*/
 
   pDataModel->setSEDMLFileName(filename);
 
   return this->parseSEDML(stringStream.str(), pImportHandler,
                           pSBMLDocument, pSedDocument, copasi2sedmlmap, copasi2sbmlmap, prLol,  plotList, pDataModel);
 }

void SEDMLImporter::restoreFunctionDB ( )

Definition at line 975 of file SEDMLImporter.cpp.

976 {

977 }

C_FLOAT64 SEDMLImporter::round ( const C_FLOAT64 & x )

staticprotected

SEDMLImporter.cpp

Rev:

: Revision of last commit

Author:

: Author of last commit

Date:

: Date of last commit

HeadURL:

Id:

Definition at line 75 of file SEDMLImporter.cpp.

 {
   return
     x < 0.0 ? -floor(-x + 0.5) : floor(x + 0.5);
 }

void SEDMLImporter::setImportHandler ( CProcessReport * pHandler )

Definition at line 81 of file SEDMLImporter.cpp.

References mpImportHandler.

82 {mpImportHandler = pHandler;}

SEDMLImporter::mpImportHandler

CProcessReport * mpImportHandler

Definition: SEDMLImporter.h:60

void SEDMLImporter::updateCopasiTaskForSimulation	(	SedSimulation *	sedmlsim,
		std::map< CCopasiObject , SedBase > &	copasi2sedmlmap
	)

Updates COPASI tasks for a given SedML Simulation

Creates and returns a COPASI CTrajectoryTask from the SEDML simulation given as argument.

Definition at line 94 of file SEDMLImporter.cpp.

References CCopasiMessage::EXCEPTION, CCopasiTask::getProblem(), CCopasiDataModel::getTaskList(), mpDataModel, SEDML_KISAO_STOCHASTIC, CTrajectoryProblem::setContinueSimultaneousEvents(), CTrajectoryProblem::setDuration(), CTrajectoryTask::setMethodType(), CTrajectoryProblem::setOutputStartTime(), CCopasiTask::setScheduled(), CTrajectoryProblem::setStepNumber(), and CCopasiMethod::stochastic.

Referenced by importTasks().

 {
 
   switch (sedmlsim->getTypeCode())
     {
       case SEDML_SIMULATION_UNIFORMTIMECOURSE:
       {
 
         CTrajectoryTask *tTask = static_cast<CTrajectoryTask*>((*mpDataModel->getTaskList())["Time-Course"]);
         tTask->setScheduled(true);
 
         CTrajectoryProblem* tProblem = static_cast<CTrajectoryProblem*>(tTask->getProblem());
         SedUniformTimeCourse* tc = static_cast<SedUniformTimeCourse*>(sedmlsim);
         tProblem->setOutputStartTime(tc->getOutputStartTime());
         tProblem->setDuration(tc->getOutputEndTime() - tc->getOutputStartTime());
         tProblem->setStepNumber(tc->getNumberOfPoints());
         tProblem->setContinueSimultaneousEvents(true);
 
         // TODO read kisao terms
         if (tc->isSetAlgorithm())
           {
             const SedAlgorithm* alg = tc->getAlgorithm();
 
             if (alg->isSetKisaoID())
               {
                 if (alg->getKisaoID() == SEDML_KISAO_STOCHASTIC)
                   {
                     tTask->setMethodType(CCopasiMethod::stochastic);
                   }
               }
           }
 
         break;
       }
 
       case SEDML_SIMULATION_ONESTEP:
       {
 
         CTrajectoryTask *tTask = static_cast<CTrajectoryTask*>((*mpDataModel->getTaskList())["Time-Course"]);
         tTask->setScheduled(true);
 
         CTrajectoryProblem* tProblem = static_cast<CTrajectoryProblem*>(tTask->getProblem());
         SedOneStep* step = static_cast<SedOneStep*>(sedmlsim);
         tProblem->setOutputStartTime(0);
         tProblem->setDuration(step->getStep());
         tProblem->setStepNumber(1);
 
         // TODO read kisao terms
 
         break;
       }
 
       case SEDML_SIMULATION_STEADYSTATE:
       {
         // nothing to be done for this one
         CSteadyStateTask *tTask = static_cast<CSteadyStateTask*>((*mpDataModel->getTaskList())["Steady-State"]);
         tTask->setScheduled(true);
 
         // TODO read kisao terms
         //CCopasiProblem* tProblem = static_cast<CCopasiProblem*>(tTask->getProblem());
         //SedSteadyState* tc = static_cast<SedSteadyState*>(sedmlsim);
 
         break;
       }
 
       default:
         CCopasiMessage(CCopasiMessage::EXCEPTION, "SEDMLImporter Error: encountered unknown simulation.");
         break;
     }
 }

Member Data Documentation

std::string SEDMLImporter::mArchiveFileName

protected

Definition at line 48 of file SEDMLImporter.h.

Referenced by getArchiveFileName().

size_t SEDMLImporter::mhImportStep

protected

Definition at line 62 of file SEDMLImporter.h.

Referenced by parseSEDML().

std::set<unsigned int> SEDMLImporter::mIgnoredSEDMLMessages

protected

Definition at line 49 of file SEDMLImporter.h.

Referenced by parseSEDML(), and SEDMLImporter().

std::string SEDMLImporter::mImportedModel

protected

Definition at line 68 of file SEDMLImporter.h.

Referenced by importFirstSBMLModel(), and importTasks().

unsigned C_INT32 SEDMLImporter::mImportStep

protected

Definition at line 61 of file SEDMLImporter.h.

Referenced by parseSEDML().

bool SEDMLImporter::mIncompleteModel

protected

Definition at line 50 of file SEDMLImporter.h.

unsigned int SEDMLImporter::mLevel

protected

Definition at line 51 of file SEDMLImporter.h.

Referenced by parseSEDML().

unsigned int SEDMLImporter::mOriginalLevel

protected

Definition at line 52 of file SEDMLImporter.h.

Referenced by parseSEDML().

CModel* SEDMLImporter::mpCopasiModel

protected

Definition at line 56 of file SEDMLImporter.h.

Referenced by deleteCopasiModel(), importFirstSBMLModel(), importTasks(), and parseSEDML().

CCopasiDataModel* SEDMLImporter::mpDataModel

protected

Definition at line 55 of file SEDMLImporter.h.

Referenced by importFirstSBMLModel(), importTasks(), parseSEDML(), readListOfPlotsFromSedMLOutput(), and updateCopasiTaskForSimulation().

CProcessReport* SEDMLImporter::mpImportHandler

protected

Definition at line 60 of file SEDMLImporter.h.

Referenced by getImportHandlerAddr(), parseSEDML(), and setImportHandler().

SedDocument* SEDMLImporter::mpSEDMLDocument

protected

Definition at line 58 of file SEDMLImporter.h.

Referenced by importFirstSBMLModel(), importTasks(), parseSEDML(), and readListOfPlotsFromSedMLOutput().

std::map<CReportDefinition*, std::string> SEDMLImporter::mReportMap

protected

Definition at line 70 of file SEDMLImporter.h.

Referenced by importTasks(), parseSEDML(), readListOfPlotsFromSedMLOutput(), and ~SEDMLImporter().

unsigned C_INT32 SEDMLImporter::mTotalSteps

protected

Definition at line 63 of file SEDMLImporter.h.

Referenced by parseSEDML().

std::set<std::string> SEDMLImporter::mUsedSEDMLIds

protected

Definition at line 65 of file SEDMLImporter.h.

bool SEDMLImporter::mUsedSEDMLIdsPopulated

protected

Definition at line 66 of file SEDMLImporter.h.

Referenced by parseSEDML().

unsigned int SEDMLImporter::mVersion

protected

Definition at line 53 of file SEDMLImporter.h.

Referenced by parseSEDML().

The documentation for this class was generated from the following files:

Public Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation