Examples with SpatialObject cbit.vcell.mapping.spatial.SpatialObject used on opensource projects

Example 16 with SpatialObject

use of cbit.vcell.mapping.spatial.SpatialObject 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.MassConservationModelReductionTag, param.isUsingMassConservationModelReduction());
    setBooleanAttribute(simulationcontext, XMLTags.InsufficientIterationsTag, param.isInsufficientIterations());
    setBooleanAttribute(simulationcontext, XMLTags.InsufficientMaxMoleculesTag, param.isInsufficientMaxMolecules());
    NetworkConstraints constraints = param.getNetworkConstraints();
    if (constraints != null) {
        simulationcontext.addContent(getXML(constraints, param));
    }
    // 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));
    }
    AssignmentRule[] assignmentRules = param.getAssignmentRules();
    if (param.getAssignmentRules() != null && assignmentRules.length > 0) {
        simulationcontext.addContent(getXML(assignmentRules));
    }
    // 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;
}

Example 17 with SpatialObject

use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.

the class Xmlproducer method getXML.

public Element getXML(SpatialObject[] spatialObjects) throws XmlParseException {
    Element spatialObjectsElement = new Element(XMLTags.SpatialObjectsTag);
    for (SpatialObject spatialObject : spatialObjects) {
        Element spatialObjectElement = new Element(XMLTags.SpatialObjectTag);
        spatialObjectElement.setAttribute(XMLTags.NameAttrTag, mangle(spatialObject.getName()));
        if (spatialObject instanceof PointObject) {
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectTypeAttrTag, XMLTags.SpatialObjectTypeAttrValue_Point);
        } else if (spatialObject instanceof SurfaceRegionObject) {
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectTypeAttrTag, XMLTags.SpatialObjectTypeAttrValue_Surface);
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectSubVolumeInsideAttrTag, ((SurfaceRegionObject) spatialObject).getInsideSubVolume().getName());
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectRegionIdInsideAttrTag, ((SurfaceRegionObject) spatialObject).getInsideRegionID().toString());
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectSubVolumeOutsideAttrTag, ((SurfaceRegionObject) spatialObject).getOutsideSubVolume().getName());
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectRegionIdOutsideAttrTag, ((SurfaceRegionObject) spatialObject).getOutsideRegionID().toString());
        } else if (spatialObject instanceof VolumeRegionObject) {
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectTypeAttrTag, XMLTags.SpatialObjectTypeAttrValue_Volume);
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectSubVolumeAttrTag, ((VolumeRegionObject) spatialObject).getSubVolume().getName());
            spatialObjectElement.setAttribute(XMLTags.SpatialObjectRegionIdAttrTag, ((VolumeRegionObject) spatialObject).getRegionID().toString());
        } else {
            throw new RuntimeException("spatialObject type " + spatialObject.getClass().getSimpleName() + " not yet supported for persistence.");
        }
        Element quantityCategoryListElement = new Element(XMLTags.QuantityCategoryListTag);
        for (QuantityCategory quantityCategory : spatialObject.getQuantityCategories()) {
            Element quantityCategoryElement = new Element(XMLTags.QuantityCategoryTag);
            quantityCategoryElement.setAttribute(XMLTags.QuantityCategoryNameAttrTag, quantityCategory.xmlName);
            quantityCategoryElement.setAttribute(XMLTags.QuantityCategoryEnabledAttrTag, Boolean.toString(spatialObject.isQuantityCategoryEnabled(quantityCategory)));
            quantityCategoryListElement.addContent(quantityCategoryElement);
        }
        spatialObjectElement.addContent(quantityCategoryListElement);
        spatialObjectsElement.addContent(spatialObjectElement);
    }
    System.out.println(XmlUtil.xmlToString(spatialObjectsElement));
    return spatialObjectsElement;
}

Example 18 with SpatialObject

use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.

the class SimContextTable method readAppComponents.

/**
 * readAppComponents : reads the additional simContext components like bioevents/application related flags (for stochastic, at the moment), if present, and sets them on simContext.
 * @param con
 * @param simContext
 * @return
 * @throws SQLException
 * @throws DataAccessException
 * @throws PropertyVetoException
 */
