public ActionResult Index(OptimizationModel model)
{
try
{
for (var index = 0; index < model.Furnaces.Count; index++)
{
var modelFurnace = model.Furnaces[index];
modelFurnace.FurnanceId = index;
}
model = Solve(model);
var solvedModel = new OptimizationModel();
solvedModel.Furnaces = model.Furnaces;
solvedModel.CoxCost = model.CoxCost;
solvedModel.GasCost = model.GasCost;
solvedModel.GasSupply = model.GasSupply;
solvedModel.CoxSupply = model.CoxSupply;
solvedModel.OptimizedFunctionResult = model.OptimizedFunctionResult;
solvedModel.RequiredIronPerformance = model.RequiredIronPerformance;
ViewBag.MessageResult = $"Рассчитанная целевая функция: {solvedModel.OptimizedFunctionResult}";
return(View(solvedModel));
}
catch (Exception e)
{
ViewBag.MessageResult = "При расчете произошла ошибка. Проверьте входные данные";
return(View(model));
}
}
private void button1_Click(object sender, EventArgs e)
{
richTextBox1.Text = "";
desc.Clear();
alg = new PGA();
OptimizationModel optModel = new OptimizationModel(func);
AlgorithmSettings settings = new AlgorithmSettings()
{
InitialLoadType = (InitialLoadType)comboBox1.SelectedItem,
OptModel = optModel,
InitialPointCount = (int)numericUpDown1.Value,
SelectionType = (SelectionType)comboBox2.SelectedItem,
EndCondition = (EndCondition)comboBox3.SelectedItem,
MaxGenerationCount = (int)numericUpDown2.Value,
SurvivedCount = (int)numericUpDown3.Value,
MutationChance = (double)numericUpDown4.Value,
CrossingGenNumber = (int)numericUpDown5.Value,
Tolerance = (double)numericUpDown6.Value,
MutationChanceAfterCrossing = (double)numericUpDown7.Value,
MutationType = (MutationType)comboBox4.SelectedItem
};
alg.Run(settings);
DrawRezult(alg);
WriteRezult(alg);
}
public static double GetObjectiveForElement(ElementModel element, int lod, OptimizationModel model)
{
var importance = Math.Pow(element.ImportanceNorm, 2);
var utility = GetUtilityForElement(element, lod);// (double)lod / element.MaxLevelOfDetail * importance;
var visibilityReward = 1.0 + model.VisibilityReward * element.Visibility;
return((importance * model.WeightImportance + utility * model.WeightUtility) * visibilityReward);
}
public ActionResult Index(OptimizationModel model)
{
model = Optimize(model);
var result = JsonConvert.SerializeObject(new
{
isSuccess = true,
optimizationModel = model
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public MainWindow()
{
_optimizationModel = new OptimizationModel();
_appModel = new AppModel(_optimizationModel);
_viewModel = new ViewModel(_appModel);
_appController = new AppController(_appModel, _viewModel);
_appController.InitFakeViewModel(this);
_appController.InitModels();
DataContext = _viewModel;
InitializeComponent();
}
public ActionResult Index()
{
var furnances = GetDefaultFurnances();
var optimizationModel = new OptimizationModel()
{
CoxCost = 1.8,
CoxSupply = 520,
GasCost = 0.6,
GasSupply = 120000,
Furnaces = furnances,
RequiredIronPerformance = 1100
};
optimizationModel = Solve(optimizationModel);
return(View(optimizationModel));
}
public static Mesh GetMesh(OptimizationModel optModel, int pointCount, InitialLoadType type)
{
Mesh mesh = null;
switch (type)
{
case InitialLoadType.Box:
mesh = GetBoxMesh(optModel, pointCount); break;
case InitialLoadType.TriangleMesh:
mesh = GetTriangMesh(optModel, pointCount); break;
default:
break;
}
return(mesh);
}
// GET: Optimization
public ActionResult Index()
{
var furnances = GetDefaultFurnances();
var optimizationModel = new OptimizationModel()
{
CoxCost = 1.8,
CoxSupply = 520,
GasCost = 0.6,
GasSupply = 120000,
Furnaces = furnances,
RequiredIronPerformance = 1100
};
optimizationModel = Optimize(optimizationModel);
return(Json(new
{
isSuccess = true,
optimizationModel = optimizationModel
}, JsonRequestBehavior.AllowGet));
}
public AppModel(OptimizationModel optimizationModel)
{
User = new UserModel();
Elements = new List <ElementModel>();
OptimizationModel = optimizationModel;
}
public static double GetTimeDependentCognitiveLoadOnsetPenalty(ElementModel element, OptimizationModel model)
{
var cogLoadOnsetPenalty = model.CognLoadOnsetPenalty *
Math.Exp(-element.TimeVisible / model.CognLoadOnsetPenaltyDecay);
return(cogLoadOnsetPenalty);
}
private OptimizationModel Solve(OptimizationModel optimizationModel)
{
var furnances = optimizationModel.Furnaces;
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
var furnancesSet = new Set(Domain.Any, "Furnances");
var parametersList = new List <Parameter>();
var gasExpenseBasePeriod = new Parameter(Domain.Real, "GasExpenseBasePeriod", furnancesSet);
gasExpenseBasePeriod.SetBinding(furnances, "GasExpenseBasePeriod", "FurnanceId");
var minGasExpense = new Parameter(Domain.Real, "MinGasExpense", furnancesSet);
minGasExpense.SetBinding(furnances, "MinGasExpense", "FurnanceId");
var maxGasExpense = new Parameter(Domain.Real, "MaxGasExpense", furnancesSet);
maxGasExpense.SetBinding(furnances, "MaxGasExpense", "FurnanceId");
var coxExpenseBasePeriod = new Parameter(Domain.Real, "CoxExpenseBasePeriod", furnancesSet);
coxExpenseBasePeriod.SetBinding(furnances, "CoxExpenseBasePeriod", "FurnanceId");
var coxReplacementEquivalent = new Parameter(Domain.Real, "CoxReplacementEquivalent", furnancesSet);
coxReplacementEquivalent.SetBinding(furnances, "CoxReplacementEquivalent", "FurnanceId");
var ironPerformance = new Parameter(Domain.Real, "IronPerformance", furnancesSet);
ironPerformance.SetBinding(furnances, "IronPerformance", "FurnanceId");
var theoreticTemperatureBasePeriod = new Parameter(Domain.Real, "TheoreticTemperatureBasePeriod", furnancesSet);
theoreticTemperatureBasePeriod.SetBinding(furnances, "TheoreticTemperatureBasePeriod", "FurnanceId");
var minTemperature = new Parameter(Domain.Real, "MinTemperature", furnancesSet);
minTemperature.SetBinding(furnances, "MinTemperature", "FurnanceId");
var maxTemperature = new Parameter(Domain.Real, "MaxTemperature", furnancesSet);
maxTemperature.SetBinding(furnances, "MaxTemperature", "FurnanceId");
var deltaIronPerformanceGasChanged = new Parameter(Domain.Real, "DeltaIronPerformanceGasChanged", furnancesSet);
deltaIronPerformanceGasChanged.SetBinding(furnances, "DeltaIronPerformanceGasChanged", "FurnanceId");
var deltaIronPerformanceCoxChanged = new Parameter(Domain.Real, "DeltaIronPerformanceCoxChanged", furnancesSet);
deltaIronPerformanceCoxChanged.SetBinding(furnances, "DeltaIronPerformanceCoxChanged", "FurnanceId");
var deltaTemperatureGasChanged = new Parameter(Domain.Real, "DeltaTemperatureGasChanged", furnancesSet);
deltaTemperatureGasChanged.SetBinding(furnances, "DeltaTemperatureGasChanged", "FurnanceId");
parametersList.Add(gasExpenseBasePeriod);
parametersList.Add(minGasExpense);
parametersList.Add(maxGasExpense);
parametersList.Add(coxExpenseBasePeriod);
parametersList.Add(coxReplacementEquivalent);
parametersList.Add(ironPerformance);
parametersList.Add(minTemperature);
parametersList.Add(maxTemperature);
parametersList.Add(theoreticTemperatureBasePeriod);
parametersList.Add(deltaIronPerformanceGasChanged);
parametersList.Add(deltaIronPerformanceCoxChanged);
parametersList.Add(deltaTemperatureGasChanged);
model.AddParameters(parametersList.ToArray());
Decision decision = new Decision(Domain.RealNonnegative, "decision", furnancesSet);
model.AddDecision(decision);
/*(koksekv*стоимость кокса - стоимость природного газа)*расход ту readjust*/
model.AddGoal("CokeSaving", GoalKind.Maximize,
Model.Sum(Model.ForEach(furnancesSet, FurnanceId => (coxReplacementEquivalent[FurnanceId] * optimizationModel.CoxCost - optimizationModel.GasCost) * decision[FurnanceId])));
model.AddConstraint("RequiredIronPerformance",
Model.Sum(Model.ForEach(furnancesSet, CalculatePerformanceConstraint)) >= optimizationModel.RequiredIronPerformance);
// (расходПГ - расходБазовомПериоде)*ИзмПрЧугИзмПГ - ЭквЗамКокс*(расходПГ - расходБазовомПериоде)*ИзмПрЧугИзимКокса + ПрПоЧугБазовомПер
Term CalculatePerformanceConstraint(Term FurnanceId)
{
var val = (decision[FurnanceId] - gasExpenseBasePeriod[FurnanceId]) * deltaIronPerformanceGasChanged[FurnanceId] -
coxReplacementEquivalent[FurnanceId] * (decision[FurnanceId] - gasExpenseBasePeriod[FurnanceId]) *
deltaIronPerformanceCoxChanged[FurnanceId] + ironPerformance[FurnanceId];
return(val);
}
model.AddConstraints("GasExpenseInterval", Model.ForEach(furnancesSet, FurnanceId => (minGasExpense[FurnanceId] <= decision[FurnanceId] <= maxGasExpense[FurnanceId])));
Term CalculateTemperatureConstraint(Term FurnanceId)
{
return(minTemperature[FurnanceId] <= ((decision[FurnanceId] - gasExpenseBasePeriod[FurnanceId]) * deltaTemperatureGasChanged[FurnanceId] + theoreticTemperatureBasePeriod[FurnanceId]) <= maxTemperature[FurnanceId]);
}
model.AddConstraints("TemperatureInterval", Model.ForEach(furnancesSet, CalculateTemperatureConstraint));
Term CalculateCoxSupplyConstraint(Term FurnanceId)
{
return(coxExpenseBasePeriod[FurnanceId] + 0.001 * (gasExpenseBasePeriod[FurnanceId] - decision[FurnanceId]) + coxReplacementEquivalent[FurnanceId]);
}
model.AddConstraint("CoxSupply", Model.Sum(Model.ForEach(furnancesSet, CalculateCoxSupplyConstraint)) <= optimizationModel.CoxSupply);
model.AddConstraint("GasSupply", Model.Sum(Model.ForEach(furnancesSet, FurnanceId => decision[FurnanceId])) <= optimizationModel.GasSupply);
SimplexDirective simplex = new SimplexDirective();
Solution solved = context.Solve(simplex);
var report = solved.GetReport();
optimizationModel.OptimizedFunctionResult = solved.Goals.First().ToDouble();
var reportToString = report.ToString();
ViewBag.ReportToString = reportToString;
var results = report.ToString().Split(new[] { "Decisions:" }, StringSplitOptions.None)[1].Split(':')
.Select(line => line.Remove(line.IndexOf("\r", StringComparison.Ordinal)))
.Where(line => !string.IsNullOrEmpty(line)).Select(Convert.ToDouble).ToList();
for (var index = 0; index < furnances.Count; index++)
{
var furnace = furnances[index];
furnace.GasExpenseToReadjust = results[index];
}
return(optimizationModel);
}
public Optimizer(OptimizationModel model)
{
_model = model;
}
private static Mesh GetBoxMesh(OptimizationModel optModel, int pointCount)
{
Mesh mesh = new Mesh();
for (double y = -10; y <= 10; y += 10)
{
for (double x = -10; x <= 10; x += 10)
{
mesh.nodes.Add(new Point(optModel, x, y));
}
}
for (double y = -5; y <= 5; y += 5)
{
for (double x = -5; x <= 5; x += 5)
{
mesh.nodes.Add(new Point(optModel, x, y));
}
}
for (int i = 0; i <= 8; i++)
{
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[4], P2 = mesh.nodes[i]
});
}
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[0], P2 = mesh.nodes[2]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[0], P2 = mesh.nodes[6]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[8], P2 = mesh.nodes[2]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[8], P2 = mesh.nodes[6]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[9], P2 = mesh.nodes[11]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[9], P2 = mesh.nodes[15]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[17], P2 = mesh.nodes[11]
});
mesh.Lines.Add(new Line()
{
P1 = mesh.nodes[17], P2 = mesh.nodes[15]
});
List <int> nums = new List <int>()
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16
};
Random r = new Random();
for (int i = 0; i < pointCount; i++)
{
int id = r.Next(0, nums.Count - 1);
mesh.Chromosomes.Add(new Chromosome(optModel, mesh.nodes[nums[id]].X1, mesh.nodes[nums[id]].X2));
nums.RemoveAt(id);
}
return(mesh);
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
int progress = 0;
optrez.Clear();
finalRez.Clear();
alg = new PGA();
OptimizationModel optModel = new OptimizationModel(func);
EnumConverter InitialLoadTypeCollection = new EnumConverter(typeof(InitialLoadType));
EnumConverter EndConditionTypeCollecton = new EnumConverter(typeof(EndCondition));
EnumConverter MutationTypeCollecton = new EnumConverter(typeof(MutationType));
EnumConverter SelectionTypeCollection = new EnumConverter(typeof(SelectionType));
foreach (InitialLoadType il in InitialLoadTypeCollection.GetStandardValues())
{
foreach (EndCondition ec in EndConditionTypeCollecton.GetStandardValues())
{
foreach (MutationType mt in MutationTypeCollecton.GetStandardValues())
{
foreach (SelectionType st in SelectionTypeCollection.GetStandardValues())
{
double[] f1m = new double[(int)numericUpDown8.Value];
double[] f2m = new double[(int)numericUpDown8.Value];
double[] fm = new double[(int)numericUpDown8.Value];
double[] x1m = new double[(int)numericUpDown8.Value];
double[] x2m = new double[(int)numericUpDown8.Value];
for (int i = 0; i < (int)numericUpDown8.Value; i++)
{
AlgorithmSettings settings = new AlgorithmSettings()
{
InitialLoadType = il,
OptModel = optModel,
InitialPointCount = (int)numericUpDown1.Value,
SelectionType = st,
EndCondition = ec,
MaxGenerationCount = (int)numericUpDown2.Value,
SurvivedCount = (int)numericUpDown3.Value,
MutationChance = (double)numericUpDown4.Value,
CrossingGenNumber = (int)numericUpDown5.Value,
Tolerance = (double)numericUpDown6.Value,
MutationChanceAfterCrossing = (double)numericUpDown7.Value,
MutationType = mt
};
alg.Run(settings);
double x1 = alg.Best.X1;
double x2 = alg.Best.X2;
double f1 = alg.Best.F;
double f2 = alg.CallCount;
double f = GetCriterion(f1, f2);
f1m[i] = f1;
f2m[i] = f2;
fm[i] = f;
x1m[i] = x1;
x2m[i] = x2;
optrez.Add(new OptRezult()
{
I = il,
E = ec,
S = st,
M = mt,
F1 = f1,
F2 = f2,
X1 = x1,
X2 = x2,
F = f
});
}
progress++;
backgroundWorker1.ReportProgress(progress * 100 / 24);
finalRez.Add(new OptRezult()
{
I = il,
E = ec,
S = st,
M = mt,
X1 = x1m.Average(),
X2 = x2m.Average(),
F1 = f1m.Average(),
F2 = f2m.Average(),
F = fm.Average()
});
}
}
}
}
}
public OptimizationCompletedEventArgs(OptimizationModel model, TimeSpan duration)
{
Model = model;
Duration = duration;
}
