Examples with Simulation cbit.vcell.solver.Simulation used on opensource projects

Example 61 with Simulation

use of cbit.vcell.solver.Simulation in project vcell by virtualcell.

the class HybridSolverTester method runSim.

private static void runSim(UserLoginInfo userLoginInfo, VCSimulationIdentifier vcSimulationIdentifier, VCellConnectionHelper vcellConnectionHelper) throws Exception {
    SimulationStatusPersistent simulationStatus = vcellConnectionHelper.getSimulationStatus(vcSimulationIdentifier.getSimulationKey());
    System.out.println("initial status=" + simulationStatus);
    if (simulationStatus != null && simulationStatus.isRunning()) /*!simulationStatus.isNeverRan() && !simulationStatus.isCompleted()*/
    {
        throw new Exception("Sim in unexpected state " + simulationStatus);
    }
    int intialMaxTaskID = vcellConnectionHelper.getMaxTaskID(simulationStatus);
    BigString simXML = vcellConnectionHelper.getSimulationXML(vcSimulationIdentifier.getSimulationKey());
    Simulation sim = XmlHelper.XMLToSim(simXML.toString());
    int scanCount = sim.getScanCount();
    vcellConnectionHelper.startSimulation(vcSimulationIdentifier, scanCount);
    long startTime = System.currentTimeMillis();
    // wait until sim has stopped running
    while ((simulationStatus = vcellConnectionHelper.getSimulationStatus(vcSimulationIdentifier.getSimulationKey())) == null || (simulationStatus.isStopped() || simulationStatus.isCompleted() || simulationStatus.isFailed())) {
        MessageEvent[] messageEvents = vcellConnectionHelper.getMessageEvents();
        if (vcellConnectionHelper.getMaxTaskID(simulationStatus) > intialMaxTaskID) {
            // new sim must have started
            break;
        }
        Thread.sleep(250);
        // }
        if ((System.currentTimeMillis() - startTime) > 120000) {
            throw new Exception("Sim finished too fast or took too long to start");
        }
    }
    SimulationStatusPersistent lastSimStatus = simulationStatus;
    while (!simulationStatus.isStopped() && !simulationStatus.isCompleted() && !simulationStatus.isFailed()) {
        Thread.sleep(3000);
        simulationStatus = vcellConnectionHelper.getSimulationStatus(vcSimulationIdentifier.getSimulationKey());
        if (simulationStatus != null && !simulationStatus.toString().equals(lastSimStatus.toString())) {
            lastSimStatus = simulationStatus;
            System.out.println("running status=" + simulationStatus);
        }
        MessageEvent[] messageEvents = vcellConnectionHelper.getMessageEvents();
    // for(int i = 0;i<(messageEvents==null?0:messageEvents.length);i++){
    // System.out.println(messageEvents[i].toString());
    // }
    }
    System.out.println("last run simStatus=" + simulationStatus);
}

Example 62 with Simulation

use of cbit.vcell.solver.Simulation in project vcell by virtualcell.

the class CheckBeforeDelete method checkLostResults.

/**
 * Insert the method's description here.
 * Creation date: (6/1/2004 3:44:03 PM)
 * @return cbit.vcell.solver.SolverResultSetInfo[]
 * @param bioModel cbit.vcell.biomodel.BioModel
 */
