public IEnumerable <Command> Commands(RunningOptions options)
{
int nextRead = 0;
var zero = default(TimeSpan);
TimeSpan eta = TimeSpan.FromSeconds(10);
var sw = new Stopwatch(); // Count the total running time
for (int s = 0; s < Stages; ++s)
{
for (; nextRead < samples.Count; ++nextRead)
{
var freq = samples[nextRead].frequency;
yield return(new Command(new SetFrequency(freq, zero), freq, options.defaultWaveform, options.defaultAmplitude, eta));
double response = 0;
while (response == 0)
{
Exception ex;
try
{
sw.Start();
response = Source.Read();
sw.Stop();
break;
}
catch (Exception e)
{
ex = e;
// !! Problem here: If the HRM throws, we similarly re-throw the exception to the
// caller, thereby preseti
}
yield return(new Command(new ThrowCommand(ex), freq, options.defaultWaveform, options.defaultAmplitude, eta));
}
samples[nextRead].response = response;
int remainingSteps = samples.Count - nextRead;
int doneSteps = nextRead;
if (doneSteps > 0)
{
var timePerStep = sw.Elapsed.TotalMilliseconds / doneSteps;
eta = TimeSpan.FromMilliseconds(timePerStep * remainingSteps);
}
OnProgress(freq, response, s + 1, eta);
}
bool lastStage = s == Stages - 1;
if (!lastStage)
{
AnalyseAndRescan(Threshold, Window);
}
}
OnFinished(Hits(Threshold, 1).ToArray());
}
public void Start(IProgram runnable, IChannel channel, RunningOptions options)
{
this.channel = channel;
runner = new SynchronousRunner();
runner.Start(runnable, options);
source = new CancellationTokenSource();
eta = runnable.Duration(options);
state = RunState.Ready;
runningThread = new Thread(ThreadFn);
runningThread.Start();
}
public double FrequencyAt(double t, RunningOptions options)
{
double f1 = Frequency1.ToHertz(options), f2 = IsSweep ? Frequency2.ToHertz(options) : f1;
double duration = double.IsNaN(Duration) ? options.defaultDuration.TotalSeconds : Duration;
var f = f1 + (f2 - f2) * t / duration;
if (options.frequencyModulation)
{
f += options.fmAmplitudeHz * triangleWave(2.0 * Math.PI * t * options.fmFrequency);
}
return(f);
}
public IEnumerable <Command> Run(IProgram program, RunningOptions options)
{
TimeSpan duration = program.Duration(options);
foreach (var step in Steps(program))
{
duration -= step.Duration(options);
foreach (var cmd in step.Commands(options))
{
var cmd2 = cmd;
cmd2.Remaining += duration;
yield return(cmd2);
}
}
}
double AmplitudeAt(double t, RunningOptions options)
{
var v = this.Amplitude1;
if (double.IsNaN(v))
{
v = options.defaultAmplitude;
}
if (options.amplitideModulation)
{
v += options.amAmplitude * triangleWave(2.0 * Math.PI * t * options.amFrequency);
}
return(v);
}
public IEnumerable <double> Test(RunningOptions options)
{
const double c = 299792.458; // Speed of light
for (int C = -1; C <= 1; ++C)
{
for (int T = -1; T <= 1; ++T)
{
for (int P = -1; P <= 1; ++P)
{
yield return(scale(Math.Pow(options.tissue_factor, T) * Math.Pow(c, C) * Math.Pow(1e9, P)));
}
}
}
}
public IEnumerable <Command> Commands(RunningOptions options)
{
double duration = double.IsNaN(Duration) ? options.defaultDuration.TotalSeconds : Duration;
TimeSpan remaining = TimeSpan.FromSeconds(duration);
Waveform w = Waveform1;
if (w == Waveform.Default)
{
w = options.defaultWaveform;
}
yield return(new Command(new SetWaveform(w), double.NaN, w, double.NaN, remaining));
if (IsSweep || options.isModulated)
{
double f1 = Frequency1.ToHertz(options), f2 = IsSweep ? Frequency2.ToHertz(options) : f1;
double numberOfSteps = duration / stepDuration.TotalSeconds;
for (int i = 0; i < numberOfSteps; ++i)
{
double f = FrequencyAt(i * stepDuration.TotalSeconds, options);
double a = AmplitudeAt(i * stepDuration.TotalSeconds, options);
if (options.amplitideModulation)
{
yield return(new Command(new SetAmplitude(a), f, w, a, remaining));
}
yield return(new Command(new SetFrequency(f, stepDuration), f, w, a, remaining -= stepDuration));
}
}
else
{
double f = Frequency1.ToHertz(options);
double a = AmplitudeAt(0, options);
yield return(new Command(new SetFrequency(f, TimeSpan.FromSeconds(1)), f, w, a, TimeSpan.FromSeconds(duration)));
for (double t = duration - 1; t > 0; t -= 1)
{
yield return(new Command(new Noop(TimeSpan.FromSeconds(1)), f, w, a, TimeSpan.FromSeconds(t)));
}
}
}
public double ToHertz(RunningOptions options)
{
// This seems to be a fairly suspect formula for conerting a "target"
// such as a molecule of a particular mass, into a frequency.
// The ideas is that we can simply scale down the frequency
// using powers of 2 so that we'll find another harmonic that can
// vibrate it.
const double c = 299792.458; // Speed of light
switch (Unit)
{
case FrequencyUnit.Hertz: return(Value);
case FrequencyUnit.BP: return(scale(Value * options.bp_to_hz_factor));
case FrequencyUnit.MW: return(scale(Value * options.mw_to_hz_factor));
case FrequencyUnit.Wavelength: return(scale(Value * options.tissue_factor * 1e9 / c));
default: throw new InvalidDataException();
}
}
public void Start(IProgram program, RunningOptions options)
{
commands = Run(program, options).GetEnumerator();
}
public TimeSpan Duration(RunningOptions options) => TimeSpan.FromHours(1);
public IEnumerable <Command> Commands(RunningOptions options)
{
yield return(new Command(this, Freq, Waveform.Default, double.NaN, Duration));
}
TimeSpan IStep.Duration(RunningOptions options) => Duration;
TimeSpan IStep.Duration(RunningOptions options) => double.IsNaN(Duration) ? options.defaultDuration : TimeSpan.FromSeconds(Duration);
public TimeSpan Duration(RunningOptions options) => steps.Aggregate(default(TimeSpan), (a, b) => a + b.Duration(options));
public TimeSpan Duration(RunningOptions options) => Step.Duration(options);
