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

Example 11 with MathMappingCallback

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

the class SimulationServiceImpl method computeModel.

private SimulationInfo computeModel(VCDocument vcDoc, SimulationSpec simSpec, ClientTaskStatusSupport statusCallback) throws Exception {
    // try {
    Simulation newsim = null;
    if (vcDoc instanceof BioModel) {
        SimulationContext simContext = ((BioModel) vcDoc).getSimulationContext(0);
        MathMappingCallback callback = new MathMappingCallbackTaskAdapter(statusCallback);
        newsim = simContext.addNewSimulation(SimulationOwner.DEFAULT_SIM_NAME_PREFIX, callback, NetworkGenerationRequirements.AllowTruncatedStandardTimeout);
    } else if (vcDoc instanceof MathModel) {
        newsim = ((MathModel) vcDoc).addNewSimulation(SimulationOwner.DEFAULT_SIM_NAME_PREFIX);
    } else {
        throw new IllegalArgumentException("computeModel expecting BioModel or MathModel but got " + vcDoc.getClass().getName());
    }
    GeometrySpec geometrySpec = newsim.getMathDescription().getGeometry().getGeometrySpec();
    VCImage image = geometrySpec.getImage();
    if (image != null) {
        newsim.getMeshSpecification().setSamplingSize(new ISize(image.getNumX(), image.getNumY(), image.getNumZ()));
    }
    // newsim.getMeshSpecification().setSamplingSize(new ISize(simContext.getGeometry().getGeometrySpec().getImage().getNumX(), simContext.getGeometry().getGeometrySpec().getImage().getNumY(), simContext.getGeometry().getGeometrySpec().getImage().getNumZ()));
    newsim.getSolverTaskDescription().setTimeBounds(new TimeBounds(0, simSpec.getTotalTime()));
    newsim.getSolverTaskDescription().setOutputTimeSpec(new UniformOutputTimeSpec(simSpec.getOutputTimeStep()));
    SimulationInfo simulationInfo = new SimulationInfo(Math.abs(new Random().nextInt(1000000)));
    // ----------- run simulation(s)
    final File localSimDataDir = ResourceUtil.getLocalSimDir(User.tempUser.getName());
    Simulation simulation = new TempSimulation(newsim, false);
    final SimulationServiceContext simServiceContext = new SimulationServiceContext();
    simServiceContext.simInfo = simulationInfo;
    simServiceContext.simState = SimulationState.running;
    simServiceContext.simTask = new SimulationTask(new SimulationJob(simulation, 0, null), 0);
    simServiceContext.vcDataIdentifier = simServiceContext.simTask.getSimulationJob().getVCDataIdentifier();
    simServiceContext.solver = createQuickRunSolver(localSimDataDir, simServiceContext.simTask);
    simServiceContext.localSimDataDir = localSimDataDir;
    if (simServiceContext.solver == null) {
        throw new RuntimeException("null solver");
    }
    sims.put(simulationInfo.getLocalId(), simServiceContext);
    simServiceContext.solver.addSolverListener(new SolverListener() {

        public void solverStopped(SolverEvent event) {
            simServiceContext.simState = SimulationState.failed;
            System.err.println("Simulation stopped");
        }

        public void solverStarting(SolverEvent event) {
            simServiceContext.simState = SimulationState.running;
            updateStatus(event);
        }

        public void solverProgress(SolverEvent event) {
            simServiceContext.simState = SimulationState.running;
            updateStatus(event);
        }

        public void solverPrinted(SolverEvent event) {
            simServiceContext.simState = SimulationState.running;
        }

        public void solverFinished(SolverEvent event) {
            try {
                getDataSetController(simServiceContext).getDataSetTimes(simServiceContext.vcDataIdentifier);
                simServiceContext.simState = SimulationState.done;
            } catch (DataAccessException e) {
                simServiceContext.simState = SimulationState.failed;
                e.printStackTrace();
            }
            updateStatus(event);
        }

        public void solverAborted(SolverEvent event) {
            simServiceContext.simState = SimulationState.failed;
            System.err.println(event.getSimulationMessage().getDisplayMessage());
        }

        private void updateStatus(SolverEvent event) {
            if (statusCallback == null)
                return;
            statusCallback.setMessage(event.getSimulationMessage().getDisplayMessage());
            statusCallback.setProgress((int) (event.getProgress() * 100));
        }
    });
    if (true) {
        // debug
        if (vcDoc instanceof BioModel) {
            XmlUtil.writeXMLStringToFile(XmlHelper.bioModelToXML(((BioModel) vcDoc)), "C:\\Users\\frm\\vcGititImageJWorkspace\\vcell\\imagej_BM_true.xml", true);
        } else if (vcDoc instanceof MathModel) {
            XmlUtil.writeXMLStringToFile(XmlHelper.mathModelToXML(((MathModel) vcDoc)), "C:\\Users\\frm\\vcGititImageJWorkspace\\vcell\\imagej_MM_true.xml", true);
        }
    }
    simServiceContext.solver.startSolver();
    return simServiceContext.simInfo;
// } catch (Exception e){
// e.printStackTrace(System.out);
// // remember the exceptiopn ... fail the status ... save the error message
// return new SimulationInfo();
// }
}