public void readAppComponents(Connection con, SimulationContext simContext, DatabaseSyntax dbSyntax) throws SQLException, DataAccessException, PropertyVetoException {
    try {
        Element appComponentsElement = getAppComponentsElement(con, simContext.getVersion().getVersionKey(), dbSyntax);
        if (appComponentsElement != null) {
            Element appRelatedFlags = appComponentsElement.getChild(XMLTags.ApplicationSpecificFlagsTag);
            if (appRelatedFlags != null) {
                // for now, only reading the 'randomizeInitCondition' attribute, since 'isStoch' and 'isUsingconcentration' are read in by other means; so not messing with those fields of simContext.
                boolean bRandomizeInitCondition = false;
                if ((appRelatedFlags.getAttributeValue(XMLTags.RandomizeInitConditionTag) != null) && (appRelatedFlags.getAttributeValue(XMLTags.RandomizeInitConditionTag).equals("true"))) {
                    bRandomizeInitCondition = true;
                }
                simContext.setRandomizeInitConditions(bRandomizeInitCondition);
            }
            if ((appComponentsElement.getAttributeValue(XMLTags.InsufficientIterationsTag) != null) && (appComponentsElement.getAttributeValue(XMLTags.InsufficientIterationsTag).equals("true"))) {
                simContext.setInsufficientIterations(true);
            } else {
                simContext.setInsufficientIterations(false);
            }
            if ((appComponentsElement.getAttributeValue(XMLTags.InsufficientMaxMoleculesTag) != null) && (appComponentsElement.getAttributeValue(XMLTags.InsufficientMaxMoleculesTag).equals("true"))) {
                simContext.setInsufficientMaxMolecules(true);
            } else {
                simContext.setInsufficientMaxMolecules(false);
            }
            if ((appComponentsElement.getAttributeValue(XMLTags.MassConservationModelReductionTag) != null) && (appComponentsElement.getAttributeValue(XMLTags.MassConservationModelReductionTag).equals("true"))) {
                simContext.setUsingMassConservationModelReduction(true);
            } else {
                simContext.setUsingMassConservationModelReduction(false);
            }
            XmlReader xmlReader = new XmlReader(false);
            NetworkConstraints nc = null;
            Element ncElement = appComponentsElement.getChild(XMLTags.RbmNetworkConstraintsTag);
            if (ncElement != null) {
                // one network constraint element
                nc = xmlReader.getAppNetworkConstraints(ncElement, simContext.getModel());
            }
            simContext.setNetworkConstraints(nc);
            // get spatial objects
            Element spatialObjectsElement = appComponentsElement.getChild(XMLTags.SpatialObjectsTag);
            if (spatialObjectsElement != null) {
                SpatialObject[] spatialObjects = xmlReader.getSpatialObjects(simContext, spatialObjectsElement);
                simContext.setSpatialObjects(spatialObjects);
            }
            // get application parameters
            Element appParamsElement = appComponentsElement.getChild(XMLTags.ApplicationParametersTag);
            if (appParamsElement != null) {
                SimulationContextParameter[] appParams = xmlReader.getSimulationContextParams(appParamsElement, simContext);
                simContext.setSimulationContextParameters(appParams);
            }
            // get bioEvents
            Element bioEventsElement = appComponentsElement.getChild(XMLTags.BioEventsTag);
            if (bioEventsElement != null) {
                BioEvent[] bioEvents = xmlReader.getBioEvents(simContext, bioEventsElement);
                simContext.setBioEvents(bioEvents);
            }
            // get spatial processes
            Element spatialProcessesElement = appComponentsElement.getChild(XMLTags.SpatialProcessesTag);
            if (spatialProcessesElement != null) {
                SpatialProcess[] spatialProcesses = xmlReader.getSpatialProcesses(simContext, spatialProcessesElement);
                simContext.setSpatialProcesses(spatialProcesses);
            }
            // get microscope measurements
            Element element = appComponentsElement.getChild(XMLTags.MicroscopeMeasurement);
            if (element != null) {
                xmlReader.getMicroscopeMeasurement(element, simContext);
            }
            // get rate rules
            Element rateRulesElement = appComponentsElement.getChild(XMLTags.RateRulesTag);
            if (rateRulesElement != null) {
                RateRule[] rateRules = xmlReader.getRateRules(simContext, rateRulesElement);
                simContext.setRateRules(rateRules);
            }
            Element assignmentRulesElement = appComponentsElement.getChild(XMLTags.AssignmentRulesTag);
            if (assignmentRulesElement != null) {
                AssignmentRule[] assignmentRules = xmlReader.getAssignmentRules(simContext, assignmentRulesElement);
                simContext.setAssignmentRules(assignmentRules);
            }
            // get reaction rule specs
            Element reactionRuleSpecsElement = appComponentsElement.getChild(XMLTags.ReactionRuleSpecsTag);
            if (reactionRuleSpecsElement != null) {
                ReactionRuleSpec[] reactionRuleSpecs = xmlReader.getReactionRuleSpecs(simContext, reactionRuleSpecsElement);
                simContext.getReactionContext().setReactionRuleSpecs(reactionRuleSpecs);
            }
        }
    } catch (XmlParseException e) {
        throw new DataAccessException("Error retrieving bioevents : " + e.getMessage(), e);
    }
}

