Examples with SimpleReaction cbit.vcell.model.SimpleReaction used on opensource projects

Example 16 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class ModelProcessEquation method parseReaction.

public static ReactionParticipant[] parseReaction(ReactionStep reactionStep, Model model, String equationString) throws ExpressionException, PropertyVetoException {
    int gotoIndex = equationString.indexOf(REACTION_GOESTO);
    if (gotoIndex < 1 && equationString.length() == 0) {
        throw new ExpressionException("Syntax error! " + REACTION_GOESTO + " not found. (e.g. a+b->c)");
    }
    if (reactionStep == null) {
        return null;
    }
    String leftHand = equationString.substring(0, gotoIndex);
    String rightHand = equationString.substring(gotoIndex + REACTION_GOESTO.length());
    StringTokenizer st = new StringTokenizer(leftHand, "+");
    ArrayList<ReactionParticipant> rplist = new ArrayList<ReactionParticipant>();
    HashMap<String, SpeciesContext> speciesContextMap = new HashMap<String, SpeciesContext>();
    Structure rxnStructure = reactionStep.getStructure();
    while (st.hasMoreElements()) {
        String nextToken = st.nextToken().trim();
        if (nextToken.length() == 0) {
            continue;
        }
        int stoichiIndex = 0;
        while (true) {
            if (Character.isDigit(nextToken.charAt(stoichiIndex))) {
                stoichiIndex++;
            } else {
                break;
            }
        }
        int stoichi = 1;
        String tmp = nextToken.substring(0, stoichiIndex);
        if (tmp.length() > 0) {
            stoichi = Integer.parseInt(tmp);
        }
        String var = nextToken.substring(stoichiIndex).trim();
        SpeciesContext sc = model.getSpeciesContext(var);
        if (sc == null) {
            sc = speciesContextMap.get(var);
            if (sc == null) {
                Species species = model.getSpecies(var);
                if (species == null) {
                    species = new Species(var, null);
                }
                sc = new SpeciesContext(species, rxnStructure);
                sc.setName(var);
                speciesContextMap.put(var, sc);
            }
        }
        // if (reactionStep instanceof SimpleReaction) {
        rplist.add(new Reactant(null, (SimpleReaction) reactionStep, sc, stoichi));
    // } else if (reactionStep instanceof FluxReaction) {
    // rplist.add(new Flux(null, (FluxReaction) reactionStep, sc));
    // }
    }
    st = new StringTokenizer(rightHand, "+");
    while (st.hasMoreElements()) {
        String nextToken = st.nextToken().trim();
        if (nextToken.length() == 0) {
            continue;
        }
        int stoichiIndex = 0;
        while (true) {
            if (Character.isDigit(nextToken.charAt(stoichiIndex))) {
                stoichiIndex++;
            } else {
                break;
            }
        }
        int stoichi = 1;
        String tmp = nextToken.substring(0, stoichiIndex);
        if (tmp.length() > 0) {
            stoichi = Integer.parseInt(tmp);
        }
        String var = nextToken.substring(stoichiIndex);
        SpeciesContext sc = model.getSpeciesContext(var);
        if (sc == null) {
            sc = speciesContextMap.get(var);
            if (sc == null) {
                Species species = model.getSpecies(var);
                if (species == null) {
                    species = new Species(var, null);
                }
                sc = new SpeciesContext(species, rxnStructure);
                sc.setName(var);
                speciesContextMap.put(var, sc);
            }
        }
        // if (reactionStep instanceof SimpleReaction) {
        rplist.add(new Product(null, (SimpleReaction) reactionStep, sc, stoichi));
    // } else if (reactionStep instanceof FluxReaction) {
    // rplist.add(new Flux(null, (FluxReaction) reactionStep, sc));
    // }
    }
    return rplist.toArray(new ReactionParticipant[0]);
}

Example 17 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class ModelProcessSpecsTableModel method getValueAt.

/**
 * getValueAt method comment.
 */
public Object getValueAt(int row, int col) {
    ModelProcessSpec modelProcessSpec = getValueAt(row);
    ColumnType columnType = columns.get(col);
    switch(columnType) {
        case COLUMN_NAME:
            {
                return modelProcessSpec.getModelProcess();
            }
        case COLUMN_TYPE:
            {
                return modelProcessSpec.getModelProcess().getDisplayType();
            }
        case COLUMN_ENABLED:
            {
                return new Boolean(!modelProcessSpec.isExcluded());
            }
        case COLUMN_FAST:
            {
                if (!(modelProcessSpec.getModelProcess() instanceof SimpleReaction)) {
                    return new Boolean(false);
                } else {
                    return new Boolean(modelProcessSpec.isFast());
                }
            }
        default:
            {
                return null;
            }
    }
}

Example 18 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class ReactionCartoonTool method lineAction.

