Examples with MathSymbolMapping cbit.vcell.mapping.MathSymbolMapping used on opensource projects

Example 6 with MathSymbolMapping

use of cbit.vcell.mapping.MathSymbolMapping in project vcell by virtualcell.

the class SimulationRepresentation method getParameters.

private static ParameterRepresentation[] getParameters(BioModel bioModel, SimulationRep simulationRep) {
    SimulationContext simContext = null;
    for (SimulationContext sc : bioModel.getSimulationContexts()) {
        if (sc.getMathDescription().getKey().equals(simulationRep.getMathKey())) {
            simContext = sc;
            break;
        }
    }
    if (simContext == null) {
        return null;
    }
    // initialize to old mathDescription in case error generating math
    MathDescription mathDesc = simContext.getMathDescription();
    MathMapping mathMapping = simContext.createNewMathMapping();
    MathSymbolMapping mathSymbolMapping = null;
    try {
        mathDesc = mathMapping.getMathDescription();
        mathSymbolMapping = mathMapping.getMathSymbolMapping();
    } catch (Exception e1) {
        System.err.println(e1.getMessage());
    }
    ArrayList<ParameterRepresentation> parameterReps = new ArrayList<ParameterRepresentation>();
    Enumeration<Constant> enumMath = mathDesc.getConstants();
    while (enumMath.hasMoreElements()) {
        Constant constant = enumMath.nextElement();
        if (constant.getExpression().isNumeric()) {
            SymbolTableEntry biologicalSymbolTableEntry = null;
            if (mathSymbolMapping != null) {
                SymbolTableEntry[] stes = mathSymbolMapping.getBiologicalSymbol(constant);
                if (stes != null && stes.length >= 1) {
                    biologicalSymbolTableEntry = stes[0];
                }
            }
            if (biologicalSymbolTableEntry instanceof ReservedSymbol) {
                continue;
            }
            try {
                parameterReps.add(new ParameterRepresentation(constant.getName(), constant.getExpression().evaluateConstant(), biologicalSymbolTableEntry));
            } catch (ExpressionException e) {
                // can't happen, because constant expression is numeric
                e.printStackTrace();
            }
        }
    }
    return parameterReps.toArray(new ParameterRepresentation[0]);
}

Example 7 with MathSymbolMapping

use of cbit.vcell.mapping.MathSymbolMapping in project vcell by virtualcell.

the class ParameterMappingPanel method jMenuItemCopy_ActionPerformed.

/**
 * Comment
 */
private void jMenuItemCopy_ActionPerformed(java.awt.event.ActionEvent actionEvent) {
    if (actionEvent.getSource() == getJMenuItemCopy() || actionEvent.getSource() == getJMenuItemCopyAll()) {
        try {
            // 
            // Copy Optimization Parameters (Initial Guess or Solution)
            // 
            int[] rows = null;
            if (actionEvent.getSource() == getJMenuItemCopyAll()) {
                rows = new int[getScrollPaneTable().getRowCount()];
                for (int i = 0; i < rows.length; i += 1) {
                    rows[i] = i;
                }
            } else {
                rows = getScrollPaneTable().getSelectedRows();
            }
            SimulationContext sc = getParameterEstimationTask().getModelOptimizationSpec().getSimulationContext();
            MathSymbolMapping msm = null;
            try {
                MathMapping mm = sc.createNewMathMapping();
                msm = mm.getMathSymbolMapping();
            } catch (Exception e) {
                e.printStackTrace(System.out);
                DialogUtils.showWarningDialog(this, "current math not valid, some paste operations will be limited\n\nreason: " + e.getMessage());
            }
            boolean bInitialGuess = (getScrollPaneTable().getSelectedColumn() == ParameterMappingTableModel.COLUMN_CURRENTVALUE);
            ParameterMappingSpec[] parameterMappingSpecs = new ParameterMappingSpec[rows.length];
            java.util.Vector<SymbolTableEntry> primarySymbolTableEntriesV = new java.util.Vector<SymbolTableEntry>();
            java.util.Vector<SymbolTableEntry> alternateSymbolTableEntriesV = new java.util.Vector<SymbolTableEntry>();
            java.util.Vector<Expression> resolvedValuesV = new java.util.Vector<Expression>();
            // 
            // Create formatted string for text/spreadsheet pasting.
            // 
            StringBuffer sb = new StringBuffer();
            sb.append("\"Parameters for (Optimization Task)" + getParameterEstimationTask().getName() + " -> " + "(BioModel)" + getParameterEstimationTask().getModelOptimizationSpec().getSimulationContext().getBioModel().getName() + " -> " + "(App)" + getParameterEstimationTask().getModelOptimizationSpec().getSimulationContext().getName() + "\"\n");
            sb.append("\"Parameter Name\"\t\"" + (bInitialGuess ? "Initial Guess" : "Solution") + "\"\n");
            for (int i = 0; i < rows.length; i += 1) {
                ParameterMappingSpec pms = parameterMappingTableModel.getValueAt(rows[i]);
                parameterMappingSpecs[i] = pms;
                primarySymbolTableEntriesV.add(pms.getModelParameter());
                if (msm != null) {
                    alternateSymbolTableEntriesV.add(msm.getVariable(pms.getModelParameter()));
                } else {
                    alternateSymbolTableEntriesV.add(null);
                }
                Double resolvedValue = null;
                if (!bInitialGuess) {
                    resolvedValue = getParameterEstimationTask().getCurrentSolution(pms);
                }
                if (resolvedValue == null) {
                    resolvedValue = new Double(pms.getCurrent());
                }
                resolvedValuesV.add(new Expression(resolvedValue.doubleValue()));
                sb.append("\"" + parameterMappingSpecs[i].getModelParameter().getName() + "\"\t" + resolvedValue + "\n");
            }
            // 
            // Send to clipboard
            // 
            VCellTransferable.ResolvedValuesSelection rvs = new VCellTransferable.ResolvedValuesSelection((SymbolTableEntry[]) BeanUtils.getArray(primarySymbolTableEntriesV, SymbolTableEntry.class), (SymbolTableEntry[]) BeanUtils.getArray(alternateSymbolTableEntriesV, SymbolTableEntry.class), (Expression[]) BeanUtils.getArray(resolvedValuesV, Expression.class), sb.toString());
            VCellTransferable.sendToClipboard(rvs);
        } catch (Throwable e) {
            PopupGenerator.showErrorDialog(this, "ParameterMappingPanel copy failed.  " + e.getMessage(), e);
        }
    }
}

Example 8 with MathSymbolMapping

use of cbit.vcell.mapping.MathSymbolMapping in project vcell by virtualcell.

the class SEDMLExporter method translateBioModelToSedML.