Example 19 with SpatialObject

use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.

the class IssuePanel method invokeHyperlink.

private void invokeHyperlink(Issue issue) {
    if (selectionManager != null) {
        // followHyperlink is no-op if selectionManger null, so no point in proceeding if it is
        IssueContext issueContext = issue.getIssueContext();
        IssueSource object = issue.getSource();
        if (object instanceof DecoratedIssueSource) {
            DecoratedIssueSource dis = (DecoratedIssueSource) object;
            dis.activateView(selectionManager);
        } else if (object instanceof Parameter) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.BIOMODEL_PARAMETERS_NODE, ActiveViewID.parameters_functions), new Object[] { object });
        } else if (object instanceof StructureMapping) {
            StructureMapping structureMapping = (StructureMapping) object;
            StructureMappingNameScope structureMappingNameScope = (StructureMappingNameScope) structureMapping.getNameScope();
            SimulationContext simulationContext = ((SimulationContextNameScope) (structureMappingNameScope.getParent())).getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.structure_mapping), new Object[] { object });
        } else if (object instanceof SpatialObject) {
            SpatialObject spatialObject = (SpatialObject) object;
            SimulationContext simulationContext = spatialObject.getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.spatial_objects), new Object[] { object });
        } else if (object instanceof SpatialProcess) {
            SpatialProcess spatialProcess = (SpatialProcess) object;
            SimulationContext simulationContext = spatialProcess.getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.spatial_processes), new Object[] { object });
        } else if (object instanceof GeometryContext.UnmappedGeometryClass) {
            UnmappedGeometryClass unmappedGeometryClass = (UnmappedGeometryClass) object;
            SimulationContext simulationContext = unmappedGeometryClass.getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.structure_mapping), new Object[] { object });
        } else if (object instanceof MicroscopeMeasurement) {
            SimulationContext simulationContext = ((MicroscopeMeasurement) object).getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.PROTOCOLS_NODE, ActiveViewID.microscope_measuremments), new Object[] { object });
        } else if (object instanceof BioEvent) {
            BioEvent be = (BioEvent) object;
            SimulationContext simulationContext = be.getSimulationContext();
            followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.PROTOCOLS_NODE, ActiveViewID.events), new Object[] { object });
        } else if (object instanceof OutputFunctionIssueSource) {
            SimulationOwner simulationOwner = ((OutputFunctionIssueSource) object).getOutputFunctionContext().getSimulationOwner();
            if (simulationOwner instanceof SimulationContext) {
                SimulationContext simulationContext = (SimulationContext) simulationOwner;
                followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.SIMULATIONS_NODE, ActiveViewID.output_functions), new Object[] { ((OutputFunctionIssueSource) object).getAnnotatedFunction() });
            } else if (simulationOwner instanceof MathModel) {
                followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.MATH_OUTPUT_FUNCTIONS_NODE, ActiveViewID.math_output_functions), new Object[] { ((OutputFunctionIssueSource) object).getAnnotatedFunction() });
            }
        } else if (object instanceof Simulation) {
            Simulation simulation = (Simulation) object;
            SimulationOwner simulationOwner = simulation.getSimulationOwner();
            if (simulationOwner instanceof SimulationContext) {
                SimulationContext simulationContext = (SimulationContext) simulationOwner;
                followHyperlink(new ActiveView(simulationContext, DocumentEditorTreeFolderClass.SIMULATIONS_NODE, ActiveViewID.simulations), new Object[] { simulation });
            } else if (simulationOwner instanceof MathModel) {
                followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.MATH_SIMULATIONS_NODE, ActiveViewID.math_simulations), new Object[] { simulation });
            }
        } else if (object instanceof AssignmentRule) {
            AssignmentRule ar = (AssignmentRule) object;
            SimulationContext sc = ar.getSimulationContext();
            followHyperlink(new ActiveView(sc, DocumentEditorTreeFolderClass.PROTOCOLS_NODE, ActiveViewID.assignmentRules), new Object[] { ar });
        } else if (object instanceof RateRule) {
            RateRule rr = (RateRule) object;
            SimulationContext sc = rr.getSimulationContext();
            followHyperlink(new ActiveView(sc, DocumentEditorTreeFolderClass.PROTOCOLS_NODE, ActiveViewID.rateRules), new Object[] { rr });
        } else if (object instanceof GeometryContext) {
            setActiveView(new ActiveView(((GeometryContext) object).getSimulationContext(), DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.geometry_definition));
        } else if (object instanceof Structure) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.STRUCTURES_NODE, ActiveViewID.structures), new Object[] { object });
        } else if (object instanceof MolecularType) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.MOLECULAR_TYPES_NODE, ActiveViewID.structures), new Object[] { object });
        } else if (object instanceof ReactionStep) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.REACTIONS_NODE, ActiveViewID.reactions), new Object[] { object });
        } else if (object instanceof ReactionRule) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.REACTIONS_NODE, ActiveViewID.reactions), new Object[] { object });
        } else if (object instanceof SpeciesContextSpec) {
            SpeciesContextSpec scs = (SpeciesContextSpec) object;
            ActiveView av = new ActiveView(scs.getSimulationContext(), DocumentEditorTreeFolderClass.SPECIFICATIONS_NODE, ActiveViewID.species_settings);
            followHyperlink(av, new Object[] { object });
        } else if (object instanceof ReactionCombo) {
            ReactionCombo rc = (ReactionCombo) object;
            followHyperlink(new ActiveView(rc.getReactionContext().getSimulationContext(), DocumentEditorTreeFolderClass.SPECIFICATIONS_NODE, ActiveViewID.reaction_setting), new Object[] { ((ReactionCombo) object).getReactionSpec() });
        } else if (object instanceof SpeciesContext) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.SPECIES_NODE, ActiveViewID.species), new Object[] { object });
        } else if (object instanceof RbmObservable) {
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.OBSERVABLES_NODE, ActiveViewID.observables), new Object[] { object });
        } else if (object instanceof MathDescription) {
            // followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.MATH_SIMULATIONS_NODE, ActiveViewID.generated_math), new Object[] {object});
            followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.structure_mapping), new Object[] { object });
        } else if (object instanceof SpeciesPattern) {
            // if (issue.getIssueContext().hasContextType(ContextType.SpeciesContext)){
            // SpeciesContext thing = (SpeciesContext)issue.getIssueContext().getContextObject(ContextType.SpeciesContext);
            // followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.SPECIES_NODE, ActiveViewID.species), new Object[] {thing});
            // }else if(issue.getIssueContext().hasContextType(ContextType.ReactionRule)) {
            // ReactionRule thing = (ReactionRule)issue.getIssueContext().getContextObject(ContextType.ReactionRule);
            // followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.REACTIONS_NODE, ActiveViewID.reactions), new Object[] {thing});
            // }else if(issue.getIssueContext().hasContextType(ContextType.RbmObservable)) {
            // RbmObservable thing = (RbmObservable)issue.getIssueContext().getContextObject(ContextType.RbmObservable);
            // followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.OBSERVABLES_NODE, ActiveViewID.observables), new Object[] {thing});
            // } else {
            System.err.println("SpeciesPattern object missing a proper issue context.");
        // }
        } else if (object instanceof SimulationContext) {
            SimulationContext sc = (SimulationContext) object;
            IssueCategory ic = issue.getCategory();
            switch(ic) {
                case RbmNetworkConstraintsBad:
                    NetworkConstraints nc = sc.getNetworkConstraints();
                    if (issue.getMessage() == SimulationContext.IssueInsufficientMolecules) {
                        NetworkConstraintsEntity nce = new NetworkConstraintsEntity(NetworkConstraintsTableModel.sMaxMoleculesName, nc.getMaxMoleculesPerSpecies() + "", NetworkTransformer.defaultMaxMoleculesPerSpecies + "");
                        followHyperlink(new ActiveView(sc, DocumentEditorTreeFolderClass.SPECIFICATIONS_NODE, ActiveViewID.network_setting), new Object[] { nce });
                    } else {
                        NetworkConstraintsEntity nce = new NetworkConstraintsEntity(NetworkConstraintsTableModel.sMaxIterationName, nc.getMaxIteration() + "", NetworkTransformer.defaultMaxIteration + "");
                        followHyperlink(new ActiveView(sc, DocumentEditorTreeFolderClass.SPECIFICATIONS_NODE, ActiveViewID.network_setting), new Object[] { nce });
                    }
                    break;
                default:
                    followHyperlink(new ActiveView(sc, DocumentEditorTreeFolderClass.SPECIFICATIONS_NODE, ActiveViewID.network_setting), new Object[] { object });
                    break;
            }
        } else if (object instanceof Geometry) {
            if (issueContext.hasContextType(ContextType.SimContext)) {
                SimulationContext simContext = (SimulationContext) issueContext.getContextObject(ContextType.SimContext);
                followHyperlink(new ActiveView(simContext, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.geometry_definition), new Object[] { object });
            } else if (issueContext.hasContextType(ContextType.MathModel)) {
                followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.MATH_GEOMETRY_NODE, ActiveViewID.math_geometry), new Object[] { object });
            } else if (issueContext.hasContextType(ContextType.MathDescription)) {
                followHyperlink(new ActiveView(null, DocumentEditorTreeFolderClass.GEOMETRY_NODE, ActiveViewID.geometry_definition), new Object[] { object });
            }
        } else {
            System.err.println("unknown object type in IssuePanel.invokeHyperlink(): " + object.getClass() + ", context type: " + issueContext.getContextType());
        }
    }
}