private void lineAction(ReactionStep reactionStart, Structure endStructure) throws Exception {
    Structure startStructure = reactionStart.getStructure();
    if (StructureUtil.reactionHereCanHaveParticipantThere(startStructure, endStructure)) {
        // if reactionStart is a SimpleRxn OR FluxRxn without a product, add speciesContext as pdt
        if ((reactionStart instanceof SimpleReaction) || ((reactionStart instanceof FluxReaction) && !reactionStart.hasProduct())) {
            SpeciesContext speciesContext = getModel().createSpeciesContext(endStructure);
            reactionStart.addProduct(speciesContext, 1);
            positionShapeForObject(endStructure, speciesContext, edgeShape.getEnd());
        }
        if (((startStructure instanceof Feature && endStructure instanceof Feature) || (startStructure instanceof Membrane && endStructure instanceof Membrane)) && startStructure != endStructure) {
        // ============ change kinetics to lumped or warn user ?????????
        // reactionStart.setKinetics(new GeneralLumpedKinetics(reactionStart));
        }
        getReactionCartoon().notifyChangeEvent();
    }
}

Example 19 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class BioCartoonTool method pasteReactionSteps0.

/**
 * pasteReactionSteps0 : does the actual pasting. First called with a cloned model, to track issues. If user still wants to proceed, the paste
 * is performed on the original model.
 *
 * Insert the method's description here.
 * Creation date: (5/10/2003 3:55:25 PM)
 * @param pasteToModel cbit.vcell.model.Model
 * @param pasteToStructure cbit.vcell.model.Structure
 * @param bNew boolean
 */