private void translateBioModelToSedML(String savePath, String sBaseFileName, boolean bForceVCML, boolean bHasDataOnly, boolean bFromOmex) {
    // true if invoked for omex export, false if for sedml
    sbmlFilePathStrAbsoluteList.clear();
    // models
    try {
        SimulationContext[] simContexts = vcBioModel.getSimulationContexts();
        cbit.vcell.model.Model vcModel = vcBioModel.getModel();
        // "urn:sedml:language:sbml";
        String sbmlLanguageURN = SUPPORTED_LANGUAGE.SBML_GENERIC.getURN();
        // "urn:sedml:language:vcml";
        String vcmlLanguageURN = SUPPORTED_LANGUAGE.VCELL_GENERIC.getURN();
        String bioModelName = vcBioModel.getName();
        String bioModelID = TokenMangler.mangleToSName(bioModelName);
        // String usrHomeDirPath = ResourceUtil.getUserHomeDir().getAbsolutePath();
        // to get Xpath string for variables.
        SBMLSupport sbmlSupport = new SBMLSupport();
        // for model count, task subcount
        int simContextCnt = 0;
        boolean bSpeciesAddedAsDataGens = false;
        String sedmlNotesStr = "";
        for (SimulationContext simContext : simContexts) {
            // Export the application itself to SBML, with default overrides
            String sbmlString = null;
            int level = 3;
            int version = 1;
            boolean isSpatial = simContext.getGeometry().getDimension() > 0 ? true : false;
            // local to global translation map
            Map<Pair<String, String>, String> l2gMap = null;
            boolean sbmlExportFailed = false;
            if (!bForceVCML) {
                // we try to save to SBML
                try {
                    // to compute and set the sizes of the remaining structures.
                    if (!simContext.getGeometryContext().isAllSizeSpecifiedPositive()) {
                        Structure structure = simContext.getModel().getStructure(0);
                        double structureSize = 1.0;
                        StructureMapping structMapping = simContext.getGeometryContext().getStructureMapping(structure);
                        StructureSizeSolver.updateAbsoluteStructureSizes(simContext, structure, structureSize, structMapping.getSizeParameter().getUnitDefinition());
                    // StructureMapping structureMapping = simContext.getGeometryContext().getStructureMappings()[0];
                    // StructureSizeSolver.updateAbsoluteStructureSizes(simContext, structureMapping.getStructure(), 1.0, structureMapping.getSizeParameter().getUnitDefinition());
                    }
                    SBMLExporter sbmlExporter = new SBMLExporter(vcBioModel, level, version, isSpatial);
                    sbmlExporter.setSelectedSimContext(simContext);
                    // no sim job
                    sbmlExporter.setSelectedSimulationJob(null);
                    sbmlString = sbmlExporter.getSBMLString();
                    l2gMap = sbmlExporter.getLocalToGlobalTranslationMap();
                } catch (Exception e) {
                    sbmlExportFailed = true;
                }
            } else {
                // we want to force VCML, we act as if saving to SBML failed
                sbmlExportFailed = true;
            }
            // marked as failed, even if exporting to sbml didn't throw any exception
            if (simContext.getGeometry().getDimension() > 0 && simContext.getApplicationType() == Application.NETWORK_STOCHASTIC) {
                sbmlExportFailed = true;
            } else if (simContext.getApplicationType() == Application.RULE_BASED_STOCHASTIC) {
                sbmlExportFailed = true;
            }
            String simContextName = simContext.getName();
            String filePathStrAbsolute = null;
            String filePathStrRelative = null;
            String urn = null;
            String simContextId = null;
            if (sbmlExportFailed) {
                // filePathStrAbsolute = Paths.get(savePath, bioModelName + ".vcml").toString();
                filePathStrAbsolute = Paths.get(savePath, sBaseFileName + ".vcml").toString();
                // filePathStrRelative = bioModelName + ".vcml";
                filePathStrRelative = sBaseFileName + ".vcml";
                if (!bFromOmex) {
                    // the vcml file is managed elsewhere when called for omex
                    String vcmlString = XmlHelper.bioModelToXML(vcBioModel);
                    XmlUtil.writeXMLStringToFile(vcmlString, filePathStrAbsolute, true);
                    sbmlFilePathStrAbsoluteList.add(filePathStrRelative);
                }
                urn = vcmlLanguageURN;
                sedmlModel.addModel(new Model(bioModelID, bioModelName, urn, filePathStrRelative));
            } else {
                // filePathStrAbsolute = Paths.get(savePath, bioModelName + "_" + TokenMangler.mangleToSName(simContextName) + ".xml").toString();
                filePathStrAbsolute = Paths.get(savePath, sBaseFileName + "_" + TokenMangler.mangleToSName(simContextName) + ".xml").toString();
                // filePathStrRelative = bioModelName + "_" +  TokenMangler.mangleToSName(simContextName) + ".xml";
                filePathStrRelative = sBaseFileName + "_" + TokenMangler.mangleToSName(simContextName) + ".xml";
                XmlUtil.writeXMLStringToFile(sbmlString, filePathStrAbsolute, true);
                urn = sbmlLanguageURN;
                sbmlFilePathStrAbsoluteList.add(filePathStrRelative);
                simContextId = TokenMangler.mangleToSName(simContextName);
                sedmlModel.addModel(new Model(simContextId, simContextName, urn, filePathStrRelative));
            }
            MathMapping mathMapping = simContext.createNewMathMapping();
            MathSymbolMapping mathSymbolMapping = mathMapping.getMathSymbolMapping();
            // -------
            // create sedml objects (simulation, task, datagenerators, report, plot) for each simulation in simcontext
            // -------
            int simCount = 0;
            String taskRef = null;
            int overrideCount = 0;
            for (Simulation vcSimulation : simContext.getSimulations()) {
                if (bHasDataOnly) {
                    // skip simulations not present in hash
                    if (!simsToExport.contains(vcSimulation))
                        continue;
                }
                // 1 -------> check compatibility
                // if simContext is non-spatial stochastic, check if sim is histogram; if so, skip it, it can't be encoded in sedml 1.x
                SolverTaskDescription simTaskDesc = vcSimulation.getSolverTaskDescription();
                if (simContext.getGeometry().getDimension() == 0 && simContext.isStoch()) {
                    long numOfTrials = simTaskDesc.getStochOpt().getNumOfTrials();
                    if (numOfTrials > 1) {
                        String msg = "\n\t" + simContextName + " ( " + vcSimulation.getName() + " ) : export of non-spatial stochastic simulation with histogram option to SEDML not supported at this time.";
                        sedmlNotesStr += msg;
                        continue;
                    }
                }
                // 2 ------->
                // create Algorithm and sedmlSimulation (UniformtimeCourse)
                SolverDescription vcSolverDesc = simTaskDesc.getSolverDescription();
                String kiSAOIdStr = vcSolverDesc.getKisao();
                Algorithm sedmlAlgorithm = new Algorithm(kiSAOIdStr);
                TimeBounds vcSimTimeBounds = simTaskDesc.getTimeBounds();
                double startingTime = vcSimTimeBounds.getStartingTime();
                String simName = vcSimulation.getName();
                UniformTimeCourse utcSim = new UniformTimeCourse(TokenMangler.mangleToSName(simName), simName, startingTime, startingTime, vcSimTimeBounds.getEndingTime(), (int) simTaskDesc.getExpectedNumTimePoints(), sedmlAlgorithm);
                // --------- deal with error tolerance
                boolean enableAbsoluteErrorTolerance;
                boolean enableRelativeErrorTolerance;
                if (vcSolverDesc.isSemiImplicitPdeSolver() || vcSolverDesc.isChomboSolver()) {
                    enableAbsoluteErrorTolerance = false;
                    enableRelativeErrorTolerance = true;
                } else if (vcSolverDesc.hasErrorTolerance()) {
                    enableAbsoluteErrorTolerance = true;
                    enableRelativeErrorTolerance = true;
                } else {
                    enableAbsoluteErrorTolerance = false;
                    enableRelativeErrorTolerance = false;
                }
                if (enableAbsoluteErrorTolerance) {
                    ErrorTolerance et = simTaskDesc.getErrorTolerance();
                    String kisaoStr = ErrorTolerance.ErrorToleranceDescription.Absolute.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, et.getAbsoluteErrorTolerance() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                if (enableRelativeErrorTolerance) {
                    ErrorTolerance et = simTaskDesc.getErrorTolerance();
                    String kisaoStr = ErrorTolerance.ErrorToleranceDescription.Relative.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, et.getRelativeErrorTolerance() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                // ---------- deal with time step (code adapted from TimeSpecPanel.refresh()
                boolean enableDefaultTimeStep;
                boolean enableMinTimeStep;
                boolean enableMaxTimeStep;
                if (vcSolverDesc.compareEqual(SolverDescription.StochGibson)) {
                    // stochastic time
                    enableDefaultTimeStep = false;
                    enableMinTimeStep = false;
                    enableMaxTimeStep = false;
                } else if (vcSolverDesc.compareEqual(SolverDescription.NFSim)) {
                    enableDefaultTimeStep = false;
                    enableMinTimeStep = false;
                    enableMaxTimeStep = false;
                } else {
                    // fixed time step solvers and non spatial stochastic solvers only show default time step.
                    if (!vcSolverDesc.hasVariableTimestep() || vcSolverDesc.isNonSpatialStochasticSolver()) {
                        enableDefaultTimeStep = true;
                        enableMinTimeStep = false;
                        enableMaxTimeStep = false;
                    } else {
                        // variable time step solvers shows min and max, but sundials solvers don't show min
                        enableDefaultTimeStep = false;
                        enableMinTimeStep = true;
                        enableMaxTimeStep = true;
                        if (vcSolverDesc.hasSundialsTimeStepping()) {
                            enableMinTimeStep = false;
                        }
                    }
                }
                TimeStep ts = simTaskDesc.getTimeStep();
                if (enableDefaultTimeStep) {
                    String kisaoStr = TimeStep.TimeStepDescription.Default.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, ts.getDefaultTimeStep() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                if (enableMinTimeStep) {
                    String kisaoStr = TimeStep.TimeStepDescription.Minimum.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, ts.getMinimumTimeStep() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                if (enableMaxTimeStep) {
                    String kisaoStr = TimeStep.TimeStepDescription.Maximum.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, ts.getMaximumTimeStep() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                if (simTaskDesc.getSimulation().getMathDescription().isNonSpatialStoch()) {
                    // ------- deal with seed
                    NonspatialStochSimOptions nssso = simTaskDesc.getStochOpt();
                    if (nssso.isUseCustomSeed()) {
                        // 488
                        String kisaoStr = SolverDescription.AlgorithmParameterDescription.Seed.getKisao();
                        AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, nssso.getCustomSeed() + "");
                        sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                    }
                } else {
                    // (... isRuleBased(), isSpatial(), isMovingMembrane(), isSpatialHybrid() ...
                    ;
                }
                if (// -------- deal with hybrid solvers (non-spatial)
                vcSolverDesc == SolverDescription.HybridEuler || vcSolverDesc == SolverDescription.HybridMilAdaptive || vcSolverDesc == SolverDescription.HybridMilstein) {
                    NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                    String kisaoStr = SolverDescription.AlgorithmParameterDescription.Epsilon.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, nssho.getEpsilon() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                    kisaoStr = SolverDescription.AlgorithmParameterDescription.Lambda.getKisao();
                    sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, nssho.getLambda() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                    kisaoStr = SolverDescription.AlgorithmParameterDescription.MSRTolerance.getKisao();
                    sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, nssho.getMSRTolerance() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                if (vcSolverDesc == SolverDescription.HybridMilAdaptive) {
                    // --------- one more param for hybrid-adaptive
                    NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                    String kisaoStr = SolverDescription.AlgorithmParameterDescription.SDETolerance.getKisao();
                    AlgorithmParameter sedmlAlgorithmParameter = new AlgorithmParameter(kisaoStr, nssho.getSDETolerance() + "");
                    sedmlAlgorithm.addAlgorithmParameter(sedmlAlgorithmParameter);
                }
                // TODO: consider adding notes for the algorithm parameters, to provide human-readable description of kisao terms
                // sedmlAlgorithm.addNote(createNotesElement(algorithmNotesStr));
                // TODO: even better, AlgorithmParameter in sed-ml should also have a human readable "name" field
                // add a note to utcSim to indicate actual solver name
                String simNotesStr = "Actual Solver Name : '" + vcSolverDesc.getDisplayLabel() + "'.";
                utcSim.addNote(createNotesElement(simNotesStr));
                sedmlModel.addSimulation(utcSim);
                // 3 ------->
                // create Tasks
                MathOverrides mathOverrides = vcSimulation.getMathOverrides();
                if ((sbmlExportFailed == false) && mathOverrides != null && mathOverrides.hasOverrides()) {
                    String[] overridenConstantNames = mathOverrides.getOverridenConstantNames();
                    String[] scannedConstantsNames = mathOverrides.getScannedConstantNames();
                    HashMap<String, String> scannedParamHash = new HashMap<String, String>();
                    HashMap<String, String> unscannedParamHash = new HashMap<String, String>();
                    for (String name : scannedConstantsNames) {
                        scannedParamHash.put(name, name);
                    }
                    for (String name : overridenConstantNames) {
                        if (!scannedParamHash.containsKey(name)) {
                            unscannedParamHash.put(name, name);
                        }
                    }
                    if (!unscannedParamHash.isEmpty() && scannedParamHash.isEmpty()) {
                        // only parameters with simple overrides (numeric/expression) no scans
                        // create new model with change for each parameter that has override; add simple task
                        String overriddenSimContextId = simContextId + "_" + overrideCount;
                        String overriddenSimContextName = simContextName + " modified";
                        Model sedModel = new Model(overriddenSimContextId, overriddenSimContextName, sbmlLanguageURN, simContextId);
                        overrideCount++;
                        for (String unscannedParamName : unscannedParamHash.values()) {
                            SymbolTableEntry ste = getSymbolTableEntryForModelEntity(mathSymbolMapping, unscannedParamName);
                            Expression unscannedParamExpr = mathOverrides.getActualExpression(unscannedParamName, 0);
                            if (unscannedParamExpr.isNumeric()) {
                                // if expression is numeric, add ChangeAttribute to model created above
                                XPathTarget targetXpath = getTargetAttributeXPath(ste, l2gMap);
                                ChangeAttribute changeAttribute = new ChangeAttribute(targetXpath, unscannedParamExpr.infix());
                                sedModel.addChange(changeAttribute);
                            } else {
                                // non-numeric expression : add 'computeChange' to modified model
                                ASTNode math = Libsedml.parseFormulaString(unscannedParamExpr.infix());
                                XPathTarget targetXpath = getTargetXPath(ste, l2gMap);
                                ComputeChange computeChange = new ComputeChange(targetXpath, math);
                                String[] exprSymbols = unscannedParamExpr.getSymbols();
                                // }
                                for (String symbol : exprSymbols) {
                                    String symbolName = TokenMangler.mangleToSName(symbol);
                                    SymbolTableEntry ste1 = vcModel.getEntry(symbol);
                                    if (ste != null) {
                                        if (ste1 instanceof SpeciesContext || ste1 instanceof Structure || ste1 instanceof ModelParameter) {
                                            XPathTarget ste1_XPath = getTargetXPath(ste1, l2gMap);
                                            org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(symbolName, symbolName, taskRef, ste1_XPath.getTargetAsString());
                                            computeChange.addVariable(sedmlVar);
                                        } else {
                                            double doubleValue = 0.0;
                                            if (ste1 instanceof ReservedSymbol) {
                                                doubleValue = getReservedSymbolValue(ste1);
                                            }
                                            Parameter sedmlParameter = new Parameter(symbolName, symbolName, doubleValue);
                                            computeChange.addParameter(sedmlParameter);
                                        }
                                    } else {
                                        throw new RuntimeException("Symbol '" + symbol + "' used in expression for '" + unscannedParamName + "' not found in model.");
                                    }
                                }
                                sedModel.addChange(computeChange);
                            }
                        }
                        sedmlModel.addModel(sedModel);
                        String taskId = "tsk_" + simContextCnt + "_" + simCount;
                        Task sedmlTask = new Task(taskId, vcSimulation.getName(), sedModel.getId(), utcSim.getId());
                        sedmlModel.addTask(sedmlTask);
                        // to be used later to add dataGenerators : one set of DGs per model (simContext).
                        taskRef = taskId;
                    } else if (!scannedParamHash.isEmpty() && unscannedParamHash.isEmpty()) {
                        // only parameters with scans : only add 1 Task and 1 RepeatedTask
                        String taskId = "tsk_" + simContextCnt + "_" + simCount;
                        Task sedmlTask = new Task(taskId, vcSimulation.getName(), simContextId, utcSim.getId());
                        sedmlModel.addTask(sedmlTask);
                        String repeatedTaskId = "repTsk_" + simContextCnt + "_" + simCount;
                        // TODO: temporary solution - we use as range here the first range
                        String scn = scannedConstantsNames[0];
                        String rId = "range_" + simContextCnt + "_" + simCount + "_" + scn;
                        RepeatedTask rt = new RepeatedTask(repeatedTaskId, repeatedTaskId, true, rId);
                        // to be used later to add dataGenerators - in our case it has to be the repeated task
                        taskRef = repeatedTaskId;
                        SubTask subTask = new SubTask("0", taskId);
                        rt.addSubtask(subTask);
                        for (String scannedConstName : scannedConstantsNames) {
                            ConstantArraySpec constantArraySpec = mathOverrides.getConstantArraySpec(scannedConstName);
                            String rangeId = "range_" + simContextCnt + "_" + simCount + "_" + scannedConstName;
                            // list of Ranges, if sim is parameter scan.
                            if (constantArraySpec != null) {
                                Range r = null;
                                // System.out.println("     " + constantArraySpec.toString());
                                if (constantArraySpec.getType() == ConstantArraySpec.TYPE_INTERVAL) {
                                    // ------ Uniform Range
                                    r = new UniformRange(rangeId, constantArraySpec.getMinValue(), constantArraySpec.getMaxValue(), constantArraySpec.getNumValues());
                                    rt.addRange(r);
                                } else {
                                    // ----- Vector Range
                                    cbit.vcell.math.Constant[] cs = constantArraySpec.getConstants();
                                    ArrayList<Double> values = new ArrayList<Double>();
                                    for (int i = 0; i < cs.length; i++) {
                                        String value = cs[i].getExpression().infix();
                                        values.add(Double.parseDouble(value));
                                    }
                                    r = new VectorRange(rangeId, values);
                                    rt.addRange(r);
                                }
                                // list of Changes
                                SymbolTableEntry ste = getSymbolTableEntryForModelEntity(mathSymbolMapping, scannedConstName);
                                XPathTarget target = getTargetXPath(ste, l2gMap);
                                // ASTNode math1 = new ASTCi(r.getId());		// was scannedConstName
                                ASTNode math1 = Libsedml.parseFormulaString(r.getId());
                                SetValue setValue = new SetValue(target, r.getId(), simContextId);
                                setValue.setMath(math1);
                                rt.addChange(setValue);
                            } else {
                                throw new RuntimeException("No scan ranges found for scanned parameter : '" + scannedConstName + "'.");
                            }
                        }
                        sedmlModel.addTask(rt);
                    } else {
                        // both scanned and simple parameters : create new model with change for each simple override; add RepeatedTask
                        // create new model with change for each unscanned parameter that has override
                        String overriddenSimContextId = simContextId + "_" + overrideCount;
                        String overriddenSimContextName = simContextName + " modified";
                        Model sedModel = new Model(overriddenSimContextId, overriddenSimContextName, sbmlLanguageURN, simContextId);
                        overrideCount++;
                        String taskId = "tsk_" + simContextCnt + "_" + simCount;
                        Task sedmlTask = new Task(taskId, vcSimulation.getName(), overriddenSimContextId, utcSim.getId());
                        sedmlModel.addTask(sedmlTask);
                        // scanned parameters
                        String repeatedTaskId = "repTsk_" + simContextCnt + "_" + simCount;
                        // TODO: temporary solution - we use as range here the first range
                        String scn = scannedConstantsNames[0];
                        String rId = "range_" + simContextCnt + "_" + simCount + "_" + scn;
                        RepeatedTask rt = new RepeatedTask(repeatedTaskId, repeatedTaskId, true, rId);
                        // to be used later to add dataGenerators - in our case it has to be the repeated task
                        taskRef = repeatedTaskId;
                        SubTask subTask = new SubTask("0", taskId);
                        rt.addSubtask(subTask);
                        for (String scannedConstName : scannedConstantsNames) {
                            ConstantArraySpec constantArraySpec = mathOverrides.getConstantArraySpec(scannedConstName);
                            String rangeId = "range_" + simContextCnt + "_" + simCount + "_" + scannedConstName;
                            // list of Ranges, if sim is parameter scan.
                            if (constantArraySpec != null) {
                                Range r = null;
                                // System.out.println("     " + constantArraySpec.toString());
                                if (constantArraySpec.getType() == ConstantArraySpec.TYPE_INTERVAL) {
                                    // ------ Uniform Range
                                    r = new UniformRange(rangeId, constantArraySpec.getMinValue(), constantArraySpec.getMaxValue(), constantArraySpec.getNumValues());
                                    rt.addRange(r);
                                } else {
                                    // ----- Vector Range
                                    cbit.vcell.math.Constant[] cs = constantArraySpec.getConstants();
                                    ArrayList<Double> values = new ArrayList<Double>();
                                    for (int i = 0; i < cs.length; i++) {
                                        String value = cs[i].getExpression().infix() + ", ";
                                        values.add(Double.parseDouble(value));
                                    }
                                    r = new VectorRange(rangeId, values);
                                    rt.addRange(r);
                                }
                                // use scannedParamHash to store rangeId for that param, since it might be needed if unscanned param has a scanned param in expr.
                                if (scannedParamHash.get(scannedConstName).equals(scannedConstName)) {
                                    // the hash was originally populated as <scannedParamName, scannedParamName>. Replace 'value' with rangeId for scannedParam
                                    scannedParamHash.put(scannedConstName, r.getId());
                                }
                                // create setValue for scannedConstName
                                SymbolTableEntry ste2 = getSymbolTableEntryForModelEntity(mathSymbolMapping, scannedConstName);
                                XPathTarget target1 = getTargetXPath(ste2, l2gMap);
                                ASTNode math1 = new ASTCi(scannedConstName);
                                SetValue setValue1 = new SetValue(target1, r.getId(), sedModel.getId());
                                setValue1.setMath(math1);
                                rt.addChange(setValue1);
                            } else {
                                throw new RuntimeException("No scan ranges found for scanned parameter : '" + scannedConstName + "'.");
                            }
                        }
                        // for unscanned parameter overrides
                        for (String unscannedParamName : unscannedParamHash.values()) {
                            SymbolTableEntry ste = getSymbolTableEntryForModelEntity(mathSymbolMapping, unscannedParamName);
                            Expression unscannedParamExpr = mathOverrides.getActualExpression(unscannedParamName, 0);
                            if (unscannedParamExpr.isNumeric()) {
                                // if expression is numeric, add ChangeAttribute to model created above
                                XPathTarget targetXpath = getTargetAttributeXPath(ste, l2gMap);
                                ChangeAttribute changeAttribute = new ChangeAttribute(targetXpath, unscannedParamExpr.infix());
                                sedModel.addChange(changeAttribute);
                            } else {
                                // check for any scanned parameter in unscanned parameter expression
                                ASTNode math = Libsedml.parseFormulaString(unscannedParamExpr.infix());
                                String[] exprSymbols = unscannedParamExpr.getSymbols();
                                boolean bHasScannedParameter = false;
                                String scannedParamNameInUnscannedParamExp = null;
                                for (String symbol : exprSymbols) {
                                    if (scannedParamHash.get(symbol) != null) {
                                        bHasScannedParameter = true;
                                        scannedParamNameInUnscannedParamExp = new String(symbol);
                                        // @TODO check for multiple scannedParameters in expression.
                                        break;
                                    }
                                }
                                // (scanned parameter in expr) ? (add setValue for unscanned param in repeatedTask) : (add computeChange to modifiedModel)
                                if (bHasScannedParameter && scannedParamNameInUnscannedParamExp != null) {
                                    // create setValue for unscannedParamName (which contains a scanned param in its expression)
                                    SymbolTableEntry entry = getSymbolTableEntryForModelEntity(mathSymbolMapping, unscannedParamName);
                                    XPathTarget target = getTargetXPath(entry, l2gMap);
                                    String rangeId = scannedParamHash.get(scannedParamNameInUnscannedParamExp);
                                    // @TODO: we have no range??
                                    SetValue setValue = new SetValue(target, rangeId, sedModel.getId());
                                    setValue.setMath(math);
                                    rt.addChange(setValue);
                                } else {
                                    // non-numeric expression : add 'computeChange' to modified model
                                    XPathTarget targetXpath = getTargetXPath(ste, l2gMap);
                                    ComputeChange computeChange = new ComputeChange(targetXpath, math);
                                    for (String symbol : exprSymbols) {
                                        String symbolName = TokenMangler.mangleToSName(symbol);
                                        SymbolTableEntry ste1 = vcModel.getEntry(symbol);
                                        // ste1 could be a math parameter, hence the above could return null
                                        if (ste1 == null) {
                                            ste1 = simContext.getMathDescription().getEntry(symbol);
                                        }
                                        if (ste1 != null) {
                                            if (ste1 instanceof SpeciesContext || ste1 instanceof Structure || ste1 instanceof ModelParameter) {
                                                XPathTarget ste1_XPath = getTargetXPath(ste1, l2gMap);
                                                org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(symbolName, symbolName, taskRef, ste1_XPath.getTargetAsString());
                                                computeChange.addVariable(sedmlVar);
                                            } else {
                                                double doubleValue = 0.0;
                                                if (ste1 instanceof ReservedSymbol) {
                                                    doubleValue = getReservedSymbolValue(ste1);
                                                } else if (ste instanceof Function) {
                                                    try {
                                                        doubleValue = ste.getExpression().evaluateConstant();
                                                    } catch (Exception e) {
                                                        e.printStackTrace(System.out);
                                                        throw new RuntimeException("Unable to evaluate function '" + ste.getName() + "' used in '" + unscannedParamName + "' expression : ", e);
                                                    }
                                                } else {
                                                    doubleValue = ste.getConstantValue();
                                                }
                                                // TODO: shouldn't be s1_init_uM which is a math symbol, should be s0 (so use the ste-something from above)
                                                // TODO: revert to Variable, not Parameter
                                                Parameter sedmlParameter = new Parameter(symbolName, symbolName, doubleValue);
                                                computeChange.addParameter(sedmlParameter);
                                            }
                                        } else {
                                            throw new RuntimeException("Symbol '" + symbol + "' used in expression for '" + unscannedParamName + "' not found in model.");
                                        }
                                    }
                                    sedModel.addChange(computeChange);
                                }
                            }
                        }
                        sedmlModel.addModel(sedModel);
                        sedmlModel.addTask(rt);
                    }
                } else {
                    // no math overrides, add basic task.
                    String taskId = "tsk_" + simContextCnt + "_" + simCount;
                    // temporary workaround
                    // TODO better fix
                    simContextId = sbmlExportFailed ? bioModelID : simContextId;
                    Task sedmlTask = new Task(taskId, vcSimulation.getName(), simContextId, utcSim.getId());
                    sedmlModel.addTask(sedmlTask);
                    // to be used later to add dataGenerators : one set of DGs per model (simContext).
                    taskRef = taskId;
                }
                // 4 ------->
                // Create DataGenerators
                List<DataGenerator> dataGeneratorsOfSim = new ArrayList<DataGenerator>();
                // add one DataGenerator for 'time'
                String timeDataGenPrefix = DATAGENERATOR_TIME_NAME + "_" + taskRef;
                DataGenerator timeDataGen = sedmlModel.getDataGeneratorWithId(timeDataGenPrefix);
                org.jlibsedml.Variable timeVar = new org.jlibsedml.Variable(DATAGENERATOR_TIME_SYMBOL + "_" + taskRef, DATAGENERATOR_TIME_SYMBOL, taskRef, VariableSymbol.TIME);
                ASTNode math = Libsedml.parseFormulaString(DATAGENERATOR_TIME_SYMBOL + "_" + taskRef);
                timeDataGen = new DataGenerator(timeDataGenPrefix, timeDataGenPrefix, math);
                timeDataGen.addVariable(timeVar);
                sedmlModel.addDataGenerator(timeDataGen);
                dataGeneratorsOfSim.add(timeDataGen);
                // add dataGenerators for species
                // get species list from SBML model.
                // Map<String, String> name2IdMap = new LinkedHashMap<> ();
                String dataGenIdPrefix = "dataGen_" + taskRef;
                if (sbmlExportFailed) {
                    // we try vcml export
                    for (SpeciesContext sc : vcModel.getSpeciesContexts()) {
                        String varName = sc.getName();
                        String varId = varName + "_" + taskRef;
                        // name2IdMap.put(varName, varId);
                        ASTNode varMath = Libsedml.parseFormulaString(varId);
                        String dataGenId = dataGenIdPrefix + "_" + TokenMangler.mangleToSName(varName);
                        DataGenerator dataGen = new DataGenerator(dataGenId, dataGenId, varMath);
                        org.jlibsedml.Variable variable = new org.jlibsedml.Variable(varId, varName, taskRef, XmlHelper.getXPathForSpecies(varName));
                        dataGen.addVariable(variable);
                        sedmlModel.addDataGenerator(dataGen);
                        dataGeneratorsOfSim.add(dataGen);
                    }
                } else {
                    String[] varNamesList = SimSpec.fromSBML(sbmlString).getVarsList();
                    for (String varName : varNamesList) {
                        String varId = varName + "_" + taskRef;
                        // name2IdMap.put(varName, varId);
                        org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(varId, varName, taskRef, sbmlSupport.getXPathForSpecies(varName));
                        ASTNode varMath = Libsedml.parseFormulaString(varId);
                        // "dataGen_" + varCount; - old code
                        String dataGenId = dataGenIdPrefix + "_" + TokenMangler.mangleToSName(varName);
                        DataGenerator dataGen = new DataGenerator(dataGenId, dataGenId, varMath);
                        dataGen.addVariable(sedmlVar);
                        sedmlModel.addDataGenerator(dataGen);
                        dataGeneratorsOfSim.add(dataGen);
                    }
                }
                // add DataGenerators for output functions here
                ArrayList<AnnotatedFunction> outputFunctions = simContext.getOutputFunctionContext().getOutputFunctionsList();
                for (AnnotatedFunction annotatedFunction : outputFunctions) {
                    // Expression originalFunctionExpression = annotatedFunction.getExpression();
                    // Expression modifiedFunctionExpr = new Expression(annotatedFunction.getExpression());
                    // System.out.println("Before: " + originalFunctionExpression);
                    // String[] symbols = modifiedFunctionExpr.getSymbols();
                    // for(String symbol : symbols) {
                    // String id = name2IdMap.get(symbol);
                    // if(id == null) {
                    // System.err.println("Could not find id for " + symbol);
                    // } else {
                    // modifiedFunctionExpr.substituteInPlace(new Expression(symbol), new Expression(id));
                    // }
                    // }
                    // System.out.println("After:  " + modifiedFunctionExpr);
                    // ASTNode funcMath = Libsedml.parseFormulaString(modifiedFunctionExpr.infix());
                    // "dataGen_" + varCount; - old code
                    String dataGenId = dataGenIdPrefix + "_" + TokenMangler.mangleToSName(annotatedFunction.getName());
                    String varId = TokenMangler.mangleToSName(annotatedFunction.getName()) + taskRef;
                    if (sbmlExportFailed) {
                        // VCML
                        Expression exp = new Expression(varId);
                        ASTNode funcMath = Libsedml.parseFormulaString(exp.infix());
                        DataGenerator dataGen = new DataGenerator(dataGenId, dataGenId, funcMath);
                        org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(varId, annotatedFunction.getName(), taskRef, XmlHelper.getXPathForOutputFunction(simContextName, annotatedFunction.getName()));
                        dataGen.addVariable(sedmlVar);
                        sedmlModel.addDataGenerator(dataGen);
                        dataGeneratorsOfSim.add(dataGen);
                    } else {
                    // SBML
                    }
                // String[] functionSymbols = originalFunctionExpression.getSymbols();
                // for (String symbol : functionSymbols) {
                // String symbolName = TokenMangler.mangleToSName(symbol);
                // // try to get symbol from model, if null, try simContext.mathDesc
                // SymbolTableEntry ste = vcModel.getEntry(symbol);
                // if (ste == null) {
                // ste = simContext.getMathDescription().getEntry(symbol);
                // }
                // if (ste instanceof SpeciesContext || ste instanceof Structure || ste instanceof ModelParameter) {
                // XPathTarget targetXPath = getTargetXPath(ste, l2gMap);
                // if(sbmlExportFailed) {		// VCML
                // if(ste instanceof SpeciesContext) {
                // //											String varId = symbolName + "_" + taskRef;
                // //											org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(varId, symbolName, taskRef, XmlHelper.getXPathForSpecies(symbolName));
                // //											dataGen.addVariable(sedmlVar);
                // } else {
                // System.err.println("Not a species");
                // }
                // } else {					// SBML
                // //										String varId = symbolName + "_" + taskRef;
                // //										org.jlibsedml.Variable sedmlVar = new org.jlibsedml.Variable(varId, symbolName, taskRef, targetXPath.getTargetAsString());
                // //										dataGen.addVariable(sedmlVar);
                // }
                // } else {
                // double value = 0.0;
                // if (ste instanceof Function) {
                // try {
                // value = ste.getExpression().evaluateConstant();
                // } catch (Exception e) {
                // e.printStackTrace(System.out);
                // throw new RuntimeException("Unable to evaluate function '" + ste.getName() + "' for output function '" + annotatedFunction.getName() + "'.", e);
                // }
                // } else {
                // value = ste.getConstantValue();
                // }
                // Parameter sedmlParameter = new Parameter(symbolName, symbolName, value);
                // dataGen.addParameter(sedmlParameter);
                // }
                // }
                }
                // ignoring output for spatial deterministic (spatial stochastic is not exported to SEDML) and non-spatial stochastic applications with histogram
                if (!(simContext.getGeometry().getDimension() > 0)) {
                    String plot2dId = "plot2d_" + TokenMangler.mangleToSName(vcSimulation.getName());
                    String reportId = "report_" + TokenMangler.mangleToSName(vcSimulation.getName());
                    // String reportId = "__plot__" + plot2dId;
                    String plotName = simContextName + "_" + simName + "_plot";
                    Plot2D sedmlPlot2d = new Plot2D(plot2dId, plotName);
                    Report sedmlReport = new Report(reportId, plotName);
                    sedmlPlot2d.addNote(createNotesElement("Plot of all variables and output functions from application '" + simContext.getName() + "' ; simulation '" + vcSimulation.getName() + "' in VCell model"));
                    sedmlReport.addNote(createNotesElement("Report of all variables and output functions from application '" + simContext.getName() + "' ; simulation '" + vcSimulation.getName() + "' in VCell model"));
                    DataGenerator dgtime = sedmlModel.getDataGeneratorWithId(DATAGENERATOR_TIME_NAME + "_" + taskRef);
                    String xDataRef = dgtime.getId();
                    String xDatasetXId = "__data_set__" + plot2dId + dgtime.getId();
                    // id, name, label, data generator reference
                    DataSet dataSet = new DataSet(xDatasetXId, DATAGENERATOR_TIME_NAME, xDataRef, xDataRef);
                    sedmlReport.addDataSet(dataSet);
                    // add a curve for each dataGenerator in SEDML model
                    int curveCnt = 0;
                    // String id, String name, ASTNode math
                    for (DataGenerator dg : dataGeneratorsOfSim) {
                        // no curve for time, since time is xDateReference
                        if (dg.getId().equals(xDataRef)) {
                            continue;
                        }
                        String curveId = "curve_" + plot2dId + "_" + dg.getName();
                        String datasetYId = "__data_set__" + plot2dId + dg.getName();
                        Curve curve = new Curve(curveId, dg.getName(), false, false, xDataRef, dg.getId());
                        sedmlPlot2d.addCurve(curve);
                        // // id, name, label, dataRef
                        // // dataset id    <- unique id
                        // // dataset name  <- data generator name
                        // // dataset label <- dataset id
                        DataSet yDataSet = new DataSet(datasetYId, dg.getName(), dg.getId(), dg.getId());
                        sedmlReport.addDataSet(yDataSet);
                        curveCnt++;
                    }
                    sedmlModel.addOutput(sedmlPlot2d);
                    sedmlModel.addOutput(sedmlReport);
                } else {
                    // spatial deterministic
                    if (simContext.getApplicationType().equals(Application.NETWORK_DETERMINISTIC)) {
                        // we ignore spatial stochastic (Smoldyn)
                        if (bForceVCML) {
                            String reportId = "_report_" + TokenMangler.mangleToSName(vcSimulation.getName());
                            Report sedmlReport = new Report(reportId, simContext.getName() + "plots");
                            String xDataRef = sedmlModel.getDataGeneratorWithId(DATAGENERATOR_TIME_NAME + "_" + taskRef).getId();
                            String xDatasetXId = "datasetX_" + DATAGENERATOR_TIME_NAME + "_" + timeDataGen.getId();
                            DataSet dataSetTime = new DataSet(xDatasetXId, xDataRef, xDatasetXId, xDataRef);
                            sedmlReport.addDataSet(dataSetTime);
                            int surfaceCnt = 0;
                            for (DataGenerator dg : dataGeneratorsOfSim) {
                                if (dg.getId().equals(xDataRef)) {
                                    continue;
                                }
                                // String datasetYId = "datasetY_" + surfaceCnt;
                                String datasetYId = "__data_set__" + surfaceCnt + "_" + dg.getName();
                                DataSet yDataSet = new DataSet(datasetYId, dg.getName(), datasetYId, dg.getId());
                                sedmlReport.addDataSet(yDataSet);
                                surfaceCnt++;
                            }
                            sedmlModel.addOutput(sedmlReport);
                        } else {
                            // spatial deterministic SBML
                            // TODO: add surfaces to the plots
                            String plot3dId = "plot3d_" + TokenMangler.mangleToSName(vcSimulation.getName());
                            String reportId = "report_" + TokenMangler.mangleToSName(vcSimulation.getName());
                            String plotName = simContext.getName() + "plots";
                            Plot3D sedmlPlot3d = new Plot3D(plot3dId, plotName);
                            Report sedmlReport = new Report(reportId, plotName);
                            sedmlPlot3d.addNote(createNotesElement("Plot of all variables and output functions from application '" + simContext.getName() + "' ; simulation '" + vcSimulation.getName() + "' in VCell model"));
                            sedmlReport.addNote(createNotesElement("Report of all variables and output functions from application '" + simContext.getName() + "' ; simulation '" + vcSimulation.getName() + "' in VCell model"));
                            DataGenerator dgtime = sedmlModel.getDataGeneratorWithId(DATAGENERATOR_TIME_NAME + "_" + taskRef);
                            String xDataRef = dgtime.getId();
                            String xDatasetXId = "__data_set__" + plot3dId + dgtime.getId();
                            // id, name, label, data generator reference
                            DataSet dataSet = new DataSet(xDatasetXId, DATAGENERATOR_TIME_NAME, xDataRef, xDataRef);
                            sedmlReport.addDataSet(dataSet);
                            // add a curve for each dataGenerator in SEDML model
                            int curveCnt = 0;
                            // String id, String name, ASTNode math
                            for (DataGenerator dg : dataGeneratorsOfSim) {
                                // no curve for time, since time is xDateReference
                                if (dg.getId().equals(xDataRef)) {
                                    continue;
                                }
                                String curveId = "curve_" + plot3dId + "_" + dg.getName();
                                String datasetYId = "__data_set__" + plot3dId + dg.getName();
                                DataSet yDataSet = new DataSet(datasetYId, dg.getName(), dg.getId(), dg.getId());
                                sedmlReport.addDataSet(yDataSet);
                                curveCnt++;
                            }
                            sedmlModel.addOutput(sedmlReport);
                        }
                    }
                }
                simCount++;
            }
            // end - for 'sims'
            simContextCnt++;
        }
        // if sedmlNotesStr is not null, there were some applications that could not be exported to SEDML (eg., spatial stochastic). Create a notes element and add it to sedml Model.
        if (sedmlNotesStr.length() > 0) {
            sedmlNotesStr = "\n\tThe following applications in the VCell model were not exported to VCell : " + sedmlNotesStr;
            sedmlModel.addNote(createNotesElement(sedmlNotesStr));
        }
        if (sedmlModel.getModels() != null && sedmlModel.getModels().size() > 1) {
            System.out.println("Number of models in the sedml is " + sedmlModel.getModels().size());
        }
    } catch (Exception e) {
        e.printStackTrace(System.out);
        throw new RuntimeException("Error adding model to SEDML document : " + e.getMessage());
    }
}

Example 9 with MathSymbolMapping

use of cbit.vcell.mapping.MathSymbolMapping in project vcell by virtualcell.

the class InitialConditionsPanel method jMenuItemPaste_ActionPerformed.

/**
 * Comment
 */
private void jMenuItemPaste_ActionPerformed(final java.awt.event.ActionEvent actionEvent) {
    final Vector<String> pasteDescriptionsV = new Vector<String>();
    final Vector<Expression> newExpressionsV = new Vector<Expression>();
    final Vector<SpeciesContextSpec.SpeciesContextSpecParameter> changedParametersV = new Vector<SpeciesContextSpec.SpeciesContextSpecParameter>();
    AsynchClientTask task1 = new AsynchClientTask("validating", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            if (actionEvent.getSource() == getJMenuItemPaste() || actionEvent.getSource() == getJMenuItemPasteAll()) {
                Object pasteThis = VCellTransferable.getFromClipboard(VCellTransferable.OBJECT_FLAVOR);
                MathSymbolMapping msm = null;
                Exception mathMappingException = null;
                try {
                    MathMapping mm = null;
                    mm = getSimulationContext().createNewMathMapping();
                    msm = mm.getMathSymbolMapping();
                } catch (Exception e) {
                    mathMappingException = e;
                    e.printStackTrace(System.out);
                }
                int[] rows = null;
                if (actionEvent.getSource() == getJMenuItemPasteAll()) {
                    rows = new int[getScrollPaneTable().getRowCount()];
                    for (int i = 0; i < rows.length; i += 1) {
                        rows[i] = i;
                    }
                } else {
                    rows = getScrollPaneTable().getSelectedRows();
                }
                // 
                // Check paste
                // 
                StringBuffer errors = null;
                for (int i = 0; i < rows.length; i += 1) {
                    SpeciesContextSpec scs = tableModel.getValueAt(rows[i]);
                    try {
                        if (pasteThis instanceof VCellTransferable.ResolvedValuesSelection) {
                            VCellTransferable.ResolvedValuesSelection rvs = (VCellTransferable.ResolvedValuesSelection) pasteThis;
                            for (int j = 0; j < rvs.getPrimarySymbolTableEntries().length; j += 1) {
                                SpeciesContextSpec.SpeciesContextSpecParameter pasteDestination = null;
                                SpeciesContextSpec.SpeciesContextSpecParameter clipboardBiologicalParameter = null;
                                if (rvs.getPrimarySymbolTableEntries()[j] instanceof SpeciesContextSpec.SpeciesContextSpecParameter) {
                                    clipboardBiologicalParameter = (SpeciesContextSpec.SpeciesContextSpecParameter) rvs.getPrimarySymbolTableEntries()[j];
                                } else if (rvs.getAlternateSymbolTableEntries() != null && rvs.getAlternateSymbolTableEntries()[j] instanceof SpeciesContextSpec.SpeciesContextSpecParameter) {
                                    clipboardBiologicalParameter = (SpeciesContextSpec.SpeciesContextSpecParameter) rvs.getAlternateSymbolTableEntries()[j];
                                }
                                if (clipboardBiologicalParameter == null) {
                                    Variable pastedMathVariable = null;
                                    if (rvs.getPrimarySymbolTableEntries()[j] instanceof Variable) {
                                        pastedMathVariable = (Variable) rvs.getPrimarySymbolTableEntries()[j];
                                    } else if (rvs.getAlternateSymbolTableEntries() != null && rvs.getAlternateSymbolTableEntries()[j] instanceof Variable) {
                                        pastedMathVariable = (Variable) rvs.getAlternateSymbolTableEntries()[j];
                                    }
                                    if (pastedMathVariable != null) {
                                        if (msm == null) {
                                            throw mathMappingException;
                                        }
                                        Variable localMathVariable = msm.findVariableByName(pastedMathVariable.getName());
                                        if (localMathVariable == null) {
                                            // try if localMathVariable is a speciesContext init parameter
                                            String initSuffix = DiffEquMathMapping.MATH_FUNC_SUFFIX_SPECIES_INIT_CONC_UNIT_PREFIX + TokenMangler.fixTokenStrict(scs.getInitialConcentrationParameter().getUnitDefinition().getSymbol());
                                            localMathVariable = msm.findVariableByName(pastedMathVariable.getName() + initSuffix);
                                        }
                                        if (localMathVariable != null) {
                                            SymbolTableEntry[] localBiologicalSymbolArr = msm.getBiologicalSymbol(localMathVariable);
                                            for (int k = 0; k < localBiologicalSymbolArr.length; k += 1) {
                                                if (localBiologicalSymbolArr[k] instanceof SpeciesContext && scs.getSpeciesContext() == localBiologicalSymbolArr[k]) {
                                                    // need to change
                                                    pasteDestination = scs.getInitialConditionParameter();
                                                } else if (localBiologicalSymbolArr[k] instanceof SpeciesContextSpec.SpeciesContextSpecParameter) {
                                                    for (int l = 0; l < scs.getParameters().length; l += 1) {
                                                        if (scs.getParameters()[l] == localBiologicalSymbolArr[k]) {
                                                            pasteDestination = (SpeciesContextSpec.SpeciesContextSpecParameter) localBiologicalSymbolArr[k];
                                                            break;
                                                        }
                                                    }
                                                }
                                                if (pasteDestination != null) {
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                } else {
                                    for (int k = 0; k < scs.getParameters().length; k += 1) {
                                        SpeciesContextSpec.SpeciesContextSpecParameter scsp = (SpeciesContextSpec.SpeciesContextSpecParameter) scs.getParameters()[k];
                                        if (scsp.getRole() == clipboardBiologicalParameter.getRole() && scs.getSpeciesContext().compareEqual(((SpeciesContextSpec) clipboardBiologicalParameter.getNameScope().getScopedSymbolTable()).getSpeciesContext())) {
                                            pasteDestination = (SpeciesContextSpec.SpeciesContextSpecParameter) scsp;
                                        }
                                    }
                                }
                                if (pasteDestination != null) {
                                    changedParametersV.add(pasteDestination);
                                    newExpressionsV.add(rvs.getExpressionValues()[j]);
                                    pasteDescriptionsV.add(VCellCopyPasteHelper.formatPasteList(scs.getSpeciesContext().getName(), pasteDestination.getName(), pasteDestination.getExpression().infix(), rvs.getExpressionValues()[j].infix()));
                                }
                            }
                        }
                    } catch (Throwable e) {
                        if (errors == null) {
                            errors = new StringBuffer();
                        }
                        errors.append(scs.getSpeciesContext().getName() + " (" + e.getClass().getName() + ") " + e.getMessage() + "\n\n");
                    }
                }
                if (errors != null) {
                    throw new Exception(errors.toString());
                }
            }
        }
    };
    AsynchClientTask task2 = new AsynchClientTask("pasting", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            // Do paste
            if (pasteDescriptionsV.size() > 0) {
                String[] pasteDescriptionArr = new String[pasteDescriptionsV.size()];
                pasteDescriptionsV.copyInto(pasteDescriptionArr);
                SpeciesContextSpec.SpeciesContextSpecParameter[] changedParametersArr = new SpeciesContextSpec.SpeciesContextSpecParameter[changedParametersV.size()];
                changedParametersV.copyInto(changedParametersArr);
                Expression[] newExpressionsArr = new Expression[newExpressionsV.size()];
                newExpressionsV.copyInto(newExpressionsArr);
                VCellCopyPasteHelper.chooseApplyPaste(InitialConditionsPanel.this, pasteDescriptionArr, changedParametersArr, newExpressionsArr);
            } else {
                PopupGenerator.showInfoDialog(InitialConditionsPanel.this, "No paste items match the destination (no changes made).");
            }
        }
    };
    ClientTaskDispatcher.dispatch(this, new Hashtable<String, Object>(), new AsynchClientTask[] { task1, task2 });
}