bundles/org.simantics.simulation/src/org/simantics/simulation/experiment/ExperimentUtil.java

   1 package org.simantics.simulation.experiment;
   2
   3 import java.util.Collection;
   4 import java.util.UUID;
   5 import java.util.function.Consumer;
   6
   7 import org.eclipse.core.runtime.IProgressMonitor;
   8 import org.eclipse.core.runtime.IStatus;
   9 import org.eclipse.core.runtime.Status;
  10 import org.eclipse.core.runtime.jobs.Job;
  11 import org.eclipse.ui.progress.IProgressConstants2;
  12 import org.simantics.DatabaseJob;
  13 import org.simantics.Simantics;
  14 import org.simantics.databoard.Bindings;
  15 import org.simantics.db.ReadGraph;
  16 import org.simantics.db.RequestProcessor;
  17 import org.simantics.db.Resource;
  18 import org.simantics.db.Session;
  19 import org.simantics.db.WriteGraph;
  20 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
  21 import org.simantics.db.common.request.ObjectsWithType;
  22 import org.simantics.db.common.request.WriteRequest;
  23 import org.simantics.db.common.request.WriteResultRequest;
  24 import org.simantics.db.exception.DatabaseException;
  25 import org.simantics.db.layer0.request.PossibleActiveExperiment;
  26 import org.simantics.db.layer0.request.PossibleActiveRun;
  27 import org.simantics.db.layer0.variable.Variable;
  28 import org.simantics.db.procedure.Procedure;
  29 import org.simantics.db.service.VirtualGraphSupport;
  30 import org.simantics.layer0.Layer0;
  31 import org.simantics.project.IProject;
  32 import org.simantics.simulation.ontology.SimulationResource;
  33 import org.simantics.simulation.project.IExperimentManager;
  34
  35 /**
  36  * @author Tuukka Lehtonen
  37  */
  38 public final class ExperimentUtil {
  39
  40     public static void stepExperiment(IExperiment experiment, double duration) {
  41         if(experiment instanceof IDynamicExperiment)
  42             ((IDynamicExperiment)experiment).simulateDuration(duration);
  43     }
  44
  45     public static void simulateExperiment(IExperiment experiment, boolean enabled) {
  46         if(experiment instanceof IDynamicExperiment)
  47             ((IDynamicExperiment)experiment).simulate(enabled);
  48     }
  49
  50     public static void disposeExperiment(final IExperiment experiment) {
  51
  52         if(experiment instanceof IDynamicExperiment) {
  53
  54             ((IDynamicExperiment)experiment).shutdown(null);
  55
  56             Session session = Simantics.getSession();
  57                         VirtualGraphSupport vgs = session.getService(VirtualGraphSupport.class);
  58                         session.asyncRequest(new WriteRequest(vgs.getMemoryPersistent("experiments")) {
  59
  60                                 @Override
  61                                 public void perform(WriteGraph graph) throws DatabaseException {
  62
  63                                         SimulationResource SIMU = SimulationResource.getInstance(graph);
  64                                         Resource activeRun = experiment.getResource();
  65                                         graph.deny(activeRun, SIMU.IsActive, activeRun);
  66
  67                                 }
  68
  69                         });
  70
  71         }
  72
  73     }
  74
  75     public static void step(double duration) {
  76         IExperimentManager manager =
  77             Simantics.getProject().getHint(IExperimentManager.KEY_EXPERIMENT_MANAGER);
  78         IExperiment experiment = manager.getActiveExperiment();
  79         if(experiment instanceof IDynamicExperiment)
  80             ((IDynamicExperiment)experiment).simulateDuration(duration);
  81     }
  82
  83     public static void simulate(boolean enabled) {
  84         IExperimentManager manager =
  85             Simantics.getProject().getHint(IExperimentManager.KEY_EXPERIMENT_MANAGER);
  86         IExperiment experiment = manager.getActiveExperiment();
  87         if(experiment instanceof IDynamicExperiment)
  88             ((IDynamicExperiment)experiment).simulate(enabled);
  89     }
  90
  91     /**
  92      * Synchronously shutdown active experiment.
  93      *
  94      * @param project
  95      */
  96     public static void shutdownActiveExperiment(IProject project) {
  97         shutdownActiveExperiment(project, null);
  98     }
  99
 100     /**
 101      * Synchronously shutdown active experiment.
 102      *
 103      * @param project
 104      */
 105     public static void shutdownActiveExperiment(IProject project, IProgressMonitor monitor) {
 106         IExperimentManager manager = project.getHint(IExperimentManager.KEY_EXPERIMENT_MANAGER);
 107         IExperiment experiment = manager.getActiveExperiment();
 108         if (experiment != null)
 109             experiment.shutdown(monitor);
 110     }
 111
 112     /**
 113      * If there is an active experiment, schedule a job for its shutdown.
 114      *
 115      * @param project
 116      */
 117     public static void scheduleShutdownActiveExperiment(IProject project) {
 118         scheduleShutdownActiveExperiment(project, null);
 119     }
 120
 121     /**
 122      * If there is an active experiment, schedule a job for its shutdown.
 123      *
 124      * @param project
 125      */
 126     public static void scheduleShutdownActiveExperiment(IProject project, Consumer<IExperiment> callback) {
 127         IExperimentManager manager = project.getHint(IExperimentManager.KEY_EXPERIMENT_MANAGER);
 128         final IExperiment experiment = manager.getActiveExperiment();
 129         if (experiment != null) {
 130             Job job = new DatabaseJob("Shutting down experiment") {
 131                 @Override
 132                 protected IStatus run(final IProgressMonitor monitor) {
 133                     try {
 134                         experiment.shutdown(monitor);
 135                         if (callback != null)
 136                             callback.accept(null);
 137                         return Status.OK_STATUS;
 138                     } finally {
 139                         monitor.done();
 140                     }
 141                 }
 142             };
 143             job.setProperty(IProgressConstants2.SHOW_IN_TASKBAR_ICON_PROPERTY, Boolean.TRUE);
 144             job.setUser(true);
 145             job.schedule();
 146         }
 147     }
 148
 149     public static Variable possibleActiveRunVariable(ReadGraph graph, Resource model) throws DatabaseException {
 150         return graph.syncRequest(new PossibleActiveRun(model));
 151     }
 152
 153     /**
 154      * @param processor
 155      * @param experiment
 156      * @param asyncCallback
 157      * @return
 158      * @throws DatabaseException
 159      */
 160     public static Resource activateExperiment(RequestProcessor processor, Resource experiment, Procedure<Resource> asyncCallback) throws DatabaseException {
 161         VirtualGraphSupport vgs = processor.getService(VirtualGraphSupport.class);
 162         WriteResultRequest<Resource> w = new WriteResultRequest<Resource>(vgs.getMemoryPersistent("experiments")) {
 163             @Override
 164             public Resource perform(WriteGraph graph) throws DatabaseException {
 165                 return activateExperiment(graph, experiment);
 166             }
 167         };
 168         if (processor instanceof WriteGraph) {
 169             return ((WriteGraph) processor).syncRequest(w);
 170         } else {
 171             if (asyncCallback == null)
 172                 asyncCallback = new ProcedureAdapter<>();
 173             processor.getSession().asyncRequest(w, asyncCallback);
 174             return null;
 175         }
 176     }
 177
 178     /**
 179      * @param processor
 180      * @param run
 181      * @throws DatabaseException
 182      */
 183     public static void activateRun(RequestProcessor processor, Resource run) throws DatabaseException {
 184         VirtualGraphSupport vgs = processor.getService(VirtualGraphSupport.class);
 185         WriteRequest w = new WriteRequest(vgs.getMemoryPersistent("experiments")) {
 186             @Override
 187             public void perform(WriteGraph graph) throws DatabaseException {
 188                 ExperimentUtil.activateRun(graph, run);
 189             }
 190         };
 191         if (processor instanceof WriteGraph) {
 192             ((WriteGraph) processor).syncRequest(w);
 193         } else {
 194             processor.getSession().asyncRequest(w);
 195         }
 196     }
 197
 198     private static Resource activateExperiment(WriteGraph graph, Resource experiment) throws DatabaseException {
 199         Layer0 L0 = Layer0.getInstance(graph);
 200         SimulationResource SIMU = SimulationResource.getInstance(graph);
 201
 202         Resource experimentType = graph.getPossibleType(experiment, SIMU.Experiment);
 203         if (experimentType == null)
 204             throw new DatabaseException("No unique experiment type was found for experiment " + graph.getPossibleURI(experiment));
 205         Collection<Resource> runTypes = graph.sync(new ObjectsWithType(experimentType, L0.ConsistsOf, SIMU.RunType));
 206         if (runTypes.size() != 1)
 207             throw new DatabaseException("No unique run type was found for experiment " + graph.getPossibleURI(experiment));
 208         final Resource runType = runTypes.iterator().next();
 209
 210         VirtualGraphSupport vgs = graph.getService(VirtualGraphSupport.class);
 211         return graph.syncRequest(new WriteResultRequest<Resource>(vgs.getMemoryPersistent("experiments")) {
 212             @Override
 213             public Resource perform(WriteGraph graph) throws DatabaseException {
 214                 Layer0 L0 = Layer0.getInstance(graph);
 215                 Resource run = graph.newResource();
 216                 graph.claim(run, L0.InstanceOf, runType);
 217                 graph.addLiteral(run, L0.HasName, L0.NameOf, L0.String, UUID.randomUUID().toString(), Bindings.STRING);
 218                 graph.claim(experiment, L0.ConsistsOf, run);
 219
 220                 Resource activeRun = graph.syncRequest(new PossibleActiveExperiment(experiment));
 221                 if (activeRun != null) {
 222                     graph.deny(activeRun, SIMU.IsActive, activeRun);
 223                 }
 224                 graph.claim(run, SIMU.IsActive, run);
 225
 226                 return run;
 227             }
 228         });
 229     }
 230
 231     private static void activateRun(WriteGraph graph, Resource run) throws DatabaseException {
 232         SimulationResource SIMU = SimulationResource.getInstance(graph);
 233         Resource activeRun = graph.syncRequest(new PossibleActiveExperiment(run));
 234         if (activeRun != null) {
 235             graph.deny(activeRun, SIMU.IsActive, activeRun);
 236         }
 237         graph.claim(run, SIMU.IsActive, run);
 238     }
 239
 240 }