Example 11 with SpatialObject
use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.
the class BioModelParametersTableModel method propertyChange.
@Override
public void propertyChange(java.beans.PropertyChangeEvent evt) {
super.propertyChange(evt);
if (evt.getSource() instanceof EditableSymbolTableEntry) {
int changeRow = getRowIndex((EditableSymbolTableEntry) evt.getSource());
if (changeRow >= 0) {
fireTableRowsUpdated(changeRow, changeRow);
}
} else {
String propertyName = evt.getPropertyName();
if (evt.getSource() == bioModel.getModel()) {
if (propertyName.equals(Model.PROPERTY_NAME_MODEL_PARAMETERS)) {
ModelParameter[] oldValue = (ModelParameter[]) evt.getOldValue();
if (oldValue != null) {
for (EditableSymbolTableEntry parameter : oldValue) {
parameter.removePropertyChangeListener(this);
}
}
ModelParameter[] newValue = (ModelParameter[]) evt.getNewValue();
if (newValue != null) {
for (EditableSymbolTableEntry parameter : newValue) {
parameter.addPropertyChangeListener(this);
}
}
refreshData();
} else if (propertyName.equals(Model.PROPERTY_NAME_SPECIES_CONTEXTS)) {
SpeciesContext[] oldValue = (SpeciesContext[]) evt.getOldValue();
if (oldValue != null) {
for (SpeciesContext sc : oldValue) {
sc.removePropertyChangeListener(this);
}
}
SpeciesContext[] newValue = (SpeciesContext[]) evt.getNewValue();
if (newValue != null) {
for (SpeciesContext sc : newValue) {
sc.addPropertyChangeListener(this);
}
}
refreshData();
} else if (propertyName.equals(Model.PROPERTY_NAME_REACTION_STEPS)) {
ReactionStep[] oldValue = (ReactionStep[]) evt.getOldValue();
if (oldValue != null) {
for (ReactionStep reactionStep : oldValue) {
reactionStep.removePropertyChangeListener(this);
reactionStep.getKinetics().removePropertyChangeListener(this);
for (KineticsParameter kineticsEditableSymbolTableEntry : reactionStep.getKinetics().getKineticsParameters()) {
kineticsEditableSymbolTableEntry.removePropertyChangeListener(this);
}
for (ProxyParameter proxyEditableSymbolTableEntry : reactionStep.getKinetics().getProxyParameters()) {
proxyEditableSymbolTableEntry.removePropertyChangeListener(this);
}
for (UnresolvedParameter unresolvedEditableSymbolTableEntry : reactionStep.getKinetics().getUnresolvedParameters()) {
unresolvedEditableSymbolTableEntry.removePropertyChangeListener(this);
}
}
}
ReactionStep[] newValue = (ReactionStep[]) evt.getNewValue();
if (newValue != null) {
for (ReactionStep reactionStep : newValue) {
reactionStep.addPropertyChangeListener(this);
reactionStep.getKinetics().addPropertyChangeListener(this);
for (KineticsParameter kineticsEditableSymbolTableEntry : reactionStep.getKinetics().getKineticsParameters()) {
kineticsEditableSymbolTableEntry.addPropertyChangeListener(this);
}
for (ProxyParameter proxyEditableSymbolTableEntry : reactionStep.getKinetics().getProxyParameters()) {
proxyEditableSymbolTableEntry.addPropertyChangeListener(this);
}
for (UnresolvedParameter unresolvedEditableSymbolTableEntry : reactionStep.getKinetics().getUnresolvedParameters()) {
unresolvedEditableSymbolTableEntry.addPropertyChangeListener(this);
}
}
}
refreshData();
} else if (evt.getPropertyName().equals(RbmModelContainer.PROPERTY_NAME_REACTION_RULE_LIST)) {
List<ReactionRule> oldValue = (List<ReactionRule>) evt.getOldValue();
if (oldValue != null) {
for (ReactionRule rs : oldValue) {
rs.removePropertyChangeListener(this);
}
}
List<ReactionRule> newValue = (List<ReactionRule>) evt.getNewValue();
if (newValue != null) {
for (ReactionRule rs : newValue) {
rs.addPropertyChangeListener(this);
}
}
refreshData();
}
} else if (evt.getSource() == bioModel) {
if (propertyName.equals(BioModel.PROPERTY_NAME_SIMULATION_CONTEXTS)) {
SimulationContext[] oldValue = (SimulationContext[]) evt.getOldValue();
for (SimulationContext simulationContext : oldValue) {
simulationContext.removePropertyChangeListener(this);
simulationContext.getGeometryContext().removePropertyChangeListener(this);
for (StructureMapping mapping : simulationContext.getGeometryContext().getStructureMappings()) {
mapping.removePropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : mapping.getParameters()) {
parameter.removePropertyChangeListener(this);
}
}
simulationContext.getReactionContext().removePropertyChangeListener(this);
for (SpeciesContextSpec spec : simulationContext.getReactionContext().getSpeciesContextSpecs()) {
spec.removePropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : spec.getParameters()) {
parameter.removePropertyChangeListener(this);
}
}
for (ElectricalStimulus elect : simulationContext.getElectricalStimuli()) {
elect.removePropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : elect.getParameters()) {
parameter.removePropertyChangeListener(this);
}
}
for (SpatialObject spatialObject : simulationContext.getSpatialObjects()) {
spatialObject.removePropertyChangeListener(this);
}
for (SpatialProcess spatialProcess : simulationContext.getSpatialProcesses()) {
spatialProcess.removePropertyChangeListener(this);
for (LocalParameter p : spatialProcess.getParameters()) {
p.removePropertyChangeListener(this);
}
}
for (SimulationContextParameter p : simulationContext.getSimulationContextParameters()) {
p.removePropertyChangeListener(this);
}
}
SimulationContext[] newValue = (SimulationContext[]) evt.getNewValue();
for (SimulationContext simulationContext : newValue) {
simulationContext.addPropertyChangeListener(this);
simulationContext.getGeometryContext().addPropertyChangeListener(this);
for (StructureMapping mapping : simulationContext.getGeometryContext().getStructureMappings()) {
mapping.addPropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : mapping.getParameters()) {
parameter.addPropertyChangeListener(this);
}
}
simulationContext.getReactionContext().addPropertyChangeListener(this);
for (SpeciesContextSpec spec : simulationContext.getReactionContext().getSpeciesContextSpecs()) {
spec.addPropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : spec.getParameters()) {
parameter.addPropertyChangeListener(this);
}
}
for (ElectricalStimulus elect : simulationContext.getElectricalStimuli()) {
elect.addPropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : elect.getParameters()) {
parameter.addPropertyChangeListener(this);
}
}
for (SpatialObject spatialObject : simulationContext.getSpatialObjects()) {
spatialObject.addPropertyChangeListener(this);
}
for (SpatialProcess spatialProcess : simulationContext.getSpatialProcesses()) {
spatialProcess.addPropertyChangeListener(this);
for (LocalParameter p : spatialProcess.getParameters()) {
p.addPropertyChangeListener(this);
}
}
for (SimulationContextParameter p : simulationContext.getSimulationContextParameters()) {
p.addPropertyChangeListener(this);
}
}
refreshData();
}
} else if (evt.getSource() instanceof GeometryContext && evt.getPropertyName().equals(GeometryContext.PROPERTY_STRUCTURE_MAPPINGS)) {
StructureMapping[] oldValue = (StructureMapping[]) evt.getOldValue();
if (oldValue != null) {
for (StructureMapping mapping : oldValue) {
mapping.removePropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : mapping.getParameters()) {
parameter.removePropertyChangeListener(this);
}
}
}
StructureMapping[] newValue = (StructureMapping[]) evt.getNewValue();
if (newValue != null) {
for (StructureMapping mapping : newValue) {
mapping.addPropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : mapping.getParameters()) {
parameter.addPropertyChangeListener(this);
}
}
}
refreshData();
} else if (evt.getSource() instanceof ReactionStep && (evt.getPropertyName().equals(ReactionStep.PROPERTY_NAME_KINETICS))) {
Kinetics oldValue = (Kinetics) evt.getOldValue();
if (oldValue != null) {
oldValue.removePropertyChangeListener(this);
for (KineticsParameter kineticsEditableSymbolTableEntry : oldValue.getKineticsParameters()) {
kineticsEditableSymbolTableEntry.removePropertyChangeListener(this);
}
for (ProxyParameter proxyEditableSymbolTableEntry : oldValue.getProxyParameters()) {
proxyEditableSymbolTableEntry.removePropertyChangeListener(this);
}
for (UnresolvedParameter unresolvedEditableSymbolTableEntry : oldValue.getUnresolvedParameters()) {
unresolvedEditableSymbolTableEntry.removePropertyChangeListener(this);
}
}
Kinetics newValue = (Kinetics) evt.getNewValue();
if (newValue != null) {
newValue.addPropertyChangeListener(this);
for (KineticsParameter kineticsEditableSymbolTableEntry : newValue.getKineticsParameters()) {
kineticsEditableSymbolTableEntry.addPropertyChangeListener(this);
}
for (ProxyParameter proxyEditableSymbolTableEntry : newValue.getProxyParameters()) {
proxyEditableSymbolTableEntry.addPropertyChangeListener(this);
}
for (UnresolvedParameter unresolvedEditableSymbolTableEntry : newValue.getUnresolvedParameters()) {
unresolvedEditableSymbolTableEntry.addPropertyChangeListener(this);
}
}
refreshData();
} else if (evt.getSource() instanceof SimulationContext && evt.getPropertyName().equals(SimulationContext.PROPERTY_NAME_SPATIALPROCESSES)) {
SpatialProcess[] oldValue = (SpatialProcess[]) evt.getOldValue();
if (oldValue != null) {
for (SpatialProcess process : oldValue) {
process.removePropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : process.getParameters()) {
parameter.removePropertyChangeListener(this);
}
}
}
SpatialProcess[] newValue = (SpatialProcess[]) evt.getNewValue();
if (newValue != null) {
for (SpatialProcess process : newValue) {
process.addPropertyChangeListener(this);
for (EditableSymbolTableEntry parameter : process.getParameters()) {
parameter.addPropertyChangeListener(this);
}
}
}
refreshData();
} else if (evt.getSource() instanceof SimulationContext && evt.getPropertyName().equals(SimulationContext.PROPERTY_NAME_SPATIALOBJECTS)) {
SpatialObject[] oldValue = (SpatialObject[]) evt.getOldValue();
if (oldValue != null) {
for (SpatialObject spatialObject : oldValue) {
spatialObject.removePropertyChangeListener(this);
}
}
SpatialObject[] newValue = (SpatialObject[]) evt.getNewValue();
if (newValue != null) {
for (SpatialObject spatialObject : newValue) {
spatialObject.addPropertyChangeListener(this);
}
}
refreshData();
} else if (evt.getSource() instanceof SpatialObject && evt.getPropertyName().equals(SpatialObject.PROPERTY_NAME_QUANTITYCATEGORIESENABLED)) {
refreshData();
} else if (evt.getSource() instanceof SimulationContext && evt.getPropertyName().equals(SimulationContext.PROPERTY_NAME_SIMULATIONCONTEXTPARAMETERS)) {
SimulationContextParameter[] oldValue = (SimulationContextParameter[]) evt.getOldValue();
if (oldValue != null) {
for (SimulationContextParameter param : oldValue) {
param.removePropertyChangeListener(this);
}
}
SimulationContextParameter[] newValue = (SimulationContextParameter[]) evt.getNewValue();
if (newValue != null) {
for (SimulationContextParameter param : newValue) {
param.addPropertyChangeListener(this);
}
}
refreshData();
} else if (evt.getSource() instanceof Kinetics && (evt.getPropertyName().equals(Kinetics.PROPERTY_NAME_KINETICS_PARAMETERS))) {
EditableSymbolTableEntry[] oldValue = (EditableSymbolTableEntry[]) evt.getOldValue();
if (oldValue != null) {
for (int i = 0; i < oldValue.length; i++) {
oldValue[i].removePropertyChangeListener(this);
}
}
EditableSymbolTableEntry[] newValue = (EditableSymbolTableEntry[]) evt.getNewValue();
if (newValue != null) {
for (int i = 0; i < newValue.length; i++) {
newValue[i].addPropertyChangeListener(this);
}
}
refreshData();
// } else if(evt.getSource() instanceof ReactionRuleEmbedded) {
// ReactionRuleEmbedded reactionRule = (ReactionRuleEmbedded) evt.getSource();
// int changeRow = getRowIndex(reactionRule);
// if (changeRow >= 0) {
// fireTableRowsUpdated(changeRow, changeRow);
// }
}
}
}
Also used :
UnresolvedParameter(cbit.vcell.model.Kinetics.UnresolvedParameter)
SpeciesContext(cbit.vcell.model.SpeciesContext)
SpeciesContextSpec(cbit.vcell.mapping.SpeciesContextSpec)
StructureMapping(cbit.vcell.mapping.StructureMapping)
SpatialObject(cbit.vcell.mapping.spatial.SpatialObject)
KineticsParameter(cbit.vcell.model.Kinetics.KineticsParameter)
SpatialProcess(cbit.vcell.mapping.spatial.processes.SpatialProcess)
ArrayList(java.util.ArrayList)
List(java.util.List)
GeometryContext(cbit.vcell.mapping.GeometryContext)
ReactionRule(cbit.vcell.model.ReactionRule)
SimulationContext(cbit.vcell.mapping.SimulationContext)
SimulationContextParameter(cbit.vcell.mapping.SimulationContext.SimulationContextParameter)
LocalParameter(cbit.vcell.mapping.ParameterContext.LocalParameter)
ModelParameter(cbit.vcell.model.Model.ModelParameter)
ElectricalStimulus(cbit.vcell.mapping.ElectricalStimulus)
ProxyParameter(cbit.vcell.model.ProxyParameter)
ReactionStep(cbit.vcell.model.ReactionStep)
Kinetics(cbit.vcell.model.Kinetics)
EditableSymbolTableEntry(cbit.vcell.model.EditableSymbolTableEntry)
Example 12 with SpatialObject
use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.
the class DiffEquMathMapping method addSpatialProcesses.
private void addSpatialProcesses(VariableHash varHash, ArrayList<CompartmentSubdomainContext> compartmentSubdomainContexts, ArrayList<MembraneSubdomainContext> membraneSubdomainContexts) throws MathException, MappingException, ExpressionException {
if (simContext.getGeometry().getDimension() == 0) {
return;
}
//
for (SpatialObject spatialObject : simContext.getSpatialObjects()) {
if (spatialObject instanceof PointObject) {
PointObject pointObject = (PointObject) spatialObject;
//
// if true, have to solve for this category
//
boolean bPosition = pointObject.isQuantityCategoryEnabled(QuantityCategory.PointPosition);
boolean bVelocity = pointObject.isQuantityCategoryEnabled(QuantityCategory.PointVelocity);
boolean bDirection = pointObject.isQuantityCategoryEnabled(QuantityCategory.DirectionToPoint);
boolean bDistance = pointObject.isQuantityCategoryEnabled(QuantityCategory.PointDistanceMap);
//
// either make a point subdomain, or just define functions.
//
ArrayList<PointLocation> pointLocationProcesses = new ArrayList<PointLocation>();
ArrayList<PointKinematics> pointKinematicsProcesses = new ArrayList<PointKinematics>();
for (SpatialProcess spatialProcess : simContext.getSpatialProcesses()) {
if (spatialProcess instanceof PointLocation && ((PointLocation) spatialProcess).getPointObject() == pointObject) {
pointLocationProcesses.add((PointLocation) spatialProcess);
}
if (spatialProcess instanceof PointKinematics && ((PointKinematics) spatialProcess).getPointObject() == pointObject) {
pointKinematicsProcesses.add((PointKinematics) spatialProcess);
}
}
if (pointLocationProcesses.size() == 1 && pointKinematicsProcesses.size() == 0 && !bVelocity) {
GeometryClass gc = null;
PointLocation pointLocation = pointLocationProcesses.get(0);
if (bPosition) {
if (simContext.getGeometry().getDimension() == 1) {
SpatialQuantity posXQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.X);
LocalParameter posXParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXParam, gc), getIdentifierSubstitutions(posXParam.getExpression(), posXParam.getUnitDefinition(), gc), gc));
Expression posXExp = new Expression(posXParam, pointLocation.getNameScope());
Expression xExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.X), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXQuantity, gc), getIdentifierSubstitutions(posXExp, posXQuantity.getUnitDefinition(), gc), gc));
Expression posX_minus_X = Expression.add(posXExp, Expression.negate(xExp));
Expression signum_posX_minus_X = Expression.function(FunctionType.MIN, new Expression(1.0), Expression.function(FunctionType.MAX, Expression.mult(new Expression(1e10), posX_minus_X), new Expression(-1)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(signum_posX_minus_X, dirXQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
Expression abs_X_minux_posX = Expression.function(FunctionType.ABS, posX_minus_X);
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(abs_X_minux_posX, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
if (simContext.getGeometry().getDimension() == 2) {
SpatialQuantity posXQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.X);
LocalParameter posXParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXParam, gc), getIdentifierSubstitutions(posXParam.getExpression(), posXParam.getUnitDefinition(), gc), gc));
Expression posXExp = new Expression(posXParam, pointLocation.getNameScope());
Expression xExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.X), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXQuantity, gc), getIdentifierSubstitutions(new Expression(posXParam, pointLocation.getNameScope()), posXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity posYQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.Y);
LocalParameter posYParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posYParam, gc), getIdentifierSubstitutions(posYParam.getExpression(), posYParam.getUnitDefinition(), gc), gc));
Expression posYExp = new Expression(posYParam, pointLocation.getNameScope());
Expression yExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.Y), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posYQuantity, gc), getIdentifierSubstitutions(new Expression(posYParam, pointLocation.getNameScope()), posYQuantity.getUnitDefinition(), gc), gc));
Expression posX_minux_X = Expression.add(posXExp, Expression.negate(xExp));
Expression posY_minux_Y = Expression.add(posYExp, Expression.negate(yExp));
Expression DX2 = Expression.mult(posX_minux_X, posX_minux_X);
Expression DY2 = Expression.mult(posY_minux_Y, posY_minux_Y);
Expression sqrt_DX2_DY2 = Expression.function(FunctionType.SQRT, Expression.add(DX2, DY2));
Expression dirX = Expression.div(posX_minux_X, Expression.add(sqrt_DX2_DY2, new Expression(1e-8)));
Expression dirY = Expression.div(posY_minux_Y, Expression.add(sqrt_DX2_DY2, new Expression(1e-8)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(dirX, dirXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirYQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Y);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirYQuantity, gc), getIdentifierSubstitutions(dirY, dirYQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(sqrt_DX2_DY2, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
if (simContext.getGeometry().getDimension() == 3) {
SpatialQuantity posXQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.X);
LocalParameter posXParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXParam, gc), getIdentifierSubstitutions(posXParam.getExpression(), posXParam.getUnitDefinition(), gc), gc));
Expression posXExp = new Expression(posXParam, pointLocation.getNameScope());
Expression xExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.X), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posXQuantity, gc), getIdentifierSubstitutions(new Expression(posXParam, pointLocation.getNameScope()), posXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity posYQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.Y);
LocalParameter posYParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posYParam, gc), getIdentifierSubstitutions(posYParam.getExpression(), posYParam.getUnitDefinition(), gc), gc));
Expression posYExp = new Expression(posYParam, pointLocation.getNameScope());
Expression yExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.Y), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posYQuantity, gc), getIdentifierSubstitutions(new Expression(posYParam, pointLocation.getNameScope()), posYQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity posZQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.Z);
LocalParameter posZParam = pointLocation.getParameter(SpatialProcessParameterType.PointPositionZ);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posZParam, gc), getIdentifierSubstitutions(posZParam.getExpression(), posZParam.getUnitDefinition(), gc), gc));
Expression posZExp = new Expression(posZParam, pointLocation.getNameScope());
Expression zExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.Z), simContext.getModel().getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(posZQuantity, gc), getIdentifierSubstitutions(new Expression(posZParam, pointLocation.getNameScope()), posZQuantity.getUnitDefinition(), gc), gc));
Expression posX_minux_X = Expression.add(posXExp, Expression.negate(xExp));
Expression posY_minux_Y = Expression.add(posYExp, Expression.negate(yExp));
Expression posZ_minux_Z = Expression.add(posZExp, Expression.negate(zExp));
Expression DX2 = Expression.mult(posX_minux_X, posX_minux_X);
Expression DY2 = Expression.mult(posY_minux_Y, posY_minux_Y);
Expression DZ2 = Expression.mult(posZ_minux_Z, posZ_minux_Z);
Expression sqrt_DX2_DY2_DZ2 = Expression.function(FunctionType.SQRT, Expression.add(DX2, DY2, DZ2));
Expression dirX = Expression.div(posX_minux_X, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
Expression dirY = Expression.div(posY_minux_Y, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
Expression dirZ = Expression.div(posZ_minux_Z, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(dirX, dirXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirYQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Y);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirYQuantity, gc), getIdentifierSubstitutions(dirY, dirYQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirZQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Z);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirZQuantity, gc), getIdentifierSubstitutions(dirZ, dirZQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(sqrt_DX2_DY2_DZ2, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
} else {
throw new MappingException("PointLocation process defined for pointObject '" + pointObject.getName() + "' but Position not enabled");
}
} else if (pointLocationProcesses.size() == 0 && pointKinematicsProcesses.size() == 1) {
GeometryClass gc = null;
PointKinematics pointKinematics = pointKinematicsProcesses.get(0);
if (bPosition && bVelocity) {
LocalParameter velXParam = pointKinematics.getParameter(SpatialProcessParameterType.PointVelocityX);
LocalParameter iniPosXParam = pointKinematics.getParameter(SpatialProcessParameterType.PointInitialPositionX);
SpatialQuantity posXQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.X);
SpatialQuantity velXQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointVelocity, QuantityComponent.X);
Expression posXExp = new Expression(posXQuantity, simContext.getNameScope());
Expression xExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.X), simContext.getModel().getNameScope());
Expression posX_minux_X = Expression.add(posXExp, Expression.negate(xExp));
LocalParameter velYParam = pointKinematics.getParameter(SpatialProcessParameterType.PointVelocityY);
LocalParameter iniPosYParam = pointKinematics.getParameter(SpatialProcessParameterType.PointInitialPositionY);
SpatialQuantity posYQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.Y);
SpatialQuantity velYQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointVelocity, QuantityComponent.Y);
Expression posYExp = new Expression(posYQuantity, simContext.getNameScope());
Expression yExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.Y), simContext.getModel().getNameScope());
Expression posY_minux_Y = Expression.add(posYExp, Expression.negate(yExp));
LocalParameter velZParam = pointKinematics.getParameter(SpatialProcessParameterType.PointVelocityZ);
LocalParameter iniPosZParam = pointKinematics.getParameter(SpatialProcessParameterType.PointInitialPositionZ);
SpatialQuantity posZQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointPosition, QuantityComponent.Z);
SpatialQuantity velZQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointVelocity, QuantityComponent.Z);
Expression posZExp = new Expression(posZQuantity, simContext.getNameScope());
Expression zExp = new Expression(simContext.getModel().getReservedSymbolByRole(ReservedSymbolRole.Z), simContext.getModel().getNameScope());
Expression posZ_minux_Z = Expression.add(posZExp, Expression.negate(zExp));
String pointSubdomainName = pointObject.getName();
Domain domain = new Domain(pointSubdomainName);
PointSubDomain pointSubdomain = new PointSubDomain(pointSubdomainName);
mathDesc.addSubDomain(pointSubdomain);
if (simContext.getGeometry().getDimension() >= 1) {
PointVariable posXVar = new PointVariable(getMathSymbol(posXQuantity, gc), domain);
varHash.addVariable(posXVar);
Expression initXExp = getIdentifierSubstitutions(new Expression(iniPosXParam, pointKinematics.getNameScope()), iniPosXParam.getUnitDefinition(), gc);
Expression rateXExp = getIdentifierSubstitutions(new Expression(velXParam, pointKinematics.getNameScope()), velXParam.getUnitDefinition(), gc);
OdeEquation odeX = new OdeEquation(posXVar, initXExp, rateXExp);
pointSubdomain.addEquation(odeX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(iniPosXParam, gc), getIdentifierSubstitutions(new Expression(iniPosXParam.getExpression()), iniPosXParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXParam, gc), getIdentifierSubstitutions(new Expression(velXParam.getExpression()), velXParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXQuantity, gc), getIdentifierSubstitutions(new Expression(velXParam, pointKinematics.getNameScope()), velXQuantity.getUnitDefinition(), gc), gc));
pointSubdomain.setPositionX(getIdentifierSubstitutions(new Expression(posXQuantity, simContext.getNameScope()), posXQuantity.getUnitDefinition(), gc));
}
if (simContext.getGeometry().getDimension() >= 2) {
PointVariable posYVar = new PointVariable(getMathSymbol(posYQuantity, gc), domain);
varHash.addVariable(posYVar);
Expression initYExp = getIdentifierSubstitutions(new Expression(iniPosYParam, pointKinematics.getNameScope()), iniPosYParam.getUnitDefinition(), gc);
Expression rateYExp = getIdentifierSubstitutions(new Expression(velYParam, pointKinematics.getNameScope()), velYParam.getUnitDefinition(), gc);
OdeEquation odeY = new OdeEquation(posYVar, initYExp, rateYExp);
pointSubdomain.addEquation(odeY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(iniPosYParam, gc), getIdentifierSubstitutions(new Expression(iniPosYParam.getExpression()), iniPosYParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYParam, gc), getIdentifierSubstitutions(new Expression(velYParam.getExpression()), velYParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYQuantity, gc), getIdentifierSubstitutions(new Expression(velYParam, pointKinematics.getNameScope()), velYQuantity.getUnitDefinition(), gc), gc));
pointSubdomain.setPositionY(getIdentifierSubstitutions(new Expression(posYQuantity, simContext.getNameScope()), posYQuantity.getUnitDefinition(), gc));
}
if (simContext.getGeometry().getDimension() == 3) {
PointVariable posZVar = new PointVariable(getMathSymbol(posZQuantity, gc), domain);
varHash.addVariable(posZVar);
Expression initZExp = getIdentifierSubstitutions(new Expression(iniPosZParam, pointKinematics.getNameScope()), iniPosZParam.getUnitDefinition(), gc);
Expression rateZExp = getIdentifierSubstitutions(new Expression(velZParam, pointKinematics.getNameScope()), velZParam.getUnitDefinition(), gc);
OdeEquation odeZ = new OdeEquation(posZVar, initZExp, rateZExp);
pointSubdomain.addEquation(odeZ);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(iniPosZParam, gc), getIdentifierSubstitutions(new Expression(iniPosZParam.getExpression()), iniPosZParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZParam, gc), getIdentifierSubstitutions(new Expression(velZParam.getExpression()), velZParam.getUnitDefinition(), gc), gc));
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZQuantity, gc), getIdentifierSubstitutions(new Expression(velZParam, pointKinematics.getNameScope()), velZQuantity.getUnitDefinition(), gc), gc));
pointSubdomain.setPositionZ(getIdentifierSubstitutions(new Expression(posZQuantity, simContext.getNameScope()), posZQuantity.getUnitDefinition(), gc));
}
if (simContext.getGeometry().getDimension() == 1) {
Expression signum_posX_minus_X = Expression.function(FunctionType.MIN, new Expression(1.0), Expression.function(FunctionType.MAX, Expression.mult(new Expression(1e10), posX_minux_X), new Expression(-1)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(signum_posX_minus_X, dirXQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
Expression abs_X_minux_posX = Expression.function(FunctionType.ABS, posX_minux_X);
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(abs_X_minux_posX, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
if (simContext.getGeometry().getDimension() == 2) {
Expression DX2 = Expression.mult(posX_minux_X, posX_minux_X);
Expression DY2 = Expression.mult(posY_minux_Y, posY_minux_Y);
Expression sqrt_DX2_DY2 = Expression.function(FunctionType.SQRT, Expression.add(DX2, DY2));
Expression dirX = Expression.div(posX_minux_X, Expression.add(sqrt_DX2_DY2, new Expression(1e-8)));
Expression dirY = Expression.div(posY_minux_Y, Expression.add(sqrt_DX2_DY2, new Expression(1e-8)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(dirX, dirXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirYQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Y);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirYQuantity, gc), getIdentifierSubstitutions(dirY, dirYQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(sqrt_DX2_DY2, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
if (simContext.getGeometry().getDimension() == 3) {
Expression DX2 = Expression.mult(posX_minux_X, posX_minux_X);
Expression DY2 = Expression.mult(posY_minux_Y, posY_minux_Y);
Expression DZ2 = Expression.mult(posZ_minux_Z, posZ_minux_Z);
Expression sqrt_DX2_DY2_DZ2 = Expression.function(FunctionType.SQRT, Expression.add(DX2, DY2, DZ2));
Expression dirX = Expression.div(posX_minux_X, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
Expression dirY = Expression.div(posY_minux_Y, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
Expression dirZ = Expression.div(posZ_minux_Z, Expression.add(sqrt_DX2_DY2_DZ2, new Expression(1e-8)));
if (bDirection) {
SpatialQuantity dirXQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.X);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirXQuantity, gc), getIdentifierSubstitutions(dirX, dirXQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirYQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Y);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirYQuantity, gc), getIdentifierSubstitutions(dirY, dirYQuantity.getUnitDefinition(), gc), gc));
SpatialQuantity dirZQuantity = pointObject.getSpatialQuantity(QuantityCategory.DirectionToPoint, QuantityComponent.Z);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(dirZQuantity, gc), getIdentifierSubstitutions(dirZ, dirZQuantity.getUnitDefinition(), gc), gc));
}
if (bDistance) {
SpatialQuantity distanceQuantity = pointObject.getSpatialQuantity(QuantityCategory.PointDistanceMap, QuantityComponent.Scalar);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(distanceQuantity, gc), getIdentifierSubstitutions(sqrt_DX2_DY2_DZ2, distanceQuantity.getUnitDefinition(), gc), gc));
}
}
} else {
throw new MappingException(pointKinematics.getDescription() + " process defined for pointObject '" + pointObject.getName() + "' but Position and Velocity not enabled");
}
} else {
throw new MappingException("expecting 1 location or kinematics process for point '" + pointObject.getName() + "'");
}
} else if (spatialObject instanceof SurfaceRegionObject) {
SurfaceRegionObject surfaceRegionObject = (SurfaceRegionObject) spatialObject;
SubVolume insideSubvolume = surfaceRegionObject.getInsideSubVolume();
SubVolume outsideSubvolume = surfaceRegionObject.getOutsideSubVolume();
SurfaceClass surfaceClass = simContext.getGeometry().getGeometrySurfaceDescription().getSurfaceClass(insideSubvolume, outsideSubvolume);
MembraneSubdomainContext memSubdomainContext = null;
for (MembraneSubdomainContext context : membraneSubdomainContexts) {
if (context.surfaceClass == surfaceClass) {
memSubdomainContext = context;
}
}
//
// if true, have to solve for this category
//
boolean bNormal = surfaceRegionObject.isQuantityCategoryEnabled(QuantityCategory.Normal);
boolean bVelocity = surfaceRegionObject.isQuantityCategoryEnabled(QuantityCategory.SurfaceVelocity);
boolean bDistance = surfaceRegionObject.isQuantityCategoryEnabled(QuantityCategory.SurfaceDistanceMap);
boolean bDirection = surfaceRegionObject.isQuantityCategoryEnabled(QuantityCategory.DirectionToSurface);
boolean bSize = surfaceRegionObject.isQuantityCategoryEnabled(QuantityCategory.SurfaceSize);
if (bVelocity) {
ArrayList<SurfaceKinematics> surfaceKinematicsList = new ArrayList<SurfaceKinematics>();
for (SpatialProcess spatialProcess : simContext.getSpatialProcesses()) {
if (spatialProcess instanceof SurfaceKinematics && ((SurfaceKinematics) spatialProcess).getSurfaceRegionObject() == surfaceRegionObject) {
surfaceKinematicsList.add((SurfaceKinematics) spatialProcess);
}
}
if (surfaceKinematicsList.size() == 1) {
SurfaceKinematics surfaceKinematics = surfaceKinematicsList.get(0);
if (simContext.getGeometry().getDimension() >= 1) {
SpatialQuantity velXQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.SurfaceVelocity, QuantityComponent.X);
LocalParameter velXParam = surfaceKinematics.getParameter(SpatialProcessParameterType.SurfaceVelocityX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXParam, surfaceClass), getIdentifierSubstitutions(velXParam.getExpression(), velXParam.getUnitDefinition(), surfaceClass), surfaceClass));
Expression velXExp = new Expression(velXParam, surfaceKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXQuantity, surfaceClass), getIdentifierSubstitutions(velXExp, velXQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
if (bNormal) {
SpatialQuantity normXQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.Normal, QuantityComponent.X);
Expression normXExp = new Expression(MathFunctionDefinitions.FUNCTION_normalX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(normXQuantity, surfaceClass), getIdentifierSubstitutions(normXExp, normXQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
}
}
if (simContext.getGeometry().getDimension() >= 2) {
SpatialQuantity velYQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.SurfaceVelocity, QuantityComponent.Y);
LocalParameter velYParam = surfaceKinematics.getParameter(SpatialProcessParameterType.SurfaceVelocityY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYParam, surfaceClass), getIdentifierSubstitutions(velYParam.getExpression(), velYParam.getUnitDefinition(), surfaceClass), surfaceClass));
Expression velYExp = new Expression(velYParam, surfaceKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYQuantity, surfaceClass), getIdentifierSubstitutions(velYExp, velYQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
if (bNormal) {
SpatialQuantity normYQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.Normal, QuantityComponent.Y);
Expression normYExp = new Expression(MathFunctionDefinitions.FUNCTION_normalY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(normYQuantity, surfaceClass), getIdentifierSubstitutions(normYExp, normYQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
}
}
if (simContext.getGeometry().getDimension() >= 3) {
SpatialQuantity velZQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.SurfaceVelocity, QuantityComponent.Z);
LocalParameter velZParam = surfaceKinematics.getParameter(SpatialProcessParameterType.SurfaceVelocityZ);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZParam, surfaceClass), getIdentifierSubstitutions(velZParam.getExpression(), velZParam.getUnitDefinition(), surfaceClass), surfaceClass));
Expression velYExp = new Expression(velZParam, surfaceKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZQuantity, surfaceClass), getIdentifierSubstitutions(velYExp, velZQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
if (bNormal) {
SpatialQuantity normZQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.Normal, QuantityComponent.Z);
// MathFunctionDefinitions.FUNCTION_normalZ);
Expression normZExp = new Expression("normalZ_not_implemented()");
varHash.addVariable(newFunctionOrConstant(getMathSymbol(normZQuantity, surfaceClass), getIdentifierSubstitutions(normZExp, normZQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
}
}
} else {
throw new MappingException("expecting 1 Surface Kinematics process for Surface Object '" + surfaceRegionObject.getName() + "'");
}
}
if (bSize) {
SpatialQuantity sizeQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.SurfaceSize, QuantityComponent.Scalar);
String funcName = MathFunctionDefinitions.Function_regionArea_current.getFunctionName();
Expression sizeExp = Expression.function(funcName, new Expression[] { new Expression("'" + surfaceClass.getName() + "'") });
varHash.addVariable(newFunctionOrConstant(getMathSymbol(sizeQuantity, surfaceClass), getIdentifierSubstitutions(sizeExp, sizeQuantity.getUnitDefinition(), surfaceClass), surfaceClass));
}
if (bDirection) {
SpatialQuantity directionXQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.DirectionToSurface, QuantityComponent.X);
SpatialQuantity directionYQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.DirectionToSurface, QuantityComponent.Y);
SpatialQuantity directionZQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.DirectionToSurface, QuantityComponent.Z);
for (SubVolume adjacentSubvolume : surfaceClass.getAdjacentSubvolumes()) {
Domain domain = new Domain(adjacentSubvolume);
CompartmentSubDomain compSubdomain = mathDesc.getCompartmentSubDomain(adjacentSubvolume.getName());
if (simContext.getGeometry().getDimension() >= 1) {
String name = adjacentSubvolume.getName() + "_dirX_" + memSubdomainContext.membraneSubdomain.getName();
LocalizedDirectionToMembraneQuantity localDirectionXQuantity = addLocalizedDirectionToMembraneQuantity(name, surfaceClass, adjacentSubvolume, QuantityComponent.X);
VolVariable distanceVar = new VolVariable(getMathSymbol(localDirectionXQuantity, adjacentSubvolume), domain);
varHash.addVariable(distanceVar);
ComputeMembraneMetricEquation membraneMetricEquation = new ComputeMembraneMetricEquation(distanceVar, MembraneMetricComponent.directionToMembraneX);
membraneMetricEquation.setTargetMembraneName(memSubdomainContext.membraneSubdomain.getName());
compSubdomain.addEquation(membraneMetricEquation);
}
if (simContext.getGeometry().getDimension() >= 2) {
String name = adjacentSubvolume.getName() + "_dirY_" + memSubdomainContext.membraneSubdomain.getName();
LocalizedDirectionToMembraneQuantity localDirectionYQuantity = addLocalizedDirectionToMembraneQuantity(name, surfaceClass, adjacentSubvolume, QuantityComponent.Y);
VolVariable distanceVar = new VolVariable(getMathSymbol(localDirectionYQuantity, adjacentSubvolume), domain);
varHash.addVariable(distanceVar);
ComputeMembraneMetricEquation membraneMetricEquation = new ComputeMembraneMetricEquation(distanceVar, MembraneMetricComponent.directionToMembraneY);
membraneMetricEquation.setTargetMembraneName(memSubdomainContext.membraneSubdomain.getName());
compSubdomain.addEquation(membraneMetricEquation);
}
if (simContext.getGeometry().getDimension() == 3) {
String name = adjacentSubvolume.getName() + "_dirZ_" + memSubdomainContext.membraneSubdomain.getName();
LocalizedDirectionToMembraneQuantity localDirectionZQuantity = addLocalizedDirectionToMembraneQuantity(name, surfaceClass, adjacentSubvolume, QuantityComponent.Z);
VolVariable distanceVar = new VolVariable(getMathSymbol(localDirectionZQuantity, adjacentSubvolume), domain);
varHash.addVariable(distanceVar);
ComputeMembraneMetricEquation membraneMetricEquation = new ComputeMembraneMetricEquation(distanceVar, MembraneMetricComponent.directionToMembraneZ);
membraneMetricEquation.setTargetMembraneName(memSubdomainContext.membraneSubdomain.getName());
compSubdomain.addEquation(membraneMetricEquation);
}
}
}
if (bDistance) {
SpatialQuantity distanceQuantity = surfaceRegionObject.getSpatialQuantity(QuantityCategory.SurfaceDistanceMap, QuantityComponent.Scalar);
for (SubVolume adjacentSubvolume : surfaceClass.getAdjacentSubvolumes()) {
String name = adjacentSubvolume.getName() + "_distanceTo_" + memSubdomainContext.membraneSubdomain.getName();
LocalizedDistanceToMembraneQuantity localDistanceQuantity = addLocalizedDistanceToMembraneQuantity(name, surfaceClass, adjacentSubvolume);
CompartmentSubDomain compSubdomain = mathDesc.getCompartmentSubDomain(adjacentSubvolume.getName());
Domain domain = new Domain(adjacentSubvolume);
VolVariable distanceVar = new VolVariable(getMathSymbol(localDistanceQuantity, adjacentSubvolume), domain);
varHash.addVariable(distanceVar);
ComputeMembraneMetricEquation membraneMetricEquation = new ComputeMembraneMetricEquation(distanceVar, MembraneMetricComponent.distanceToMembrane);
membraneMetricEquation.setTargetMembraneName(memSubdomainContext.membraneSubdomain.getName());
compSubdomain.addEquation(membraneMetricEquation);
}
}
} else if (spatialObject instanceof VolumeRegionObject) {
VolumeRegionObject volumeRegionObject = (VolumeRegionObject) spatialObject;
SubVolume subvolume = volumeRegionObject.getSubVolume();
boolean bCentroid = volumeRegionObject.isQuantityCategoryEnabled(QuantityCategory.DirectionToSurface);
boolean bSize = volumeRegionObject.isQuantityCategoryEnabled(QuantityCategory.VolumeSize);
boolean bVelocity = volumeRegionObject.isQuantityCategoryEnabled(QuantityCategory.InteriorVelocity);
if (bVelocity) {
ArrayList<VolumeKinematics> volumeKinematicsList = new ArrayList<VolumeKinematics>();
for (SpatialProcess spatialProcess : simContext.getSpatialProcesses()) {
if (spatialProcess instanceof VolumeKinematics && ((VolumeKinematics) spatialProcess).getVolumeRegionObject() == volumeRegionObject) {
volumeKinematicsList.add((VolumeKinematics) spatialProcess);
}
}
if (volumeKinematicsList.size() == 1) {
VolumeKinematics volumeKinematics = volumeKinematicsList.get(0);
if (simContext.getGeometry().getDimension() >= 1) {
SpatialQuantity velXQuantity = volumeRegionObject.getSpatialQuantity(QuantityCategory.InteriorVelocity, QuantityComponent.X);
LocalParameter velXParam = volumeKinematics.getParameter(SpatialProcessParameterType.InternalVelocityX);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXParam, subvolume), getIdentifierSubstitutions(velXParam.getExpression(), velXParam.getUnitDefinition(), subvolume), subvolume));
Expression velXExp = new Expression(velXParam, volumeKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velXQuantity, subvolume), getIdentifierSubstitutions(velXExp, velXQuantity.getUnitDefinition(), subvolume), subvolume));
}
if (simContext.getGeometry().getDimension() >= 2) {
SpatialQuantity velYQuantity = volumeRegionObject.getSpatialQuantity(QuantityCategory.InteriorVelocity, QuantityComponent.Y);
LocalParameter velYParam = volumeKinematics.getParameter(SpatialProcessParameterType.InternalVelocityY);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYParam, subvolume), getIdentifierSubstitutions(velYParam.getExpression(), velYParam.getUnitDefinition(), subvolume), subvolume));
Expression velYExp = new Expression(velYParam, volumeKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velYQuantity, subvolume), getIdentifierSubstitutions(velYExp, velYQuantity.getUnitDefinition(), subvolume), subvolume));
}
if (simContext.getGeometry().getDimension() == 3) {
SpatialQuantity velZQuantity = volumeRegionObject.getSpatialQuantity(QuantityCategory.InteriorVelocity, QuantityComponent.Z);
LocalParameter velZParam = volumeKinematics.getParameter(SpatialProcessParameterType.InternalVelocityZ);
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZParam, subvolume), getIdentifierSubstitutions(velZParam.getExpression(), velZParam.getUnitDefinition(), subvolume), subvolume));
Expression velZExp = new Expression(velZParam, volumeKinematics.getNameScope());
varHash.addVariable(newFunctionOrConstant(getMathSymbol(velZQuantity, subvolume), getIdentifierSubstitutions(velZExp, velZQuantity.getUnitDefinition(), subvolume), subvolume));
}
} else {
throw new MappingException("expecting 1 Volume Kinematics process for Volume Object '" + volumeRegionObject.getName() + "'");
}
}
if (bSize) {
SpatialQuantity sizeQuantity = volumeRegionObject.getSpatialQuantity(QuantityCategory.VolumeSize, QuantityComponent.Scalar);
String funcName = MathFunctionDefinitions.Function_regionVolume_current.getFunctionName();
Expression sizeExp = Expression.function(funcName, new Expression[] { new Expression("'" + subvolume.getName() + "'") });
varHash.addVariable(newFunctionOrConstant(getMathSymbol(sizeQuantity, subvolume), getIdentifierSubstitutions(sizeExp, sizeQuantity.getUnitDefinition(), subvolume), subvolume));
}
if (bCentroid) {
throw new MappingException(QuantityCategory.Centroid.description + " not yet implemented in math generation");
}
}
}
}
Also used :
GeometryClass(cbit.vcell.geometry.GeometryClass)
PointLocation(cbit.vcell.mapping.spatial.processes.PointLocation)
SurfaceClass(cbit.vcell.geometry.SurfaceClass)
VolumeKinematics(cbit.vcell.mapping.spatial.processes.VolumeKinematics)
ArrayList(java.util.ArrayList)
PointSubDomain(cbit.vcell.math.PointSubDomain)
SpatialObject(cbit.vcell.mapping.spatial.SpatialObject)
PointObject(cbit.vcell.mapping.spatial.PointObject)
SpatialProcess(cbit.vcell.mapping.spatial.processes.SpatialProcess)
SubVolume(cbit.vcell.geometry.SubVolume)
ComputeMembraneMetricEquation(cbit.vcell.math.ComputeMembraneMetricEquation)
SpatialQuantity(cbit.vcell.mapping.spatial.SpatialObject.SpatialQuantity)
VolumeRegionObject(cbit.vcell.mapping.spatial.VolumeRegionObject)
VolVariable(cbit.vcell.math.VolVariable)
SurfaceKinematics(cbit.vcell.mapping.spatial.processes.SurfaceKinematics)
LocalParameter(cbit.vcell.mapping.ParameterContext.LocalParameter)
OdeEquation(cbit.vcell.math.OdeEquation)
Expression(cbit.vcell.parser.Expression)
CompartmentSubDomain(cbit.vcell.math.CompartmentSubDomain)
PointKinematics(cbit.vcell.mapping.spatial.processes.PointKinematics)
PointVariable(cbit.vcell.math.PointVariable)
CompartmentSubDomain(cbit.vcell.math.CompartmentSubDomain)
SubDomain(cbit.vcell.math.SubDomain)
PointSubDomain(cbit.vcell.math.PointSubDomain)
Domain(cbit.vcell.math.Variable.Domain)
MembraneSubDomain(cbit.vcell.math.MembraneSubDomain)
SurfaceRegionObject(cbit.vcell.mapping.spatial.SurfaceRegionObject)
Example 13 with SpatialObject
use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.
the class SimulationContext method getLocalEntries.
public void getLocalEntries(Map<String, SymbolTableEntry> entryMap) {
getModel().getEntries(entryMap);
for (SymbolTableEntry ste : fieldSimulationContextParameters) {
entryMap.put(ste.getName(), ste);
}
for (SymbolTableEntry ste : dataContext.getDataSymbols()) {
entryMap.put(ste.getName(), ste);
}
for (SpatialObject spatialObject : spatialObjects) {
for (SpatialQuantity spatialQuantity : spatialObject.getSpatialQuantities()) {
if (spatialQuantity.isEnabled()) {
entryMap.put(spatialQuantity.getName(), spatialQuantity);
}
}
}
entryMap.put(MathFunctionDefinitions.fieldFunctionDefinition.getName(), MathFunctionDefinitions.fieldFunctionDefinition);
}
Also used :
SymbolTableEntry(cbit.vcell.parser.SymbolTableEntry)
GeneratedSpeciesSymbolTableEntry(cbit.vcell.mapping.NetworkTransformer.GeneratedSpeciesSymbolTableEntry)
SpatialQuantity(cbit.vcell.mapping.spatial.SpatialObject.SpatialQuantity)
SpatialObject(cbit.vcell.mapping.spatial.SpatialObject)
Example 14 with SpatialObject
use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.
the class SimulationContext method gatherIssues.
public void gatherIssues(IssueContext issueContext, List<Issue> issueVector, boolean bIgnoreMathDescription) {
// issueContext = issueContext.newChildContext(ContextType.SimContext, this);
if (applicationType.equals(Application.RULE_BASED_STOCHASTIC)) {
for (ReactionRuleSpec rrs : getReactionContext().getReactionRuleSpecs()) {
if (rrs.isExcluded()) {
continue;
}
ReactionRule rr = rrs.getReactionRule();
if (rr.getReactantPatterns().size() > 2) {
String message = "NFSim doesn't support more than 2 reactants within a reaction rule.";
issueVector.add(new Issue(rr, issueContext, IssueCategory.Identifiers, message, Issue.Severity.WARNING));
}
if (rr.isReversible() && rr.getProductPatterns().size() > 2) {
String message = "NFSim doesn't support more than 2 products within a reversible reaction rule.";
issueVector.add(new Issue(rr, issueContext, IssueCategory.Identifiers, message, Issue.Severity.WARNING));
}
}
for (ReactionSpec rrs : getReactionContext().getReactionSpecs()) {
if (rrs.isExcluded()) {
continue;
}
ReactionStep rs = rrs.getReactionStep();
if (rs.getNumReactants() > 2) {
String message = "NFSim doesn't support more than 2 reactants within a reaction step.";
issueVector.add(new Issue(rs, issueContext, IssueCategory.Identifiers, message, Issue.Severity.WARNING));
}
if (rs.isReversible() && rs.getNumProducts() > 2) {
String message = "NFSim doesn't support more than 2 products within a reversible reaction step.";
issueVector.add(new Issue(rs, issueContext, IssueCategory.Identifiers, message, Issue.Severity.WARNING));
}
}
// we give warning when we have plain reactions with participants with patterns;
// making rules from these may result in inconsistent interpretation for the constant rates
boolean isParticipantWithPattern = false;
for (ReactionSpec rrs : getReactionContext().getReactionSpecs()) {
if (rrs.isExcluded()) {
continue;
}
ReactionStep rs = rrs.getReactionStep();
for (Reactant r : rs.getReactants()) {
if (r.getSpeciesContext().hasSpeciesPattern()) {
isParticipantWithPattern = true;
break;
}
}
if (isParticipantWithPattern) {
break;
}
for (Product p : rs.getProducts()) {
if (p.getSpeciesContext().hasSpeciesPattern()) {
isParticipantWithPattern = true;
break;
}
}
if (isParticipantWithPattern) {
break;
}
}
if (isParticipantWithPattern) {
String message = SimulationContext.rateWarning2;
String tooltip = SimulationContext.rateWarning;
issueVector.add(new Issue(this, issueContext, IssueCategory.Identifiers, message, tooltip, Issue.Severity.WARNING));
}
for (Structure struct : getModel().getStructures()) {
String name = struct.getName();
if (!name.equals(TokenMangler.fixTokenStrict(name))) {
String msg = "'" + name + "' not legal identifier for rule-based stochastic applications, try '" + TokenMangler.fixTokenStrict(name) + "'.";
issueVector.add(new Issue(struct, issueContext, IssueCategory.Identifiers, msg, Issue.Severity.ERROR));
}
}
}
if (fieldBioEvents != null) {
for (BioEvent bioEvent : fieldBioEvents) {
bioEvent.gatherIssues(issueContext, issueVector);
}
}
if (spatialObjects != null) {
for (SpatialObject spatialObject : spatialObjects) {
spatialObject.gatherIssues(issueContext, issueVector);
}
}
if (spatialProcesses != null) {
for (SpatialProcess spatialProcess : spatialProcesses) {
spatialProcess.gatherIssues(issueContext, issueVector);
}
}
if (fieldRateRules != null) {
// to avoid duplicated Issues for the same problem
Set<String> alreadyIssue = new HashSet<>();
for (RateRule rr : fieldRateRules) {
rr.gatherIssues(issueContext, issueVector, alreadyIssue);
}
}
if (fieldAssignmentRules != null) {
Set<String> alreadyIssue = new HashSet<>();
for (AssignmentRule ar : fieldAssignmentRules) {
ar.gatherIssues(issueContext, issueVector, alreadyIssue);
}
}
if (applicationType.equals(Application.NETWORK_DETERMINISTIC) && getModel().getRbmModelContainer().getMolecularTypeList().size() > 0) {
// we're going to use network transformer to flatten (or we already did)
if (isInsufficientIterations()) {
issueVector.add(new Issue(this, issueContext, IssueCategory.RbmNetworkConstraintsBad, IssueInsufficientIterations, Issue.Severity.WARNING));
}
if (isInsufficientMaxMolecules()) {
issueVector.add(new Issue(this, issueContext, IssueCategory.RbmNetworkConstraintsBad, IssueInsufficientMolecules, Issue.Severity.WARNING));
}
}
Geometry geo = getGeometryContext().getGeometry();
int dimension = geo.getDimension();
if (dimension != 0) {
for (ReactionSpec rrs : getReactionContext().getReactionSpecs()) {
if (rrs.isExcluded()) {
continue;
}
ReactionStep rs = rrs.getReactionStep();
if (rs.getStructure() instanceof Membrane) {
continue;
}
// for spatial applications
// we look for reactions where reactants and products are in more than one compartments
// if such reactions are not on a membrane, we issue a warning
Set<Structure> features = new HashSet<>();
for (Reactant r : rs.getReactants()) {
Structure struct = r.getStructure();
if (struct instanceof Feature) {
features.add(struct);
}
}
for (Product p : rs.getProducts()) {
Structure struct = p.getStructure();
if (struct instanceof Feature) {
features.add(struct);
}
}
if (features.size() > 1) {
String message = "Reaction must be situated on a membrane (spatial application present)";
String tooltip = "Spatial application '" + getName() + "' requires that reactions between compartments must be situated on a membrane.";
issueVector.add(new Issue(rs, issueContext, IssueCategory.Identifiers, message, tooltip, Issue.Severity.WARNING));
}
}
}
getReactionContext().gatherIssues(issueContext, issueVector);
getGeometryContext().gatherIssues(issueContext, issueVector);
if (fieldAnalysisTasks != null) {
for (AnalysisTask analysisTask : fieldAnalysisTasks) {
analysisTask.gatherIssues(issueContext, issueVector);
}
}
getOutputFunctionContext().gatherIssues(issueContext, issueVector);
getMicroscopeMeasurement().gatherIssues(issueContext, issueVector);
if (getMathDescription() != null && !bIgnoreMathDescription) {
getMathDescription().gatherIssues(issueContext, issueVector);
}
if (networkConstraints == null) {
// issueVector.add(new Issue(this, issueContext, IssueCategory.RbmNetworkConstraintsBad, "Network Constraints is null", Issue.Severity.ERROR));
} else {
networkConstraints.gatherIssues(issueContext, issueVector);
}
}
Also used :
Issue(org.vcell.util.Issue)
ReactionRule(cbit.vcell.model.ReactionRule)
Product(cbit.vcell.model.Product)
Reactant(cbit.vcell.model.Reactant)
Feature(cbit.vcell.model.Feature)
SpatialObject(cbit.vcell.mapping.spatial.SpatialObject)
Geometry(cbit.vcell.geometry.Geometry)
SpatialProcess(cbit.vcell.mapping.spatial.processes.SpatialProcess)
ReactionStep(cbit.vcell.model.ReactionStep)
AnalysisTask(cbit.vcell.modelopt.AnalysisTask)
Membrane(cbit.vcell.model.Membrane)
Structure(cbit.vcell.model.Structure)
HashSet(java.util.HashSet)
Example 15 with SpatialObject
use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.
the class XmlReader method getSimulationContext.
/**
* This method returns a SimulationContext from a XML representation.
* Creation date: (4/2/2001 3:19:01 PM)
* @return cbit.vcell.mapping.SimulationContext
* @param param org.jdom.Element
*/
private SimulationContext getSimulationContext(Element param, BioModel biomodel) throws XmlParseException {
// get the attributes
// name
String name = unMangle(param.getAttributeValue(XMLTags.NameAttrTag));
boolean bStoch = false;
boolean bRuleBased = false;
boolean bUseConcentration = true;
boolean bRandomizeInitCondition = false;
boolean bInsufficientIterations = false;
boolean bInsufficientMaxMolecules = false;
// default is true for now
boolean bMassConservationModelReduction = true;
NetworkConstraints nc = null;
Element ncElement = param.getChild(XMLTags.RbmNetworkConstraintsTag, vcNamespace);
if (ncElement != null) {
// one network constraint element
nc = getAppNetworkConstraints(ncElement, biomodel.getModel());
} else {
if (legacyNetworkConstraints != null) {
nc = legacyNetworkConstraints;
}
}
if ((param.getAttributeValue(XMLTags.StochAttrTag) != null) && (param.getAttributeValue(XMLTags.StochAttrTag).equals("true"))) {
bStoch = true;
}
if (bStoch) {
// stochastic and using concentration vs amount
if ((param.getAttributeValue(XMLTags.ConcentrationAttrTag) != null) && (param.getAttributeValue(XMLTags.ConcentrationAttrTag).equals("false"))) {
bUseConcentration = false;
}
// stochastic and randomizing initial conditions or not (for non-spatial)
if ((param.getAttributeValue(XMLTags.RandomizeInitConditionTag) != null) && (param.getAttributeValue(XMLTags.RandomizeInitConditionTag).equals("true"))) {
bRandomizeInitCondition = true;
}
}
if ((param.getAttributeValue(XMLTags.MassConservationModelReductionTag) != null) && (param.getAttributeValue(XMLTags.MassConservationModelReductionTag).equals("false"))) {
bMassConservationModelReduction = false;
}
if ((param.getAttributeValue(XMLTags.InsufficientIterationsTag) != null) && (param.getAttributeValue(XMLTags.InsufficientIterationsTag).equals("true"))) {
bInsufficientIterations = true;
}
if ((param.getAttributeValue(XMLTags.InsufficientMaxMoleculesTag) != null) && (param.getAttributeValue(XMLTags.InsufficientMaxMoleculesTag).equals("true"))) {
bInsufficientMaxMolecules = true;
}
if ((param.getAttributeValue(XMLTags.RuleBasedAttrTag) != null) && (param.getAttributeValue(XMLTags.RuleBasedAttrTag).equals("true"))) {
bRuleBased = true;
if ((param.getAttributeValue(XMLTags.ConcentrationAttrTag) != null) && (param.getAttributeValue(XMLTags.ConcentrationAttrTag).equals("false"))) {
bUseConcentration = false;
}
if ((param.getAttributeValue(XMLTags.RandomizeInitConditionTag) != null) && (param.getAttributeValue(XMLTags.RandomizeInitConditionTag).equals("true"))) {
// we propagate the flag but we don't use it for now
bRandomizeInitCondition = true;
}
}
// Retrieve Geometry
Geometry newgeometry = null;
try {
newgeometry = getGeometry(param.getChild(XMLTags.GeometryTag, vcNamespace));
} catch (Throwable e) {
e.printStackTrace();
String stackTrace = null;
try {
java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
java.io.PrintStream ps = new java.io.PrintStream(bos);
e.printStackTrace(ps);
ps.flush();
bos.flush();
stackTrace = new String(bos.toByteArray());
ps.close();
bos.close();
} catch (Exception e2) {
// do Nothing
}
throw new XmlParseException("A Problem occurred while retrieving the geometry for the simulationContext " + name, e);
}
// Retrieve MathDescription(if there is no MathDescription skip it)
MathDescription newmathdesc = null;
Element xmlMathDescription = param.getChild(XMLTags.MathDescriptionTag, vcNamespace);
if (xmlMathDescription != null) {
newmathdesc = getMathDescription(xmlMathDescription, newgeometry);
if (biomodel.getVersion() != null && biomodel.getVersion().getVersionKey() != null) {
Long lpcBMKey = Long.valueOf(biomodel.getVersion().getVersionKey().toString());
// MathDescription.originalHasLowPrecisionConstants.remove(lpcBMKey);
try {
Enumeration<Constant> myenum = newmathdesc.getConstants();
while (myenum.hasMoreElements()) {
Constant nextElement = myenum.nextElement();
String name2 = nextElement.getName();
ReservedSymbol reservedSymbolByName = biomodel.getModel().getReservedSymbolByName(name2);
if (reservedSymbolByName != null && nextElement.getExpression() != null && reservedSymbolByName.getExpression() != null) {
// System.out.println(name2);
boolean equals = nextElement.getExpression().infix().equals(reservedSymbolByName.getExpression().infix());
// System.out.println("--"+" "+nextElement.getExpression().infix() +" "+reservedSymbolByName.getExpression().infix()+" "+equals);
if (!equals) {
TreeSet<String> treeSet = MathDescription.originalHasLowPrecisionConstants.get(lpcBMKey);
if (treeSet == null) {
treeSet = new TreeSet<>();
MathDescription.originalHasLowPrecisionConstants.put(lpcBMKey, treeSet);
}
treeSet.add(newmathdesc.getVersion().getVersionKey().toString());
break;
}
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// Retrieve Version (Metada)
Version version = getVersion(param.getChild(XMLTags.VersionTag, vcNamespace));
// ------ Create SimContext ------
SimulationContext newsimcontext = null;
try {
newsimcontext = new SimulationContext(biomodel.getModel(), newgeometry, newmathdesc, version, bStoch, bRuleBased);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A propertyveto exception was generated when creating the new SimulationContext " + name, e);
}
// set attributes
try {
newsimcontext.setName(name);
// Add annotation
String annotation = param.getChildText(XMLTags.AnnotationTag, vcNamespace);
if (annotation != null) /* && annotation.length()>0*/
{
newsimcontext.setDescription(unMangle(annotation));
}
// set if using concentration
newsimcontext.setUsingConcentration(bUseConcentration);
// set mass conservation model reduction flag
newsimcontext.setUsingMassConservationModelReduction(bMassConservationModelReduction);
// set if randomizing init condition or not (for stochastic applications
if (bStoch) {
newsimcontext.setRandomizeInitConditions(bRandomizeInitCondition);
}
if (bInsufficientIterations) {
newsimcontext.setInsufficientIterations(bInsufficientIterations);
}
if (bInsufficientMaxMolecules) {
newsimcontext.setInsufficientMaxMolecules(bInsufficientMaxMolecules);
}
if (nc != null) {
newsimcontext.setNetworkConstraints(nc);
}
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("Exception", e);
}
String tempchar = param.getAttributeValue(XMLTags.CharacteristicSizeTag);
if (tempchar != null) {
try {
newsimcontext.setCharacteristicSize(Double.valueOf(tempchar));
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A PropertyVetoException was fired when setting the CharacteristicSize " + tempchar, e);
}
}
// Retrieve DataContext
Element dataContextElement = param.getChild(XMLTags.DataContextTag, vcNamespace);
if (dataContextElement != null) {
DataContext dataContext = newsimcontext.getDataContext();
ArrayList<DataSymbol> dataSymbols = getDataSymbols(dataContextElement, dataContext, newsimcontext.getModel().getUnitSystem());
for (int i = 0; i < dataSymbols.size(); i++) {
dataContext.addDataSymbol(dataSymbols.get(i));
}
}
// Retrieve spatialObjects and add to simContext
Element spatialObjectsElement = param.getChild(XMLTags.SpatialObjectsTag, vcNamespace);
if (spatialObjectsElement != null) {
SpatialObject[] spatialObjects = getSpatialObjects(newsimcontext, spatialObjectsElement);
try {
newsimcontext.setSpatialObjects(spatialObjects);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding spatialObjects to simulationContext", e);
}
}
// Retrieve application parameters and add to simContext
Element appParamsElement = param.getChild(XMLTags.ApplicationParametersTag, vcNamespace);
if (appParamsElement != null) {
SimulationContextParameter[] appParameters = getSimulationContextParams(appParamsElement, newsimcontext);
try {
newsimcontext.setSimulationContextParameters(appParameters);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding application parameters to simulationContext", e);
}
}
//
// -Process the GeometryContext-
//
Element tempelement = param.getChild(XMLTags.GeometryContextTag, vcNamespace);
LinkedList<StructureMapping> maplist = new LinkedList<StructureMapping>();
// Retrieve FeatureMappings
Iterator<Element> iterator = tempelement.getChildren(XMLTags.FeatureMappingTag, vcNamespace).iterator();
while (iterator.hasNext()) {
maplist.add(getFeatureMapping((Element) (iterator.next()), newsimcontext));
}
// Retrieve MembraneMappings
iterator = tempelement.getChildren(XMLTags.MembraneMappingTag, vcNamespace).iterator();
while (iterator.hasNext()) {
maplist.add(getMembraneMapping((Element) (iterator.next()), newsimcontext));
}
// Add these mappings to the internal geometryContext of this simcontext
StructureMapping[] structarray = new StructureMapping[maplist.size()];
maplist.toArray(structarray);
try {
newsimcontext.getGeometryContext().setStructureMappings(structarray);
newsimcontext.getGeometryContext().refreshStructureMappings();
newsimcontext.refreshSpatialObjects();
} catch (MappingException e) {
e.printStackTrace();
throw new XmlParseException("A MappingException was fired when trying to set the StructureMappings array to the Geometrycontext of the SimContext " + name, e);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A PopertyVetoException was fired when trying to set the StructureMappings array to the Geometrycontext of the SimContext " + name, e);
}
//
// -Process the ReactionContext-
//
tempelement = param.getChild(XMLTags.ReactionContextTag, vcNamespace);
// Retrieve ReactionSpecs
List<Element> children = tempelement.getChildren(XMLTags.ReactionSpecTag, vcNamespace);
if (children.size() != 0) {
if (children.size() != biomodel.getModel().getReactionSteps().length) {
throw new XmlParseException("The number of reactions is not consistent.\n" + "Model reactions=" + biomodel.getModel().getReactionSteps().length + ", Reaction specs=" + children.size());
}
// *NOTE: Importing a model from other languages does not generates reaction specs.
// A more robust code will read the reactions in the source file and replace the ones created by the default by the VirtualCell framework.
ReactionSpec[] reactionSpecs = new ReactionSpec[children.size()];
int rSpecCounter = 0;
for (Element rsElement : children) {
reactionSpecs[rSpecCounter] = getReactionSpec(rsElement, newsimcontext);
rSpecCounter++;
}
try {
newsimcontext.getReactionContext().setReactionSpecs(reactionSpecs);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A PropertyVetoException occurred while setting the ReactionSpecs to the SimContext " + name, e);
}
}
// Retrieve ReactionRuleSpecs
Element reactionRuleSpecsElement = tempelement.getChild(XMLTags.ReactionRuleSpecsTag, vcNamespace);
if (reactionRuleSpecsElement != null) {
ReactionRuleSpec[] reactionRuleSpecs = getReactionRuleSpecs(newsimcontext, reactionRuleSpecsElement);
try {
newsimcontext.getReactionContext().setReactionRuleSpecs(reactionRuleSpecs);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A PropertyVetoException occurred while setting the ReactionRuleSpecs to the SimContext " + name, e);
}
}
children = tempelement.getChildren(XMLTags.SpeciesContextSpecTag, vcNamespace);
getSpeciesContextSpecs(children, newsimcontext.getReactionContext(), biomodel.getModel());
// Retrieve output functions
Element outputFunctionsElement = param.getChild(XMLTags.OutputFunctionsTag, vcNamespace);
if (outputFunctionsElement != null) {
ArrayList<AnnotatedFunction> outputFunctions = getOutputFunctions(outputFunctionsElement);
try {
// construct OutputFnContext from mathDesc in newSimContext and add output functions that were read in from XML.
OutputFunctionContext outputFnContext = newsimcontext.getOutputFunctionContext();
for (AnnotatedFunction outputFunction : outputFunctions) {
outputFnContext.addOutputFunction(outputFunction);
}
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException(e);
}
}
// Retrieve Electrical context
org.jdom.Element electElem = param.getChild(XMLTags.ElectricalContextTag, vcNamespace);
// this information is optional!
if (electElem != null) {
if (electElem.getChild(XMLTags.ClampTag, vcNamespace) != null) {
// read clamp
ElectricalStimulus[] electArray = new ElectricalStimulus[1];
electArray[0] = getElectricalStimulus(electElem.getChild(XMLTags.ClampTag, vcNamespace), newsimcontext);
try {
newsimcontext.setElectricalStimuli(electArray);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException(e);
}
}
// read ground electrode
if (electElem.getChild(XMLTags.ElectrodeTag, vcNamespace) != null) {
Electrode groundElectrode = getElectrode(electElem.getChild(XMLTags.ElectrodeTag, vcNamespace), newsimcontext);
try {
newsimcontext.setGroundElectrode(groundElectrode);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException(e);
}
}
}
// Retrieve (bio)events and add to simContext
tempelement = param.getChild(XMLTags.BioEventsTag, vcNamespace);
if (tempelement != null) {
BioEvent[] bioEvents = getBioEvents(newsimcontext, tempelement);
try {
newsimcontext.setBioEvents(bioEvents);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding events to simulationContext", e);
}
}
// Retrieve spatialProcesses and add to simContext
tempelement = param.getChild(XMLTags.SpatialProcessesTag, vcNamespace);
if (tempelement != null) {
SpatialProcess[] spatialProcesses = getSpatialProcesses(newsimcontext, tempelement);
try {
newsimcontext.setSpatialProcesses(spatialProcesses);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding spatialProcesses to simulationContext", e);
}
}
// Retrieve rate rules and add to simContext
tempelement = param.getChild(XMLTags.RateRulesTag, vcNamespace);
if (tempelement != null) {
RateRule[] rateRules = getRateRules(newsimcontext, tempelement);
try {
newsimcontext.setRateRules(rateRules);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding rate rules to simulationContext", e);
}
}
tempelement = param.getChild(XMLTags.AssignmentRulesTag, vcNamespace);
if (tempelement != null) {
AssignmentRule[] assignmentRules = getAssignmentRules(newsimcontext, tempelement);
try {
newsimcontext.setAssignmentRules(assignmentRules);
} catch (PropertyVetoException e) {
e.printStackTrace(System.out);
throw new RuntimeException("Error adding assignment rules to simulationContext", e);
}
}
org.jdom.Element analysisTaskListElement = param.getChild(XMLTags.AnalysisTaskListTag, vcNamespace);
if (analysisTaskListElement != null) {
children = analysisTaskListElement.getChildren(XMLTags.ParameterEstimationTaskTag, vcNamespace);
if (children.size() != 0) {
Vector<ParameterEstimationTask> analysisTaskList = new Vector<ParameterEstimationTask>();
for (Element parameterEstimationTaskElement : children) {
try {
ParameterEstimationTask parameterEstimationTask = ParameterEstimationTaskXMLPersistence.getParameterEstimationTask(parameterEstimationTaskElement, newsimcontext);
analysisTaskList.add(parameterEstimationTask);
} catch (Exception e) {
e.printStackTrace(System.out);
throw new XmlParseException("An Exception occurred when parsing AnalysisTasks of SimContext " + name, e);
}
}
try {
AnalysisTask[] analysisTasks = (AnalysisTask[]) BeanUtils.getArray(analysisTaskList, AnalysisTask.class);
newsimcontext.setAnalysisTasks(analysisTasks);
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("A PropertyVetoException occurred when setting the AnalysisTasks of the SimContext " + name, e);
}
}
}
// Microscope Measurement
org.jdom.Element element = param.getChild(XMLTags.MicroscopeMeasurement, vcNamespace);
if (element != null) {
getMicroscopeMeasurement(element, newsimcontext);
}
for (GeometryClass gc : newsimcontext.getGeometry().getGeometryClasses()) {
try {
StructureSizeSolver.updateUnitStructureSizes(newsimcontext, gc);
} catch (Exception e) {
e.printStackTrace();
}
}
newsimcontext.getGeometryContext().enforceHierarchicalBoundaryConditions(newsimcontext.getModel().getStructureTopology());
return newsimcontext;
}
Also used :
MathDescription(cbit.vcell.math.MathDescription)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
Version(org.vcell.util.document.Version)
RedistributionVersion(cbit.vcell.solvers.mb.MovingBoundarySolverOptions.RedistributionVersion)
SimulationVersion(org.vcell.util.document.SimulationVersion)
VCellSoftwareVersion(org.vcell.util.document.VCellSoftwareVersion)
SpatialProcess(cbit.vcell.mapping.spatial.processes.SpatialProcess)
RateRule(cbit.vcell.mapping.RateRule)
Vector(java.util.Vector)
AnnotatedFunction(cbit.vcell.solver.AnnotatedFunction)
Electrode(cbit.vcell.mapping.Electrode)
ReactionSpec(cbit.vcell.mapping.ReactionSpec)
ReactionRuleSpec(cbit.vcell.mapping.ReactionRuleSpec)
AssignmentRule(cbit.vcell.mapping.AssignmentRule)
LinkedList(java.util.LinkedList)
PropertyVetoException(java.beans.PropertyVetoException)
OutputFunctionContext(cbit.vcell.solver.OutputFunctionContext)
FieldDataSymbol(cbit.vcell.data.FieldDataSymbol)
DataSymbol(cbit.vcell.data.DataSymbol)
ParameterEstimationTask(cbit.vcell.modelopt.ParameterEstimationTask)
AnalysisTask(cbit.vcell.modelopt.AnalysisTask)
NetworkConstraints(org.vcell.model.rbm.NetworkConstraints)
GeometryClass(cbit.vcell.geometry.GeometryClass)
MacroscopicRateConstant(cbit.vcell.math.MacroscopicRateConstant)
Constant(cbit.vcell.math.Constant)
Element(org.jdom.Element)
ReservedSymbol(cbit.vcell.model.Model.ReservedSymbol)
StructureMapping(cbit.vcell.mapping.StructureMapping)
SpatialObject(cbit.vcell.mapping.spatial.SpatialObject)
DataContext(cbit.vcell.data.DataContext)
SimulationContext(cbit.vcell.mapping.SimulationContext)
SimulationContextParameter(cbit.vcell.mapping.SimulationContext.SimulationContextParameter)
GeometryException(cbit.vcell.geometry.GeometryException)
MathFormatException(cbit.vcell.math.MathFormatException)
MappingException(cbit.vcell.mapping.MappingException)
PropertyVetoException(java.beans.PropertyVetoException)
ImageException(cbit.image.ImageException)
ExpressionBindingException(cbit.vcell.parser.ExpressionBindingException)
ModelException(cbit.vcell.model.ModelException)
DataConversionException(org.jdom.DataConversionException)
ExpressionException(cbit.vcell.parser.ExpressionException)
MathException(cbit.vcell.math.MathException)
Geometry(cbit.vcell.geometry.Geometry)
ElectricalStimulus(cbit.vcell.mapping.ElectricalStimulus)
BioEvent(cbit.vcell.mapping.BioEvent)
Element(org.jdom.Element)
Aggregations
SpatialObject (cbit.vcell.mapping.spatial.SpatialObject)29
SpatialProcess (cbit.vcell.mapping.spatial.processes.SpatialProcess)18
SurfaceRegionObject (cbit.vcell.mapping.spatial.SurfaceRegionObject)9
VolumeRegionObject (cbit.vcell.mapping.spatial.VolumeRegionObject)9
BioEvent (cbit.vcell.mapping.BioEvent)8
SimulationContext (cbit.vcell.mapping.SimulationContext)8
PointObject (cbit.vcell.mapping.spatial.PointObject)8
AssignmentRule (cbit.vcell.mapping.AssignmentRule)7
RateRule (cbit.vcell.mapping.RateRule)7
ReactionStep (cbit.vcell.model.ReactionStep)7
Geometry (cbit.vcell.geometry.Geometry)6
SimulationContextParameter (cbit.vcell.mapping.SimulationContext.SimulationContextParameter)6
SpeciesContextSpec (cbit.vcell.mapping.SpeciesContextSpec)6
StructureMapping (cbit.vcell.mapping.StructureMapping)6
ArrayList (java.util.ArrayList)6
Element (org.jdom.Element)6
ReactionRule (cbit.vcell.model.ReactionRule)5
SpeciesContext (cbit.vcell.model.SpeciesContext)5
NetworkConstraints (org.vcell.model.rbm.NetworkConstraints)5
BioModel (cbit.vcell.biomodel.BioModel)4
