internal AlgorithmParameters(SignalFixerAlgorithmTypes algorithmType, DigitzerParameters digitizerParams ,IExperimentData experimentData, FixBasedOnTypes signalToFix, FixScopeTypes fixType, int iterationToRun, double maxErrorToFixFrom, bool rescaleAfterSmoothing,
int startFixIndex, int fixEveryNSample, int savitzkyGolayFilterOrder, int savitzkyGolayFilterLength, int constantPhaseAdjustmnet, bool useDerivativeFix, double epsilonFactor)
{
AlgorithmType = algorithmType;
DigitzerParams = digitizerParams;
SeedExperiment = experimentData;
SignalToFix = signalToFix;
FixType = fixType;
IterationToRun = iterationToRun;
MaxErrorToFixFrom = maxErrorToFixFrom;
RescaleAfterSmoothing = rescaleAfterSmoothing;
StartFixIndex = startFixIndex;
FixEveryNSample = fixEveryNSample;
ConstantPhaseAdjustment = constantPhaseAdjustmnet;
UseDerivativeFix = useDerivativeFix;
EpsilonFactor = epsilonFactor;
SavitzkyGolayFilterOrder = savitzkyGolayFilterOrder;
SavitzkyGolayFilterLength = savitzkyGolayFilterLength;
//make sure filter length is larger than polynom order.
if (SavitzkyGolayFilterLength < SavitzkyGolayFilterOrder)
{
SavitzkyGolayFilterLength = SavitzkyGolayFilterOrder + 3;
}
//make sure the filter length is odd.
if (SavitzkyGolayFilterLength % 2 == 0)
{
SavitzkyGolayFilterLength += 1;
}
}
public override void FixSignalIteration(IExperimentData experimentData, out double[] fixedSignalGeneratorInput, out bool fixDone)
{
base.FixSignalIteration(experimentData, out fixedSignalGeneratorInput, out fixDone);
double[] signalGeneraorData = experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray();
for (int i = 0; i < PeriodLength; i++)
{
int diIndex = i;
int diNextInedex = i + 1;
if (diNextInedex == PeriodLength)
{
diNextInedex = 0;
}
double di = signalGeneraorData[diNextInedex] - signalGeneraorData[diIndex];
double signalAmp = IterationsData[CurrentIterationIndex].SignalsAmplitude[Experiments.SignalTypes.PhotodiodeOutput];
double actualError = IterationsData[CurrentIterationIndex].OutputError[i] * signalAmp;
double dfdi = 1 + (Math.PI * Math.Sin(2 * i * Math.PI / PeriodLength) / PeriodLength);
IterationsData[CurrentIterationIndex].FixValue[i] = di * actualError / dfdi;
IterationsData[CurrentIterationIndex].FixValue[i] /= 200;
if (actualError <= 40)
IterationsData[CurrentIterationIndex].FixValue[i] = 0;
}
base.CalculateFixedSignal(out fixedSignalGeneratorInput);
//MatlabFigure dbgFixValues = new MatlabFigure("First order fix values", IterationsData[CurrentIteration].FixValue);
///dbgFixValues.Show();
}
public ERROR_CODES AddNewExperiment(ExperimentInitialSettings experimentSettings, out IExperimentData newExperiment, string fileName)
{
ERROR_CODES status = ERROR_CODES.AA_OK;
DialogResult dlgRes = DialogResult.OK;
newExperiment = null;
if (string.IsNullOrEmpty(fileName))
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.Filter = "Text File|*.txt";
dlg.Title = "Select signal generator input file.";
dlg.Multiselect = false;
dlgRes = dlg.ShowDialog();
if (dlgRes == DialogResult.OK)
{
fileName = dlg.FileName;
}
}
//DialogResult dlgRes = DialogResult.OK;
if (dlgRes == DialogResult.OK)
{
string[] sgInput = System.IO.File.ReadAllLines(fileName);
double[] signalGeneratorInput = sgInput.Select(x => double.Parse(x)).ToArray();
status = AddNewExperiment(experimentSettings, out newExperiment, signalGeneratorInput);
}
return status;
}
public ManualFrequencyAlgorithparameters(SignalFixerAlgorithmTypes algorithmType, DigitzerParameters digitizerParams, IExperimentData experimentData, FixBasedOnTypes signalToFix, FixScopeTypes fixType, int iterationToRun,
int harmonyToFix, double fixStart, double fixDelta, ManualFrequencyModType frequencyModType, double maxErrorToFixFrom, bool rescaleAfterSmoothing, int fixFromSample, int fixEveryNSample, int savitzkyGolayPolyOrder, int savitzkyGolayFilterLength, int constantPhaseAdjustment, bool useDerivativeFix, double epsilonFactor)
: base(algorithmType, digitizerParams, experimentData, signalToFix, fixType, iterationToRun, maxErrorToFixFrom, rescaleAfterSmoothing, fixFromSample, fixEveryNSample, savitzkyGolayPolyOrder, savitzkyGolayFilterLength, constantPhaseAdjustment, useDerivativeFix, epsilonFactor)
{
InitialInput = experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray();
HarmonyToFix = harmonyToFix;
FrequencyModeType = frequencyModType;
StartFix = fixStart;
DeltaFix = fixDelta;
}
public SignalFixerIterationData(IExperimentData experimentData, int periodLength)
{
SignalsData = new Dictionary<SignalTypes, double[]>();
NormalizedData = new Dictionary<SignalTypes, double[]>();
SignalsAmplitude = new Dictionary<SignalTypes, double>();
OutputError = new double[periodLength];
FixValue = new double[periodLength];
FixedInput = new double[periodLength];
ExperimentData = experimentData;
}
public ERROR_CODES AddNewExperiment(ExperimentInitialSettings experimentSettings, out IExperimentData newExperiment, double[] signalGeneratorInput)
{
ERROR_CODES status = ERROR_CODES.AA_OK;
status = applicationController.AddNewExperiment(signalGeneratorInput, experimentSettings, out newExperiment);
//status = applicationController.AddNewExperiment(@"C:\Users\User\Documents\Dror\AOM measurements\PID control\ptMove200.txt", experimentSettings, out newExperiment);
if (status == ERROR_CODES.AA_OK)
{
managedForm.AddNewExperimentData(newExperiment);
}
return status;
}
public ERROR_CODES AddNewExperiment(double[] signalGeneratorOutputData, ExperimentInitialSettings initialSettings, out IExperimentData newExperiment)
{
ERROR_CODES status = ERROR_CODES.AA_OK;
newExperiment = null;
try
{
newExperiment = new ExperimentData(signalGeneratorOutputData, initialSettings);
try
{
if (initialSettings.UseRunningInsturmentSettings)
{
try
{
UpdateSignalGeneratorDataFromInstrument(newExperiment.SignalGeneratorData);
}
catch (Exception ex)
{
string s = ex.Message;
}
}
else
{
newExperiment.SignalGeneratorData.HighVoltage = initialSettings.SignalGeneratorHighVoltage;
newExperiment.SignalGeneratorData.LowVoltage = initialSettings.SignalGeneratorLowVoltage;
newExperiment.SignalGeneratorData.OutputFrequency = initialSettings.SignalGeneratorFrequencyOutput;
}
//set scope buffer size by points in cycle, so buffer size is a multiple of cycle point count.
int maxPointInBuffer = Scope.MaxBufferSize;
int bufferSizeToUse = (maxPointInBuffer / newExperiment.PointsInCycle);
bufferSizeToUse *= newExperiment.PointsInCycle;
newExperiment.ScopeData.PointsToSave = bufferSizeToUse * newExperiment.InitialSettings.BuffersToRead;
Scope.BufferSize = bufferSizeToUse;
Scope.PointsInCycle = newExperiment.PointsInCycle;
Scope.SampleRate = newExperiment.InitialSettings.SampleRate;
newExperiment.ScopeData.SampleRate = Scope.SampleRateInHz;
RunExperiment(newExperiment);
experiments.Add(newExperiment.ID, newExperiment);
}
catch { status = ERROR_CODES.INSTRUMENT_READ_WRITE_FAIL; }
}
catch { status = ERROR_CODES.INVALID_SIGNAL_GENERATOR_INPUT_FILE; }
return status;
}
public override void FixSignalIteration(IExperimentData experimentData, out double[] fixedSignalGeneratorInput, out bool fixDone)
{
base.FixSignalIteration(experimentData, out fixedSignalGeneratorInput, out fixDone);
if (CurrentIterationIndex == AlgorithmParams.ValuesToCheck.Length - 1)
{
CalcIntersectPoint();
}
if (CurrentIterationIndex == AlgorithmParams.ValuesToCheck.Length)
{
fixDone = true;
}
if (!fixDone)
{
DistortSignal();
}
this.CalculateFixedSignal(out fixedSignalGeneratorInput);
}
public HighFrequencyDistortionAlgorithmParameters(SignalFixerAlgorithmTypes algorithmType, DigitzerParameters digitizerParams, IExperimentData experimentData, FixBasedOnTypes signalToFix, FixScopeTypes fixType,
int iterationToRun, double maxErrorToFixFrom, bool rescaleAfterSmoothing, int fixFromSample, int fixEveryNSample, int savitzkyGolayPolyOrder, int savitzkyGolayFilterLength, int harmonyToFix, int fftScalingFactor, double midPoint, double range, FrequencyDomainDisttortionType distortionType, int pointsToCheck, int constantPhaseAdjustment, bool useDerivativeFix, double epsilonFactor)
: base(algorithmType, digitizerParams, experimentData, signalToFix, fixType, iterationToRun, maxErrorToFixFrom, rescaleAfterSmoothing, fixFromSample, fixEveryNSample, savitzkyGolayPolyOrder, savitzkyGolayFilterLength, constantPhaseAdjustment, useDerivativeFix, epsilonFactor)
{
HarmonyToFix = harmonyToFix;
FFTScalingFactor = fftScalingFactor;
MidPoint = midPoint;
Range = range;
DistortionType = distortionType;
PointsToCheck = pointsToCheck;
ValuesToCheck = new Complex[5];
ValuesToCheck[0] = new Complex(MidPoint - Range, 0);
ValuesToCheck[1] = new Complex(MidPoint - (Range)*2/3, 0);
ValuesToCheck[2] = new Complex(MidPoint + (Range) * 2 / 3, 0);
ValuesToCheck[3] = new Complex(MidPoint + Range, 0);
/*ValuesToCheck = new Complex[13];
double start = midPoint - range;
double delta = range / 6;
for (double i = 0; i < 13; i++)
{
ValuesToCheck[(int)i] = start + delta * i;
}*/
}
public override ISignalFixerIterationData GetNewIteration(IExperimentData experimentData)
{
return new HighFrequencyDistortionIterationData(experimentData, PeriodLength);
}
protected override void CompareNewIterationData(IExperimentData experimentData)
{
double currentR;
int harmonyIdx;
if (AlgorithmParams.HarmonyToFix > 7)
{
harmonyIdx = 7;
}
else
{
harmonyIdx = AlgorithmParams.HarmonyToFix - 1;
}
currentR = experimentData.DemodulatorsData[harmonyIdx].R.Mean;
InternalIterationData[CurrentIterationIndex].HarmonicValue = currentR;
if (CurrentIterationIndex == 0)
{
InternalIterationData[CurrentIterationIndex].ScaleValue = AlgorithmParams.MidPoint;
BestIterationIndex = 0;
return;
}
else
{
InternalIterationData[CurrentIterationIndex].ScaleValue = AlgorithmParams.ValuesToCheck[CurrentIterationIndex - 1].Real;
}
//this.IterationsData[CurrentIterationIndex].Sc
double bestR;
double currentMaxR, bestMaxR;
currentR = experimentData.DemodulatorsData[harmonyIdx].R.Mean ;
bestR = IterationsData[BestIterationIndex].ExperimentData.DemodulatorsData[harmonyIdx].R.Mean;
currentMaxR = experimentData.MaximumHarmonic.vRMS;
bestMaxR = IterationsData[BestIterationIndex].ExperimentData.MaximumHarmonic.vRMS;
if (currentR < bestR)
{
if (currentMaxR < bestMaxR * 1.2)
{
BestIterationIndex = CurrentIterationIndex;
}
}
}
public PIDAlgorithmParamters(SignalFixerAlgorithmTypes algorithmType, DigitzerParameters digitizerParams, IExperimentData experimentData, FixBasedOnTypes signalToFix, FixScopeTypes fixType,
int iterationToRun, double pFactor, double iFactor, double dFactor, double maxErrorToFixFrom, bool rescaleAfterSmoothing, int fixFromSample, int fixEveryNSample, int savitzkyGolayPolyOrder, int savitzkyGolayFilterLength, int constantPhaseAdjustment, bool useDerivativeFix, double epsilonFactor)
: base(algorithmType, digitizerParams, experimentData, signalToFix, fixType, iterationToRun, maxErrorToFixFrom, rescaleAfterSmoothing, fixFromSample, fixEveryNSample, savitzkyGolayPolyOrder, savitzkyGolayFilterLength, constantPhaseAdjustment, useDerivativeFix, epsilonFactor)
{
PFactor = pFactor; IFactor = iFactor; DFactor = dFactor;
}
public ScanDataEventArgs(IExperimentData data, string experimentName, bool updatedData)
{
this.data = data;
this.experimentName = experimentName;
this.updatedData = updatedData;
}
protected virtual void CompareNewIterationData(IExperimentData experimentData)
{
}
public override void FixSignalIteration(IExperimentData experimentData, out double[] fixedSignalGeneratorInput, out bool fixDone)
{
fixedSignalGeneratorInput = null;
Complex lowerBound, upperBound;
int currentHarmonicIndex;
base.FixSignalIteration(experimentData, out fixedSignalGeneratorInput, out fixDone);
switch (this.RunTimeState.IterationState)
{
case FrequencyDomainIterationState.Init:
RunTimeState.InitNewIterationRun(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray());
RunTimeState.CurrentHarmonic = experimentData.MaximumHarmonic.Order;
RunTimeState.IterationState = FrequencyDomainIterationState.FixingScale;
upperBound = 1.3;
lowerBound = 0.7;
UpdateTrinarySearchBound(lowerBound, upperBound);
RunTimeState.SearchStage = TrinarySearchStage.LowerBound;
RunTimeState.AddNewvRMSIterationData(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray(), experimentData.DemodulatorsData, experimentData.MaximumHarmonic, 1);
FixInput(out fixedSignalGeneratorInput);
break;
case FrequencyDomainIterationState.FixingScaleDone:
RunTimeState.IterationState = FrequencyDomainIterationState.FixingPhase;
RunTimeState.SearchStage = TrinarySearchStage.LowerBound;
this.RunTimeState.SaveScaleValues(true);
this.RunTimeState.InitNewIterationRun(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray());
lowerBound = -0.1;
upperBound = 0.1;
UpdateTrinarySearchBound(lowerBound, upperBound);
FixInput(out fixedSignalGeneratorInput);
RunTimeState.AddNewvRMSIterationData(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray(), experimentData.DemodulatorsData, experimentData.MaximumHarmonic, 0);
break;
case FrequencyDomainIterationState.Idle:
/*double maxHarmonicError = experimentData.MaximumHarmonic.vRMS;
if (maxHarmonicError > AlgorithmParams.MaxHarmonicError)
{
this.RunTimeState.IterationState = FrequencyDomainIterationState.FixingScale;
this.RunTimeState.CurrentHarmonic = experimentData.MaximumHarmonic.Order;
this.RunTimeState.InitNewIterationRun(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray());
//base.FixSignalIteration(experimentData, out fixedSignalGeneratorInput);
tmp = (SignalFixerIterationData)IterationsData[0];
tmp.ExperimentData = experimentData;
lowerBound = 0.8;
upperBound = 1.2;
UpdateTrinarySearchBound(lowerBound, upperBound);
RunTimeState.SearchStage = TrinarySearchStage.LowerBound;
RunTimeState.AddNewvRMSIterationData(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray(), experimentData.DemodulatorsData, experimentData.MaximumHarmonic);
FixInput(out fixedSignalGeneratorInput);
}*/
this.IterationsData[CurrentIterationIndex].FixValue = new double[experimentData.SignalGeneratorData.ArbitrarySignalData.Count()];
this.CalculateFixedSignal(out fixedSignalGeneratorInput);
RunTimeState.SaveScaleValues(false);
fixDone = true;
break;
case FrequencyDomainIterationState.FixingScale:
currentHarmonicIndex = RunTimeState.CurrentHarmonic;
RunTimeState.TrinearySearchValues[RunTimeState.SearchStage.GetHashCode()] = experimentData.DemodulatorsData[RunTimeState.CurrentHarmonic - 1].R.Mean;
RunTimeState.AddNewvRMSIterationData(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray(), experimentData.DemodulatorsData, experimentData.MaximumHarmonic, RunTimeState.Bounds[RunTimeState.SearchStage.GetHashCode()].Real);
switch (RunTimeState.SearchStage)
{
case TrinarySearchStage.LowerBound:
//RunTimeState.IterationData[CurrentIteration].
RunTimeState.SearchStage = TrinarySearchStage.UppderBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.UppderBound:
RunTimeState.SearchStage = TrinarySearchStage.ThirdBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.ThirdBound:
RunTimeState.SearchStage = TrinarySearchStage.TwoThirdBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.TwoThirdBound:
RunTimeState.SearchStage = TrinarySearchStage.ThirdBound;
CalculateNewBounds();
Complex newLower = RunTimeState.Bounds[TrinarySearchStage.LowerBound.GetHashCode()];
Complex newUpper = RunTimeState.Bounds[TrinarySearchStage.UppderBound.GetHashCode()];
int iterationCount = RunTimeState.IterationData.Count();
double preR = RunTimeState.IterationData[iterationCount - 2].vRMSData[currentHarmonicIndex - 1];
double currR = RunTimeState.IterationData[iterationCount - 1].vRMSData[currentHarmonicIndex - 1];
double dR = Math.Abs(preR - currR);
double deltaUL = newLower.Real - newUpper.Real;
if ((Math.Abs(newLower.Real - newUpper.Real) <= 5e-3))
//if ((Math.Abs(newLower.Real - newUpper.Real) <= ConvergenceLimit) )
{
fixedSignalGeneratorInput = RunTimeState.BestIterationSoFar.InputSingal;
RunTimeState.IterationState = FrequencyDomainIterationState.FixingScaleDone;
}
else
{
FixInput(out fixedSignalGeneratorInput);
}
break;
}
break;
case FrequencyDomainIterationState.FixingPhase:
currentHarmonicIndex = RunTimeState.CurrentHarmonic;
RunTimeState.AddNewvRMSIterationData(experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray(), experimentData.DemodulatorsData, experimentData.MaximumHarmonic, RunTimeState.Bounds[RunTimeState.SearchStage.GetHashCode()].Real);
RunTimeState.TrinearySearchValues[RunTimeState.SearchStage.GetHashCode()] = experimentData.DemodulatorsData[RunTimeState.CurrentHarmonic - 1].R.Mean;
switch (RunTimeState.SearchStage)
{
case TrinarySearchStage.LowerBound:
RunTimeState.SearchStage = TrinarySearchStage.UppderBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.UppderBound:
RunTimeState.SearchStage = TrinarySearchStage.ThirdBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.ThirdBound:
RunTimeState.SearchStage = TrinarySearchStage.TwoThirdBound;
FixInput(out fixedSignalGeneratorInput);
break;
case TrinarySearchStage.TwoThirdBound:
RunTimeState.SearchStage = TrinarySearchStage.ThirdBound;
CalculateNewBounds();
Complex newLower = RunTimeState.Bounds[TrinarySearchStage.LowerBound.GetHashCode()];
Complex newUpper = RunTimeState.Bounds[TrinarySearchStage.UppderBound.GetHashCode()];
int iterationCount = RunTimeState.IterationData.Count();
double preR = RunTimeState.IterationData[iterationCount - 2].vRMSData[currentHarmonicIndex - 1];
double currR = RunTimeState.IterationData[iterationCount - 1].vRMSData[currentHarmonicIndex - 1];
double dR = Math.Abs(preR - currR);
double dRange = Math.Abs(newLower.Real - newUpper.Real);
if (Math.Abs(newLower.Real - newUpper.Real) <= 1e-3)
{
fixedSignalGeneratorInput = RunTimeState.BestIterationSoFar.InputSingal;
IterationsData[CurrentIterationIndex].FixedInput = fixedSignalGeneratorInput;
RunTimeState.IterationState = FrequencyDomainIterationState.Idle;
RunTimeState.SaveScaleValues(false);
fixDone = true;
}
else
{
FixInput(out fixedSignalGeneratorInput);
}
break;
}
break;
}
}
public virtual void FixSignalIteration(IExperimentData experimentData, out double[] fixedSignalGeneratorInput, out bool fixDone)
{
CurrentIterationIndex++;
fixDone = false;
ISignalFixerIterationData iter = GetNewIteration(experimentData);
IterationsData[CurrentIterationIndex] = iter;
iter.SignalsData.Add(SignalTypes.SignalGeneratorOutput, experimentData.SignalGeneratorData.ArbitrarySignalData.ToArray());
iter.SignalsData.Add(SignalTypes.PhotodiodeOutput, experimentData.GetScopeDataBySignalType(Experiments.SignalTypes.PhotodiodeOutput).SignalSamples.ToArray());
iter.SignalsData.Add(SignalTypes.SignalGeneratorSync, experimentData.GetScopeDataBySignalType(Experiments.SignalTypes.SignalGeneratorSync).SignalSamples.ToArray());
double signalAmplitude = 0;
foreach (SignalTypes index in Enum.GetValues(typeof(SignalTypes)))
{
if (index == SignalTypes.PhotodiodeOutput)
{
double[] noramlizeSignal = SignalDigitizer.NormalizeSignal(iter.SignalsData[index], AlgorithmParams.DigitzerParams, out signalAmplitude).ToArray();
iter.SignalsAmplitude.Add(index, signalAmplitude);
iter.NormalizedData.Add(index, noramlizeSignal);
}
}
iter.OutputPhase = PhaseAnalyzer.FindBinPhaseByShift(iter.NormalizedData[SignalTypes.PhotodiodeOutput], ZeroPhaseOutputReference, PeriodLength, -50, 50, AlgorithmParams.ConstantPhaseAdjustment, false);
iter.NormalizedZeroPhaseOutput = new double[PeriodLength];
double lockingPhase = experimentData.DemodulatorsData[0].Phase.Mean;
int lockingPhaseInBins = (int) Math.Round((lockingPhase / (2 * Math.PI)) * PeriodLength);
//iter.OutputPhase = new PhaseData(12, )
for (int i = 0; i < PeriodLength; i++)
{
int phasedIndex = i + iter.OutputPhase.PhaseInBins % PeriodLength;
//int phasedIndex = (i + lockingPhaseInBins) % PeriodLength;
phasedIndex = (phasedIndex >= PeriodLength) ? phasedIndex - PeriodLength : phasedIndex;
phasedIndex = (phasedIndex < 0) ? phasedIndex + PeriodLength: phasedIndex;
iter.NormalizedZeroPhaseOutput[i] = iter.NormalizedData[SignalTypes.PhotodiodeOutput][phasedIndex];
iter.OutputError[i] = iter.NormalizedZeroPhaseOutput[i] - ZeroPhaseOutputReference[i];
}
//Saver.SaveArrayToFile($"C:\\Pts\\Ref{CurrentIteration}.txt", ZeroPhaseOutputReference);
//Saver.SaveArrayToFile($"C:\\Pts\\UnPhase{CurrentIteration}.txt", iter.NormalizedData[SignalTypes.PhotodiodeOutput]);
//Saver.SaveArrayToFile($"C:\\Pts\\Phased{CurrentIteration}.txt", iter.NormalizedZeroPhaseOutput);
//double signalAmp = iter.SignalsAmplitude[SignalTypes.PhotodiodeOutput];
//MatlabFigure tmp1 = new MatlabFigure();
//tmp1.AddPlot("ref", ZeroPhaseOutputReference, true);
//tmp1.AddPlot("my phase sig", iter.NormalizedZeroPhaseOutput, true);
//tmp1.AddPlot("my non phase sig", iter.NormalizedData[SignalTypes.PhotodiodeOutput], true);
//tmp1.Show();
//debugFigure = new MatlabFigure();
//debugFigure.Text = CurrentIteration.ToString();
//debugFigure.AddPlot("error", iter.OutputError, true);
//debugFigure.Show();
//debugFigure.AddPointY(iter.OutputError[DebugPoint] * signalAmp, string.Format("Error @ {0}", DebugPoint));
//SharedCode.DebugHelper.MatlabFigure tmp = new SharedCode.DebugHelper.MatlabFigure("", iter.NormalizedData[SignalTypes.PhotodiodeOutput]);
//tmp.AddPlot("", iter.NormalizedZeroPhaseOutput, true);
//tmp.AddPlot("", ZeroPhaseOutputReference, true);
//tmp.Show();
CompareNewIterationData(experimentData);
fixedSignalGeneratorInput = null;
}
public virtual ISignalFixerIterationData GetNewIteration(IExperimentData experimentData)
{
return new SignalFixerIterationData(experimentData, PeriodLength);
}
public ExperimentEndedEventArgs(enExperimentStatus status, IExperimentData data)
{
this.status = status;
this.data = data;
}
public ExperimentDataEventArgs(IExperimentData data, bool updatedData)
{
this.data = data;
this.updatedData = updatedData;
}
internal void ChartPhaseMatchedRequest(IExperimentData expData)
{
double[] photodiodeOutput, signalGeneratorOutput, shiftedOutput;
signalGeneratorOutput = expData.GetScopeDataBySignalType(Experiments.SignalTypes.SignalGeneratorOutput).SignalSamples.ToArray();
photodiodeOutput = expData.GetScopeDataBySignalType(Experiments.SignalTypes.PhotodiodeOutput).SignalSamples.ToArray();
int shift = expData.PhaseDifferenceInBins;
int shiftedIdx;
int N = photodiodeOutput.Count();
shiftedOutput = new double[N];
for (int i = 0; i < N; i++)
{
shiftedIdx = i + shift;
shiftedIdx = (shiftedIdx >= N) ? N - shiftedIdx : shiftedIdx;
shiftedIdx = (shiftedIdx < 0) ? N + shiftedIdx : shiftedIdx;
shiftedOutput[shiftedIdx] = photodiodeOutput[i];
}
IList<double[]> signalsToChart = new List<double[]>();
signalsToChart.Add(signalGeneratorOutput);
signalsToChart.Add(shiftedOutput);
managedForm.ChartSignal(signalsToChart);
}
public HighFrequencyDistortionIterationData(IExperimentData experimentData, int periodLength)
: base(experimentData, periodLength)
{
}
public ERROR_CODES RunExperiment(IExperimentData experimentToRun)
{
//alot of constants here that later on need to be parametrized
ERROR_CODES status = ERROR_CODES.AA_OK;
PhaseData phaseData = null;
double scopeSampleRate = 0;
bool[] demodulatorToRead = new bool[LockinAmplifier.NumberOfDemodulators];
for (int i = 0; i < LockinAmplifier.NumberOfDemodulators; i++)
{
demodulatorToRead[i] = true;
}
try
{
status |= SignalGenerator.UpdateOutputState(true);
status |= SignalGenerator.UploadArbitrarySignalData(experimentToRun.SignalGeneratorData.ArbitrarySignalData, false);
//LaserModulation.SignalFixer.Classes.Saver.SaveArrayToFile("C:\\Pts\\bad1.txt", experimentToRun.SignalGeneratorData.ArbitrarySignalData.ToArray());
System.Threading.Thread.Sleep(500);
}
catch (Exception ex)
{
string s = ex.Message;
}
if (status != ERROR_CODES.AA_OK)
{
status = status;
}
status = ERROR_CODES.NOT_CONNECTED_TO_ZI_SERVER;
System.Threading.Thread.Sleep(1000);
IEnumerable<double> signalData;
double tmpAmplitude = 0;
try
{
signalData = null;
foreach (SignalTypes signalType in Enum.GetValues(typeof(SignalTypes)))
{
ScopeInputChannel scopeInChl = experimentToRun.GetScopeChannelByDataType(signalType);
if (signalType == SignalTypes.PhotodiodeOutput)
{
try
{
status = Scope.ReadScopeData(scopeInChl, experimentToRun.ScopeData.PointsToSave, experimentToRun.ScopeData.SampleMode, 512, out signalData);
if (status != ERROR_CODES.AA_OK)
{
status = status;
}
}
catch (Exception ex)
{
string ds = ex.Message;
}
}
else
{
signalData = new double[0];
}
if (status != ERROR_CODES.AA_OK)
{
status = status;
}
switch (signalType)
{
case SignalTypes.PhotodiodeOutput:
double[] expectedOutput = new double[scopeCycleSize];
double[] normalizeSignalData = SignalDigitizer.NormalizeSignal(signalData.ToArray(), new DigitzerParameters(DigitizingMethods.Absolute, 0, 0, 0, false), out tmpAmplitude).ToArray();
expectedOutput = FunctionGenerator.PositivieNormalizeCosine(scopeCycleSize);
try
{
phaseData = PhaseAnalyzer.FindBinPhaseByShift(normalizeSignalData, expectedOutput, scopeCycleSize, -30, 30, 0, false);
}
catch (Exception ex)
{
string s = ex.Message;
}
break;
case SignalTypes.SignalGeneratorOutput:
phaseData = new PhaseData(0,0,0);
if (!workWithLockinScope)
{
double[] normalizeSignalGeneratorOutput = SignalDigitizer.NormalizeSignal(signalData.ToArray(), new DigitzerParameters(DigitizingMethods.Absolute, 0, 0, 0, false), out tmpAmplitude).ToArray();
double[] normalizeExpectedSignalGeneratoroutput = SignalDigitizer.NormalizeSignal(experimentToRun.SignalGeneratorData.ArbitrarySignalData.ToArray(), new DigitzerParameters(DigitizingMethods.Absolute, 0, 0, 0, false), out tmpAmplitude).ToArray();
phaseData = PhaseAnalyzer.FindBinPhaseByShift(normalizeSignalGeneratorOutput, normalizeExpectedSignalGeneratoroutput, scopeCycleSize, -30, 30, 0, false);
}
break;
case SignalTypes.SignalGeneratorSync:
phaseData = null;
break;
}
try
{
SignalData tmp = new SignalData(signalType, signalData.ToArray(), scopeSampleRate, phaseData);
experimentToRun.ScopeData.SavedData.Add(scopeInChl, tmp);
}
catch (Exception ex)
{
String s = ex.Message;
}
}
}
catch (Exception ex)
{
string s = ex.Message;
}
//add here lockin code.
IDemodulatorDataPacket[] lockinData = null;
try
{
LockinAmplifier.GetPolledData(demodulatorToRead, 1000, out lockinData);
experimentToRun.DemodulatorsData = lockinData;
}
catch (Exception ex)
{
string s = ex.Message;
}
try
{
double r1 = experimentToRun.DemodulatorsData[0].R.Mean;
double std1 = experimentToRun.DemodulatorsData[0].R.StandardDeviation;
double r2 = experimentToRun.DemodulatorsData[1].R.Mean;
double std2 = experimentToRun.DemodulatorsData[1].R.StandardDeviation;
//MatlabFigure dbg = new MatlabFigure();
//dbg.AddPlot("R2", experimentToRun.DemodulatorsData[1].RSamples, false);
//dbg.Show();
}
catch (Exception ex)
{
string s = ex.Message;
}
return status;
}