private static final PasteHelper pasteReactionSteps0(HashMap<String, HashMap<ReactionParticipant, Structure>> rxPartMapStructure, Component parent, IssueContext issueContext, ReactionStep[] copyFromRxSteps, Model pasteToModel, Structure pasteToStructure, boolean bNew, /*boolean bUseDBSpecies,*/
UserResolvedRxElements userResolvedRxElements) throws Exception {
    HashMap<BioModelEntityObject, BioModelEntityObject> reactionsAndSpeciesContexts = new HashMap<>();
    if (copyFromRxSteps == null || copyFromRxSteps.length == 0 || pasteToModel == null || pasteToStructure == null) {
        throw new IllegalArgumentException("CartoonTool.pasteReactionSteps Error " + (copyFromRxSteps == null || copyFromRxSteps.length == 0 ? "reactionStepsArr empty " : "") + (pasteToModel == null ? "model is null " : "") + (pasteToStructure == null ? "struct is null " : ""));
    }
    if (!pasteToModel.contains(pasteToStructure)) {
        throw new IllegalArgumentException("CartoonTool.pasteReactionSteps model " + pasteToModel.getName() + " does not contain structure " + pasteToStructure.getName());
    }
    // Check PasteToModel has preferred targets if set
    if (userResolvedRxElements != null) {
        for (int i = 0; i < userResolvedRxElements.toSpeciesArr.length; i++) {
            if (userResolvedRxElements.toSpeciesArr[i] != null) {
                if (!pasteToModel.contains(userResolvedRxElements.toSpeciesArr[i])) {
                    throw new RuntimeException("PasteToModel does not contain preferred Species " + userResolvedRxElements.toSpeciesArr[i]);
                }
            }
            if (userResolvedRxElements.toStructureArr[i] != null) {
                if (!pasteToModel.contains(userResolvedRxElements.toStructureArr[i])) {
                    throw new RuntimeException("PasteToModel does not contain preferred Structure " + userResolvedRxElements.toStructureArr[i]);
                }
            }
        }
    }
    int counter = 0;
    Structure currentStruct = pasteToStructure;
    String copiedStructName = copyFromRxSteps[counter].getStructure().getName();
    StructureTopology structTopology = (copyFromRxSteps[counter].getModel() == null ? pasteToModel.getStructureTopology() : copyFromRxSteps[counter].getModel().getStructureTopology());
    IdentityHashMap<Species, Species> speciesHash = new IdentityHashMap<Species, Species>();
    IdentityHashMap<SpeciesContext, SpeciesContext> speciesContextHash = new IdentityHashMap<SpeciesContext, SpeciesContext>();
    Vector<Issue> issueVector = new Vector<Issue>();
    do {
        // create a new reaction, instead of cloning the old one; set struc
        ReactionStep copyFromReactionStep = copyFromRxSteps[counter];
        String newName = copyFromReactionStep.getName();
        while (pasteToModel.getReactionStep(newName) != null) {
            newName = org.vcell.util.TokenMangler.getNextEnumeratedToken(newName);
        }
        ReactionStep newReactionStep = null;
        if (copyFromReactionStep instanceof SimpleReaction) {
            newReactionStep = new SimpleReaction(pasteToModel, currentStruct, newName, copyFromReactionStep.isReversible());
        } else if (copyFromReactionStep instanceof FluxReaction && currentStruct instanceof Membrane) {
            newReactionStep = new FluxReaction(pasteToModel, (Membrane) currentStruct, null, newName, copyFromReactionStep.isReversible());
        }
        pasteToModel.addReactionStep(newReactionStep);
        reactionsAndSpeciesContexts.put(newReactionStep, copyFromReactionStep);
        Structure toRxnStruct = newReactionStep.getStructure();
        Structure fromRxnStruct = copyFromReactionStep.getStructure();
        if (!fromRxnStruct.getClass().equals(pasteToStructure.getClass())) {
            throw new Exception("Cannot copy reaction from " + fromRxnStruct.getTypeName() + " to " + pasteToStructure.getTypeName() + ".");
        }
        // add appropriate reactionParticipants to newReactionStep.
        StructureTopology toStructureTopology = pasteToModel.getStructureTopology();
        ReactionParticipant[] copyFromRxParticipantArr = copyFromReactionStep.getReactionParticipants();
        if (rxPartMapStructure == null) {
            // null during 'issues' trial
            rxPartMapStructure = new HashMap<String, HashMap<ReactionParticipant, Structure>>();
        }
        if (rxPartMapStructure.get(copyFromReactionStep.getName()) == null) {
            // Ask user to assign species to compartments for each reaction to be pasted
            rxPartMapStructure.put(copyFromReactionStep.getName(), askUserResolveMembraneConnections(parent, pasteToModel.getStructures(), currentStruct, fromRxnStruct, toRxnStruct, copyFromRxParticipantArr, toStructureTopology, structTopology));
        }
        for (int i = 0; i < copyFromRxParticipantArr.length; i += 1) {
            Structure pasteToStruct = currentStruct;
            // if(toRxnStruct instanceof Membrane){
            pasteToStruct = rxPartMapStructure.get(copyFromReactionStep.getName()).get(copyFromRxParticipantArr[i]);
            // if(pasteToStruct == null){
            // for(ReactionParticipant myRXPart:rxPartMapStructure.get(copyFromReactionStep.getName()).keySet()){
            // if(myRXPart.getSpeciesContext().getName().equals(copyFromRxParticipantArr[i].getSpeciesContext().getName())){
            // pasteToStruct = rxPartMapStructure.get(copyFromReactionStep.getName()).get(myRXPart);
            // break;
            // }
            // }
            // }
            // }
            // this adds the speciesContexts and species (if any) to the model)
            String rootSC = ReactionCartoonTool.speciesContextRootFinder(copyFromRxParticipantArr[i].getSpeciesContext());
            SpeciesContext newSc = null;
            SpeciesContext[] matchSC = pasteToModel.getSpeciesContexts();
            for (int j = 0; matchSC != null && j < matchSC.length; j++) {
                String matchRoot = ReactionCartoonTool.speciesContextRootFinder(matchSC[j]);
                if (matchRoot != null && matchRoot.equals(rootSC) && matchSC[j].getStructure().getName().equals(pasteToStruct.getName())) {
                    newSc = matchSC[j];
                    reactionsAndSpeciesContexts.put(newSc, matchSC[j]);
                    break;
                }
            }
            if (newSc == null) {
                newSc = pasteSpecies(parent, copyFromRxParticipantArr[i].getSpecies(), rootSC, pasteToModel, pasteToStruct, bNew, /*bUseDBSpecies,*/
                speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, copyFromRxParticipantArr[i]));
                reactionsAndSpeciesContexts.put(newSc, copyFromRxParticipantArr[i].getSpeciesContext());
            }
            // record the old-new speciesContexts (reactionparticipants) in the IdHashMap, this is useful, esp for 'Paste new', while replacing proxyparams.
            SpeciesContext oldSc = copyFromRxParticipantArr[i].getSpeciesContext();
            if (speciesContextHash.get(oldSc) == null) {
                speciesContextHash.put(oldSc, newSc);
            }
            if (copyFromRxParticipantArr[i] instanceof Reactant) {
                newReactionStep.addReactionParticipant(new Reactant(null, newReactionStep, newSc, copyFromRxParticipantArr[i].getStoichiometry()));
            } else if (copyFromRxParticipantArr[i] instanceof Product) {
                newReactionStep.addReactionParticipant(new Product(null, newReactionStep, newSc, copyFromRxParticipantArr[i].getStoichiometry()));
            } else if (copyFromRxParticipantArr[i] instanceof Catalyst) {
                newReactionStep.addCatalyst(newSc);
            }
        }
        // // If 'newReactionStep' is a fluxRxn, set its fluxCarrier
        // if (newReactionStep instanceof FluxReaction) {
        // if (fluxCarrierSp != null) {
        // ((FluxReaction)newReactionStep).setFluxCarrier(fluxCarrierSp, pasteToModel);
        // } else {
        // throw new RuntimeException("Could not set FluxCarrier species for the flux reaction to be pasted");
        // }
        // }
        // For each kinetic parameter expression for new kinetics, replace the proxyParams from old kinetics with proxyParams in new kinetics
        // i.e., if the proxyParams are speciesContexts, replace with corresponding speciesContext in newReactionStep;
        // if the proxyParams are structureSizes or MembraneVoltages, replace with corresponding structure quantity in newReactionStep
        Kinetics oldKinetics = copyFromReactionStep.getKinetics();
        KineticsParameter[] oldKps = oldKinetics.getKineticsParameters();
        KineticsProxyParameter[] oldKprps = oldKinetics.getProxyParameters();
        Hashtable<String, Expression> paramExprHash = new Hashtable<String, Expression>();
        for (int i = 0; oldKps != null && i < oldKps.length; i++) {
            Expression newExpression = new Expression(oldKps[i].getExpression());
            for (int j = 0; oldKprps != null && j < oldKprps.length; j++) {
                // check if kinetic proxy parameter is in kinetic parameter expression
                if (newExpression.hasSymbol(oldKprps[j].getName())) {
                    SymbolTableEntry ste = oldKprps[j].getTarget();
                    Model pasteFromModel = copyFromReactionStep.getModel();
                    if (ste instanceof SpeciesContext) {
                        // if newRxnStruct is a feature/membrane, get matching spContexts from old reaction and replace them in new rate expr.
                        SpeciesContext oldSC = (SpeciesContext) ste;
                        SpeciesContext newSC = speciesContextHash.get(oldSC);
                        if (newSC == null) {
                            // check if oldSc is present in paste-model; if not, add it.
                            if (!pasteToModel.equals(pasteFromModel)) {
                                if (pasteToModel.getSpeciesContext(oldSC.getName()) == null) {
                                    // if paste-model has oldSc struct, paste it there,
                                    Structure newSCStruct = pasteToModel.getStructure(oldSC.getStructure().getName());
                                    if (newSCStruct != null) {
                                        newSC = pasteSpecies(parent, oldSC.getSpecies(), null, pasteToModel, newSCStruct, bNew, /*bUseDBSpecies,*/
                                        speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, oldSC));
                                        speciesContextHash.put(oldSC, newSC);
                                    } else {
                                        // oldStruct wasn't found in paste-model, paste it in newRxnStruct and add warning to issues list
                                        newSC = pasteSpecies(parent, oldSC.getSpecies(), null, pasteToModel, toRxnStruct, bNew, /*bUseDBSpecies,*/
                                        speciesHash, UserResolvedRxElements.getPreferredReactionElement(userResolvedRxElements, oldSC));
                                        speciesContextHash.put(oldSC, newSC);
                                        Issue issue = new Issue(oldSC, issueContext, IssueCategory.CopyPaste, "SpeciesContext '" + oldSC.getSpecies().getCommonName() + "' was not found in compartment '" + oldSC.getStructure().getName() + "' in the model; the species was added to the compartment '" + toRxnStruct.getName() + "' where the reaction was pasted.", Issue.SEVERITY_WARNING);
                                        issueVector.add(issue);
                                    }
                                }
                            }
                        // if models are the same and newSc is null, then oldSc is not a rxnParticipant. Leave it as is in the expr.
                        }
                        if (newSC != null) {
                            reactionsAndSpeciesContexts.put(newSC, oldSC);
                            newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(newSC.getName()));
                        }
                    // SpeciesContext sc = null;
                    // Species newSp = model.getSpecies(oldSc.getSpecies().getCommonName());
                    // if  (oldSc.getStructure() == (oldRxnStruct)) {
                    // sc = model.getSpeciesContext(newSp, newRxnStruct);
                    // } else {
                    // if (newRxnStruct instanceof Membrane) {
                    // // for a membrane, we need to make sure that inside-outside spContexts used are appropriately replaced.
                    // if (oldSc.getStructure() == ((Membrane)oldRxnStruct).getOutsideFeature()) {
                    // // old speciesContext is outside (old) membrane, new spContext should be outside new membrane
                    // sc = model.getSpeciesContext(newSp, ((Membrane)newRxnStruct).getOutsideFeature());
                    // } else if (oldSc.getStructure() == ((Membrane)oldRxnStruct).getInsideFeature()) {
                    // // old speciesContext is inside (old) membrane, new spContext should be inside new membrane
                    // sc = model.getSpeciesContext(newSp, ((Membrane)newRxnStruct).getInsideFeature());
                    // }
                    // }
                    // }
                    // if (sc != null) {
                    // newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(sc.getName()));
                    // }
                    } else if (ste instanceof StructureSize) {
                        Structure str = ((StructureSize) ste).getStructure();
                        // if the structure size used is same as the structure in which the reaction is present, change the structSize to appropriate new struct
                        if (str.compareEqual(fromRxnStruct)) {
                            newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(toRxnStruct.getStructureSize().getName()));
                        } else {
                            if (fromRxnStruct instanceof Membrane) {
                                if (str.equals(structTopology.getOutsideFeature((Membrane) fromRxnStruct))) {
                                    newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(structTopology.getOutsideFeature((Membrane) toRxnStruct).getStructureSize().getName()));
                                } else if (str.equals(structTopology.getInsideFeature((Membrane) fromRxnStruct))) {
                                    newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(structTopology.getInsideFeature((Membrane) toRxnStruct).getStructureSize().getName()));
                                }
                            }
                        }
                    } else if (ste instanceof MembraneVoltage) {
                        Membrane membr = ((MembraneVoltage) ste).getMembrane();
                        // if the MembraneVoltage used is same as that of the membrane in which the reaction is present, change the MemVoltage
                        if ((fromRxnStruct instanceof Membrane) && (membr.compareEqual(fromRxnStruct))) {
                            newExpression.substituteInPlace(new Expression(ste.getName()), new Expression(((Membrane) toRxnStruct).getMembraneVoltage().getName()));
                        }
                    } else if (ste instanceof ModelParameter) {
                        // see if model has this global parameter (if rxn is being pasted into another model, it won't)
                        if (!pasteToModel.equals(pasteFromModel)) {
                            ModelParameter oldMp = (ModelParameter) ste;
                            ModelParameter mp = pasteToModel.getModelParameter(oldMp.getName());
                            boolean bNonNumeric = false;
                            String newMpName = oldMp.getName();
                            if (mp != null) {
                                // new model has a model parameter with same name - are they the same param?
                                if (!mp.getExpression().equals(oldMp.getExpression())) {
                                    // no, they are not the same param, so mangle the 'ste' name and add as global in the other model
                                    while (pasteToModel.getModelParameter(newMpName) != null) {
                                        newMpName = TokenMangler.getNextEnumeratedToken(newMpName);
                                    }
                                    // if expression if numeric, add it as such. If not, set it to 0.0 and add it as global
                                    Expression exp = oldMp.getExpression();
                                    if (!exp.flatten().isNumeric()) {
                                        exp = new Expression(0.0);
                                        bNonNumeric = true;
                                    }
                                    ModelParameter newMp = pasteToModel.new ModelParameter(newMpName, exp, Model.ROLE_UserDefined, oldMp.getUnitDefinition());
                                    String annotation = "Copied from model : " + pasteFromModel.getNameScope();
                                    newMp.setModelParameterAnnotation(annotation);
                                    pasteToModel.addModelParameter(newMp);
                                    // if global param name had to be changed, make sure newExpr is updated as well.
                                    if (!newMpName.equals(oldMp.getName())) {
                                        newExpression.substituteInPlace(new Expression(oldMp.getName()), new Expression(newMpName));
                                    }
                                }
                            } else {
                                // no global param with same name was found in other model, so add it to other model.
                                // if expression if numeric, add it as such. If not, set it to 0.0 and add it as global
                                Expression exp = oldMp.getExpression();
                                if (!exp.flatten().isNumeric()) {
                                    exp = new Expression(0.0);
                                    bNonNumeric = true;
                                }
                                ModelParameter newMp = pasteToModel.new ModelParameter(newMpName, exp, Model.ROLE_UserDefined, oldMp.getUnitDefinition());
                                String annotation = "Copied from model : " + pasteFromModel.getNameScope();
                                newMp.setModelParameterAnnotation(annotation);
                                pasteToModel.addModelParameter(newMp);
                            }
                            // if a non-numeric parameter was encountered in the old model, it was added as a numeric (0.0), warn user of change.
                            if (bNonNumeric) {
                                Issue issue = new Issue(oldMp, issueContext, IssueCategory.CopyPaste, "Global parameter '" + oldMp.getName() + "' was non-numeric; it has been added " + "as global parameter '" + newMpName + "' in the new model with value = 0.0. " + "Please update its value, if required, before using it.", Issue.SEVERITY_WARNING);
                                issueVector.add(issue);
                            }
                        }
                    }
                }
            // end - if newExpr.hasSymbol(ProxyParam)
            }
            // now if store <param names, new expression> in hashTable
            if (paramExprHash.get(oldKps[i].getName()) == null) {
                paramExprHash.put(oldKps[i].getName(), newExpression);
            }
        }
        // end for - oldKps (old kinetic parameters)
        // use this new expression to generate 'vcml' for the (new) kinetics (easier way to transfer all kinetic parameters)
        String newKineticsStr = oldKinetics.writeTokensWithReplacingProxyParams(paramExprHash);
        // convert the kinetics 'vcml' to tokens.
        CommentStringTokenizer kineticsTokens = new CommentStringTokenizer(newKineticsStr);
        // skip the first token;
        kineticsTokens.nextToken();
        // second token is the kinetic type; use this to create a dummy kinetics
        String kineticType = kineticsTokens.nextToken();
        Kinetics newkinetics = KineticsDescription.fromVCMLKineticsName(kineticType).createKinetics(newReactionStep);
        // use the remaining tokens to construct the new kinetics
        newkinetics.fromTokens(newKineticsStr);
        // bind newkinetics to newReactionStep and add it to newReactionStep
        newkinetics.bind(newReactionStep);
        newReactionStep.setKinetics(newkinetics);
        counter += 1;
        if (counter == copyFromRxSteps.length) {
            break;
        }
        if (!copiedStructName.equals(fromRxnStruct.getName())) {
            if (currentStruct instanceof Feature) {
                currentStruct = structTopology.getMembrane((Feature) currentStruct);
            } else if (currentStruct instanceof Membrane) {
                currentStruct = structTopology.getInsideFeature((Membrane) currentStruct);
            }
        }
        copiedStructName = fromRxnStruct.getName();
    } while (true);
    return new PasteHelper(issueVector, rxPartMapStructure, reactionsAndSpeciesContexts);
}

