Example 11 with ASTNode
use of org.sbml.jsbml.ASTNode in project vcell by virtualcell.
the class MathModel_SBMLExporter method addGeometry.
private static void addGeometry(Model sbmlModel, MathModel vcMathModel) {
SpatialModelPlugin mplugin = (SpatialModelPlugin) sbmlModel.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
// Creates a geometry object via SpatialModelPlugin object.
org.sbml.jsbml.ext.spatial.Geometry sbmlGeometry = mplugin.getGeometry();
sbmlGeometry.setCoordinateSystem(GeometryKind.cartesian);
Geometry vcGeometry = vcMathModel.getGeometry();
//
// list of CoordinateComponents : 1 if geometry is 1-d, 2 if geometry is 2-d, 3 if geometry is 3-d
//
int dimension = vcGeometry.getDimension();
Extent vcExtent = vcGeometry.getExtent();
Origin vcOrigin = vcGeometry.getOrigin();
// add x coordinate component
CoordinateComponent coordCompX = sbmlGeometry.createCoordinateComponent();
coordCompX.setSpatialId("CoordCompX");
coordCompX.setType(CoordinateKind.cartesianX);
Boundary minX = coordCompX.getBoundaryMaximum();
minX.setSpatialId("Xmin");
minX.setValue(vcOrigin.getX());
Boundary maxX = coordCompX.getBoundaryMaximum();
maxX.setSpatialId("Xmax");
maxX.setValue(vcOrigin.getX() + (vcExtent.getX()));
Parameter parameterX = sbmlModel.createParameter();
// note for exporting BioModels rather than MathModels, get ReservedSymbol from Model with Role of ReservedSymbolRole.X
parameterX.setId(ReservedVariable.X.getName());
SpatialSymbolReference coordXSpatialRef = new SpatialSymbolReference();
coordXSpatialRef.setSpatialRef(coordCompX.getSpatialId());
SpatialParameterPlugin parameterXSpatialPlugin = (SpatialParameterPlugin) parameterX.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
parameterXSpatialPlugin.setParamType(coordXSpatialRef);
// add y coordinate component
if (dimension == 2 || dimension == 3) {
CoordinateComponent coordCompY = sbmlGeometry.createCoordinateComponent();
coordCompY.setSpatialId("CoordCompY");
coordCompY.setType(CoordinateKind.cartesianY);
Boundary minY = coordCompY.getBoundaryMinimum();
minY.setId("Ymin");
minY.setValue(vcOrigin.getY());
Boundary maxY = coordCompY.getBoundaryMaximum();
maxY.setId("Ymax");
maxY.setValue(vcOrigin.getY() + (vcExtent.getY()));
Parameter parameterY = sbmlModel.createParameter();
// note for exporting BioModels rather than MathModels, get ReservedSymbol from Model with Role of ReservedSymbolRole.Y
parameterY.setId(ReservedVariable.Y.getName());
SpatialSymbolReference coordYSpatialRef = new SpatialSymbolReference();
coordYSpatialRef.setSpatialRef(coordCompY.getSpatialId());
SpatialParameterPlugin parameterYSpatialPlugin = (SpatialParameterPlugin) parameterY.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
parameterYSpatialPlugin.setParamType(coordYSpatialRef);
}
// add z coordinate component
if (dimension == 3) {
CoordinateComponent coordCompZ = sbmlGeometry.createCoordinateComponent();
coordCompZ.setSpatialId("CoordCompZ");
coordCompZ.setType(CoordinateKind.cartesianZ);
Boundary minZ = coordCompZ.getBoundaryMinimum();
minZ.setId("Zmin");
minZ.setValue(vcOrigin.getZ());
Boundary maxZ = coordCompZ.getBoundaryMaximum();
maxZ.setId("Zmax");
maxZ.setValue(vcOrigin.getZ() + (vcExtent.getZ()));
Parameter parameterZ = sbmlModel.createParameter();
// note for exporting BioModels rather than MathModels, get ReservedSymbol from Model with Role of ReservedSymbolRole.Y
parameterZ.setId(ReservedVariable.Z.getName());
SpatialSymbolReference coordZSpatialRef = new SpatialSymbolReference();
coordZSpatialRef.setSpatialRef(coordCompZ.getSpatialId());
SpatialParameterPlugin parameterZSpatialPlugin = (SpatialParameterPlugin) parameterZ.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
parameterZSpatialPlugin.setParamType(coordZSpatialRef);
}
//
// list of domain types : subvolumes and surface classes from VC
// Also create compartments - one compartment for each geometryClass. set id and spatialDimension based on type of geometryClass.
//
boolean bAnalyticGeom = false;
boolean bImageGeom = false;
GeometryClass[] vcGeomClasses = vcGeometry.getGeometryClasses();
int numVCGeomClasses = vcGeomClasses.length;
for (int i = 0; i < numVCGeomClasses; i++) {
DomainType domainType = sbmlGeometry.createDomainType();
domainType.setId(vcGeomClasses[i].getName());
if (vcGeomClasses[i] instanceof SubVolume) {
if (((SubVolume) vcGeomClasses[i]) instanceof AnalyticSubVolume) {
bAnalyticGeom = true;
} else if (((SubVolume) vcGeomClasses[i]) instanceof ImageSubVolume) {
bImageGeom = true;
}
domainType.setSpatialDimensions(3);
} else if (vcGeomClasses[i] instanceof SurfaceClass) {
domainType.setSpatialDimensions(2);
}
}
//
// list of domains, adjacent domains : from VC geometricRegions
//
GeometrySurfaceDescription vcGSD = vcGeometry.getGeometrySurfaceDescription();
if (vcGSD.getRegionImage() == null) {
try {
vcGSD.updateAll();
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to generate region images for geometry");
}
}
GeometricRegion[] vcGeometricRegions = vcGSD.getGeometricRegions();
ISize sampleSize = vcGSD.getVolumeSampleSize();
int numX = sampleSize.getX();
int numY = sampleSize.getY();
int numZ = sampleSize.getZ();
double ox = vcOrigin.getX();
double oy = vcOrigin.getY();
double oz = vcOrigin.getZ();
RegionInfo[] regionInfos = vcGSD.getRegionImage().getRegionInfos();
Compartment compartment = null;
for (int i = 0; i < vcGeometricRegions.length; i++) {
// domains
Domain domain = sbmlGeometry.createDomain();
domain.setId(vcGeometricRegions[i].getName());
compartment = sbmlModel.createCompartment();
compartment.setId("compartment" + i);
if (vcGeometricRegions[i] instanceof VolumeGeometricRegion) {
domain.setDomainType(((VolumeGeometricRegion) vcGeometricRegions[i]).getSubVolume().getName());
// domain.setImplicit(false);
compartment.setSpatialDimensions(3);
InteriorPoint interiorPt = domain.createInteriorPoint();
int regionID = ((VolumeGeometricRegion) vcGeometricRegions[i]).getRegionID();
boolean bFound = false;
int regInfoIndx = 0;
for (int j = 0; j < regionInfos.length; j++) {
regInfoIndx = j;
if (regionInfos[j].getRegionIndex() == regionID) {
int volIndx = 0;
for (int z = 0; z < numZ && !bFound; z++) {
for (int y = 0; y < numY && !bFound; y++) {
for (int x = 0; x < numX && !bFound; x++) {
if (regionInfos[j].isIndexInRegion(volIndx)) {
bFound = true;
double unit_z = (numZ > 1) ? ((double) z) / (numZ - 1) : 0.5;
double coordZ = oz + vcExtent.getZ() * unit_z;
double unit_y = (numY > 1) ? ((double) y) / (numY - 1) : 0.5;
double coordY = oy + vcExtent.getY() * unit_y;
double unit_x = (numX > 1) ? ((double) x) / (numX - 1) : 0.5;
double coordX = ox + vcExtent.getX() * unit_x;
interiorPt.setCoord1(coordX);
interiorPt.setCoord2(coordY);
interiorPt.setCoord3(coordZ);
}
volIndx++;
}
// end - for x
}
// end - for y
}
// end - for z
}
// end if
}
// end for regionInfos
if (!bFound) {
throw new RuntimeException("Unable to find interior point for region '" + regionInfos[regInfoIndx].toString());
}
} else if (vcGeometricRegions[i] instanceof SurfaceGeometricRegion) {
SurfaceGeometricRegion vcSurfaceGeomReg = (SurfaceGeometricRegion) vcGeometricRegions[i];
GeometricRegion geomRegion0 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[0];
GeometricRegion geomRegion1 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[1];
SurfaceClass surfaceClass = vcGSD.getSurfaceClass(((VolumeGeometricRegion) geomRegion0).getSubVolume(), ((VolumeGeometricRegion) geomRegion1).getSubVolume());
domain.setDomainType(surfaceClass.getName());
// domain.setImplicit(true);
compartment.setSpatialDimensions(2);
// adjacent domains : 2 adjacent domain objects for each surfaceClass in VC.
// adjacent domain 1
AdjacentDomains adjDomain = sbmlGeometry.createAdjacentDomain();
adjDomain.setId(TokenMangler.mangleToSName(vcSurfaceGeomReg.getName() + "_" + geomRegion0.getName()));
adjDomain.setDomain1(vcSurfaceGeomReg.getName());
adjDomain.setDomain2(geomRegion0.getName());
// adjacent domain 2
adjDomain = sbmlGeometry.createAdjacentDomain();
adjDomain.setId(TokenMangler.mangleToSName(vcSurfaceGeomReg.getName() + "_" + geomRegion1.getName()));
adjDomain.setDomain1(vcSurfaceGeomReg.getName());
adjDomain.setDomain2(geomRegion1.getName());
}
//
// Mathmodel does not have structureMapping, hence creating compartmentMapping while creating domains.
// @TODO : how to assign unitSize for compartmentMapping?
//
SpatialCompartmentPlugin cplugin = (SpatialCompartmentPlugin) compartment.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
CompartmentMapping compMapping = cplugin.getCompartmentMapping();
String compMappingId = TokenMangler.mangleToSName(domain.getDomainType() + "_" + compartment.getId());
compMapping.setId(compMappingId);
compMapping.setDomainType(TokenMangler.mangleToSName(domain.getDomainType()));
// try {
// compMapping.setUnitSize(1.0);
// } catch (ExpressionException e) {
// e.printStackTrace(System.out);
// throw new RuntimeException("Unable to create compartment mapping for structureMapping '" + compMapping.getId() +"' : " + e.getMessage());
// }
}
AnalyticGeometry sbmlAnalyticGeom = null;
SampledFieldGeometry sbmlSFGeom = null;
// both image and analytic subvolumes?? == not handled in SBML at this time.
if (bAnalyticGeom && !bImageGeom) {
sbmlAnalyticGeom = sbmlGeometry.createAnalyticGeometry();
sbmlAnalyticGeom.setId(TokenMangler.mangleToSName(vcGeometry.getName()));
} else if (bImageGeom && !bAnalyticGeom) {
// assuming image based geometry if not analytic geometry
sbmlSFGeom = sbmlGeometry.createSampledFieldGeometry();
sbmlSFGeom.setId(TokenMangler.mangleToSName(vcGeometry.getName()));
} else if (bAnalyticGeom && bImageGeom) {
throw new RuntimeException("Export to SBML of a combination of Image-based and Analytic geometries is not supported yet.");
} else if (!bAnalyticGeom && !bImageGeom) {
throw new RuntimeException("Unknown geometry type.");
}
//
for (int i = 0; i < vcGeomClasses.length; i++) {
if (vcGeomClasses[i] instanceof AnalyticSubVolume) {
// add analytiVols to sbmlAnalyticGeometry
if (sbmlAnalyticGeom != null) {
AnalyticVolume analyticVol = sbmlAnalyticGeom.createAnalyticVolume();
analyticVol.setId(vcGeomClasses[i].getName());
analyticVol.setDomainType(vcGeomClasses[i].getName());
analyticVol.setFunctionType(FunctionKind.layered);
analyticVol.setOrdinal(i);
Expression expr = ((AnalyticSubVolume) vcGeomClasses[i]).getExpression();
try {
String mathMLStr = ExpressionMathMLPrinter.getMathML(expr, true);
ASTNode mathMLNode = ASTNode.readMathMLFromString(mathMLStr);
analyticVol.setMath(mathMLNode);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error converting VC subvolume expression to mathML" + e.getMessage());
}
} else {
throw new RuntimeException("SBML AnalyticGeometry is null.");
}
} else if (vcGeomClasses[i] instanceof ImageSubVolume) {
// add sampledVols to sbmlSFGeometry
if (sbmlSFGeom != null) {
SampledVolume sampledVol = sbmlSFGeom.createSampledVolume();
sampledVol.setId(vcGeomClasses[i].getName());
sampledVol.setDomainType(vcGeomClasses[i].getName());
sampledVol.setSampledValue(((ImageSubVolume) vcGeomClasses[i]).getPixelValue());
} else {
throw new RuntimeException("SBML SampledFieldGeometry is null.");
}
}
}
if (sbmlSFGeom != null) {
// add sampledField to sampledFieldGeometry
SampledField sampledField = sbmlGeometry.createSampledField();
VCImage vcImage = vcGeometry.getGeometrySpec().getImage();
sampledField.setId(vcImage.getName());
sampledField.setNumSamples1(vcImage.getNumX());
if (vcImage.getNumY() > 1) {
sampledField.setNumSamples2(vcImage.getNumY());
}
if (vcImage.getNumZ() > 1) {
sampledField.setNumSamples3(vcImage.getNumZ());
}
sampledField.setInterpolationType(InterpolationKind.nearestNeighbor);
sampledField.setDataType(DataKind.UINT8);
// add image from vcGeometrySpec to sampledField.
try {
StringBuffer sb = new StringBuffer();
byte[] imagePixelsBytes = vcImage.getPixelsCompressed();
for (int i = 0; i < imagePixelsBytes.length; i++) {
int uint8_sample = ((int) imagePixelsBytes[i]) & 0xff;
sb.append(uint8_sample + " ");
}
sampledField.setSamplesLength(vcImage.getNumXYZ());
sampledField.setSamples(sb.toString().trim());
} catch (ImageException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to export image from VCell to SBML : " + e.getMessage());
}
}
}
Also used :
Origin(org.vcell.util.Origin)
CompartmentMapping(org.sbml.jsbml.ext.spatial.CompartmentMapping)
Compartment(org.sbml.jsbml.Compartment)
SpatialParameterPlugin(org.sbml.jsbml.ext.spatial.SpatialParameterPlugin)
AnalyticGeometry(org.sbml.jsbml.ext.spatial.AnalyticGeometry)
Boundary(org.sbml.jsbml.ext.spatial.Boundary)
DomainType(org.sbml.jsbml.ext.spatial.DomainType)
SampledVolume(org.sbml.jsbml.ext.spatial.SampledVolume)
SubVolume(cbit.vcell.geometry.SubVolume)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
SpatialCompartmentPlugin(org.sbml.jsbml.ext.spatial.SpatialCompartmentPlugin)
CoordinateComponent(org.sbml.jsbml.ext.spatial.CoordinateComponent)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
GeometricRegion(cbit.vcell.geometry.surface.GeometricRegion)
SpatialSymbolReference(org.sbml.jsbml.ext.spatial.SpatialSymbolReference)
AnalyticVolume(org.sbml.jsbml.ext.spatial.AnalyticVolume)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
SampledField(org.sbml.jsbml.ext.spatial.SampledField)
Domain(org.sbml.jsbml.ext.spatial.Domain)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
GeometryClass(cbit.vcell.geometry.GeometryClass)
ImageException(cbit.image.ImageException)
GeometrySurfaceDescription(cbit.vcell.geometry.surface.GeometrySurfaceDescription)
Extent(org.vcell.util.Extent)
SurfaceClass(cbit.vcell.geometry.SurfaceClass)
ISize(org.vcell.util.ISize)
RegionInfo(cbit.vcell.geometry.RegionImage.RegionInfo)
VCImage(cbit.image.VCImage)
ASTNode(org.sbml.jsbml.ASTNode)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
SpatialModelPlugin(org.sbml.jsbml.ext.spatial.SpatialModelPlugin)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
XMLStreamException(javax.xml.stream.XMLStreamException)
ImageException(cbit.image.ImageException)
SBMLException(org.sbml.jsbml.SBMLException)
AdjacentDomains(org.sbml.jsbml.ext.spatial.AdjacentDomains)
Geometry(cbit.vcell.geometry.Geometry)
AnalyticGeometry(org.sbml.jsbml.ext.spatial.AnalyticGeometry)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
Expression(cbit.vcell.parser.Expression)
Parameter(org.sbml.jsbml.Parameter)
Example 12 with ASTNode
use of org.sbml.jsbml.ASTNode in project vcell by virtualcell.
the class MainController method addActionListenersToView.
private void addActionListenersToView() {
view.addNewListener(event -> {
model.setProject(new Project("New project"));
});
view.addOpenListener(event -> {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int returnVal = fileChooser.showOpenDialog(view);
if (returnVal == JFileChooser.APPROVE_OPTION) {
Task<Project, String> loadTask = projectService.load(fileChooser.getSelectedFile());
loadTask.addPropertyChangeListener(propertyChangeEvent -> {
if (propertyChangeEvent.getPropertyName().equals(Task.STATE) && loadTask.getState() == SwingWorker.StateValue.DONE) {
try {
model.setProject(loadTask.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
});
try {
executeTaskWithProgressDialog(loadTask, view, "Loading...", false);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
});
view.addSaveListener(event -> {
Task<Void, String> saveTask = projectService.save(model.getProject());
try {
executeTaskWithProgressDialog(saveTask, view, "Saving...", false);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
});
view.addSaveAsListener(event -> {
JFileChooser fileChooser = new JFileChooser();
int returnVal = fileChooser.showSaveDialog(view);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fileChooser.getSelectedFile();
model.setProjectTitle(file.getName());
Task<Void, String> saveAsTask = projectService.saveAs(model.getProject(), file);
try {
executeTaskWithProgressDialog(saveAsTask, view, "Saving...", false);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
});
view.addImportDataListener(event -> {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
if (presentOpenFileChooser(fileChooser)) {
Dataset dataset = getDatasetFromFile(fileChooser.getSelectedFile());
model.addData(dataset);
}
});
view.addImportGeometryListener(event -> {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
if (presentOpenFileChooser(fileChooser)) {
Dataset dataset = getDatasetFromFile(fileChooser.getSelectedFile());
model.addGeometry(dataset);
}
});
view.addImportResultsSingleListener(event -> {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
if (presentOpenFileChooser(fileChooser)) {
Dataset dataset = getDatasetFromFile(fileChooser.getSelectedFile());
model.addResult(dataset);
}
});
view.addImportResultsTimeSeriesListener(event -> {
JFileChooser fileChooser = new JFileChooser();
fileChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
if (presentOpenFileChooser(fileChooser)) {
try {
Dataset dataset = vCellResultService.importCsv(fileChooser.getSelectedFile());
model.addResult(dataset);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
});
view.addExportListener(event -> {
Dataset dataset = view.getSelectedDataset();
if (dataset == null) {
JOptionPane.showMessageDialog(view, "Please select a dataset to export.", "No dataset selected", JOptionPane.PLAIN_MESSAGE);
return;
}
JFileChooser fileChooser = new JFileChooser();
fileChooser.setSelectedFile(new File(dataset.getName()));
int returnVal = fileChooser.showSaveDialog(view);
if (returnVal == JFileChooser.APPROVE_OPTION) {
try {
datasetIOService.save(dataset.duplicate(), fileChooser.getSelectedFile().getPath());
} catch (IOException e) {
e.printStackTrace();
}
}
});
view.addChangeAxesListener(event -> {
Dataset dataset = view.getSelectedDataset();
if (dataset == null) {
JOptionPane.showMessageDialog(view, "Please select a dataset to edit.", "No dataset selected", JOptionPane.PLAIN_MESSAGE);
return;
}
ChangeAxesPanel panel = new ChangeAxesPanel(dataset);
int returnVal = JOptionPane.showConfirmDialog(view, panel, "Change Axes", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
if (returnVal == JOptionPane.OK_OPTION) {
model.changeAxes(dataset, panel.getSelectedAxisTypes());
}
});
view.addDeleteListener(event -> {
Dataset dataset = view.getSelectedDataset();
if (dataset == null) {
JOptionPane.showMessageDialog(view, "Please select a dataset to delete.", "No dataset selected", JOptionPane.PLAIN_MESSAGE);
return;
}
int result = JOptionPane.showConfirmDialog(view, "Are you sure you want to delete \"" + dataset.getName() + "\"?", "Delete", JOptionPane.OK_CANCEL_OPTION);
if (result == JOptionPane.OK_OPTION) {
model.delete(dataset);
}
});
view.addCompareDatasetsListener(event -> {
List<Dataset> datasetList = model.getProject().getData();
datasetList.addAll(model.getProject().getGeometry());
datasetList.addAll(model.getProject().getResults());
Dataset[] datasetArray = datasetList.toArray(new Dataset[datasetList.size()]);
DatasetSelectionPanel panel = new DatasetSelectionPanel();
String descriptionA = "Dataset A:";
String descriptionB = "Dataset B:";
panel.addComboBox(datasetArray, descriptionA);
panel.addComboBox(datasetArray, descriptionB);
int returnVal = JOptionPane.showConfirmDialog(view, panel, "Select datasets to compare", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
if (returnVal == JOptionPane.OK_OPTION) {
ArrayList<Dataset> datasets = new ArrayList<>();
datasets.add(panel.getSelectedDatasetForDescription(descriptionA));
datasets.add(panel.getSelectedDatasetForDescription(descriptionB));
if (!Datasets.areSameSize(datasets.toArray(new Dataset[datasets.size()]), 0, 1)) {
JOptionPane.showMessageDialog(view, "The selected datasets are not the same size.", "Incompatible datasets", JOptionPane.ERROR_MESSAGE);
return;
}
CompareView compareView = new CompareView(datasets);
new CompareController(compareView, model, context);
compareView.setVisible(true);
for (Dataset dataset : datasets) {
inFrameDisplayService.displayDataset(dataset, compareView);
}
}
});
view.addConstructTIRFGeometryListener(event -> {
List<Dataset> dataList = model.getProject().getData();
Dataset[] dataArray = dataList.toArray(new Dataset[dataList.size()]);
ConstructTIRFGeometryInputPanel panel = new ConstructTIRFGeometryInputPanel(dataArray);
int returnVal = JOptionPane.showConfirmDialog(view, panel, "Construct TIRF Geometry", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
if (returnVal == JOptionPane.OK_OPTION) {
Dataset dataset = panel.getData();
int sliceIndex = panel.getSliceIndex();
double wavelength = panel.getWavelength();
double angle = panel.getAngle();
double zSpacing = panel.getZSpacing();
Dataset geometry = (Dataset) opService.run("constructTIRFGeometry", dataset, sliceIndex, wavelength, angle, zSpacing);
String baseName = FilenameUtils.getBaseName(dataset.getName());
String extension = FilenameUtils.getExtension(dataset.getName());
geometry.setName(baseName + "_geometry." + extension);
model.addGeometry(geometry);
}
});
view.addConstructTIRFImageListener(event -> {
List<Dataset> geometry = model.getProject().getGeometry();
List<Dataset> results = model.getProject().getResults();
Dataset[] geometryArray = geometry.toArray(new Dataset[geometry.size()]);
Dataset[] resultsArray = results.toArray(new Dataset[results.size()]);
ConstructTIRFImageInputPanel panel = new ConstructTIRFImageInputPanel(geometryArray, resultsArray);
int returnVal = JOptionPane.showConfirmDialog(view, panel, "Construct TIRF Image", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
if (returnVal == JOptionPane.OK_OPTION) {
Dataset selectedGeometry = panel.getGeometry();
Dataset selectedMembraneResults = panel.getMembraneResults();
Dataset selectedVolumeResults = panel.getVolumeResults();
double wavelength = panel.getWavelength();
double angle = panel.getAngle();
double zSpacing = panel.getZSpacing();
double xySpacing = panel.getXSpacing() * panel.getYSpacing();
Dataset result = (Dataset) opService.run("constructTIRFImage", selectedGeometry, selectedMembraneResults, selectedVolumeResults, wavelength, angle, zSpacing, xySpacing);
String baseName = FilenameUtils.getBaseName(selectedGeometry.getName());
if (baseName.endsWith("_geometry")) {
baseName = baseName.substring(0, baseName.length() - "_geometry".length());
}
String extension = FilenameUtils.getExtension(selectedGeometry.getName());
result.setName(baseName + "_constructed_TIRF." + extension);
model.addResult(result);
}
});
view.addNewModelListener(event -> {
Task<List<VCellModel>, String> loadTask = vCellModelService.getModels(vCellService);
try {
List<VCellModel> models = executeTaskWithProgressDialog(loadTask, view, "Loading models...", false);
VCellModelSelectionDialog dialog = new VCellModelSelectionDialog(view, vCellModelService);
dialog.setModels(models);
int resultVal = dialog.display();
if (resultVal == JOptionPane.OK_OPTION) {
VCellModel selectedModel = dialog.getSelectedModel();
if (selectedModel != null) {
model.addModel(selectedModel);
}
}
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
});
view.addSimulateModelListener(event -> {
VCellModel vCellModel = view.getSelectedModel();
if (vCellModel == null) {
JOptionPane.showMessageDialog(view, "Please select a model to simulate.", "No model selected", JOptionPane.PLAIN_MESSAGE);
return;
} else if (vCellModel.getSimulationState() == SimulationState.running) {
JOptionPane.showMessageDialog(view, "This simulation is currently in progress", "Simulation in progress", JOptionPane.PLAIN_MESSAGE);
return;
}
SimulateModelPanel panel = new SimulateModelPanel(vCellModel);
int returnVal = JOptionPane.showConfirmDialog(view, panel, "Simulate model", JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);
if (returnVal == JOptionPane.OK_OPTION) {
// Update parameters of model from user input
HashMap<Parameter, ASTNode> parameterMathMap = panel.getParameterMathMap();
Model sbmlModel = vCellModel.getSbmlDocument().getModel();
for (Parameter parameter : parameterMathMap.keySet()) {
sbmlModel.getParameter(parameter.getId()).setValue(parameter.getValue());
ASTNode math = parameterMathMap.get(parameter);
if (math != null) {
ExplicitRule rule = sbmlModel.getRuleByVariable(parameter.getId());
if (rule != null) {
rule.setMath(math);
}
}
}
SimulationSpec simSpec = new SimulationSpec();
simSpec.setOutputTimeStep(panel.getTimeStep());
simSpec.setTotalTime(panel.getTotalTime());
Task<List<Dataset>, SimulationState> task = vCellService.runSimulation(vCellModel, simSpec, panel.getSelectedSpecies(), panel.getShouldCreateIndividualDatasets());
task.addPropertyChangeListener(propertyChangeEvent -> {
if (propertyChangeEvent.getPropertyName().equals(Task.SUBTASK)) {
model.setSimulationStateForVCellModel(task.getSubtask(), vCellModel);
}
});
task.addDoneListener(propertyChangeEvent -> {
try {
List<Dataset> results = task.get();
for (Dataset result : results) {
model.addResult(result);
}
System.out.println(results.toString());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
});
task.execute();
}
});
view.addTabbedPaneChangeListener(event -> {
view.clearListSelection();
});
view.addListSelectionListener(event -> {
if (!event.getValueIsAdjusting()) {
Object selected = ((JList<?>) event.getSource()).getSelectedValue();
if (Dataset.class.isInstance(selected)) {
view.displayDataset((Dataset) selected);
} else if (VCellModel.class.isInstance(selected)) {
view.displayModel((VCellModel) selected);
}
}
});
}
Also used :
ExplicitRule(org.sbml.jsbml.ExplicitRule)
SimulateModelPanel(org.vcell.imagej.common.vcell.SimulateModelPanel)
FileNotFoundException(java.io.FileNotFoundException)
ArrayList(java.util.ArrayList)
SimulationSpec(org.vcell.vcellij.api.SimulationSpec)
ASTNode(org.sbml.jsbml.ASTNode)
ArrayList(java.util.ArrayList)
JList(javax.swing.JList)
List(java.util.List)
VCellModelSelectionDialog(org.vcell.imagej.common.vcell.VCellModelSelectionDialog)
ExecutionException(java.util.concurrent.ExecutionException)
Dataset(net.imagej.Dataset)
IOException(java.io.IOException)
JFileChooser(javax.swing.JFileChooser)
VCellModel(org.vcell.imagej.common.vcell.VCellModel)
Model(org.sbml.jsbml.Model)
VCellModel(org.vcell.imagej.common.vcell.VCellModel)
Parameter(org.sbml.jsbml.Parameter)
SimulationState(org.vcell.vcellij.api.SimulationState)
ChangeAxesPanel(org.vcell.imagej.common.gui.ChangeAxesPanel)
File(java.io.File)
JList(javax.swing.JList)
Example 13 with ASTNode
use of org.sbml.jsbml.ASTNode in project vcell by virtualcell.
the class SBMLExporter method addSpecies.
/**
* addSpecies comment.
* @throws XMLStreamException
* @throws SbmlException
*/
protected void addSpecies() throws XMLStreamException, SbmlException {
Model vcModel = vcBioModel.getModel();
SpeciesContext[] vcSpeciesContexts = vcModel.getSpeciesContexts();
for (int i = 0; i < vcSpeciesContexts.length; i++) {
org.sbml.jsbml.Species sbmlSpecies = sbmlModel.createSpecies();
sbmlSpecies.setId(vcSpeciesContexts[i].getName());
if (vcSpeciesContexts[i].getSbmlName() != null) {
sbmlSpecies.setName(vcSpeciesContexts[i].getSbmlName());
}
// Assuming that at this point, the compartment(s) for the model are already filled in.
Compartment compartment = sbmlModel.getCompartment(TokenMangler.mangleToSName(vcSpeciesContexts[i].getStructure().getName()));
if (compartment != null) {
sbmlSpecies.setCompartment(compartment.getId());
}
// 'hasSubstanceOnly' field will be 'true', since export to SBML is done by converting to initial amounts.
sbmlSpecies.setHasOnlySubstanceUnits(true);
// Get (and set) the initial concentration value
if (getSelectedSimContext() == null) {
throw new RuntimeException("No simcontext (application) specified; Cannot proceed.");
}
// Get the speciesContextSpec in the simContext corresponding to the 'speciesContext'; and extract its initial concentration value.
SpeciesContextSpec vcSpeciesContextsSpec = getSelectedSimContext().getReactionContext().getSpeciesContextSpec(vcSpeciesContexts[i]);
// since we are setting the substance units for species to 'molecule' or 'item', a unit that is originally in uM (or molecules/um2),
// we need to convert concentration from uM -> molecules/um3; this can be achieved by dividing by KMOLE.
// for now we don't do this here and defer to the mechanisms built into the SimContext to convert and set amount instead of concentration
// TO-DO: change to export either concentrations or amounts depending on the type of SimContext and setting
SpeciesContextSpecParameter initCount = vcSpeciesContextsSpec.getInitialCountParameter();
if (initCount.getExpression() == null) {
try {
getSelectedSimContext().convertSpeciesIniCondition(false);
} catch (MappingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new RuntimeException(e.getMessage());
} catch (PropertyVetoException e) {
// TODO Auto-generated catch block
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
Expression initCountExpr = initCount.getExpression();
try {
sbmlSpecies.setInitialAmount(initCountExpr.evaluateConstant());
} catch (cbit.vcell.parser.ExpressionException e) {
// If exporting to L2V3, if species concentration is not an expr with x, y, z or other species, add as InitialAssignment, else complain.
if (initCountExpr != null) {
if ((sbmlLevel == 2 && sbmlVersion >= 3) || (sbmlLevel > 2)) {
// L2V3 and above - add expression as init assignment
cbit.vcell.mapping.AssignmentRule vcellAs = getSelectedSimContext().getAssignmentRule(vcSpeciesContexts[i]);
if (vcellAs == null) {
// we don't create InitialAssignment for an AssignmentRule variable (Reference: L3V1 Section 4.8)
ASTNode initAssgnMathNode = getFormulaFromExpression(initCountExpr);
InitialAssignment initAssignment = sbmlModel.createInitialAssignment();
initAssignment.setSymbol(vcSpeciesContexts[i].getName());
initAssignment.setMath(initAssgnMathNode);
}
} else {
// L2V1 (or L1V2 also??)
// do nothing - we no longer support export to level <3
// // L2V1 (and L1V2?) and species is 'fixed' (constant), and not fn of x,y,z, other sp, add expr as assgn rule
// ASTNode assgnRuleMathNode = getFormulaFromExpression(initCountExpr);
// AssignmentRule assgnRule = sbmlModel.createAssignmentRule();
// assgnRule.setVariable(vcSpeciesContexts[i].getName());
// assgnRule.setMath(assgnRuleMathNode);
}
}
}
// Get (and set) the boundary condition value
boolean bBoundaryCondition = getBoundaryCondition(vcSpeciesContexts[i]);
sbmlSpecies.setBoundaryCondition(bBoundaryCondition);
// mandatory for L3, optional for L2
sbmlSpecies.setConstant(false);
// set species substance units as 'molecules' - same as defined in the model; irrespective of it is in surface or volume.
UnitDefinition unitDefn = getOrCreateSBMLUnit(sbmlExportSpec.getSubstanceUnits());
sbmlSpecies.setSubstanceUnits(unitDefn);
// need to do the following if exporting to SBML spatial
if (bSpatial) {
// Required for setting BoundaryConditions : structureMapping for vcSpeciesContext[i] & sbmlGeometry.coordinateComponents
StructureMapping sm = getSelectedSimContext().getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure());
SpatialModelPlugin mplugin = (SpatialModelPlugin) sbmlModel.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
org.sbml.jsbml.ext.spatial.Geometry sbmlGeometry = mplugin.getGeometry();
CoordinateComponent ccX = sbmlGeometry.getListOfCoordinateComponents().get(vcModel.getX().getName());
CoordinateComponent ccY = sbmlGeometry.getListOfCoordinateComponents().get(vcModel.getY().getName());
CoordinateComponent ccZ = sbmlGeometry.getListOfCoordinateComponents().get(vcModel.getZ().getName());
// add diffusion, advection, boundary condition parameters for species, if they exist
Parameter[] scsParams = vcSpeciesContextsSpec.getParameters();
if (scsParams != null) {
for (int j = 0; j < scsParams.length; j++) {
if (scsParams[j] != null) {
SpeciesContextSpecParameter scsParam = (SpeciesContextSpecParameter) scsParams[j];
// no need to add parameters in SBML for init conc or init count
int role = scsParam.getRole();
switch(role) {
case SpeciesContextSpec.ROLE_BoundaryValueXm:
{
break;
}
case SpeciesContextSpec.ROLE_BoundaryValueXp:
{
break;
}
case SpeciesContextSpec.ROLE_BoundaryValueYm:
{
break;
}
case SpeciesContextSpec.ROLE_BoundaryValueYp:
{
break;
}
case SpeciesContextSpec.ROLE_BoundaryValueZm:
{
break;
}
case SpeciesContextSpec.ROLE_BoundaryValueZp:
{
break;
}
case SpeciesContextSpec.ROLE_DiffusionRate:
{
break;
}
case SpeciesContextSpec.ROLE_InitialConcentration:
{
// done elsewhere??
continue;
// break;
}
case SpeciesContextSpec.ROLE_InitialCount:
{
// done elsewhere??
continue;
// break;
}
case SpeciesContextSpec.ROLE_VelocityX:
{
break;
}
case SpeciesContextSpec.ROLE_VelocityY:
{
break;
}
case SpeciesContextSpec.ROLE_VelocityZ:
{
break;
}
default:
{
throw new RuntimeException("SpeciesContext Specification parameter with role " + SpeciesContextSpec.RoleNames[role] + " not yet supported for SBML export");
}
}
// if diffusion is 0 && vel terms are not specified, boundary condition not present
if (vcSpeciesContextsSpec.isAdvecting() || vcSpeciesContextsSpec.isDiffusing()) {
Expression diffExpr = vcSpeciesContextsSpec.getDiffusionParameter().getExpression();
boolean bDiffExprNull = (diffExpr == null);
boolean bDiffExprIsZero = false;
if (!bDiffExprNull && diffExpr.isNumeric()) {
try {
bDiffExprIsZero = (diffExpr.evaluateConstant() == 0.0);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to evalute numeric value of diffusion parameter for speciesContext '" + vcSpeciesContexts[i] + "'.");
}
}
boolean bDiffusionZero = (bDiffExprNull || bDiffExprIsZero);
Expression velX_Expr = vcSpeciesContextsSpec.getVelocityXParameter().getExpression();
SpatialQuantity[] velX_Quantities = vcSpeciesContextsSpec.getVelocityQuantities(QuantityComponent.X);
boolean bVelX_ExprIsNull = (velX_Expr == null && velX_Quantities.length == 0);
Expression velY_Expr = vcSpeciesContextsSpec.getVelocityYParameter().getExpression();
SpatialQuantity[] velY_Quantities = vcSpeciesContextsSpec.getVelocityQuantities(QuantityComponent.Y);
boolean bVelY_ExprIsNull = (velY_Expr == null && velY_Quantities.length == 0);
Expression velZ_Expr = vcSpeciesContextsSpec.getVelocityZParameter().getExpression();
SpatialQuantity[] velZ_Quantities = vcSpeciesContextsSpec.getVelocityQuantities(QuantityComponent.Z);
boolean bVelZ_ExprIsNull = (velZ_Expr == null && velZ_Quantities.length == 0);
boolean bAdvectionNull = (bVelX_ExprIsNull && bVelY_ExprIsNull && bVelZ_ExprIsNull);
if (bDiffusionZero && bAdvectionNull) {
continue;
}
}
// for example, if scsParam is BC_Zm and if coordinateComponent 'ccZ' is null, no SBML parameter should be created for BC_Zm
if ((((role == SpeciesContextSpec.ROLE_BoundaryValueXm) || (role == SpeciesContextSpec.ROLE_BoundaryValueXp)) && (ccX == null)) || (((role == SpeciesContextSpec.ROLE_BoundaryValueYm) || (role == SpeciesContextSpec.ROLE_BoundaryValueYp)) && (ccY == null)) || (((role == SpeciesContextSpec.ROLE_BoundaryValueZm) || (role == SpeciesContextSpec.ROLE_BoundaryValueZp)) && (ccZ == null))) {
continue;
}
org.sbml.jsbml.Parameter sbmlParam = createSBMLParamFromSpeciesParam(vcSpeciesContexts[i], (SpeciesContextSpecParameter) scsParams[j]);
if (sbmlParam != null) {
BoundaryConditionType vcBCType_Xm = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeXm();
BoundaryConditionType vcBCType_Xp = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeXp();
BoundaryConditionType vcBCType_Ym = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeYm();
BoundaryConditionType vcBCType_Yp = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeYp();
BoundaryConditionType vcBCType_Zm = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeZm();
BoundaryConditionType vcBCType_Zp = vcSelectedSimContext.getGeometryContext().getStructureMapping(vcSpeciesContexts[i].getStructure()).getBoundaryConditionTypeZp();
SpatialParameterPlugin spplugin = (SpatialParameterPlugin) sbmlParam.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
if (role == SpeciesContextSpec.ROLE_DiffusionRate) {
// set diffusionCoefficient element in SpatialParameterPlugin for param
DiffusionCoefficient sbmlDiffCoeff = new DiffusionCoefficient();
sbmlDiffCoeff.setVariable(vcSpeciesContexts[i].getName());
sbmlDiffCoeff.setDiffusionKind(DiffusionKind.isotropic);
sbmlDiffCoeff.setSpeciesRef(vcSpeciesContexts[i].getName());
spplugin.setParamType(sbmlDiffCoeff);
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueXm) && (ccX != null)) {
// set BoundaryCondn Xm element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCXm = new BoundaryCondition();
spplugin.setParamType(sbmlBCXm);
sbmlBCXm.setType(getBoundaryConditionKind(vcBCType_Xm));
sbmlBCXm.setVariable(vcSpeciesContexts[i].getName());
sbmlBCXm.setCoordinateBoundary(ccX.getBoundaryMinimum().getId());
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueXp) && (ccX != null)) {
// set BoundaryCondn Xp element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCXp = new BoundaryCondition();
spplugin.setParamType(sbmlBCXp);
sbmlBCXp.setType(getBoundaryConditionKind(vcBCType_Xp));
sbmlBCXp.setVariable(vcSpeciesContexts[i].getName());
// sbmlBCXp.setType(sm.getBoundaryConditionTypeXp().boundaryTypeStringValue());
sbmlBCXp.setCoordinateBoundary(ccX.getBoundaryMaximum().getId());
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueYm) && (ccY != null)) {
// set BoundaryCondn Ym element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCYm = new BoundaryCondition();
spplugin.setParamType(sbmlBCYm);
sbmlBCYm.setType(getBoundaryConditionKind(vcBCType_Yp));
sbmlBCYm.setVariable(vcSpeciesContexts[i].getName());
// sbmlBCYm.setType(sm.getBoundaryConditionTypeYm().boundaryTypeStringValue());
sbmlBCYm.setCoordinateBoundary(ccY.getBoundaryMinimum().getId());
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueYp) && (ccY != null)) {
// set BoundaryCondn Yp element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCYp = new BoundaryCondition();
spplugin.setParamType(sbmlBCYp);
sbmlBCYp.setType(getBoundaryConditionKind(vcBCType_Yp));
sbmlBCYp.setVariable(vcSpeciesContexts[i].getName());
// sbmlBCYp.setType(sm.getBoundaryConditionTypeYp().boundaryTypeStringValue());
sbmlBCYp.setCoordinateBoundary(ccY.getBoundaryMaximum().getId());
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueZm) && (ccZ != null)) {
// set BoundaryCondn Zm element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCZm = new BoundaryCondition();
spplugin.setParamType(sbmlBCZm);
sbmlBCZm.setType(getBoundaryConditionKind(vcBCType_Zm));
sbmlBCZm.setVariable(vcSpeciesContexts[i].getName());
// sbmlBCZm.setType(sm.getBoundaryConditionTypeZm().boundaryTypeStringValue());
sbmlBCZm.setCoordinateBoundary(ccZ.getBoundaryMinimum().getId());
}
if ((role == SpeciesContextSpec.ROLE_BoundaryValueZp) && (ccZ != null)) {
// set BoundaryCondn Zp element in SpatialParameterPlugin for param
BoundaryCondition sbmlBCZp = new BoundaryCondition();
spplugin.setParamType(sbmlBCZp);
sbmlBCZp.setType(getBoundaryConditionKind(vcBCType_Zp));
sbmlBCZp.setVariable(vcSpeciesContexts[i].getName());
// sbmlBCZp.setType(sm.getBoundaryConditionTypeZp().boundaryTypeStringValue());
sbmlBCZp.setCoordinateBoundary(ccZ.getBoundaryMaximum().getId());
}
if (role == SpeciesContextSpec.ROLE_VelocityX) {
// set advectionCoeff X element in SpatialParameterPlugin for param
AdvectionCoefficient sbmlAdvCoeffX = new AdvectionCoefficient();
spplugin.setParamType(sbmlAdvCoeffX);
sbmlAdvCoeffX.setVariable(vcSpeciesContexts[i].getName());
sbmlAdvCoeffX.setCoordinate(CoordinateKind.cartesianX);
}
if (role == SpeciesContextSpec.ROLE_VelocityY) {
// set advectionCoeff Y element in SpatialParameterPlugin for param
AdvectionCoefficient sbmlAdvCoeffY = new AdvectionCoefficient();
spplugin.setParamType(sbmlAdvCoeffY);
sbmlAdvCoeffY.setVariable(vcSpeciesContexts[i].getName());
sbmlAdvCoeffY.setCoordinate(CoordinateKind.cartesianY);
}
if (role == SpeciesContextSpec.ROLE_VelocityZ) {
// set advectionCoeff Z element in SpatialParameterPlugin for param
AdvectionCoefficient sbmlAdvCoeffZ = new AdvectionCoefficient();
spplugin.setParamType(sbmlAdvCoeffZ);
sbmlAdvCoeffZ.setVariable(vcSpeciesContexts[i].getName());
sbmlAdvCoeffZ.setCoordinate(CoordinateKind.cartesianZ);
}
}
// if sbmlParam != null
}
// if scsParams[j] != null
}
// end for scsParams
}
// end scsParams != null
}
// end if (bSpatial)
// Add the common name of species to annotation, and add an annotation element to the species.
// This is required later while trying to read in fluxes ...
// new Element(XMLTags.VCellRelatedInfoTag, sbml_vcml_ns);
Element sbmlImportRelatedElement = null;
// Element speciesElement = new Element(XMLTags.SpeciesTag, sbml_vcml_ns);
// speciesElement.setAttribute(XMLTags.NameAttrTag, TokenMangler.mangleToSName(vcSpeciesContexts[i].getSpecies().getCommonName()));
// sbmlImportRelatedElement.addContent(speciesElement);
// Get RDF annotation for species from SBMLAnnotationUtils
sbmlAnnotationUtil.writeAnnotation(vcSpeciesContexts[i].getSpecies(), sbmlSpecies, sbmlImportRelatedElement);
// Now set notes,
sbmlAnnotationUtil.writeNotes(vcSpeciesContexts[i].getSpecies(), sbmlSpecies);
}
}
Also used :
Compartment(org.sbml.jsbml.Compartment)
Element(org.jdom.Element)
BoundaryConditionType(cbit.vcell.math.BoundaryConditionType)
SpatialParameterPlugin(org.sbml.jsbml.ext.spatial.SpatialParameterPlugin)
SpeciesContext(cbit.vcell.model.SpeciesContext)
SpeciesContextSpec(cbit.vcell.mapping.SpeciesContextSpec)
StructureMapping(cbit.vcell.mapping.StructureMapping)
MappingException(cbit.vcell.mapping.MappingException)
ASTNode(org.sbml.jsbml.ASTNode)
SpatialQuantity(cbit.vcell.mapping.spatial.SpatialObject.SpatialQuantity)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
UnitDefinition(org.sbml.jsbml.UnitDefinition)
SpeciesContextSpecParameter(cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)
CoordinateComponent(org.sbml.jsbml.ext.spatial.CoordinateComponent)
AdvectionCoefficient(org.sbml.jsbml.ext.spatial.AdvectionCoefficient)
AssignmentRule(org.sbml.jsbml.AssignmentRule)
SpatialModelPlugin(org.sbml.jsbml.ext.spatial.SpatialModelPlugin)
ExpressionException(cbit.vcell.parser.ExpressionException)
DiffusionCoefficient(org.sbml.jsbml.ext.spatial.DiffusionCoefficient)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
XMLStreamException(javax.xml.stream.XMLStreamException)
MatrixException(cbit.vcell.matrix.MatrixException)
SbmlException(org.vcell.sbml.SbmlException)
ParseException(org.sbml.jsbml.text.parser.ParseException)
RuntimeCryptoException(org.bouncycastle.crypto.RuntimeCryptoException)
XmlParseException(cbit.vcell.xml.XmlParseException)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
ImageException(cbit.image.ImageException)
SBMLException(org.sbml.jsbml.SBMLException)
ModelException(cbit.vcell.model.ModelException)
ExpressionException(cbit.vcell.parser.ExpressionException)
MathException(cbit.vcell.math.MathException)
PropertyVetoException(java.beans.PropertyVetoException)
InitialAssignment(org.sbml.jsbml.InitialAssignment)
Expression(cbit.vcell.parser.Expression)
BoundaryCondition(org.sbml.jsbml.ext.spatial.BoundaryCondition)
Model(cbit.vcell.model.Model)
BioModel(cbit.vcell.biomodel.BioModel)
StructureMappingParameter(cbit.vcell.mapping.StructureMapping.StructureMappingParameter)
Parameter(cbit.vcell.model.Parameter)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
SpeciesContextSpecParameter(cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)
LocalParameter(cbit.vcell.mapping.ParameterContext.LocalParameter)
Example 14 with ASTNode
use of org.sbml.jsbml.ASTNode in project vcell by virtualcell.
the class SBMLExporter method addGeometry.
private void addGeometry() throws SbmlException {
SpatialModelPlugin mplugin = (SpatialModelPlugin) sbmlModel.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
// Creates a geometry object via SpatialModelPlugin object.
org.sbml.jsbml.ext.spatial.Geometry sbmlGeometry = mplugin.createGeometry();
sbmlGeometry.setCoordinateSystem(GeometryKind.cartesian);
sbmlGeometry.setSpatialId("vcell");
Geometry vcGeometry = getSelectedSimContext().getGeometry();
Model vcModel = getSelectedSimContext().getModel();
//
// list of CoordinateComponents : 1 if geometry is 1-d, 2 if geometry is 2-d, 3 if geometry is 3-d
//
int dimension = vcGeometry.getDimension();
Extent vcExtent = vcGeometry.getExtent();
Origin vcOrigin = vcGeometry.getOrigin();
// add x coordinate component
CoordinateComponent xComp = sbmlGeometry.createCoordinateComponent();
xComp.setSpatialId(vcModel.getX().getName());
xComp.setType(CoordinateKind.cartesianX);
final UnitDefinition sbmlUnitDef_length = getOrCreateSBMLUnit(vcModel.getUnitSystem().getLengthUnit());
xComp.setUnits(sbmlUnitDef_length);
Boundary minX = new Boundary();
xComp.setBoundaryMinimum(minX);
minX.setSpatialId("Xmin");
minX.setValue(vcOrigin.getX());
Boundary maxX = new Boundary();
xComp.setBoundaryMaximum(maxX);
maxX.setSpatialId("Xmax");
maxX.setValue(vcOrigin.getX() + (vcExtent.getX()));
org.sbml.jsbml.Parameter pX = sbmlModel.createParameter();
pX.setId(vcModel.getX().getName());
pX.setValue(0.0);
pX.setConstant(false);
pX.setUnits(sbmlUnitDef_length);
SpatialParameterPlugin spPluginPx = (SpatialParameterPlugin) pX.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
SpatialSymbolReference spSymRefPx = new SpatialSymbolReference();
spPluginPx.setParamType(spSymRefPx);
spSymRefPx.setSpatialRef(xComp.getSpatialId());
// add y coordinate component
if (dimension == 2 || dimension == 3) {
CoordinateComponent yComp = sbmlGeometry.createCoordinateComponent();
yComp.setSpatialId(vcModel.getY().getName());
yComp.setType(CoordinateKind.cartesianY);
yComp.setUnits(sbmlUnitDef_length);
Boundary minY = new Boundary();
yComp.setBoundaryMinimum(minY);
minY.setSpatialId("Ymin");
minY.setValue(vcOrigin.getY());
Boundary maxY = new Boundary();
yComp.setBoundaryMaximum(maxY);
maxY.setSpatialId("Ymax");
maxY.setValue(vcOrigin.getY() + (vcExtent.getY()));
org.sbml.jsbml.Parameter pY = sbmlModel.createParameter();
pY.setId(vcModel.getY().getName());
pY.setValue(0.0);
pY.setConstant(false);
pY.setUnits(sbmlUnitDef_length);
SpatialParameterPlugin spPluginPy = (SpatialParameterPlugin) pY.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
SpatialSymbolReference spSymRefPy = new SpatialSymbolReference();
spPluginPy.setParamType(spSymRefPy);
spSymRefPy.setSpatialRef(yComp.getSpatialId());
}
// add z coordinate component
if (dimension == 3) {
CoordinateComponent zComp = sbmlGeometry.createCoordinateComponent();
zComp.setSpatialId(vcModel.getZ().getName());
zComp.setType(CoordinateKind.cartesianZ);
zComp.setUnits(sbmlUnitDef_length);
Boundary minZ = new Boundary();
zComp.setBoundaryMinimum(minZ);
minZ.setSpatialId("Zmin");
minZ.setValue(vcOrigin.getZ());
Boundary maxZ = new Boundary();
zComp.setBoundaryMaximum(maxZ);
maxZ.setSpatialId("Zmax");
maxZ.setValue(vcOrigin.getZ() + (vcExtent.getZ()));
org.sbml.jsbml.Parameter pZ = sbmlModel.createParameter();
pZ.setId(vcModel.getZ().getName());
pZ.setValue(0.0);
pZ.setConstant(false);
pZ.setUnits(sbmlUnitDef_length);
SpatialParameterPlugin spPluginPz = (SpatialParameterPlugin) pZ.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
SpatialSymbolReference spSymRefPz = new SpatialSymbolReference();
spPluginPz.setParamType(spSymRefPz);
spSymRefPz.setSpatialRef(zComp.getSpatialId());
}
//
// list of compartmentMappings : VC structureMappings
//
GeometryContext vcGeoContext = getSelectedSimContext().getGeometryContext();
StructureMapping[] vcStrucMappings = vcGeoContext.getStructureMappings();
for (int i = 0; i < vcStrucMappings.length; i++) {
StructureMapping vcStructMapping = vcStrucMappings[i];
String structName = vcStructMapping.getStructure().getName();
Compartment comp = sbmlModel.getCompartment(TokenMangler.mangleToSName(structName));
SpatialCompartmentPlugin cplugin = (SpatialCompartmentPlugin) comp.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
GeometryClass gc = vcStructMapping.getGeometryClass();
if (!goodPointer(gc, GeometryClass.class, structName)) {
continue;
}
CompartmentMapping compMapping = new CompartmentMapping();
cplugin.setCompartmentMapping(compMapping);
String geomClassName = gc.getName();
String id = TokenMangler.mangleToSName(geomClassName + structName);
compMapping.setSpatialId(id);
compMapping.setDomainType(TokenMangler.mangleToSName(DOMAIN_TYPE_PREFIX + geomClassName));
try {
StructureMappingParameter usp = vcStructMapping.getUnitSizeParameter();
Expression e = usp.getExpression();
if (goodPointer(e, Expression.class, id)) {
compMapping.setUnitSize(e.evaluateConstant());
}
} catch (ExpressionException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to create compartment mapping for structureMapping '" + compMapping.getId() + "' : " + e.getMessage());
}
}
//
// list of domain types : subvolumes and surface classes from VC
//
boolean bAnyAnalyticSubvolumes = false;
boolean bAnyImageSubvolumes = false;
boolean bAnyCSGSubvolumes = false;
GeometryClass[] vcGeomClasses = vcGeometry.getGeometryClasses();
int numSubVols = 0;
for (int i = 0; i < vcGeomClasses.length; i++) {
DomainType domainType = sbmlGeometry.createDomainType();
domainType.setSpatialId(DOMAIN_TYPE_PREFIX + vcGeomClasses[i].getName());
if (vcGeomClasses[i] instanceof SubVolume) {
if (((SubVolume) vcGeomClasses[i]) instanceof AnalyticSubVolume) {
bAnyAnalyticSubvolumes = true;
} else if (((SubVolume) vcGeomClasses[i]) instanceof ImageSubVolume) {
bAnyImageSubvolumes = true;
} else if (((SubVolume) vcGeomClasses[i]) instanceof CSGObject) {
bAnyCSGSubvolumes = true;
}
domainType.setSpatialDimensions(3);
numSubVols++;
} else if (vcGeomClasses[i] instanceof SurfaceClass) {
domainType.setSpatialDimensions(2);
}
}
//
// list of domains, adjacent domains : from VC geometricRegions
//
GeometrySurfaceDescription vcGSD = vcGeometry.getGeometrySurfaceDescription();
if (vcGSD.getRegionImage() == null) {
try {
vcGSD.updateAll();
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to generate region images for geometry");
}
}
GeometricRegion[] vcGeometricRegions = vcGSD.getGeometricRegions();
ISize sampleSize = vcGSD.getVolumeSampleSize();
int numX = sampleSize.getX();
int numY = sampleSize.getY();
int numZ = sampleSize.getZ();
double ox = vcOrigin.getX();
double oy = vcOrigin.getY();
double oz = vcOrigin.getZ();
RegionInfo[] regionInfos = vcGSD.getRegionImage().getRegionInfos();
for (int i = 0; i < vcGeometricRegions.length; i++) {
// domains
Domain domain = sbmlGeometry.createDomain();
domain.setSpatialId(vcGeometricRegions[i].getName());
if (vcGeometricRegions[i] instanceof VolumeGeometricRegion) {
domain.setDomainType(DOMAIN_TYPE_PREFIX + ((VolumeGeometricRegion) vcGeometricRegions[i]).getSubVolume().getName());
//
// get a list of interior points ... should probably use the distance map to find a point
// furthest inside (or several points associated with the morphological skeleton).
//
InteriorPoint interiorPt = domain.createInteriorPoint();
int regionID = ((VolumeGeometricRegion) vcGeometricRegions[i]).getRegionID();
boolean bFound = false;
int regInfoIndx = 0;
for (int j = 0; j < regionInfos.length; j++) {
regInfoIndx = j;
if (regionInfos[j].getRegionIndex() == regionID) {
int volIndx = 0;
for (int z = 0; z < numZ && !bFound; z++) {
for (int y = 0; y < numY && !bFound; y++) {
for (int x = 0; x < numX && !bFound; x++) {
if (regionInfos[j].isIndexInRegion(volIndx)) {
bFound = true;
double unit_z = (numZ > 1) ? ((double) z) / (numZ - 1) : 0.5;
double coordZ = oz + vcExtent.getZ() * unit_z;
double unit_y = (numY > 1) ? ((double) y) / (numY - 1) : 0.5;
double coordY = oy + vcExtent.getY() * unit_y;
double unit_x = (numX > 1) ? ((double) x) / (numX - 1) : 0.5;
double coordX = ox + vcExtent.getX() * unit_x;
interiorPt.setCoord1(coordX);
interiorPt.setCoord2(coordY);
interiorPt.setCoord3(coordZ);
}
volIndx++;
}
// end - for x
}
// end - for y
}
// end - for z
}
// end if
}
// end for regionInfos
if (!bFound) {
throw new RuntimeException("Unable to find interior point for region '" + regionInfos[regInfoIndx].toString());
}
} else if (vcGeometricRegions[i] instanceof SurfaceGeometricRegion) {
SurfaceGeometricRegion vcSurfaceGeomReg = (SurfaceGeometricRegion) vcGeometricRegions[i];
GeometricRegion geomRegion0 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[0];
GeometricRegion geomRegion1 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[1];
SurfaceClass surfaceClass = vcGSD.getSurfaceClass(((VolumeGeometricRegion) geomRegion0).getSubVolume(), ((VolumeGeometricRegion) geomRegion1).getSubVolume());
domain.setDomainType(DOMAIN_TYPE_PREFIX + surfaceClass.getName());
// adjacent domains : 2 adjacent domain objects for each surfaceClass in VC.
// adjacent domain 1
GeometricRegion adjGeomRegion0 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[0];
GeometricRegion adjGeomRegion1 = vcSurfaceGeomReg.getAdjacentGeometricRegions()[1];
AdjacentDomains adjDomain = new AdjacentDomains();
adjDomain.setSpatialId(TokenMangler.mangleToSName(vcSurfaceGeomReg.getName() + "_" + adjGeomRegion0.getName()));
adjDomain.setDomain1(vcSurfaceGeomReg.getName());
adjDomain.setDomain2(adjGeomRegion0.getName());
sbmlGeometry.addAdjacentDomain(adjDomain);
// adj domain 2
adjDomain = new AdjacentDomains();
adjDomain.setSpatialId(TokenMangler.mangleToSName(vcSurfaceGeomReg.getName() + "_" + adjGeomRegion1.getName()));
adjDomain.setDomain1(vcSurfaceGeomReg.getName());
adjDomain.setDomain2(adjGeomRegion1.getName());
sbmlGeometry.addAdjacentDomain(adjDomain);
}
}
//
if (bAnyAnalyticSubvolumes && !bAnyImageSubvolumes && !bAnyCSGSubvolumes) {
AnalyticGeometry sbmlAnalyticGeomDefinition = sbmlGeometry.createAnalyticGeometry();
sbmlAnalyticGeomDefinition.setSpatialId(TokenMangler.mangleToSName("Analytic_" + vcGeometry.getName()));
sbmlAnalyticGeomDefinition.setIsActive(true);
for (int i = 0; i < vcGeomClasses.length; i++) {
if (vcGeomClasses[i] instanceof AnalyticSubVolume) {
AnalyticVolume analyticVol = sbmlAnalyticGeomDefinition.createAnalyticVolume();
analyticVol.setSpatialId(vcGeomClasses[i].getName());
analyticVol.setDomainType(DOMAIN_TYPE_PREFIX + vcGeomClasses[i].getName());
analyticVol.setFunctionType(FunctionKind.layered);
analyticVol.setOrdinal(numSubVols - (i + 1));
Expression expr = ((AnalyticSubVolume) vcGeomClasses[i]).getExpression();
try {
String mathMLStr = ExpressionMathMLPrinter.getMathML(expr, true, MathType.BOOLEAN);
ASTNode mathMLNode = ASTNode.readMathMLFromString(mathMLStr);
analyticVol.setMath(mathMLNode);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error converting VC subvolume expression to mathML" + e.getMessage());
}
}
}
}
//
if (!bAnyAnalyticSubvolumes && !bAnyImageSubvolumes && bAnyCSGSubvolumes) {
CSGeometry sbmlCSGeomDefinition = new CSGeometry();
sbmlGeometry.addGeometryDefinition(sbmlCSGeomDefinition);
sbmlCSGeomDefinition.setSpatialId(TokenMangler.mangleToSName("CSG_" + vcGeometry.getName()));
for (int i = 0; i < vcGeomClasses.length; i++) {
if (vcGeomClasses[i] instanceof CSGObject) {
CSGObject vcellCSGObject = (CSGObject) vcGeomClasses[i];
org.sbml.jsbml.ext.spatial.CSGObject sbmlCSGObject = new org.sbml.jsbml.ext.spatial.CSGObject();
sbmlCSGeomDefinition.addCSGObject(sbmlCSGObject);
sbmlCSGObject.setSpatialId(vcellCSGObject.getName());
sbmlCSGObject.setDomainType(DOMAIN_TYPE_PREFIX + vcellCSGObject.getName());
// the ordinal should the the least for the default/background subVolume
sbmlCSGObject.setOrdinal(numSubVols - (i + 1));
org.sbml.jsbml.ext.spatial.CSGNode sbmlcsgNode = getSBMLCSGNode(vcellCSGObject.getRoot());
sbmlCSGObject.setCSGNode(sbmlcsgNode);
}
}
}
//
// add "Segmented" and "DistanceMap" SampledField Geometries
//
final boolean bVCGeometryIsImage = bAnyImageSubvolumes && !bAnyAnalyticSubvolumes && !bAnyCSGSubvolumes;
// 55if (bAnyAnalyticSubvolumes || bAnyImageSubvolumes || bAnyCSGSubvolumes){
if (bVCGeometryIsImage) {
//
// add "Segmented" SampledFieldGeometry
//
SampledFieldGeometry segmentedImageSampledFieldGeometry = sbmlGeometry.createSampledFieldGeometry();
segmentedImageSampledFieldGeometry.setSpatialId(TokenMangler.mangleToSName("SegmentedImage_" + vcGeometry.getName()));
segmentedImageSampledFieldGeometry.setIsActive(true);
// 55boolean bVCGeometryIsImage = bAnyImageSubvolumes && !bAnyAnalyticSubvolumes && !bAnyCSGSubvolumes;
Geometry vcImageGeometry = null;
{
if (bVCGeometryIsImage) {
// make a resampled image;
if (dimension == 3) {
try {
ISize imageSize = vcGeometry.getGeometrySpec().getDefaultSampledImageSize();
vcGeometry.precomputeAll(new GeometryThumbnailImageFactoryAWT());
vcImageGeometry = RayCaster.resampleGeometry(new GeometryThumbnailImageFactoryAWT(), vcGeometry, imageSize);
} catch (Throwable e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to convert the original analytic or constructed solid geometry to image-based geometry : " + e.getMessage());
}
} else {
try {
vcGeometry.precomputeAll(new GeometryThumbnailImageFactoryAWT(), true, false);
GeometrySpec origGeometrySpec = vcGeometry.getGeometrySpec();
VCImage newVCImage = origGeometrySpec.getSampledImage().getCurrentValue();
//
// construct the new geometry with the sampled VCImage.
//
vcImageGeometry = new Geometry(vcGeometry.getName() + "_asImage", newVCImage);
vcImageGeometry.getGeometrySpec().setExtent(vcGeometry.getExtent());
vcImageGeometry.getGeometrySpec().setOrigin(vcGeometry.getOrigin());
vcImageGeometry.setDescription(vcGeometry.getDescription());
vcImageGeometry.getGeometrySurfaceDescription().setFilterCutoffFrequency(vcGeometry.getGeometrySurfaceDescription().getFilterCutoffFrequency());
vcImageGeometry.precomputeAll(new GeometryThumbnailImageFactoryAWT(), true, true);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to convert the original analytic or constructed solid geometry to image-based geometry : " + e.getMessage());
}
}
GeometryClass[] vcImageGeomClasses = vcImageGeometry.getGeometryClasses();
for (int j = 0; j < vcImageGeomClasses.length; j++) {
if (vcImageGeomClasses[j] instanceof ImageSubVolume) {
SampledVolume sampledVol = segmentedImageSampledFieldGeometry.createSampledVolume();
sampledVol.setSpatialId(vcGeomClasses[j].getName());
sampledVol.setDomainType(DOMAIN_TYPE_PREFIX + vcGeomClasses[j].getName());
sampledVol.setSampledValue(((ImageSubVolume) vcImageGeomClasses[j]).getPixelValue());
}
}
// add sampledField to sampledFieldGeometry
SampledField segmentedImageSampledField = sbmlGeometry.createSampledField();
VCImage vcImage = vcImageGeometry.getGeometrySpec().getImage();
segmentedImageSampledField.setSpatialId("SegmentedImageSampledField");
segmentedImageSampledField.setNumSamples1(vcImage.getNumX());
segmentedImageSampledField.setNumSamples2(vcImage.getNumY());
segmentedImageSampledField.setNumSamples3(vcImage.getNumZ());
segmentedImageSampledField.setInterpolationType(InterpolationKind.nearestNeighbor);
segmentedImageSampledField.setCompression(CompressionKind.uncompressed);
segmentedImageSampledField.setDataType(DataKind.UINT8);
segmentedImageSampledFieldGeometry.setSampledField(segmentedImageSampledField.getId());
try {
byte[] vcImagePixelsBytes = vcImage.getPixels();
// imageData.setCompression("");
StringBuffer sb = new StringBuffer();
for (int i = 0; i < vcImagePixelsBytes.length; i++) {
int uint8_sample = ((int) vcImagePixelsBytes[i]) & 0xff;
sb.append(uint8_sample + " ");
}
segmentedImageSampledField.setSamplesLength(vcImage.getNumXYZ());
segmentedImageSampledField.setSamples(sb.toString().trim());
} catch (ImageException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to export image from VCell to SBML : " + e.getMessage());
}
}
}
/*
//
// add "DistanceMap" SampledFieldGeometry if there are exactly two subvolumes (else need more fields) and geometry is 3d.
//
if (numSubVols==2 && dimension == 3){
SignedDistanceMap[] distanceMaps = null;
try {
distanceMaps = DistanceMapGenerator.computeDistanceMaps(vcImageGeometry, vcImageGeometry.getGeometrySpec().getImage(), false, false);
} catch (ImageException e) {
e.printStackTrace(System.out);
System.err.println("Unable to export distance map sampled field from VCell to SBML : " + e.getMessage());
// throw new RuntimeException("Unable to export distance map sampled field from VCell to SBML : " + e.getMessage());
// don't want to throw an exception and stop export because distance map geometry couldn't be exported.
// just 'return' from method (since this is the last thing that is being done in this method).
return;
}
//
// the two distanceMaps should be redundant (one is negation of the other) ... so choose first one for field.
//
double[] signedDistances = distanceMaps[0].getSignedDistances();
SampledFieldGeometry distanceMapSampledFieldGeometry = sbmlGeometry.createSampledFieldGeometry();
distanceMapSampledFieldGeometry.setSpatialId(TokenMangler.mangleToSName("DistanceMap_"+vcGeometry.getName()));
SampledField distanceMapSampledField = distanceMapSampledFieldGeometry.createSampledField();
distanceMapSampledField.setSpatialId("DistanceMapSampledField");
distanceMapSampledField.setNumSamples1(distanceMaps[0].getSamplesX().length);
distanceMapSampledField.setNumSamples2(distanceMaps[0].getSamplesY().length);
distanceMapSampledField.setNumSamples3(distanceMaps[0].getSamplesZ().length);
distanceMapSampledField.setDataType("real");
System.err.println("do we need distanceMapSampleField.setDataType()?");
distanceMapSampledField.setInterpolationType("linear");
ImageData distanceMapImageData = distanceMapSampledField.createImageData();
distanceMapImageData.setDataType("int16");
System.err.println("should be:\n distanceMapImageData.setDataType(\"float32\")");
// distanceMapImageData.setCompression("");
double maxAbsValue = 0;
for (int i = 0; i < signedDistances.length; i++) {
maxAbsValue = Math.max(maxAbsValue,Math.abs(signedDistances[i]));
}
if (maxAbsValue==0.0){
throw new RuntimeException("computed distance map all zeros");
}
double scale = (Short.MAX_VALUE-1)/maxAbsValue;
int[] scaledIntegerDistanceMap = new int[signedDistances.length];
for (int i = 0; i < signedDistances.length; i++) {
scaledIntegerDistanceMap[i] = (int)(scale * signedDistances[i]);
}
distanceMapImageData.setSamples(scaledIntegerDistanceMap, signedDistances.length);
System.err.println("should be:\n distanceMapImageData.setSamples((float[])signedDistances,signedDistances.length)");
SampledVolume sampledVol = distanceMapSampledFieldGeometry.createSampledVolume();
sampledVol.setSpatialId(distanceMaps[0].getInsideSubvolumeName());
sampledVol.setDomainType(DOMAIN_TYPE_PREFIX+distanceMaps[0].getInsideSubvolumeName());
sampledVol.setSampledValue(255);
sampledVol = distanceMapSampledFieldGeometry.createSampledVolume();
sampledVol.setSpatialId(distanceMaps[1].getInsideSubvolumeName());
sampledVol.setDomainType(DOMAIN_TYPE_PREFIX+distanceMaps[1].getInsideSubvolumeName());
sampledVol.setSampledValue(1);
}
*/
}
//
// add "SurfaceMesh" ParametricGeometry
//
// if (bAnyAnalyticSubvolumes || bAnyImageSubvolumes || bAnyCSGSubvolumes){
// ParametricGeometry sbmlParametricGeomDefinition = sbmlGeometry.createParametricGeometry();
// sbmlParametricGeomDefinition.setSpatialId(TokenMangler.mangleToSName("SurfaceMesh_"+vcGeometry.getName()));
// xxxx
// }
}
Also used :
Origin(org.vcell.util.Origin)
CompartmentMapping(org.sbml.jsbml.ext.spatial.CompartmentMapping)
Compartment(org.sbml.jsbml.Compartment)
SpatialParameterPlugin(org.sbml.jsbml.ext.spatial.SpatialParameterPlugin)
StructureMappingParameter(cbit.vcell.mapping.StructureMapping.StructureMappingParameter)
AnalyticGeometry(org.sbml.jsbml.ext.spatial.AnalyticGeometry)
ExpressionException(cbit.vcell.parser.ExpressionException)
Boundary(org.sbml.jsbml.ext.spatial.Boundary)
GeometrySpec(cbit.vcell.geometry.GeometrySpec)
DomainType(org.sbml.jsbml.ext.spatial.DomainType)
SampledVolume(org.sbml.jsbml.ext.spatial.SampledVolume)
SubVolume(cbit.vcell.geometry.SubVolume)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
GeometryContext(cbit.vcell.mapping.GeometryContext)
SpatialCompartmentPlugin(org.sbml.jsbml.ext.spatial.SpatialCompartmentPlugin)
CoordinateComponent(org.sbml.jsbml.ext.spatial.CoordinateComponent)
SimulationContext(cbit.vcell.mapping.SimulationContext)
SpeciesContext(cbit.vcell.model.SpeciesContext)
GeometryContext(cbit.vcell.mapping.GeometryContext)
ReactionContext(cbit.vcell.mapping.ReactionContext)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
GeometricRegion(cbit.vcell.geometry.surface.GeometricRegion)
SpatialSymbolReference(org.sbml.jsbml.ext.spatial.SpatialSymbolReference)
AnalyticVolume(org.sbml.jsbml.ext.spatial.AnalyticVolume)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
SampledField(org.sbml.jsbml.ext.spatial.SampledField)
Domain(org.sbml.jsbml.ext.spatial.Domain)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
GeometryClass(cbit.vcell.geometry.GeometryClass)
ImageException(cbit.image.ImageException)
GeometrySurfaceDescription(cbit.vcell.geometry.surface.GeometrySurfaceDescription)
Extent(org.vcell.util.Extent)
SurfaceClass(cbit.vcell.geometry.SurfaceClass)
ISize(org.vcell.util.ISize)
CSGeometry(org.sbml.jsbml.ext.spatial.CSGeometry)
RegionInfo(cbit.vcell.geometry.RegionImage.RegionInfo)
VCImage(cbit.image.VCImage)
StructureMapping(cbit.vcell.mapping.StructureMapping)
GeometryThumbnailImageFactoryAWT(cbit.vcell.geometry.GeometryThumbnailImageFactoryAWT)
ASTNode(org.sbml.jsbml.ASTNode)
CSGObject(cbit.vcell.geometry.CSGObject)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
UnitDefinition(org.sbml.jsbml.UnitDefinition)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
SpatialModelPlugin(org.sbml.jsbml.ext.spatial.SpatialModelPlugin)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
XMLStreamException(javax.xml.stream.XMLStreamException)
MatrixException(cbit.vcell.matrix.MatrixException)
SbmlException(org.vcell.sbml.SbmlException)
ParseException(org.sbml.jsbml.text.parser.ParseException)
RuntimeCryptoException(org.bouncycastle.crypto.RuntimeCryptoException)
XmlParseException(cbit.vcell.xml.XmlParseException)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
ImageException(cbit.image.ImageException)
SBMLException(org.sbml.jsbml.SBMLException)
ModelException(cbit.vcell.model.ModelException)
ExpressionException(cbit.vcell.parser.ExpressionException)
MathException(cbit.vcell.math.MathException)
AdjacentDomains(org.sbml.jsbml.ext.spatial.AdjacentDomains)
Geometry(cbit.vcell.geometry.Geometry)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
AnalyticGeometry(org.sbml.jsbml.ext.spatial.AnalyticGeometry)
CSGeometry(org.sbml.jsbml.ext.spatial.CSGeometry)
Expression(cbit.vcell.parser.Expression)
Model(cbit.vcell.model.Model)
BioModel(cbit.vcell.biomodel.BioModel)
Example 15 with ASTNode
use of org.sbml.jsbml.ASTNode in project vcell by virtualcell.
the class SBMLExporter method addParameters.
/**
* addKineticParameterUnits:
* @throws SbmlException
*/
// private void addKineticAndGlobalParameterUnits() throws SbmlException {
//
// //
// // Get all kinetic parameters from simple reactions and flux reactions from the Biomodel
// // And all Model (global) parameters from Model.
// // For each parameter,
// // get its unit (VCunitDefinition)
// // check if it is part of unitsList - if so, continue
// // check if it is a base unit - if so, continue
// // else, get the converted unit (VC -> SBML)
// // add unit to sbmlModel unit definition
// //
//
// Vector<Parameter> paramsVector = new Vector<Parameter>();
// // Add globals
// Model vcModel = vcBioModel.getModel();
// ModelParameter[] globalParams = vcModel.getModelParameters();
// for (int i = 0; i < globalParams.length; i++) {
// paramsVector.addElement(globalParams[i]);
// }
// // Add reaction kinetic parameters
// ReactionStep[] vcReactions = vcModel.getReactionSteps();
// for (int i = 0; i < vcReactions.length; i++) {
// Kinetics rxnKinetics = vcReactions[i].getKinetics();
// Parameter[] kineticParams = rxnKinetics.getKineticsParameters();
// for (int j = 0; j < kineticParams.length; j++) {
// paramsVector.addElement(kineticParams[j]);
// }
// }
//
// for (int i = 0; i < paramsVector.size(); i++){
// Parameter param = (Parameter)paramsVector.elementAt(i);
// VCUnitDefinition paramUnitDefn = param.getUnitDefinition();
// if (paramUnitDefn == null || paramUnitDefn.isTBD()) {
// continue;
// }
// String unitSymbol = org.vcell.util.TokenMangler.mangleToSName(paramUnitDefn.getSymbol());
// if (unitSymbol == null) {
// continue;
// }
// getOrCreateSBMLUnit(paramUnitDefn);
// }
// }
/**
* At present, the Virtual cell doesn't support global parameters
* @throws SbmlException
*/
protected void addParameters() throws ExpressionException, SbmlException {
Model vcModel = getSelectedSimContext().getModel();
// add VCell global parameters to the SBML listofParameters
ModelParameter[] vcGlobalParams = vcModel.getModelParameters();
if (vcGlobalParams != null) {
for (ModelParameter vcParam : vcGlobalParams) {
org.sbml.jsbml.Parameter sbmlParam = sbmlModel.createParameter();
sbmlParam.setId(vcParam.getName());
String sbmlName = vcParam.getSbmlName();
if (sbmlName != null && !sbmlName.isEmpty()) {
sbmlParam.setName(sbmlName);
}
sbmlParam.setConstant(vcParam.isConstant());
Expression paramExpr = new Expression(vcParam.getExpression());
boolean bParamIsNumeric = true;
if (paramExpr.isNumeric()) {
// For a VCell global param, if it is numeric, it has a constant value and is not defined by a rule, hence set Constant = true.
sbmlParam.setValue(paramExpr.evaluateConstant());
// the expression for modelParam might be numeric, but modelParam could have a rate rule, if so, set constant attribute to 'false'
if (getSelectedSimContext().getRateRule(vcParam) != null) {
bParamIsNumeric = false;
}
} else {
// non-numeric VCell global parameter will be defined by a (assignment) rule, hence mark Constant = false.
bParamIsNumeric = false;
// add assignment rule for param
ASTNode paramFormulaNode = getFormulaFromExpression(paramExpr);
AssignmentRule sbmlParamAssignmentRule = sbmlModel.createAssignmentRule();
sbmlParamAssignmentRule.setVariable(vcParam.getName());
sbmlParamAssignmentRule.setMath(paramFormulaNode);
}
sbmlParam.setConstant(bParamIsNumeric);
VCUnitDefinition vcParamUnit = vcParam.getUnitDefinition();
if (!vcParamUnit.isTBD()) {
sbmlParam.setUnits(getOrCreateSBMLUnit(vcParamUnit));
}
}
}
ReservedSymbol[] vcReservedSymbols = vcModel.getReservedSymbols();
if (vcReservedSymbols != null) {
for (ReservedSymbol vcParam : vcReservedSymbols) {
if (vcParam.isTime() || vcParam.isX() || vcParam.isY() || vcParam.isZ()) {
continue;
}
if (vcParam.getRole().equals(ReservedSymbolRole.KMILLIVOLTS)) {
// System.out.println("KMILLIVOLTS");
// continue;
}
if (vcParam.getRole().equals(ReservedSymbolRole.K_GHK)) {
// System.out.println("K_GHK");
}
org.sbml.jsbml.Parameter sbmlParam = sbmlModel.createParameter();
sbmlParam.setId(vcParam.getName());
sbmlParam.setConstant(vcParam.isConstant());
Expression reservedSymbolExpression = vcParam.getExpression();
if (reservedSymbolExpression == null) {
if (vcParam.isTemperature()) {
SimulationContext sc = getSelectedSimContext();
double T = sc.getTemperatureKelvin();
sbmlParam.setValue(T);
sbmlParam.setConstant(true);
}
} else {
Expression paramExpr = new Expression(reservedSymbolExpression);
boolean bParamIsNumeric = true;
if (paramExpr.isNumeric()) {
sbmlParam.setValue(paramExpr.evaluateConstant());
if (getSelectedSimContext().getRateRule(vcParam) != null) {
bParamIsNumeric = false;
}
} else {
bParamIsNumeric = false;
ASTNode paramFormulaNode = getFormulaFromExpression(paramExpr);
AssignmentRule sbmlParamAssignmentRule = sbmlModel.createAssignmentRule();
sbmlParamAssignmentRule.setVariable(vcParam.getName());
sbmlParamAssignmentRule.setMath(paramFormulaNode);
}
sbmlParam.setConstant(bParamIsNumeric);
}
VCUnitDefinition vcParamUnit = vcParam.getUnitDefinition();
if (!vcParamUnit.isTBD()) {
sbmlParam.setUnits(getOrCreateSBMLUnit(vcParamUnit));
}
}
}
}
Also used :
AssignmentRule(org.sbml.jsbml.AssignmentRule)
ReservedSymbol(cbit.vcell.model.Model.ReservedSymbol)
SimulationContext(cbit.vcell.mapping.SimulationContext)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
Expression(cbit.vcell.parser.Expression)
Model(cbit.vcell.model.Model)
BioModel(cbit.vcell.biomodel.BioModel)
ASTNode(org.sbml.jsbml.ASTNode)
Aggregations
ASTNode (org.sbml.jsbml.ASTNode)21
Expression (cbit.vcell.parser.Expression)17
InteriorPoint (org.sbml.jsbml.ext.spatial.InteriorPoint)13
ExpressionException (cbit.vcell.parser.ExpressionException)11
VCUnitDefinition (cbit.vcell.units.VCUnitDefinition)8
BioModel (cbit.vcell.biomodel.BioModel)7
Model (cbit.vcell.model.Model)7
XMLStreamException (javax.xml.stream.XMLStreamException)7
AssignmentRule (org.sbml.jsbml.AssignmentRule)7
SBMLException (org.sbml.jsbml.SBMLException)7
ModelParameter (cbit.vcell.model.Model.ModelParameter)6
PropertyVetoException (java.beans.PropertyVetoException)6
StructureMapping (cbit.vcell.mapping.StructureMapping)5
SpeciesContext (cbit.vcell.model.SpeciesContext)5
XmlParseException (cbit.vcell.xml.XmlParseException)5
IOException (java.io.IOException)5
Compartment (org.sbml.jsbml.Compartment)5
Kinetics (cbit.vcell.model.Kinetics)4
KineticsParameter (cbit.vcell.model.Kinetics.KineticsParameter)4
ModelPropertyVetoException (cbit.vcell.model.ModelPropertyVetoException)4
