public static void Open(string FileName, out CalculationInputData id, out Dictionary <StagesVariableValues, OutputParameters> io)
{
var XML = new XmlDocument();
XML.Load(FileName);
Open(XML, out id, out io);
}
private void SetCalculationInputData(CalculationInputData id)
{
constantParametersControl.PayloadMass = id.M_pg;
constantParametersControl.Height = id.H;
constantParametersControl.Velocity = id.V;
constantParametersControl.Angle = id.nu;
FirstStageConstantParametersControl.VoidSpecificImpulse = id.FirstStageConstantParameters.I_p;
FirstStageConstantParametersControl.SpecificImpulsesRatio = id.FirstStageConstantParameters.l;
FirstStageConstantParametersControl.MidshipLoad = id.FirstStageConstantParameters.P_m;
FirstStageConstantParametersControl.FuelDensity = id.FirstStageConstantParameters.rg;
FirstStageConstantParametersControl.OxidizeDensity = id.FirstStageConstantParameters.ro;
FirstStageConstantParametersControl.FuelRatio = id.FirstStageConstantParameters.kd;
SecondStageConstantParametersControl.VoidSpecificImpulse = id.SecondStageConstantParameters.I_p;
SecondStageConstantParametersControl.SpecificImpulsesRatio = id.SecondStageConstantParameters.l;
SecondStageConstantParametersControl.MidshipLoad = id.SecondStageConstantParameters.P_m;
SecondStageConstantParametersControl.FuelDensity = id.SecondStageConstantParameters.rg;
SecondStageConstantParametersControl.OxidizeDensity = id.SecondStageConstantParameters.ro;
SecondStageConstantParametersControl.FuelRatio = id.SecondStageConstantParameters.kd;
variableParametersControl[FirstStageVariableParameterType.n_0].Set(id.FirstStageVariableParameters.n_0);
variableParametersControl[FirstStageVariableParameterType.a_to].Set(id.FirstStageVariableParameters.a_to);
variableParametersControl[FirstStageVariableParameterType.mu_su_pr].Set(id.FirstStageVariableParameters.mu_su_pr);
variableParametersControl[FirstStageVariableParameterType.gamma_du].Set(id.FirstStageVariableParameters.gamma_du);
variableParametersControl[FirstStageVariableParameterType.mu_k].Set(id.FirstStageVariableParameters.mu_k);
variableParametersControl[SecondStageVariableParameterType.n_0].Set(id.SecondStageVariableParameters.n_0);
variableParametersControl[SecondStageVariableParameterType.a_to].Set(id.SecondStageVariableParameters.a_to);
variableParametersControl[SecondStageVariableParameterType.mu_su_pr].Set(id.SecondStageVariableParameters.mu_su_pr);
variableParametersControl[SecondStageVariableParameterType.gamma_du].Set(id.SecondStageVariableParameters.gamma_du);
variableParametersControl[TrajectoryVariableParameterType.phi_k1].Set(id.phi_k1);
variableParametersControl[TrajectoryVariableParameterType.phi_k2].Set(id.phi_k2);
variableParametersControl[TrajectoryVariableParameterType.phi_0].Set(id.phi_0);
}
public SaveEventArgs(
string FileName,
CalculationInputData id,
Dictionary <StagesVariableValues, OutputParameters> Result) : base()
{
this.FileName = FileName;
this.id = id;
this.Result = Result;
}
public CalculateTrajectoryEventArgs(
StagesVariableValues StagesVariableValues,
OutputParameters OutputParameters,
CalculationInputData id) : base()
{
this.StagesVariableValues = StagesVariableValues;
this.OutputParameters = OutputParameters;
this.id = id;
}
CalculationInputData GetCalculationInputData()
{
CalculationInputData id = new CalculationInputData();
id.FirstStageConstantParameters = FirstStageConstantParametersControl.GetStageConstantParameters();
id.SecondStageConstantParameters = SecondStageConstantParametersControl.GetStageConstantParameters();
id.FirstStageVariableParameters = variableParametersControl.GetFirstStageVariableParameters();
id.SecondStageVariableParameters = variableParametersControl.GetSecondStageVariableParameters();
id.phi_k1 = variableParametersControl[TrajectoryVariableParameterType.phi_k1].GetParameter();
id.phi_k2 = variableParametersControl[TrajectoryVariableParameterType.phi_k2].GetParameter();
id.phi_0 = variableParametersControl[TrajectoryVariableParameterType.phi_0].GetParameter();
id.M_pg = constantParametersControl.PayloadMass;
id.V = constantParametersControl.Velocity;
id.H = constantParametersControl.Height;
id.nu = constantParametersControl.Angle;
return(id);
}
public static void Save(string FileName, CalculationInputData id, Dictionary <StagesVariableValues, OutputParameters> result)
{
var XML = new XmlDocument();
Action <XmlNode, string, double> AddNodeWithValue = (Node, name, value) =>
{
var node = XML.CreateElement(name);
node.InnerText = value.ToString();
Node.AppendChild(node);
};
Action <XmlNode, string, Dictionary <string, double> > AddNodeWithAttributes = (Node, name, attributes) =>
{
var node = XML.CreateElement(name);
foreach (var attr in attributes)
{
var Attribute = XML.CreateAttribute(attr.Key);
Attribute.InnerText = attr.Value.ToString();
node.Attributes.Append(Attribute);
}
Node.AppendChild(node);
};
Action <XmlNode, string, StageConstantParameters> AddStageConstantParametersNode = (Node, name, parameters) =>
{
AddNodeWithAttributes(Node, name, new Dictionary <string, double>()
{
{ "VoidSpecificImpulse", parameters.I_p },
{ "SpecificImpulsesRatio", parameters.l },
{ "MidshipLoad", parameters.P_m },
{ "FuelDensity", parameters.rg },
{ "OxidizeDensity", parameters.ro },
{ "FuelRatio", parameters.kd }
});
};
Action <XmlNode, string, VariableParameter> AddVariableParameterNode = (Node, name, parameter) =>
{
AddNodeWithAttributes(Node, name, new Dictionary <string, double>()
{
{ "StartValue", parameter.Start },
{ "EndValue", parameter.End }
});
};
Action <XmlNode, string, StageVariableParameters> AddStageVariableParametersNode = (Node, name, parameters) =>
{
var node = XML.CreateElement(name);
AddVariableParameterNode(node, "InitialThrustToWeightRatio", parameters.n_0);
AddVariableParameterNode(node, "FuelBayRatio", parameters.a_to);
AddVariableParameterNode(node, "OtherSystemsRatio", parameters.mu_su_pr);
AddVariableParameterNode(node, "EngineBayRatio", parameters.gamma_du);
if (parameters is FirstStageVariableParameters)
{
AddVariableParameterNode(node, "EndMassRatio", (parameters as FirstStageVariableParameters).mu_k);
}
Node.AppendChild(node);
};
Func <XmlNode, string, StagesVariableValues, OutputParameters, XmlNode> AddCalculationResultNode = (Node, name, VariableValues, OutputParameters) =>
{
var CalculationResultNode = XML.CreateElement(name);
Action <string, StageVariableValues> AddStageVariableNode = (StageVariableNodeName, StageVariableValues) =>
{
var dict = new Dictionary <string, double>()
{
{ "InitialThrustToWeightRatio", StageVariableValues.n_0 },
{ "FuelBayRatio", StageVariableValues.a_to },
{ "OtherSystemsRatio", StageVariableValues.mu_su_pr },
{ "EngineBayRatio", StageVariableValues.gamma_du }
};
if (StageVariableValues is FirstStageVariableValues)
{
dict.Add("EndMassRatio", (StageVariableValues as FirstStageVariableValues).mu_k);
}
AddNodeWithAttributes(CalculationResultNode, StageVariableNodeName, dict);
};
Action <string, StageOutputData> AddStageOutputDataNode = (StageOutputDataNodeName, StageOutputData) =>
{
var StageOutputDataNode = XML.CreateElement(StageOutputDataNodeName);
AddNodeWithValue(StageOutputDataNode, "Thrust", StageOutputData.P_0);
AddNodeWithValue(StageOutputDataNode, "InitialMass", StageOutputData.m_0);
AddNodeWithValue(StageOutputDataNode, "EndMass", StageOutputData.m_k);
AddNodeWithValue(StageOutputDataNode, "EngineBayMass", StageOutputData.m_du);
AddNodeWithValue(StageOutputDataNode, "CombustibleMass", StageOutputData.m_g);
AddNodeWithValue(StageOutputDataNode, "OxidizeMass", StageOutputData.m_o);
AddNodeWithValue(StageOutputDataNode, "FuelMass", StageOutputData.m_t);
AddNodeWithValue(StageOutputDataNode, "FuelBayMass", StageOutputData.m_to);
AddNodeWithValue(StageOutputDataNode, "OtherSystemsMass", StageOutputData.m_su_pr);
AddNodeWithValue(StageOutputDataNode, "DryMass", StageOutputData.m_sux);
AddNodeWithValue(StageOutputDataNode, "DryMassRatio", StageOutputData.mu_sux);
if (StageOutputData is SecondStageOutputData)
{
AddNodeWithValue(StageOutputDataNode, "EndMassRatio", (StageOutputData as SecondStageOutputData).mu_k);
}
CalculationResultNode.AppendChild(StageOutputDataNode);
};
AddStageVariableNode("FirstStageVariableValues", VariableValues.firstStageVariableValues);
AddStageVariableNode("SecondStageVariableValues", VariableValues.secondStageVariableValues);
AddStageOutputDataNode("FirstStageOutputData", OutputParameters.FirstStageOutputData);
AddStageOutputDataNode("SecondStageOutputData", OutputParameters.SecondStageOutputData);
var TrajectoryParametersNode = XML.CreateElement("TrajectoryParameters");
AddNodeWithAttributes(TrajectoryParametersNode, "EndPoint", new Dictionary <string, double>()
{
{ "Height", OutputParameters.TrajectoryOutputParameters.H },
{ "Velocity", OutputParameters.TrajectoryOutputParameters.V },
{ "Angle", OutputParameters.TrajectoryOutputParameters.nu }
});
AddNodeWithAttributes(TrajectoryParametersNode, "FlightTime", new Dictionary <string, double>()
{
{ "FirstStage", OutputParameters.TrajectoryOutputParameters.t_1 },
{ "SecondStage", OutputParameters.TrajectoryOutputParameters.t_2 }
});
AddNodeWithAttributes(TrajectoryParametersNode, "PitchProgram", new Dictionary <string, double>()
{
{ "FirstStageEndPitchAngle", OutputParameters.TrajectoryOutputParameters.phi_k1 },
{ "SecondStageInitialPitchAngle", OutputParameters.TrajectoryOutputParameters.phi_0 },
{ "SecondStageEndPitchAngle", OutputParameters.TrajectoryOutputParameters.phi_k2 }
});
CalculationResultNode.AppendChild(TrajectoryParametersNode);
AddNodeWithValue(CalculationResultNode, "PayLoadMassRatio", OutputParameters.mu_pg);
Node.AppendChild(CalculationResultNode);
return(CalculationResultNode);
};
Action <XmlNode, string, Dictionary <StagesVariableValues, OutputParameters> > AddPossibleSolutionsNode = (Node, Name, OutputParametersArray) =>
{
var node = XML.CreateElement(Name);
int i = 1;
foreach (var outputParameters in OutputParametersArray)
{
AddCalculationResultNode(node, "Solution_" + i.ToString(), outputParameters.Key, outputParameters.Value);
i++;
}
Node.AppendChild(node);
};
var Root = XML.CreateElement("Calculation");
var CalculationInputDataNode = XML.CreateElement("CalculationInputData");
AddNodeWithValue(CalculationInputDataNode, "PayloadMass", id.M_pg);
AddNodeWithAttributes(CalculationInputDataNode, "EndPoint", new Dictionary <string, double>()
{
{ "Height", id.H },
{ "Velocity", id.V },
{ "Angle", id.nu }
});
AddVariableParameterNode(CalculationInputDataNode, "FirstStageEndPitchAngle", id.phi_k1);
AddVariableParameterNode(CalculationInputDataNode, "SecondStageInitialPitchAngle", id.phi_0);
AddVariableParameterNode(CalculationInputDataNode, "SecondStageEndPitchAngle", id.phi_k2);
AddStageConstantParametersNode(CalculationInputDataNode, "FirstStageConstantParameters", id.FirstStageConstantParameters);
AddStageConstantParametersNode(CalculationInputDataNode, "SecondStageConstantParameters", id.SecondStageConstantParameters);
AddStageVariableParametersNode(CalculationInputDataNode, "FirstStageVariableParameters", id.FirstStageVariableParameters);
AddStageVariableParametersNode(CalculationInputDataNode, "SecondStageVariableParameters", id.SecondStageVariableParameters);
Root.AppendChild(CalculationInputDataNode);
if ((result != null) && (result.Count != 0))
{
var CalculationResultNode = XML.CreateElement("CalculationResult");
AddPossibleSolutionsNode(CalculationResultNode, "PossibleSolutions", result);
Root.AppendChild(CalculationResultNode);
}
XML.AppendChild(Root);
XML.Save(FileName);
}
public static void Open(XmlDocument XML, out CalculationInputData id, out Dictionary <StagesVariableValues, OutputParameters> io)
{
Func <XmlNode, VariableParameter> GetVariableParameter = Node => new VariableParameter(
Convert.ToDouble(Node.Attributes["StartValue"].InnerText),
Convert.ToDouble(Node.Attributes["EndValue"].InnerText));
Func <XmlNode, StageConstantParameters> GetStageConstantParameters = Node =>
{
var Parameters = new StageConstantParameters();
Parameters.I_p = Convert.ToDouble(Node.Attributes["VoidSpecificImpulse"].InnerText);
Parameters.l = Convert.ToDouble(Node.Attributes["SpecificImpulsesRatio"].InnerText);
Parameters.P_m = Convert.ToDouble(Node.Attributes["MidshipLoad"].InnerText);
Parameters.rg = Convert.ToDouble(Node.Attributes["FuelDensity"].InnerText);
Parameters.ro = Convert.ToDouble(Node.Attributes["OxidizeDensity"].InnerText);
Parameters.kd = Convert.ToDouble(Node.Attributes["FuelRatio"].InnerText);
return(Parameters);
};
Action <XmlNode, StageVariableParameters> FillStageVariableParameters = (Node, Parameters) =>
{
Parameters.n_0 = GetVariableParameter(Node.FindChildByName("InitialThrustToWeightRatio"));
Parameters.a_to = GetVariableParameter(Node.FindChildByName("FuelBayRatio"));
Parameters.mu_su_pr = GetVariableParameter(Node.FindChildByName("OtherSystemsRatio"));
Parameters.gamma_du = GetVariableParameter(Node.FindChildByName("EngineBayRatio"));
if (Parameters is FirstStageVariableParameters)
{
(Parameters as FirstStageVariableParameters).mu_k = GetVariableParameter(Node.FindChildByName("EndMassRatio"));
}
};
var idNode = XML.ChildNodes[0].ChildNodes[0];
id = new CalculationInputData
{
M_pg = Convert.ToDouble(idNode.FindChildByName("PayloadMass").InnerText),
H = Convert.ToDouble(idNode.FindChildByName("EndPoint").Attributes["Height"].InnerText),
V = Convert.ToDouble(idNode.FindChildByName("EndPoint").Attributes["Velocity"].InnerText),
nu = Convert.ToDouble(idNode.FindChildByName("EndPoint").Attributes["Angle"].InnerText),
phi_k1 = GetVariableParameter(idNode.FindChildByName("FirstStageEndPitchAngle")),
phi_0 = GetVariableParameter(idNode.FindChildByName("SecondStageInitialPitchAngle")),
phi_k2 = GetVariableParameter(idNode.FindChildByName("SecondStageEndPitchAngle")),
FirstStageConstantParameters = GetStageConstantParameters(idNode.FindChildByName("FirstStageConstantParameters")),
SecondStageConstantParameters = GetStageConstantParameters(idNode.FindChildByName("SecondStageConstantParameters")),
FirstStageVariableParameters = new FirstStageVariableParameters(),
SecondStageVariableParameters = new SecondStageVariableParameters()
};
FillStageVariableParameters(idNode.FindChildByName("FirstStageVariableParameters"), id.FirstStageVariableParameters);
FillStageVariableParameters(idNode.FindChildByName("SecondStageVariableParameters"), id.SecondStageVariableParameters);
if (XML.ChildNodes[0].ChildNodes.Count == 1)
{
io = null;
return;
}
var ioNode = XML.ChildNodes[0].ChildNodes[1];
Action <XmlNode, StageVariableValues> FillStageVariableValues = (Node, Parameters) =>
{
Parameters.n_0 = Convert.ToDouble(Node.Attributes["InitialThrustToWeightRatio"].InnerText);
Parameters.a_to = Convert.ToDouble(Node.Attributes["FuelBayRatio"].InnerText);
Parameters.mu_su_pr = Convert.ToDouble(Node.Attributes["OtherSystemsRatio"].InnerText);
Parameters.gamma_du = Convert.ToDouble(Node.Attributes["EngineBayRatio"].InnerText);
if (Parameters is FirstStageVariableValues)
{
(Parameters as FirstStageVariableValues).mu_k = Convert.ToDouble(Node.Attributes["EndMassRatio"].InnerText);
}
};
Action <XmlNode, StageOutputData> FillStageOutputData = (Node, Parameters) =>
{
Parameters.P_0 = Convert.ToDouble(Node.FindChildByName("Thrust").InnerText);
Parameters.m_0 = Convert.ToDouble(Node.FindChildByName("InitialMass").InnerText);
Parameters.m_k = Convert.ToDouble(Node.FindChildByName("EndMass").InnerText);
Parameters.m_du = Convert.ToDouble(Node.FindChildByName("EngineBayMass").InnerText);
Parameters.m_g = Convert.ToDouble(Node.FindChildByName("CombustibleMass").InnerText);
Parameters.m_o = Convert.ToDouble(Node.FindChildByName("OxidizeMass").InnerText);
Parameters.m_t = Convert.ToDouble(Node.FindChildByName("FuelMass").InnerText);
Parameters.m_to = Convert.ToDouble(Node.FindChildByName("FuelBayMass").InnerText);
Parameters.m_su_pr = Convert.ToDouble(Node.FindChildByName("OtherSystemsMass").InnerText);
Parameters.m_sux = Convert.ToDouble(Node.FindChildByName("DryMass").InnerText);
Parameters.mu_sux = Convert.ToDouble(Node.FindChildByName("DryMassRatio").InnerText);
if (Parameters is SecondStageOutputData)
{
(Parameters as SecondStageOutputData).mu_k = Convert.ToDouble(Node.FindChildByName("EndMassRatio").InnerText);
}
};
Func <XmlNode, TrajectoryOutputParameters> GetTrajectoryParameters = Node => new TrajectoryOutputParameters
{
H = Convert.ToDouble(Node.FindChildByName("EndPoint").Attributes["Height"].InnerText),
V = Convert.ToDouble(Node.FindChildByName("EndPoint").Attributes["Velocity"].InnerText),
nu = Convert.ToDouble(Node.FindChildByName("EndPoint").Attributes["Angle"].InnerText),
t_1 = Convert.ToDouble(Node.FindChildByName("FlightTime").Attributes["FirstStage"].InnerText),
t_2 = Convert.ToDouble(Node.FindChildByName("FlightTime").Attributes["SecondStage"].InnerText),
phi_k1 = Convert.ToDouble(Node.FindChildByName("PitchProgram").Attributes["FirstStageEndPitchAngle"].InnerText),
phi_0 = Convert.ToDouble(Node.FindChildByName("PitchProgram").Attributes["SecondStageInitialPitchAngle"].InnerText),
phi_k2 = Convert.ToDouble(Node.FindChildByName("PitchProgram").Attributes["SecondStageEndPitchAngle"].InnerText)
};
Func <XmlNode, KeyValuePair <StagesVariableValues, OutputParameters> > GetOutputParameters = Node =>
{
var stagesVariableValues = new StagesVariableValues
{
firstStageVariableValues = new FirstStageVariableValues()
};
FillStageVariableValues(Node.FindChildByName("FirstStageVariableValues"), stagesVariableValues.firstStageVariableValues);
stagesVariableValues.secondStageVariableValues = new SecondStageVariableValues();
FillStageVariableValues(Node.FindChildByName("SecondStageVariableValues"), stagesVariableValues.secondStageVariableValues);
var outputParameters = new OutputParameters
{
FirstStageOutputData = new FirstStageOutputData()
};
FillStageOutputData(Node.FindChildByName("FirstStageOutputData"), outputParameters.FirstStageOutputData);
outputParameters.SecondStageOutputData = new SecondStageOutputData();
FillStageOutputData(Node.FindChildByName("SecondStageOutputData"), outputParameters.SecondStageOutputData);
outputParameters.TrajectoryOutputParameters = GetTrajectoryParameters(Node.FindChildByName("TrajectoryParameters"));
outputParameters.mu_pg = Convert.ToDouble(Node.FindChildByName("PayLoadMassRatio").InnerText);
return(new KeyValuePair <StagesVariableValues, OutputParameters>(stagesVariableValues, outputParameters));
};
io = new Dictionary <StagesVariableValues, OutputParameters>();
foreach (var node in ioNode.FindChildByName("PossibleSolutions").ChildNodes.Cast <XmlNode>())
{
var OutputParameters = GetOutputParameters(node);
io.Add(OutputParameters.Key, OutputParameters.Value);
}
}
public CalculateEventArgs(CalculationInputData id, CancellationTokenSource cts) : base()
{
this.id = id;
this.cts = cts;
}
public void Open(XmlDocument XML, out CalculationInputData id, out Dictionary <StagesVariableValues, OutputParameters> io)
{
CalculationIO.Open(XML, out id, out io);
}
public void Open(string FileName, out CalculationInputData id, out Dictionary <StagesVariableValues, OutputParameters> io)
{
CalculationIO.Open(FileName, out id, out io);
}
public void Save(string FileName, CalculationInputData id, Dictionary <StagesVariableValues, OutputParameters> result)
{
CalculationIO.Save(FileName, id, result);
}
public Dictionary <StagesVariableValues, OutputParameters> Get_mu_k2_Orientiered(
CalculationInputData id,
CancellationTokenSource cts)
{
Func <VariableParameter, int, List <double> > VariableParameterToList = (VariableParameter, Count) =>
{
double Start = VariableParameter.Start;
double End = VariableParameter.End;
var List = new List <double>();
double Delta = (End - Start) / Count;
if (Delta == 0)
{
List.Add(Start);
}
else
{
while (Start <= End)
{
List.Add(Start);
Start += Delta;
}
}
return(List);
};
var AllVaribleParametersList = new List <AllVariableParameters>();
foreach (var _n_01 in VariableParameterToList(id.FirstStageVariableParameters.n_0, 5))
{
foreach (var _n_02 in VariableParameterToList(id.SecondStageVariableParameters.n_0, 5))
{
foreach (var _a_to1 in VariableParameterToList(id.FirstStageVariableParameters.a_to, 5))
{
foreach (var _a_to2 in VariableParameterToList(id.SecondStageVariableParameters.a_to, 5))
{
foreach (var _mu_su_pr1 in VariableParameterToList(id.FirstStageVariableParameters.mu_su_pr, 5))
{
foreach (var _mu_su_pr2 in VariableParameterToList(id.SecondStageVariableParameters.mu_su_pr, 5))
{
foreach (var _gamma_du1 in VariableParameterToList(id.FirstStageVariableParameters.gamma_du, 5))
{
foreach (var _gamma_du2 in VariableParameterToList(id.SecondStageVariableParameters.gamma_du, 5))
{
foreach (var _mu_k1 in VariableParameterToList(id.FirstStageVariableParameters.mu_k, 5))
{
foreach (var _phi_k1 in VariableParameterToList(id.phi_k1, 5))
{
foreach (var _phi_0 in VariableParameterToList(id.phi_0, 5))
{
foreach (var _phi_k2 in VariableParameterToList(id.phi_k2, 5))
{
AllVaribleParametersList.Add(new AllVariableParameters()
{
StagesVariableValues = new StagesVariableValues()
{
firstStageVariableValues = new FirstStageVariableValues()
{
n_0 = _n_01, a_to = _a_to1, mu_su_pr = _mu_su_pr1, gamma_du = _gamma_du1, mu_k = _mu_k1
},
secondStageVariableValues = new SecondStageVariableValues()
{
n_0 = _n_02, a_to = _a_to2, mu_su_pr = _mu_su_pr2, gamma_du = _gamma_du2
}
},
Angles = new Angles()
{
phi_k1 = _phi_k1, phi_0 = _phi_0, phi_k2 = _phi_k2
}
});
}
}
}
}
}
}
}
}
}
}
}
}
var Variants = new List <InputOutputUnion>();
int N = AllVaribleParametersList.Count;
int n = 0;
Dictionary <StagesVariableValues, OutputParameters> Result = null;
var MaxResult = new KeyValuePair <StagesVariableValues, OutputParameters>(null, null);
var po = new ParallelOptions()
{
CancellationToken = cts.Token, MaxDegreeOfParallelism = System.Environment.ProcessorCount
};
try
{
Parallel.For(0, N, po, i =>
{
var varibleParameters = AllVaribleParametersList[i];
Variants.Add(new InputOutputUnion()
{
VaribleParameterValues = varibleParameters.StagesVariableValues,
OutputParameters = Get_mu_k2(
varibleParameters.StagesVariableValues,
id.FirstStageConstantParameters,
id.SecondStageConstantParameters,
varibleParameters.Angles.phi_k1,
varibleParameters.Angles.phi_k2,
varibleParameters.Angles.phi_0,
id.V,
id.M_pg),
Index = i
});
n++;
ProgressChanged(n * 100.0 / N);
});
}
catch (OperationCanceledException e)
{ }
finally
{
var dHmax = Variants.Where(x => x.OutputParameters != null).Max(x => Math.Abs(x.OutputParameters.TrajectoryOutputParameters.H - id.H));
var dnumax = Variants.Where(x => x.OutputParameters != null).Max(x => Math.Abs(x.OutputParameters.TrajectoryOutputParameters.nu - id.nu));
Result = Variants
.Where(x => x.OutputParameters != null)
.OrderBy(x => Math.Sqrt(Math.Pow((x.OutputParameters.TrajectoryOutputParameters.H - id.H) / dHmax, 2) + Math.Pow((x.OutputParameters.TrajectoryOutputParameters.nu - id.nu) / dnumax, 2)))
.Take(15)
.OrderBy(x => x.Index)
.ToDictionary(x => x.VaribleParameterValues, x => x.OutputParameters);
ProgressChanged(100);
cts.Dispose();
}
return(Result);
}
public List <TrajectoryParameters> GetTrajectory(
StagesVariableValues StagesVariableValues,
OutputParameters OutputParameters,
CalculationInputData id)
{
var Trajectory = new List <TrajectoryParameters>();
try
{
double t_k1 = OutputParameters.TrajectoryOutputParameters.t_1;
Func <double, double> firstStage_phi = phi_1(OutputParameters.TrajectoryOutputParameters.phi_k1, t_k1);
var F1 = GetF(
StagesVariableValues.firstStageVariableValues.n_0,
id.FirstStageConstantParameters.I_p,
id.FirstStageConstantParameters.l,
id.FirstStageConstantParameters.P_m,
firstStage_phi);
double t_1 = 0;
double dt = 0.1;
var X_1 = new double[] { 0, 0, 0, 0, 1, 0, 0 };
Action <double, double[], double, double> AddTrajectoryParameter = (Time, X, m_0, phi) =>
{
Trajectory.Add(new TrajectoryParameters()
{
Time = Time,
v_char = X[0],
v_grav = X[1],
v_aer = X[2],
v_press = X[3],
m = X[4] * m_0,
x = X[5],
y = X[6],
phi = phi,
h = Math.Sqrt(Math.Pow(X[5], 2) + Math.Pow(X[6] + R, 2)) - R,
xi = Math.Atan(X[5] / (R + X[6])),
nu = phi + Math.Atan(X[5] / (R + X[6]))
});
};
do
{
AddTrajectoryParameter(t_1, X_1, OutputParameters.FirstStageOutputData.m_0, firstStage_phi(t_1));
X_1 = X_1.Zip(RungeKuttaIteration.Get(X_1, F1, t_1, dt), (x, dx) => x + dx).ToArray();
t_1 += dt;
} while (t_1 < t_k1);
double t_k2 = OutputParameters.TrajectoryOutputParameters.t_2;
Func <double, double> secondStage_phi = phi_2(OutputParameters.TrajectoryOutputParameters.phi_0, OutputParameters.TrajectoryOutputParameters.phi_k2, t_k2);
var F2 = GetF(
StagesVariableValues.secondStageVariableValues.n_0,
id.SecondStageConstantParameters.I_p,
id.SecondStageConstantParameters.l,
id.SecondStageConstantParameters.P_m,
secondStage_phi);
double t_2 = 0;
var X_2 = X_1;
X_2[4] = 1;
while (t_2 < t_k2)
{
X_2 = X_2.Zip(RungeKuttaIteration.Get(X_2, F2, t_2, dt), (x, dx) => x + dx).ToArray();
t_2 = t_2 + dt;
AddTrajectoryParameter(t_2 + t_k1, X_2, OutputParameters.SecondStageOutputData.m_0, secondStage_phi(t_2));
}
}
catch { }
return(Trajectory);
}
