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