Example 12 with MathMappingCallback

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

the class StandaloneSEDMLTest method doit.

public static void doit(File archiveFile) throws Exception {
    ArchiveComponents ac = null;
    ac = Libsedml.readSEDMLArchive(new FileInputStream(archiveFile));
    SEDMLDocument sedmlDoc = ac.getSedmlDocuments().get(0);
    SedML sedml = sedmlDoc.getSedMLModel();
    if (sedml == null || sedml.getModels().isEmpty()) {
        throw new RuntimeException("sedml null or empty");
    }
    ModelResolver resolver = new ModelResolver(sedml);
    // resolver.add(new FileModelResolver());
    resolver.add(new ArchiveModelResolver(ac));
    resolver.add(new BioModelsModelsRetriever());
    resolver.add(new URLResourceRetriever());
    // resolver.add(new RelativeFileModelResolver(FileUtils.getFullPath(archiveFile.getAbsolutePath())));
    // 
    // 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();
    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());
    }
    // 
    // extract models referenced in tasks.
    // 
    KisaoOntology kisaoInstance = KisaoOntology.getInstance();
    // HashMap<String,Model> flattenedModels = new HashMap<String, Model>();
    List<AbstractTask> taskList = sedml.getTasks();
    for (AbstractTask task : taskList) {
        String modelReference = task.getModelReference();
        org.jlibsedml.Model sedmlOriginalModel = sedml.getModelWithId(modelReference);
        String sbmlModelString = resolver.getModelString(sedmlOriginalModel);
        // sbmlSource with all the changes applied
        XMLSource sbmlSource = new XMLSource(sbmlModelString);
        org.jlibsedml.Simulation sedmlSimulation = sedml.getSimulation(task.getSimulationReference());
        Algorithm algorithm = sedmlSimulation.getAlgorithm();
        KisaoTerm sedmlKisao = kisaoInstance.getTermById(algorithm.getKisaoID());
        // 
        // try to find a VCell solverDescription to match the Kisao term
        // 
        // UniformTimeCourse [initialTime=0.0, numberOfPoints=1000, outputEndTime=1.0, outputStartTime=0.0,
        // Algorithm [kisaoID=KISAO:0000019], getId()=SimSlow]
        // identify the vCell solvers that would match best the sedml solver kisao id
        List<SolverDescription> solverDescriptions = new ArrayList<>();
        for (SolverDescription sd : SolverDescription.values()) {
            KisaoTerm solverKisaoTerm = kisaoInstance.getTermById(sd.getKisao());
            if (solverKisaoTerm == null) {
                break;
            }
            boolean isExactlySame = solverKisaoTerm.equals(sedmlKisao);
            if (isExactlySame && !solverKisaoTerm.isObsolete()) {
                // we make a list with all the solvers that match the kisao
                solverDescriptions.add(sd);
            }
        }
        if (solverDescriptions.isEmpty()) {
            throw new RuntimeException("cannot find the solverDescription with exact match for Kisao term '" + sedmlKisao + "'");
        }
        // choose first one
        SolverDescription solverDescription = solverDescriptions.get(0);
        // 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;
            }
        }
        BioModel bioModel = (BioModel) XmlHelper.importSBML(transLogger, sbmlSource, bSpatial);
        // 
        // we already have an application loaded from the sbml file, with initial conditions and stuff
        // which may be not be suitable because the sedml kisao may need a different app type
        // so we do a "copy as" to the right type and then delete the original we loaded from the sbml file
        // 
        // the new application we're making from the old one
        SimulationContext newSimulationContext = null;
        if (bioModel.getSimulationContexts().length == 1) {
            SimulationContext oldSimulationContext = bioModel.getSimulationContext(0);
            String newSCName = bioModel.getFreeSimulationContextName();
            newSimulationContext = SimulationContext.copySimulationContext(oldSimulationContext, newSCName, bSpatial, appType);
            bioModel.addSimulationContext(newSimulationContext);
            bioModel.removeSimulationContext(oldSimulationContext);
        } else {
            newSimulationContext = bioModel.addNewSimulationContext("App1", appType);
        }
        // 
        // making the new vCell simulation based on the sedml simulation
        // 
        newSimulationContext.refreshDependencies();
        MathMappingCallback callback = new MathMappingCallbackTaskAdapter(progressListener);
        newSimulationContext.refreshMathDescription(callback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
        Simulation newSimulation = new Simulation(newSimulationContext.getMathDescription());
        newSimulation.setName(sedmlSimulation.getName());
        bioModel.addSimulation(newSimulation);
        // and set the vCell simulation parameters accordingly
        if (sedmlSimulation instanceof UniformTimeCourse) {
        } else if (sedmlSimulation instanceof OneStep) {
        } else if (sedmlSimulation instanceof SteadyState) {
        } else {
        }
        System.out.println(XmlHelper.bioModelToXML(bioModel));
    }
}

