public SignalData(SignalTypes type, IEnumerable<double> samples, double samplingSpeed, PhaseData phaseData)
{
SignalType = type;
SignalSamples = samples;
SampleSpeed = samplingSpeed;
PhaseShiftData = phaseData;
}
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;
}
public ERROR_CODES TestScopeError()
{
ERROR_CODES status = ERROR_CODES.AA_OK;
if (!workWithLockinScope)
{
double dbg1 = 0, dbg2 = 0, dbg3 = 0;
try
{
int iterationsCount = 100;
double scopeSampleRate;
double pi = Math.PI;
double testFrequencyHz = SignalGenerator.OutputFrequency;
Scope.GetSampleRate(out scopeSampleRate);
int binsInPeriod = Convert.ToInt32(scopeSampleRate / testFrequencyHz);
int periodsInScopeData = Convert.ToInt32(scopeSamplesToRead / binsInPeriod);
double[] refSineSignal = new double[binsInPeriod];
for (int i = 0; i < binsInPeriod; i++)
{
refSineSignal[i] = 0.5 * (Math.Sin(2 * pi * i / binsInPeriod) + 1);
}
MatlabFigure tmp = new MatlabFigure("ref", refSineSignal);
tmp.Show();
double[] normalizeBuffer, scopeData;
double[] data = new double[0];
double signalAmp;
PhaseData[] phaseData = new PhaseData[iterationsCount];
double[] phaseValue = new double[iterationsCount];
double[][] iterationData = new double[binsInPeriod][];
double[][] errorData = new double[binsInPeriod][];
int rowsCount = iterationsCount * periodsInScopeData;
for (int i = 0; i < binsInPeriod; i++)
{
iterationData[i] = new double[rowsCount];
errorData[i] = new double[rowsCount];
}
bool showDebugWindow = false;
Scope.SetupScopeRead(ScopeInputChannel.Chl2, scopeSamplesToRead, ScopeSampleMode.Average, 512);
for (int iterationIndex = 0; iterationIndex < iterationsCount; iterationIndex++)
{
//showDebugWindow = ((iterationIndex % 10) == 0) ? true : false;
dbg1 = iterationIndex;
Scope.ReadChannel(out scopeData);
normalizeBuffer = SignalDigitizer.NormalizeSignal(scopeData, new DigitzerParameters(DigitizingMethods.AverageMinMax, 0.005, 0.005, 1, false), out signalAmp).ToArray();
phaseData[iterationIndex] = PhaseAnalyzer.FindBinPhaseByShift(normalizeBuffer, refSineSignal, binsInPeriod, -500, 500, 0, showDebugWindow);
data = data.Concat(scopeData).ToArray();
phaseValue[iterationIndex] = phaseData[iterationIndex].PhaseInBins;
//slice up the scope data the single periods data
for (int j = 0; j < binsInPeriod; j++)
{
dbg2 = j;
for (int k = 0; k < periodsInScopeData; k++)
{
dbg3 = k;
int periodIndex = k + (periodsInScopeData * iterationIndex);
int zeroPhaseIndex = j + k * binsInPeriod + phaseData[iterationIndex].PhaseInBins;
if (zeroPhaseIndex >= scopeSamplesToRead)
{
zeroPhaseIndex = zeroPhaseIndex - scopeSamplesToRead;
}
iterationData[j][periodIndex] = scopeData[zeroPhaseIndex];
errorData[j][periodIndex] = Math.Abs(normalizeBuffer[zeroPhaseIndex] - refSineSignal[j]) * signalAmp;
}
}
}
MatlabFigure debugSignal = new MatlabFigure(string.Format("Scope date over {0} iterations.", iterationsCount), data);
debugSignal.Show();
MatlabFigure debugPhase = new MatlabFigure(string.Format("Scope phase date over {0} iterations.", iterationsCount), phaseValue);
debugPhase.Show();
int totalPeriods = iterationsCount * periodsInScopeData;
double[] stdDevivations = new double[binsInPeriod];
IStatisticalData[] valueVariation = new StatisticalData[binsInPeriod];
IStatisticalData[] errorVariation = new StatisticalData[binsInPeriod];
for (int i = 0; i < binsInPeriod; i++)
{
valueVariation[i] = new StatisticalData(iterationData[i]);
stdDevivations[i] = valueVariation[i].StandardDeviation;
errorVariation[i] = new StatisticalData(errorData[i]);
}
IStatisticalData secondMoment = new StatisticalData(stdDevivations);
MatlabFigure debugValues = new MatlabFigure();
debugValues.AddPlot("Values fluctuation.", valueVariation, false);
debugValues.Show();
MatlabFigure debugStdDeviations = new MatlabFigure("std deviations", stdDevivations);
debugStdDeviations.Show();
MatlabFigure debugErrorVariations = new MatlabFigure();
debugErrorVariations.AddPlot("Error variations", errorVariation, false);
debugErrorVariations.Show();
}
catch (Exception ex)
{
string s = ex.Message;
double z = dbg1;
z = dbg2; z = dbg3;
}
}
return status;
}
/// <summary>Find the phase shift between an input signal and the zero-phase expected signal.
/// The phase shift is found by shifting the reference signal and finding the shift where the difference between
/// the input and the reference is at minimum.</summary>
/// <param name="inputSignal"> Input signal whos phase we want to find</param>
/// <param name="zeroPhasedSignal"> Zero phase reference signal.</param>
/// <param name="binsInPeriod"> The expected preiod of the input signal in bins.</param>
/// <param name="startShift"> The intitial shift to check.</param>
/// <param name=endShift"> The final shift to check.</param>
/// <remarks>The function assume that the zero phase signal start @ a global minimum!
/// Positive shift value shift the shifted signal right (negative value shift to the left).</remarks>
public static PhaseData FindBinPhaseByShift(IEnumerable<double> inputSignal, IEnumerable<double> zeroPhasedSignal, int binsInPeriod, int startShift, int endShift, bool showDebugWindow)
{
try
{
double tmpMin = inputSignal.Min();
double[] tmpSignal = inputSignal.SkipWhile(x => x != tmpMin).ToArray();
int skippedBins = inputSignal.Count() - tmpSignal.Count();
if (skippedBins > (inputSignal.Count() - binsInPeriod))
{
//skippedBins = skippedBins - binsInPeriod;
}
double differenceSum, minDifferenceSum;
int minDifferencePhase = 0;
int phaseShiftIndex = 0;
double[] sig = inputSignal.ToArray();
double[] refSig = zeroPhasedSignal.ToArray();
minDifferenceSum = double.PositiveInfinity;
int shift;
int i;
try
{
for (shift = startShift; shift <= endShift; shift++)
{
differenceSum = 0;
for (i = 0; i < binsInPeriod; i++)
{
phaseShiftIndex = skippedBins + shift + i;
phaseShiftIndex = phaseShiftIndex % inputSignal.Count();
phaseShiftIndex = (phaseShiftIndex < 0) ? phaseShiftIndex + binsInPeriod : phaseShiftIndex;
phaseShiftIndex = (phaseShiftIndex >= binsInPeriod) ? phaseShiftIndex - binsInPeriod : phaseShiftIndex;
differenceSum += Math.Abs(sig[phaseShiftIndex] - refSig[i]);
}
if (differenceSum < minDifferenceSum)
{
minDifferencePhase = shift;
minDifferenceSum = differenceSum;
}
}
}
catch (Exception ex)
{
string s = ex.Message;
}
PhaseData phaseData = new PhaseData((skippedBins + minDifferencePhase), binsInPeriod, minDifferenceSum / binsInPeriod);
int totalPhase = skippedBins + minDifferencePhase;
if (totalPhase < 0)
{
totalPhase += inputSignal.Count();
}
double[] shiftedSig = new double[binsInPeriod];
for (i = 0; i < binsInPeriod; i++)
{
int phaseIdx = (i + totalPhase) % sig.Length;
phaseIdx = (phaseIdx > sig.Length) ? phaseIdx - sig.Length : phaseIdx;
phaseIdx = (phaseIdx < 0) ? phaseIdx + sig.Length : phaseIdx;
if (phaseIdx >= sig.Length)
{
phaseIdx = phaseIdx - sig.Length;
}
shiftedSig[i] = sig[phaseIdx];
}
if (showDebugWindow)
{
SharedCode.DebugHelper.MatlabFigure tmp = new SharedCode.DebugHelper.MatlabFigure("ref", zeroPhasedSignal.ToArray());
tmp.AddPlot("phased", shiftedSig, true);
tmp.Show();
}
return phaseData;
}
catch (Exception ex)
{
string s = ex.Message;
throw new Exception("Find phase fail - " + ex.Message);
}
}