public void SynthesizeAirfoil(Airfoil.AirfoilManager[] airfoils, Double[] coefficients)
{
// Format Check
var length = airfoils.Length;
if (length != coefficients.Length)
{
throw new FormatException("Number of basis airfoils and coefficients did not match.");
}
Double[,] newCoordinate = new Double[length, 2];
for (int i = 0; i < length; i++)
{
var basis = airfoils[i].ResizedCoordinate;
newCoordinate[i, 0] += basis[i].X;
newCoordinate[i, 1] += coefficients[i] * basis[i].Z;
}
var sAirfoil = new Airfoil.AirfoilCoordinate();
sAirfoil.Import(newCoordinate);
SynthesizedAirfoil = new Airfoil.AirfoilManager(sAirfoil);
}
private DataTable CreateTable(Airfoil.AirfoilManager airfoil)
{
var specifications = new System.Data.DataTable();
specifications.Columns.Add();
specifications.Columns.Add();
specifications.Rows.Add("Airfoil Name", airfoil.AirfoilName);
specifications.Rows.Add("Chord Length", airfoil.ChordLength);
specifications.Rows.Add("Max Thickness", airfoil.MaximumThickness);
specifications.Rows.Add("Max Camber", airfoil.MaximumCamber);
specifications.Rows.Add("L.E. Radius", airfoil.LeadingEdgeRadius);
return(specifications);
}
private static void InitializeTestVariables(out Airfoil.CoefficientOfCombination coefficients, out General.BasisAirfoils basisAirfoils)
{
StreamReader sr1 = new StreamReader(@"DAE-11.csv");
StreamReader sr2 = new StreamReader(@"NACA4412.csv");
var dae = General.CsvManager.ConvertCsvToArray(sr1.ReadToEnd());
var naca = General.CsvManager.ConvertCsvToArray(sr2.ReadToEnd());
var daeCoordinate = new Airfoil.AirfoilCoordinate();
var nacaCoordinate = new Airfoil.AirfoilCoordinate();
daeCoordinate.Import(dae);
nacaCoordinate.Import(naca);
var DAE11 = new Airfoil.AirfoilManager(daeCoordinate);
var NACA4412 = new Airfoil.AirfoilManager(daeCoordinate);
var coef = new double[][] { new[] { 0.7, 0.3, 0.6 }, new[] { 0.3, 0.7, 0.4 } };
coefficients = new Airfoil.CoefficientOfCombination(General.ArrayManager.ConvertJuggedArrayToArray(coef));
basisAirfoils = new General.BasisAirfoils(new[] { DAE11, NACA4412 });
}
// DelegateCommand Action ==========================================================================
private void AirfoilSelectionMethod()
{
Models.AirfoilCsvAnalyzer airfoilCsvAnalyzer = Models.AirfoilCsvAnalyzer.GetInstance();
String _airfoil_path;
// Issue the Messenger displaying OpenFileDialog
_airfoil_path = General.Messenger.OpenFileMessenger.Show("CSV File (*.csv)|*.csv");
if (_airfoil_path == null)
{
return;
}
// Analyze the CSV file located in _airfoil_path
var result = airfoilCsvAnalyzer.Analyze(_airfoil_path);
// Get Airfoil's name from csv file name.
var newAirfoil = new Airfoil.AirfoilManager(result);
newAirfoil.AirfoilName = Path.GetFileName(_airfoil_path).Replace(".csv", "");
// Registrate imported Airfoil to the AirfoilGroupManager.
ImportedAirfoil.Add(newAirfoil);
}
/// <summary>
/// Execute the crossover with UNDX
/// </summary>
/// <param name="parents">Individuals of previous generation</param>
/// <returns>If all crossovers are succesful, offsprings are returned, otherwise null is returned.</returns>
public double[][] ExecuteCrossover(IndividualsGroup parents)
{
Airfoil.CombinedAirfoilsGroupManager offsptingAirfoils = new Airfoil.CombinedAirfoilsGroupManager(nCrossover);
Airfoil.AirfoilManager[] selectedParents = new Airfoil.AirfoilManager[2];
General.RandomNumber.RandomNumberGenerator randomNumberGenerator = new General.RandomNumber.RandomNumberGenerator();
General.Statistics.SamplingWithoutReplacement sampling = new General.Statistics.SamplingWithoutReplacement();
// Random Airfoil Selection
uint[] pIndex = sampling.GetIndex(3, (uint)parents.NumberOfIndividuals);
ParentsIndex[0] = (int)pIndex[0];
ParentsIndex[1] = (int)pIndex[1];
// Create Optimization Parameter Vector
General.Vector p1 = new General.Vector(nParams);
General.Vector p2 = new General.Vector(nParams);
General.Vector p3 = new General.Vector(nParams);
for (int i = 0; i < nParams; i++)
{
p1[i] = parents.IndivisualsGroup[(int)pIndex[0]].OptParameters[i];
p2[i] = parents.IndivisualsGroup[(int)pIndex[1]].OptParameters[i];
p3[i] = parents.IndivisualsGroup[(int)pIndex[2]].OptParameters[i];
}
// If same parameter vector are selected, return null to retry selection.
if (p1.Equals(p2) && p1.Equals(p3))
{
return(null);
}
int n = parents.NumberOfIndividuals;
double d1 = (p2 - p1).Norm();
double d2 = (General.Vector.InnerProduct(p3 - p1, p2 - p1) / Math.Pow((p2 - p1).Norm(), 2) * (p2 - p1) - p3).Norm();
double sigma1 = alpha * d1;
double sigma2 = beta * d2 / Math.Sqrt(n);
General.Vector m = (1.0 / 2.0) * (p1 + p2);
// Create new parameter vector for offsprings
General.Vector[] offspringParameter = new General.Vector[nCrossover];
double[][] offspringParameterArray = new double[nCrossover][];
// Create Offspring's parameter vector
for (int i = 0; i < nCrossover; i++)
{
var StdOffspringPts = randomNumberGenerator.NormDistRandNumSeq(nParams);
offspringParameter[i] = new General.Vector(StdOffspringPts);
var e1 = 1 / (p2 - p1).Norm() * (p2 - p1);
var pAxisComp = General.Vector.InnerProduct(offspringParameter[i], e1);
offspringParameter[i] -= pAxisComp * e1;
offspringParameter[i] = sigma2 * offspringParameter[i];
offspringParameter[i] += sigma1 * pAxisComp * e1;
offspringParameter[i] = offspringParameter[i] + m;
offspringParameterArray[i] = offspringParameter[i].ToDoubleArray();
}
return(offspringParameterArray);
}
public static AirfoilSelectorViewModel Create(Airfoil.AirfoilManager airfoil, Dictionary <Airfoil.AirfoilManager, String> airfoilsMap)
{
return(new AirfoilSelectorViewModel(airfoil, airfoilsMap[airfoil]));
}
public AirfoilSelectorViewModel(Airfoil.AirfoilManager airfoil, String label)
{
this.SelectedAirfoil = airfoil;
this.Label = label;
}
public FitnessCalculator(Airfoil.AirfoilManager airfoil, FitnessMode fitnessMode)
{
this.airfoil = airfoil;
this.fitnessMode = fitnessMode;
}
/// <summary>
///
/// </summary>
/// <param name="airfoil">Added Airfoil</param>
public AirfoilRemovedEventArgs(Airfoil.AirfoilManager airfoil, String label)
{
this.Lable = label;
RemovedAirfoil = airfoil;
}
/// <summary>
///
/// </summary>
/// <param name="airfoil">Added Airfoil</param>
public AirfoilAddedEventArgs(Airfoil.AirfoilManager airfoil)
{
AddedAirfoil = airfoil;
}
/// <summary>
///
/// </summary>
/// <param name="airfoil">Previewing Airfoil</param>
/// <param name="height">Preview Window Height</param>
/// <param name="width">Preview Window Width</param>
/// <returns></returns>
public static System.Collections.ObjectModel.ObservableCollection <System.Windows.Point> GetPreviewPointList(Airfoil.AirfoilManager airfoil, double height, double width)
{
System.Collections.ObjectModel.ObservableCollection <System.Windows.Point> pointList = new System.Collections.ObjectModel.ObservableCollection <System.Windows.Point>();
var airfoilCoordinates = airfoil.InterpolatedCoordinate;
double airfoilLength = Airfoil.AirfoilCoordinate.GetMaximumValue(airfoilCoordinates, 0) - Airfoil.AirfoilCoordinate.GetMinimumValue(airfoilCoordinates, 0);
double airfoilHeight = Airfoil.AirfoilCoordinate.GetMaximumValue(airfoilCoordinates, 1) - Airfoil.AirfoilCoordinate.GetMinimumValue(airfoilCoordinates, 1);
double magnification = 0.8 * (double)width / (double)airfoilLength;
// Adjustment variable
double adjustX = (width - airfoilLength * magnification) / 2 - Airfoil.AirfoilCoordinate.GetMinimumValue(airfoilCoordinates, 0);
double adjustZ = (height - airfoilHeight * magnification) / 2 + Airfoil.AirfoilCoordinate.GetMaximumValue(airfoilCoordinates, 1) * magnification;
// Adjust Airfoil Coordinates to Fit Preview Window
var adjustedCoordinate = Airfoil.AirfoilCoordinate.Scaling(airfoilCoordinates, magnification);
var temp = new Double[adjustedCoordinate.Length, 2];
for (int i = 0; i < adjustedCoordinate.Length; i++)
{
temp[i, 0] = adjustX + adjustedCoordinate[i].X;
temp[i, 1] = adjustZ - adjustedCoordinate[i].Z;
}
adjustedCoordinate.Import(temp);
// Convert adjustCoordinate to ObservableCollection
for (int i = 0; i < adjustedCoordinate.Length; i++)
{
pointList.Add(new System.Windows.Point()
{
X = adjustedCoordinate[i].X, Y = adjustedCoordinate[i].Z
});
}
return(pointList);
}