private Simulation[] checkLostResults(BioModel oldBioModel, BioModel newlySavedBioModel, cbit.vcell.clientdb.DocumentManager documentManager, Simulation[] submittedSimulations) throws Exception {
    // 
    // before deleting old version, prompt user if old simulation results will not be availlable in new edition
    // 
    Vector<Simulation> lostResultsSimulationList = new Vector<Simulation>();
    Simulation[] oldSimulations = oldBioModel.getSimulations();
    for (int i = 0; i < oldSimulations.length; i++) {
        Simulation oldSimulation = oldSimulations[i];
        SimulationStatus simStatus = null;
        SimulationInfo oldSimInfo = oldSimulation.getSimulationInfo();
        if (oldSimInfo != null) {
            // 
            // we need to ask for previous sim results (here we need possible translation to ask for parent's results).
            // 
            simStatus = documentManager.getServerSimulationStatus(oldSimInfo.getAuthoritativeVCSimulationIdentifier());
        }
        if (simStatus != null && simStatus.getHasData()) {
            // 
            // results exist in old version (the BioModel to be deleted) for SimulationInfo "oldSimInfo"
            // Users should be warned when they are going to loose any simulation results in any unexpected way.
            // 
            // WARN if the lost data is because new simulation is not mathematically equivalent to old edition
            // (different MathDescription key)
            // 
            // IGNORE if the lost data is from edits of a Simulation only (same MathDescription)
            // (same MathDescription key, different Simulation key)
            // 
            // IGNORE if Simulation has been deleted
            // (Simulation not found in current BioModel)
            // 
            // IGNORE if Simulation has been submitted for running
            // 
            boolean bDataInNewEdition = false;
            Simulation[] newSimulations = newlySavedBioModel.getSimulations();
            Simulation correspondingSimulation = null;
            for (int j = 0; j < newSimulations.length; j++) {
                if (newSimulations[j].getName().equals(oldSimulation.getName())) {
                    correspondingSimulation = newSimulations[j];
                    if (correspondingSimulation.getKey().equals(oldSimulation.getKey())) {
                        // 
                        // exactly same simulation (same key), so no lost data
                        // 
                        bDataInNewEdition = true;
                    } else if (correspondingSimulation.getSimulationVersion().getParentSimulationReference() != null) {
                        // 
                        // new simulation changed but points to same results
                        // 
                        bDataInNewEdition = true;
                    }
                    break;
                }
            }
            if (!bDataInNewEdition && correspondingSimulation != null) {
                // 
                // result set (for "rsInfo") will be lost, should we ignore this fact?
                // 
                boolean bIgnore = false;
                // 
                if (correspondingSimulation.getMathDescription().getKey().equals(oldSimulation.getMathDescription().getKey())) {
                    bIgnore = true;
                }
                // 
                for (int j = 0; submittedSimulations != null && j < submittedSimulations.length; j++) {
                    if (correspondingSimulation.getName().equals(submittedSimulations[j].getName())) {
                        bIgnore = true;
                    }
                }
                // 
                if (!bIgnore) {
                    lostResultsSimulationList.add(correspondingSimulation);
                }
            }
        }
    }
    return (Simulation[]) BeanUtils.getArray(lostResultsSimulationList, Simulation.class);
}

Example 63 with Simulation

use of cbit.vcell.solver.Simulation in project vcell by virtualcell.

the class ExportDocument method run.

/**
 * Insert the method's description here.
 * Creation date: (5/31/2004 6:04:14 PM)
 * @param hashTable java.util.Hashtable
 * @param clientWorker cbit.vcell.desktop.controls.ClientWorker
 */