Example 20 with SpatialObject

use of cbit.vcell.mapping.spatial.SpatialObject in project vcell by virtualcell.

the class BioModelParametersTableModel method bioModelChange.

@Override
protected void bioModelChange(PropertyChangeEvent evt) {
    super.bioModelChange(evt);
    BioModel oldValue = (BioModel) evt.getOldValue();
    if (oldValue != null) {
        for (EditableSymbolTableEntry parameter : oldValue.getModel().getModelParameters()) {
            parameter.removePropertyChangeListener(this);
        }
        for (SpeciesContext sc : oldValue.getModel().getSpeciesContexts()) {
            sc.removePropertyChangeListener(this);
        }
        for (ReactionStep reactionStep : oldValue.getModel().getReactionSteps()) {
            reactionStep.removePropertyChangeListener(this);
            Kinetics kinetics = reactionStep.getKinetics();
            kinetics.removePropertyChangeListener(this);
            for (KineticsParameter kineticsEditableSymbolTableEntry : kinetics.getKineticsParameters()) {
                kineticsEditableSymbolTableEntry.removePropertyChangeListener(this);
            }
            for (ProxyParameter proxyEditableSymbolTableEntry : kinetics.getProxyParameters()) {
                proxyEditableSymbolTableEntry.removePropertyChangeListener(this);
            }
            for (UnresolvedParameter unresolvedEditableSymbolTableEntry : kinetics.getUnresolvedParameters()) {
                unresolvedEditableSymbolTableEntry.removePropertyChangeListener(this);
            }
        }
        for (SimulationContext simulationContext : oldValue.getSimulationContexts()) {
            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);
            }
        }
    }
    BioModel newValue = (BioModel) evt.getNewValue();
    if (newValue != null) {
        for (ModelParameter modelEditableSymbolTableEntry : newValue.getModel().getModelParameters()) {
            modelEditableSymbolTableEntry.addPropertyChangeListener(this);
        }
        for (SpeciesContext sc : newValue.getModel().getSpeciesContexts()) {
            sc.addPropertyChangeListener(this);
        }
        for (ReactionStep reactionStep : newValue.getModel().getReactionSteps()) {
            reactionStep.addPropertyChangeListener(this);
            Kinetics kinetics = reactionStep.getKinetics();
            kinetics.addPropertyChangeListener(this);
            for (KineticsParameter kineticsEditableSymbolTableEntry : kinetics.getKineticsParameters()) {
                kineticsEditableSymbolTableEntry.addPropertyChangeListener(this);
            }
            for (ProxyParameter proxyEditableSymbolTableEntry : kinetics.getProxyParameters()) {
                proxyEditableSymbolTableEntry.addPropertyChangeListener(this);
            }
            for (UnresolvedParameter unresolvedEditableSymbolTableEntry : kinetics.getUnresolvedParameters()) {
                unresolvedEditableSymbolTableEntry.addPropertyChangeListener(this);
            }
        }
        for (SimulationContext simulationContext : newValue.getSimulationContexts()) {
            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);
            }
        }
    }
}