use of cbit.vcell.mapping.spatial.processes.SpatialProcess in project vcell by virtualcell.
the class DefaultScrollTableCellRenderer method isMatchWithSelectedObject.
private boolean isMatchWithSelectedObject(JTable table, int row) {
SpatialProcessTableModel tm = (SpatialProcessTableModel) table.getModel();
SelectionManager selectionManager = tm.getSelectionManager();
boolean found = false;
if (selectionManager != null) {
for (Object ob : selectionManager.getSelectedObjects()) {
if (ob instanceof SpatialObject) {
// a SpatialObject selected
List<SpatialProcess> spList = ((SpatialObject) ob).getRelatedSpatialProcesses();
for (SpatialProcess theirs : spList) {
SpatialProcess ours = tm.getValueAt(row);
if (ours == theirs) {
found = true;
break;
}
}
}
if (found == true) {
break;
}
}
}
return found;
}
use of cbit.vcell.mapping.spatial.processes.SpatialProcess in project vcell by virtualcell.
the class DefaultScrollTableCellRenderer method isMatchWithSelectedProcess.
private boolean isMatchWithSelectedProcess(JTable table, int row) {
SpatialObjectTableModel tm = (SpatialObjectTableModel) table.getModel();
SelectionManager selectionManager = tm.getSelectionManager();
boolean found = false;
if (selectionManager != null) {
for (Object ob : selectionManager.getSelectedObjects()) {
if (ob instanceof SpatialProcess) {
// a SpatialProcess selected
List<SpatialObject> soList = ((SpatialProcess) ob).getSpatialObjects();
for (SpatialObject theirs : soList) {
SpatialObject ours = tm.getValueAt(row);
if (ours == theirs) {
found = true;
break;
}
}
}
if (found == true) {
break;
}
}
}
return found;
}
use of cbit.vcell.mapping.spatial.processes.SpatialProcess in project vcell by virtualcell.
the class DefaultScrollTableCellRenderer method getTableCellRendererComponent.
/**
* Insert the method's description here.
* Creation date: (3/27/2001 1:07:02 PM)
* @return java.awt.Component
* @param table javax.swing.JTable
* @param value java.lang.Object
* @param isSelected boolean
* @param hasFocus boolean
* @param row int
* @param column int
*/
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
defaultToolTipText = null;
super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
defaultToolTipText = getToolTipText();
setBorder(DEFAULT_GAP);
if (isSelected) {
setBackground(table.getSelectionBackground());
setForeground(table.getSelectionForeground());
} else {
if (table instanceof ScrollTable && ((ScrollTable) table).getHoverRow() == row) {
setBackground(hoverColor);
} else {
setBackground(row % 2 == 0 ? table.getBackground() : everyOtherRowColor);
}
if (table.getModel() instanceof SpatialProcessTableModel) /* && column == SpatialProcessTableModel.COLUMN_SpatialProcess_SPATIALOBJECTS */
{
boolean found = isMatchWithSelectedObject(table, row);
if (found == true) {
setBackground(Color.yellow);
}
} else if (table.getModel() instanceof SpatialObjectTableModel) /* && column == SpatialObjectTableModel.COLUMN_SpatialObject_NAME */
{
boolean found = isMatchWithSelectedProcess(table, row);
if (found == true) {
setBackground(Color.yellow);
}
}
setForeground(table.getForeground());
}
TableModel tableModel = table.getModel();
if (bEnableUneditableForeground && (!table.isEnabled() || !tableModel.isCellEditable(row, column))) {
if (!isSelected) {
setForeground(uneditableForeground);
}
}
if (value instanceof Double) {
Double doubleValue = (Double) value;
setText(nicelyFormattedDouble(doubleValue));
} else if (value instanceof JComponent) {
JComponent jc = (JComponent) value;
if (hasFocus) {
jc.setBorder(focusHighlightBorder);
} else {
jc.setBorder(noFocusBorder);
}
return jc;
}
if (BioModelEditorRightSideTableModel.ADD_NEW_HERE_TEXT.equals(value)) {
setText(BioModelEditorRightSideTableModel.ADD_NEW_HERE_HTML);
} else if (value instanceof ModelProcessEquation && BioModelEditorRightSideTableModel.ADD_NEW_HERE_REACTION_TEXT.equals(((ModelProcessEquation) value).toString())) {
setText(BioModelEditorRightSideTableModel.ADD_NEW_REACTION_OR_RULE_HTML);
}
if (tableModel instanceof BioModelEditorApplicationsTableModel) {
// for the applications table we show the icons with the app type
Icon icon = null;
String toolTipSuffix = "";
BioModelEditorApplicationsTableModel bmeatm = (BioModelEditorApplicationsTableModel) tableModel;
SimulationContext simContext = (SimulationContext) (bmeatm.getValueAt(row));
if (simContext.isRuleBased()) {
if (simContext.getGeometry().getDimension() == 0) {
icon = VCellIcons.appRbmNonspIcon;
toolTipSuffix = "Rule Based / Non spatial";
}
} else if (simContext.isStoch()) {
if (simContext.getGeometry().getDimension() == 0) {
icon = VCellIcons.appStoNonspIcon;
toolTipSuffix = "Stochastic / Non spatial";
} else {
icon = VCellIcons.appStoSpatialIcon;
toolTipSuffix = "Stochastic / Spatial";
}
} else {
// deterministic
if (simContext.getGeometry().getDimension() == 0) {
icon = VCellIcons.appDetNonspIcon;
toolTipSuffix = "Deterministic / Non spatial";
} else {
icon = VCellIcons.appDetSpatialIcon;
toolTipSuffix = "Deterministic / Spatial";
}
}
String toolTipPrefix = "Application: ";
setToolTipText(toolTipPrefix + toolTipSuffix);
if (column == 0) {
setIcon(icon);
} else {
setIcon(null);
}
} else if (column == 2 && tableModel instanceof SpatialProcessTableModel) {
Icon icon = null;
SpatialProcess spatialProcess = (SpatialProcess) (((SpatialProcessTableModel) tableModel).getValueAt(row));
if (spatialProcess instanceof PointLocation) {
icon = VCellIcons.spatialPointIcon;
} else if (spatialProcess instanceof PointKinematics) {
icon = VCellIcons.spatialPointIcon;
} else if (spatialProcess instanceof SurfaceKinematics) {
icon = VCellIcons.spatialMembraneIcon;
} else {
icon = VCellIcons.spatialVolumeIcon;
}
setIcon(icon);
} else if (tableModel instanceof SortTableModel) {
// for most other tables we reserve the icon spot to display issues
DefaultScrollTableCellRenderer.issueRenderer(this, defaultToolTipText, table, row, column, (SortTableModel) tableModel);
}
return this;
}
use of cbit.vcell.mapping.spatial.processes.SpatialProcess 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;
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.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);
}
// 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 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);
}
}
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;
}
use of cbit.vcell.mapping.spatial.processes.SpatialProcess in project vcell by virtualcell.
the class Xmlproducer method getXML.
/**
* This method returns a XML representation of a SimulationContext object.
* Creation date: (2/22/2001 2:15:14 PM)
* @return Element
* @param param cbit.vcell.mapping.SimulationContext
*/
public Element getXML(SimulationContext param, BioModel bioModel) throws XmlParseException {
SimulationContext.Application applicationType = param.getApplicationType();
Element simulationcontext = new Element(XMLTags.SimulationSpecTag);
// add attributes
String name = mangle(param.getName());
simulationcontext.setAttribute(XMLTags.NameAttrTag, name);
// set isStoch, isUsingConcentration attributes
if (applicationType == Application.NETWORK_STOCHASTIC) {
simulationcontext.setAttribute(XMLTags.StochAttrTag, "true");
setBooleanAttribute(simulationcontext, XMLTags.ConcentrationAttrTag, param.isUsingConcentration());
// write out 'randomizeInitConditin' flag only if non-spatial stochastic simContext
if (param.getGeometry().getDimension() == 0) {
setBooleanAttribute(simulationcontext, XMLTags.RandomizeInitConditionTag, param.isRandomizeInitCondition());
}
} else {
simulationcontext.setAttribute(XMLTags.StochAttrTag, "false");
simulationcontext.setAttribute(XMLTags.ConcentrationAttrTag, "true");
}
final boolean ruleBased = param.getApplicationType() == SimulationContext.Application.RULE_BASED_STOCHASTIC;
setBooleanAttribute(simulationcontext, XMLTags.RuleBasedAttrTag, ruleBased);
if (ruleBased) {
setBooleanAttribute(simulationcontext, XMLTags.ConcentrationAttrTag, param.isUsingConcentration());
if (param.getGeometry().getDimension() == 0) {
// we don't use it yet but we do propagate it
setBooleanAttribute(simulationcontext, XMLTags.RandomizeInitConditionTag, param.isRandomizeInitCondition());
}
}
setBooleanAttribute(simulationcontext, XMLTags.InsufficientIterationsTag, param.isInsufficientIterations());
setBooleanAttribute(simulationcontext, XMLTags.InsufficientMaxMoleculesTag, param.isInsufficientMaxMolecules());
NetworkConstraints constraints = param.getNetworkConstraints();
if (constraints != null) {
simulationcontext.addContent(getXML(constraints));
}
// add annotation
if (param.getDescription() != null && param.getDescription().length() > 0) {
Element annotationElem = new Element(XMLTags.AnnotationTag);
annotationElem.setText(mangle(param.getDescription()));
simulationcontext.addContent(annotationElem);
}
if (param.getCharacteristicSize() != null) {
simulationcontext.setAttribute(XMLTags.CharacteristicSizeTag, param.getCharacteristicSize().toString());
}
// write Geometry (or GeometryRef???)
try {
simulationcontext.addContent(getXML(param.getGeometryContext().getGeometry()));
} catch (XmlParseException e) {
e.printStackTrace();
throw new XmlParseException("A problem occurred when trying to process the geometry for the simulationContext " + name, e);
}
// write GeometryContext (geometric mapping)
simulationcontext.addContent(getXML(param.getGeometryContext()));
// write ReactionContext (parameter/variable mapping)
simulationcontext.addContent(getXML(param.getReactionContext()));
// check if there is anything to write first for the electrical context
if (param.getElectricalStimuli().length == 1 || param.getGroundElectrode() != null) {
// create ElectricalContext
Element electricalElement = new Element(XMLTags.ElectricalContextTag);
// Write the electrical stimuli
if (param.getElectricalStimuli().length == 1) {
// write clamp
electricalElement.addContent(getXML(param.getElectricalStimuli(0)));
// Element clampElem = new Element(XMLTags.ClampTag);
// clampElem.addContent(getXML(param.getElectricalStimuli(0)));
// if (param.getElectricalStimuli()[0] instanceof VoltageClampStimulus) {
// //this is a VOLTAGE clamp
// clampElem.setAttribute(XMLTags.TypeAttrTag, XMLTags.VoltageClampTag);
// clampElem.setAttribute( XMLTags.NameAttrTag, this.mangle((param.getElectricalStimuli()[0]).getName()) );
// String tempExp = this.mangleExpression( ((VoltageClampStimulus)param.getElectricalStimuli()[0]).getVoltageParameter().getExpression() );
// clampElem.setAttribute(XMLTags.ExpressionAttrTag, tempExp);
// //add probe-electrode
// clampElem.addContent(getXML(param.getElectricalStimuli()[0].getElectrode()));
// } else {
// //this is a CURRENT clamp
// clampElem.setAttribute(XMLTags.TypeAttrTag, XMLTags.CurrentClampTag);
// clampElem.setAttribute( XMLTags.NameAttrTag, this.mangle((param.getElectricalStimuli()[0]).getName()) );
// String tempExp = this.mangleExpression( ((CurrentClampStimulus)param.getElectricalStimuli()[0]).getCurrentParameter().getExpression() );
// clampElem.setAttribute(XMLTags.ExpressionAttrTag, tempExp);
// //add probe-electrode
// clampElem.addContent(getXML(param.getElectricalStimuli()[0].getElectrode()));
// }
// electricalElement.addContent(clampElem);
//
} else if (param.getElectricalStimuli().length > 1) {
// **ONLY ONE ELECTRODE IS SUPPORTED RIGHT NOW!
throw new IllegalArgumentException("More than one electrode is not supported!");
}
// Process the Ground electrode
if (param.getGroundElectrode() != null) {
// write the ground electrode
electricalElement.addContent(getXML(param.getGroundElectrode()));
}
simulationcontext.addContent(electricalElement);
}
// Add Mathdescription (if present)
if (param.getMathDescription() != null) {
simulationcontext.addContent(getXML(param.getMathDescription()));
}
if (param.getOutputFunctionContext() != null) {
ArrayList<AnnotatedFunction> outputFunctions = param.getOutputFunctionContext().getOutputFunctionsList();
if (outputFunctions != null && outputFunctions.size() > 0) {
// get output functions
simulationcontext.addContent(getXML(outputFunctions));
}
}
// Add Simulations to the simulationSpec
if (bioModel != null) {
cbit.vcell.solver.Simulation[] simulations = bioModel.getSimulations(param);
for (int i = 0; simulations != null && i < simulations.length; i++) {
simulationcontext.addContent(getXML(simulations[i]));
}
}
// Add AnalysisTasks
if (param.getAnalysisTasks() != null && param.getAnalysisTasks().length > 0) {
// if the task is empty (no parameters set up, no reference data), we shall not save it
if (param.getAnalysisTasks().length == 1) {
AnalysisTask task = param.getAnalysisTasks()[0];
if (task instanceof ParameterEstimationTask) {
if (!((ParameterEstimationTask) task).isEmpty()) {
simulationcontext.addContent(getXML(param.getAnalysisTasks()));
}
}
} else // have more than one analysis task
{
simulationcontext.addContent(getXML(param.getAnalysisTasks()));
}
}
// Add (Bio)events
BioEvent[] bioEvents = param.getBioEvents();
if (bioEvents != null && bioEvents.length > 0) {
simulationcontext.addContent(getXML(bioEvents));
}
SimulationContextParameter[] appParams = param.getSimulationContextParameters();
if (appParams != null && appParams.length > 0) {
simulationcontext.addContent(getXML(appParams));
}
SpatialObject[] spatialObjects = param.getSpatialObjects();
if (spatialObjects != null && spatialObjects.length > 0) {
simulationcontext.addContent(getXML(spatialObjects));
}
SpatialProcess[] spatialProcesses = param.getSpatialProcesses();
if (spatialProcesses != null && spatialProcesses.length > 0) {
simulationcontext.addContent(getXML(spatialProcesses));
}
// Add rate rules
RateRule[] rateRules = param.getRateRules();
if (param.getRateRules() != null && rateRules.length > 0) {
simulationcontext.addContent(getXML(rateRules));
}
// Add Datacontext
if (param.getDataContext() != null && param.getDataContext().getDataSymbols().length > 0) {
simulationcontext.addContent(getXML(param.getDataContext(), param.getModel().getUnitSystem()));
}
// Add Metadata (if any)
if (param.getVersion() != null) {
simulationcontext.addContent(getXML(param.getVersion(), param));
}
// Add microscope measurements
simulationcontext.addContent(getXML(param.getMicroscopeMeasurement()));
return simulationcontext;
}
Aggregations