public void run(Hashtable<String, Object> hashTable) throws java.lang.Exception {
    VCDocument documentToExport = (VCDocument) hashTable.get("documentToExport");
    File exportFile = fetch(hashTable, EXPORT_FILE, File.class, true);
    ExtensionFilter fileFilter = fetch(hashTable, FILE_FILTER, ExtensionFilter.class, true);
    DocumentManager documentManager = fetch(hashTable, DocumentManager.IDENT, DocumentManager.class, true);
    String resultString = null;
    FileCloseHelper closeThis = null;
    try {
        if (documentToExport instanceof BioModel) {
            if (!(fileFilter instanceof SelectorExtensionFilter)) {
                throw new Exception("Expecting fileFilter type " + SelectorExtensionFilter.class.getName() + " but got " + fileFilter.getClass().getName());
            }
            BioModel bioModel = (BioModel) documentToExport;
            SimulationContext chosenSimContext = fetch(hashTable, SIM_CONTEXT, SimulationContext.class, false);
            ((SelectorExtensionFilter) fileFilter).writeBioModel(documentManager, bioModel, exportFile, chosenSimContext);
        /*		DELETE this after finishing validation testing
			
			// check format requested
			if (fileFilter.getDescription().equals(FileFilters.FILE_FILTER_MATLABV6.getDescription())){
				// matlab from application; get application
		
				SimulationContext chosenSimContext = fetch(hashTable,SIM_CONTEXT,SimulationContext.class, true);
				// regenerate a fresh MathDescription
				MathMapping mathMapping = chosenSimContext.createNewMathMapping();
				MathDescription mathDesc = mathMapping.getMathDescription();
				if(mathDesc != null && !mathDesc.isSpatial() && !mathDesc.isNonSpatialStoch()){
					// do export
					resultString = exportMatlab(exportFile, fileFilter, mathDesc);
				}else{
					throw new Exception("Matlab export failed: NOT an non-spatial deterministic application!");
				}
			} else if (fileFilter.equals(FileFilters.FILE_FILTER_PDF)) {   
				FileOutputStream fos = null;
				try {
					fos = new FileOutputStream(exportFile);
					documentManager.generatePDF(bioModel, fos);				
				} finally {
					if(fos != null) {
						fos.close();					
					}
				}
				return; 									//will take care of writing to the file as well.
			}
			//Export a simulation to Smoldyn input file, if there are parameter scans
			//in simulation, we'll export multiple Smoldyn input files.
			else if (fileFilter.equals(FileFilters.FILE_FILTER_SMOLDYN_INPUT)) 
			{ 
				Simulation selectedSim = (Simulation)hashTable.get("selectedSimulation");
				if (selectedSim != null) {
					int scanCount = selectedSim.getScanCount();
					if(scanCount > 1) // has parameter scan
					{
						String baseExportFileName = exportFile.getPath().substring(0, exportFile.getPath().indexOf("."));
						for(int i=0; i<scanCount; i++)
						{
							SimulationTask simTask = new SimulationTask(new SimulationJob(selectedSim, i, null),0);
							// Need to export each parameter scan into a separate file
							String newExportFileName = baseExportFileName + "_" + i + SMOLDYN_INPUT_FILE_EXTENSION;
							exportFile = new File(newExportFileName);
							
							PrintWriter pw = new PrintWriter(exportFile);
							SmoldynFileWriter smf = new SmoldynFileWriter(pw, true, null, simTask, false);
							smf.write();
							pw.close();	
						}
					}
					else if(scanCount == 1)// regular simulation, no parameter scan
					{
						SimulationTask simTask = new SimulationTask(new SimulationJob(selectedSim, 0, null),0);
						// export the simulation to the selected file
						PrintWriter pw = new PrintWriter(exportFile);
						SmoldynFileWriter smf = new SmoldynFileWriter(pw, true, null, simTask, false);
						smf.write();
						pw.close();
					}
					else
					{
						throw new Exception("Simulation scan count is smaller than 1.");
					}
				}
				return;
													
			} else {
				// convert it if other format
				if (!fileFilter.equals(FileFilters.FILE_FILTER_VCML)) {
					// SBML or CellML; get application name
					if ((fileFilter.equals(FileFilters.FILE_FILTER_SBML_12)) || (fileFilter.equals(FileFilters.FILE_FILTER_SBML_21)) || 
						(fileFilter.equals(FileFilters.FILE_FILTER_SBML_22)) || (fileFilter.equals(FileFilters.FILE_FILTER_SBML_23)) || 
						(fileFilter.equals(FileFilters.FILE_FILTER_SBML_24)) || (fileFilter.equals(FileFilters.FILE_FILTER_SBML_31_CORE)) || 
						(fileFilter.equals(FileFilters.FILE_FILTER_SBML_31_SPATIAL)) ) {
						SimulationContext selectedSimContext = (SimulationContext)hashTable.get("selectedSimContext");
						Simulation selectedSim = (Simulation)hashTable.get("selectedSimulation");
						int sbmlLevel = 0;
						int sbmlVersion = 0;
						int sbmlPkgVersion = 0;
						boolean bIsSpatial = false;
						if ((fileFilter.equals(FileFilters.FILE_FILTER_SBML_12))) {
							sbmlLevel = 1;
							sbmlVersion = 2;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_21)) {
							sbmlLevel = 2;
							sbmlVersion = 1;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_22)) {
							sbmlLevel = 2;
							sbmlVersion = 2;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_23)) {
							sbmlLevel = 2;
							sbmlVersion = 3;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_24)) {
							sbmlLevel = 2;
							sbmlVersion = 4;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_31_CORE)) {
							sbmlLevel = 3;
							sbmlVersion = 1;
						} else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_31_SPATIAL)) {
							sbmlLevel = 3;
							sbmlVersion = 1;
							sbmlPkgVersion = 1;
							bIsSpatial = true;
						}
						if (selectedSim == null) {
							resultString = XmlHelper.exportSBML(bioModel, sbmlLevel, sbmlVersion, sbmlPkgVersion, bIsSpatial, selectedSimContext, null);
							XmlUtil.writeXMLStringToFile(resultString, exportFile.getAbsolutePath(), true);
							return;
						} else {
							for (int sc = 0; sc < selectedSim.getScanCount(); sc++) {
								SimulationJob simJob = new SimulationJob(selectedSim, sc, null);
								resultString = XmlHelper.exportSBML(bioModel, sbmlLevel, sbmlVersion, sbmlPkgVersion, bIsSpatial, selectedSimContext, simJob);
								// Need to export each parameter scan into a separate file 
								String newExportFileName = exportFile.getPath().substring(0, exportFile.getPath().indexOf(".xml")) + "_" + sc + ".xml";
								exportFile.renameTo(new File(newExportFileName));
								XmlUtil.writeXMLStringToFile(resultString, exportFile.getAbsolutePath(), true);
							}
							return;
						}
					} else if (fileFilter.equals(FileFilters.FILE_FILTER_BNGL)) {
						RbmModelContainer rbmModelContainer = bioModel.getModel().getRbmModelContainer();
						StringWriter bnglStringWriter = new StringWriter();
						PrintWriter pw = new PrintWriter(bnglStringWriter);
						RbmNetworkGenerator.writeBngl(bioModel, pw);
						resultString = bnglStringWriter.toString();
						pw.close();
						
					} else if (fileFilter.equals(FileFilters.FILE_FILTER_NFSIM)) {
						// TODO: get the first thing we find for now, in the future we'll need to modify ChooseFile 
						//       to only offer the applications / simulations with bngl content
						SimulationContext simContexts[] = bioModel.getSimulationContexts();
						SimulationContext aSimulationContext = simContexts[0];
						Simulation selectedSim = aSimulationContext.getSimulations(0);
						//Simulation selectedSim = (Simulation)hashTable.get("selectedSimulation");
						SimulationTask simTask = new SimulationTask(new SimulationJob(selectedSim, 0, null),0);
						long randomSeed = 0;	// a fixed seed will allow us to run reproducible simulations
						//long randomSeed = System.currentTimeMillis();
						NFsimSimulationOptions nfsimSimulationOptions = new NFsimSimulationOptions();
						// we get the data we need from the math description
						Element root = NFsimXMLWriter.writeNFsimXML(simTask, randomSeed, nfsimSimulationOptions);
						Document doc = new Document();
						doc.setRootElement(root);
						XMLOutputter xmlOut = new XMLOutputter();
						resultString = xmlOut.outputString(doc);
	
					} else if (fileFilter.equals(FileFilters.FILE_FILTER_CELLML)) {
						Integer chosenSimContextIndex = (Integer)hashTable.get("chosenSimContextIndex");
						String applicationName = bioModel.getSimulationContext(chosenSimContextIndex.intValue()).getName();
						resultString = XmlHelper.exportCellML(bioModel, applicationName);
						// cellml still uses default character encoding for now ... maybe UTF-8 in the future
					} else if (fileFilter.equals(FileFilters.FILE_FILTER_SEDML)) {
						// export the entire biomodel to a SEDML file (for now, only non-spatial,non-stochastic applns)
						int sedmlLevel = 1;
						int sedmlVersion = 1;
						String sPath = FileUtils.getFullPathNoEndSeparator(exportFile.getAbsolutePath());
						String sFile = FileUtils.getBaseName(exportFile.getAbsolutePath());
						String sExt = FileUtils.getExtension(exportFile.getAbsolutePath());
						
						SEDMLExporter sedmlExporter = null;
						if (bioModel instanceof BioModel) {
							sedmlExporter = new SEDMLExporter(bioModel, sedmlLevel, sedmlVersion);
							resultString = sedmlExporter.getSEDMLFile(sPath);
						} else {
							throw new RuntimeException("unsupported Document Type " + bioModel.getClass().getName() + " for SedML export");
						}
						if(sExt.equals("sedx")) {
							sedmlExporter.createManifest(sPath, sFile);
							String sedmlFileName = sPath + FileUtils.WINDOWS_SEPARATOR + sFile + ".sedml";
							XmlUtil.writeXMLStringToFile(resultString, sedmlFileName, true);
							sedmlExporter.addSedmlFileToList(sFile + ".sedml");
							sedmlExporter.addSedmlFileToList("manifest.xml");
							sedmlExporter.createZipArchive(sPath, sFile);
							return;
						} else {
							XmlUtil.writeXMLStringToFile(resultString, exportFile.getAbsolutePath(), true);
						}
					}
				} else {
					// if format is VCML, get it from biomodel.
					bioModel.getVCMetaData().cleanupMetadata();
					resultString = XmlHelper.bioModelToXML(bioModel);
					XmlUtil.writeXMLStringToFile(resultString, exportFile.getAbsolutePath(), true);
					return;
				}
			}*/
        } else if (documentToExport instanceof MathModel) {
            MathModel mathModel = (MathModel) documentToExport;
            // check format requested
            if (fileFilter.equals(FileFilters.FILE_FILTER_MATLABV6)) {
                // check if it's ODE
                if (mathModel.getMathDescription() != null && (!mathModel.getMathDescription().isSpatial() && !mathModel.getMathDescription().isNonSpatialStoch())) {
                    MathDescription mathDesc = mathModel.getMathDescription();
                    resultString = exportMatlab(exportFile, fileFilter, mathDesc);
                } else {
                    throw new Exception("Matlab export failed: NOT an non-spatial deterministic model.");
                }
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_PDF)) {
                FileOutputStream fos = new FileOutputStream(exportFile);
                documentManager.generatePDF(mathModel, fos);
                fos.close();
                // will take care of writing to the file as well.
                return;
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_VCML)) {
                resultString = XmlHelper.mathModelToXML(mathModel);
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_CELLML)) {
                resultString = XmlHelper.exportCellML(mathModel, null);
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_23)) {
                resultString = XmlHelper.exportSBML(mathModel, 2, 3, 0, false, null, null);
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_SBML_24)) {
                resultString = XmlHelper.exportSBML(mathModel, 2, 4, 0, false, null, null);
            } else // in simulation, we'll export multiple Smoldyn input files.
            if (fileFilter.equals(FileFilters.FILE_FILTER_SMOLDYN_INPUT)) {
                Simulation selectedSim = (Simulation) hashTable.get("selectedSimulation");
                if (selectedSim != null) {
                    int scanCount = selectedSim.getScanCount();
                    // -----
                    String baseExportFileName = (scanCount == 1 ? null : exportFile.getPath().substring(0, exportFile.getPath().indexOf(".")));
                    for (int i = 0; i < scanCount; i++) {
                        SimulationTask simTask = new SimulationTask(new SimulationJob(selectedSim, i, null), 0);
                        // Need to export each parameter scan into a separate file
                        File localExportFile = (scanCount == 1 ? exportFile : new File(baseExportFileName + "_" + i + SMOLDYN_INPUT_FILE_EXTENSION));
                        FileCloseHelper localCloseThis = new FileCloseHelper(localExportFile);
                        try {
                            SmoldynFileWriter smf = new SmoldynFileWriter(localCloseThis.getPrintWriter(), true, null, simTask, false);
                            smf.write();
                        } finally {
                            if (localCloseThis != null) {
                                localCloseThis.close();
                            }
                        }
                    }
                }
                return;
            }
        } else if (documentToExport instanceof Geometry) {
            Geometry geom = (Geometry) documentToExport;
            if (fileFilter.equals(FileFilters.FILE_FILTER_PDF)) {
                documentManager.generatePDF(geom, (closeThis = new FileCloseHelper(exportFile)).getFileOutputStream());
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_VCML)) {
                resultString = XmlHelper.geometryToXML(geom);
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_AVS)) {
                cbit.vcell.export.AVS_UCD_Exporter.writeUCDGeometryOnly(geom.getGeometrySurfaceDescription(), (closeThis = new FileCloseHelper(exportFile)).getFileWriter());
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_STL)) {
                // make sure filename end with .stl
                File stlFile = exportFile;
                if (!exportFile.getName().toLowerCase().endsWith(".stl")) {
                    stlFile = new File(exportFile.getParentFile(), exportFile.getName() + ".stl");
                }
                cbit.vcell.geometry.surface.StlExporter.writeBinaryStl(geom.getGeometrySurfaceDescription(), (closeThis = new FileCloseHelper(stlFile)).getRandomAccessFile("rw"));
            } else if (fileFilter.equals(FileFilters.FILE_FILTER_PLY)) {
                writeStanfordPolygon(geom.getGeometrySurfaceDescription(), (closeThis = new FileCloseHelper(exportFile)).getFileWriter());
            }
        }
        if (resultString != null) {
            (closeThis = new FileCloseHelper(exportFile)).getFileWriter().write(resultString);
        }
    } finally {
        if (closeThis != null) {
            closeThis.close();
        }
    }
}

