Examples with MathMappingCallback cbit.vcell.mapping.SimulationContext.MathMappingCallback used on opensource projects

Example 21 with MathMappingCallback

use of cbit.vcell.mapping.SimulationContext.MathMappingCallback in project vcell by virtualcell.

the class NetworkConstraintsPanel method runBioNetGen.

private void runBioNetGen() {
    EditConstraintsPanel panel = new EditConstraintsPanel(this);
    ChildWindowManager childWindowManager = ChildWindowManager.findChildWindowManager(this);
    ChildWindow childWindow = childWindowManager.addChildWindow(panel, panel, "Edit / Test Constraints");
    Dimension dim = new Dimension(320, 330);
    childWindow.pack();
    panel.setChildWindow(childWindow);
    childWindow.setPreferredSize(dim);
    childWindow.showModal();
    int maxIterations;
    int maxMolecules;
    int speciesLimit;
    int reactionsLimit;
    Map<MolecularType, Integer> testMaxStoichiometryMap = new LinkedHashMap<>();
    StoichiometryTableModel stoichiometryTableModel = panel.getStoichiometryTableModel();
    for (int row = 0; row < stoichiometryTableModel.getRowCount(); row++) {
        MaxStoichiometryEntity nce = stoichiometryTableModel.getValueAt(row);
        MolecularType key = nce.getMolecularType();
        Integer value = nce.getValue();
        testMaxStoichiometryMap.put(key, value);
    }
    if (panel.getButtonPushed() == ActionButtons.Run) {
        maxIterations = new Integer(panel.maxIterationTextField.getText());
        maxMolecules = new Integer(panel.maxMolTextField.getText());
        speciesLimit = new Integer(panel.speciesLimitTextField.getText());
        reactionsLimit = new Integer(panel.reactionsLimitTextField.getText());
        fieldSimulationContext.getNetworkConstraints().setTestConstraints(maxIterations, maxMolecules, speciesLimit, reactionsLimit, testMaxStoichiometryMap);
    } else if (panel.getButtonPushed() == ActionButtons.Apply) {
        activateConsole();
        maxIterations = new Integer(panel.maxIterationTextField.getText());
        maxMolecules = new Integer(panel.maxMolTextField.getText());
        speciesLimit = new Integer(panel.speciesLimitTextField.getText());
        reactionsLimit = new Integer(panel.reactionsLimitTextField.getText());
        fieldSimulationContext.getNetworkConstraints().setTestConstraints(maxIterations, maxMolecules, speciesLimit, reactionsLimit, testMaxStoichiometryMap);
        fieldSimulationContext.getNetworkConstraints().updateConstraintsFromTest();
        // apply will invalidate everything: generated species, reactions, console, cache, etc
        updateBioNetGenOutput(null);
        refreshInterface();
        TaskCallbackMessage tcm = new TaskCallbackMessage(TaskCallbackStatus.Clean, "");
        fieldSimulationContext.appendToConsole(tcm);
        String message = "Warning: The current Constraints are not tested / validated.";
        tcm = new TaskCallbackMessage(TaskCallbackStatus.Warning, message);
        fieldSimulationContext.appendToConsole(tcm);
        message = "The Network generation may take a very long time or the generated network may be incomplete. " + "We recommend testing this set of constraints.";
        tcm = new TaskCallbackMessage(TaskCallbackStatus.Notification, message);
        fieldSimulationContext.appendToConsole(tcm);
        return;
    } else {
        // when cancel we put back in sync the test values
        maxIterations = fieldSimulationContext.getNetworkConstraints().getMaxIteration();
        maxMolecules = fieldSimulationContext.getNetworkConstraints().getMaxMoleculesPerSpecies();
        speciesLimit = fieldSimulationContext.getNetworkConstraints().getSpeciesLimit();
        reactionsLimit = fieldSimulationContext.getNetworkConstraints().getReactionsLimit();
        fieldSimulationContext.getNetworkConstraints().setTestConstraints(maxIterations, maxMolecules, speciesLimit, reactionsLimit, testMaxStoichiometryMap);
        return;
    }
    // TODO: do not delete the commented code below
    // uncomment the next 6 lines to keep the data in the dialogs synchronized with the most recent reaction network
    // if(viewSpeciesDialog != null) {
    // viewSpeciesDialog.dispose();
    // }
    // if(viewReactionsDialog != null) {
    // viewReactionsDialog.dispose();
    // }
    activateConsole();
    // previousIterationSpecies = 0;
    synchronized (this) {
        fieldSimulationContext.setMd5hash(null);
        fieldSimulationContext.setMostRecentlyCreatedOutputSpec(null);
    }
    refreshInterface();
    if (!checkBnglRequirements()) {
        return;
    }
    NetworkTransformer transformer = new NetworkTransformer();
    MathMappingCallback dummyCallback = new MathMappingCallback() {

        public void setProgressFraction(float percentDone) {
        }

        public void setMessage(String message) {
        }

        public boolean isInterrupted() {
            return false;
        }
    };
    String input = transformer.convertToBngl(fieldSimulationContext, true, dummyCallback, NetworkGenerationRequirements.ComputeFullNoTimeout);
    // we alter the input string to use the test values for speciesLimit and reactionsLimit
    BufferedReader br = new BufferedReader(new StringReader(input));
    StringBuilder sb = new StringBuilder();
    int lineNumber = 0;
    while (true) {
        String line = null;
        try {
            line = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (line == null) {
            // end of document
            break;
        }
        if (line.isEmpty()) {
            sb.append("\n");
            lineNumber++;
            continue;
        }
        if (line.contains(NetworkConstraints.SPECIES_LIMIT_PARAMETER)) {
            sb.append(NetworkConstraints.SPECIES_LIMIT_PARAMETER + "\t\t" + speciesLimit + "\n");
        } else if (line.contains(NetworkConstraints.REACTIONS_LIMIT_PARAMETER)) {
            sb.append(NetworkConstraints.REACTIONS_LIMIT_PARAMETER + "\t\t" + reactionsLimit + "\n");
        } else {
            sb.append(line + "\n");
        }
    }
    input = sb.toString();
    // we alter the input string to use the test values for max iterations and max molecules per species
    // get rid of the default generate network command...
    input = input.substring(0, input.indexOf("generate_network({"));
    // ... and replace it with the "fake" one
    StringWriter bnglStringWriter = new StringWriter();
    PrintWriter pw = new PrintWriter(bnglStringWriter);
    // testMaxStoichiometryMap
    RbmNetworkGenerator.generateNetworkEx(maxIterations, maxMolecules, true, pw, fieldSimulationContext.getModel().getRbmModelContainer(), fieldSimulationContext, NetworkGenerationRequirements.ComputeFullNoTimeout);
    String genNetStr = bnglStringWriter.toString();
    pw.close();
    input += genNetStr;
    BNGInput bngInput = new BNGInput(input);
    final BNGExecutorService bngService = BNGExecutorService.getInstance(bngInput, NetworkGenerationRequirements.NoTimeoutMS);
    bngService.registerBngUpdaterCallback(this);
    Hashtable<String, Object> hash = new Hashtable<String, Object>();
    AsynchClientTask[] tasksArray = new AsynchClientTask[3];
    TaskCallbackMessage message = new TaskCallbackMessage(TaskCallbackStatus.Clean, "");
    fieldSimulationContext.appendToConsole(message);
    tasksArray[0] = new RunBioNetGen(bngService);
    tasksArray[1] = new CreateBNGOutputSpec(bngService);
    tasksArray[2] = new ReturnBNGOutput(bngService, fieldSimulationContext, this);
    ClientTaskDispatcher.dispatch(this, hash, tasksArray, false, true, new ProgressDialogListener() {

        @Override
        public void cancelButton_actionPerformed(EventObject newEvent) {
            try {
                bngService.stopBNG();
                String s = "...user cancelled.";
                TaskCallbackMessage tcm = new TaskCallbackMessage(TaskCallbackStatus.TaskStopped, s);
                // message will be processed in TaskCallbackProcessor::case TaskStopped
                setNewCallbackMessage(tcm);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    });
}

Example 22 with MathMappingCallback

use of cbit.vcell.mapping.SimulationContext.MathMappingCallback in project vcell by virtualcell.

the class XmlHelper method sedmlToBioModel.

public static List<VCDocument> sedmlToBioModel(VCLogger transLogger, ExternalDocInfo externalDocInfo, SedML sedml, List<AbstractTask> tasks, String sedmlFileLocation, boolean exactMatchOnly) throws Exception {
    if (sedml.getModels().isEmpty()) {
        throw new Exception("No models found in SED-ML document");
    }
    try {
        // iterate through all the elements and show them at the console
        List<org.jlibsedml.Model> mmm = sedml.getModels();
        for (Model mm : mmm) {
            System.out.println(mm.toString());
        }
        List<org.jlibsedml.Simulation> sss = sedml.getSimulations();
        for (org.jlibsedml.Simulation ss : sss) {
            System.out.println(ss.toString());
        }
        List<AbstractTask> ttt = sedml.getTasks();
        if (ttt.isEmpty()) {
            throw new Exception("No tasks found in SED-ML document");
        }
        for (AbstractTask tt : ttt) {
            System.out.println(tt.toString());
        }
        List<DataGenerator> ddd = sedml.getDataGenerators();
        for (DataGenerator dd : ddd) {
            System.out.println(dd.toString());
        }
        List<Output> ooo = sedml.getOutputs();
        for (Output oo : ooo) {
            System.out.println(oo.toString());
        }
        if (ooo.isEmpty()) {
            System.err.println("List of outputs cannot be empty!");
        }
        if (tasks == null || tasks.isEmpty()) {
            // no task selection, we'll import all that we find in the SED-ML
            tasks = sedml.getTasks();
        }
        // We need to make a separate BioModel for each SED-ML model
        // We will parse all tasks and create Simulations for each in the BioModel(s) corresponding to the model referenced by the tasks
        List<VCDocument> docs = new ArrayList<VCDocument>();
        // extract bioModel name from sedx (or sedml) file
        String bioModelBaseName = FileUtils.getBaseName(externalDocInfo.getFile().getAbsolutePath());
        String kisaoID = null;
        // this will become the vCell simulation
        org.jlibsedml.Simulation sedmlSimulation = null;
        // the "original" model referred to by the task
        org.jlibsedml.Model sedmlOriginalModel = null;
        // this will be used in the BioModel name
        String sedmlOriginalModelName = null;
        // can be sbml or vcml
        String sedmlOriginalModelLanguage = null;
        ArchiveComponents ac = null;
        if (externalDocInfo.getFile().getPath().toLowerCase().endsWith("sedx") || externalDocInfo.getFile().getPath().toLowerCase().endsWith("omex")) {
            ac = Libsedml.readSEDMLArchive(new FileInputStream(externalDocInfo.getFile().getPath()));
        }
        ModelResolver resolver = new ModelResolver(sedml);
        if (ac != null) {
            resolver.add(new ArchiveModelResolver(ac));
        }
        resolver.add(new FileModelResolver());
        if (sedmlFileLocation != null) {
            File sedmlFile = new File(sedmlFileLocation);
            String sedmlRelativePrefix = sedmlFile.getParent() + File.separator;
            if (sedmlRelativePrefix != null) {
                resolver.add(new RelativeFileModelResolver(sedmlRelativePrefix));
            }
        }
        for (AbstractTask selectedTask : tasks) {
            if (selectedTask instanceof Task) {
                sedmlOriginalModel = sedml.getModelWithId(selectedTask.getModelReference());
                sedmlSimulation = sedml.getSimulation(selectedTask.getSimulationReference());
            } else if (selectedTask instanceof RepeatedTask) {
                System.err.println("RepeatedTask not supported yet, task " + SEDMLUtil.getName(selectedTask) + " is being skipped");
                continue;
            // TODO the below is unfinished code
            // RepeatedTask rt = (RepeatedTask)selectedTask;
            // assert(rt.getSubTasks().size() == 1);
            // SubTask st = rt.getSubTasks().entrySet().iterator().next().getValue();		// first (and only) subtask
            // String taskId = st.getTaskId();
            // AbstractTask t = sedml.getTaskWithId(taskId);
            // sedmlOriginalModel = sedml.getModelWithId(t.getModelReference());			// get model and simulation from subtask
            // sedmlSimulation = sedml.getSimulation(t.getSimulationReference());
            } else {
                throw new RuntimeException("Unexpected task " + selectedTask);
            }
            sedmlOriginalModelName = sedmlOriginalModel.getId();
            sedmlOriginalModelLanguage = sedmlOriginalModel.getLanguage();
            // at this point we assume that the sedml simulation, algorithm and kisaoID are all valid
            Algorithm algorithm = sedmlSimulation.getAlgorithm();
            kisaoID = algorithm.getKisaoID();
            // identify the vCell solvers that would match best the sedml solver kisao id
            // try to find a match in the ontology tree
            SolverDescription solverDescription = SolverUtilities.matchSolverWithKisaoId(kisaoID, exactMatchOnly);
            if (solverDescription != null) {
                System.out.println("Task (id='" + selectedTask.getId() + "') is compatible, solver match found in ontology: '" + kisaoID + "' matched to " + solverDescription);
            } else {
                // give it a try anyway with our deterministic default solver
                solverDescription = SolverDescription.CombinedSundials;
                System.err.println("Task (id='" + selectedTask.getId() + ")' is not compatible, no equivalent solver found in ontology for requested algorithm '" + kisaoID + "'; trying with deterministic default solver " + solverDescription);
            }
            // find out everything else we need about the application we're going to use,
            // some of the info will be needed when we parse the sbml file
            boolean bSpatial = false;
            Application appType = Application.NETWORK_DETERMINISTIC;
            Set<SolverDescription.SolverFeature> sfList = solverDescription.getSupportedFeatures();
            for (SolverDescription.SolverFeature sf : sfList) {
                switch(sf) {
                    case Feature_Rulebased:
                        appType = Application.RULE_BASED_STOCHASTIC;
                        break;
                    case Feature_Stochastic:
                        appType = Application.NETWORK_STOCHASTIC;
                        break;
                    case Feature_Deterministic:
                        appType = Application.NETWORK_DETERMINISTIC;
                        break;
                    case Feature_Spatial:
                        bSpatial = true;
                        break;
                    default:
                        break;
                }
            }
            // we make a biomodel for each task; if there are many simulations, probably
            // only one will match the selected task id, the others are parasites and must not be run
            BioModel bioModel = null;
            boolean justMade = false;
            String newMdl = resolver.getModelString(sedmlOriginalModel);
            String bioModelName = bioModelBaseName + "_" + sedml.getFileName() + "_" + sedmlOriginalModelName;
            // get it if we made it already
            for (VCDocument existingDoc : docs) {
                if (!docs.isEmpty()) {
                    if (existingDoc.getName().equals(bioModelName)) {
                        bioModel = (BioModel) existingDoc;
                        break;
                    }
                }
            }
            // make it if we didn't and mark it as fresh
            if (bioModel == null) {
                if (sedmlOriginalModelLanguage.contentEquals(SUPPORTED_LANGUAGE.VCELL_GENERIC.getURN())) {
                    // vcml
                    XMLSource vcmlSource = new XMLSource(newMdl);
                    bioModel = (BioModel) XmlHelper.XMLToBioModel(vcmlSource);
                    bioModel.setName(bioModelName);
                    docs.add(bioModel);
                    justMade = true;
                    try {
                        bioModel.getVCMetaData().createBioPaxObjects(bioModel);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else {
                    // we assume it's sbml, if it's neither import will fail
                    // sbmlSource with all the changes applied
                    XMLSource sbmlSource = new XMLSource(newMdl);
                    bioModel = (BioModel) XmlHelper.importSBML(transLogger, sbmlSource, bSpatial);
                    bioModel.setName(bioModelName);
                    docs.add(bioModel);
                    justMade = true;
                }
            }
            if (sedmlOriginalModelLanguage.contentEquals(SUPPORTED_LANGUAGE.VCELL_GENERIC.getURN())) {
                // we basically ignore the sedml simulation altogether
                for (Simulation sim : bioModel.getSimulations()) {
                    if (sim.getName().equals(selectedTask.getName())) {
                        System.out.println(" --- selected task - name: " + selectedTask.getName() + ", id: " + selectedTask.getId());
                        sim.setImportedTaskID(selectedTask.getId());
                    }
                }
                continue;
            }
            // even if we just created the biomodel from the sbml file we have at least one application with initial conditions and stuff
            // see if there is a suitable application type for the sedml kisao
            // if not, we add one by doing a "copy as" to the right type
            SimulationContext[] existingSimulationContexts = bioModel.getSimulationContexts();
            SimulationContext matchingSimulationContext = null;
            for (SimulationContext simContext : existingSimulationContexts) {
                if (simContext.getApplicationType().equals(appType) && ((simContext.getGeometry().getDimension() > 0) == bSpatial)) {
                    matchingSimulationContext = simContext;
                    break;
                }
            }
            if (matchingSimulationContext == null) {
                if (justMade) {
                    matchingSimulationContext = SimulationContext.copySimulationContext(existingSimulationContexts[0], sedmlOriginalModelName, bSpatial, appType);
                    bioModel.removeSimulationContext(existingSimulationContexts[0]);
                } else {
                    matchingSimulationContext = SimulationContext.copySimulationContext(existingSimulationContexts[0], sedmlOriginalModelName + "_" + existingSimulationContexts.length, bSpatial, appType);
                }
                bioModel.addSimulationContext(matchingSimulationContext);
            }
            // making the new vCell simulation based on the sedml simulation
            matchingSimulationContext.refreshDependencies();
            MathMappingCallback callback = new MathMappingCallbackTaskAdapter(null);
            matchingSimulationContext.refreshMathDescription(callback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
            Simulation newSimulation = new Simulation(matchingSimulationContext.getMathDescription());
            newSimulation.setSimulationOwner(matchingSimulationContext);
            if (selectedTask instanceof Task) {
                String newSimName = selectedTask.getId();
                if (SEDMLUtil.getName(selectedTask) != null) {
                    newSimName += "_" + SEDMLUtil.getName(selectedTask);
                }
                newSimulation.setName(newSimName);
                newSimulation.setImportedTaskID(selectedTask.getId());
            } else {
                newSimulation.setName(SEDMLUtil.getName(sedmlSimulation) + "_" + SEDMLUtil.getName(selectedTask));
            }
            // we identify the type of sedml simulation (uniform time course, etc)
            // and set the vCell simulation parameters accordingly
            SolverTaskDescription simTaskDesc = newSimulation.getSolverTaskDescription();
            if (solverDescription != null) {
                simTaskDesc.setSolverDescription(solverDescription);
            }
            TimeBounds timeBounds = new TimeBounds();
            TimeStep timeStep = new TimeStep();
            double outputTimeStep = 0.1;
            int outputNumberOfPoints = 1;
            if (sedmlSimulation instanceof UniformTimeCourse) {
                // we translate initial time to zero, we provide output for the duration of the simulation
                // because we can't select just an interval the way the SEDML simulation can
                double initialTime = ((UniformTimeCourse) sedmlSimulation).getInitialTime();
                double outputStartTime = ((UniformTimeCourse) sedmlSimulation).getOutputStartTime();
                double outputEndTime = ((UniformTimeCourse) sedmlSimulation).getOutputEndTime();
                outputNumberOfPoints = ((UniformTimeCourse) sedmlSimulation).getNumberOfPoints();
                outputTimeStep = (outputEndTime - outputStartTime) / outputNumberOfPoints;
                timeBounds = new TimeBounds(0, outputEndTime - initialTime);
                ErrorTolerance errorTolerance = new ErrorTolerance();
                // we look for explicit algorithm parameters
                List<AlgorithmParameter> sedmlAlgorithmParameters = algorithm.getListOfAlgorithmParameters();
                for (AlgorithmParameter sedmlAlgorithmParameter : sedmlAlgorithmParameters) {
                    String apKisaoID = sedmlAlgorithmParameter.getKisaoID();
                    String apValue = sedmlAlgorithmParameter.getValue();
                    if (apKisaoID == null || apKisaoID.isEmpty()) {
                        System.err.println("Undefined KisaoID algorithm parameter for algorithm '" + kisaoID + "'");
                    }
                    // TODO: use the proper ontology for the algorithm parameters kisao id
                    if (apKisaoID.contentEquals(ErrorTolerance.ErrorToleranceDescription.Absolute.getKisao())) {
                        double value = Double.parseDouble(apValue);
                        errorTolerance.setAbsoluteErrorTolerance(value);
                    } else if (apKisaoID.contentEquals(ErrorTolerance.ErrorToleranceDescription.Relative.getKisao())) {
                        double value = Double.parseDouble(apValue);
                        errorTolerance.setRelativeErrorTolerance(value);
                    } else if (apKisaoID.contentEquals(TimeStep.TimeStepDescription.Default.getKisao())) {
                        double value = Double.parseDouble(apValue);
                        timeStep.setDefaultTimeStep(value);
                    } else if (apKisaoID.contentEquals(TimeStep.TimeStepDescription.Maximum.getKisao())) {
                        double value = Double.parseDouble(apValue);
                        timeStep.setMaximumTimeStep(value);
                    } else if (apKisaoID.contentEquals(TimeStep.TimeStepDescription.Minimum.getKisao())) {
                        double value = Double.parseDouble(apValue);
                        timeStep.setMinimumTimeStep(value);
                    } else if (apKisaoID.contentEquals(AlgorithmParameterDescription.Seed.getKisao())) {
                        // custom seed
                        if (simTaskDesc.getSimulation().getMathDescription().isNonSpatialStoch()) {
                            NonspatialStochSimOptions nssso = simTaskDesc.getStochOpt();
                            int value = Integer.parseInt(apValue);
                            nssso.setCustomSeed(value);
                        } else {
                            System.err.println("Algorithm parameter '" + AlgorithmParameterDescription.Seed.getDescription() + "' is only supported for nonspatial stochastic simulations");
                        }
                    // some arguments used only for non-spatial hybrid solvers
                    } else if (apKisaoID.contentEquals(AlgorithmParameterDescription.Epsilon.getKisao())) {
                        NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                        nssho.setEpsilon(Double.parseDouble(apValue));
                    } else if (apKisaoID.contentEquals(AlgorithmParameterDescription.Lambda.getKisao())) {
                        NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                        nssho.setLambda(Double.parseDouble(apValue));
                    } else if (apKisaoID.contentEquals(AlgorithmParameterDescription.MSRTolerance.getKisao())) {
                        NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                        nssho.setMSRTolerance(Double.parseDouble(apValue));
                    } else if (apKisaoID.contentEquals(AlgorithmParameterDescription.SDETolerance.getKisao())) {
                        NonspatialStochHybridOptions nssho = simTaskDesc.getStochHybridOpt();
                        nssho.setSDETolerance(Double.parseDouble(apValue));
                    } else {
                        System.err.println("Algorithm parameter with kisao id '" + apKisaoID + "' not supported at this time, skipping.");
                    }
                }
                simTaskDesc.setErrorTolerance(errorTolerance);
            } else if (sedmlSimulation instanceof OneStep) {
                // for anything other than UniformTimeCourse we just ignore
                System.err.println("OneStep Simulation not supported");
                continue;
            } else if (sedmlSimulation instanceof SteadyState) {
                System.err.println("SteadyState Simulation not supported");
                continue;
            }
            OutputTimeSpec outputTimeSpec = new UniformOutputTimeSpec(outputTimeStep);
            simTaskDesc.setTimeBounds(timeBounds);
            simTaskDesc.setTimeStep(timeStep);
            if (simTaskDesc.getSolverDescription().supports(outputTimeSpec)) {
                simTaskDesc.setOutputTimeSpec(outputTimeSpec);
            } else {
                simTaskDesc.setOutputTimeSpec(new DefaultOutputTimeSpec(1, Integer.max(DefaultOutputTimeSpec.DEFAULT_KEEP_AT_MOST, outputNumberOfPoints)));
            }
            newSimulation.setSolverTaskDescription(simTaskDesc);
            newSimulation.setDescription(SEDMLUtil.getName(selectedTask));
            bioModel.addSimulation(newSimulation);
            newSimulation.refreshDependencies();
        }
        return docs;
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException("Unable to initialize bioModel for the given selection\n" + e.getMessage());
    }
}