Example 20 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class ReactionCartoonTool method mouseReleased.

@Override
public void mouseReleased(MouseEvent event) {
    if (getReactionCartoon() == null) {
        return;
    }
    try {
        if (dragStructTimer != null) {
            dragStructTimer.stop();
        }
        endPointWorld = getReactionCartoon().getResizeManager().unzoom(event.getPoint());
        Shape endShape = getReactionCartoon().pickWorld(endPointWorld);
        if (event.isPopupTrigger() && mode == Mode.SELECT) {
            // win, linux popup
            popupMenu(getReactionCartoon().getSelectedShape(), event.getX(), event.getY());
            return;
        }
        if (mode == Mode.SELECT && bStartRxContainerLabel) {
            resetDropTargets(null, mode == Mode.STRUCTURE);
            if (endShape != null && endShape instanceof ReactionContainerShape) {
                Rectangle labelOutlineRectangle = ((ReactionContainerShape) endShape).getLabelOutline(endShape.getAbsX(), endShape.getAbsY());
                boolean bLabel = labelOutlineRectangle.contains(startPointWorld.x, startPointWorld.y);
                getGraphPane().setCursor((bLabel ? Cursor.getPredefinedCursor(Cursor.HAND_CURSOR) : Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)));
            }
            bStartRxContainerLabel = false;
            RXContainerDropTargetInfo trueRXContainerDropTargetInfo = getSelectedContainerDropTargetInfo();
            lastRXContainerDropTargetInfoMap = null;
            if (trueRXContainerDropTargetInfo == null) {
                // turn off rxDropTargetRectangles
                getGraphPane().repaint();
                return;
            }
            StructureSuite structureSuite = null;
            structureSuite = getReactionCartoon().getStructureSuite();
            if (structureSuite != null) {
                Structure[] originalOrderedStructArr = structureSuite.getStructures().toArray(new Structure[0]);
                // find where user wants to put the structure
                try {
                    if (trueRXContainerDropTargetInfo != null) {
                        ArrayList<Structure> newStructOrderList = new ArrayList<Structure>(Arrays.asList(originalOrderedStructArr));
                        newStructOrderList.remove(((ReactionContainerShape) startShape).getStructure());
                        int indexEnd = newStructOrderList.indexOf(((ReactionContainerShape) trueRXContainerDropTargetInfo.dropShape).getStructure());
                        int indexClosestNeighbor = (trueRXContainerDropTargetInfo.closestNeighborShape == null ? (trueRXContainerDropTargetInfo.insertFlag == RXContainerDropTargetInfo.INSERT_BEGINNING ? 0 : newStructOrderList.size()) : newStructOrderList.indexOf(((ReactionContainerShape) trueRXContainerDropTargetInfo.closestNeighborShape).getStructure()));
                        if (indexClosestNeighbor < indexEnd) {
                            newStructOrderList.add(indexEnd, ((ReactionContainerShape) startShape).getStructure());
                        } else {
                            newStructOrderList.add(indexClosestNeighbor, ((ReactionContainerShape) startShape).getStructure());
                        }
                        if (structureSuite instanceof AllStructureSuite) {
                            ((AllStructureSuite) structureSuite).setModelStructureOrder(true);
                        }
                        ArrayList<Diagram> newDiagramOrderList = new ArrayList<Diagram>();
                        for (Structure structure : newStructOrderList) {
                            newDiagramOrderList.add(getModel().getDiagram(structure));
                        }
                        getModel().setDiagrams(newDiagramOrderList.toArray(new Diagram[0]));
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return;
        }
        // else do select and move
        switch(mode) {
            case SELECT:
                {
                    getGraphPane().setCursor(Cursor.getDefaultCursor());
                    if (bMoving) {
                        getGraphPane().invalidate();
                        ((JViewport) getGraphPane().getParent()).revalidate();
                        getGraphPane().repaint();
                        saveDiagram();
                    } else if (bRectStretch) {
                        Point absLoc = rectShape.getSpaceManager().getRelPos();
                        Dimension size = rectShape.getSpaceManager().getSize();
                        // remove temporary rectangle
                        getReactionCartoon().removeShape(rectShape);
                        rectShape = null;
                        Rectangle rect = new Rectangle(absLoc.x, absLoc.y, size.width, size.height);
                        boolean bShift = (event.getModifiers() & InputEvent.SHIFT_MASK) == InputEvent.SHIFT_MASK;
                        boolean bCntrl = (event.getModifiers() & InputEvent.CTRL_MASK) == InputEvent.CTRL_MASK;
                        selectEventFromWorld(rect, bShift, bCntrl);
                        getGraphPane().repaint();
                    }
                    bMoving = false;
                    movingShape = null;
                    bRectStretch = false;
                    rectShape = null;
                    break;
                }
            case LINEDIRECTED:
                {
                    getGraphPane().setCursor(Cursor.getDefaultCursor());
                    if (bLineStretch && getDragDistanceSquared() >= MIN_DRAG_DISTANCE_TO_CREATE_NEW_ELEMENTS_SQUARED) {
                        bLineStretch = false;
                        // set label and color for line depending on which shape the edge started.
                        // (rather than attachment area on ReactionStepShape)
                        LineType lineType = getLineTypeFromDirection(startShape, endPointWorld);
                        if (endShape instanceof SimpleReactionShape) {
                            SimpleReaction simpleReaction = (SimpleReaction) endShape.getModelObject();
                            Object startShapeObject = null;
                            if (startShape != null) {
                                startShapeObject = startShape.getModelObject();
                            }
                            if (startShapeObject instanceof SpeciesContext) {
                                SpeciesContext speciesContext = (SpeciesContext) startShapeObject;
                                lineAction(speciesContext, simpleReaction);
                            } else if (startShapeObject instanceof Structure) {
                                Structure structure = (Structure) startShapeObject;
                                lineActon(structure, simpleReaction);
                            }
                        } else if (endShape instanceof SpeciesContextShape) {
                            SpeciesContext speciesContextEnd = (SpeciesContext) endShape.getModelObject();
                            Object startShapeObject = null;
                            if (startShape != null) {
                                startShapeObject = startShape.getModelObject();
                            }
                            if (startShapeObject instanceof SimpleReaction) {
                                SimpleReaction simpleReaction = (SimpleReaction) startShapeObject;
                                lineAction(simpleReaction, speciesContextEnd);
                            } else if (startShapeObject instanceof FluxReaction) {
                                FluxReaction fluxReaction = (FluxReaction) startShapeObject;
                                lineAction(fluxReaction, speciesContextEnd);
                            } else if (startShapeObject instanceof SpeciesContext) {
                                SpeciesContext speciesContextStart = (SpeciesContext) startShapeObject;
                                if (!speciesContextStart.equals(speciesContextEnd)) {
                                    lineAction(speciesContextStart, speciesContextEnd);
                                }
                            } else if (startShapeObject instanceof Structure) {
                                Structure startStructure = (Structure) startShapeObject;
                                lineAction(startStructure, speciesContextEnd);
                            }
                        } else if (endShape instanceof FluxReactionShape) {
                            FluxReaction fluxReaction = (FluxReaction) endShape.getModelObject();
                            fluxReaction.setModel(getModel());
                            Object startShapeObject = null;
                            if (startShape != null) {
                                startShapeObject = startShape.getModelObject();
                            }
                            if (startShapeObject instanceof SpeciesContext) {
                                SpeciesContext speciesContext = (SpeciesContext) startShapeObject;
                                lineAction(speciesContext, fluxReaction);
                            } else if (startShapeObject instanceof Structure) {
                                Structure structure = (Structure) startShapeObject;
                                lineActon(structure, fluxReaction);
                            }
                            // remove temporary edge
                            getReactionCartoon().removeShape(edgeShape);
                            edgeShape = null;
                        } else if (endShape instanceof ReactionContainerShape) {
                            Structure endStructure = (Structure) endShape.getModelObject();
                            Object startObject = null;
                            if (startShape != null) {
                                startObject = startShape.getModelObject();
                            }
                            if (startObject instanceof SimpleReaction) {
                                SimpleReaction reaction = (SimpleReaction) startObject;
                                lineAction(reaction, endStructure);
                            } else if (startObject instanceof FluxReaction) {
                                FluxReaction reaction = (FluxReaction) startObject;
                                lineAction(reaction, endStructure);
                            } else if (startObject instanceof SpeciesContext) {
                                SpeciesContext speciesContextStart = (SpeciesContext) startObject;
                                lineAction(speciesContextStart, endStructure);
                            } else if (startObject instanceof Structure) {
                                Structure startStructure = (Structure) startObject;
                                lineAction(startStructure, endStructure, endShape);
                            }
                        }
                    }
                    saveDiagram();
                    break;
                }
            case LINECATALYST:
                {
                    getGraphPane().setCursor(Cursor.getDefaultCursor());
                    if (bLineStretch && getDragDistanceSquared() >= MIN_DRAG_DISTANCE_TO_CREATE_NEW_ELEMENTS_SQUARED) {
                        bLineStretch = false;
                        // set label and color for line depending on which shape the edge started.
                        // (rather than attachment area on ReactionStepShape)
                        Object startObject = startShape.getModelObject();
                        Object endObject = endShape.getModelObject();
                        ReactionStep reactionStep = null;
                        SpeciesContext speciesContext = null;
                        if (startObject instanceof ReactionStep) {
                            reactionStep = (ReactionStep) startObject;
                            if (endObject instanceof SpeciesContext) {
                                if (StructureUtil.reactionHereCanHaveParticipantThere(reactionStep.getStructure(), ((SpeciesContext) endObject).getStructure())) {
                                    speciesContext = (SpeciesContext) endObject;
                                }
                            } else if (endObject instanceof Structure) {
                                Structure endStructure = (Structure) endObject;
                                if (StructureUtil.reactionHereCanHaveParticipantThere(reactionStep.getStructure(), endStructure)) {
                                    speciesContext = getReactionCartoon().getModel().createSpeciesContext(endStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    Point endPos = edgeShape.getEnd();
                                    positionShapeForObject(endStructure, speciesContext, endPos);
                                }
                            }
                        } else if (startObject instanceof SpeciesContext) {
                            speciesContext = (SpeciesContext) startObject;
                            if (endObject instanceof ReactionStep) {
                                if (StructureUtil.reactionHereCanHaveParticipantThere(((ReactionStep) endObject).getStructure(), speciesContext.getStructure())) {
                                    reactionStep = (ReactionStep) endObject;
                                }
                            } else if (endObject instanceof Structure) {
                                Structure endStructure = (Structure) endObject;
                                if (StructureUtil.reactionHereCanHaveParticipantThere(endStructure, speciesContext.getStructure())) {
                                    reactionStep = getReactionCartoon().getModel().createSimpleReaction(endStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    Point endPos = edgeShape.getEnd();
                                    positionShapeForObject(endStructure, reactionStep, endPos);
                                }
                            }
                        } else if (startObject instanceof Structure) {
                            Structure startStructure = (Structure) startObject;
                            if (endObject instanceof ReactionStep) {
                                reactionStep = (ReactionStep) endObject;
                                if (StructureUtil.reactionHereCanHaveParticipantThere(reactionStep.getStructure(), startStructure)) {
                                    speciesContext = getReactionCartoon().getModel().createSpeciesContext(startStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    positionShapeForObject(startStructure, speciesContext, startPointWorld);
                                }
                            } else if (endObject instanceof SpeciesContext) {
                                speciesContext = (SpeciesContext) endObject;
                                if (StructureUtil.reactionHereCanHaveParticipantThere(startStructure, speciesContext.getStructure())) {
                                    reactionStep = getReactionCartoon().getModel().createSimpleReaction(startStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    positionShapeForObject(startStructure, reactionStep, startPointWorld);
                                }
                            } else if (endObject instanceof Structure) {
                                Structure endStructure = (Structure) endObject;
                                if (StructureUtil.reactionHereCanHaveParticipantThere(startStructure, endStructure)) {
                                    speciesContext = getReactionCartoon().getModel().createSpeciesContext(endStructure);
                                    reactionStep = getReactionCartoon().getModel().createSimpleReaction(startStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    Point endPos = edgeShape.getEnd();
                                    positionShapeForObject(endStructure, speciesContext, endPos);
                                    positionShapeForObject(startStructure, reactionStep, startPointWorld);
                                } else if (StructureUtil.reactionHereCanHaveParticipantThere(endStructure, startStructure)) {
                                    speciesContext = getReactionCartoon().getModel().createSpeciesContext(startStructure);
                                    reactionStep = getReactionCartoon().getModel().createSimpleReaction(endStructure);
                                    getReactionCartoon().notifyChangeEvent();
                                    positionShapeForObject(startStructure, speciesContext, startPointWorld);
                                    Point endPos = edgeShape.getEnd();
                                    positionShapeForObject(endStructure, reactionStep, endPos);
                                }
                            }
                        }
                        if (reactionStep != null && speciesContext != null) {
                            Catalyst catalyst = null;
                            for (ReactionParticipant participant : reactionStep.getReactionParticipants()) {
                                if (participant instanceof Catalyst && participant.getSpeciesContext().equals(speciesContext)) {
                                    catalyst = (Catalyst) participant;
                                }
                            }
                            if (catalyst == null) {
                                reactionStep.addCatalyst(speciesContext);
                                getReactionCartoon().notifyChangeEvent();
                            }
                        // add reactionParticipant to model
                        } else {
                            getGraphPane().repaint();
                        }
                    }
                    saveDiagram();
                    break;
                }
            default:
                {
                    break;
                }
        }
    } catch (Exception e) {
        System.out.println("CartoonTool.mouseReleased: uncaught exception");
        e.printStackTrace(System.out);
    }
    resetMouseActionHistory();
    getGraphPane().repaint();
}