Example 64 with Simulation

use of cbit.vcell.solver.Simulation in project vcell by virtualcell.

the class BioModelTreeModel method propertyChange.

/**
 * Insert the method's description here.
 * Creation date: (5/9/01 8:28:22 AM)
 * @param evt java.beans.PropertyChangeEvent
 */
public void propertyChange(java.beans.PropertyChangeEvent evt) {
    try {
        if (evt.getSource() == getBioModel() && evt.getPropertyName().equals("simulations")) {
            refreshTree();
            Simulation[] oldSims = (Simulation[]) evt.getOldValue();
            if (oldSims != null) {
                for (int i = 0; i < oldSims.length; i++) {
                    oldSims[i].removePropertyChangeListener(this);
                }
            }
            Simulation[] newSims = (Simulation[]) evt.getNewValue();
            if (newSims != null) {
                for (int i = 0; i < newSims.length; i++) {
                    newSims[i].addPropertyChangeListener(this);
                }
            }
        } else if (evt.getSource() == getBioModel() && evt.getPropertyName().equals("simulationContexts")) {
            refreshTree();
            SimulationContext[] oldSCs = (SimulationContext[]) evt.getOldValue();
            if (oldSCs != null) {
                for (int i = 0; i < oldSCs.length; i++) {
                    oldSCs[i].removePropertyChangeListener(this);
                }
            }
            SimulationContext[] newSCs = (SimulationContext[]) evt.getNewValue();
            if (newSCs != null) {
                for (int i = 0; i < newSCs.length; i++) {
                    newSCs[i].addPropertyChangeListener(this);
                }
            }
        } else if (evt.getSource() == getBioModel() && evt.getPropertyName().equals("description")) {
            BioModel bioModel = (BioModel) evt.getSource();
            BioModelNode bioModelNode = ((BioModelNode) getRoot()).findNodeByUserObject(bioModel);
            BioModelNode annotNode = bioModelNode.findNodeByUserObject(new Annotation((String) evt.getOldValue()));
            if (annotNode == null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                // 
                // must add annotation node (was null string)
                // 
                bioModelNode.insert(new BioModelNode(new Annotation((String) evt.getNewValue()), false), 0);
                nodeStructureChanged(bioModelNode);
            } else if (annotNode != null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                // 
                // change annotation content for annotation node
                // 
                annotNode.setUserObject(new Annotation((String) evt.getNewValue()));
                nodeChanged(annotNode);
            } else if (annotNode != null && (evt.getNewValue() == null || ((String) evt.getNewValue()).equals(""))) {
                // 
                // delete annotation node
                // 
                removeNodeFromParent(annotNode);
            }
        } else if (evt.getSource() instanceof Simulation) {
            if (evt.getPropertyName().equals("name")) {
                Simulation sim = (Simulation) evt.getSource();
                BioModelNode simNode = ((BioModelNode) getRoot()).findNodeByUserObject(sim);
                nodeChanged(simNode);
            } else if (evt.getPropertyName().equals("description")) {
                Simulation sim = (Simulation) evt.getSource();
                BioModelNode simNode = ((BioModelNode) getRoot()).findNodeByUserObject(sim);
                BioModelNode annotNode = simNode.findNodeByUserObject(new Annotation((String) evt.getOldValue()));
                if (annotNode == null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                    // 
                    // must add annotation node (was null string)
                    // 
                    simNode.insert(new BioModelNode(new Annotation((String) evt.getNewValue()), false), 0);
                    nodeStructureChanged(simNode);
                } else if (annotNode != null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                    // 
                    // change annotation content for annotation node
                    // 
                    annotNode.setUserObject(new Annotation((String) evt.getNewValue()));
                    nodeChanged(annotNode);
                } else if (annotNode != null && (evt.getNewValue() == null || ((String) evt.getNewValue()).equals(""))) {
                    // 
                    // delete annotation node
                    // 
                    removeNodeFromParent(annotNode);
                }
            }
        } else if (evt.getSource() instanceof SimulationContext) {
            if (evt.getPropertyName().equals("geometry")) {
                Geometry oldGeometry = (Geometry) evt.getOldValue();
                Geometry newGeometry = (Geometry) evt.getNewValue();
                BioModelNode geoNode = ((BioModelNode) getRoot()).findNodeByUserObject(oldGeometry);
                geoNode.setUserObject(newGeometry);
                nodeChanged(geoNode);
            } else if (evt.getPropertyName().equals("name")) {
                SimulationContext simContext = (SimulationContext) evt.getSource();
                BioModelNode scNode = ((BioModelNode) getRoot()).findNodeByUserObject(simContext);
                nodeChanged(scNode);
            } else if (evt.getPropertyName().equals("description")) {
                SimulationContext simContext = (SimulationContext) evt.getSource();
                BioModelNode scNode = ((BioModelNode) getRoot()).findNodeByUserObject(simContext);
                BioModelNode annotNode = scNode.findNodeByUserObject(new Annotation((String) evt.getOldValue()));
                if (annotNode == null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                    // 
                    // must add annotation node (was null string)
                    // 
                    scNode.insert(new BioModelNode(new Annotation((String) evt.getNewValue()), false), 0);
                    nodeStructureChanged(scNode);
                } else if (annotNode != null && evt.getNewValue() != null && !((String) evt.getNewValue()).equals("")) {
                    // 
                    // change annotation content for annotation node
                    // 
                    annotNode.setUserObject(new Annotation((String) evt.getNewValue()));
                    nodeChanged(annotNode);
                } else if (annotNode != null && (evt.getNewValue() == null || ((String) evt.getNewValue()).equals(""))) {
                    // 
                    // delete annotation node
                    // 
                    removeNodeFromParent(annotNode);
                }
            } else if (evt.getPropertyName().equals("mathDescription")) {
                SimulationContext simContext = (SimulationContext) evt.getSource();
                BioModelNode scNode = ((BioModelNode) getRoot()).findNodeByUserObject(simContext);
                nodeStructureChanged(scNode);
            }
        }
    } catch (Exception e) {
        e.printStackTrace(System.out);
    }
}

