-/*******************************************************************************\r
- * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.simulation.data;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.Collections;\r
-import java.util.List;\r
-import java.util.Random;\r
-\r
-import org.simantics.databoard.Datatypes;\r
-import org.simantics.databoard.binding.Binding;\r
-import org.simantics.databoard.binding.NumberBinding;\r
-import org.simantics.databoard.binding.error.BindingException;\r
-import org.simantics.databoard.type.Datatype;\r
-import org.simantics.databoard.util.Bean;\r
-\r
-/**\r
- * Pseudo solver has three variables: Sine, Ramp and Random\r
- * \r
- * Values are sampled in real time until the solver is disposed.\r
- *\r
- * @author Toni Kalajainen <toni.kalajainen@vtt.fi>\r
- */\r
-public class PseudoSolver extends AbstractDatasource {\r
- \r
- public static String SINE = "Sine";\r
- public static String RAMP = "Ramp";\r
- public static String RANDOM = "Random";\r
- public static List<String> KEYS;\r
- \r
- Thread thread;\r
- long startTime;\r
- double time;\r
- Random random;\r
- int cycle = 0;\r
- \r
- public PseudoSolver() {\r
- super(); \r
- random = new Random();\r
- }\r
- \r
- @Override\r
- public Collection<String> getVariables() {\r
- return KEYS;\r
- }\r
- \r
- public void start() {\r
- thread = new Thread() {\r
- @Override\r
- public void run() {\r
- startTime = System.nanoTime();\r
- notifyStep();\r
- while (Thread.currentThread() == thread) {\r
- writeLock.lock();\r
- try {\r
- if (Thread.currentThread() != thread) return;\r
- for (int i=0; i<10; i++) {\r
- cycle++;\r
- time = cycle * 0.01;\r
- notifyStep();\r
- }\r
- } finally {\r
- writeLock.unlock();\r
- }\r
- try {Thread.sleep(15); } catch (InterruptedException e) {}\r
- }\r
- }\r
- };\r
- thread.start();\r
- }\r
- \r
- public void stop() {\r
- writeLock.lock();\r
- try {\r
- thread = null;\r
- } finally {\r
- writeLock.unlock();\r
- }\r
- }\r
- \r
- @Override\r
- public Datatype getType(String key) {\r
- //if (key.equals("Ramp")) return Datatypes.BOOLEAN;\r
- return Datatypes.DOUBLE;\r
- }\r
- \r
- @Override\r
- public Object getTime(NumberBinding binding) {\r
- try {\r
- return binding.create(time);\r
- } catch (BindingException e) {\r
- throw new RuntimeException(e);\r
- }\r
- }\r
-\r
- @Override\r
- public VariableHandle openHandle(Bean item, String key, Binding valueBinding) {\r
- getValue(key, valueBinding);\r
- return new MyVariableHandle(key, valueBinding);\r
- }\r
- \r
- public Object getValue(String key, Binding binding) {\r
- if (binding instanceof NumberBinding == false) throw new IllegalArgumentException("binding must be NumberBinding");\r
- NumberBinding nb = (NumberBinding) binding;\r
- try {\r
- if (key.equals(SINE)) {\r
- double value = Math.sin(time);\r
- return nb.create(value);\r
- } else if (key.equals(RAMP)) {\r
- boolean up = time - Math.floor(time) >= 0.5;\r
- double value = up ? 1.0 : 0.0; \r
- return value; \r
- } else if (key.equals(RANDOM)) {\r
- return random.nextDouble()*10;\r
- }\r
- } catch (BindingException e) {\r
- throw new RuntimeException(e);\r
- }\r
- throw new RuntimeException("Unknown variable "+key);\r
- } \r
- \r
- static {\r
- List<String> keys = new ArrayList<String>();\r
- keys.add(SINE);\r
- keys.add(RAMP);\r
- keys.add(RANDOM);\r
- KEYS = Collections.unmodifiableList( keys );\r
- }\r
- \r
- class MyVariableHandle implements VariableHandle {\r
-\r
- String key; \r
- Binding b;\r
- \r
- public MyVariableHandle(String key, Binding b) {\r
- this.b = b;\r
- this.key = key;\r
- }\r
-\r
- @Override\r
- public String key() {\r
- return key;\r
- }\r
- \r
- @Override\r
- public Binding binding() {\r
- return b;\r
- }\r
-\r
- @Override\r
- public Object getValue() {\r
- return PseudoSolver.this.getValue(key, b);\r
- }\r
-\r
- @Override\r
- public void dispose() {\r
- }\r
- \r
- }\r
-}\r
-\r
+/*******************************************************************************
+ * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.simulation.data;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+import org.simantics.databoard.Datatypes;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.databoard.binding.NumberBinding;
+import org.simantics.databoard.binding.error.BindingException;
+import org.simantics.databoard.type.Datatype;
+import org.simantics.databoard.util.Bean;
+
+/**
+ * Pseudo solver has three variables: Sine, Ramp and Random
+ *
+ * Values are sampled in real time until the solver is disposed.
+ *
+ * @author Toni Kalajainen <toni.kalajainen@vtt.fi>
+ */
+public class PseudoSolver extends AbstractDatasource {
+
+ public static String SINE = "Sine";
+ public static String RAMP = "Ramp";
+ public static String RANDOM = "Random";
+ public static List<String> KEYS;
+
+ Thread thread;
+ long startTime;
+ double time;
+ Random random;
+ int cycle = 0;
+
+ public PseudoSolver() {
+ super();
+ random = new Random();
+ }
+
+ @Override
+ public Collection<String> getVariables() {
+ return KEYS;
+ }
+
+ public void start() {
+ thread = new Thread() {
+ @Override
+ public void run() {
+ startTime = System.nanoTime();
+ notifyStep();
+ while (Thread.currentThread() == thread) {
+ writeLock.lock();
+ try {
+ if (Thread.currentThread() != thread) return;
+ for (int i=0; i<10; i++) {
+ cycle++;
+ time = cycle * 0.01;
+ notifyStep();
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ try {Thread.sleep(15); } catch (InterruptedException e) {}
+ }
+ }
+ };
+ thread.start();
+ }
+
+ public void stop() {
+ writeLock.lock();
+ try {
+ thread = null;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public Datatype getType(String key) {
+ //if (key.equals("Ramp")) return Datatypes.BOOLEAN;
+ return Datatypes.DOUBLE;
+ }
+
+ @Override
+ public Object getTime(NumberBinding binding) {
+ try {
+ return binding.create(time);
+ } catch (BindingException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public VariableHandle openHandle(Bean item, String key, Binding valueBinding) {
+ getValue(key, valueBinding);
+ return new MyVariableHandle(key, valueBinding);
+ }
+
+ public Object getValue(String key, Binding binding) {
+ if (binding instanceof NumberBinding == false) throw new IllegalArgumentException("binding must be NumberBinding");
+ NumberBinding nb = (NumberBinding) binding;
+ try {
+ if (key.equals(SINE)) {
+ double value = Math.sin(time);
+ return nb.create(value);
+ } else if (key.equals(RAMP)) {
+ boolean up = time - Math.floor(time) >= 0.5;
+ double value = up ? 1.0 : 0.0;
+ return value;
+ } else if (key.equals(RANDOM)) {
+ return random.nextDouble()*10;
+ }
+ } catch (BindingException e) {
+ throw new RuntimeException(e);
+ }
+ throw new RuntimeException("Unknown variable "+key);
+ }
+
+ static {
+ List<String> keys = new ArrayList<String>();
+ keys.add(SINE);
+ keys.add(RAMP);
+ keys.add(RANDOM);
+ KEYS = Collections.unmodifiableList( keys );
+ }
+
+ class MyVariableHandle implements VariableHandle {
+
+ String key;
+ Binding b;
+
+ public MyVariableHandle(String key, Binding b) {
+ this.b = b;
+ this.key = key;
+ }
+
+ @Override
+ public String key() {
+ return key;
+ }
+
+ @Override
+ public Binding binding() {
+ return b;
+ }
+
+ @Override
+ public Object getValue() {
+ return PseudoSolver.this.getValue(key, b);
+ }
+
+ @Override
+ public void dispose() {
+ }
+
+ }
+}
+
Code Review / simantics / platform.git / blobdiff