public void Calc_Extrap_Recovery_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.startDate = Convert.ToDateTime("8/1/2008 0:00");
thisMet.metData.endDate = Convert.ToDateTime("1/28/2009 0:00");
string[] filtsToApply = new string[1];
filtsToApply[0] = "All";
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(80);
double thisRec = thisMet.metData.CalcExtrapRecovery(thisMet.metData.simData[0]);
Assert.AreEqual(thisRec, 0.823225309, 0.001, "Wrong extrapolated data recovery");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.startDate = Convert.ToDateTime("6/24/2008 0:00");
thisMet.metData.endDate = Convert.ToDateTime("12/2/2008 0:00");
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(80);
thisRec = thisMet.metData.CalcExtrapRecovery(thisMet.metData.simData[0]);
Assert.AreEqual(thisRec, 0.84269323, 0.001, "Wrong extrapolated data recovery");
}
public void CalcOverallTurbulenceIntensity()
{
Continuum thisInst = new Continuum("");
string fileName = testingFolder + "\\Met testing.cfm";
thisInst.Open(fileName);
Met thisMet = thisInst.metList.metItem[0];
thisMet.CalcTurbulenceIntensity(thisMet.metData.startDate, thisMet.metData.endDate, 80, thisInst);
Met.TIandCount[] thisTI = thisMet.CalcOverallTurbulenceIntensity("Average", thisInst);
Assert.AreEqual(thisTI[3].overallTI, 0.1498, 0.001, "Wrong Avg TI Test 1");
Assert.AreEqual(thisTI[6].overallTI, 0.0987, 0.001, "Wrong Avg TI Test 2");
Assert.AreEqual(thisTI[9].overallTI, 0.0894, 0.001, "Wrong Avg TI Test 3");
Assert.AreEqual(thisTI[12].overallTI, 0.1002, 0.001, "Wrong Avg TI Test 4");
thisTI = thisMet.CalcOverallTurbulenceIntensity("Representative", thisInst);
Assert.AreEqual(thisTI[3].overallTI, 0.2417, 0.001, "Wrong Avg TI Test 1");
Assert.AreEqual(thisTI[6].overallTI, 0.1585, 0.001, "Wrong Avg TI Test 2");
Assert.AreEqual(thisTI[9].overallTI, 0.1321, 0.001, "Wrong Avg TI Test 3");
Assert.AreEqual(thisTI[12].overallTI, 0.1332, 0.001, "Wrong Avg TI Test 4");
Assert.AreEqual(thisTI[15].overallTI, 0.1330, 0.001, "Wrong Avg TI Test 4");
thisInst.Close();
}
public void Calc_Perc_Diff_from_LT_Monthly_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MERRA_Testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisInst.metList.metItem[0].UTMX, thisInst.metList.metItem[0].UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
double thisDiff = merra.Calc_Perc_Diff_from_LT_Monthly(merra.interpData.Monthly_Prod[0], 2008);
Assert.AreEqual(0.390928274, thisDiff, 0.001, "Wrong Perc Diff Jan 2008");
thisDiff = merra.Calc_Perc_Diff_from_LT_Monthly(merra.interpData.Monthly_Prod[4], 2009);
Assert.AreEqual(-0.186664345, thisDiff, 0.001, "Wrong Perc Diff May 2009");
thisDiff = merra.Calc_Perc_Diff_from_LT_Monthly(merra.interpData.Monthly_Prod[11], 2010);
Assert.AreEqual(-0.2157710, thisDiff, 0.001, "Wrong Perc Diff Dec 2010");
thisInst.Close();
}
public void Calc_Perc_Diff_from_LT_Yearly_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MERRA_Testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisInst.metList.metItem[0].UTMX, thisInst.metList.metItem[0].UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
double This_Diff = merra.Calc_Perc_Diff_from_LT_Yearly(merra.interpData.Annual_Prod, 2008);
Assert.AreEqual(0.09389, This_Diff, 0.001, "Wrong Perc Diff 2008");
This_Diff = merra.Calc_Perc_Diff_from_LT_Yearly(merra.interpData.Annual_Prod, 2009);
Assert.AreEqual(-0.0113, This_Diff, 0.001, "Wrong Perc Diff 2009");
This_Diff = merra.Calc_Perc_Diff_from_LT_Yearly(merra.interpData.Annual_Prod, 2010);
Assert.AreEqual(-0.08254, This_Diff, 0.001, "Wrong Perc Diff 2010");
thisInst.Close();
}
public void Do_MCP_Uncertainty_test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MCP testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
MCP thisMCP = thisMet.mcp;
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisMet.UTMX, thisMet.UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
thisMCP.numWD = 16;
thisMCP.Do_MCP_Uncertainty(thisInst, merra, thisMet);
Assert.AreEqual(thisMCP.uncertOrtho.Length, 12, 0, "Wrong number of uncertainty objects");
Assert.AreEqual(thisMCP.uncertOrtho[0].NWindows, 12, 0, "Wrong number of monthly intervals");
Assert.AreEqual(thisMCP.uncertOrtho[7].NWindows, 5, 0, "Wrong number ofintervals");
Assert.AreEqual(thisMCP.uncertOrtho[5].WSize, 6, 0, "Wrong wrong window size");
Assert.AreEqual(thisMCP.uncertOrtho[0].avg, 6.411818, 0.001, "Wrong average LT Estimate in uncertainty calculation");
thisInst.Close();
}
public void Calc_LT_Avg_Prod_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MERRA_Testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisInst.metList.metItem[0].UTMX, thisInst.metList.metItem[0].UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
merra.Calc_LT_Avg_Prod(ref merra.interpData.Annual_Prod);
// Test 1
double thisProd = merra.interpData.Annual_Prod.LT_Avg;
Assert.AreEqual(3302607.8, thisProd, 50, "Wrong LT Avg Prod");
// Test 2
thisProd = merra.interpData.Annual_Prod.Yearly_Prod[0].prod;
Assert.AreEqual(3612674.8, thisProd, 50, "Wrong 2008 Prod");
// Test 3
Assert.AreEqual(3, merra.interpData.Annual_Prod.Yearly_Prod.Length, "Wrong number of years");
thisInst.Close();
}
public void GenerateMatrixCDFs_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MCP testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
MCP thisMCP = thisMet.mcp;
// Test 1
thisMCP.numWD = 4;
thisMCP.numTODs = 1;
thisMCP.numSeasons = 1;
thisMCP.WS_BinWidth = 1;
MCP.CDF_Obj[] ThisCDF_Obj = thisMCP.GenerateMatrixCDFs();
// check counts of each CDF
Assert.AreEqual(ThisCDF_Obj[6].count, 266);
Assert.AreEqual(ThisCDF_Obj[32].count, 155);
Assert.AreEqual(ThisCDF_Obj[70].count, 147);
Assert.AreEqual(ThisCDF_Obj[100].count, 208);
// check CDF in three locations
Assert.AreEqual(ThisCDF_Obj[5].CDF[25], 0.02381, 0.01, "Wrong CDF[25] for WS_ind = 0");
Assert.AreEqual(ThisCDF_Obj[5].CDF[40], 0.178571, 0.01, "Wrong CDF[40] for WS_ind = 0");
Assert.AreEqual(ThisCDF_Obj[5].CDF[82], 0.940476, 0.01, "Wrong CDF[82] for WS_ind = 0");
thisInst.Close();
}
public void GetSubsetConcData_test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MCP testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
MCP thisMCP = thisMet.mcp;
thisMCP.numWD = 8;
thisMCP.numTODs = 2;
thisMCP.numSeasons = 1;
DateTime thisStart = new DateTime(2008, 12, 1);
DateTime thisEnd = new DateTime(2009, 7, 1);
thisMCP.GetSubsetConcData(thisStart, thisEnd);
Assert.AreEqual(thisMCP.concData[0].thisDate, thisStart, "Wrong start date");
int Last_ind = thisMCP.concData.Length - 1;
Assert.AreEqual(thisMCP.concData[Last_ind].thisDate, thisEnd, "Wrong end date");
thisStart = new DateTime(2009, 8, 31);
thisEnd = new DateTime(2009, 9, 2);
thisMCP.GetSubsetConcData(thisStart, thisEnd);
Assert.AreEqual(thisMCP.concData[0].thisDate, thisStart, "Wrong start date");
Last_ind = thisMCP.concData.Length - 1;
Assert.AreEqual(thisMCP.concData[Last_ind].thisDate, thisEnd, "Wrong end date");
thisInst.Close();
}
public void GetAlphaPValue_Test()
{
Continuum thisInst = new Continuum("");
string fileName = testingFolder + "\\Met testing.cfm";
thisInst.Open(fileName);
Met thisMet = thisInst.metList.metItem[0];
double thisAlphaVal = thisMet.GetAlphaPValue(5, 10, 10, thisInst, thisMet.metData.allStartDate, thisMet.metData.allEndDate);
Assert.AreEqual(thisAlphaVal, 0.6537, 0.001, "Wrong Alpha P Value Test 1");
thisAlphaVal = thisMet.GetAlphaPValue(5, 10, 50, thisInst, thisMet.metData.allStartDate, thisMet.metData.allEndDate);
Assert.AreEqual(thisAlphaVal, 0.276, 0.001, "Wrong Alpha P Value Test 2");
thisAlphaVal = thisMet.GetAlphaPValue(5, 10, 90, thisInst, thisMet.metData.allStartDate, thisMet.metData.allEndDate);
Assert.AreEqual(thisAlphaVal, 0.0791, 0.001, "Wrong Alpha P Value Test 3");
thisAlphaVal = thisMet.GetAlphaPValue(5, 10, 99, thisInst, thisMet.metData.allStartDate, thisMet.metData.allEndDate);
Assert.AreEqual(thisAlphaVal, -0.0082, 0.001, "Wrong Alpha P Value Test 4");
thisInst.Close();
}
public void ExtrapolateData_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
string[] filtsToApply = new string[1];
filtsToApply[0] = "All";
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(80);
thisMet.metData.ExtrapolateData(45);
thisMet.metData.ExtrapolateData(20);
Assert.AreEqual(thisMet.metData.simData[2].WS_WD_data[253].WS, 3.797445309, 0.001, "Wrong extrapolated wind speed Test 1");
Assert.AreEqual(thisMet.metData.simData[1].WS_WD_data[12679].WS, 3.847447028, 0.001, "Wrong extrapolated wind speed Test 2");
Assert.AreEqual(thisMet.metData.simData[0].WS_WD_data[5559].WS, 4.201222192, 0.001, "Wrong extrapolated wind speed Test 3");
Assert.AreEqual(thisMet.metData.simData[2].WS_WD_data[44444].WS, 5.077628706, 0.001, "Wrong extrapolated wind speed Test 4");
thisInst.Close();
}
public void Get_Conc_WS_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
Met_Data_Filter.Anem_Data anemA = new Met_Data_Filter.Anem_Data();
Met_Data_Filter.Anem_Data anemB = new Met_Data_Filter.Anem_Data();
thisMet.metData.startDate = Convert.ToDateTime("1/6/2009 3:00");
thisMet.metData.endDate = Convert.ToDateTime("4/15/2009 16:00");
Met_Data_Filter.Conc_WS_Data thisConcData = thisMet.metData.GetConcWS(30, "Filtered", thisInst, thisMet.name, anemA, anemB);
Assert.AreEqual(thisConcData.anemA_WS.Length, 11166, 0, "Wrong number in Test 1");
thisMet.metData.startDate = Convert.ToDateTime("12/15/2008 18:00");
thisMet.metData.endDate = Convert.ToDateTime("2/16/2009 4:00");
thisConcData = thisMet.metData.GetConcWS(40, "Filtered", thisInst, thisMet.name, anemA, anemB);
Assert.AreEqual(thisConcData.anemA_WS.Length, 7369, 0, "Wrong number in Test 2");
thisMet.metData.startDate = Convert.ToDateTime("3/3/2009 22:00");
thisMet.metData.endDate = Convert.ToDateTime("3/31/2009 1:00");
thisConcData = thisMet.metData.GetConcWS(50, "Filtered", thisInst, thisMet.name, anemA, anemB);
Assert.AreEqual(thisConcData.anemA_WS.Length, 2895, 0, "Wrong number in Test 3");
thisInst.Close();
}
public void Calc_Anem_Data_Recovery_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
// Test 1
double thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[0], false);
Assert.AreEqual(thisRec, 0.93586377, 0.001, "Wrong 30m unfiltered data recovery Test 1");
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].ID == 'B' && thisMet.metData.anems[i].height == 30)
{
thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[i], true);
break;
}
}
Assert.AreEqual(thisRec, 0.80359589, 0.001, "Wrong 30m filtered data recovery Test 2");
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].ID == 'B' && thisMet.metData.anems[i].height == 40)
{
thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[i], true);
break;
}
}
Assert.AreEqual(thisRec, 0.816799848, 0.001, "Wrong 40m filtered data recovery Test 3");
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].ID == 'B' && thisMet.metData.anems[i].height == 50)
{
thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[i], true);
break;
}
}
Assert.AreEqual(thisRec, 0.818493151, 0.0001, "Wrong 50m filtered data recovery Test 4");
thisMet.metData.startDate = Convert.ToDateTime("1/1/2009");
thisMet.metData.endDate = Convert.ToDateTime("6/14/2009 16:10");
thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[4], true);
Assert.AreEqual(thisRec, 0.926327331, 0.0001, "Wrong 50m filtered data recovery Test 5");
thisRec = thisMet.metData.CalcAnemDataRecovery(thisMet.metData.anems[3], true);
Assert.AreEqual(thisRec, 0.878294606, 0.0001, "Wrong 40m filtered data recovery Test 6");
thisInst.Close();
}
public void AddDynButton(string name, Met met, Transform holder)
{
GameObject go = Instantiate(button, holder.transform);
ButtonHelper btnHelp = go.GetComponent <ButtonHelper>();
btnHelp.SetText(name);
btnHelp.btn.onClick.AddListener(met.Invoke);
}
public void CalcMeas_WSWD_Dists_Test()
{
Continuum thisInst = new Continuum("");
string fileName = testingFolder + "\\Met testing.cfm";
thisInst.Open(fileName);
Met thisMet = thisInst.metList.metItem[0];
thisMet.metData.GetSensorDataFromDB(thisInst, thisMet.name);
// Test 1
Met.WSWD_Dist thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.All, Met.Season.All, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 6.617531, 0.01, "Wrong WS Test 1");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[0], 4.842588, 0.01, "Wrong WS Test 1");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[5], 5.461858, 0.01, "Wrong WS Test 1");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[15], 5.159092, 0.01, "Wrong WS Test 1");
// Test 2
thisInst.metList.numTOD = 2;
thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.Day, Met.Season.All, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 6.374398, 0.01, "Wrong WS Test 2");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[0], 4.51033, 0.01, "Wrong WS Test 2");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[3], 5.039229, 0.01, "Wrong WS Test 2");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[10], 7.798786, 0.01, "Wrong WS Test 2");
// Test 3
thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.Night, Met.Season.All, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 6.8643, 0.01, "Wrong WS Test 3");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[1], 5.241824, 0.01, "Wrong WS Test 3");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[7], 7.063508, 0.01, "Wrong WS Test 3");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[15], 5.41911, 0.01, "Wrong WS Test 3");
// Test 4
thisInst.metList.numTOD = 1;
thisInst.metList.numSeason = 4;
thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.All, Met.Season.Winter, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 8.033652, 0.01, "Wrong WS Test 4");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[0], 4.493193, 0.01, "Wrong WS Test 4");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[11], 9.351834, 0.01, "Wrong WS Test 4");
thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.All, Met.Season.Summer, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 5.437018, 0.01, "Wrong WS Test 5");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[4], 4.760074, 0.01, "Wrong WS Test 5");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[15], 4.57385, 0.01, "Wrong WS Test 5");
// Test 6
thisInst.metList.numTOD = 2;
thisDist = thisMet.CalcMeas_WSWD_Dists(80, Met.TOD.Day, Met.Season.Spring, thisInst, thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisDist.WS, 6.733493, 0.01, "Wrong WS Test 6");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[1], 5.530139, 0.01, "Wrong WS Test 6");
Assert.AreEqual(thisDist.WS * thisDist.sectorWS_Ratio[15], 5.760701, 0.01, "Wrong WS Test 6");
thisInst.Close();
}
public void GetAvgAlpha_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
double[] theseAvgAlphas = thisMet.metData.GetAvgAlpha(0, 24, 1);
Assert.AreEqual(theseAvgAlphas[0], 0.297582647, 0.001, "Wrong average alpha for Test 1");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
string[] filtsToApply = new string[1];
filtsToApply[0] = "All";
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("8/1/2008");
thisMet.metData.endDate = Convert.ToDateTime("10/31/2008");
thisMet.metData.EstimateAlpha();
theseAvgAlphas = thisMet.metData.GetAvgAlpha(0, 24, 1);
Assert.AreEqual(theseAvgAlphas[0], 0.320117958, 0.001, "Wrong average alpha for Test 2");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("6/25/2008");
thisMet.metData.endDate = Convert.ToDateTime("6/24/2009 23:50");
thisMet.metData.EstimateAlpha();
theseAvgAlphas = thisMet.metData.GetAvgAlpha(7, 9, 1);
Assert.AreEqual(theseAvgAlphas[0], 0.33187482, 0.001, "Wrong average alpha for Test 3");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("6/25/2008");
thisMet.metData.endDate = Convert.ToDateTime("6/24/2009 23:50");
thisMet.metData.EstimateAlpha();
theseAvgAlphas = thisMet.metData.GetAvgAlpha(12, 23, 16);
Assert.AreEqual(theseAvgAlphas[2], 0.160170555, 0.001, "Wrong average alpha for Test 4");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("1/1/2009");
thisMet.metData.endDate = Convert.ToDateTime("3/15/2009");
thisMet.metData.EstimateAlpha();
theseAvgAlphas = thisMet.metData.GetAvgAlpha(0, 2, 1);
Assert.AreEqual(theseAvgAlphas[0], 0.347682384, 0.001, "Wrong average alpha for Test 5");
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("12/30/2008");
thisMet.metData.endDate = Convert.ToDateTime("2/1/2009");
thisMet.metData.EstimateAlpha();
theseAvgAlphas = thisMet.metData.GetAvgAlpha(3, 3, 16);
Assert.AreEqual(theseAvgAlphas[15], 0.400452263, 0.001, "Wrong average alpha for Test 6");
thisInst.Close();
}
public void DoWS_EstAlongNodes_Test()
{
Continuum thisInst = new Continuum("");
double thisUTMX = 823500;
double thisUTMY = 4500400;
int numWD = 16;
string Filename = testingFolder + "\\Turbine testing.cfm";
thisInst.Open(Filename);
thisInst.turbineList.ClearAllTurbines();
thisInst.turbineList.AddTurbine("Test", thisUTMX, thisUTMY, 1);
thisInst.topo.GetElevsAndSRDH_ForCalcs(thisInst, null, false);
thisInst.turbineList.CalcTurbineExposures(thisInst, 4000, 1.0f, 1);
double[] windRose = thisInst.metList.GetInterpolatedWindRose(thisInst.metList.GetMetsUsed(), thisUTMX, thisUTMY, Met.TOD.All, Met.Season.All, thisInst.modeledHeight);
thisInst.turbineList.turbineEsts[0].gridStats.GetGridArrayAndCalcStats(thisInst.turbineList.turbineEsts[0].UTMX, thisInst.turbineList.turbineEsts[0].UTMY, thisInst);
Model[] models = thisInst.modelList.GetModels(thisInst, thisInst.metList.GetMetsUsed(), Met.TOD.All, Met.Season.All, thisInst.modeledHeight, false);
Met thisMet = thisInst.metList.metItem[0];
Turbine.WS_Ests New_WS_Est = new Turbine.WS_Ests();
New_WS_Est.predictorMetName = thisMet.name;
New_WS_Est.model = models[0];
NodeCollection nodeList = new NodeCollection();
thisInst.turbineList.turbineEsts[0].AddWS_Estimate(New_WS_Est);
Nodes startNode = nodeList.GetMetNode(thisMet);
Nodes targetNode = nodeList.GetTurbNode(thisInst.turbineList.turbineEsts[0]);
Nodes[] pathOfNodes = nodeList.FindPathOfNodes(startNode, targetNode, models[0], thisInst);
Turbine.WS_Ests thisWS_Est = thisInst.turbineList.turbineEsts[0].DoWS_EstAlongNodes(thisMet, models[0], pathOfNodes, thisInst, windRose);
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[0, 0], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[1, 0], 0, 0, "Didn't calculate WS at Node 2");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[2, 0], 0, 0, "Didn't calculate WS at Node 3");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[0, 8], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[1, 8], 0, 0, "Didn't calculate WS at Node 2");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[2, 8], 0, 0, "Didn't calculate WS at Node 3");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[0, numWD - 1], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[1, numWD - 1], 0, 0, "Didn't calculate WS at Node 2");
Assert.AreNotEqual(thisWS_Est.sectorWS_at_nodes[2, numWD - 1], 0, 0, "Didn't calculate WS at Node 3");
Assert.AreNotEqual(thisWS_Est.WS_at_nodes[0], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.WS_at_nodes[1], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.WS_at_nodes[2], 0, 0, "Didn't calculate WS at Node 1");
Assert.AreNotEqual(thisWS_Est.sectorWS[0], 0, 0, "Didn't calculate WS at Target site");
Assert.AreNotEqual(thisWS_Est.sectorWS[numWD - 1], 0, 0, "Didn't calculate WS at Target site");
Assert.AreNotEqual(thisWS_Est.WS, 0, 0, "Didn't calculate WS at Target site");
thisInst.Close();
}
public void CalcAvgExtrapolatedWS_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
string[] filtsToApply = new string[1];
filtsToApply[0] = "All";
thisMet.metData.startDate = Convert.ToDateTime("6/24/2008 15:00");
thisMet.metData.endDate = Convert.ToDateTime("1/22/2009 18:30");
thisMet.metData.EstimateAlpha();
// Test 1
thisMet.metData.ExtrapolateData(80);
double thisAvgWS = thisMet.metData.CalcAvgExtrapolatedWS(thisMet.metData.GetSimulatedTimeSeries(80));
Assert.AreEqual(thisAvgWS, 5.67062, 0.001, "Wrong WS Test 1");
// Test 2
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("10/13/2008 21:30");
thisMet.metData.endDate = Convert.ToDateTime("6/30/2009 23:50");
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(100);
thisAvgWS = thisMet.metData.CalcAvgExtrapolatedWS(thisMet.metData.GetSimulatedTimeSeries(100));
Assert.AreEqual(thisAvgWS, 6.69379, 0.001, "Wrong WS Test 2");
// Test 3
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("1/6/2009");
thisMet.metData.endDate = Convert.ToDateTime("6/1/2009");
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(20);
thisAvgWS = thisMet.metData.CalcAvgExtrapolatedWS(thisMet.metData.GetSimulatedTimeSeries(20));
Assert.AreEqual(thisAvgWS, 4.6989779, 0.001, "Wrong WS Test 3");
// Test 4
thisMet.metData.ClearFilterFlagsAndEstimatedData();
thisMet.metData.FilterData(filtsToApply);
thisMet.metData.startDate = Convert.ToDateTime("1/1/2009 13:00");
thisMet.metData.endDate = Convert.ToDateTime("1/2/2009 12:00");
thisMet.metData.EstimateAlpha();
thisMet.metData.ExtrapolateData(43);
thisAvgWS = thisMet.metData.CalcAvgExtrapolatedWS(thisMet.metData.GetSimulatedTimeSeries(43));
Assert.AreEqual(thisAvgWS, 6.422621015, 0.001, "Wrong WS Test 4");
thisInst.Close();
}
public void Find_MERRA_Coords_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MERRA_Testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisInst.metList.metItem[0].UTMX, thisInst.metList.metItem[0].UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
// Test 1
bool Get_MERRA_Coords = merra.Find_MERRA_Coords(merraFolder);
Assert.AreEqual(4, merra.MERRA_Nodes[0].XY_ind.X_ind, "Wrong x ind");
Assert.AreEqual(2, merra.MERRA_Nodes[0].XY_ind.Y_ind, "Wrong y ind");
// Test 2
merra.numMERRA_Nodes = 4;
Array.Resize(ref merra.MERRA_Nodes, merra.numMERRA_Nodes);
merra.ClearAll();
merra.Set_Interp_LatLon_Dates_Offset(41.2, -83.8, thisInst.UTM_conversions.GetUTC_Offset(41.2, -83.8), thisInst);
Get_MERRA_Coords = merra.Find_MERRA_Coords(merraFolder);
Assert.AreEqual(4, merra.MERRA_Nodes[0].XY_ind.X_ind, "Wrong x ind 0");
Assert.AreEqual(1, merra.MERRA_Nodes[0].XY_ind.Y_ind, "Wrong y ind 0");
Assert.AreEqual(5, merra.MERRA_Nodes[1].XY_ind.X_ind, "Wrong x ind 1");
Assert.AreEqual(1, merra.MERRA_Nodes[1].XY_ind.Y_ind, "Wrong y ind 1");
Assert.AreEqual(4, merra.MERRA_Nodes[2].XY_ind.X_ind, "Wrong x ind 2");
Assert.AreEqual(2, merra.MERRA_Nodes[2].XY_ind.Y_ind, "Wrong y ind 2");
Assert.AreEqual(5, merra.MERRA_Nodes[3].XY_ind.X_ind, "Wrong x ind 3");
Assert.AreEqual(2, merra.MERRA_Nodes[3].XY_ind.Y_ind, "Wrong y ind 3");
// Test 3
merra.numMERRA_Nodes = 16;
Array.Resize(ref merra.MERRA_Nodes, merra.numMERRA_Nodes);
merra.ClearAll();
merra.Set_Interp_LatLon_Dates_Offset(40.4, -82.9, thisInst.UTM_conversions.GetUTC_Offset(40.4, -82.9), thisInst);
Get_MERRA_Coords = merra.Find_MERRA_Coords(merraFolder);
Assert.AreEqual(1, merra.MERRA_Nodes[0].XY_ind.X_ind, "Wrong x ind 0");
Assert.AreEqual(2, merra.MERRA_Nodes[0].XY_ind.Y_ind, "Wrong y ind 0");
Assert.AreEqual(2, merra.MERRA_Nodes[1].XY_ind.X_ind, "Wrong x ind 1");
Assert.AreEqual(2, merra.MERRA_Nodes[1].XY_ind.Y_ind, "Wrong y ind 1");
Assert.AreEqual(3, merra.MERRA_Nodes[2].XY_ind.X_ind, "Wrong x ind 2");
Assert.AreEqual(2, merra.MERRA_Nodes[2].XY_ind.Y_ind, "Wrong y ind 2");
Assert.AreEqual(4, merra.MERRA_Nodes[3].XY_ind.X_ind, "Wrong x ind 2");
Assert.AreEqual(2, merra.MERRA_Nodes[3].XY_ind.Y_ind, "Wrong y ind 2");
thisInst.Close();
}
public void GetClosestWS_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
double thisWS = thisMet.metData.GetClosestWS(1, 13256);
Assert.AreEqual(thisWS, 2.771643406, 0.0001, "Wrong closest wind speed Test 1");
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary> GUI form initializer. </summary>
public GenWakeMap(Continuum continuum)
{
InitializeComponent();
thisInst = continuum;
if (thisInst.topo.useSepMod)
{
txt_FlowSep_Used.Text = "Flow Sep. model used";
txt_FlowSep_Used.BackColor = Color.LightBlue;
}
else
{
txt_FlowSep_Used.Text = "Flow Sep. model NOT used";
txt_FlowSep_Used.BackColor = Color.LightCoral;
}
if (thisInst.topo.useSR)
{
txtLC_Used.Text = "Roughness model used";
txtLC_Used.BackColor = Color.MediumSeaGreen;
}
else
{
txtLC_Used.Text = "Roughness model NOT used";
txtLC_Used.BackColor = Color.LightCoral;
}
thisInst.metList.AreAllMetsMCPd();
if (thisInst.metList.allMCPd)
{
txtisMCPGenWakeMap.Text = "MCP'd Met data used";
txtisMCPGenWakeMap.BackColor = Color.MediumOrchid;
}
else
{
txtisMCPGenWakeMap.Text = "Meas. Met data used";
txtisMCPGenWakeMap.BackColor = Color.LightCoral;
}
chkMetsToUse.Items.Clear(); // Met list on Wake model dialog
int metCount = thisInst.metList.ThisCount;
if (metCount > 0)
{
for (int j = 0; j < metCount; j++) // Now repopulate it with met towers
{
Met thisMet = thisInst.metList.metItem[j];
chkMetsToUse.Items.Add(thisMet.name, true);
}
}
}
public void GetAnemsClosestToHH_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
int actInd = 0;
double HH = 30;
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].height == 30 && thisMet.metData.anems[i].ID == 'B')
{
actInd = i;
}
}
int[] thisInd = thisMet.metData.GetAnemsClosestToHH(HH);
Assert.AreEqual(thisInd[1], actInd, 0, "Wrong anem index");
HH = 55;
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].height == 50 && thisMet.metData.anems[i].ID == 'B')
{
actInd = i;
}
}
thisInd = thisMet.metData.GetAnemsClosestToHH(HH);
Assert.AreEqual(thisInd[1], actInd, 0, "Wrong anem index");
HH = 42;
for (int i = 0; i < thisMet.metData.GetNumAnems(); i++)
{
if (thisMet.metData.anems[i].height == 40 && thisMet.metData.anems[i].ID == 'B')
{
actInd = i;
}
}
thisInd = thisMet.metData.GetAnemsClosestToHH(HH);
Assert.AreEqual(thisInd[1], actInd, 0, "Wrong anem index");
thisInst.Close();
}
public void Method_Of_Bins_Test()
{
// Test Method of Bins method
// Loop through WD, TOD, Season, and WS width (0.5 and 1.0 m/s)
Continuum thisInst = new Continuum("");
string fileName = "C:\\Users\\liz_w\\Desktop\\Continuum 3 GUI Testing\\SaveFolder\\OneMetTSNotFiltWithMERRAAndMCP_1";
thisInst.Open(fileName + ".cfm");
thisInst.isTest = true;
thisInst.cboMCP_Type.SelectedIndex = 1;
Met thisMet = thisInst.GetSelectedMet("MCP");
Met.WSWD_Dist thisEst = new Met.WSWD_Dist();
Met.WSWD_Dist lastEst = new Met.WSWD_Dist();
for (int WD_ind = 0; WD_ind <= 4; WD_ind++)
{
for (int TOD_ind = 0; TOD_ind <= 1; TOD_ind++)
{
for (int seasonInd = 0; seasonInd <= 1; seasonInd++)
{
for (int WS_width_ind = 0; WS_width_ind <= 1; WS_width_ind++)
{
if (WS_width_ind == 0)
{
thisInst.txtWS_bin_width.Text = "0.5";
}
else
{
thisInst.txtWS_bin_width.Text = "1.0";
}
thisInst.cboMCPNumHours.SelectedIndex = TOD_ind;
thisInst.cboMCPNumSeasons.SelectedIndex = seasonInd;
thisInst.cboMCPNumWD.SelectedIndex = WD_ind;
thisInst.DoMCP();
thisEst = thisMet.GetWS_WD_Dist(thisInst.modeledHeight, Met.TOD.All, Met.Season.All);
Assert.AreNotEqual(thisEst.WS, lastEst.WS, "LT Estimate did not change with setting change");
lastEst = thisEst;
}
}
}
}
thisInst.Close();
}
public void CalcSectorWS_Ratios_Test()
{
Continuum thisInst = new Continuum("");
thisInst.UTM_conversions.savedDatumIndex = 0;
thisInst.UTM_conversions.hemisphere = "Northern";
thisInst.ofdMets.FileName = testingFolder + "\\Archbold.TAB";
thisInst.ImportMetsTAB();
Met thisMet = thisInst.metList.metItem[0];
thisMet.CalcSectorWS_Ratios(thisInst);
Assert.AreEqual(thisMet.WSWD_Dists[0].sectorWS_Ratio[0], 0.868457, 0.001, "Wrong Sector WS index 0");
Assert.AreEqual(thisMet.WSWD_Dists[0].sectorWS_Ratio[4], 0.880843, 0.001, "Wrong Sector WS index 4");
Assert.AreEqual(thisMet.WSWD_Dists[0].sectorWS_Ratio[9], 1.027484, 0.001, "Wrong Sector WS index 9");
Assert.AreEqual(thisMet.WSWD_Dists[0].sectorWS_Ratio[15], 0.962568, 0.001, "Wrong Sector WS index 15");
}
public void Method_Help()
{
List <double> arr = new List <double>();
Fac Factrial = delegate(int n)
{
if (n == 0)
{
return(1);
}
double res = 1;
for (int i = 1; i <= n; i++)
{
res *= i;
}
return(res);
};
Met P = delegate(double prev, int n)
{
double res = 0;
double add = Math.Pow(Math.E, -1 * beta) * Math.Pow(beta, n) / Factrial(n);
res = prev + add;
return(res);
};
arr.Add(P(0, 0));
for (int i = 1; true; i++)
{
arr.Add(P(arr[i - 1], i));
if (arr[i] >= 1)
{
arr[i] = 1;
break;
}
}
mas.Add(-1);
mas.Add((int)(arr[0] * int.MaxValue));
for (int i = 1; true; i++)
{
if (mas.Last() == int.MaxValue)
{
break;
}
int t = (int)(arr[i] * int.MaxValue);
mas.Add(t);
}
}
public void Calc_Avg_or_LT_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MERRA_Testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
UTM_conversion.Lat_Long theseLL = thisInst.UTM_conversions.UTMtoLL(thisInst.metList.metItem[0].UTMX, thisInst.metList.metItem[0].UTMY);
MERRA merra = thisInst.merraList.GetMERRA(theseLL.latitude, theseLL.longitude);
if (merra.interpData.TS_Data.Length == 0)
{
merra.GetMERRADataFromDB(thisInst);
merra.GetInterpData(thisInst.UTM_conversions);
}
// Test 1
double thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 100, 100, "50 m WS");
Assert.AreEqual(6.670311915, thisAvg, 0.001, "Wrong 50m WS all data");
// Test 2
thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 100, 100, "Surface Pressure");
Assert.AreEqual(98.72393837, thisAvg, 0.001, "Wrong Pressure");
// Test 3
thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 100, 100, "10 m Temp"); // all data
Assert.AreEqual(10.33596373, thisAvg, 0.001, "Wrong 10m Temp");
// Test 4
thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 1, 2008, "50 m WS"); // jan 2008
Assert.AreEqual(8.938906452, thisAvg, 0.001, "Wrong 50m WS");
// Test 5
thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 100, 2010, "50 m WS"); // avg 2010
Assert.AreEqual(6.421752226, thisAvg, 0.001, "Wrong 50 m WS");
// Test 6
thisAvg = merra.Calc_Avg_or_LT(merra.interpData.TS_Data, 1, 100, "50 m WS"); // avg all january's
Assert.AreEqual(7.639244713, thisAvg, 0.001, "Wrong 50m WS");
thisInst.Close();
}
public void Calc_Percent_Vane_Filtered_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
Met_Data_Filter.Vane_Data This_Vane = new Met_Data_Filter.Vane_Data();
for (int i = 0; i < thisMet.metData.GetNumVanes(); i++)
{
if (thisMet.metData.vanes[i].height == 41)
{
This_Vane = thisMet.metData.vanes[i];
}
}
double thisPercFilt = thisMet.metData.CalcPercentVaneFiltered(This_Vane, Met_Data_Filter.Filter_Flags.Icing);
Assert.AreEqual(thisPercFilt, 0.027302, 0.00001, "Wrong Icing Filt at 41m Test 1");
for (int i = 0; i < thisMet.metData.GetNumVanes(); i++)
{
if (thisMet.metData.vanes[i].height == 49)
{
This_Vane = thisMet.metData.vanes[i];
}
}
thisPercFilt = thisMet.metData.CalcPercentVaneFiltered(This_Vane, Met_Data_Filter.Filter_Flags.Icing);
Assert.AreEqual(thisPercFilt, 0.024543, 0.00001, "Wrong Icing Filt at 49m Test 2");
thisMet.metData.startDate = Convert.ToDateTime("1/27/2009");
thisMet.metData.endDate = Convert.ToDateTime("4/3/2009");
thisPercFilt = thisMet.metData.CalcPercentVaneFiltered(thisMet.metData.vanes[0], Met_Data_Filter.Filter_Flags.Icing);
Assert.AreEqual(thisPercFilt, 0.016729798, 0.00001, "Wrong Icing Filt at 41m");
thisPercFilt = thisMet.metData.CalcPercentVaneFiltered(thisMet.metData.vanes[1], Met_Data_Filter.Filter_Flags.Icing);
Assert.AreEqual(thisPercFilt, 0.018097643, 0.00001, "Wrong Icing Filt at 49m");
thisInst.Close();
}
public void CalcExtremeWindSpeeds_Test()
{
Continuum thisInst = new Continuum("");
string fileName = testingFolder + "\\Extreme WS\\Extreme WS Ashta Iten.cfm";
thisInst.Open(fileName);
Met thisMet = thisInst.metList.metItem[0];
Met.Extreme_WindSpeed maxWS = thisMet.CalcExtremeWindSpeeds(thisInst);
Assert.AreEqual(maxWS.gust1yr, 27.0, 0.1, "Wrong Gust 1-year WS");
Assert.AreEqual(maxWS.tenMin1yr, 16.87, 0.1, "Wrong Ten-Min 1yrear WS");
Assert.AreEqual(maxWS.gust50yr, 32.0, 0.1, "Wrong Gust 50-year WS");
Assert.AreEqual(maxWS.tenMin50yr, 20.0, 0.1, "Wrong Ten-Min 50-year WS");
thisInst.Close();
}
public void GetMaxWS_atHeight_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
double thisMax = thisMet.metData.GetMaxWS_atHeight(30, 0);
Assert.AreEqual(thisMax, 0.581, 0.001, "Wrong max WS at ind 0");
thisMax = thisMet.metData.GetMaxWS_atHeight(30, 10);
Assert.AreEqual(thisMax, 1.475, 0.001, "Wrong max WS at ind 10");
thisInst.Close();
}
public void Calc_Vane_Data_Recovery_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
double thisRec = 0;
for (int i = 0; i < thisMet.metData.GetNumVanes(); i++)
{
if (thisMet.metData.vanes[i].height == 41)
{
thisRec = thisMet.metData.CalcVaneDataRecovery(thisMet.metData.vanes[i], true);
break;
}
}
Assert.AreEqual(thisRec, 0.908561644, 0.001, "Wrong 41m filtered data recovery Test 1");
for (int i = 0; i < thisMet.metData.GetNumVanes(); i++)
{
if (thisMet.metData.vanes[i].height == 49)
{
thisRec = thisMet.metData.CalcVaneDataRecovery(thisMet.metData.vanes[i], true);
break;
}
}
Assert.AreEqual(thisRec, 0.911320396, 0.001, "Wrong 49m filtered data recovery Test 2");
thisMet.metData.startDate = Convert.ToDateTime("9/24/2008");
thisMet.metData.endDate = Convert.ToDateTime("5/4/2009 5:00");
thisRec = thisMet.metData.CalcVaneDataRecovery(thisMet.metData.vanes[0], true);
Assert.AreEqual(thisRec, 0.849803113, 0.001, "Wrong 41m filtered data recovery Test 3");
thisRec = thisMet.metData.CalcVaneDataRecovery(thisMet.metData.vanes[1], true);
Assert.AreEqual(thisRec, 0.854334646, 0.001, "Wrong 49m filtered data recovery Test 4");
thisInst.Close();
}
public void Get_WS_Ratio_or_Diff_and_WS_Test()
{
Continuum thisInst = new Continuum("");
string Filename = testingFolder + "\\MetDataFilter Archbold testing.cfm";
thisInst.Open(Filename);
Met thisMet = thisInst.metList.metItem[0];
Met_Data_Filter.WS_Ratio_WS_Data theseCalcs = new Met_Data_Filter.WS_Ratio_WS_Data();
// 30m Anem tests
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(30, "Unfiltered", "Ratio");
Assert.AreEqual(theseCalcs.WS_Ratio[2468], 0.96742, 0.001, "Wrong value for Test 1");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(30, "Unfiltered", "Diff");
Assert.AreEqual(theseCalcs.WS_Ratio[49], 0, 0.001, "Wrong value for Test 2");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(30, "Filtered", "Ratio");
Assert.AreEqual(theseCalcs.WS[1567], 2.816, 0.001, "Wrong value for Test 3");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(30, "Filtered", "Diff");
Assert.AreEqual(theseCalcs.WS_Ratio[15559], -0.582, 0.001, "Wrong value for Test 4");
thisMet.metData.startDate = Convert.ToDateTime("1/1/2009 22:00");
thisMet.metData.endDate = Convert.ToDateTime("4/3/2009 8:00");
// 50m Anem Tests
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(50, "Unfiltered", "Ratio");
Assert.AreEqual(theseCalcs.WS[1687], 8.896, 0.001, "Wrong value for Test 5");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(50, "Unfiltered", "Diff");
Assert.AreEqual(theseCalcs.WS_Ratio[6874], 0.134, 0.001, "Wrong value for Test 6");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(50, "Filtered", "Ratio");
Assert.AreEqual(theseCalcs.WS_Ratio[2198], 0.983128, 0.001, "Wrong value for Test 7");
theseCalcs = thisMet.metData.GetWS_RatioOrDiffAndWS(50, "Filtered", "Diff");
Assert.AreEqual(theseCalcs.WS[357], 4.873, 0.001, "Wrong value for Test 8");
thisInst.Close();
}