Example 13 with MathMappingCallback

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

the class StochtestRunService method runOne.

public void runOne() throws IllegalArgumentException, SQLException, DataAccessException, XmlParseException, PropertyVetoException, ExpressionException, MappingException, GeometryException, ImageException, IOException {
    StochtestRun stochtestRun = StochtestDbUtils.acceptNextWaitingStochtestRun(conFactory);
    String biomodelXML = null;
    if (stochtestRun != null) {
        String networkGenProbs = null;
        try {
            User user = new User(PropertyLoader.ADMINISTRATOR_ACCOUNT, new KeyValue(PropertyLoader.ADMINISTRATOR_ID));
            ServerDocumentManager serverDocumentManager = new ServerDocumentManager(this.dbServerImpl);
            biomodelXML = serverDocumentManager.getBioModelXML(new QueryHashtable(), user, stochtestRun.stochtest.biomodelRef, true);
            BioModel bioModel = XmlHelper.XMLToBioModel(new XMLSource(biomodelXML));
            bioModel.refreshDependencies();
            SimulationContext srcSimContext = null;
            for (SimulationContext sc : bioModel.getSimulationContexts()) {
                if (sc.getKey().equals(stochtestRun.stochtest.simContextRef)) {
                    srcSimContext = sc;
                }
            }
            if (srcSimContext == null) {
                throw new RuntimeException("cannot find simcontext with key=" + stochtestRun.stochtest.simContextRef);
            }
            // 
            for (SpeciesContextSpec scs : srcSimContext.getReactionContext().getSpeciesContextSpecs()) {
                scs.setConstant(false);
            }
            SimulationContext simContext = srcSimContext;
            StochtestMathType parentMathType = stochtestRun.parentMathType;
            StochtestMathType mathType = stochtestRun.mathType;
            if (parentMathType != mathType) {
                if (parentMathType == StochtestMathType.nonspatialstochastic && mathType == StochtestMathType.rules) {
                    simContext = SimulationContext.copySimulationContext(srcSimContext, "generatedRules", false, Application.RULE_BASED_STOCHASTIC);
                } else if (parentMathType == StochtestMathType.rules && mathType == StochtestMathType.nonspatialstochastic) {
                    simContext = SimulationContext.copySimulationContext(srcSimContext, "generatedSSA", false, Application.NETWORK_STOCHASTIC);
                } else {
                    throw new RuntimeException("unexpected copy of simcontext from " + parentMathType + " to " + mathType);
                }
                bioModel.addSimulationContext(simContext);
            }
            MathMappingCallback mathMappingCallback = new MathMappingCallback() {

                @Override
                public void setProgressFraction(float fractionDone) {
                }

                @Override
                public void setMessage(String message) {
                }

                @Override
                public boolean isInterrupted() {
                    return false;
                }
            };
            MathMapping mathMapping = simContext.createNewMathMapping(mathMappingCallback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
            MathDescription mathDesc = mathMapping.getMathDescription(mathMappingCallback);
            simContext.setMathDescription(mathDesc);
            if (simContext.isInsufficientIterations()) {
                networkGenProbs = "insufficientIterations";
            } else if (simContext.isInsufficientMaxMolecules()) {
                networkGenProbs = "insufficientMaxMolecules";
            }
            File baseDirectory = StochtestFileUtils.createDirFile(baseDir, stochtestRun);
            try {
                OutputTimeSpec outputTimeSpec = new UniformOutputTimeSpec(0.5);
                double endTime = 10.0;
                computeTrials(simContext, stochtestRun, baseDirectory, outputTimeSpec, endTime, numTrials);
                StochtestDbUtils.finalizeAcceptedStochtestRun(conFactory, stochtestRun, StochtestRun.StochtestRunStatus.complete, null, networkGenProbs);
            } finally {
                StochtestFileUtils.clearDir(baseDirectory);
            }
        } catch (Exception e) {
            StochtestDbUtils.finalizeAcceptedStochtestRun(conFactory, stochtestRun, StochtestRun.StochtestRunStatus.failed, e.getMessage(), networkGenProbs);
            // 
            if (biomodelXML != null) {
                XmlUtil.writeXMLStringToFile(biomodelXML, new File(baseDir, "stochtestrun_" + stochtestRun.stochtest.key + ".vcml").getPath(), false);
            }
            // 
            // write exception trace to .txt file
            // 
            StringWriter stringWriter = new StringWriter();
            PrintWriter printWriter = new PrintWriter(stringWriter);
            e.printStackTrace(printWriter);
            printWriter.flush();
            System.out.println(stringWriter.getBuffer().toString());
            XmlUtil.writeXMLStringToFile(stringWriter.getBuffer().toString(), new File(baseDir, "stochtestrun_" + stochtestRun.stochtest.key + "_error.txt").getPath(), false);
        }
    } else {
        System.out.println("no jobs waiting");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Example 14 with MathMappingCallback

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

the class HealthService method runsimLoop.

private void runsimLoop() {
    try {
        Thread.sleep(SIMULATION_LOOP_START_DELAY);
    } catch (InterruptedException e1) {
    }
    UserLoginInfo userLoginInfo = new UserLoginInfo(testUserid, testPassword);
    while (true) {
        long id = simStartEvent();
        KeyValue savedBioModelKey = null;
        VCSimulationIdentifier runningSimId = null;
        try {
            RemoteProxyVCellConnectionFactory vcellConnectionFactory = new RemoteProxyVCellConnectionFactory(host, port, userLoginInfo);
            VCellConnection vcellConnection = vcellConnectionFactory.createVCellConnection();
            String vcmlString = IOUtils.toString(getClass().getResourceAsStream("/TestTemplate.vcml"));
            BioModel templateBioModel = XmlHelper.XMLToBioModel(new XMLSource(vcmlString));
            templateBioModel.clearVersion();
            String newBiomodelName = "test_" + System.currentTimeMillis();
            templateBioModel.setName(newBiomodelName);
            // remove all existing simulations from stored template model, and add new one
            while (templateBioModel.getNumSimulations() > 0) {
                templateBioModel.removeSimulation(templateBioModel.getSimulation(0));
            }
            MathMappingCallback callback = new MathMappingCallback() {

                @Override
                public void setProgressFraction(float fractionDone) {
                }

                @Override
                public void setMessage(String message) {
                }

                @Override
                public boolean isInterrupted() {
                    return false;
                }
            };
            templateBioModel.getSimulationContext(0).addNewSimulation("sim", callback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
            BigString vcml = new BigString(XmlHelper.bioModelToXML(templateBioModel));
            String[] independentSims = new String[0];
            BigString savedBioModelVCML = vcellConnection.getUserMetaDbServer().saveBioModelAs(vcml, newBiomodelName, independentSims);
            BioModel savedBioModel = XmlHelper.XMLToBioModel(new XMLSource(savedBioModelVCML.toString()));
            savedBioModelKey = savedBioModel.getVersion().getVersionKey();
            Simulation sim = savedBioModel.getSimulation(0);
            VCSimulationIdentifier vcSimId = new VCSimulationIdentifier(sim.getKey(), sim.getVersion().getOwner());
            long eventTimestamp = System.currentTimeMillis();
            SimulationStatus simStatus = vcellConnection.getSimulationController().startSimulation(vcSimId, 1);
            simSubmitEvent(id, vcSimId);
            runningSimId = vcSimId;
            long startTime_MS = System.currentTimeMillis();
            while (simStatus.isActive()) {
                if ((System.currentTimeMillis() - startTime_MS) > SIMULATION_TIMEOUT) {
                    throw new RuntimeException("simulation took longer than " + SIMULATION_TIMEOUT + " to complete");
                }
                Thread.sleep(1000);
                MessageEvent[] messageEvents = vcellConnection.getMessageEvents();
                if (messageEvents != null) {
                    for (MessageEvent event : messageEvents) {
                        if (event instanceof SimulationJobStatusEvent) {
                            SimulationJobStatusEvent jobEvent = (SimulationJobStatusEvent) event;
                            SimulationJobStatus jobStatus = jobEvent.getJobStatus();
                            VCSimulationIdentifier eventSimId = jobStatus.getVCSimulationIdentifier();
                            if (eventSimId.getOwner().equals(userLoginInfo.getUser()) && eventSimId.getSimulationKey().equals(sim.getKey())) {
                                simStatus = SimulationStatus.updateFromJobEvent(simStatus, jobEvent);
                            }
                        }
                    }
                }
            }
            runningSimId = null;
            if (!simStatus.isCompleted()) {
                throw new RuntimeException("failed: " + simStatus.getDetails());
            }
            simSuccess(id);
        } catch (Throwable e) {
            simFailed(id, e.getMessage());
        } finally {
            // cleanup
            try {
                RemoteProxyVCellConnectionFactory vcellConnectionFactory = new RemoteProxyVCellConnectionFactory(host, port, userLoginInfo);
                VCellConnection vcellConnection = vcellConnectionFactory.createVCellConnection();
                if (runningSimId != null) {
                    try {
                        vcellConnection.getSimulationController().stopSimulation(runningSimId);
                    } catch (Exception e) {
                        e.printStackTrace(System.out);
                    }
                }
                if (savedBioModelKey != null) {
                    vcellConnection.getUserMetaDbServer().deleteBioModel(savedBioModelKey);
                }
            } catch (Exception e) {
                e.printStackTrace(System.out);
            }
        }
        try {
            Thread.sleep(SIMULATION_LOOP_SLEEP);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Example 15 with MathMappingCallback

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

the class ClientRequestManager method createBioModelFromApplication.

public void createBioModelFromApplication(final BioModelWindowManager requester, final String name, final SimulationContext simContext) {
    if (simContext == null) {
        PopupGenerator.showErrorDialog(requester, "Selected Application is null, cannot generate corresponding bio model");
        return;
    }
    if (simContext.isRuleBased()) {
        createRuleBasedBioModelFromApplication(requester, name, simContext);
        return;
    }
    AsynchClientTask task1 = new AsynchClientTask("Creating BioModel from BioModel Application", AsynchClientTask.TASKTYPE_NONSWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            MathMappingCallback dummyCallback = new MathMappingCallback() {

                public void setProgressFraction(float percentDone) {
                }

                public void setMessage(String message) {
                }

                public boolean isInterrupted() {
                    return false;
                }
            };
            MathMapping transformedMathMapping = simContext.createNewMathMapping(dummyCallback, NetworkGenerationRequirements.ComputeFullStandardTimeout);
            BioModel newBioModel = new BioModel(null);
            SimulationContext transformedSimContext = transformedMathMapping.getTransformation().transformedSimContext;
            Model newModel = transformedSimContext.getModel();
            newBioModel.setModel(newModel);
            RbmModelContainer rbmmc = newModel.getRbmModelContainer();
            for (RbmObservable o : rbmmc.getObservableList()) {
                rbmmc.removeObservable(o);
            }
            for (ReactionRule r : rbmmc.getReactionRuleList()) {
                rbmmc.removeReactionRule(r);
            }
            for (ReactionStep rs : newModel.getReactionSteps()) {
                String oldName = rs.getName();
                if (oldName.startsWith("_reverse_")) {
                    String newName = newModel.getReactionName("rev", oldName.substring("_reverse_".length()));
                    rs.setName(newName);
                }
            }
            hashTable.put("newBioModel", newBioModel);
        }
    };
    AsynchClientTask task2 = new AsynchClientTask("Creating BioModel from BioModel Application", AsynchClientTask.TASKTYPE_SWING_BLOCKING) {

        @Override
        public void run(Hashtable<String, Object> hashTable) throws Exception {
            BioModel newBioModel = (BioModel) hashTable.get("newBioModel");
            DocumentWindowManager windowManager = createDocumentWindowManager(newBioModel);
            // if(simContext.getBioModel().getVersion() != null){
            // ((BioModelWindowManager)windowManager). setCopyFromBioModelAppVersionableTypeVersion(
            // new VersionableTypeVersion(VersionableType.BioModelMetaData, simContext.getBioModel().getVersion()));
            // }
            getMdiManager().createNewDocumentWindow(windowManager);
        }
    };
    ClientTaskDispatcher.dispatch(requester.getComponent(), new Hashtable<String, Object>(), new AsynchClientTask[] { task1, task2 }, false);
}