Example 21 with StructureMapping
use of cbit.vcell.mapping.StructureMapping in project vcell by virtualcell.
the class SBMLImporter method addGeometry.
protected void addGeometry() {
// get a Geometry object via SpatialModelPlugin object.
org.sbml.jsbml.ext.spatial.Geometry sbmlGeometry = getSbmlGeometry();
if (sbmlGeometry == null) {
return;
}
int dimension = 0;
Origin vcOrigin = null;
Extent vcExtent = null;
{
// local code block
// get a CoordComponent object via the Geometry object.
ListOf<CoordinateComponent> listOfCoordComps = sbmlGeometry.getListOfCoordinateComponents();
if (listOfCoordComps == null) {
throw new RuntimeException("Cannot have 0 coordinate compartments in geometry");
}
// coord component
double ox = 0.0;
double oy = 0.0;
double oz = 0.0;
double ex = 1.0;
double ey = 1.0;
double ez = 1.0;
for (CoordinateComponent coordComponent : listOfCoordComps) {
double minValue = coordComponent.getBoundaryMinimum().getValue();
double maxValue = coordComponent.getBoundaryMaximum().getValue();
switch(coordComponent.getType()) {
case cartesianX:
{
ox = minValue;
ex = maxValue - minValue;
break;
}
case cartesianY:
{
oy = minValue;
ey = maxValue - minValue;
break;
}
case cartesianZ:
{
oz = minValue;
ez = maxValue - minValue;
break;
}
}
dimension++;
}
vcOrigin = new Origin(ox, oy, oz);
vcExtent = new Extent(ex, ey, ez);
}
// from geometry definition, find out which type of geometry : image or
// analytic or CSG
AnalyticGeometry analyticGeometryDefinition = null;
CSGeometry csGeometry = null;
SampledFieldGeometry segmentedSampledFieldGeometry = null;
SampledFieldGeometry distanceMapSampledFieldGeometry = null;
ParametricGeometry parametricGeometry = null;
for (int i = 0; i < sbmlGeometry.getListOfGeometryDefinitions().size(); i++) {
GeometryDefinition gd_temp = sbmlGeometry.getListOfGeometryDefinitions().get(i);
if (!gd_temp.isSetIsActive()) {
continue;
}
if (gd_temp instanceof AnalyticGeometry) {
analyticGeometryDefinition = (AnalyticGeometry) gd_temp;
} else if (gd_temp instanceof SampledFieldGeometry) {
SampledFieldGeometry sfg = (SampledFieldGeometry) gd_temp;
String sfn = sfg.getSampledField();
ListOf<SampledField> sampledFields = sbmlGeometry.getListOfSampledFields();
if (sampledFields.size() > 1) {
throw new RuntimeException("only one sampled field supported");
}
InterpolationKind ik = sampledFields.get(0).getInterpolationType();
switch(ik) {
case linear:
distanceMapSampledFieldGeometry = sfg;
break;
case nearestNeighbor:
segmentedSampledFieldGeometry = sfg;
break;
default:
lg.warn("Unsupported " + sampledFields.get(0).getName() + " interpolation type " + ik);
}
} else if (gd_temp instanceof CSGeometry) {
csGeometry = (CSGeometry) gd_temp;
} else if (gd_temp instanceof ParametricGeometry) {
parametricGeometry = (ParametricGeometry) gd_temp;
} else {
throw new RuntimeException("unsupported geometry definition type " + gd_temp.getClass().getSimpleName());
}
}
if (analyticGeometryDefinition == null && segmentedSampledFieldGeometry == null && distanceMapSampledFieldGeometry == null && csGeometry == null) {
throw new SBMLImportException("VCell supports only Analytic, Image based (segmentd or distance map) or Constructed Solid Geometry at this time.");
}
GeometryDefinition selectedGeometryDefinition = null;
if (csGeometry != null) {
selectedGeometryDefinition = csGeometry;
} else if (analyticGeometryDefinition != null) {
selectedGeometryDefinition = analyticGeometryDefinition;
} else if (segmentedSampledFieldGeometry != null) {
selectedGeometryDefinition = segmentedSampledFieldGeometry;
} else if (distanceMapSampledFieldGeometry != null) {
selectedGeometryDefinition = distanceMapSampledFieldGeometry;
} else if (parametricGeometry != null) {
selectedGeometryDefinition = parametricGeometry;
} else {
throw new SBMLImportException("no geometry definition found");
}
Geometry vcGeometry = null;
if (selectedGeometryDefinition == analyticGeometryDefinition || selectedGeometryDefinition == csGeometry) {
vcGeometry = new Geometry("spatialGeom", dimension);
} else if (selectedGeometryDefinition == distanceMapSampledFieldGeometry || selectedGeometryDefinition == segmentedSampledFieldGeometry) {
SampledFieldGeometry sfg = (SampledFieldGeometry) selectedGeometryDefinition;
// get image from sampledFieldGeometry
// get a sampledVol object via the listOfSampledVol (from
// SampledGeometry) object.
// gcw gcw gcw
String sfn = sfg.getSampledField();
SampledField sf = null;
for (SampledField sampledField : sbmlGeometry.getListOfSampledFields()) {
if (sampledField.getSpatialId().equals(sfn)) {
sf = sampledField;
}
}
int numX = sf.getNumSamples1();
int numY = sf.getNumSamples2();
int numZ = sf.getNumSamples3();
int[] samples = new int[sf.getSamplesLength()];
StringTokenizer tokens = new StringTokenizer(sf.getSamples(), " ");
int count = 0;
while (tokens.hasMoreTokens()) {
int sample = Integer.parseInt(tokens.nextToken());
samples[count++] = sample;
}
byte[] imageInBytes = new byte[samples.length];
if (selectedGeometryDefinition == distanceMapSampledFieldGeometry) {
//
for (int i = 0; i < imageInBytes.length; i++) {
// if (interpolation(samples[i])<0){
if (samples[i] < 0) {
imageInBytes[i] = -1;
} else {
imageInBytes[i] = 1;
}
}
} else {
for (int i = 0; i < imageInBytes.length; i++) {
imageInBytes[i] = (byte) samples[i];
}
}
try {
// System.out.println("ident " + sf.getId() + " " + sf.getName());
VCImage vcImage = null;
CompressionKind ck = sf.getCompression();
DataKind dk = sf.getDataType();
if (ck == CompressionKind.deflated) {
vcImage = new VCImageCompressed(null, imageInBytes, vcExtent, numX, numY, numZ);
} else {
switch(dk) {
case UINT8:
case UINT16:
case UINT32:
vcImage = new VCImageUncompressed(null, imageInBytes, vcExtent, numX, numY, numZ);
default:
}
}
if (vcImage == null) {
throw new SbmlException("Unsupported type combination " + ck + ", " + dk + " for sampled field " + sf.getName());
}
vcImage.setName(sf.getId());
ListOf<SampledVolume> sampledVolumes = sfg.getListOfSampledVolumes();
final int numSampledVols = sampledVolumes.size();
if (numSampledVols == 0) {
throw new RuntimeException("Cannot have 0 sampled volumes in sampledField (image_based) geometry");
}
// check to see if values are uniquely integer , add set up scaling if necessary
double scaleFactor = checkPixelScaling(sampledVolumes, 1);
if (scaleFactor != 1) {
double checkScaleFactor = checkPixelScaling(sampledVolumes, scaleFactor);
VCAssert.assertTrue(checkScaleFactor != scaleFactor, "Scale factor check failed");
}
VCPixelClass[] vcpixelClasses = new VCPixelClass[numSampledVols];
// get pixel classes for geometry
for (int i = 0; i < numSampledVols; i++) {
SampledVolume sVol = sampledVolumes.get(i);
// from subVolume, get pixelClass?
final int scaled = (int) (scaleFactor * sVol.getSampledValue());
vcpixelClasses[i] = new VCPixelClass(null, sVol.getDomainType(), scaled);
}
vcImage.setPixelClasses(vcpixelClasses);
// now create image geometry
vcGeometry = new Geometry("spatialGeom", vcImage);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new RuntimeException("Unable to create image from SampledFieldGeometry : " + e.getMessage());
}
}
GeometrySpec vcGeometrySpec = vcGeometry.getGeometrySpec();
vcGeometrySpec.setOrigin(vcOrigin);
try {
vcGeometrySpec.setExtent(vcExtent);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new SBMLImportException("Unable to set extent on VC geometry : " + e.getMessage(), e);
}
// get listOfDomainTypes via the Geometry object.
ListOf<DomainType> listOfDomainTypes = sbmlGeometry.getListOfDomainTypes();
if (listOfDomainTypes == null || listOfDomainTypes.size() < 1) {
throw new SBMLImportException("Cannot have 0 domainTypes in geometry");
}
// get a listOfDomains via the Geometry object.
ListOf<Domain> listOfDomains = sbmlGeometry.getListOfDomains();
if (listOfDomains == null || listOfDomains.size() < 1) {
throw new SBMLImportException("Cannot have 0 domains in geometry");
}
// ListOfGeometryDefinitions listOfGeomDefns =
// sbmlGeometry.getListOfGeometryDefinitions();
// if ((listOfGeomDefns == null) ||
// (sbmlGeometry.getNumGeometryDefinitions() > 1)) {
// throw new
// RuntimeException("Can have only 1 geometry definition in geometry");
// }
// use the boolean bAnalytic to create the right kind of subvolume.
// First match the somVol=domainTypes for spDim=3. Deal witl spDim=2
// afterwards.
GeometrySurfaceDescription vcGsd = vcGeometry.getGeometrySurfaceDescription();
Vector<DomainType> surfaceClassDomainTypesVector = new Vector<DomainType>();
try {
for (DomainType dt : listOfDomainTypes) {
if (dt.getSpatialDimensions() == 3) {
// subvolume
if (selectedGeometryDefinition == analyticGeometryDefinition) {
// will set expression later - when reading in Analytic
// Volumes in GeometryDefinition
vcGeometrySpec.addSubVolume(new AnalyticSubVolume(dt.getId(), new Expression(1.0)));
} else {
// add SubVolumes later for CSG and Image-based
}
} else if (dt.getSpatialDimensions() == 2) {
surfaceClassDomainTypesVector.add(dt);
}
}
// analytic vol is needed to get the expression for subVols
if (selectedGeometryDefinition == analyticGeometryDefinition) {
// get an analyticVol object via the listOfAnalyticVol (from
// AnalyticGeometry) object.
ListOf<AnalyticVolume> aVolumes = analyticGeometryDefinition.getListOfAnalyticVolumes();
if (aVolumes.size() < 1) {
throw new SBMLImportException("Cannot have 0 Analytic volumes in analytic geometry");
}
for (AnalyticVolume analyticVol : aVolumes) {
// get subVol from VC geometry using analyticVol spatialId;
// set its expr using analyticVol's math.
SubVolume vcSubvolume = vcGeometrySpec.getSubVolume(analyticVol.getDomainType());
CastInfo<AnalyticSubVolume> ci = BeanUtils.attemptCast(AnalyticSubVolume.class, vcSubvolume);
if (!ci.isGood()) {
throw new RuntimeException("analytic volume '" + analyticVol.getId() + "' does not map to any VC subvolume.");
}
AnalyticSubVolume asv = ci.get();
try {
Expression subVolExpr = getExpressionFromFormula(analyticVol.getMath());
asv.setExpression(subVolExpr);
} catch (ExpressionException e) {
e.printStackTrace(System.out);
throw new SBMLImportException("Unable to set expression on subVolume '" + asv.getName() + "'. " + e.getMessage(), e);
}
}
}
SampledFieldGeometry sfg = BeanUtils.downcast(SampledFieldGeometry.class, selectedGeometryDefinition);
if (sfg != null) {
ListOf<SampledVolume> sampledVolumes = sfg.getListOfSampledVolumes();
int numSampledVols = sampledVolumes.size();
if (numSampledVols == 0) {
throw new SBMLImportException("Cannot have 0 sampled volumes in sampledField (image_based) geometry");
}
VCPixelClass[] vcpixelClasses = new VCPixelClass[numSampledVols];
ImageSubVolume[] vcImageSubVols = new ImageSubVolume[numSampledVols];
// get pixel classes for geometry
int idx = 0;
for (SampledVolume sVol : sampledVolumes) {
// from subVolume, get pixelClass?
final String name = sVol.getDomainType();
final int pixelValue = SBMLUtils.ignoreZeroFraction(sVol.getSampledValue());
VCPixelClass pc = new VCPixelClass(null, name, pixelValue);
vcpixelClasses[idx] = pc;
// Create the new Image SubVolume - use index of this for
// loop as 'handle' for ImageSubVol?
ImageSubVolume isv = new ImageSubVolume(null, pc, idx);
isv.setName(name);
vcImageSubVols[idx++] = isv;
}
vcGeometry.getGeometrySpec().setSubVolumes(vcImageSubVols);
}
if (selectedGeometryDefinition == csGeometry) {
ListOf<org.sbml.jsbml.ext.spatial.CSGObject> listOfcsgObjs = csGeometry.getListOfCSGObjects();
ArrayList<org.sbml.jsbml.ext.spatial.CSGObject> sbmlCSGs = new ArrayList<org.sbml.jsbml.ext.spatial.CSGObject>(listOfcsgObjs);
// we want the CSGObj with highest ordinal to be the first
// element in the CSG subvols array.
Collections.sort(sbmlCSGs, new Comparator<org.sbml.jsbml.ext.spatial.CSGObject>() {
@Override
public int compare(org.sbml.jsbml.ext.spatial.CSGObject lhs, org.sbml.jsbml.ext.spatial.CSGObject rhs) {
// minus one to reverse sort
return -1 * Integer.compare(lhs.getOrdinal(), rhs.getOrdinal());
}
});
int n = sbmlCSGs.size();
CSGObject[] vcCSGSubVolumes = new CSGObject[n];
for (int i = 0; i < n; i++) {
org.sbml.jsbml.ext.spatial.CSGObject sbmlCSGObject = sbmlCSGs.get(i);
CSGObject vcellCSGObject = new CSGObject(null, sbmlCSGObject.getDomainType(), i);
vcellCSGObject.setRoot(getVCellCSGNode(sbmlCSGObject.getCSGNode()));
}
vcGeometry.getGeometrySpec().setSubVolumes(vcCSGSubVolumes);
}
// Call geom.geomSurfDesc.updateAll() to automatically generate
// surface classes.
// vcGsd.updateAll();
vcGeometry.precomputeAll(new GeometryThumbnailImageFactoryAWT(), true, true);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new SBMLImportException("Unable to create VC subVolumes from SBML domainTypes : " + e.getMessage(), e);
}
// should now map each SBML domain to right VC geometric region.
GeometricRegion[] vcGeomRegions = vcGsd.getGeometricRegions();
ISize sampleSize = vcGsd.getVolumeSampleSize();
RegionInfo[] regionInfos = vcGsd.getRegionImage().getRegionInfos();
int numX = sampleSize.getX();
int numY = sampleSize.getY();
int numZ = sampleSize.getZ();
double ox = vcOrigin.getX();
double oy = vcOrigin.getY();
double oz = vcOrigin.getZ();
for (Domain domain : listOfDomains) {
String domainType = domain.getDomainType();
InteriorPoint interiorPt = domain.getListOfInteriorPoints().get(0);
if (interiorPt == null) {
DomainType currDomainType = null;
for (DomainType dt : sbmlGeometry.getListOfDomainTypes()) {
if (dt.getSpatialId().equals(domainType)) {
currDomainType = dt;
}
}
if (currDomainType.getSpatialDimensions() == 2) {
continue;
}
}
Coordinate sbmlInteriorPtCoord = new Coordinate(interiorPt.getCoord1(), interiorPt.getCoord2(), interiorPt.getCoord3());
for (int j = 0; j < vcGeomRegions.length; j++) {
if (vcGeomRegions[j] instanceof VolumeGeometricRegion) {
int regionID = ((VolumeGeometricRegion) vcGeomRegions[j]).getRegionID();
for (int k = 0; k < regionInfos.length; k++) {
// (using gemoRegion regionID).
if (regionInfos[k].getRegionIndex() == regionID) {
int volIndx = 0;
Coordinate nearestPtCoord = null;
double minDistance = Double.MAX_VALUE;
// represented by SBML 'domain[i]'.
for (int z = 0; z < numZ; z++) {
for (int y = 0; y < numY; y++) {
for (int x = 0; x < numX; x++) {
if (regionInfos[k].isIndexInRegion(volIndx)) {
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;
// for now, find the shortest dist
// coord. Can refine algo later.
Coordinate vcCoord = new Coordinate(coordX, coordY, coordZ);
double distance = sbmlInteriorPtCoord.distanceTo(vcCoord);
if (distance < minDistance) {
minDistance = distance;
nearestPtCoord = vcCoord;
}
}
volIndx++;
}
// end - for x
}
// end - for y
}
// with domain name
if (nearestPtCoord != null) {
GeometryClass geomClassSBML = vcGeometry.getGeometryClass(domainType);
// we know vcGeometryReg[j] is a VolGeomRegion
GeometryClass geomClassVC = ((VolumeGeometricRegion) vcGeomRegions[j]).getSubVolume();
if (geomClassSBML.compareEqual(geomClassVC)) {
vcGeomRegions[j].setName(domain.getId());
}
}
}
// end if (regInfoIndx = regId)
}
// end - for regInfo
}
}
// end for - vcGeomRegions
}
// deal with surfaceClass:spDim2-domainTypes
for (int i = 0; i < surfaceClassDomainTypesVector.size(); i++) {
DomainType surfaceClassDomainType = surfaceClassDomainTypesVector.elementAt(i);
// 'surfaceClassDomainType'
for (Domain d : listOfDomains) {
if (d.getDomainType().equals(surfaceClassDomainType.getId())) {
// get the adjacent domains of this 'surface' domain
// (surface domain + its 2 adj vol domains)
Set<Domain> adjacentDomainsSet = getAssociatedAdjacentDomains(sbmlGeometry, d);
// get the domain types of the adjacent domains in SBML and
// store the corresponding subVol counterparts from VC for
// adj vol domains
Vector<SubVolume> adjacentSubVolumesVector = new Vector<SubVolume>();
Vector<VolumeGeometricRegion> adjVolGeomRegionsVector = new Vector<VolumeGeometricRegion>();
Iterator<Domain> iterator = adjacentDomainsSet.iterator();
while (iterator.hasNext()) {
Domain dom = iterator.next();
DomainType dt = getBySpatialID(sbmlGeometry.getListOfDomainTypes(), dom.getDomainType());
if (dt.getSpatialDimensions() == 3) {
// for domain type with sp. dim = 3, get
// correspoinding subVol from VC geometry.
GeometryClass gc = vcGeometry.getGeometryClass(dt.getId());
adjacentSubVolumesVector.add((SubVolume) gc);
// store volGeomRegions corresponding to this (vol)
// geomClass in adjVolGeomRegionsVector : this
// should return ONLY 1 region for subVol.
GeometricRegion[] geomRegion = vcGsd.getGeometricRegions(gc);
adjVolGeomRegionsVector.add((VolumeGeometricRegion) geomRegion[0]);
}
}
// there should be only 2 subVols in this vector
if (adjacentSubVolumesVector.size() != 2) {
throw new RuntimeException("Cannot have more or less than 2 subvolumes that are adjacent to surface (membrane) '" + d.getId() + "'");
}
// get the surface class with these 2 adj subVols. Set its
// name to that of 'surfaceClassDomainType'
SurfaceClass surfacClass = vcGsd.getSurfaceClass(adjacentSubVolumesVector.get(0), adjacentSubVolumesVector.get(1));
surfacClass.setName(surfaceClassDomainType.getSpatialId());
// get surfaceGeometricRegion that has adjVolGeomRegions as
// its adjacent vol geom regions and set its name from
// domain 'd'
SurfaceGeometricRegion surfaceGeomRegion = getAssociatedSurfaceGeometricRegion(vcGsd, adjVolGeomRegionsVector);
if (surfaceGeomRegion != null) {
surfaceGeomRegion.setName(d.getId());
}
}
// end if - domain.domainType == surfaceClassDomainType
}
// end for - numDomains
}
// structureMappings in VC from compartmentMappings in SBML
try {
// set geometry first and then set structureMappings?
vcBioModel.getSimulationContext(0).setGeometry(vcGeometry);
// update simContextName ...
vcBioModel.getSimulationContext(0).setName(vcBioModel.getSimulationContext(0).getName() + "_" + vcGeometry.getName());
Model vcModel = vcBioModel.getSimulationContext(0).getModel();
ModelUnitSystem vcModelUnitSystem = vcModel.getUnitSystem();
Vector<StructureMapping> structMappingsVector = new Vector<StructureMapping>();
SpatialCompartmentPlugin cplugin = null;
for (int i = 0; i < sbmlModel.getNumCompartments(); i++) {
Compartment c = sbmlModel.getCompartment(i);
String cname = c.getName();
cplugin = (SpatialCompartmentPlugin) c.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
CompartmentMapping compMapping = cplugin.getCompartmentMapping();
if (compMapping != null) {
// final String id = compMapping.getId();
// final String name = compMapping.getName();
CastInfo<Structure> ci = SBMLHelper.getTypedStructure(Structure.class, vcModel, cname);
if (ci.isGood()) {
Structure struct = ci.get();
String domainType = compMapping.getDomainType();
GeometryClass geometryClass = vcGeometry.getGeometryClass(domainType);
double unitSize = compMapping.getUnitSize();
Feature feat = BeanUtils.downcast(Feature.class, struct);
if (feat != null) {
FeatureMapping featureMapping = new FeatureMapping(feat, vcBioModel.getSimulationContext(0), vcModelUnitSystem);
featureMapping.setGeometryClass(geometryClass);
if (geometryClass instanceof SubVolume) {
featureMapping.getVolumePerUnitVolumeParameter().setExpression(new Expression(unitSize));
} else if (geometryClass instanceof SurfaceClass) {
featureMapping.getVolumePerUnitAreaParameter().setExpression(new Expression(unitSize));
}
structMappingsVector.add(featureMapping);
} else if (struct instanceof Membrane) {
MembraneMapping membraneMapping = new MembraneMapping((Membrane) struct, vcBioModel.getSimulationContext(0), vcModelUnitSystem);
membraneMapping.setGeometryClass(geometryClass);
if (geometryClass instanceof SubVolume) {
membraneMapping.getAreaPerUnitVolumeParameter().setExpression(new Expression(unitSize));
} else if (geometryClass instanceof SurfaceClass) {
membraneMapping.getAreaPerUnitAreaParameter().setExpression(new Expression(unitSize));
}
structMappingsVector.add(membraneMapping);
}
}
}
}
StructureMapping[] structMappings = structMappingsVector.toArray(new StructureMapping[0]);
vcBioModel.getSimulationContext(0).getGeometryContext().setStructureMappings(structMappings);
// if type from SBML parameter Boundary Condn is not the same as the
// boundary type of the
// structureMapping of structure of paramSpContext, set the boundary
// condn type of the structureMapping
// to the value of 'type' from SBML parameter Boundary Condn.
ListOf<Parameter> listOfGlobalParams = sbmlModel.getListOfParameters();
for (Parameter sbmlGlobalParam : sbmlModel.getListOfParameters()) {
SpatialParameterPlugin spplugin = (SpatialParameterPlugin) sbmlGlobalParam.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
ParameterType paramType = spplugin.getParamType();
if (!(paramType instanceof BoundaryCondition)) {
continue;
}
BoundaryCondition bCondn = (BoundaryCondition) paramType;
if (bCondn.isSetVariable()) {
// get the var of boundaryCondn; find appropriate spContext
// in vcell;
SpeciesContext paramSpContext = vcBioModel.getSimulationContext(0).getModel().getSpeciesContext(bCondn.getVariable());
if (paramSpContext != null) {
Structure s = paramSpContext.getStructure();
StructureMapping sm = vcBioModel.getSimulationContext(0).getGeometryContext().getStructureMapping(s);
if (sm != null) {
BoundaryConditionType bct = null;
switch(bCondn.getType()) {
case Dirichlet:
{
bct = BoundaryConditionType.DIRICHLET;
break;
}
case Neumann:
{
bct = BoundaryConditionType.NEUMANN;
break;
}
case Robin_inwardNormalGradientCoefficient:
case Robin_sum:
case Robin_valueCoefficient:
default:
throw new RuntimeException("boundary condition type " + bCondn.getType().name() + " not supported");
}
for (CoordinateComponent coordComp : getSbmlGeometry().getListOfCoordinateComponents()) {
if (bCondn.getSpatialRef().equals(coordComp.getBoundaryMinimum().getSpatialId())) {
switch(coordComp.getType()) {
case cartesianX:
{
sm.setBoundaryConditionTypeXm(bct);
}
case cartesianY:
{
sm.setBoundaryConditionTypeYm(bct);
}
case cartesianZ:
{
sm.setBoundaryConditionTypeZm(bct);
}
}
}
if (bCondn.getSpatialRef().equals(coordComp.getBoundaryMaximum().getSpatialId())) {
switch(coordComp.getType()) {
case cartesianX:
{
sm.setBoundaryConditionTypeXm(bct);
}
case cartesianY:
{
sm.setBoundaryConditionTypeYm(bct);
}
case cartesianZ:
{
sm.setBoundaryConditionTypeZm(bct);
}
}
}
}
} else // sm != null
{
logger.sendMessage(VCLogger.Priority.MediumPriority, VCLogger.ErrorType.OverallWarning, "No structure " + s.getName() + " requested by species context " + paramSpContext.getName());
}
}
// end if (paramSpContext != null)
}
// end if (bCondn.isSetVar())
}
// end for (sbmlModel.numParams)
vcBioModel.getSimulationContext(0).getGeometryContext().refreshStructureMappings();
vcBioModel.getSimulationContext(0).refreshSpatialObjects();
} catch (Exception e) {
e.printStackTrace(System.out);
throw new SBMLImportException("Unable to create VC structureMappings from SBML compartment mappings : " + e.getMessage(), e);
}
}
Also used :
Origin(org.vcell.util.Origin)
VCPixelClass(cbit.image.VCPixelClass)
MembraneMapping(cbit.vcell.mapping.MembraneMapping)
DataKind(org.sbml.jsbml.ext.spatial.DataKind)
ArrayList(java.util.ArrayList)
BoundaryConditionType(cbit.vcell.math.BoundaryConditionType)
SpeciesContext(cbit.vcell.model.SpeciesContext)
Feature(cbit.vcell.model.Feature)
GeometryDefinition(org.sbml.jsbml.ext.spatial.GeometryDefinition)
SubVolume(cbit.vcell.geometry.SubVolume)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
CompartmentSubVolume(cbit.vcell.geometry.CompartmentSubVolume)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
Vector(java.util.Vector)
CoordinateComponent(org.sbml.jsbml.ext.spatial.CoordinateComponent)
SimulationContext(cbit.vcell.mapping.SimulationContext)
SpeciesContext(cbit.vcell.model.SpeciesContext)
GeometryContext(cbit.vcell.mapping.GeometryContext)
IssueContext(org.vcell.util.IssueContext)
ReactionContext(cbit.vcell.mapping.ReactionContext)
CompressionKind(org.sbml.jsbml.ext.spatial.CompressionKind)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
PropertyVetoException(java.beans.PropertyVetoException)
ModelPropertyVetoException(cbit.vcell.model.ModelPropertyVetoException)
Coordinate(org.vcell.util.Coordinate)
BoundaryCondition(org.sbml.jsbml.ext.spatial.BoundaryCondition)
SbmlException(org.vcell.sbml.SbmlException)
AnalyticSubVolume(cbit.vcell.geometry.AnalyticSubVolume)
SurfaceClass(cbit.vcell.geometry.SurfaceClass)
CSGeometry(org.sbml.jsbml.ext.spatial.CSGeometry)
VCImage(cbit.image.VCImage)
StructureMapping(cbit.vcell.mapping.StructureMapping)
GeometryThumbnailImageFactoryAWT(cbit.vcell.geometry.GeometryThumbnailImageFactoryAWT)
FeatureMapping(cbit.vcell.mapping.FeatureMapping)
Structure(cbit.vcell.model.Structure)
ModelUnitSystem(cbit.vcell.model.ModelUnitSystem)
ParameterType(org.sbml.jsbml.ext.spatial.ParameterType)
BioEventParameterType(cbit.vcell.mapping.BioEvent.BioEventParameterType)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
Geometry(cbit.vcell.geometry.Geometry)
SampledFieldGeometry(org.sbml.jsbml.ext.spatial.SampledFieldGeometry)
AnalyticGeometry(org.sbml.jsbml.ext.spatial.AnalyticGeometry)
ParametricGeometry(org.sbml.jsbml.ext.spatial.ParametricGeometry)
CSGeometry(org.sbml.jsbml.ext.spatial.CSGeometry)
StringTokenizer(java.util.StringTokenizer)
Expression(cbit.vcell.parser.Expression)
Model(cbit.vcell.model.Model)
BioModel(cbit.vcell.biomodel.BioModel)
InterpolationKind(org.sbml.jsbml.ext.spatial.InterpolationKind)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
Parameter(org.sbml.jsbml.Parameter)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
SpeciesContextSpecParameter(cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)
LocalParameter(org.sbml.jsbml.LocalParameter)
KineticsProxyParameter(cbit.vcell.model.Kinetics.KineticsProxyParameter)
UnresolvedParameter(cbit.vcell.model.Kinetics.UnresolvedParameter)
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)
ExpressionException(cbit.vcell.parser.ExpressionException)
GeometrySpec(cbit.vcell.geometry.GeometrySpec)
DomainType(org.sbml.jsbml.ext.spatial.DomainType)
SampledVolume(org.sbml.jsbml.ext.spatial.SampledVolume)
ListOf(org.sbml.jsbml.ListOf)
SpatialCompartmentPlugin(org.sbml.jsbml.ext.spatial.SpatialCompartmentPlugin)
VCImageCompressed(cbit.image.VCImageCompressed)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
VolumeGeometricRegion(cbit.vcell.geometry.surface.VolumeGeometricRegion)
GeometricRegion(cbit.vcell.geometry.surface.GeometricRegion)
AnalyticVolume(org.sbml.jsbml.ext.spatial.AnalyticVolume)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
ParametricGeometry(org.sbml.jsbml.ext.spatial.ParametricGeometry)
SampledField(org.sbml.jsbml.ext.spatial.SampledField)
Domain(org.sbml.jsbml.ext.spatial.Domain)
GeometryClass(cbit.vcell.geometry.GeometryClass)
GeometrySurfaceDescription(cbit.vcell.geometry.surface.GeometrySurfaceDescription)
Extent(org.vcell.util.Extent)
ISize(org.vcell.util.ISize)
RegionInfo(cbit.vcell.geometry.RegionImage.RegionInfo)
Membrane(cbit.vcell.model.Membrane)
CSGObject(cbit.vcell.geometry.CSGObject)
ImageSubVolume(cbit.vcell.geometry.ImageSubVolume)
SurfaceGeometricRegion(cbit.vcell.geometry.surface.SurfaceGeometricRegion)
VCImageUncompressed(cbit.image.VCImageUncompressed)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
XMLStreamException(javax.xml.stream.XMLStreamException)
SbmlException(org.vcell.sbml.SbmlException)
XmlParseException(cbit.vcell.xml.XmlParseException)
IOException(java.io.IOException)
PropertyVetoException(java.beans.PropertyVetoException)
DivideByZeroException(cbit.vcell.parser.DivideByZeroException)
SBMLException(org.sbml.jsbml.SBMLException)
ExpressionBindingException(cbit.vcell.parser.ExpressionBindingException)
ModelPropertyVetoException(cbit.vcell.model.ModelPropertyVetoException)
ExpressionException(cbit.vcell.parser.ExpressionException)
Example 22 with StructureMapping
use of cbit.vcell.mapping.StructureMapping in project vcell by virtualcell.
the class SBMLImporter method addParameters.
/**
* addParameters : Adds global parameters from SBML model to VCell model. If
* expression for global parameter contains species, creates a conc_factor
* parameter (conversion from SBML - VCell conc units) and adds this factor
* to VC global params list, and replaces occurances of 'sp' with
* 'sp*concFactor' in original param expression.
*
* @throws PropertyVetoException
*/
protected void addParameters(Map<String, String> vcToSbmlNameMap, Map<String, String> sbmlToVcNameMap) throws Exception {
ListOf listofGlobalParams = sbmlModel.getListOfParameters();
if (listofGlobalParams == null) {
System.out.println("No Global Parameters");
return;
}
Model vcModel = vcBioModel.getSimulationContext(0).getModel();
ArrayList<ModelParameter> vcModelParamsList = new ArrayList<Model.ModelParameter>();
// create a hash of reserved symbols so that if there is any reserved
// symbol occurring as a global parameter in the SBML model,
// the hash can be used to check for reserved symbols, so that it will
// not be added as a global parameter in VCell,
// since reserved symbols cannot be used as other variables (species,
// structureSize, parameters, reactions, etc.).
HashSet<String> reservedSymbolHash = new HashSet<String>();
for (ReservedSymbol rs : vcModel.getReservedSymbols()) {
reservedSymbolHash.add(rs.getName());
}
ModelUnitSystem modelUnitSystem = vcModel.getUnitSystem();
for (int i = 0; i < sbmlModel.getNumParameters(); i++) {
Parameter sbmlGlobalParam = (Parameter) listofGlobalParams.get(i);
String paramName = sbmlGlobalParam.getId();
String sbmlParamName = sbmlGlobalParam.getName();
SpatialParameterPlugin spplugin = null;
if (bSpatial) {
// check if parameter id is x/y/z : if so, check if its
// 'spatialSymbolRef' child's spatial id and type are non-empty.
// If so, the parameter represents a spatial element.
// If not, throw an exception, since a parameter that does not
// represent a spatial element cannot have an id of x/y/z
spplugin = (SpatialParameterPlugin) sbmlGlobalParam.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
if (paramName.equals("x") || paramName.equals("y") || paramName.equals("z")) {
boolean bSpatialParam = (spplugin != null && spplugin.getParamType() instanceof SpatialSymbolReference);
// if (a) and (b) are true, continue with the next parameter
if (!bSpatialParam) {
throw new RuntimeException("Parameter '" + paramName + "' is not a spatial parameter : Cannot have a variable in VCell named '" + paramName + "' unless it is a spatial variable.");
} else {
// parameter to the list of vcell parameters.
continue;
}
}
}
//
// Get param value if set or get its expression from rule
//
// Check if param is defined by an assignment rule or initial
// assignment. If so, that value overrides the value existing in the
// param element.
// assignment rule, first
Expression valueExpr = getValueFromAssignmentRule(paramName);
if (valueExpr == null) {
if (sbmlGlobalParam.isSetValue()) {
double value = sbmlGlobalParam.getValue();
valueExpr = new Expression(value);
} else {
// if value for global param is not set and param has a rate
// rule, need to set an init value for param (else, there
// will be a problem in reaction which uses this parameter).
// use a 'default' initial value of '0'
valueExpr = new Expression(0.0);
// logger.sendMessage(VCLogger.Priority.MediumPriority,
// VCLogger.Priority.LowPriority,
// "Parameter did not have an initial value, but has a rate rule specified. Using a default value of 0.0.");
}
}
if (valueExpr != null) {
// valueExpr will be changed
valueExpr = adjustExpression(valueExpr, vcModel);
}
// extension
if (bSpatial) {
VCAssert.assertTrue(spplugin != null, "invalid initialization logic");
ParameterType sbmlParamType = spplugin.getParamType();
SpeciesContext paramSpContext = null;
SpeciesContextSpec vcSpContextsSpec = null;
// Check for diffusion coefficient(s)
if (sbmlParamType instanceof DiffusionCoefficient) {
DiffusionCoefficient diffCoeff = (DiffusionCoefficient) sbmlParamType;
if (diffCoeff != null && diffCoeff.isSetVariable()) {
// get the var of diffCoeff; find appropriate spContext
// in vcell; set its diff param to param value.
paramSpContext = vcModel.getSpeciesContext(diffCoeff.getVariable());
if (paramSpContext != null) {
vcSpContextsSpec = vcBioModel.getSimulationContext(0).getReactionContext().getSpeciesContextSpec(paramSpContext);
vcSpContextsSpec.getDiffusionParameter().setExpression(valueExpr);
}
// coeff parameter to the list of vcell parameters.
continue;
}
}
// Check for advection coefficient(s)
if (sbmlParamType instanceof AdvectionCoefficient) {
AdvectionCoefficient advCoeff = (AdvectionCoefficient) sbmlParamType;
if (advCoeff != null && advCoeff.isSetVariable()) {
// get the var of advCoeff; find appropriate spContext
// in vcell; set its adv param to param value.
paramSpContext = vcModel.getSpeciesContext(advCoeff.getVariable());
if (paramSpContext != null) {
vcSpContextsSpec = vcBioModel.getSimulationContext(0).getReactionContext().getSpeciesContextSpec(paramSpContext);
CoordinateKind coordKind = advCoeff.getCoordinate();
SpeciesContextSpecParameter param = null;
switch(coordKind) {
case cartesianX:
{
param = vcSpContextsSpec.getParameterFromRole(SpeciesContextSpec.ROLE_VelocityX);
break;
}
case cartesianY:
{
param = vcSpContextsSpec.getParameterFromRole(SpeciesContextSpec.ROLE_VelocityY);
break;
}
case cartesianZ:
{
param = vcSpContextsSpec.getParameterFromRole(SpeciesContextSpec.ROLE_VelocityZ);
break;
}
}
param.setExpression(valueExpr);
}
// coeff parameter to the list of vcell parameters.
continue;
}
}
// Check for Boundary condition(s)
if (sbmlParamType instanceof BoundaryCondition) {
BoundaryCondition bCondn = (BoundaryCondition) sbmlParamType;
if (bCondn != null && bCondn.isSetVariable()) {
// get the var of boundaryCondn; find appropriate
// spContext in vcell;
// set the BC param of its speciesContextSpec to param
// value.
paramSpContext = vcModel.getSpeciesContext(bCondn.getVariable());
if (paramSpContext == null) {
throw new RuntimeException("unable to process boundary condition for variable " + bCondn.getVariable());
}
StructureMapping sm = vcBioModel.getSimulationContext(0).getGeometryContext().getStructureMapping(paramSpContext.getStructure());
vcSpContextsSpec = vcBioModel.getSimulationContext(0).getReactionContext().getSpeciesContextSpec(paramSpContext);
for (CoordinateComponent coordComp : getSbmlGeometry().getListOfCoordinateComponents()) {
if (bCondn.getSpatialRef().equals(coordComp.getBoundaryMinimum().getSpatialId())) {
switch(coordComp.getType()) {
case cartesianX:
{
vcSpContextsSpec.getBoundaryXmParameter().setExpression(valueExpr);
}
case cartesianY:
{
vcSpContextsSpec.getBoundaryYmParameter().setExpression(valueExpr);
}
case cartesianZ:
{
vcSpContextsSpec.getBoundaryZmParameter().setExpression(valueExpr);
}
}
}
if (bCondn.getSpatialRef().equals(coordComp.getBoundaryMaximum().getSpatialId())) {
switch(coordComp.getType()) {
case cartesianX:
{
vcSpContextsSpec.getBoundaryXpParameter().setExpression(valueExpr);
}
case cartesianY:
{
vcSpContextsSpec.getBoundaryYpParameter().setExpression(valueExpr);
}
case cartesianZ:
{
vcSpContextsSpec.getBoundaryZpParameter().setExpression(valueExpr);
}
}
}
}
continue;
}
}
// Check for Boundary condition(s)
if (sbmlParamType instanceof SpatialSymbolReference) {
SpatialSymbolReference spatialSymbolRef = (SpatialSymbolReference) sbmlParamType;
throw new RuntimeException("generic Spatial Symbol References not yet supported, unresolved spatial reference '" + spatialSymbolRef.getSpatialRef() + "'");
}
}
// doesn't exist.
if (vcModel.getModelParameter(paramName) == null) {
VCUnitDefinition glParamUnitDefn = sbmlUnitIdentifierHash.get(sbmlGlobalParam.getUnits());
// set it to TBD or check if it was dimensionless.
if (glParamUnitDefn == null) {
glParamUnitDefn = modelUnitSystem.getInstance_TBD();
}
// special treatment for x,y,z
if (isRestrictedXYZT(paramName)) {
String vcSpeciesId = "s_" + paramName;
vcToSbmlNameMap.put(vcSpeciesId, paramName);
sbmlToVcNameMap.put(paramName, vcSpeciesId);
ModelParameter vcGlobalParam = vcModel.new ModelParameter(vcSpeciesId, valueExpr, Model.ROLE_UserDefined, glParamUnitDefn);
if (vcSpeciesId.length() > 64) {
vcGlobalParam.setDescription("Parameter Name : " + vcSpeciesId);
}
if (sbmlParamName != null && !sbmlParamName.isEmpty()) {
vcGlobalParam.setSbmlName(sbmlParamName);
}
vcModelParamsList.add(vcGlobalParam);
} else if (!reservedSymbolHash.contains(paramName)) {
// Also check if the SBML global param is a reserved symbol in
// VCell : cannot add reserved symbol to model params.
// we dealt with x,y,z above
ModelParameter vcGlobalParam = vcModel.new ModelParameter(paramName, valueExpr, Model.ROLE_UserDefined, glParamUnitDefn);
if (paramName.length() > 64) {
// record global parameter name in annotation if it is
// longer than 64 characeters
vcGlobalParam.setDescription("Parameter Name : " + paramName);
}
if (sbmlParamName != null && !sbmlParamName.isEmpty()) {
vcGlobalParam.setSbmlName(sbmlParamName);
}
vcModelParamsList.add(vcGlobalParam);
}
}
}
// end for - sbmlModel.parameters
vcModel.setModelParameters(vcModelParamsList.toArray(new ModelParameter[0]));
}
Also used :
ReservedSymbol(cbit.vcell.model.Model.ReservedSymbol)
ArrayList(java.util.ArrayList)
SpatialParameterPlugin(org.sbml.jsbml.ext.spatial.SpatialParameterPlugin)
SpeciesContext(cbit.vcell.model.SpeciesContext)
SpeciesContextSpec(cbit.vcell.mapping.SpeciesContextSpec)
StructureMapping(cbit.vcell.mapping.StructureMapping)
CoordinateKind(org.sbml.jsbml.ext.spatial.CoordinateKind)
ListOf(org.sbml.jsbml.ListOf)
HashSet(java.util.HashSet)
ModelUnitSystem(cbit.vcell.model.ModelUnitSystem)
SpeciesContextSpecParameter(cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)
CoordinateComponent(org.sbml.jsbml.ext.spatial.CoordinateComponent)
AdvectionCoefficient(org.sbml.jsbml.ext.spatial.AdvectionCoefficient)
ParameterType(org.sbml.jsbml.ext.spatial.ParameterType)
BioEventParameterType(cbit.vcell.mapping.BioEvent.BioEventParameterType)
DiffusionCoefficient(org.sbml.jsbml.ext.spatial.DiffusionCoefficient)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
SpatialSymbolReference(org.sbml.jsbml.ext.spatial.SpatialSymbolReference)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
Expression(cbit.vcell.parser.Expression)
BoundaryCondition(org.sbml.jsbml.ext.spatial.BoundaryCondition)
Model(cbit.vcell.model.Model)
BioModel(cbit.vcell.biomodel.BioModel)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
Parameter(org.sbml.jsbml.Parameter)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
SpeciesContextSpecParameter(cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)
LocalParameter(org.sbml.jsbml.LocalParameter)
KineticsProxyParameter(cbit.vcell.model.Kinetics.KineticsProxyParameter)
UnresolvedParameter(cbit.vcell.model.Kinetics.UnresolvedParameter)
Example 23 with StructureMapping
use of cbit.vcell.mapping.StructureMapping in project vcell by virtualcell.
the class SBMLExporter method addCompartments.
/**
* addCompartments comment.
* @throws XMLStreamException
* @throws SbmlException
*/
protected void addCompartments() throws XMLStreamException, SbmlException {
Model vcModel = vcBioModel.getModel();
cbit.vcell.model.Structure[] vcStructures = vcModel.getStructures();
for (int i = 0; i < vcStructures.length; i++) {
Compartment sbmlCompartment = sbmlModel.createCompartment();
sbmlCompartment.setId(TokenMangler.mangleToSName(vcStructures[i].getName()));
sbmlCompartment.setName(vcStructures[i].getName());
VCUnitDefinition sbmlSizeUnit = null;
StructureTopology structTopology = getSelectedSimContext().getModel().getStructureTopology();
Structure parentStructure = structTopology.getParentStructure(vcStructures[i]);
if (vcStructures[i] instanceof Feature) {
sbmlCompartment.setSpatialDimensions(3);
String outside = null;
if (parentStructure != null) {
outside = TokenMangler.mangleToSName(parentStructure.getName());
}
if (outside != null) {
if (outside.length() > 0) {
sbmlCompartment.setOutside(outside);
}
}
sbmlSizeUnit = sbmlExportSpec.getVolumeUnits();
UnitDefinition unitDefn = getOrCreateSBMLUnit(sbmlSizeUnit);
sbmlCompartment.setUnits(unitDefn);
} else if (vcStructures[i] instanceof Membrane) {
Membrane vcMembrane = (Membrane) vcStructures[i];
sbmlCompartment.setSpatialDimensions(2);
Feature outsideFeature = structTopology.getOutsideFeature(vcMembrane);
if (outsideFeature != null) {
sbmlCompartment.setOutside(TokenMangler.mangleToSName(outsideFeature.getName()));
sbmlSizeUnit = sbmlExportSpec.getAreaUnits();
UnitDefinition unitDefn = getOrCreateSBMLUnit(sbmlSizeUnit);
sbmlCompartment.setUnits(unitDefn);
} else if (lg.isWarnEnabled()) {
lg.warn(this.sbmlModel.getName() + " membrame " + vcMembrane.getName() + " has not outside feature");
}
}
sbmlCompartment.setConstant(true);
StructureMapping vcStructMapping = getSelectedSimContext().getGeometryContext().getStructureMapping(vcStructures[i]);
try {
if (vcStructMapping.getSizeParameter().getExpression() != null) {
sbmlCompartment.setSize(vcStructMapping.getSizeParameter().getExpression().evaluateConstant());
} else {
// really no need to set sizes of compartments in spatial ..... ????
// throw new RuntimeException("Compartment size not set for compartment \"" + vcStructures[i].getName() + "\" ; Please set size and try exporting again.");
}
} catch (cbit.vcell.parser.ExpressionException e) {
// If it is in the catch block, it means that the compartment size was probably not a double, but an assignment.
// Check if the expression for the compartment size is not null and add it as an assignment rule.
Expression sizeExpr = vcStructMapping.getSizeParameter().getExpression();
if (sizeExpr != null) {
ASTNode ruleFormulaNode = getFormulaFromExpression(sizeExpr);
AssignmentRule assignRule = sbmlModel.createAssignmentRule();
assignRule.setVariable(vcStructures[i].getName());
assignRule.setMath(ruleFormulaNode);
// If compartmentSize is specified by an assignment rule, the 'constant' field should be set to 'false' (default - true).
sbmlCompartment.setConstant(false);
sbmlModel.addRule(assignRule);
}
}
// Add the outside compartment of given compartment as annotation to the compartment.
// This is required later while trying to read in compartments ...
Element sbmlImportRelatedElement = null;
// if (parentStructure != null) {
// sbmlImportRelatedElement = new Element(XMLTags.VCellRelatedInfoTag, sbml_vcml_ns);
// Element compartmentElement = new Element(XMLTags.OutsideCompartmentTag, sbml_vcml_ns);
// compartmentElement.setAttribute(XMLTags.NameAttrTag, TokenMangler.mangleToSName(parentStructure.getName()));
// sbmlImportRelatedElement.addContent(compartmentElement);
// }
// Get annotation (RDF and non-RDF) for reactionStep from SBMLAnnotationUtils
sbmlAnnotationUtil.writeAnnotation(vcStructures[i], sbmlCompartment, sbmlImportRelatedElement);
// Now set notes,
sbmlAnnotationUtil.writeNotes(vcStructures[i], sbmlCompartment);
}
}
Also used :
StructureTopology(cbit.vcell.model.Model.StructureTopology)
Compartment(org.sbml.jsbml.Compartment)
AssignmentRule(org.sbml.jsbml.AssignmentRule)
Element(org.jdom.Element)
ExpressionException(cbit.vcell.parser.ExpressionException)
Feature(cbit.vcell.model.Feature)
StructureMapping(cbit.vcell.mapping.StructureMapping)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
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)
Membrane(cbit.vcell.model.Membrane)
Structure(cbit.vcell.model.Structure)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
UnitDefinition(org.sbml.jsbml.UnitDefinition)
Example 24 with StructureMapping
use of cbit.vcell.mapping.StructureMapping in project vcell by virtualcell.
the class SBMLExporter method addReactions.
/**
* addReactions comment.
* @throws SbmlException
* @throws XMLStreamException
*/
protected void addReactions() throws SbmlException, XMLStreamException {
// Check if any reaction has electrical mapping
boolean bCalculatePotential = false;
StructureMapping[] structureMappings = getSelectedSimContext().getGeometryContext().getStructureMappings();
for (int i = 0; i < structureMappings.length; i++) {
if (structureMappings[i] instanceof MembraneMapping) {
if (((MembraneMapping) structureMappings[i]).getCalculateVoltage()) {
bCalculatePotential = true;
}
}
}
// If it does, VCell doesn't export it to SBML (no representation).
if (bCalculatePotential) {
throw new RuntimeException("This VCell model has Electrical mapping; cannot be exported to SBML at this time");
}
l2gMap.clear();
ReactionSpec[] vcReactionSpecs = getSelectedSimContext().getReactionContext().getReactionSpecs();
for (int i = 0; i < vcReactionSpecs.length; i++) {
if (vcReactionSpecs[i].isExcluded()) {
continue;
}
ReactionStep vcReactionStep = vcReactionSpecs[i].getReactionStep();
// Create sbml reaction
String rxnName = vcReactionStep.getName();
org.sbml.jsbml.Reaction sbmlReaction = sbmlModel.createReaction();
sbmlReaction.setId(org.vcell.util.TokenMangler.mangleToSName(rxnName));
sbmlReaction.setName(rxnName);
String rxnSbmlName = vcReactionStep.getSbmlName();
if (rxnSbmlName != null && !rxnSbmlName.isEmpty()) {
sbmlReaction.setName(rxnSbmlName);
}
// If the reactionStep is a flux reaction, add the details to the annotation (structure, carrier valence, flux carrier, fluxOption, etc.)
// If reactionStep is a simple reaction, add annotation to indicate the structure of reaction.
// Useful when roundtripping ...
Element sbmlImportRelatedElement = null;
// try {
// sbmlImportRelatedElement = getAnnotationElement(vcReactionStep);
// } catch (XmlParseException e1) {
// e1.printStackTrace(System.out);
// // throw new RuntimeException("Error ");
// }
// Get annotation (RDF and non-RDF) for reactionStep from SBMLAnnotationUtils
sbmlAnnotationUtil.writeAnnotation(vcReactionStep, sbmlReaction, sbmlImportRelatedElement);
// Now set notes,
sbmlAnnotationUtil.writeNotes(vcReactionStep, sbmlReaction);
// Get reaction kineticLaw
Kinetics vcRxnKinetics = vcReactionStep.getKinetics();
org.sbml.jsbml.KineticLaw sbmlKLaw = sbmlReaction.createKineticLaw();
try {
// Convert expression from kinetics rate parameter into MathML and use libSBMl utilities to convert it to formula
// (instead of directly using rate parameter's expression infix) to maintain integrity of formula :
// for example logical and inequalities are not handled gracefully by libSBMl if expression.infix is used.
final Expression localRateExpr;
final Expression lumpedRateExpr;
if (vcRxnKinetics instanceof DistributedKinetics) {
localRateExpr = ((DistributedKinetics) vcRxnKinetics).getReactionRateParameter().getExpression();
lumpedRateExpr = null;
} else if (vcRxnKinetics instanceof LumpedKinetics) {
localRateExpr = null;
lumpedRateExpr = ((LumpedKinetics) vcRxnKinetics).getLumpedReactionRateParameter().getExpression();
} else {
throw new RuntimeException("unexpected Rate Law '" + vcRxnKinetics.getClass().getSimpleName() + "', not distributed or lumped type");
}
// if (vcRxnKinetics instanceof DistributedKinetics)
// Expression correctedRateExpr = kineticsAdapter.getExpression();
// Add parameters, if any, to the kineticLaw
Kinetics.KineticsParameter[] vcKineticsParams = vcRxnKinetics.getKineticsParameters();
// In the first pass thro' the kinetic params, store the non-numeric param names and expressions in arrays
String[] kinParamNames = new String[vcKineticsParams.length];
Expression[] kinParamExprs = new Expression[vcKineticsParams.length];
for (int j = 0; j < vcKineticsParams.length; j++) {
if (true) {
// Since local reaction parameters cannot be defined by a rule, such parameters (with rules) are exported as global parameters.
if ((vcKineticsParams[j].getRole() == Kinetics.ROLE_CurrentDensity && (!vcKineticsParams[j].getExpression().isZero())) || (vcKineticsParams[j].getRole() == Kinetics.ROLE_LumpedCurrent && (!vcKineticsParams[j].getExpression().isZero()))) {
throw new RuntimeException("Electric current not handled by SBML export; failed to export reaction \"" + vcReactionStep.getName() + "\" at this time");
}
if (!vcKineticsParams[j].getExpression().isNumeric()) {
// NON_NUMERIC KINETIC PARAM
// Create new name for kinetic parameter and store it in kinParamNames, store corresponding exprs in kinParamExprs
// Will be used later to add this param as global.
String newParamName = TokenMangler.mangleToSName(vcKineticsParams[j].getName() + "_" + vcReactionStep.getName());
kinParamNames[j] = newParamName;
kinParamExprs[j] = new Expression(vcKineticsParams[j].getExpression());
}
}
}
// If so, these need to be added as global param (else the SBML doc will not be valid)
for (int j = 0; j < vcKineticsParams.length; j++) {
final KineticsParameter vcKParam = vcKineticsParams[j];
if ((vcKParam.getRole() != Kinetics.ROLE_ReactionRate) && (vcKParam.getRole() != Kinetics.ROLE_LumpedReactionRate)) {
// if expression of kinetic param evaluates to a double, the parameter value is set
if ((vcKParam.getRole() == Kinetics.ROLE_CurrentDensity && (!vcKParam.getExpression().isZero())) || (vcKParam.getRole() == Kinetics.ROLE_LumpedCurrent && (!vcKParam.getExpression().isZero()))) {
throw new RuntimeException("Electric current not handled by SBML export; failed to export reaction \"" + vcReactionStep.getName() + "\" at this time");
}
if (vcKParam.getExpression().isNumeric()) {
// NUMERIC KINETIC PARAM
// check if it is used in other parameters that have expressions,
boolean bAddedParam = false;
String origParamName = vcKParam.getName();
String newParamName = TokenMangler.mangleToSName(origParamName + "_" + vcReactionStep.getName());
VCUnitDefinition vcUnit = vcKParam.getUnitDefinition();
for (int k = 0; k < vcKineticsParams.length; k++) {
if (kinParamExprs[k] != null) {
// The param could be in the expression for any other param
if (kinParamExprs[k].hasSymbol(origParamName)) {
// mangle its name to avoid conflict with other globals
if (globalParamNamesHash.get(newParamName) == null) {
globalParamNamesHash.put(newParamName, newParamName);
org.sbml.jsbml.Parameter sbmlKinParam = sbmlModel.createParameter();
sbmlKinParam.setId(newParamName);
sbmlKinParam.setValue(vcKParam.getConstantValue());
final boolean constValue = vcKParam.isConstant();
sbmlKinParam.setConstant(true);
// Set SBML units for sbmlParam using VC units from vcParam
if (!vcUnit.isTBD()) {
UnitDefinition unitDefn = getOrCreateSBMLUnit(vcUnit);
sbmlKinParam.setUnits(unitDefn);
}
Pair<String, String> origParam = new Pair<String, String>(rxnName, origParamName);
l2gMap.put(origParam, newParamName);
bAddedParam = true;
} else {
// need to get another name for param and need to change all its refereces in the other kinParam euqations.
}
// update the expression to contain new name, since the globalparam has new name
kinParamExprs[k].substituteInPlace(new Expression(origParamName), new Expression(newParamName));
}
}
}
// If the param hasn't been added yet, it is definitely a local param. add it to kineticLaw now.
if (!bAddedParam) {
org.sbml.jsbml.LocalParameter sbmlKinParam = sbmlKLaw.createLocalParameter();
sbmlKinParam.setId(origParamName);
sbmlKinParam.setValue(vcKParam.getConstantValue());
System.out.println("tis constant " + sbmlKinParam.isExplicitlySetConstant());
// Set SBML units for sbmlParam using VC units from vcParam
if (!vcUnit.isTBD()) {
UnitDefinition unitDefn = getOrCreateSBMLUnit(vcUnit);
sbmlKinParam.setUnits(unitDefn);
}
} else {
// hence change its occurance in rate expression if it contains that param name
if (localRateExpr != null && localRateExpr.hasSymbol(origParamName)) {
localRateExpr.substituteInPlace(new Expression(origParamName), new Expression(newParamName));
}
if (lumpedRateExpr != null && lumpedRateExpr.hasSymbol(origParamName)) {
lumpedRateExpr.substituteInPlace(new Expression(origParamName), new Expression(newParamName));
}
}
}
}
}
// (using the kinParamNames and kinParamExprs above) to ensure uniqueness in the global parameter names.
for (int j = 0; j < vcKineticsParams.length; j++) {
if (((vcKineticsParams[j].getRole() != Kinetics.ROLE_ReactionRate) && (vcKineticsParams[j].getRole() != Kinetics.ROLE_LumpedReactionRate)) && !(vcKineticsParams[j].getExpression().isNumeric())) {
String oldName = vcKineticsParams[j].getName();
String newName = kinParamNames[j];
// change the name of this parameter in the rate expression
if (localRateExpr != null && localRateExpr.hasSymbol(oldName)) {
localRateExpr.substituteInPlace(new Expression(oldName), new Expression(newName));
}
if (lumpedRateExpr != null && lumpedRateExpr.hasSymbol(oldName)) {
lumpedRateExpr.substituteInPlace(new Expression(oldName), new Expression(newName));
}
// Change the occurence of this param in other param expressions
for (int k = 0; k < vcKineticsParams.length; k++) {
if (((vcKineticsParams[k].getRole() != Kinetics.ROLE_ReactionRate) && (vcKineticsParams[j].getRole() != Kinetics.ROLE_LumpedReactionRate)) && !(vcKineticsParams[k].getExpression().isNumeric())) {
if (k != j && vcKineticsParams[k].getExpression().hasSymbol(oldName)) {
// for all params except the current param represented by index j (whose name was changed)
kinParamExprs[k].substituteInPlace(new Expression(oldName), new Expression(newName));
}
if (k == j && vcKineticsParams[k].getExpression().hasSymbol(oldName)) {
throw new RuntimeException("A parameter cannot refer to itself in its expression");
}
}
}
// end for - k
}
}
// In the fifth pass thro' the kinetic params, the non-numeric params are added to the global params of the model
for (int j = 0; j < vcKineticsParams.length; j++) {
if (((vcKineticsParams[j].getRole() != Kinetics.ROLE_ReactionRate) && (vcKineticsParams[j].getRole() != Kinetics.ROLE_LumpedReactionRate)) && !(vcKineticsParams[j].getExpression().isNumeric())) {
// Now, add this param to the globalParamNamesHash and add a global parameter to the sbmlModel
String paramName = kinParamNames[j];
if (globalParamNamesHash.get(paramName) == null) {
globalParamNamesHash.put(paramName, paramName);
} else {
// need to get another name for param and need to change all its refereces in the other kinParam euqations.
}
Pair<String, String> origParam = new Pair<String, String>(rxnName, paramName);
// keeps its name but becomes a global (?)
l2gMap.put(origParam, paramName);
ASTNode paramFormulaNode = getFormulaFromExpression(kinParamExprs[j]);
AssignmentRule sbmlParamAssignmentRule = sbmlModel.createAssignmentRule();
sbmlParamAssignmentRule.setVariable(paramName);
sbmlParamAssignmentRule.setMath(paramFormulaNode);
org.sbml.jsbml.Parameter sbmlKinParam = sbmlModel.createParameter();
sbmlKinParam.setId(paramName);
if (!vcKineticsParams[j].getUnitDefinition().isTBD()) {
sbmlKinParam.setUnits(getOrCreateSBMLUnit(vcKineticsParams[j].getUnitDefinition()));
}
// Since the parameter is being specified by a Rule, its 'constant' field shoud be set to 'false' (default - true).
sbmlKinParam.setConstant(false);
}
}
// end for (j) - fifth pass
// After making all necessary adjustments to the rate expression, now set the sbmlKLaw.
final ASTNode exprFormulaNode;
if (lumpedRateExpr != null) {
exprFormulaNode = getFormulaFromExpression(lumpedRateExpr);
} else {
if (bSpatial) {
exprFormulaNode = getFormulaFromExpression(localRateExpr);
} else {
exprFormulaNode = getFormulaFromExpression(Expression.mult(localRateExpr, new Expression(vcReactionStep.getStructure().getName())));
}
}
sbmlKLaw.setMath(exprFormulaNode);
} catch (cbit.vcell.parser.ExpressionException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error getting value of parameter : " + e.getMessage());
}
// Add kineticLaw to sbmlReaction - not needed now, since we use sbmlRxn.createKLaw() ??
// sbmlReaction.setKineticLaw(sbmlKLaw);
// Add reactants, products, modifiers
// Simple reactions have catalysts, fluxes have 'flux'
cbit.vcell.model.ReactionParticipant[] rxnParticipants = vcReactionStep.getReactionParticipants();
for (ReactionParticipant rxnParticpant : rxnParticipants) {
SimpleSpeciesReference ssr = null;
SpeciesReference sr = null;
// to get unique ID when the same species is both a reactant and a product
String rolePostfix = "";
if (rxnParticpant instanceof cbit.vcell.model.Reactant) {
rolePostfix = "r";
ssr = sr = sbmlReaction.createReactant();
} else if (rxnParticpant instanceof cbit.vcell.model.Product) {
rolePostfix = "p";
ssr = sr = sbmlReaction.createProduct();
}
if (rxnParticpant instanceof cbit.vcell.model.Catalyst) {
rolePostfix = "c";
ssr = sbmlReaction.createModifier();
}
if (ssr != null) {
ssr.setSpecies(rxnParticpant.getSpeciesContext().getName());
}
if (sr != null) {
sr.setStoichiometry(Double.parseDouble(Integer.toString(rxnParticpant.getStoichiometry())));
String modelUniqueName = vcReactionStep.getName() + '_' + rxnParticpant.getName() + rolePostfix;
sr.setId(TokenMangler.mangleToSName(modelUniqueName));
// SBML-REVIEW
sr.setConstant(true);
// int rcode = sr.appendNotes("<
// we know that in VCell we can't override stoichiometry anywhere, below is no longer questionable
// try {
// SBMLHelper.addNote(sr, "VCELL guess: how do we know if reaction is constant?");
// } catch (Exception e) {
// e.printStackTrace();
// }
}
}
sbmlReaction.setFast(vcReactionSpecs[i].isFast());
// this attribute is mandatory for L3, optional for L2. So explicitly setting value.
sbmlReaction.setReversible(true);
if (bSpatial) {
// set compartment for reaction if spatial
sbmlReaction.setCompartment(vcReactionStep.getStructure().getName());
// CORE HAS ALT MATH true
// set the "isLocal" attribute = true (in 'spatial' namespace) for each species
SpatialReactionPlugin srplugin = (SpatialReactionPlugin) sbmlReaction.getPlugin(SBMLUtils.SBML_SPATIAL_NS_PREFIX);
srplugin.setIsLocal(vcRxnKinetics instanceof DistributedKinetics);
}
}
}
Also used :
MembraneMapping(cbit.vcell.mapping.MembraneMapping)
LumpedKinetics(cbit.vcell.model.LumpedKinetics)
Element(org.jdom.Element)
StructureMapping(cbit.vcell.mapping.StructureMapping)
SimpleSpeciesReference(org.sbml.jsbml.SimpleSpeciesReference)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
SpeciesReference(org.sbml.jsbml.SpeciesReference)
SimpleSpeciesReference(org.sbml.jsbml.SimpleSpeciesReference)
ASTNode(org.sbml.jsbml.ASTNode)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
UnitDefinition(org.sbml.jsbml.UnitDefinition)
Pair(org.vcell.util.Pair)
DistributedKinetics(cbit.vcell.model.DistributedKinetics)
SpatialReactionPlugin(org.sbml.jsbml.ext.spatial.SpatialReactionPlugin)
ReactionSpec(cbit.vcell.mapping.ReactionSpec)
AssignmentRule(org.sbml.jsbml.AssignmentRule)
ExpressionException(cbit.vcell.parser.ExpressionException)
InteriorPoint(org.sbml.jsbml.ext.spatial.InteriorPoint)
VCUnitDefinition(cbit.vcell.units.VCUnitDefinition)
Expression(cbit.vcell.parser.Expression)
ReactionStep(cbit.vcell.model.ReactionStep)
Kinetics(cbit.vcell.model.Kinetics)
DistributedKinetics(cbit.vcell.model.DistributedKinetics)
LumpedKinetics(cbit.vcell.model.LumpedKinetics)
ReactionParticipant(cbit.vcell.model.ReactionParticipant)
Example 25 with StructureMapping
use of cbit.vcell.mapping.StructureMapping in project vcell by virtualcell.
the class StructureMappingCartoon method refreshAll.
@Override
public void refreshAll() {
{
if (getGeometryContext() == null || getGeometryContext().getGeometry() == null) {
return;
}
GeometryClass[] geometryClasses = getGeometryContext().getGeometry().getGeometryClasses();
if (geometryClasses == null) {
return;
}
for (int i = 0; i < geometryClasses.length; i++) {
Shape testShape = getShapeFromModelObject(geometryClasses[i]);
if (testShape instanceof GeometryClassLegendShape) {
geometryClasses[i].removePropertyChangeListener((GeometryClassLegendShape) testShape);
}
}
}
clearAllShapes();
if (getSimulationContext() == null) {
fireGraphChanged(new GraphEvent(this));
return;
}
GeometryContextGeometryShape geometryShape = new GeometryContextGeometryShape(this, getGeometryContext().getGeometry());
GeometryContextStructureShape structureContainerShape = new GeometryContextStructureShape(this, getGeometryContext().getModel());
GeometryContextContainerShape containerShape = new GeometryContextContainerShape(this, getGeometryContext(), structureContainerShape, geometryShape);
addShape(containerShape);
addShape(geometryShape);
addShape(structureContainerShape);
getGeometryContext().removePropertyChangeListener(this);
getGeometryContext().addPropertyChangeListener(this);
// create all StructureShapes
Structure[] structures = getGeometryContext().getModel().getStructures();
for (int i = 0; i < structures.length; i++) {
StructureMappingStructureShape smShape = new StructureMappingStructureShape((Structure) structures[i], getGeometryContext().getModel(), this);
addShape(smShape);
structureContainerShape.addChildShape(smShape);
structures[i].removePropertyChangeListener(this);
structures[i].addPropertyChangeListener(this);
}
// create all SubvolumeLegendShapes (for legend)
GeometryClass[] geometryClasses = getGeometryContext().getGeometry().getGeometryClasses();
for (int i = 0; i < geometryClasses.length; i++) {
GeometryClassLegendShape geometryClassLegendShape = new GeometryClassLegendShape(geometryClasses[i], getGeometryContext().getGeometry(), this, 10);
geometryClasses[i].addPropertyChangeListener(geometryClassLegendShape);
addShape(geometryClassLegendShape);
geometryShape.addChildShape(geometryClassLegendShape);
}
if ((subVolumeContainerShape == null) || (subVolumeContainerShape.getModelObject() != getGeometryContext().getGeometry())) {
subVolumeContainerShape = new SubVolumeContainerShape(getGeometryContext().getGeometry(), this);
}
subVolumeContainerShape.removeAllChildren();
subVolumeContainerShape.setBrightImage(getGeometryContext().getGeometry().getGeometrySpec().getThumbnailImage().getCurrentValue());
addShape(subVolumeContainerShape);
geometryShape.addChildShape(subVolumeContainerShape);
StructureMapping[] structureMappings = getGeometryContext().getStructureMappings();
for (int i = 0; i < structureMappings.length; i++) {
StructureMapping structureMapping = structureMappings[i];
structureMapping.removePropertyChangeListener(this);
structureMapping.addPropertyChangeListener(this);
if (structureMapping.getGeometryClass() != null) {
StructureShape sShape = (StructureShape) getShapeFromModelObject(structureMapping.getStructure());
GeometryClassLegendShape geometryClassLegendShape = (GeometryClassLegendShape) getShapeFromModelObject(structureMapping.getGeometryClass());
StructureMappingShape smShape = new StructureMappingShape(structureMapping, sShape, geometryClassLegendShape, this);
addShape(smShape);
containerShape.addChildShape(smShape);
}
}
// // assign children to shapes according to heirarchy in Model
// int nullParentCount=0;
// Collection<Shape> shapes = getShapes();
// for(Shape shape : shapes) {
// // for each featureShape, find corresponding featureShape
// if (shape instanceof StructureShape){
// StructureShape fs = (FeatureShape)shape;
// if(!structureContainerShape.contains(fs)) {
// structureContainerShape.addChildShape(fs);
// }
// nullParentCount++;
// }
// }
fireGraphChanged(new GraphEvent(this));
}
Also used :
GeometryClass(cbit.vcell.geometry.GeometryClass)
Shape(cbit.gui.graph.Shape)
StructureMapping(cbit.vcell.mapping.StructureMapping)
GraphEvent(cbit.gui.graph.GraphEvent)
Structure(cbit.vcell.model.Structure)
Aggregations
StructureMapping (cbit.vcell.mapping.StructureMapping)49
Expression (cbit.vcell.parser.Expression)25
Structure (cbit.vcell.model.Structure)22
ExpressionException (cbit.vcell.parser.ExpressionException)19
SpeciesContextSpec (cbit.vcell.mapping.SpeciesContextSpec)18
MembraneMapping (cbit.vcell.mapping.MembraneMapping)17
SimulationContext (cbit.vcell.mapping.SimulationContext)16
SpeciesContext (cbit.vcell.model.SpeciesContext)16
KineticsParameter (cbit.vcell.model.Kinetics.KineticsParameter)15
VCUnitDefinition (cbit.vcell.units.VCUnitDefinition)15
Model (cbit.vcell.model.Model)14
BioModel (cbit.vcell.biomodel.BioModel)13
FeatureMapping (cbit.vcell.mapping.FeatureMapping)12
ModelParameter (cbit.vcell.model.Model.ModelParameter)12
ReactionStep (cbit.vcell.model.ReactionStep)12
GeometryContext (cbit.vcell.mapping.GeometryContext)11
MappingException (cbit.vcell.mapping.MappingException)11
SpeciesContextSpecParameter (cbit.vcell.mapping.SpeciesContextSpec.SpeciesContextSpecParameter)11
Membrane (cbit.vcell.model.Membrane)11
Feature (cbit.vcell.model.Feature)10
