Example 1 with ModelException
use of cbit.vcell.model.ModelException 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 ModelException
use of cbit.vcell.model.ModelException in project vcell by virtualcell.
the class OutputFunctionsListTableModel method propertyChange.
/**
* This method gets called when a bound property is changed.
* @param evt A PropertyChangeEvent object describing the event source
* and the property that has changed.
*/
public void propertyChange(java.beans.PropertyChangeEvent evt) {
OutputFunctionContext fc = getOutputFunctionContext();
SimulationOwner so = null;
if (fc != null) {
so = fc.getSimulationOwner();
}
if (evt.getSource() == fc && evt.getPropertyName().equals(OutputFunctionContext.PROPERTY_OUTPUT_FUNCTIONS)) {
setData(outputFunctionContext.getOutputFunctionsList());
}
if (evt.getSource() instanceof SimulationContext && evt.getSource() == so && evt.getPropertyName().equals(Model.PROPERTY_NAME_MODEL_ENTITY_NAME)) {
SimulationContext simulationContext = (SimulationContext) so;
if (fc.getOutputFunctionsList() == null || fc.getOutputFunctionsList().isEmpty()) {
return;
}
Hashtable<String, Object> hashTable = new Hashtable<String, Object>();
//
// WARNING: this should NOT be used under any circumstance for batch renaming
// MathDescription, MathMapping, expressions are NOT thread safe
//
AsynchClientTask task0 = new AsynchClientTask("Renaming Functions", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING, false, false) {
@Override
public void run(Hashtable<String, Object> hashTable) throws Exception {
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);
} catch (MappingException | MathException | MatrixException | ExpressionException | ModelException e1) {
e1.printStackTrace();
}
String oldName = (String) evt.getOldValue();
String newName = (String) evt.getNewValue();
ArrayList<AnnotatedFunction> afList = fc.getOutputFunctionsList();
List<Expression> changedExpressions = new ArrayList<>();
for (AnnotatedFunction af : afList) {
if (af == null) {
continue;
}
Expression exp = af.getExpression();
if (exp == null || exp.getSymbols() == null || exp.getSymbols().length == 0) {
continue;
}
String errMsg = "Failed to rename symbol '" + oldName + "' with '" + newName + "' in the Expression of Function '" + af.getName() + "'.";
for (String symbol : exp.getSymbols()) {
if (symbol.contentEquals(oldName)) {
try {
exp.substituteInPlace(new Expression(oldName), new Expression(newName));
changedExpressions.add(exp);
} catch (ExpressionException e) {
e.printStackTrace();
throw new RuntimeException(errMsg);
}
}
}
}
if (changedExpressions.size() > 0) {
try {
simulationContext.setMathDescription(mathDesc);
for (Expression exp : changedExpressions) {
exp.bindExpression(outputFunctionContext);
}
} catch (ExpressionException | PropertyVetoException e) {
e.printStackTrace();
}
}
}
};
ClientTaskDispatcher.dispatch(ownerTable, hashTable, new AsynchClientTask[] { task0 }, false);
}
if (evt.getPropertyName().equals(GeometryOwner.PROPERTY_NAME_GEOMETRY)) {
Geometry oldGeometry = (Geometry) evt.getOldValue();
Geometry newGeometry = (Geometry) evt.getNewValue();
// changing from ode to pde
if (oldGeometry.getDimension() == 0 && newGeometry.getDimension() > 0) {
fireTableStructureChanged();
setData(getOutputFunctionContext().getOutputFunctionsList());
}
}
}
Also used :
AsynchClientTask(cbit.vcell.client.task.AsynchClientTask)
MathDescription(cbit.vcell.math.MathDescription)
ArrayList(java.util.ArrayList)
ExpressionException(cbit.vcell.parser.ExpressionException)
MappingException(cbit.vcell.mapping.MappingException)
SimulationOwner(cbit.vcell.solver.SimulationOwner)
MatrixException(cbit.vcell.matrix.MatrixException)
AnnotatedFunction(cbit.vcell.solver.AnnotatedFunction)
MathMappingCallback(cbit.vcell.mapping.SimulationContext.MathMappingCallback)
ModelException(cbit.vcell.model.ModelException)
Hashtable(java.util.Hashtable)
SimulationContext(cbit.vcell.mapping.SimulationContext)
OutputFunctionContext(cbit.vcell.solver.OutputFunctionContext)
PropertyVetoException(java.beans.PropertyVetoException)
Geometry(cbit.vcell.geometry.Geometry)
ScopedExpression(cbit.gui.ScopedExpression)
Expression(cbit.vcell.parser.Expression)
MathException(cbit.vcell.math.MathException)
MathMapping(cbit.vcell.mapping.MathMapping)
Example 3 with ModelException
use of cbit.vcell.model.ModelException in project vcell by virtualcell.
the class BioCartoonTool method mapStructures.
// map the structures to be pasted to existing structures in the cloned model
// we may need to generate some name iteratively until we solve all naming conflicts
private static Map<Structure, String> mapStructures(Component requester, ReactionSpeciesCopy rsCopy, Model modelTo, Structure structTo, IssueContext issueContext) {
// use internally only; we exit the dialog when there are no issues left
Vector<Issue> issueVector = new Vector<>();
Structure structFrom = rsCopy.getFromStructure();
Map<Structure, String> fullyMappedStructures = new LinkedHashMap<>();
fullyMappedStructures.put(structFrom, structTo.getName());
StructurePasteMappingPanel structureMappingPanel = null;
do {
issueVector.clear();
if (structureMappingPanel == null) {
structureMappingPanel = new StructurePasteMappingPanel(rsCopy, modelTo, structTo, issueVector, issueContext);
structureMappingPanel.setPreferredSize(new Dimension(400, 220));
}
int result = DialogUtils.showComponentOKCancelDialog(requester, structureMappingPanel, "Assign 'From' structures to 'To' structures");
if (result != JOptionPane.OK_OPTION) {
throw UserCancelException.CANCEL_GENERIC;
}
} while (structureMappingPanel.hasErrors());
for (Map.Entry<Structure, JComboBox<String>> entry : structureMappingPanel.getStructureMap().entrySet()) {
if (entry.getValue().getSelectedItem().equals(StructurePasteMappingPanel.MAKE_NEW)) {
// we generate a "to" structure name based on the "from" name
String newNameTo = entry.getKey().getName();
while (modelTo.getStructure(newNameTo) != null) {
newNameTo = org.vcell.util.TokenMangler.getNextEnumeratedToken(newNameTo);
for (Structure sFrom : rsCopy.getStructuresArr()) {
if (newNameTo.equals(sFrom.getName())) {
// the new name must not match any existing "from" name either
newNameTo = org.vcell.util.TokenMangler.getNextEnumeratedToken(newNameTo);
break;
}
}
}
try {
// as to avoid risk of duplicates / conflicting names
if (entry.getKey() instanceof Membrane) {
modelTo.addMembrane(newNameTo);
} else {
modelTo.addFeature(newNameTo);
}
} catch (ModelException | PropertyVetoException e) {
throw new RuntimeException("Failed to generate the missing 'from' Structures in the cloned model, " + e.getMessage());
}
fullyMappedStructures.put(entry.getKey(), newNameTo);
} else {
// name of an existing "to" structure
fullyMappedStructures.put(entry.getKey(), (String) entry.getValue().getSelectedItem());
}
}
return fullyMappedStructures;
}
Also used :
Issue(org.vcell.util.Issue)
JComboBox(javax.swing.JComboBox)
ModelException(cbit.vcell.model.ModelException)
Dimension(java.awt.Dimension)
LinkedHashMap(java.util.LinkedHashMap)
PropertyVetoException(java.beans.PropertyVetoException)
Membrane(cbit.vcell.model.Membrane)
Structure(cbit.vcell.model.Structure)
Vector(java.util.Vector)
Map(java.util.Map)
IdentityHashMap(java.util.IdentityHashMap)
HashMap(java.util.HashMap)
LinkedHashMap(java.util.LinkedHashMap)
Example 4 with ModelException
use of cbit.vcell.model.ModelException in project vcell by virtualcell.
the class ViewGeneratedReactionsPanel method updateShape.
public void updateShape(int selectedRow) {
GeneratedReactionTableRow reactionTableRow = tableModel.getValueAt(selectedRow);
String inputString = reactionTableRow.getExpression();
System.out.println(selectedRow + ": " + inputString);
// ReactionRule newReactionRule = (ReactionRule)RbmUtils.parseReactionRule(inputString, bioModel);
Model tempModel = null;
try {
tempModel = new Model("MyTempModel");
tempModel.addFeature("c0");
} catch (ModelException | PropertyVetoException e1) {
e1.printStackTrace();
}
if (owner != null && owner.getSimulationContext() != null) {
List<MolecularType> mtList = owner.getSimulationContext().getModel().getRbmModelContainer().getMolecularTypeList();
try {
tempModel.getRbmModelContainer().setMolecularTypeList(mtList);
} catch (PropertyVetoException e1) {
e1.printStackTrace();
throw new RuntimeException("Unexpected exception setting " + MolecularType.typeName + " list: " + e1.getMessage(), e1);
}
} else {
// This should not be possible
throw new RuntimeException("Owner or SimulationContext are null.");
}
int arrowIndex = inputString.indexOf("<->");
boolean bReversible = true;
if (arrowIndex < 0) {
arrowIndex = inputString.indexOf("->");
bReversible = false;
}
String left = inputString.substring(0, arrowIndex).trim();
String right = inputString.substring(arrowIndex + (bReversible ? 3 : 2)).trim();
if (left.length() == 0 && right.length() == 0) {
return;
}
// we recover the original rule that generated the flattened reaction we now try to transform back into a fake rule
BNGReaction reactionObject = reactionTableRow.getReactionObject();
String name = reactionObject.getRuleName();
if (name.contains(GeneratedReactionTableModel.reverse)) {
name = name.substring(GeneratedReactionTableModel.reverse.length());
}
if (name.endsWith(ReactionRule.DirectHalf)) {
name = name.substring(0, name.indexOf(ReactionRule.DirectHalf));
}
if (name.endsWith(ReactionRule.InverseHalf)) {
name = name.substring(0, name.indexOf(ReactionRule.InverseHalf));
}
// get the name of the original structure from the original rule and make here another structure with the same name
String strStructure = null;
Structure ruleStructure;
SimulationContext sc = owner.getSimulationContext();
ReactionRule rr = sc.getModel().getRbmModelContainer().getReactionRule(name);
if (rr != null && rr.getStructure() != null) {
strStructure = rr.getStructure().getName();
}
if (strStructure != null) {
if (tempModel.getStructure(strStructure) == null) {
try {
if (rr.getStructure().getTypeName().equals(Structure.TYPE_NAME_MEMBRANE)) {
tempModel.addMembrane(strStructure);
} else {
tempModel.addFeature(strStructure);
}
} catch (ModelException | PropertyVetoException e) {
e.printStackTrace();
}
}
ruleStructure = tempModel.getStructure(strStructure);
} else {
throw new RuntimeException("Failed to recover a Structure name from the Reaction Rule: " + name);
}
// making the fake rules just for display purpose, actually they are the flattened reactions resulted from bngl
// the name is probably not unique, it's likely that many flattened reactions are derived from the same rule
ReactionRule reactionRule = tempModel.getRbmModelContainer().createReactionRule(name, ruleStructure, bReversible);
String regex = "[^!]\\+";
String[] patterns = left.split(regex);
for (String spString : patterns) {
try {
spString = spString.trim();
// if compartments are present, we're cheating big time making some fake compartments just for compartment name display purposes
SpeciesPattern speciesPattern = (SpeciesPattern) RbmUtils.parseSpeciesPattern(spString, tempModel);
strStructure = RbmUtils.parseCompartment(spString, tempModel);
speciesPattern.resolveBonds();
Structure structure;
if (strStructure != null) {
if (tempModel.getStructure(strStructure) == null) {
if (sc.getModel().getStructure(strStructure).getTypeName().equals(Structure.TYPE_NAME_MEMBRANE)) {
tempModel.addMembrane(strStructure);
} else {
tempModel.addFeature(strStructure);
}
}
structure = tempModel.getStructure(strStructure);
} else {
// if nothing explicit for a participant, we use by default the structure of the rule
structure = ruleStructure;
}
reactionRule.addReactant(new ReactantPattern(speciesPattern, structure));
} catch (Throwable ex) {
ex.printStackTrace();
// error (red circle)
SpeciesPatternLargeShape spls = new SpeciesPatternLargeShape(20, 20, -1, shapePanel, true, issueManager);
reactantPatternShapeList.clear();
productPatternShapeList.clear();
reactantPatternShapeList.add(spls);
shapePanel.repaint();
return;
}
}
patterns = right.split(regex);
for (String spString : patterns) {
try {
spString = spString.trim();
SpeciesPattern speciesPattern = (SpeciesPattern) RbmUtils.parseSpeciesPattern(spString, tempModel);
strStructure = RbmUtils.parseCompartment(spString, tempModel);
speciesPattern.resolveBonds();
Structure structure;
if (strStructure != null) {
if (tempModel.getStructure(strStructure) == null) {
if (sc.getModel().getStructure(strStructure).getTypeName().equals(Structure.TYPE_NAME_MEMBRANE)) {
tempModel.addMembrane(strStructure);
} else {
tempModel.addFeature(strStructure);
}
}
structure = tempModel.getStructure(strStructure);
} else {
structure = ruleStructure;
}
// BNGLParser parser = new BNGLParser(new StringReader(sp));
// ASTSpeciesPattern astSpeciesPattern = parser.SpeciesPattern();
// BnglObjectConstructionVisitor constructionVisitor = new BnglObjectConstructionVisitor(tempModel, null, false);
// SpeciesPattern speciesPattern = (SpeciesPattern) astSpeciesPattern.jjtAccept(constructionVisitor, null);
// for(MolecularTypePattern mtp : speciesPattern.getMolecularTypePatterns()) {
// mtp.setParticipantMatchLabel("*");
// }
// System.out.println(speciesPattern.toString());
reactionRule.addProduct(new ProductPattern(speciesPattern, structure));
} catch (Throwable ex) {
ex.printStackTrace();
// error (red circle)
SpeciesPatternLargeShape spls = new SpeciesPatternLargeShape(20, 20, -1, shapePanel, true, issueManager);
reactantPatternShapeList.clear();
productPatternShapeList.clear();
reactantPatternShapeList.add(spls);
shapePanel.repaint();
return;
}
}
// ----------------------------------------------------------------------------------------------------
List<ReactantPattern> rpList = reactionRule.getReactantPatterns();
reactantPatternShapeList.clear();
int xOffset = 20;
int xOffsetRound = 20;
if (rpList != null && rpList.size() > 0) {
for (int i = 0; i < rpList.size(); i++) {
SpeciesPattern sp = rpList.get(i).getSpeciesPattern();
for (MolecularTypePattern mtp : sp.getMolecularTypePatterns()) {
mtp.setParticipantMatchLabel("*");
}
SpeciesPatternLargeShape sps = new SpeciesPatternLargeShape(xOffset, 20, -1, sp, shapePanel, reactionRule, issueManager);
// SpeciesPatternRoundShape sps = new SpeciesPatternRoundShape(xOffsetRound, 20, -1, sp, shapePanel, reactionRule);
if (i < rpList.size() - 1) {
sps.addEndText("+");
} else {
if (reactionRule.isReversible()) {
sps.addEndText("<->");
} else {
sps.addEndText("->");
}
}
xOffset = sps.getRightEnd() + 45;
xOffsetRound = sps.getRightEnd() + 45;
reactantPatternShapeList.add(sps);
}
}
// space for the <-> sign
xOffset += 15;
List<ProductPattern> ppList = reactionRule.getProductPatterns();
productPatternShapeList.clear();
if (ppList != null && ppList.size() > 0) {
for (int i = 0; i < ppList.size(); i++) {
SpeciesPattern sp = ppList.get(i).getSpeciesPattern();
for (MolecularTypePattern mtp : sp.getMolecularTypePatterns()) {
mtp.setParticipantMatchLabel("*");
}
SpeciesPatternLargeShape sps = new SpeciesPatternLargeShape(xOffset, 20, -1, sp, shapePanel, reactionRule, issueManager);
// SpeciesPatternRoundShape sps = new SpeciesPatternRoundShape(xOffset, 20, -1, sp, shapePanel, reactionRule);
if (i < ppList.size() - 1) {
sps.addEndText("+");
}
xOffset = sps.getRightEnd() + 45;
productPatternShapeList.add(sps);
}
}
Dimension preferredSize = new Dimension(xOffset + 90, 50);
shapePanel.setPreferredSize(preferredSize);
shapePanel.repaint();
}
Also used :
SpeciesPatternLargeShape(cbit.vcell.graph.SpeciesPatternLargeShape)
SpeciesPattern(org.vcell.model.rbm.SpeciesPattern)
Structure(cbit.vcell.model.Structure)
ReactantPattern(cbit.vcell.model.ReactantPattern)
ModelException(cbit.vcell.model.ModelException)
ReactionRule(cbit.vcell.model.ReactionRule)
ProductPattern(cbit.vcell.model.ProductPattern)
Dimension(java.awt.Dimension)
SimulationContext(cbit.vcell.mapping.SimulationContext)
Point(java.awt.Point)
PropertyVetoException(java.beans.PropertyVetoException)
MolecularType(org.vcell.model.rbm.MolecularType)
BNGReaction(cbit.vcell.bionetgen.BNGReaction)
Model(cbit.vcell.model.Model)
VCellSortTableModel(cbit.vcell.client.desktop.biomodel.VCellSortTableModel)
BioModel(cbit.vcell.biomodel.BioModel)
MolecularTypePattern(org.vcell.model.rbm.MolecularTypePattern)
Example 5 with ModelException
use of cbit.vcell.model.ModelException in project vcell by virtualcell.
the class GeneratedReactionTableModel method getModel.
private Model getModel() {
if (model == null) {
try {
model = new Model("MyTempModel");
model.addFeature("c0");
} catch (ModelException | PropertyVetoException e1) {
e1.printStackTrace();
}
}
return model;
}
Also used :
PropertyVetoException(java.beans.PropertyVetoException)
ModelException(cbit.vcell.model.ModelException)
AutoCompleteTableModel(org.vcell.util.gui.AutoCompleteTableModel)
VCellSortTableModel(cbit.vcell.client.desktop.biomodel.VCellSortTableModel)
Model(cbit.vcell.model.Model)
Aggregations
ModelException (cbit.vcell.model.ModelException)30
PropertyVetoException (java.beans.PropertyVetoException)28
ExpressionException (cbit.vcell.parser.ExpressionException)15
Model (cbit.vcell.model.Model)14
Structure (cbit.vcell.model.Structure)13
MappingException (cbit.vcell.mapping.MappingException)10
SpeciesContext (cbit.vcell.model.SpeciesContext)10
ArrayList (java.util.ArrayList)10
SimulationContext (cbit.vcell.mapping.SimulationContext)9
MathDescription (cbit.vcell.math.MathDescription)9
Expression (cbit.vcell.parser.Expression)9
SpeciesPattern (org.vcell.model.rbm.SpeciesPattern)9
MathException (cbit.vcell.math.MathException)8
BioModel (cbit.vcell.biomodel.BioModel)7
MatrixException (cbit.vcell.matrix.MatrixException)7
Vector (java.util.Vector)7
MolecularType (org.vcell.model.rbm.MolecularType)7
ModelParameter (cbit.vcell.model.Model.ModelParameter)6
ReactionStep (cbit.vcell.model.ReactionStep)6
DataAccessException (org.vcell.util.DataAccessException)6
