public override IOutputData PullOutputData(IDAQOutputStream stream, TimeSpan duration)
{
/*
* IOuputData will be directed to a device (not an DAQStream) by the controller.
* Controller should get mapping (device=>data) from the current Epoch instance.
*
* Thus the standard PullOuputData will pull from the controller's queue for this
* device.
*/
if (duration.Samples(stream.SampleRate) <= 1)
{
throw new ExternalDeviceException("Cannot pull less than one sample.");
}
try
{
IOutputData data = this.Controller.PullOutputData(this, duration);
return(data.DataWithUnits(MeasurementConversionTarget)
.DataWithExternalDeviceConfiguration(this, Configuration));
}
catch (Exception ex)
{
log.DebugFormat("Error pulling data from controller: " + ex.Message);
throw;
}
}
/// <summary>
/// Pulls data for output to the given IDAQStream. Default implementation pulls data from
/// this Device's Controller.
/// </summary>
/// <remarks>Appends this Device's Configuration to the IOutputData</remarks>
/// <param name="stream">Stream for output</param>
/// <param name="duration">Requested duration</param>
/// <returns>IOutputData of duration less than or equal to duration</returns>
/// <exception cref="ExternalDeviceException">Requested duration is less than one sample</exception>
public override IOutputData PullOutputData(IDAQOutputStream stream, TimeSpan duration)
{
/*
* IOuputData will be directed to a device (not an DAQStream) by the controller.
* Controller should get mapping (device=>data) from the current Epoch instance.
*
* Thus the standard PullOuputData will pull from the controller's queue for this
* device.
*/
try
{
//TODO should raise exception if duration is less than one sample
IOutputData data = this.Controller.PullOutputData(this, duration);
var deviceParameters = DeviceParametersForOutput(DateTimeOffset.Now.UtcDateTime).Data;
var config = MergeDeviceParametersIntoConfiguration(Configuration, deviceParameters);
log.DebugFormat("Pulling OutputData with parameters {0} (units {1})",
config,
UnitsForScaleFactorUnits(deviceParameters.ScaleFactorUnits));
return(data.DataWithConversion(m => ConvertOutput(m, deviceParameters))
.DataWithExternalDeviceConfiguration(this, config));
}
catch (Exception ex)
{
log.DebugFormat("Error pulling data from controller: {0} ({1})", ex.Message, ex);
throw;
}
}
private void SetupOutputPipeline(IDAQController c, out IOutputData expectedOutput, out DAQOutputStream outStream)
{
string units = "V";
var data = Enumerable.Range(0, 1000).Select(i => new Measurement(i, units)).ToList();
var sampleRate = new Measurement(100, "Hz");
var config = new Dictionary <string, object>();
expectedOutput = new OutputData(data,
sampleRate, true);
outStream = new DAQOutputStream("OUT");
outStream.SampleRate = sampleRate;
outStream.MeasurementConversionTarget = units;
(c as IMutableDAQController).AddStream(outStream);
var outQueue = new Dictionary <IDAQOutputStream, Queue <IOutputData> >();
outQueue[outStream] = new Queue <IOutputData>();
outQueue[outStream].Enqueue(expectedOutput);
TestDevice dev = new TestDevice("OUT-DEVICE", outQueue);
dev.BindStream(outStream);
dev.MeasurementConversionTarget = units;
}
public void Execute()
{
SearchingResult = CreateISearch();
Types = CreateTypes();
Bti = CreateBTI();
processing = CreateProcessing();
processing.Cutter += Types.CutterDelegate;
SearchingResult.FederalCodesDetected += processing.IsFederalEventHandler;
SearchingResult.Seek();
processing.FullProcessing();
if (IsNoResult())
{
IInputData newData = new InputData(data.VriKlass, data.Area
, data.BtiVri, data.LoLvl, data.MidLvl, data.HiLvl);
IFactory newFactory = new Factory(newData);
newFactory.Execute();
outputData = newFactory.outputData;
}
else
{
outputData = CreateOutputData();
}
}
/// <summary>
/// Pulls the next IOuputData from this stream's external device.
/// <para>This method checks the pulled data to see if its IsLast flag is true.
/// If so, this stream is marked as with LastDataPulled=true.</para>
/// </summary>
/// <remarks>Appends this stream's Configuration to the output data.</remarks>
/// <returns>The output data to be sent down the output pipeline</returns>
/// <exception cref="DAQException">If Device is null</exception>
/// <exception cref="DAQException">If the pulled data's SampleRate does match this stream's SampleRate</exception>
public virtual IOutputData PullOutputData(TimeSpan duration)
{
if (Device == null)
{
throw new DAQException("External Device is null (check configuration)");
}
IOutputData outData = Device.PullOutputData(this, duration);
if (!outData.SampleRate.Equals(this.SampleRate))
{
throw new DAQException("Sample rate mismatch.");
}
if (outData.IsLast)
{
LastDataPulled = true;
}
var convertedData = outData.DataWithUnits(MeasurementConversionTarget)
.DataWithStreamConfiguration(this, this.Configuration);
return(convertedData);
}
private void SetupInputPipeline(IDAQController c, out IOutputData expectedOutput, out DAQOutputStream outStream, out DAQInputStream inStream)
{
SetupOutputPipeline(c, out expectedOutput, out outStream);
inStream = new DAQInputStream("IN");
inStream.SampleRate = outStream.SampleRate;
outStream.Device.BindStream(inStream);
inStream.MeasurementConversionTarget = outStream.MeasurementConversionTarget;
}
void PreloadData(IHekaDevice device, IOutputData data)
{
var inputUnits = (ChannelType == StreamType.DIGITAL_OUT || ChannelType == StreamType.AUX_OUT)
? Measurement.UNITLESS : "V";
var sampleData = data.DataWithUnits(inputUnits).DataWithUnits(DAQCountUnits);
var samples = sampleData.Data.Select(m => (short)m.Quantity).ToList();
device.PreloadSamples(ChannelType, ChannelNumber, samples);
}
public OutputData(IOutputData baseData,
IEnumerable <IMeasurement> derivedData) :
base(baseData, derivedData)
{
if (baseData.HasOutputTime)
{
OutputTime = baseData.OutputTime;
}
IsLast = baseData.IsLast;
}
/// <summary>
/// Constructs a new RenderedStimulus instance.
/// </summary>
/// <param name="stimulusID">Stimulus plugin ID</param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="data">Pre-rendered stimulus data</param>
/// <exception cref="MeasurementIncompatibilityException">If data measurements do not have homogenous BaseUnits</exception>
public RenderedStimulus(string stimulusID, IDictionary <string, object> parameters, IOutputData data)
: base(stimulusID, data.Data.BaseUnits(), parameters)
{
if (data == null)
{
throw new ArgumentException("Data may not be null", "data");
}
if (parameters == null)
{
throw new ArgumentException("Parameters may not be null", "Parameters");
}
Data = data;
}
/// <summary>
/// Returns a new IOutputData which is the concatenation of this data and the supplied IOutputData.
/// </summary>
/// <param name="o">Data to concatenate</param>
/// <returns>A new IOuputData instance which is the concatenation {this,o}</returns>
/// <exception cref="ExistingConfigurationException">If either this or o has an existing device configuration</exception>
public IOutputData Concat(IOutputData o)
{
if (this.Configuration.Count() > 0 || o.Configuration.Count() > 0)
{
throw new ArgumentException("Cannot concatenate OutputData with existing node configurations.");
}
if (!this.SampleRate.Equals(o.SampleRate))
{
throw new ArgumentException("Sample rate mismatch");
}
return(new OutputData(this.Data.Concat(o.Data).ToList(), this.SampleRate, this.IsLast || o.IsLast));
}
public bool Assign(IOutputData outputData)
{
if (outputData is TimeClip otherTimeClip)
{
_timeRange = otherTimeClip.TimeRange;
_sourceRange = otherTimeClip.SourceRange;
LayerIndex = otherTimeClip.LayerIndex;
return(true);
}
Log.Error($"Trying to assign output data of type '{outputData.GetType()}' to 'TimeClip'.");
return(false);
}
public override IOutputData PullOutputData(IDAQOutputStream stream, TimeSpan duration)
{
/*
* IOuputData will be directed to a device (not an DAQStream) by the controller.
* Controller should get mapping (device=>data) from the current Epoch instance.
*
* Thus the standard PullOuputData will pull from the controller's queue for this
* device.
*/
//TODO should raise exception if duration is less than one sample
IOutputData data = this.Controller.PullOutputData(this, duration); //TODO
return(new OutputData(data,
data.DataWithUnits(MeasurementConversionTarget).Data).DataWithExternalDeviceConfiguration(Configuration));
}
public override IEnumerable <IOutputData> DataBlocks(TimeSpan blockDuration)
{
IOutputData current = BlockDelegate(Parameters, blockDuration);
while (current != null)
{
if (current.Data.BaseUnits() != Units)
{
throw new StimulusException("Data units do not match stimulus units");
}
yield return(current);
current = BlockDelegate(Parameters, blockDuration);
}
}
public void LastDataIsLast()
{
var parameters = new Dictionary <string, object>();
var sampleRate = new Measurement(1000, "Hz");
IOutputData data = new OutputData(Enumerable.Range(0, 1000).Select(i => new Measurement(i, "units")).ToList(),
sampleRate,
false);
var s = new RenderedStimulus((string)"RenderedStimulus", (IDictionary <string, object>)parameters, data);
var block = TimeSpan.FromMilliseconds(100);
IEnumerator <IOutputData> iter = s.DataBlocks(block).GetEnumerator();
IOutputData current = null;
while (iter.MoveNext())
{
current = iter.Current;
}
Assert.That(current.IsLast, Is.True);
}
private void GeneratePdfInternal(IInputData[] inputFiles, IOutputData output, string coverHtml, RocketPDFParameterManager parameterManager)
{
TempFileManager tempFileManager = new TempFileManager(tempFilesDirectory: TempFilesDirectory, filePrefix: "pdf-temp-");
OutputFileProvider outputFileProvider = new OutputFileProvider(tempFileManager);
var outputPdfFilePath = output.Accept(outputFileProvider).OutputFile;
ResultProvider resultProvider = new ResultProvider(outputPdfFilePath);
var parameters = parameterManager.GetParameters();
var pdfParametersInternal = GenerateInternalParameters(inputFiles, outputPdfFilePath, coverHtml, parameters, tempFileManager);
try
{
if (_batchMode)
{
InvokeWkHtmlToPdfInInBatch(parameters, pdfParametersInternal);
}
else
{
InvokeWkHtmlToPdf(parameters, pdfParametersInternal);
}
output.Accept(resultProvider);
}
catch (Exception ex)
{
if (!_batchMode)
{
_processHelper.EnsureWkHtmlProcessStopped();
}
throw new Exception("Can't generate PDF: " + ex.Message, ex);
}
finally
{
tempFileManager.DeleteTempFiles();
}
}
/// <summary>
/// Pulls output data from the given device of the given duration.
/// <para>If the given device has an associated Stimulus in this.Stimuli,
/// the data is pulled from that Stimulus. If there is no associated Stimulus,
/// data is generated according to this.Background[dev].</para>
/// </summary>
/// <param name="dev">Output device requesting data</param>
/// <param name="blockDuration">Requested duration of the IOutputData</param>
/// <returns>IOutputData intsance with duration less than or equal to blockDuration</returns>
public IOutputData PullOutputData(IExternalDevice dev, TimeSpan blockDuration)
{
if (Stimuli.ContainsKey(dev))
{
var blockIter = StimulusDataEnumerators.GetOrAdd(dev,
(d) => Stimuli[d].DataBlocks(blockDuration).GetEnumerator()
);
IOutputData stimData = null;
while (stimData == null || stimData.Duration < blockDuration)
{
if (!blockIter.MoveNext())
{
break;
}
stimData =
stimData == null ? blockIter.Current : stimData.Concat(blockIter.Current);
}
if (stimData == null)
{
return(BackgroundDataForDevice(dev, blockDuration));
}
if (stimData.Duration < blockDuration)
{
var remainingDuration = blockDuration - stimData.Duration;
stimData = stimData.Concat(BackgroundDataForDevice(dev, remainingDuration));
}
return(stimData);
}
log.DebugFormat("Will send background for device {0} ({1})", dev.Name, blockDuration);
return(BackgroundDataForDevice(dev, blockDuration));
}
public void InputDataConversionViaProc()
{
IDictionary <string, object> config = new Dictionary <string, object>(2);
config["param1"] = 10;
config["param2"] = 1;
IMeasurement srate = new Measurement(1000, "Hz");
IOutputData outData = new OutputData(this.Data,
srate, false)
.DataWithExternalDeviceConfiguration(devFake, new Dictionary <string, object>())
.DataWithStreamConfiguration(streamFake, new Dictionary <string, object>());
outData.OutputTime = DateTimeOffset.Now;
Converters.Clear();
ConvertProc fooConversion = (m) => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo");
Converters.Register("V", "foo", fooConversion);
IOutputData expected = new OutputData(outData,
outData.Data.Select(m => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo")).ToList())
{
OutputTime = outData.OutputTime
};
IOutputData actual = outData.DataWithConversion((m) => new Measurement(m.QuantityInBaseUnit * 10, 1, "foo"));
Assert.AreEqual(expected.Data, actual.Data);
Assert.AreEqual(expected.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME),
actual.NodeConfigurationWithName(IOData.EXTERNAL_DEVICE_CONFIGURATION_NAME));
Assert.AreEqual(expected.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME),
actual.NodeConfigurationWithName(IOData.STREAM_CONFIGURATION_NAME));
Assert.AreEqual(expected.OutputTime, actual.OutputTime);
}
/// <summary>
/// This default constructor will not output results anywhere. Use this for testing
/// </summary>
public Runner()
{
_outputData = new NoOutput();
}
private void SetupInputPipeline(IDAQController c, out IOutputData expectedOutput, out DAQOutputStream outStream, out DAQInputStream inStream)
{
SetupOutputPipeline(c, out expectedOutput, out outStream);
inStream = new DAQInputStream("IN");
inStream.SampleRate = outStream.SampleRate;
outStream.Device.BindStream(inStream);
inStream.MeasurementConversionTarget = outStream.MeasurementConversionTarget;
}
public OutputData(IOutputData baseData, bool isLast)
: this(baseData)
{
IsLast = isLast;
}
public void SetOutputData(IOutputData data)
{
TimeClip = data as TimeClip;
TimeClip.Id = Parent.SymbolChildId;
}
void PreloadData(IHekaDevice device, IOutputData data)
{
var inputUnits = (ChannelType == StreamType.DO_PORT || ChannelType == StreamType.XO)
? Measurement.UNITLESS : "V";
var sampleData = data.DataWithUnits(inputUnits).DataWithUnits(DAQCountUnits);
var samples = sampleData.Data.Select(m => (short)m.Quantity).ToList();
device.PreloadSamples(ChannelType, ChannelNumber, samples);
}
public void Preload(IHekaDevice device, IOutputData data)
{
PreloadData(device, data);
}
public void SetUp()
{
const int srate = 1000;
IList<IMeasurement> list = Enumerable.Range(0, srate * 2).Select(i => new Measurement(i, "V") as IMeasurement).ToList();
var data = new OutputData(list, new Measurement(srate, "Hz"));
var stim1 = new RenderedStimulus("stim1", new Dictionary<string, object>(), data);
stream1 = new StimulusOutputDataStream(stim1, TimeSpan.FromSeconds(0.1));
var stim2 = new RenderedStimulus("stim2", new Dictionary<string, object>(), data);
stream2 = new StimulusOutputDataStream(stim2, TimeSpan.FromSeconds(0.1));
seqData = data.Concat(data);
seqStream = new SequenceOutputDataStream();
seqStream.Add(stream1);
seqStream.Add(stream2);
}
/// <summary>
/// Constructs a new RenderedStimulus instance with duration equal to the specified stimulus data.
/// </summary>
/// <param name="stimulusID">Stimulus plugin ID</param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="data">Pre-rendered stimulus data</param>
public RenderedStimulus(string stimulusID, IDictionary<string, object> parameters, IOutputData data)
: this(stimulusID, parameters, data, Option<TimeSpan>.Some(data.Duration))
{
}
private void addOutput(IOutputData o)
{
outputs.Add(o.name, o);
}
/// <summary>
/// You can implement IOutputData to write data to any stream you want
/// and in any format you like
/// </summary>
/// <param name="outputData"></param>
public Runner(IOutputData outputData)
{
this._outputData = outputData;
}
private void SetupOutputPipeline(IDAQController c, out IOutputData expectedOutput, out DAQOutputStream outStream)
{
string units = "V";
var data = Enumerable.Range(0, 1000).Select(i => new Measurement(i, units)).ToList();
var sampleRate = new Measurement(100, "Hz");
var config = new Dictionary<string, object>();
expectedOutput = new OutputData(data,
sampleRate, true);
outStream = new DAQOutputStream("OUT");
outStream.SampleRate = sampleRate;
outStream.MeasurementConversionTarget = units;
(c as IMutableDAQController).AddStream(outStream);
var outQueue = new Dictionary<IDAQOutputStream, Queue<IOutputData>>();
outQueue[outStream] = new Queue<IOutputData>();
outQueue[outStream].Enqueue(expectedOutput);
TestDevice dev = new TestDevice("OUT-DEVICE", outQueue);
dev.BindStream(outStream);
dev.MeasurementConversionTarget = units;
}
public void Preload(IHekaDevice device, IOutputData data)
{
PreloadData(device, data);
}
protected OutputData(IOutputData data,
IPipelineNodeConfiguration config)
: base(data, config)
{
IsLast = data.IsLast;
}
/// <summary>
/// Constructs a new RenderedStimulus instance.
/// </summary>
/// <param name="stimulusID">Stimulus plugin ID</param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="data">Pre-rendered stimulus data</param>
/// <exception cref="MeasurementIncompatibilityException">If data measurements do not have homogenous BaseUnits</exception>
public RenderedStimulus(string stimulusID, IDictionary<string, object> parameters, IOutputData data)
: base(stimulusID, data.Data.BaseUnits(), parameters)
{
if (data == null)
{
throw new ArgumentException("Data may not be null", "data");
}
if (parameters == null)
{
throw new ArgumentException("Parameters may not be null", "Parameters");
}
Data = data;
}
public OutputData(IOutputData baseData)
: base(baseData)
{
}
public IOutputData PullOutputData(TimeSpan duration)
{
if (IsAtEnd)
throw new InvalidOperationException("Pulling from a stream that has ended");
var data = UnusedData;
while (data == null || data.Duration < duration)
{
if (!StimulusDataEnumerator.MoveNext())
break;
var current = StimulusDataEnumerator.Current;
data = data == null ? current : data.Concat(current);
}
if (data == null)
throw new StimulusException("Failed to enumerate stimulus: " + Stimulus.StimulusID);
var cons = data.SplitData(duration);
UnusedData = cons.Rest;
Position += cons.Head.Duration;
return cons.Head;
}
/// <summary>
/// Constructs a new RenderedStimulus instance.
/// </summary>
/// <param name="stimulusID">Stimulus plugin ID</param>
/// <param name="parameters">Stimulus parameters</param>
/// <param name="data">Pre-rendered stimulus data</param>
/// <param name="duration">Duration of stimulus, clipping and/or repeating data as necessary</param>
/// <exception cref="MeasurementIncompatibilityException">If data measurements do not have homogenous BaseUnits</exception>
public RenderedStimulus(string stimulusID, IDictionary<string, object> parameters, IOutputData data, Option<TimeSpan> duration)
: base(stimulusID, data.Data.BaseUnits(), parameters)
{
if (data == null)
throw new ArgumentException("Data may not be null", "data");
if (parameters == null)
throw new ArgumentException("Parameters may not be null", "parameters");
if (duration == null)
throw new ArgumentException("Duration may not be null", "duration");
_data = data;
_duration = duration;
ShouldDataBePersisted = false;
}
public Output(Symbol.OutputDefinition outputDefinition, IOutputData outputData)
{
OutputDefinition = outputDefinition;
OutputData = outputData;
}
