/// <summary> /// Once interrrupts /// </summary> /// <param name="calculation">Asynchronous calculation</param> /// <param name="finish">Finish action</param> public static void OnceFinish(IAsynchronousCalculation calculation, Action finish) { if ((calculation == null) | (finish == null)) { return; } new FinishHelper(calculation, finish); }
/// <summary> /// Once interrrupts /// </summary> /// <param name="calculation">Asynchronous calculation</param> /// <param name="interrupt">Interrupt action</param> public static void OnceInterrupt(IAsynchronousCalculation calculation, Action interrupt) { if ((calculation == null) | (interrupt == null)) { return; } new InterruptHelper(calculation, interrupt); }
/// <summary> /// Interruption /// </summary> static public void Interrupt() { if (currentCalculation == null) { return; } currentCalculation.Interrupt(); currentCalculation = null; }
/// <summary> /// Starts animation /// </summary> /// <param name="collection">Collection of components</param> /// <param name="reasons">Reasons</param> /// <param name="animationType">Type of animation</param> /// <param name="pause">Pause</param> /// <param name="timeScale">Time scale</param> /// <param name="realTime">The "real time" sign</param> /// <param name="absoluteTime">The "absolute time" sign</param> /// <returns>Animation asynchronous calculation</returns> public static IAsynchronousCalculation StartAnimation(this IComponentCollection collection, string[] reasons, Animation.Interfaces.Enums.AnimationType animationType, TimeSpan pause, double timeScale, bool realTime, bool absoluteTime) { currentCalculation = global::Animation.Interfaces.StaticExtensionAnimationInterfaces.StartAnimation (collection, reasons, animationType, pause, timeScale, realTime, absoluteTime) as IAsynchronousCalculation; return(currentCalculation); }
/// <summary> /// Creates scada from desktop /// </summary> /// <param name="desktop">The desktop</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sing</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>The scada</returns> public override IScadaInterface Create(IDesktop desktop, string dataConsumer, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { IScadaInterface scada = new ScadaDesktopMotion6D(desktop, dataConsumer, timeUnit, isAbsoluteTime, realtimeStep); scada.OnCreateXml += (XElement document) => { onCreateXmlFactory(desktop, document); }; return(scada); }
/// <summary> /// Stops current calculation /// </summary> static public void StopCurrentCalculation() { if (currentCalculation == null) { return; } if (currentCalculation.IsRunning) { currentCalculation.Interrupt(); } currentCalculation = null; }
/// <summary> /// Constructor /// </summary> /// <param name="collection">Collection of components</param> /// <param name="reason">Reason</param> /// <param name="priority">Priority</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="realtimeStep">Realtime step</param> /// <param name="realtime">Realtime provider</param> public DataRuntime(IComponentCollection collection, string reason, int priority, IDataConsumer dataConsumer = null, IAsynchronousCalculation realtimeStep = null, ITimeMeasureProvider realtime = null) : base(collection, reason, priority, dataConsumer, realtimeStep, realtime) { updateInternal = base.UpdateAll; foreach (IPosition p in collection.GetObjectsAndArrows <IPosition>()) { updateInternal = UpdateWithFrames; break; } }
/// <summary> /// Start /// </summary> /// <param name="collection">Components</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="stepAction">Step Action</param> /// <param name="dataConsumer">Data Consumer</param> /// <param name="log">log</param> /// <param name="reason">Reason</param> IRealtime IRealtime.Start(IComponentCollection collection, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation stepAction, IDataConsumer dataConsumer, IEventLog log, string reason) { this.reason = reason; StaticExtensionEventPortable.StartRealtime(collection); StandardEventRuntime rt = new StandardEventRuntime(); rt.collection = collection; try { ITimeMeasureProvider realTime = RealtimeProvider.Create(isAbsoluteTime, timeUnit, reason); Tuple <IDataConsumer, IComponentCollection, ITimeMeasureProvider, IAsynchronousCalculation> tuple = new Tuple <IDataConsumer, IComponentCollection, ITimeMeasureProvider, IAsynchronousCalculation> (dataConsumer, collection, realTime, stepAction); rt.timeProvider = realTime; rt.timeBackup = new DataPerformer.TimeProviderBackup(dataConsumer, realTime, null, reason, 0); IEvent[] events = (dataConsumer as IEventHandler).Events.EnumerableToArray(); if (log != null) { foreach (IEvent ev in events) { string name = (dataConsumer as IAssociatedObject).GetRelativeName(ev as IAssociatedObject); ev.ConnectLog(log, name); } collection.ForEach((IEventReader reader) => { string name = (dataConsumer as IAssociatedObject).GetRelativeName(reader as IAssociatedObject); reader.ConnectLog(log, name); }); } collection.ForEach((ICalculationReason cr) => { cr.CalculationReason = reason; }); collection.ForEach((IRealTimeStartStop ss) => { ss.Start(); }); rt.eventBackup = new EventBackup(tuple, events, reason); } catch (Exception exception) { onError(exception); (rt as IRealtime).Stop(); rt = null; } return(rt); }
IRealtime StartRealtime() { IAsynchronousCalculation animation = collection.StartAnimation(new string[] { StaticExtensionEventInterfaces.Realtime, AnimationType.GetReason() }, AnimationType, new TimeSpan(0), 1, true, isAbsoluteTime); if (animation != null) { StaticExtensionEventPortable.OnceStop(animation.Interrupt); } return(StaticExtensionEventPortable.StartRealtime(collection, timeUnit, isAbsoluteTime, animation, dataConsumer, StaticExtensionEventInterfaces.NewLog, StaticExtensionEventInterfaces.Realtime)); }
/// <summary> /// Constructor /// </summary> /// <param name="desktop">The desktop</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <param name="events">Events</param> protected ScadaDesktop(IDesktop desktop, string dataConsumer, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep, Event.Interfaces.IEvent[] events) { if (desktop == null) { return; } this.realtimeStep = realtimeStep; this.desktop = desktop; this.timeUnit = timeUnit; this.isAbsoluteTime = isAbsoluteTime; consumerName = dataConsumer; eventsData = events; CreateScada(); }
object IAnimationDriver.StartAnimation(IComponentCollection collection, string[] reasons, AnimationType animationType, TimeSpan pause, double timeScale, bool realTime, bool absoluteTime) { List <IAnimatedObject> l = new List <IAnimatedObject>(); IAsynchronousCalculation calc = null; double[] changeFrameTime = new double[1]; if (realTime) { collection.ForEach <IAnimatedObject>((IAnimatedObject animated) => { animated.InitRealtime(animationType, changeFrameTime); l.Add(animated); }); if (animationType == AnimationType.Asynchronous) { calc = new Animated.WpfAsynchronousRealtimeAnimatedCalculation(l.ToArray(), 1, changeFrameTime, collection); } } else { collection.ForEach <IAnimatedObject>((IAnimatedObject animated) => { animated.InitAnimation(animationType); l.Add(animated); animated.InitAnimation(animationType); }); if (animationType == AnimationType.Synchronous) { if (pause > TimeSpan.FromSeconds(0)) { calc = new DataPerformer.AsynchronousCalculation.PauseAsynchronousCalculation(pause); collection = null; } } else { calc = new Animated.WpfAsynchronousAnimatedCalculation(l.ToArray(), timeScale, collection); } } if (l.Count == null) { return(null); } return(calc); }
/// <summary> /// Constructor /// </summary> /// <param name="desktop">The desktop</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <param name="events">Events</param> protected ScadaDesktop(IDesktop desktop, string dataConsumer, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep, Event.Interfaces.IEvent[] events) : base(desktop, dataConsumer, timeUnit, isAbsoluteTime, realtimeStep, events) { onStop += () => { Event.Interfaces.IEventLog log = Event.Interfaces.StaticExtensionEventInterfaces.CurrentLog; if (log != null) { if (log is IDisposable) { (log as IDisposable).Dispose(); } } Event.Interfaces.StaticExtensionEventInterfaces.NewLog = null; }; }
/// <summary> /// Performs action with fixed step /// </summary> /// <param name="consumer">Data consumer</param> /// <param name="start">Start</param> /// <param name="step">Step</param> /// <param name="count">Count of steps</param> /// <param name="provider">Provider of time measure</param> /// <param name="processor">Differential equation processor</param> /// <param name="reason">Reason</param> /// <param name="priority">Priority</param> /// <param name="action">Additional action</param> /// <param name="errorHandler">Error handler</param> /// <param name="asynchronousCalculation">Asynchronous calculation</param> static public void PerformFixed(this IDataConsumer consumer, double start, double step, int count, ITimeMeasureProvider provider, IDifferentialEquationProcessor processor, string reason, int priority, Action action, IAsynchronousCalculation asynchronousCalculation = null, IErrorHandler errorHandler = null) { try { using (TimeProviderBackup backup = new TimeProviderBackup(consumer, provider, processor, reason, priority)) { IDataRuntime runtime = backup.Runtime; ITimeMeasureProvider old = processor.TimeProvider; processor.TimeProvider = provider; IStep st = null; if (runtime is IStep) { st = runtime as IStep; } provider.Time = start; double t = start; double last = t; Action <double, double, long> act = runtime.Step(processor, (double time) => { provider.Time = time; }, reason, asynchronousCalculation); for (int i = 0; i < count; i++) { t = start + i * step; act(last, t, i); last = t; action(); } processor.TimeProvider = old; } } catch (Exception ex) { if (errorHandler != null) { errorHandler.ShowError(ex, 10); } else { ex.ShowError(10); } } }
/// <summary> /// Constructor /// </summary> /// <param name="collection">Collection of components</param> /// <param name="reason">Reason</param> /// <param name="priority">Priority</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="realtimeStep">Realtime step</param> /// <param name="realtime">Realtime provider</param> public DataRuntime(IComponentCollection collection, string reason, int priority, IDataConsumer dataConsumer = null, IAsynchronousCalculation realtimeStep = null, ITimeMeasureProvider realtime = null) { this.collection = collection; this.priority = priority; this.reason = reason; this.realtimeStep = realtimeStep; Prepare(); if (realtime != null & priority == 0) { if (reason == StaticExtensionEventInterfaces.Realtime | reason.IsRealtimeAnalysis()) { List <IRealtimeUpdate> lr = new List <IRealtimeUpdate>(); realTimeData = new Dictionary <IComponentCollection, Tuple <IDataRuntime, double[], IDifferentialEquationProcessor, Action> >(); this.realtime = realtime as RealtimeProvider; provider = realtime; dCollection = new Dictionary <object, IComponentCollection>(); /*!!!! * DECOMPOSITION THINK AFTER * collections = collection.Decompose(dCollection); */ //========== REPLACED======== collections = new List <IComponentCollection>() { collection }; collection.ForEach((IEvent ev) => { dCollection[ev] = collection; }); //=========================== IEventLog log = null; if (reason.Equals(StaticExtensionEventInterfaces.Realtime)) { log = StaticExtensionEventInterfaces.NewLog; } Action logupd = null; if (log != null) { Dictionary <IMeasurement, string> namem = new Dictionary <IMeasurement, string>(); List <IMeasurement> lim = new List <IMeasurement>(); collection.ForEach((IMeasurements mm) => { string name = (dataConsumer).GetMeasurementsName(mm) + "."; for (int i = 0; i < mm.Count; i++) { IMeasurement mea = mm[i]; if (mea is IReplacedMeasurementParameter) { lim.Add(mea); namem[mea] = name + mea.Name; } } }); if (lim.Count > 0) { if (reason == "Realtime") { logupd = () => { logDictionary = new Dictionary <string, object>(); foreach (IMeasurement mea in namem.Keys) { string n = namem[mea]; logDictionary[n] = mea.Parameter(); } log.Write(logDictionary, DateTime.Now); }; } } } if (collections.Count == 1) { IDifferentialEquationProcessor pr = CreateProcessor(collection); double[] dt = new double[1]; bool find = (reason.Equals(StaticExtensionEventInterfaces.Realtime) | reason.Equals(StaticExtensionEventInterfaces.RealtimeLogAnalysis)); collection.ForEach((IRealtimeUpdate ru) => { lr.Add(ru); }, find); collection.ForEach((IEvent ev) => { IComponentCollection cc = CreateCollection(ev); if (!realTimeData.ContainsKey(cc)) { List <IRealtimeUpdate> lru = new List <IRealtimeUpdate>(); cc.ForEach((IRealtimeUpdate rud) => { lru.Add(rud); }, find); IDataRuntime drc = Copy(cc); double[] dtt = new double[1]; Action actp = CreateAction(drc, dtt, pr, logupd, lru.ToArray()); realTimeData[cc] = new Tuple <IDataRuntime, double[], IDifferentialEquationProcessor, Action> (drc, dtt, pr, actp); } }); } else { foreach (IComponentCollection coll in collections) { List <IRealtimeUpdate> lu = new List <IRealtimeUpdate>(); foreach (object o in coll.AllComponents) { if (o is IObjectLabel) { IRealtimeUpdate ru = (o as IObjectLabel).Object.GetObject <IRealtimeUpdate>(); if (ru != null) { lu.Add(ru); } } } IDataRuntime rt = Copy(coll); IDifferentialEquationProcessor pr = CreateProcessor(collection); double[] dt = new double[1]; Action act = CreateAction(rt, dt, pr, null, lr.ToArray()); realTimeData[coll] = new Tuple <IDataRuntime, double[], IDifferentialEquationProcessor, Action> (rt, dt, pr, act); } } (realtime as RealtimeProvider).Update(); startRuntime = provider.Time; foreach (Tuple <IDataRuntime, double[], IDifferentialEquationProcessor, Action> t in realTimeData.Values) { t.Item2[0] = startRuntime; } collection.ForEach <IStarted>((IStarted st) => { st.Start(startRuntime); }); } } }
/// <summary> /// Creates scada from desktop /// </summary> /// <param name="desktop">The desktop</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sing</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>The scada</returns> public abstract IScadaInterface Create(IDesktop desktop, string dataConsumer, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep);
/// <summary> /// Creates Scada from stream /// </summary> /// <param name="stream">Stream</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>Scada</returns> public static IScadaInterface ScadaFromBytes(this System.IO.Stream stream, string dataConsumer, TimeType timeType, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { IDesktop desktop = stream.DesktopFromStream(); return(desktop.ScadaFromDesktop(dataConsumer, timeType, isAbsoluteTime, realtimeStep)); }
/// <summary> /// Creates Scada from file /// </summary> /// <param name="fileName">File name</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>Scada</returns> public static IScadaInterface ScadaFromFile(this string fileName, string dataConsumer, TimeType timeType, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { IDesktop desktop = fileName.DesktopFromFile(); return(desktop.ScadaFromDesktop(dataConsumer, timeType, isAbsoluteTime, realtimeStep)); }
/// <summary> /// Creates Scada from string /// </summary> /// <param name="buffer">Buffer</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>Scada</returns> public static IScadaInterface ScadaFromString(this string buffer, string dataConsumer, TimeType timeType, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { return(buffer.StringToBytes().ScadaFromBytes(dataConsumer, timeType, isAbsoluteTime, realtimeStep)); }
/// <summary> /// Creates Scada from bytes /// </summary> /// <param name="buffer">Buffer</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>Scada</returns> public static IScadaInterface ScadaFromBytes(this byte[] buffer, string dataConsumer, TimeType timeType, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { IDesktop desktop = buffer.DesktopFromBytes(); return(desktop.ScadaFromDesktop(dataConsumer, timeType, isAbsoluteTime, realtimeStep)); }
/// <summary> /// Creates Scada from desktop /// </summary> /// <param name="desktop">Desktop</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeType">Time type</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> /// <returns>Scada</returns> public static IScadaInterface ScadaFromDesktop(this IDesktop desktop, string dataConsumer, TimeType timeType, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) { if (desktop == null) { return(null); } return(scadaFactory.Create(desktop, dataConsumer, timeType, isAbsoluteTime, realtimeStep)); }
internal FinishHelper(IAsynchronousCalculation calc, Action stop) { this.calc = calc; this.stop = stop; calc.Finish += StopAction; }
internal InterruptHelper(IAsynchronousCalculation calc, Action stop) { this.calc = calc; this.stop = stop; calc.OnInterrupt += StopAction; }
/// <summary> /// Constructor /// </summary> /// <param name="desktop">The desktop</param> /// <param name="dataConsumer">Data consumer</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">The "is absolute time" sign</param> /// <param name="realtimeStep">Realtime Step</param> protected ScadaDesktopMotion6D(IDesktop desktop, string dataConsumer, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep) : base(desktop, dataConsumer, timeUnit, isAbsoluteTime, realtimeStep, null) { }
/// <summary> /// Start /// </summary> /// <param name="collection">Components</param> /// <param name="timeUnit">Time unit</param> /// <param name="isAbsoluteTime">Components</param> /// <param name="realtimeStep">Realtime step</param> /// <param name="dataConsumer">Data consumer</param> public static IRealtime StartRealtime(this IComponentCollection collection, TimeType timeUnit, bool isAbsoluteTime, IAsynchronousCalculation realtimeStep, IDataConsumer dataConsumer, IEventLog log, string reason) { if (reason.Equals(StaticExtensionEventInterfaces.Realtime)) { if (currentRuntime != null) { throw new Exception(); } start(reason); currentRuntime = Runtime.Start(collection, timeUnit, isAbsoluteTime, realtimeStep, dataConsumer, log, reason); if (currentRuntime == null) { stop(); } } else { start(reason); return(Runtime.Start(collection, timeUnit, isAbsoluteTime, realtimeStep, dataConsumer, log, reason)); } return(currentRuntime); }