Example 65 with Simulation

use of cbit.vcell.solver.Simulation in project vcell by virtualcell.

the class BioModelTreeModel method setBioModel.

/**
 * Sets the bioModel property (cbit.vcell.biomodel.BioModel) value.
 * @param bioModel The new value for the property.
 * @see #getBioModel
 */
public void setBioModel(cbit.vcell.biomodel.BioModel bioModel) {
    cbit.vcell.biomodel.BioModel oldValue = fieldBioModel;
    if (oldValue != null) {
        oldValue.removePropertyChangeListener(this);
        SimulationContext[] SCs = oldValue.getSimulationContexts();
        for (int i = 0; SCs != null && i < SCs.length; i++) {
            SCs[i].removePropertyChangeListener(this);
            SCs[i].getGeometryContext().removePropertyChangeListener(this);
        }
        Simulation[] sims = oldValue.getSimulations();
        for (int i = 0; sims != null && i < sims.length; i++) {
            sims[i].removePropertyChangeListener(this);
        }
        oldValue.getVCMetaData().removeAnnotationEventListener(this);
    }
    fieldBioModel = bioModel;
    if (bioModel != null) {
        bioModel.addPropertyChangeListener(this);
        SimulationContext[] SCs = bioModel.getSimulationContexts();
        for (int i = 0; SCs != null && i < SCs.length; i++) {
            SCs[i].addPropertyChangeListener(this);
            SCs[i].getGeometryContext().addPropertyChangeListener(this);
        }
        Simulation[] sims = bioModel.getSimulations();
        for (int i = 0; sims != null && i < sims.length; i++) {
            sims[i].addPropertyChangeListener(this);
        }
        bioModel.getVCMetaData().addAnnotationEventListener(this);
    }
    firePropertyChange("bioModel", oldValue, bioModel);
    refreshTree();
}