private void calculateLmatch_btn_Click(object sender, EventArgs e) { //. Complex ZA = MenialOperations.ComplexFromString(CalculateLMatch_ZA_tb.Text); Complex ZB = MenialOperations.ComplexFromString(CalculateLMatch_ZB_tb.Text); bool isLP = lowpass_rb.Checked; double freq = Convert.ToDouble(CalculateLmatch_frequency_tb.Text); double Zo = Convert.ToDouble(CalculateLMatch_Zo_tb.Text); //Calculate. double L; double C; bool seriesNextToLoad = OnePortNetwork.Lmatch(ZA, ZB, isLP, freq, Zo, out L, out C); //Show. ThreadSafe.SetControlTextThreadSafe_f(this, CalculateLmatch_Output_tb, L.ToString() + " H, " + Environment.NewLine + ((seriesNextToLoad == isLP) ? "Next to ZA, " : "Next to ZB, ") + Environment.NewLine + //Series next to load XOR isLP. (isLP ? "Series, " : "Shunt, ") + Environment.NewLine ); ThreadSafe.SetControlTextThreadSafe_f(this, CalculateLmatch_Output_tb, C.ToString() + " F," + Environment.NewLine + ((seriesNextToLoad != isLP) ? "Next to ZA, " : "Next to ZB, ") + Environment.NewLine + //Series next to load XNOR isLP. (!isLP ? "Series, " : "Shunt, ") ); //Draw ind and cap connected on screen. }
/// <summary> /// Calculates response of Hartley oscillator with respect to change in varactor reverse bias voltage. /// </summary> /// <param name="C_3A">Capacitance that sits ON EITHER SIDE of varactor Cj.</param> /// <param name="C_3B">Capacitance that sits in parallel with C_3A - Cj - C_3A series combination.</param> /// <returns></returns> static XY CalcHartleyVoltageResponse(double C_3A, double C_3B) { XY Cj = ImportData.ReadCSVtoXY(ImportData.OutputDataPath); XY freq = new XY(Cj.x); XY C3 = new XY(Cj.x); //This block of variables is necessary for initializing inductance. //Inductance is initialized to resonate with first-calculated C3 value at 49.5 MHz. double L1; double L2; double omega0 = 2 * Math.PI * 49.5 * Math.Pow(10, 6); //Frequency I want for voltage == 0.0. double beta = 80.0; for (int n = 0; n < freq.N; n++) { C3.y[n] = C_3B + MenialOperations.Parallel(0.5 * C_3A, Cj.y[n]); Hartley_CwBtoL(C3.y[0], omega0, beta, out L1, out L2); freq.y[n] = Math.Pow(C3.y[n] * (L1 + L2), -0.50) / (2.0 * Math.PI); //Debug.WriteLine("Run " + n + ": " + C3.y[n] + " " + L1 + " " + L2 + " " + freq.y[n]); } ExportData.WriteXYtoCSV("C:\\Users\\Mehdy Faik\\Desktop\\Work\\Work\\Side Hustles\\Microwave\\Microwave\\Microwave\\Data\\hartley.csv", freq); return(freq); }
private void calculateZs_btn_Click(object sender, EventArgs e) { //Parse inputs. Complex V_A1 = MenialOperations.ComplexFromString(Va1_tb.Text); Complex Z_L1 = MenialOperations.ComplexFromString(Rl1_tb.Text); Complex V_A2 = MenialOperations.ComplexFromString(Va2_tb.Text); Complex Z_L2 = MenialOperations.ComplexFromString(Rl2_tb.Text); MessageBox.Show(V_A1.ToString()); MessageBox.Show(Z_L1.ToString()); MessageBox.Show(V_A2.ToString()); MessageBox.Show(Z_L2.ToString()); Double freq; Double.TryParse(frequency_tb.Text, out freq); //Pass to calculation. Complex Z_S = (V_A2 - V_A1) / ((V_A1 / Z_L1) - (V_A2 / Z_L2)); MessageBox.Show(Z_S.ToString()); Complex Z_S_Conj = new Complex(Z_S.Real, -Z_S.Imaginary); Complex V_S_Ampl = (V_A2 / Z_L2) * Z_S + V_A2; //Populate textboxes. SetControlTextThreadSafe(Zs_tb, Z_S.ToString()); SetControlTextThreadSafe(ZsComponent_tb, Z_S.Real + ", " + Conversions.XtoComponent(Z_S.Imaginary, freq)); SetControlTextThreadSafe(ZsConj_tb, Z_S_Conj.ToString()); SetControlTextThreadSafe(ZsConjComponent_tb, Z_S_Conj.Real + ", " + Conversions.XtoComponent(Z_S_Conj.Imaginary, freq)); SetControlTextThreadSafe(VsAmpl_tb, V_S_Ampl.Magnitude + "<" + V_S_Ampl.Phase); }
public Complex Access(int row_mag, int col_phase) { double mag = this.Mag.v[row_mag]; double phase = this.Phase.v[col_phase]; return(MenialOperations.complex_magphase(mag, phase, true)); }
public static double[] AddConstantToVector(double[] x, double constant) { double[] x_copy = MenialOperations.CopyVector(x); for (int n = 0; n < x.Length; n++) { x_copy[n] += constant; } return(x_copy); }
public static int AppendXYtoCSV(string csvPath, XY xy) { string s = ""; bool overwrite = false; double[,] arrayOut = new double[1, 1]; //If the file doesn't exist, create it. if (!File.Exists(csvPath)) { using (StreamWriter sw = new StreamWriter(csvPath, false)) { sw.Write(""); } } using (StreamReader sr = new StreamReader(csvPath)) { s = sr.ReadLine(); if (String.IsNullOrEmpty(s)) //Empty file -> plot full XY. { overwrite = false; } else //Non-empty file -> read what's there, tack on XY, and overwrite. { double[,] curTable = ImportData.ReadCSVtoDoubleArray(csvPath); arrayOut = new double[curTable.GetLength(0), curTable.GetLength(1) + 1]; MenialOperations.copy_matrix(curTable, arrayOut); for (int curRow = 0; curRow < xy.N; curRow++) { arrayOut[curRow, arrayOut.GetLength(1) - 1] = xy.y[curRow]; } overwrite = true; } } if (!overwrite) { WriteXYtoCSV(csvPath, xy); return(0); } else { WriteDoubleArrayToCSV(csvPath, arrayOut); return(0); } //If there is something here: //read in everything //add XY.y as a column //put everything back out }
//NOT RELATED TO UPDATING. private void ConjugateMatch_btn_Click(object sender, EventArgs e) { //Dummy validation script. //Take s-parameters. //TwoPortNetworks.TwoPortNetwork tpn = new TwoPortNetworks.TwoPortNetwork( // MenialOperations.complex_magphase(0.869, -159, true), // MenialOperations.complex_magphase(0.031, -9, true), // MenialOperations.complex_magphase(4.250, 61, true), // MenialOperations.complex_magphase(0.507, -117, true), // TwoPortNetworks.STATE.S, // 50.0 // ); // //ComplexXY gammaIN_TEST_XY = new ComplexXY(new ComplexLinearSpace(100, 100), tpn.CalculateGammaIN); //ComplexXY gammaOUT_TEST_XY = new ComplexXY(new ComplexLinearSpace(100, 100), tpn.CalculateGammaOUT); // //this.PlotGammaXY(gammaIN_TEST_XY, Color.Red); //this.PlotGammaXY(gammaOUT_TEST_XY, Color.Blue, false); TwoPortNetworks.TwoPortNetwork tpn = this.Device.ExtractTwoPortNetwork(DesignFrequency); //Calculate gamma_s and gamma_L. Complex gamma_s = PAdesign.gamma_S(tpn); Complex gamma_l = PAdesign.gamma_L(tpn); Complex Z_s = Conversions.GammaToZ(gamma_s, this.Device.Zo); Complex Z_l = Conversions.GammaToZ(gamma_l, this.Device.Zo); //Compute gain. double GS = PAdesign.G_S(tpn); double GL = PAdesign.G_L(tpn); double GTotal = PAdesign.G_total(tpn); //Report. string CompleteCircuitDesign = ""; CompleteCircuitDesign += "Gamma S: " + Environment.NewLine + gamma_s.Magnitude + " " + MenialOperations.radtodeg(gamma_s.Phase) + Environment.NewLine + Z_s + Environment.NewLine + Z_s.Real + ", " + Conversions.XtoComponent(Z_s.Imaginary, DesignFrequency) + Environment.NewLine + Environment.NewLine; CompleteCircuitDesign += "Gamma L: " + Environment.NewLine + gamma_l.Magnitude + " " + MenialOperations.radtodeg(gamma_l.Phase) + Environment.NewLine + Z_l + Environment.NewLine + Z_l.Real + ", " + Conversions.XtoComponent(Z_l.Imaginary, DesignFrequency) + Environment.NewLine + Environment.NewLine; ////These.... might not be correct..... //CompleteCircuitDesign += "GS is: " + GS + " (" + 10 * Math.Log10(GS) + "dB)" + Environment.NewLine; //CompleteCircuitDesign += "GL is: " + GL + " (" + 10 * Math.Log10(GL) + "dB)" + Environment.NewLine; //CompleteCircuitDesign += "GTotal is: " + GTotal + " (" + 10 * Math.Log10(GTotal) + "dB)" + Environment.NewLine; //CompleteCircuitDesign += "Mu is: " + tpn.mu(); // ThreadSafe.SetControlTextThreadSafe_uc(this, CompleteCircuitDesign_tb, CompleteCircuitDesign); }
public static double G_S(TwoPortNetworks.TwoPortNetwork tpn) { if (tpn.state != TwoPortNetworks.STATE.S) { throw new Exception("Error: Attempt to call s-param function without two-port network in s-params mode"); } Complex gamma_s = gamma_S(tpn); Complex gamma_in = MenialOperations.gamma_IN(tpn.p, gamma_s); double numer = 1 - Math.Pow(Complex.Abs(gamma_s), 2); double denom = Math.Pow(Complex.Abs(1 - gamma_in * gamma_s), 2); return(numer / denom); }
public static double Covariance(double[] x, double[] y) { if (x.Length != y.Length) { return(0.0); } double[] x_shifted = MenialOperations.copy_vector(x); double[] y_shifted = MenialOperations.copy_vector(y); x_shifted = MenialOperations.shift_vector(x_shifted, -ExpectedValue(x_shifted)); y_shifted = MenialOperations.shift_vector(y_shifted, -ExpectedValue(y_shifted)); return(ExpectedValue(MenialOperations.mul_vector(x_shifted, y_shifted))); }
private void CalculateOscillatorInForm(Complex gammaL) { //int gx = smithChart.gammacoord_to_imagecoord(g.Real, true); //int gy = smithChart.gammacoord_to_imagecoord(g.Imaginary, false); //MessageBox.Show("You clicked at " + e.X + ", " + e.Y + ", which is " + g.Real + ", " + g.Imaginary + ", which converts back to " + gx + ", " + gy); //So clicking should give you the whole rundown on the rest of the circuit. Complex Z_L = Conversions.GammaToZ(gammaL, BiasedBJT.Zo); Complex gammaIN = MenialOperations.gamma_IN(BiasedBJTAtDesignFrequency.p, gammaL); Complex Zin = Conversions.GammaToZ(gammaIN, BiasedBJT.Zo); Complex Z_s = new Complex(Zin.Real / -3, -Zin.Imaginary); Complex gammaS = Conversions.ZtoGamma(Z_s, BiasedBJT.Zo); ThreadSafe.SetControlTextThreadSafe_f(this, completeCircuitDesign_tb, "Desired Gamma In /// Zin: " + MenialOperations.ComplexToStringMagPhase(gammaIN) + " /// " + Zin + Environment.NewLine + Environment.NewLine + "Source Z: " + Z_s + " (" + Conversions.XtoComponent(Z_s.Imaginary, DesignFrequency) + ")" + Environment.NewLine + Environment.NewLine + "Load Z: " + Z_L + " (" + Conversions.XtoComponent(Z_L.Imaginary, DesignFrequency) + ")" ); //For every other frequency, calculate the gammaIN and gammaOUT with this network. //For every other frequency. ThreadSafe.SetControlTextThreadSafe_f(this, otherOscillationModes_tb, ""); for (int n = 0; n < BiasedBJT.freq.Count; n++) { //Calculate gammaIN and gammaOUT. Complex gammaIN_otherFrequency = MenialOperations.gamma_IN(BiasedBJT.p[n], gammaL); Complex gammaOUT_otherFrequency = MenialOperations.gamma_OUT(BiasedBJT.p[n], gammaS); //If any magnitudes are greater than one. if (gammaIN_otherFrequency.Magnitude > 1 || gammaOUT_otherFrequency.Magnitude > 1) { //Print them. ThreadSafe.AppendControlTextThreadSafe_f(this, otherOscillationModes_tb, BiasedBJT.freq[n] + ", " + gammaIN_otherFrequency.Magnitude + ", " + gammaOUT_otherFrequency.Magnitude + Environment.NewLine ); } } }
public static void Lmatch_Z(Complex ZA, Complex ZB, bool isLP, double freq, out double L, out double C) { //Calculate Xs s/t GA,new = GB. //Add shunt susceptance s/t ZA = ZB. Complex YA = 1 / ZA; Complex YB = 1 / ZB; double a = YB.Real; double b = YB.Real * 2 * ZA.Imaginary; double c = YB.Real * ZA.Imaginary * ZA.Imaginary + YB.Real * ZA.Real * ZA.Real - ZA.Real; double Xs_Add; double Xs_Sub; MenialOperations.Quadratic(a, b, c, out Xs_Add, out Xs_Sub); double Xs = 0; //If this is a lowpass match, Xs needs > 0. if (isLP) { Xs = Xs_Add > 0 ? Xs_Add : Xs_Sub; Conversions.XtoComponent(Xs, freq, out L); Complex YA_Prime = 1 / (ZA + new Complex(0, Xs)); double Bp = YB.Imaginary - YA_Prime.Imaginary; Conversions.BtoComponent(Bp, freq, out C); } //If this is a highpass match, Xs needs < 0. else { Xs = Xs_Add < 0 ? Xs_Add : Xs_Sub; Conversions.XtoComponent(Xs, freq, out C); Complex YA_Prime = 1 / (ZA + new Complex(0, Xs)); double Bp = YB.Imaginary - YA_Prime.Imaginary; Conversions.BtoComponent(Bp, freq, out L); } }
public static void Lmatch_Y(Complex YA, Complex YB, bool isLP, double freq, out double L, out double C) { Complex ZA = 1 / YA; Complex ZB = 1 / YB; double a = ZB.Real; double b = ZB.Real * 2 * YA.Imaginary; double c = ZB.Real * YA.Imaginary * YA.Imaginary + ZB.Real * YA.Real * YA.Real - YA.Real; double Bp_Add; double Bp_Sub; MenialOperations.Quadratic(a, b, c, out Bp_Add, out Bp_Sub); double Bp = 0; //If this is a lowpass match, Bp needs > 0. if (isLP) { Bp = Bp_Add > 0 ? Bp_Add : Bp_Sub; Conversions.BtoComponent(Bp, freq, out C); Complex ZA_Prime = 1 / (YA + new Complex(0, Bp)); double Xs = ZB.Imaginary - ZA_Prime.Imaginary; Conversions.XtoComponent(Xs, freq, out L); } //If this is a highpass match, Bp needs < 0. else { Bp = Bp_Add < 0 ? Bp_Add : Bp_Sub; Conversions.BtoComponent(Bp, freq, out L); Complex ZA_Prime = 1 / (YA + new Complex(0, Bp)); double Xs = ZB.Imaginary - ZA_Prime.Imaginary; Conversions.XtoComponent(Xs, freq, out C); } }
public static Complex ComplexFromString(string s, bool degNOTRAD = true) { //a + jb if (s.Contains("j") || (s.Contains("i"))) { s = Regex.Replace(s, @"\s", ""); Regex RealRegex = new Regex(@"^(-)?(\d+)?(\.)?\d+"); Regex ImagRegex = new Regex(@"(\+|-)(j|i)(\d+\.)?\d+"); double real = double.MinValue; double.TryParse(RealRegex.Match(s).Value, out real); double imag = double.MinValue; double.TryParse(ImagRegex.Match(s).Value.Replace("i", "").Replace("j", ""), out imag); Complex toReturn = new Complex(real, imag); return(toReturn); } //m<phase. Defaults to this branch if no imaginary is entered. Returns solely re + j0 if no "<" with corresponding phase is entered. else { s = Regex.Replace(s, @"\s", ""); Regex MagRegex = new Regex(@"^(\d+)?(\.)?\d+"); Regex PhaseRegex = new Regex(@"<(-)?(\d+\d.)?\d+"); double mag = double.MinValue; double.TryParse(MagRegex.Match(s).Value, out mag); double phase = double.MinValue; double.TryParse(PhaseRegex.Match(s).Value.Substring(PhaseRegex.Match(s).Value.IndexOf('<') + 1), out phase); Complex toReturn = MenialOperations.complex_magphase(mag, phase, degNOTRAD); return(toReturn); } }
private void UpdateForDesignFrequencyChange() { //Change DesignFrequency variable. bool UserInputFrequency = double.TryParse(setDesignFrequency_tb.Text, out DesignFrequency); if (!UserInputFrequency) { MessageBox.Show("Please enter valid frequency"); return; } DesignFrequency *= MenialOperations.M; //Fill out table. BiasedBJTAtDesignFrequency = BiasedBJT.ExtractTwoPortNetwork(DesignFrequency); ThreadSafe.SetControlTextThreadSafe_f(this, sParamsChosen_tlp.GetControlFromPosition(0, 0), BiasedBJTAtDesignFrequency.m(1, 1).ToString()); ThreadSafe.SetControlTextThreadSafe_f(this, sParamsChosen_tlp.GetControlFromPosition(0, 1), BiasedBJTAtDesignFrequency.m(1, 2).ToString()); ThreadSafe.SetControlTextThreadSafe_f(this, sParamsChosen_tlp.GetControlFromPosition(1, 0), BiasedBJTAtDesignFrequency.m(2, 1).ToString()); ThreadSafe.SetControlTextThreadSafe_f(this, sParamsChosen_tlp.GetControlFromPosition(1, 1), BiasedBJTAtDesignFrequency.m(2, 2).ToString()); //So now we have the right two-port network. It's the one at our design-freq of course. //But we're interested in mag gammaIN wrt gammaL. //You can make this be a scalarField2D that takes in gammaL.real and gammaL.imag, then outputs gammaIN.magnitude. //Then you can do the Func<> and Fill() that way and get the whole .csv. //Alternatively you can go with the contour plot, which this is not. //But luckily it's not much of a change to go. //Sweep and calculate. double maxMagnitude = 0; double minMagnitude = double.MaxValue; ComplexLinearSpace gammaL_Sweep = new ComplexLinearSpace( new LinearSpace(0.0, 1.0, (int)200), new LinearSpace(0.0, 2 * Math.PI, (int)200) ); Complex[,] gammaIN_Sweep = new Complex[gammaL_Sweep.Mag.N, gammaL_Sweep.Phase.N]; for (int mag_ind = 0; mag_ind < gammaL_Sweep.Mag.N; mag_ind++) { for (int phase_ind = 0; phase_ind < gammaL_Sweep.Phase.N; phase_ind++) { Complex gammaL_Current = MenialOperations.complex_magphase(gammaL_Sweep.Mag.v[mag_ind], gammaL_Sweep.Phase.v[phase_ind], false); gammaIN_Sweep[mag_ind, phase_ind] = MenialOperations.gamma_IN(BiasedBJTAtDesignFrequency.p, gammaL_Current); if (gammaIN_Sweep[mag_ind, phase_ind].Magnitude > maxMagnitude) { maxMagnitude = gammaIN_Sweep[mag_ind, phase_ind].Magnitude; maximizing_gammaL = gammaL_Current; Debug.WriteLine("Max magnitude of " + maxMagnitude + " at " + gammaL_Current); } if (gammaIN_Sweep[mag_ind, phase_ind].Magnitude < minMagnitude) { minMagnitude = gammaIN_Sweep[mag_ind, phase_ind].Magnitude; Debug.WriteLine("Min magnitude of " + minMagnitude + " at " + gammaL_Current); } } } maxMagnitude = Math.Log10(maxMagnitude); minMagnitude = Math.Log10(minMagnitude); //Plot. for (int mag_ind = 0; mag_ind < gammaL_Sweep.Mag.N; mag_ind++) { for (int phase_ind = 0; phase_ind < gammaL_Sweep.Phase.N; phase_ind++) { Complex gammaL_Current = MenialOperations.complex_magphase(gammaL_Sweep.Mag.v[mag_ind], gammaL_Sweep.Phase.v[phase_ind], false); if (gammaIN_Sweep[mag_ind, phase_ind].Magnitude > 1) { int colorFactor = (int)((Math.Log10(gammaIN_Sweep[mag_ind, phase_ind].Magnitude) - minMagnitude) / (maxMagnitude - minMagnitude) * 255); smithChart.plotGamma(gammaL_Current, Color.FromArgb(255, colorFactor, 255 - colorFactor, 0)); } } } smithChart_pb.Invalidate(); }
public static XY LTSpiceVaractorImport(string path, string pathOut) { //String. string DataHeader = "Step Information:"; string curLine; //Numerical. int numRuns = -1; int curRun = 0; double MaxGainForRun = Double.MinValue; double MaxGainFreqForRun = Double.MinValue; double CurFreq = Double.MinValue; string CurFreqString = ""; double CurGain = Double.MinValue; string CurGainString = ""; double[] TestVoltages = new double[1]; double[] ResonantFrequencies = new double[1]; double[] VaractorCapacitances = new double[1]; //Circuit constants. double L = 2000 * MenialOperations.n; double C1 = 10 * MenialOperations.p; double C2 = 10 * MenialOperations.p; //Open stream to target file. System.IO.StreamReader fr = new System.IO.StreamReader(path); while (!fr.EndOfStream) { curLine = fr.ReadLine(); //Case 1: Very first occurrence of DataHeader. if (curLine.Contains(DataHeader) && numRuns == -1) { int.TryParse(curLine.Substring(curLine.IndexOf('/') + 1, curLine.IndexOf(')') - curLine.IndexOf('/') - 1), out numRuns); TestVoltages = new double[numRuns]; TestVoltages[0] = ParseTestParameter(MenialOperations.SubstringProperly(curLine, curLine.IndexOf('=') + 1, curLine.IndexOf('(')).Trim()); ResonantFrequencies = new double[numRuns]; VaractorCapacitances = new double[numRuns]; } //Case 2: Non-first occurrence of DataHeader. else if (curLine.Contains(DataHeader)) { //Store necessary data. ResonantFrequencies[curRun] = MaxGainFreqForRun; TestVoltages[curRun + 1] = ParseTestParameter(MenialOperations.SubstringProperly(curLine, curLine.IndexOf('=') + 1, curLine.IndexOf('(')).Trim()); //Reset maxes. MaxGainForRun = Double.MinValue; //New run -> Recorded max gain from previous run is now obsolete MaxGainFreqForRun = Double.MinValue; curRun++; //New run -> new test voltage -> new resonant frequency -> new varactor capacitance. } //Case 3: Dealing with number. else if (curLine.Contains("dB")) { //Getting freq. //Take substring from [0] to ind(e) + 5. CurFreqString = MenialOperations.SubstringProperly(curLine, 0, curLine.IndexOf('e') + 5); CurFreq = ParseScientificNotation(CurFreqString); curLine = curLine.Replace(CurFreqString, ""); //Chop it off. //Getting gain. //Take substring from [ind('(') + 1] to ind(e) + 5. CurGainString = MenialOperations.SubstringProperly(curLine, curLine.IndexOf('(') + 1, curLine.IndexOf('e') + 5); CurGain = ParseScientificNotation(CurGainString); if (CurGain > MaxGainForRun) { MaxGainFreqForRun = CurFreq; MaxGainForRun = CurGain; } } } //Case 4: End of file. ResonantFrequencies[curRun] = MaxGainFreqForRun; //Calculate varactor capacitances from resonant frequencies in test circuit. for (int n = 0; n < ResonantFrequencies.Length; n++) { double combinedCaps = MenialOperations.Parallel(C1, C2); double inductiveResonanceFactor = 1.0 / ((2.0 * Math.PI * ResonantFrequencies[n]) * (2.0 * Math.PI * ResonantFrequencies[n]) * L); VaractorCapacitances[n] = (combinedCaps * inductiveResonanceFactor) / (combinedCaps - inductiveResonanceFactor); } //Now print. //Debug.WriteLine("Voltage, Resonant Frequency, Capacitance"); //Console.WriteLine("Voltage, Resonant Frequency, Capacitance"); //for (int n = 0; n < ResonantFrequencies.Length; n++) //{ // Debug.WriteLine(TestVoltages[n] + ", " + ResonantFrequencies[n] + ", " + VaractorCapacitances[n]); // Console.WriteLine(TestVoltages[n] + ", " + ResonantFrequencies[n] + ", " + VaractorCapacitances[n]); //} using (StreamWriter fw = new StreamWriter(pathOut)) { fw.WriteLine("Voltage, Varactor Capacitance"); for (int n = 0; n < ResonantFrequencies.Length; n++) { fw.WriteLine(TestVoltages[n] + ", " + VaractorCapacitances[n]); } } //Return. XY Cj = new Microwave.XY(TestVoltages, VaractorCapacitances); return(Cj); //Find number of runs. //Allocate this # of resFreq terms. //Also fill out vector for v. //For each line in the file: //If it says "Step Information", get this value for v. //Get the magnitude value. (dB) //If it's greater than the previous magnitude value: //Store it. //Also store the freq. //Else, move to the next line. //For each resFreq term: //Convert this resFreq to the respective capacitance. }