/// <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);
}
