Example 1 with SedML
use of org.jlibsedml.SedML in project vcell by virtualcell.
the class ClientRequestManager method openAfterChecking.
private void openAfterChecking(VCDocumentInfo documentInfo, final TopLevelWindowManager requester, final boolean inNewWindow) {
final String DOCUMENT_INFO = "documentInfo";
final String SEDML_TASK = "SedMLTask";
final String SEDML_MODELS = "SedMLModels";
final String BNG_UNIT_SYSTEM = "bngUnitSystem";
final String BMDB_DEFAULT_APPLICATION = "Deterministic";
/* asynchronous and not blocking any window */
bOpening = true;
Hashtable<String, Object> hashTable = new Hashtable<String, Object>();
// may want to insert corrected VCDocumentInfo later if our import debugger
// corrects it (BNGL Debugger).
hashTable.put(DOCUMENT_INFO, documentInfo);
hashTable.put("isBMDB", false);
hashTable.put("isSEDML", false);
// start a thread that gets it and updates the GUI by creating a new document
// desktop
String taskName = null;
if (documentInfo instanceof ExternalDocInfo) {
taskName = "Importing document";
ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
File file = externalDocInfo.getFile();
if (file != null && !file.getName().isEmpty() && file.getName().endsWith("bngl")) {
BngUnitSystem bngUnitSystem = new BngUnitSystem(BngUnitOrigin.DEFAULT);
String fileText;
String originalFileText;
try {
fileText = BeanUtils.readBytesFromFile(file, null);
originalFileText = new String(fileText);
} catch (IOException e1) {
e1.printStackTrace();
DialogUtils.showErrorDialog(requester.getComponent(), "<html>Error reading file " + file.getPath() + "</html>");
return;
}
Reader reader = externalDocInfo.getReader();
boolean bException = true;
while (bException) {
try {
BioModel bioModel = createDefaultBioModelDocument(bngUnitSystem);
boolean bStochastic = true;
boolean bRuleBased = true;
SimulationContext ruleBasedSimContext = bioModel.addNewSimulationContext("temp NFSim app", SimulationContext.Application.RULE_BASED_STOCHASTIC);
List<SimulationContext> appList = new ArrayList<SimulationContext>();
appList.add(ruleBasedSimContext);
RbmModelContainer rbmModelContainer = bioModel.getModel().getRbmModelContainer();
RbmUtils.reactionRuleLabelIndex = 0;
RbmUtils.reactionRuleNames.clear();
ASTModel astModel = RbmUtils.importBnglFile(reader);
// for now, hasUnitSystem() always returns false
if (astModel.hasUnitSystem()) {
bngUnitSystem = astModel.getUnitSystem();
}
if (astModel.hasCompartments()) {
Structure struct = bioModel.getModel().getStructure(0);
if (struct != null) {
bioModel.getModel().removeStructure(struct);
}
}
BnglObjectConstructionVisitor constructionVisitor = null;
if (!astModel.hasMolecularDefinitions()) {
System.out.println("Molecular Definition Block missing.");
constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, false);
} else {
constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, true);
}
astModel.jjtAccept(constructionVisitor, rbmModelContainer);
bException = false;
} catch (final Exception e) {
e.printStackTrace(System.out);
BNGLDebuggerPanel panel = new BNGLDebuggerPanel(fileText, e);
int oKCancel = DialogUtils.showComponentOKCancelDialog(requester.getComponent(), panel, "Bngl Debugger: " + file.getName());
if (oKCancel == JOptionPane.CANCEL_OPTION || oKCancel == JOptionPane.DEFAULT_OPTION) {
throw new UserCancelException("Canceling Import");
}
// inserting <potentially> corrected DocumentInfo
fileText = panel.getText();
externalDocInfo = new ExternalDocInfo(panel.getText());
reader = externalDocInfo.getReader();
hashTable.put(DOCUMENT_INFO, externalDocInfo);
}
}
if (!originalFileText.equals(fileText)) {
// file has been modified
String message = "Importing <b>" + file.getName() + "</b> into vCell. <br>Overwrite the file on the disk?<br>";
message = "<html>" + message + "</html>";
Object[] options = { "Overwrite and Import", "Import Only", "Cancel" };
int returnCode = JOptionPane.showOptionDialog(requester.getComponent(), message, "Bngl Debugger", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, options, options[2]);
if (returnCode == JOptionPane.YES_OPTION) {
try {
FileWriter fw = new FileWriter(file);
fw.write(fileText);
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
} else if (returnCode == JOptionPane.CANCEL_OPTION || returnCode == JOptionPane.CLOSED_OPTION) {
return;
}
}
if (!(bngUnitSystem.getOrigin() == BngUnitOrigin.PARSER)) {
BNGLUnitsPanel panel = new BNGLUnitsPanel(bngUnitSystem);
int oKCancel = DialogUtils.showComponentOKCancelDialog(requester.getComponent(), panel, " Bngl Units Selector", null, false);
if (oKCancel == JOptionPane.CANCEL_OPTION || oKCancel == JOptionPane.DEFAULT_OPTION) {
// TODO: or do nothing and continue with default values?
return;
} else {
bngUnitSystem = panel.getUnits();
}
}
hashTable.put(BNG_UNIT_SYSTEM, bngUnitSystem);
} else if (file != null && !file.getName().isEmpty() && file.getName().toLowerCase().endsWith(".sedml")) {
try {
XMLSource xmlSource = externalDocInfo.createXMLSource();
File sedmlFile = xmlSource.getXmlFile();
SedML sedml = Libsedml.readDocument(sedmlFile).getSedMLModel();
if (sedml == null || sedml.getModels().isEmpty()) {
return;
}
// AbstractTask chosenTask = SEDMLChooserPanel.chooseTask(sedml, requester.getComponent(),
// file.getName());
List<SedML> sedmls = new ArrayList<>();
sedmls.add(sedml);
hashTable.put(SEDML_MODELS, sedmls);
// hashTable.put(SEDML_TASK, chosenTask);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("failed to read document: " + e.getMessage(), e);
}
} else if (file != null && !file.getName().isEmpty() && (file.getName().toLowerCase().endsWith(".sedx") || file.getName().toLowerCase().endsWith(".omex"))) {
try {
ArchiveComponents ac = null;
ac = Libsedml.readSEDMLArchive(new FileInputStream(file));
List<SEDMLDocument> docs = ac.getSedmlDocuments();
List<SedML> sedmls = new ArrayList<>();
for (SEDMLDocument doc : docs) {
SedML sedml = doc.getSedMLModel();
if (sedml == null) {
throw new RuntimeException("Failed importing " + file.getName());
}
if (sedml.getModels().isEmpty()) {
throw new RuntimeException("Unable to find any model in " + file.getName());
}
sedmls.add(sedml);
}
// AbstractTask chosenTask = SEDMLChooserPanel.chooseTask(sedml, requester.getComponent(),
// file.getName());
hashTable.put(SEDML_MODELS, sedmls);
// hashTable.put(SEDML_TASK, chosenTask);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("failed to read archive: " + e.getMessage(), e);
}
}
} else {
taskName = "Loading document '" + documentInfo.getVersion().getName() + "' from database";
}
AsynchClientTask task0 = new AsynchClientTask(taskName, AsynchClientTask.TASKTYPE_SWING_BLOCKING) {
public void run(Hashtable<String, Object> hashTable) throws Exception {
if (!inNewWindow) {
// request was to replace the document in an existing window
getMdiManager().blockWindow(requester.getManagerID());
}
}
};
AsynchClientTask task1 = new AsynchClientTask(taskName, AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {
@Override
public void run(Hashtable<String, Object> hashTable) throws Exception {
VCDocument doc = null;
List<VCDocument> docs = new ArrayList<>();
boolean isBMDB = false;
boolean isSEDML = false;
VCDocumentInfo documentInfo = (VCDocumentInfo) hashTable.get(DOCUMENT_INFO);
if (documentInfo instanceof BioModelInfo) {
BioModelInfo bmi = (BioModelInfo) documentInfo;
doc = getDocumentManager().getBioModel(bmi);
} else if (documentInfo instanceof MathModelInfo) {
MathModelInfo mmi = (MathModelInfo) documentInfo;
doc = getDocumentManager().getMathModel(mmi);
} else if (documentInfo instanceof GeometryInfo) {
GeometryInfo gmi = (GeometryInfo) documentInfo;
doc = getDocumentManager().getGeometry(gmi);
} else if (documentInfo instanceof ExternalDocInfo) {
ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
File file = externalDocInfo.getFile();
if (file != null && !file.getName().isEmpty() && (file.getName().toLowerCase().endsWith(".sedx") || file.getName().toLowerCase().endsWith(".omex"))) {
TranslationLogger transLogger = new TranslationLogger(requester);
// iterate through one or more SEDML objects
List<SedML> sedmls = (List<SedML>) hashTable.get(SEDML_MODELS);
for (SedML sedml : sedmls) {
// default to import all tasks
List<VCDocument> vcdocs = XmlHelper.sedmlToBioModel(transLogger, externalDocInfo, sedml, null, null, false);
for (VCDocument vcdoc : vcdocs) {
docs.add(vcdoc);
}
}
// treat the same since OMEX is just and archive with SED-ML file(s)
isSEDML = true;
} else if (!externalDocInfo.isXML()) {
if (hashTable.containsKey(BNG_UNIT_SYSTEM)) {
// not XML, look for BNGL etc.
// we use the BngUnitSystem already created during the 1st pass
BngUnitSystem bngUnitSystem = (BngUnitSystem) hashTable.get(BNG_UNIT_SYSTEM);
BioModel bioModel = createDefaultBioModelDocument(bngUnitSystem);
SimulationContext ruleBasedSimContext = bioModel.addNewSimulationContext("NFSim app", SimulationContext.Application.RULE_BASED_STOCHASTIC);
SimulationContext odeSimContext = bioModel.addNewSimulationContext("BioNetGen app", SimulationContext.Application.NETWORK_DETERMINISTIC);
List<SimulationContext> appList = new ArrayList<SimulationContext>();
appList.add(ruleBasedSimContext);
appList.add(odeSimContext);
// set convention for initial conditions in generated application for seed
// species (concentration or count)
ruleBasedSimContext.setUsingConcentration(bngUnitSystem.isConcentration());
odeSimContext.setUsingConcentration(bngUnitSystem.isConcentration());
RbmModelContainer rbmModelContainer = bioModel.getModel().getRbmModelContainer();
RbmUtils.reactionRuleLabelIndex = 0;
RbmUtils.reactionRuleNames.clear();
Reader reader = externalDocInfo.getReader();
ASTModel astModel = RbmUtils.importBnglFile(reader);
if (bioModel.getModel() != null && bioModel.getModel().getVcMetaData() != null) {
VCMetaData vcMetaData = bioModel.getModel().getVcMetaData();
vcMetaData.setFreeTextAnnotation(bioModel, astModel.getProlog());
}
if (astModel.hasCompartments()) {
Structure struct = bioModel.getModel().getStructure(0);
if (struct != null) {
bioModel.getModel().removeStructure(struct);
}
}
BnglObjectConstructionVisitor constructionVisitor = null;
if (!astModel.hasMolecularDefinitions()) {
System.out.println("Molecular Definition Block missing. Extracting it from Species, Reactions, Obserbables.");
constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, false);
} else {
constructionVisitor = new BnglObjectConstructionVisitor(bioModel.getModel(), appList, bngUnitSystem, true);
}
// we'll convert the kinetic parameters to BngUnitSystem inside the
// visit(ASTKineticsParameter...)
astModel.jjtAccept(constructionVisitor, rbmModelContainer);
// set the volume in the newly created application to
// BngUnitSystem.bnglModelVolume
// TODO: set the right values if we import compartments from the bngl file!
// if(!bngUnitSystem.isConcentration()) {
Expression sizeExpression = new Expression(bngUnitSystem.getVolume());
ruleBasedSimContext.getGeometryContext().getStructureMapping(0).getSizeParameter().setExpression(sizeExpression);
odeSimContext.getGeometryContext().getStructureMapping(0).getSizeParameter().setExpression(sizeExpression);
// }
// we remove the NFSim application if any seed species is clamped because NFSim
// doesn't know what to do with it
boolean bClamped = false;
for (SpeciesContextSpec scs : ruleBasedSimContext.getReactionContext().getSpeciesContextSpecs()) {
if (scs.isConstant()) {
bClamped = true;
break;
}
}
if (bClamped) {
bioModel.removeSimulationContext(ruleBasedSimContext);
}
// // TODO: DON'T delete this code
// // the code below is needed if we also want to create simulations, example for 1 rule based simulation
// // it is rule-based so it wont have to flatten, should be fast.
// MathMappingCallback callback = new MathMappingCallbackTaskAdapter(getClientTaskStatusSupport());
// NetworkGenerationRequirements networkGenerationRequirements = null; // network generation should not be executed.
// ruleBasedSimContext.refreshMathDescription(callback,networkGenerationRequirements);
// Simulation sim = ruleBasedSimContext.addNewSimulation(SimulationOwner.DEFAULT_SIM_NAME_PREFIX,callback,networkGenerationRequirements);
doc = bioModel;
}
} else {
// is XML
try (TranslationLogger transLogger = new TranslationLogger(requester)) {
XMLSource xmlSource = externalDocInfo.createXMLSource();
org.jdom.Element rootElement = xmlSource.getXmlDoc().getRootElement();
String xmlType = rootElement.getName();
String modelXmlType = null;
if (xmlType.equals(XMLTags.VcmlRootNodeTag)) {
// For now, assuming that <vcml> element has only one child (biomodel, mathmodel
// or geometry).
// Will deal with multiple children of <vcml> Element when we get to model
// composition.
@SuppressWarnings("unchecked") List<Element> childElementList = rootElement.getChildren();
// assuming first child is the biomodel,
Element modelElement = childElementList.get(0);
// mathmodel or geometry.
modelXmlType = modelElement.getName();
}
if (xmlType.equals(XMLTags.BioModelTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.BioModelTag))) {
doc = XmlHelper.XMLToBioModel(xmlSource);
} else if (xmlType.equals(XMLTags.MathModelTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.MathModelTag))) {
doc = XmlHelper.XMLToMathModel(xmlSource);
} else if (xmlType.equals(XMLTags.GeometryTag) || (xmlType.equals(XMLTags.VcmlRootNodeTag) && modelXmlType.equals(XMLTags.GeometryTag))) {
doc = XmlHelper.XMLToGeometry(xmlSource);
} else if (xmlType.equals(XMLTags.SbmlRootNodeTag)) {
Namespace namespace = rootElement.getNamespace(XMLTags.SBML_SPATIAL_NS_PREFIX);
isBMDB = externalDocInfo.isBioModelsNet();
boolean bIsSpatial = (namespace == null) ? false : true;
doc = XmlHelper.importSBML(transLogger, xmlSource, bIsSpatial);
} else if (xmlType.equals(XMLTags.CellmlRootNodeTag)) {
if (requester instanceof BioModelWindowManager) {
doc = XmlHelper.importBioCellML(transLogger, xmlSource);
} else {
doc = XmlHelper.importMathCellML(transLogger, xmlSource);
}
} else if (xmlType.equals(MicroscopyXMLTags.FRAPStudyTag)) {
doc = VFrapXmlHelper.VFRAPToBioModel(hashTable, xmlSource, getDocumentManager(), requester);
} else if (xmlType.equals(XMLTags.SedMLTypeTag)) {
// we know it is a single SedML since it is an actual XML source
List<SedML> sedmls = (List<SedML>) hashTable.get(SEDML_MODELS);
SedML sedml = sedmls.get(0);
// default to import all tasks
docs = XmlHelper.sedmlToBioModel(transLogger, externalDocInfo, sedml, null, externalDocInfo.getFile().getAbsolutePath(), false);
isSEDML = true;
} else {
// unknown XML format
throw new RuntimeException("unsupported XML format, first element tag is <" + rootElement.getName() + ">");
}
if (externalDocInfo.getDefaultName() != null) {
doc.setName(externalDocInfo.getDefaultName());
}
}
}
if (doc == null && docs == null) {
File f = externalDocInfo.getFile();
if (f != null) {
throw new RuntimeException("Unable to determine type of file " + f.getCanonicalPath());
}
throw new ProgrammingException();
}
}
// create biopax objects using annotation
if (doc instanceof BioModel) {
BioModel bioModel = (BioModel) doc;
try {
bioModel.getVCMetaData().createBioPaxObjects(bioModel);
} catch (Exception e) {
e.printStackTrace();
}
}
requester.prepareDocumentToLoad(doc, inNewWindow);
hashTable.put("isBMDB", isBMDB);
hashTable.put("isSEDML", isSEDML);
if (!isSEDML) {
hashTable.put("doc", doc);
} else {
hashTable.put("docs", docs);
}
}
};
AsynchClientTask task2 = new AsynchClientTask("Showing document", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false) {
@Override
public void run(Hashtable<String, Object> hashTable) throws Exception {
try {
Throwable exc = (Throwable) hashTable.get(ClientTaskDispatcher.TASK_ABORTED_BY_ERROR);
if (exc == null) {
boolean isSEDML = (boolean) hashTable.get("isSEDML");
if (isSEDML) {
List<VCDocument> docs = (List<VCDocument>) hashTable.get("docs");
List<DocumentWindowManager> windowManagers = new ArrayList<DocumentWindowManager>();
for (VCDocument doc : docs) {
DocumentWindowManager windowManager = createDocumentWindowManager(doc);
getMdiManager().createNewDocumentWindow(windowManager);
windowManagers.add(windowManager);
}
hashTable.put("managers", windowManagers);
hashTable.put("docs", docs);
} else {
VCDocument doc = (VCDocument) hashTable.get("doc");
DocumentWindowManager windowManager = null;
if (inNewWindow) {
windowManager = createDocumentWindowManager(doc);
// request was to create a new top-level window with this doc
getMdiManager().createNewDocumentWindow(windowManager);
} else {
// request was to replace the document in an existing window
windowManager = (DocumentWindowManager) requester;
getMdiManager().setCanonicalTitle(requester.getManagerID());
windowManager.resetDocument(doc);
}
hashTable.put(WIN_MGR_KEY, windowManager);
hashTable.put("doc", doc);
}
}
} catch (Exception ex) {
ex.printStackTrace();
// TODO: check why getMdiManager().createNewDocumentWindow(windowManager) fails sometimes
} finally {
if (!inNewWindow) {
getMdiManager().unBlockWindow(requester.getManagerID());
}
bOpening = false;
}
}
};
AsynchClientTask task3 = new AsynchClientTask("Special Layout", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false) {
@Override
public void run(Hashtable<String, Object> hashTable) throws Exception {
if (documentInfo instanceof ExternalDocInfo) {
ExternalDocInfo externalDocInfo = (ExternalDocInfo) documentInfo;
boolean isSEDML = (boolean) hashTable.get("isSEDML");
if (externalDocInfo.isBioModelsNet() || externalDocInfo.isFromXmlFile() || !isSEDML) {
DocumentWindowManager windowManager = (DocumentWindowManager) hashTable.get(WIN_MGR_KEY);
if (windowManager instanceof BioModelWindowManager) {
((BioModelWindowManager) windowManager).specialLayout();
}
}
if (isSEDML) {
List<DocumentWindowManager> windowManagers = (List<DocumentWindowManager>) hashTable.get("managers");
if (windowManagers != null) {
for (DocumentWindowManager manager : windowManagers) {
((BioModelWindowManager) manager).specialLayout();
}
}
}
}
}
};
AsynchClientTask task4 = new AsynchClientTaskFunction(ClientRequestManager::setWindowFocus, "Set window focus", AsynchClientTask.TASKTYPE_SWING_BLOCKING, false, false);
AsynchClientTask task6 = new AsynchClientTask("Renaming, please wait...", // TASKTYPE_NONSWING_BLOCKING
AsynchClientTask.TASKTYPE_NONSWING_BLOCKING, // TASKTYPE_NONSWING_BLOCKING
false, // TASKTYPE_NONSWING_BLOCKING
false) {
@Override
public void run(Hashtable<String, Object> hashTable) throws Exception {
VCDocument doc = (VCDocument) hashTable.get("doc");
if (!(doc instanceof BioModel)) {
return;
}
boolean isBMDB = (boolean) hashTable.get("isBMDB");
if (documentInfo instanceof ExternalDocInfo) {
if (isBMDB) {
idToNameConversion(doc);
}
}
if (isBMDB) {
BioModel bioModel = (BioModel) doc;
SimulationContext simulationContext = bioModel.getSimulationContext(0);
simulationContext.setName(BMDB_DEFAULT_APPLICATION);
MathMappingCallback callback = new MathMappingCallback() {
@Override
public void setProgressFraction(float fractionDone) {
}
@Override
public void setMessage(String message) {
}
@Override
public boolean isInterrupted() {
return false;
}
};
MathMapping mathMapping = simulationContext.createNewMathMapping(callback, NetworkGenerationRequirements.ComputeFullNoTimeout);
MathDescription mathDesc = null;
try {
mathDesc = mathMapping.getMathDescription(callback);
simulationContext.setMathDescription(mathDesc);
Simulation sim = new Simulation(mathDesc);
sim.setName(simulationContext.getBioModel().getFreeSimulationName());
simulationContext.addSimulation(sim);
bioModel.refreshDependencies();
} catch (MappingException | MathException | MatrixException | ExpressionException | ModelException e1) {
e1.printStackTrace();
}
hashTable.put("doc", doc);
}
}
};
ClientTaskDispatcher.dispatch(requester.getComponent(), hashTable, new AsynchClientTask[] { task0, task1, task6, task2, task3, task4 }, false);
}
Also used :
SetMathDescription(cbit.vcell.client.task.SetMathDescription)
MathDescription(cbit.vcell.math.MathDescription)
ArrayList(java.util.ArrayList)
UserCancelException(org.vcell.util.UserCancelException)
SpeciesContextSpec(cbit.vcell.mapping.SpeciesContextSpec)
ExpressionException(cbit.vcell.parser.ExpressionException)
MappingException(cbit.vcell.mapping.MappingException)
SedML(org.jlibsedml.SedML)
ExternalDocInfo(cbit.vcell.xml.ExternalDocInfo)
AsynchClientTaskFunction(cbit.vcell.client.task.AsynchClientTaskFunction)
MatrixException(cbit.vcell.matrix.MatrixException)
VCMetaData(cbit.vcell.biomodel.meta.VCMetaData)
BnglObjectConstructionVisitor(org.vcell.model.rbm.RbmUtils.BnglObjectConstructionVisitor)
RbmModelContainer(cbit.vcell.model.Model.RbmModelContainer)
GeometryInfo(cbit.vcell.geometry.GeometryInfo)
ArrayList(java.util.ArrayList)
List(java.util.List)
VCDocument(org.vcell.util.document.VCDocument)
MathMappingCallback(cbit.vcell.mapping.SimulationContext.MathMappingCallback)
ModelException(cbit.vcell.model.ModelException)
FileInputStream(java.io.FileInputStream)
Namespace(org.jdom.Namespace)
BngUnitSystem(org.vcell.model.bngl.BngUnitSystem)
BNGLDebuggerPanel(org.vcell.model.bngl.gui.BNGLDebuggerPanel)
SEDMLDocument(org.jlibsedml.SEDMLDocument)
MathMapping(cbit.vcell.mapping.MathMapping)
CSGObject(cbit.vcell.geometry.CSGObject)
ChooseFile(cbit.vcell.client.task.ChooseFile)
File(java.io.File)
AsynchClientTask(cbit.vcell.client.task.AsynchClientTask)
FileWriter(java.io.FileWriter)
Element(org.jdom.Element)
StlReader(cbit.vcell.geometry.surface.StlReader)
FileReader(java.io.FileReader)
ImageDatasetReader(org.vcell.vcellij.ImageDatasetReader)
Reader(java.io.Reader)
BufferedReader(java.io.BufferedReader)
ArchiveComponents(org.jlibsedml.ArchiveComponents)
ProgrammingException(org.vcell.util.ProgrammingException)
Structure(cbit.vcell.model.Structure)
Hashtable(java.util.Hashtable)
BNGLUnitsPanel(org.vcell.model.bngl.gui.BNGLUnitsPanel)
BioModelInfo(org.vcell.util.document.BioModelInfo)
IOException(java.io.IOException)
MathModelInfo(org.vcell.util.document.MathModelInfo)
SimulationContext(cbit.vcell.mapping.SimulationContext)
ProgrammingException(org.vcell.util.ProgrammingException)
MatrixException(cbit.vcell.matrix.MatrixException)
GeometryException(cbit.vcell.geometry.GeometryException)
IOException(java.io.IOException)
DataAccessException(org.vcell.util.DataAccessException)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
ImageException(cbit.image.ImageException)
UtilCancelException(org.vcell.util.UtilCancelException)
ModelException(cbit.vcell.model.ModelException)
DataFormatException(java.util.zip.DataFormatException)
ExpressionException(cbit.vcell.parser.ExpressionException)
MathException(cbit.vcell.math.MathException)
UserCancelException(org.vcell.util.UserCancelException)
Simulation(cbit.vcell.solver.Simulation)
VCDocumentInfo(org.vcell.util.document.VCDocumentInfo)
Expression(cbit.vcell.parser.Expression)
MathException(cbit.vcell.math.MathException)
BioModel(cbit.vcell.biomodel.BioModel)
XMLSource(cbit.vcell.xml.XMLSource)
Element(org.jdom.Element)
ASTModel(org.vcell.model.bngl.ASTModel)
Example 2 with SedML
use of org.jlibsedml.SedML in project vcell by virtualcell.
the class VCellSedMLSolver method main.
// static String inString = "/usr/local/app/vcell/simulation";
// static String outRootString = "/usr/local/app/vcell/simulation/out";
public static void main(String[] args) {
CommandLineParser parser = new DefaultParser();
HelpFormatter formatter = new HelpFormatter();
// place the sedml file and the sbml file(s) in inDir directory
Options options = getCommandLineOptions();
CommandLine cmd = null;
try {
cmd = parser.parse(options, args);
if (cmd.getOptions().length == 0) {
System.out.println("usage: vcell [-h] [-q] -i ARCHIVE [-o OUT_DIR] [-v]");
System.exit(1);
}
if (args[0].contains("-h") || args[0].contains("--help")) {
formatter.printHelp("vcell [-h] [-q] -i ARCHIVE [-o OUT_DIR] [-v]", "\nBioSimulators-compliant command-line interface to the VCell simulation program <http://vcell.org>.\n\n" + "optional arguments:\n\n", options, "");
System.exit(1);
}
IN_ROOT_STRING = cmd.getOptionValue("archive");
OUT_ROOT_STRING = cmd.getOptionValue("out-dir");
} catch (Exception ex) {
System.out.println(ex.getMessage());
System.exit(1);
}
if (IN_ROOT_STRING == null || OUT_ROOT_STRING == null) {
formatter.printHelp("vcell", options);
System.exit(1);
}
// CombineArchive omex = new CombineArchive();
// boolean isInitialized = omex.initializeFromArchive(IN_ROOT_STRING);
// boolean isExtracted = omex.extractTo(tempDir)
File tempDir = Files.createTempDir();
ArrayList<String> sedmlLocations = new ArrayList<>();
try {
System.loadLibrary("combinej");
CombineArchive omex = new CombineArchive();
boolean isInitialized = omex.initializeFromArchive(IN_ROOT_STRING);
boolean isExtracted = omex.extractTo(tempDir.getAbsolutePath());
CaOmexManifest manifest = omex.getManifest();
CaListOfContents contents = manifest.getListOfContents();
System.out.println("Contents fetched");
for (int contentIndex = 0; contentIndex < contents.getNumContents(); contentIndex++) {
CaContent content = (CaContent) contents.get(contentIndex);
if (content.isFormat("sedml")) {
sedmlLocations.add(content.getLocation());
}
}
System.out.println("All SEDML locations fetched");
// unzip(IN_ROOT_STRING, tempDir);
} catch (Exception ex) {
System.err.println("Cannot extract Omex");
System.exit(1);
}
File inDir = tempDir;
File outRootDir = new File(OUT_ROOT_STRING);
// delete the output directory and all its content recursively
if (outRootDir.exists()) {
try {
deleteRecursively(outRootDir);
} catch (IOException e) {
System.err.println("Failed to empty outRootDir.");
System.exit(99);
}
}
if (!outRootDir.exists()) {
outRootDir.mkdirs();
}
// }
for (int sedmlIndex = 0; sedmlIndex < sedmlLocations.size(); sedmlIndex++) {
try {
String completeSedmlPath = tempDir.getAbsolutePath() + "/" + sedmlLocations.get(sedmlIndex);
File sedmlFile = new File(completeSedmlPath);
SedML sedml = Libsedml.readDocument(sedmlFile).getSedMLModel();
if (sedml == null || sedml.getModels().isEmpty()) {
System.err.println("the sedml file '" + sedmlFile.getName() + "'does not contain a valid document");
System.exit(99);
}
VCellSedMLSolver vCellSedMLSolver = new VCellSedMLSolver();
ExternalDocInfo externalDocInfo = new ExternalDocInfo(sedmlFile, true);
for (AbstractTask at : sedml.getTasks()) {
vCellSedMLSolver.doWork(externalDocInfo, at, sedml);
}
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
// try {
// SedML sedml = Libsedml.readDocument(sedmlFile).getSedMLModel();
// if (sedml == null || sedml.getModels().isEmpty()) {
// System.err.println("the sedml file '" + sedmlFile.getName() + "'does not contain a valid document");
// System.exit(99);
// }
// VCellSedMLSolver vCellSedMLSolver = new VCellSedMLSolver();
// ExternalDocInfo externalDocInfo = new ExternalDocInfo(sedmlFile, true);
// for(AbstractTask at : sedml.getTasks()) {
// vCellSedMLSolver.doWork(externalDocInfo, at, sedml);
// }
// } catch (Exception e) {
// System.err.println(e.getMessage());
// } finally {
deleteDirectory(tempDir);
// }
}
Also used :
Options(org.apache.commons.cli.Options)
AbstractTask(org.jlibsedml.AbstractTask)
JsonParseException(com.fasterxml.jackson.core.JsonParseException)
SBMLImportException(org.vcell.sbml.vcell.SBMLImportException)
JsonMappingException(com.fasterxml.jackson.databind.JsonMappingException)
HelpFormatter(org.apache.commons.cli.HelpFormatter)
SedML(org.jlibsedml.SedML)
ExternalDocInfo(cbit.vcell.xml.ExternalDocInfo)
CommandLine(org.apache.commons.cli.CommandLine)
CommandLineParser(org.apache.commons.cli.CommandLineParser)
DefaultParser(org.apache.commons.cli.DefaultParser)
Example 3 with SedML
use of org.jlibsedml.SedML in project vcell by virtualcell.
the class StandaloneSEDMLTest method doit.
public static void doit(File archiveFile) throws Exception {
ArchiveComponents ac = null;
ac = Libsedml.readSEDMLArchive(new FileInputStream(archiveFile));
SEDMLDocument sedmlDoc = ac.getSedmlDocuments().get(0);
SedML sedml = sedmlDoc.getSedMLModel();
if (sedml == null || sedml.getModels().isEmpty()) {
throw new RuntimeException("sedml null or empty");
}
ModelResolver resolver = new ModelResolver(sedml);
// resolver.add(new FileModelResolver());
resolver.add(new ArchiveModelResolver(ac));
resolver.add(new BioModelsModelsRetriever());
resolver.add(new URLResourceRetriever());
// resolver.add(new RelativeFileModelResolver(FileUtils.getFullPath(archiveFile.getAbsolutePath())));
//
// iterate through all the elements and show them at the console
//
List<org.jlibsedml.Model> mmm = sedml.getModels();
for (Model mm : mmm) {
System.out.println(mm.toString());
}
List<org.jlibsedml.Simulation> sss = sedml.getSimulations();
for (org.jlibsedml.Simulation ss : sss) {
System.out.println(ss.toString());
}
List<AbstractTask> ttt = sedml.getTasks();
for (AbstractTask tt : ttt) {
System.out.println(tt.toString());
}
List<DataGenerator> ddd = sedml.getDataGenerators();
for (DataGenerator dd : ddd) {
System.out.println(dd.toString());
}
List<Output> ooo = sedml.getOutputs();
for (Output oo : ooo) {
System.out.println(oo.toString());
}
//
// extract models referenced in tasks.
//
KisaoOntology kisaoInstance = KisaoOntology.getInstance();
// HashMap<String,Model> flattenedModels = new HashMap<String, Model>();
List<AbstractTask> taskList = sedml.getTasks();
for (AbstractTask task : taskList) {
String modelReference = task.getModelReference();
org.jlibsedml.Model sedmlOriginalModel = sedml.getModelWithId(modelReference);
String sbmlModelString = resolver.getModelString(sedmlOriginalModel);
// sbmlSource with all the changes applied
XMLSource sbmlSource = new XMLSource(sbmlModelString);
org.jlibsedml.Simulation sedmlSimulation = sedml.getSimulation(task.getSimulationReference());
Algorithm algorithm = sedmlSimulation.getAlgorithm();
KisaoTerm sedmlKisao = kisaoInstance.getTermById(algorithm.getKisaoID());
//
// try to find a VCell solverDescription to match the Kisao term
//
// UniformTimeCourse [initialTime=0.0, numberOfPoints=1000, outputEndTime=1.0, outputStartTime=0.0,
// Algorithm [kisaoID=KISAO:0000019], getId()=SimSlow]
// identify the vCell solvers that would match best the sedml solver kisao id
List<SolverDescription> solverDescriptions = new ArrayList<>();
for (SolverDescription sd : SolverDescription.values()) {
KisaoTerm solverKisaoTerm = kisaoInstance.getTermById(sd.getKisao());
if (solverKisaoTerm == null) {
break;
}
boolean isExactlySame = solverKisaoTerm.equals(sedmlKisao);
if (isExactlySame && !solverKisaoTerm.isObsolete()) {
// we make a list with all the solvers that match the kisao
solverDescriptions.add(sd);
}
}
if (solverDescriptions.isEmpty()) {
throw new RuntimeException("cannot find the solverDescription with exact match for Kisao term '" + sedmlKisao + "'");
}
// choose first one
SolverDescription solverDescription = solverDescriptions.get(0);
// find out everything else we need about the application we're going to use,
// some of the info will be needed when we parse the sbml file
boolean bSpatial = false;
Application appType = Application.NETWORK_DETERMINISTIC;
Set<SolverDescription.SolverFeature> sfList = solverDescription.getSupportedFeatures();
for (SolverDescription.SolverFeature sf : sfList) {
switch(sf) {
case Feature_Rulebased:
appType = Application.RULE_BASED_STOCHASTIC;
break;
case Feature_Stochastic:
appType = Application.NETWORK_STOCHASTIC;
break;
case Feature_Deterministic:
appType = Application.NETWORK_DETERMINISTIC;
break;
case Feature_Spatial:
bSpatial = true;
break;
default:
break;
}
}
BioModel bioModel = (BioModel) XmlHelper.importSBML(transLogger, sbmlSource, bSpatial);
//
// we already have an application loaded from the sbml file, with initial conditions and stuff
// which may be not be suitable because the sedml kisao may need a different app type
// so we do a "copy as" to the right type and then delete the original we loaded from the sbml file
//
// the new application we're making from the old one
SimulationContext newSimulationContext = null;
if (bioModel.getSimulationContexts().length == 1) {
SimulationContext oldSimulationContext = bioModel.getSimulationContext(0);
String newSCName = bioModel.getFreeSimulationContextName();
newSimulationContext = SimulationContext.copySimulationContext(oldSimulationContext, newSCName, bSpatial, appType);
bioModel.addSimulationContext(newSimulationContext);
bioModel.removeSimulationContext(oldSimulationContext);
} else {
newSimulationContext = bioModel.addNewSimulationContext("App1", appType);
}
//
// making the new vCell simulation based on the sedml simulation
//
newSimulationContext.refreshDependencies();
MathMappingCallback callback = new MathMappingCallbackTaskAdapter(progressListener);
newSimulationContext.refreshMathDescription(callback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
Simulation newSimulation = new Simulation(newSimulationContext.getMathDescription());
newSimulation.setName(sedmlSimulation.getName());
bioModel.addSimulation(newSimulation);
// and set the vCell simulation parameters accordingly
if (sedmlSimulation instanceof UniformTimeCourse) {
} else if (sedmlSimulation instanceof OneStep) {
} else if (sedmlSimulation instanceof SteadyState) {
} else {
}
System.out.println(XmlHelper.bioModelToXML(bioModel));
}
}
Also used :
AbstractTask(org.jlibsedml.AbstractTask)
SolverDescription(cbit.vcell.solver.SolverDescription)
ArrayList(java.util.ArrayList)
OneStep(org.jlibsedml.OneStep)
ModelResolver(org.jlibsedml.execution.ModelResolver)
ArchiveModelResolver(org.jlibsedml.execution.ArchiveModelResolver)
SteadyState(org.jlibsedml.SteadyState)
SedML(org.jlibsedml.SedML)
ArchiveComponents(org.jlibsedml.ArchiveComponents)
Output(org.jlibsedml.Output)
MathMappingCallbackTaskAdapter(cbit.vcell.mapping.MathMappingCallbackTaskAdapter)
MathMappingCallback(cbit.vcell.mapping.SimulationContext.MathMappingCallback)
BioModelsModelsRetriever(org.jlibsedml.modelsupport.BioModelsModelsRetriever)
SimulationContext(cbit.vcell.mapping.SimulationContext)
Algorithm(org.jlibsedml.Algorithm)
FileInputStream(java.io.FileInputStream)
KisaoTerm(org.jlibsedml.modelsupport.KisaoTerm)
Simulation(cbit.vcell.solver.Simulation)
URLResourceRetriever(org.jlibsedml.modelsupport.URLResourceRetriever)
KisaoOntology(org.jlibsedml.modelsupport.KisaoOntology)
ArchiveModelResolver(org.jlibsedml.execution.ArchiveModelResolver)
Model(org.jlibsedml.Model)
SEDMLDocument(org.jlibsedml.SEDMLDocument)
DataGenerator(org.jlibsedml.DataGenerator)
BioModel(cbit.vcell.biomodel.BioModel)
BioModel(cbit.vcell.biomodel.BioModel)
Model(org.jlibsedml.Model)
UniformTimeCourse(org.jlibsedml.UniformTimeCourse)
XMLSource(cbit.vcell.xml.XMLSource)
Application(cbit.vcell.mapping.SimulationContext.Application)
Aggregations
SedML (org.jlibsedml.SedML)3
BioModel (cbit.vcell.biomodel.BioModel)2
SimulationContext (cbit.vcell.mapping.SimulationContext)2
MathMappingCallback (cbit.vcell.mapping.SimulationContext.MathMappingCallback)2
Simulation (cbit.vcell.solver.Simulation)2
ExternalDocInfo (cbit.vcell.xml.ExternalDocInfo)2
XMLSource (cbit.vcell.xml.XMLSource)2
FileInputStream (java.io.FileInputStream)2
ArrayList (java.util.ArrayList)2
AbstractTask (org.jlibsedml.AbstractTask)2
ArchiveComponents (org.jlibsedml.ArchiveComponents)2
SEDMLDocument (org.jlibsedml.SEDMLDocument)2
ImageException (cbit.image.ImageException)1
VCMetaData (cbit.vcell.biomodel.meta.VCMetaData)1
AsynchClientTask (cbit.vcell.client.task.AsynchClientTask)1
AsynchClientTaskFunction (cbit.vcell.client.task.AsynchClientTaskFunction)1
ChooseFile (cbit.vcell.client.task.ChooseFile)1
SetMathDescription (cbit.vcell.client.task.SetMathDescription)1
CSGObject (cbit.vcell.geometry.CSGObject)1
GeometryException (cbit.vcell.geometry.GeometryException)1
