use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class ReactionCartoonMolecule method refreshAll.
@Override
protected void refreshAll(boolean reallocateShapes) {
try {
if (getModel() == null || getStructureSuite() == null) {
return;
}
System.out.println("ReactionCartoonMolecule, RefreshAll()");
for (Structure structure : structureSuite.getStructures()) {
Diagram diagram = getModel().getDiagram(structure);
if (diagram != null) {
// Maintain consistency between rule participant nodes, signatures and
// species pattern when a molecule is being modified.
rebindAll(diagram);
}
}
// calculate species context weight (number of reactions for which it's a participant)
Map<SpeciesContext, Integer> scWeightMap = new HashMap<>();
// all the species contexts that are catalysts
Set<SpeciesContext> scCatalystSet = new HashSet<>();
// calculate species context length (number of species patterns it contains, 1 if has no species patterns)
for (ReactionStep rs : getModel().getReactionSteps()) {
ReactionParticipant[] rpList = rs.getReactionParticipants();
for (int i = 0; i < rpList.length; i++) {
ReactionParticipant rp = rpList[i];
SpeciesContext sc = rp.getSpeciesContext();
int increment = 1;
if (rp instanceof Catalyst) {
scCatalystSet.add(sc);
}
if (scWeightMap.containsKey(sc)) {
int weight = scWeightMap.get(sc);
weight += increment;
scWeightMap.put(sc, weight);
} else {
scWeightMap.put(sc, increment);
}
}
}
Set<Shape> unwantedShapes = new HashSet<Shape>();
Set<RuleParticipantSignature> unwantedSignatures = new HashSet<RuleParticipantSignature>();
unwantedShapes.addAll(getShapes());
unwantedSignatures.addAll(ruleParticipantSignatures);
ContainerContainerShape containerShape = (ContainerContainerShape) getShapeFromModelObject(getModel());
List<ReactionContainerShape> reactionContainerShapeList = new ArrayList<ReactionContainerShape>();
List<Structure> structureList = new ArrayList<Structure>(getStructureSuite().getStructures());
// create all ReactionContainerShapes (one for each Structure)
for (Structure structure : structureList) {
if (structure instanceof Membrane) {
Membrane membrane = (Membrane) structure;
ReactionContainerShape membraneShape = (ReactionContainerShape) getShapeFromModelObject(membrane);
if (membraneShape == null) {
membraneShape = new ReactionContainerShape(membrane, structureSuite, this);
addShape(membraneShape);
membrane.getMembraneVoltage().removePropertyChangeListener(this);
membrane.getMembraneVoltage().addPropertyChangeListener(this);
} else {
membraneShape.setStructureSuite(structureSuite);
}
membrane.removePropertyChangeListener(this);
membrane.addPropertyChangeListener(this);
membraneShape.refreshLabel();
unwantedShapes.remove(membraneShape);
reactionContainerShapeList.add(membraneShape);
} else if (structure instanceof Feature) {
Feature feature = (Feature) structure;
ReactionContainerShape featureShape = (ReactionContainerShape) getShapeFromModelObject(feature);
if (featureShape == null) {
featureShape = new ReactionContainerShape(feature, structureSuite, this);
addShape(featureShape);
} else {
featureShape.setStructureSuite(structureSuite);
}
feature.removePropertyChangeListener(this);
feature.addPropertyChangeListener(this);
featureShape.refreshLabel();
unwantedShapes.remove(featureShape);
reactionContainerShapeList.add(featureShape);
}
}
if (containerShape == null) {
containerShape = new ContainerContainerShape(this, getModel(), reactionContainerShapeList);
addShape(containerShape);
} else {
containerShape.setReactionContainerShapeList(reactionContainerShapeList);
}
containerShape.refreshLabel();
unwantedShapes.remove(containerShape);
// add all species context shapes within the structures
for (Structure structure : getStructureSuite().getStructures()) {
ReactionContainerShape reactionContainerShape = (ReactionContainerShape) getShapeFromModelObject(structure);
structure.removePropertyChangeListener(this);
structure.addPropertyChangeListener(this);
for (SpeciesContext structSpeciesContext : getModel().getSpeciesContexts(structure)) {
SpeciesContextShape ss = (SpeciesContextShape) getShapeFromModelObject(structSpeciesContext);
if (ss == null) {
ss = new SpeciesContextShape(structSpeciesContext, this);
ss.truncateLabelName(false);
structSpeciesContext.getSpecies().removePropertyChangeListener(this);
structSpeciesContext.getSpecies().addPropertyChangeListener(this);
reactionContainerShape.addChildShape(ss);
addShape(ss);
ss.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
}
if (speciesSizeOption == SpeciesSizeOptions.weight) {
// this number sets the diameter of the shape
Integer weight = scWeightMap.get(structSpeciesContext);
if (weight != null) {
// we cap the diameter of the shape to something reasonable
weight = Math.min(weight, 16);
}
ss.setFilters(highlightCatalystOption ? scCatalystSet.contains(structSpeciesContext) : false, weight);
} else if (speciesSizeOption == SpeciesSizeOptions.length) {
Integer length = null;
if (structSpeciesContext.getSpeciesPattern() != null && !structSpeciesContext.getSpeciesPattern().getMolecularTypePatterns().isEmpty()) {
length = structSpeciesContext.getSpeciesPattern().getMolecularTypePatterns().size() * 2;
length = Math.min(length, 16);
}
ss.setFilters(highlightCatalystOption ? scCatalystSet.contains(structSpeciesContext) : false, length);
} else {
ss.setFilters(highlightCatalystOption ? scCatalystSet.contains(structSpeciesContext) : false, null);
}
structSpeciesContext.removePropertyChangeListener(this);
structSpeciesContext.addPropertyChangeListener(this);
ss.refreshLabel();
unwantedShapes.remove(ss);
}
}
// add all reactionSteps that are in this structure (ReactionContainerShape), and draw the lines
getModel().removePropertyChangeListener(this);
getModel().addPropertyChangeListener(this);
//
for (ReactionRule rr : getModel().getRbmModelContainer().getReactionRuleList()) {
rr.removePropertyChangeListener(this);
rr.addPropertyChangeListener(this);
Structure structure = rr.getStructure();
if (getStructureSuite().areReactionsShownFor(structure)) {
ReactionContainerShape reactionContainerShape = (ReactionContainerShape) getShapeFromModelObject(structure);
ReactionRuleFullDiagramShape rrShape = (ReactionRuleFullDiagramShape) getShapeFromModelObject(rr);
if (rrShape == null) {
rrShape = new ReactionRuleFullDiagramShape(rr, this);
addShape(rrShape);
rrShape.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
reactionContainerShape.addChildShape(rrShape);
rrShape.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
}
rrShape.refreshLabel();
unwantedShapes.remove(rrShape);
//
// add reaction participants as edges and SignatureShapes as needed
//
List<ReactionRuleParticipant> participants = rr.getReactionRuleParticipants();
List<RuleParticipantEdgeDiagramShape> ruleEdges = new ArrayList<>();
for (ReactionRuleParticipant participant : participants) {
participant.getSpeciesPattern().removePropertyChangeListener(this);
participant.getSpeciesPattern().addPropertyChangeListener(this);
Structure speciesStructure = participant.getStructure();
Structure reactionStructure = rr.getStructure();
if (getStructureSuite().getStructures().contains(speciesStructure) && getStructureSuite().areReactionsShownFor(reactionStructure)) {
//
// find existing RuleParticipantSignatureShape in cartoon
//
RuleParticipantShortSignature ruleParticipantShortSignature = null;
for (RuleParticipantSignature signature : ruleParticipantSignatures) {
if (signature instanceof RuleParticipantLongSignature && signature.getStructure() == participant.getStructure()) {
System.out.println("ReactionCartoonMolecule, refreshAll(), RuleParticipantLongSignature");
break;
}
}
for (RuleParticipantSignature signature : ruleParticipantSignatures) {
if (signature instanceof RuleParticipantShortSignature && signature.getStructure() == participant.getStructure() && signature.compareByCriteria(participant.getSpeciesPattern(), GroupingCriteria.molecule)) {
ruleParticipantShortSignature = (RuleParticipantShortSignature) signature;
break;
}
}
//
// if didn't find signature in cartoons list of signatures, then create one (and create a shape for it).
//
RuleParticipantSignatureShortDiagramShape signatureShape = null;
if (ruleParticipantShortSignature == null) {
ruleParticipantShortSignature = RuleParticipantShortSignature.fromReactionRuleParticipant(participant, this);
ruleParticipantSignatures.add(ruleParticipantShortSignature);
signatureShape = new RuleParticipantSignatureShortDiagramShape(ruleParticipantShortSignature, this);
addShape(signatureShape);
ReactionContainerShape participantContainerShape = (ReactionContainerShape) getShapeFromModelObject(participant.getStructure());
signatureShape.getSpaceManager().setRelPos(participantContainerShape.getRandomPosition());
participantContainerShape.addChildShape(signatureShape);
signatureShape.getSpaceManager().setRelPos(participantContainerShape.getRandomPosition());
} else {
signatureShape = (RuleParticipantSignatureShortDiagramShape) getShapeFromModelObject(ruleParticipantShortSignature);
}
unwantedShapes.remove(signatureShape);
unwantedSignatures.remove(ruleParticipantShortSignature);
signatureShape.refreshLabel();
signatureShape.setVisible(true);
//
// add edge for ReactionRuleParticipant if not already present.
//
RuleParticipantEdgeDiagramShape ruleParticipantShape = (RuleParticipantEdgeDiagramShape) getShapeFromModelObject(participant);
if (ruleParticipantShape == null || ruleParticipantShape.getRuleParticipantSignatureShape() != signatureShape) {
if (participant instanceof ReactantPattern && signatureShape.isVisible()) {
ruleParticipantShape = new ReactantPatternEdgeDiagramShape((ReactantPattern) participant, rrShape, signatureShape, this);
} else if (participant instanceof ProductPattern && signatureShape.isVisible()) {
ruleParticipantShape = new ProductPatternEdgeDiagramShape((ProductPattern) participant, rrShape, signatureShape, this);
} else {
throw new RuntimeException("unsupported ReactionRuleParticipant " + participant.getClass());
}
addShape(ruleParticipantShape);
}
if (!containerShape.getChildren().contains(ruleParticipantShape)) {
containerShape.addChildShape(ruleParticipantShape);
}
unwantedShapes.remove(ruleParticipantShape);
ruleParticipantShape.refreshLabel();
// all the edges for this rule
ruleEdges.add(ruleParticipantShape);
}
}
// a product edge (a closed loop) between the rule diagram shape and the signature diagram shape
for (RuleParticipantEdgeDiagramShape ours : ruleEdges) {
// reset them all
ours.setSibling(false);
}
for (RuleParticipantEdgeDiagramShape ours : ruleEdges) {
for (RuleParticipantEdgeDiagramShape theirs : ruleEdges) {
if (ours == theirs) {
// don't compare with self
continue;
}
if (ours.getRuleParticipantSignatureShape() == theirs.getRuleParticipantSignatureShape()) {
ours.setSibling(true);
theirs.setSibling(true);
}
}
}
}
}
ruleParticipantSignatures.removeAll(unwantedSignatures);
for (ReactionStep reactionStep : getModel().getReactionSteps()) {
reactionStep.removePropertyChangeListener(this);
reactionStep.addPropertyChangeListener(this);
Structure structure = reactionStep.getStructure();
if (getStructureSuite().areReactionsShownFor(structure)) {
ReactionContainerShape reactionContainerShape = (ReactionContainerShape) getShapeFromModelObject(structure);
if (reactionContainerShape == null) {
System.out.println("Reaction container shape is null for structure " + structure + " for reaction step " + reactionStep);
}
ReactionStepShape reactionStepShape = (ReactionStepShape) getShapeFromModelObject(reactionStep);
if (reactionStepShape == null) {
if (reactionStep instanceof SimpleReaction) {
reactionStepShape = new SimpleReactionShape((SimpleReaction) reactionStep, this);
} else if (reactionStep instanceof FluxReaction) {
reactionStepShape = new FluxReactionShape((FluxReaction) reactionStep, this);
} else {
throw new RuntimeException("unknown type of ReactionStep '" + reactionStep.getClass().toString());
}
addShape(reactionStepShape);
reactionStepShape.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
reactionContainerShape.addChildShape(reactionStepShape);
reactionStepShape.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
}
reactionStepShape.refreshLabel();
unwantedShapes.remove(reactionStepShape);
// add reaction participants as edges
for (ReactionParticipant participant : reactionStep.getReactionParticipants()) {
participant.removePropertyChangeListener(this);
participant.addPropertyChangeListener(this);
Structure speciesStructure = participant.getStructure();
Structure reactionStructure = reactionStep.getStructure();
if (getStructureSuite().getStructures().contains(speciesStructure) && getStructureSuite().areReactionsShownFor(reactionStructure)) {
SpeciesContext speciesContext = getModel().getSpeciesContext(participant.getSpecies(), speciesStructure);
// add speciesContextShapes that are not in this structure, but are referenced from the reactionParticipants
// these are only when reactionParticipants are from features that are outside of the membrane being displayed
SpeciesContextShape speciesContextShape = (SpeciesContextShape) getShapeFromModelObject(speciesContext);
if (speciesContextShape == null) {
speciesContextShape = new SpeciesContextShape(speciesContext, this);
speciesContextShape.truncateLabelName(false);
reactionContainerShape.addChildShape(speciesContextShape);
addShape(speciesContextShape);
speciesContextShape.getSpaceManager().setRelPos(reactionContainerShape.getRandomPosition());
}
speciesContextShape.refreshLabel();
unwantedShapes.remove(speciesContextShape);
ReactionParticipantShape reactionParticipantShape = (ReactionParticipantShape) getShapeFromModelObject(participant);
if (reactionParticipantShape == null) {
if (participant instanceof Reactant) {
reactionParticipantShape = new ReactantShape((Reactant) participant, reactionStepShape, speciesContextShape, this);
} else if (participant instanceof Product) {
reactionParticipantShape = new ProductShape((Product) participant, reactionStepShape, speciesContextShape, this);
} else if (participant instanceof Catalyst) {
reactionParticipantShape = new CatalystShape((Catalyst) participant, reactionStepShape, speciesContextShape, this);
} else {
throw new RuntimeException("unsupported ReactionParticipant " + participant.getClass());
}
addShape(reactionParticipantShape);
}
if (!containerShape.getChildren().contains(reactionParticipantShape)) {
containerShape.addChildShape(reactionParticipantShape);
}
unwantedShapes.remove(reactionParticipantShape);
reactionParticipantShape.refreshLabel();
}
}
}
}
for (Shape unwantedShape : unwantedShapes) {
removeShape(unwantedShape);
}
// update diagrams
for (Structure structure : structureSuite.getStructures()) {
Diagram diagram = getModel().getDiagram(structure);
if (diagram != null) {
applyDefaults(diagram);
}
}
fireGraphChanged(new GraphEvent(this));
} catch (Throwable e) {
handleException(e);
}
}
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class ReactionCartoonRule method applyDefaults.
public void applyDefaults(Diagram diagram) {
List<NodeReference> nodeList = diagram.getNodeRuleList();
List<NodeReference> orphansList = new ArrayList<NodeReference>();
for (int i = 0; i < nodeList.size(); i++) {
NodeReference node = nodeList.get(i);
Object obj = null;
Structure struct = diagram.getStructure();
boolean found = false;
switch(node.nodeType) {
case NodeReference.SIMPLE_REACTION_NODE:
obj = getModel().getReactionStep(node.name);
if (!(obj instanceof SimpleReaction)) {
System.out.println("ReactionCartoon.applyDefaults(), diagram reaction " + node.name + " type mismatch in model, using location anyway");
}
break;
case NodeReference.FLUX_REACTION_NODE:
obj = getModel().getReactionStep(node.name);
if (!(obj instanceof FluxReaction)) {
System.out.println("ReactionCartoon.applyDefaults(), diagram flux " + node.name + " type mismatch in model, using location anyway");
}
break;
case NodeReference.SPECIES_CONTEXT_NODE:
obj = getModel().getSpeciesContext(node.name);
break;
case // TODO: aici
NodeReference.REACTION_RULE_NODE:
obj = getModel().getRbmModelContainer().getReactionRule(node.name);
break;
case // obj is a RuleParticipantSignature
NodeReference.RULE_PARTICIPANT_SIGNATURE_FULL_NODE:
System.out.println("ReactionCartoonRule, RULE_PARTICIPANT_SIGNATURE_FULL_NODE detected");
for (RuleParticipantSignature signature : ruleParticipantSignatures) {
if (signature instanceof RuleParticipantLongSignature && signature.getStructure() == struct && signature.compareByCriteria(node.getName(), GroupingCriteria.full)) {
obj = signature;
found = true;
break;
}
}
if (!found) {
orphansList.add(node);
}
break;
case NodeReference.RULE_PARTICIPANT_SIGNATURE_SHORT_NODE:
for (RuleParticipantSignature signature : ruleParticipantSignatures) {
if (signature instanceof RuleParticipantShortSignature && signature.getStructure() == struct && signature.compareByCriteria(node.getName(), GroupingCriteria.full)) {
obj = signature;
found = true;
break;
}
}
if (!found) {
orphansList.add(node);
}
break;
}
// -- switch
Shape shape = getShapeFromModelObject(obj);
if (shape != null) {
Point relPosOld = shape.getRelPos();
Point relPosNew = node.location;
// In old models, the same node can appear in multiple diagrams.
// Now, we have only one diagram, so if a node has multiple positions,
// some would overwrite others.
// This attempts to prevent overwriting a position with a worse one.
// if(relPosOld.x + relPosOld.y < relPosNew.x + relPosNew.y) {
shape.setRelPos(relPosNew);
// }
}
}
if (!orphansList.isEmpty()) {
diagram.removeNodeReferences(NodeReference.Mode.rule, orphansList);
}
}
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class BioModelEditorModelPanel method newButtonPressed.
private void newButtonPressed() throws ModelException, PropertyVetoException {
newObject = null;
computeCurrentSelectedTable();
if (currentSelectedTable == speciesTable) {
if (bioModel.getModel().getNumStructures() == 1) {
newObject = bioModel.getModel().createSpeciesContext(bioModel.getModel().getStructures()[0]);
} else if (bioModel.getModel().getNumStructures() > 1) {
final JPopupMenu menu = new JPopupMenu("Choose compartment");
for (int i = 0; i < bioModel.getModel().getNumStructures(); i++) {
Structure s = bioModel.getModel().getStructure(i);
String sName = s.getName();
JMenuItem menuItem = new JMenuItem("In " + s.getTypeName() + " " + sName);
menuItem.setIcon(new StructureToolShapeIcon(17));
menu.add(menuItem);
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
newObject = bioModel.getModel().createSpeciesContext(s);
}
});
}
menu.show(newButton, 0, newButton.getHeight());
}
} else if (currentSelectedTable == molecularTypeTable) {
if (bioModel.getModel().getRbmModelContainer() != null) {
MolecularType mt = bioModel.getModel().getRbmModelContainer().createMolecularType();
bioModel.getModel().getRbmModelContainer().addMolecularType(mt, true);
newObject = mt;
}
} else if (currentSelectedTable == observablesTable) {
if (bioModel.getModel().getRbmModelContainer() != null) {
if (bioModel.getModel().getRbmModelContainer().getMolecularTypeList().isEmpty()) {
PopupGenerator.showInfoDialog(this, VCellErrorMessages.MustBeRuleBased);
return;
}
if (bioModel.getModel().getNumStructures() == 1) {
RbmObservable o = bioModel.getModel().getRbmModelContainer().createObservable(RbmObservable.ObservableType.Molecules);
bioModel.getModel().getRbmModelContainer().addObservable(o);
SpeciesPattern sp = new SpeciesPattern();
o.addSpeciesPattern(sp);
newObject = o;
} else if (bioModel.getModel().getNumStructures() > 1) {
final JPopupMenu menu = new JPopupMenu("Choose compartment");
for (int i = 0; i < bioModel.getModel().getNumStructures(); i++) {
Structure s = bioModel.getModel().getStructure(i);
String sName = s.getName();
JMenuItem menuItem = new JMenuItem("In " + s.getTypeName() + " " + sName);
menuItem.setIcon(new StructureToolShapeIcon(17));
menu.add(menuItem);
menuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
RbmObservable o = bioModel.getModel().getRbmModelContainer().createObservable(RbmObservable.ObservableType.Molecules, null, s);
o.setStructure(s);
try {
bioModel.getModel().getRbmModelContainer().addObservable(o);
} catch (ModelException | PropertyVetoException e1) {
e1.printStackTrace();
throw new RuntimeException(e1.getMessage(), e1);
}
SpeciesPattern sp = new SpeciesPattern();
o.addSpeciesPattern(sp);
newObject = o;
if (newObject != null) {
for (int i = 0; i < currentSelectedTableModel.getRowCount(); i++) {
if (currentSelectedTableModel.getValueAt(i) == newObject) {
currentSelectedTable.setRowSelectionInterval(i, i);
break;
}
}
}
}
});
}
menu.show(newButton, 0, newButton.getHeight());
}
}
} else if (currentSelectedTable == structuresTable) {
try {
Feature feature = bioModel.getModel().createFeature();
newObject = feature;
} catch (Exception e) {
e.printStackTrace();
DialogUtils.showErrorDialog(this, e.getMessage(), e);
}
} else if (currentSelectedTable == reactionsTable) {
if (bioModel.getModel().getNumStructures() == 1) {
SimpleReaction reactionStep = bioModel.getModel().createSimpleReaction(bioModel.getModel().getStructures()[0]);
newObject = reactionStep;
} else {
addNewReaction();
}
}
if (newObject != null) {
for (int i = 0; i < currentSelectedTableModel.getRowCount(); i++) {
if (currentSelectedTableModel.getValueAt(i) == newObject) {
currentSelectedTable.setRowSelectionInterval(i, i);
break;
}
}
}
}
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class BioModelEditorModelPanel method addNewReaction.
private void addNewReaction() {
if (reactionEditorPanel == null) {
reactionEditorPanel = new ReactionEditorPanel();
}
Model model = getModel();
reactionEditorPanel.setModel(model);
while (true) {
int confirm = DialogUtils.showComponentOKCancelDialog(this, reactionEditorPanel, "New Reaction");
if (confirm == javax.swing.JOptionPane.OK_OPTION) {
Structure reactionStructure = reactionEditorPanel.getStructure();
String reactionName = reactionEditorPanel.getReactionName();
String equationString = reactionEditorPanel.getEquationString();
try {
if (reactionName == null || reactionName.trim().length() == 0 || equationString == null || equationString.trim().length() == 0) {
throw new RuntimeException("Reaction name or equation cannot be empty.");
}
if (getModel().getReactionStep(reactionName) != null) {
throw new RuntimeException("Reaction '" + reactionName + "' already exists.");
}
ReactionStep simpleReaction = new SimpleReaction(model, reactionStructure, "dummy", true);
ReactionParticipant[] rpArray = ModelProcessEquation.parseReaction(simpleReaction, getModel(), equationString);
// StructureTopology structTopology = getModel().getStructureTopology();
// for (ReactionParticipant reactionParticipant : rpArray) {
// if (reactionParticipant.getStructure() == reactionStructure) {
// continue;
// }
// if (reactionStructure instanceof Feature) {
// throw new RuntimeException("Species '" + reactionParticipant.getSpeciesContext().getName() + "' must be in the same volume compartment as reaction.");
// } else if (reactionStructure instanceof Membrane) {
// if (structTopology.getInsideFeature((Membrane)reactionStructure) != reactionParticipant.getStructure()
// && (structTopology.getOutsideFeature((Membrane)reactionStructure)) != reactionParticipant.getStructure()) {
// throw new RuntimeException("Species '" + reactionParticipant.getSpeciesContext().getName() + "' must be adjacent to " +
// "or within reaction's structure '" + reactionStructure.getName() + "'.");
// }
// }
// }
simpleReaction = getModel().createSimpleReaction(reactionStructure);
for (ReactionParticipant rp : rpArray) {
SpeciesContext speciesContext = rp.getSpeciesContext();
if (bioModel.getModel().getSpeciesContext(speciesContext.getName()) == null) {
bioModel.getModel().addSpecies(speciesContext.getSpecies());
bioModel.getModel().addSpeciesContext(speciesContext);
}
}
simpleReaction.setReactionParticipants(rpArray);
simpleReaction.setName(reactionName);
setSelectedObjects(new Object[] { simpleReaction });
break;
} catch (Exception e) {
e.printStackTrace();
DialogUtils.showErrorDialog(this, e.getMessage());
}
} else {
break;
}
}
}
use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.
the class XmlReader method getKinetics.
/**
* This method returns a Kinetics object from a XML Element based on the value of the kinetics type attribute.
* Creation date: (3/19/2001 4:42:04 PM)
* @return cbit.vcell.model.Kinetics
* @param param org.jdom.Element
*/
private Kinetics getKinetics(Element param, ReactionStep reaction, Model model) throws XmlParseException {
VariableHash varHash = new VariableHash();
addResevedSymbols(varHash, model);
String type = param.getAttributeValue(XMLTags.KineticsTypeAttrTag);
Kinetics newKinetics = null;
try {
if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralKinetics)) {
// create a general kinetics
newKinetics = new GeneralKinetics(reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralCurrentKinetics)) {
// Create GeneralCurrentKinetics
newKinetics = new GeneralCurrentKinetics(reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeMassAction) && reaction instanceof SimpleReaction) {
// create a Mass Action kinetics
newKinetics = new MassActionKinetics((SimpleReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeNernst) && reaction instanceof FluxReaction) {
// create NernstKinetics
newKinetics = new NernstKinetics((FluxReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGHK) && reaction instanceof FluxReaction) {
// create GHKKinetics
newKinetics = new GHKKinetics((FluxReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeHMM_Irr) && reaction instanceof SimpleReaction) {
// create HMM_IrrKinetics
newKinetics = new HMM_IRRKinetics((SimpleReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeHMM_Rev) && reaction instanceof SimpleReaction) {
// create HMM_RevKinetics
newKinetics = new HMM_REVKinetics((SimpleReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralTotal_oldname)) {
// create GeneralTotalKinetics
newKinetics = new GeneralLumpedKinetics(reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralLumped)) {
// create GeneralLumpedKinetics
newKinetics = new GeneralLumpedKinetics(reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralCurrentLumped)) {
// create GeneralCurrentLumpedKinetics
newKinetics = new GeneralCurrentLumpedKinetics(reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeGeneralPermeability) && reaction instanceof FluxReaction) {
// create GeneralPermeabilityKinetics
newKinetics = new GeneralPermeabilityKinetics((FluxReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeMacroscopic_Irr) && reaction instanceof SimpleReaction) {
// create Macroscopic_IRRKinetics
newKinetics = new Macroscopic_IRRKinetics((SimpleReaction) reaction);
} else if (type.equalsIgnoreCase(XMLTags.KineticsTypeMicroscopic_Irr) && reaction instanceof SimpleReaction) {
// create Microscopic_IRRKinetics
newKinetics = new Microscopic_IRRKinetics((SimpleReaction) reaction);
} else {
throw new XmlParseException("Unknown kinetics type: " + type);
}
} catch (ExpressionException e) {
e.printStackTrace();
throw new XmlParseException("Error creating the kinetics for reaction: " + reaction.getName(), e);
}
try {
// transaction begin flag ... yeah, this is a hack
newKinetics.reading(true);
// Read all of the parameters
List<Element> list = param.getChildren(XMLTags.ParameterTag, vcNamespace);
// add constants that may be used in kinetics.
// VariableHash varHash = getVariablesHash();
ArrayList<String> reserved = new ArrayList<String>();
ReservedSymbol[] reservedSymbols = reaction.getModel().getReservedSymbols();
for (ReservedSymbol rs : reservedSymbols) {
reserved.add(rs.getName());
}
try {
if (reaction.getStructure() instanceof Membrane) {
Membrane membrane = (Membrane) reaction.getStructure();
varHash.addVariable(new Constant(membrane.getMembraneVoltage().getName(), new Expression(0.0)));
reserved.add(membrane.getMembraneVoltage().getName());
}
//
// add Reactants, Products, and Catalysts (ReactionParticipants)
//
ReactionParticipant[] rp = reaction.getReactionParticipants();
for (int i = 0; i < rp.length; i++) {
varHash.addVariable(new Constant(rp[i].getName(), new Expression(0.0)));
}
} catch (MathException e) {
e.printStackTrace(System.out);
throw new XmlParseException("error reordering parameters according to dependencies: ", e);
}
//
for (Element xmlParam : list) {
String paramName = unMangle(xmlParam.getAttributeValue(XMLTags.NameAttrTag));
String role = xmlParam.getAttributeValue(XMLTags.ParamRoleAttrTag);
String paramExpStr = xmlParam.getText();
Expression paramExp = unMangleExpression(paramExpStr);
try {
if (varHash.getVariable(paramName) == null) {
varHash.addVariable(new Function(paramName, paramExp, null));
} else {
if (reserved.contains(paramName)) {
varHash.removeVariable(paramName);
varHash.addVariable(new Function(paramName, paramExp, null));
}
}
} catch (MathException e) {
e.printStackTrace(System.out);
throw new XmlParseException("error reordering parameters according to dependencies: ", e);
}
Kinetics.KineticsParameter tempParam = null;
if (!role.equals(XMLTags.ParamRoleUserDefinedTag)) {
tempParam = newKinetics.getKineticsParameterFromRole(Kinetics.getParamRoleFromDefaultDesc(role));
} else {
continue;
}
// hack for bringing in General Total kinetics without breaking.
if (tempParam == null && newKinetics instanceof GeneralLumpedKinetics) {
if (role.equals(Kinetics.GTK_AssumedCompartmentSize_oldname) || role.equals(Kinetics.GTK_ReactionRate_oldname) || role.equals(Kinetics.GTK_CurrentDensity_oldname)) {
continue;
} else if (role.equals(VCMODL.TotalRate_oldname)) {
tempParam = newKinetics.getKineticsParameterFromRole(Kinetics.ROLE_LumpedReactionRate);
}
}
// hack from bringing in chargeValence parameters without breaking
if (tempParam == null && Kinetics.getParamRoleFromDefaultDesc(role) == Kinetics.ROLE_ChargeValence) {
tempParam = newKinetics.getChargeValenceParameter();
}
if (tempParam == null) {
throw new XmlParseException("parameter with role '" + role + "' not found in kinetics type '" + type + "'");
}
//
if (!tempParam.getName().equals(paramName)) {
Kinetics.KineticsParameter multNameParam = newKinetics.getKineticsParameter(paramName);
int n = 0;
while (multNameParam != null) {
String tempName = paramName + "_" + n++;
newKinetics.renameParameter(paramName, tempName);
multNameParam = newKinetics.getKineticsParameter(tempName);
}
newKinetics.renameParameter(tempParam.getName(), paramName);
}
}
//
// create unresolved parameters for all unresolved symbols
//
String unresolvedSymbol = varHash.getFirstUnresolvedSymbol();
while (unresolvedSymbol != null) {
try {
// will turn into an UnresolvedParameter.
varHash.addVariable(new Function(unresolvedSymbol, new Expression(0.0), null));
} catch (MathException e) {
e.printStackTrace(System.out);
throw new XmlParseException(e);
}
newKinetics.addUnresolvedParameter(unresolvedSymbol);
unresolvedSymbol = varHash.getFirstUnresolvedSymbol();
}
Variable[] sortedVariables = varHash.getTopologicallyReorderedVariables();
ModelUnitSystem modelUnitSystem = reaction.getModel().getUnitSystem();
for (int i = sortedVariables.length - 1; i >= 0; i--) {
if (sortedVariables[i] instanceof Function) {
Function paramFunction = (Function) sortedVariables[i];
Element xmlParam = null;
for (int j = 0; j < list.size(); j++) {
Element tempParam = (Element) list.get(j);
if (paramFunction.getName().equals(unMangle(tempParam.getAttributeValue(XMLTags.NameAttrTag)))) {
xmlParam = tempParam;
break;
}
}
if (xmlParam == null) {
// must have been an unresolved parameter
continue;
}
String symbol = xmlParam.getAttributeValue(XMLTags.VCUnitDefinitionAttrTag);
VCUnitDefinition unit = null;
if (symbol != null) {
unit = modelUnitSystem.getInstance(symbol);
}
Kinetics.KineticsParameter tempParam = newKinetics.getKineticsParameter(paramFunction.getName());
if (tempParam == null) {
newKinetics.addUserDefinedKineticsParameter(paramFunction.getName(), paramFunction.getExpression(), unit);
} else {
newKinetics.setParameterValue(tempParam, paramFunction.getExpression());
tempParam.setUnitDefinition(unit);
}
}
}
} catch (java.beans.PropertyVetoException e) {
e.printStackTrace(System.out);
throw new XmlParseException("Exception while setting parameters for Reaction : " + reaction.getName(), e);
} catch (ExpressionException e) {
e.printStackTrace(System.out);
throw new XmlParseException("Exception while settings parameters for Reaction : " + reaction.getName(), e);
} finally {
newKinetics.reading(false);
}
return newKinetics;
}
Aggregations