static List <Tuple <double, double> > CalcPr(PrSimulator sim, Func <double, double, double> u)
{
List <Tuple <double, double> > ress = new List <Tuple <double, double> >();
for (int i = 1; i <= 10; i++)
{
Console.WriteLine($"PR i = {i}");
double maxSimTime = i * 20d;
sim.Reset();
while (sim.TotalSimTime <= maxSimTime)
{
sim.SimulateSteps();
}
double res = 0;
for (int x = 0; x < sim.Size.Width; x++)
{
res += u(x, 0) * sim[x, 0];
res += u(x, sim.Size.Height - 1) * sim[x, sim.Size.Height - 1];
}
for (int y = 1; y < sim.Size.Height - 1; y++)
{
res += u(0, y) * sim[0, y];
res += u(sim.Size.Width - 1, y) * sim[sim.Size.Width - 1, y];
}
ress.Add(Tuple.Create(maxSimTime, res));
}
return(ress);
}
private void InitComponents(SimulationOptions options)
{
m_PrSimulator = new PrSimulator(options);
m_StSimulator = new StSimulator(options);
m_DiffGenerator = new DiffGenerator(m_PrSimulator, m_StSimulator);
m_Visualizer = new Visualizer2D();
}
static void Main(string[] args)
{
var options = new SimulationOptions(new GridSize(11, 11), new GridIndex(5, 5));
PrSimulator pr = new PrSimulator(options);
StSimulator st = new StSimulator(options);
Func <double, double, double> u = (x, y) => Math.Log(Math.Sqrt((x / 10 + 3) * (x / 10 + 3) + (y / 10 + 3) * (y / 10 + 3)));
File.WriteAllLines("comp_pr.csv", CalcPr(pr, u).Select(x => $"{x.Item1.ToString("E20")};{x.Item2.ToString("E20")}"), Encoding.UTF8);
Console.WriteLine("Finished pr");
File.WriteAllLines("comp_st.csv", CalcSt(st, u).Select(x => $"{x.Item1.ToString("E20")};{x.Item2.ToString("E20")}"), Encoding.UTF8);
}
private double CalcCell(GridIndex coords)
{
var sim = new PrSimulator(new SimulationOptions(m_EdgeData.Size, coords));
while (CanContinue(sim.SimulationInfo))
{
if (CancelRequested())
{
return(double.NaN);
}
sim.SimulateSteps(10);
}
var data = sim.GetData();
double sum = 0;
foreach (var idx in m_EdgeData.Bounds.EnumerateEdge())
{
sum += data[idx] * m_EdgeData[idx];
}
return(sum);
}
static void Main(string[] args)
{
double simTime = 1000d;
var size = new GridSize(5, 5);
var start = new GridIndex(2, 2);
PrSimulator pr = new PrSimulator(new SimulationOptions(size, start));
StSimulator st = new StSimulator(new SimulationOptions(size, start));
List <Tuple <double, double> > prp = new List <Tuple <double, double> >();
List <Tuple <double, double> > stp = new List <Tuple <double, double> >();
double prt = -1d;
double stt = -1d;
while (pr.TotalSimTime < simTime)
{
pr.SimulateSteps();
if (prt == -1d)
{
prt = pr.TotalSimTime;
}
prp.Add(Tuple.Create(pr.TotalSimTime - prt, pr.GetData()[2, 0]));
}
while (st.TotalSimTime < simTime)
{
st.SimulateSteps();
if (stt == -1d)
{
stt = st.TotalSimTime;
}
stp.Add(Tuple.Create(st.TotalSimTime - stt, st.GetData()[2, 0]));
}
File.WriteAllLines("comp_pr.csv", prp.Select(x => $"{x.Item1};{x.Item2}"), Encoding.UTF8);
File.WriteAllLines("comp_st.csv", stp.Select(x => $"{x.Item1};{x.Item2}"), Encoding.UTF8);
}
public PrTabViewModel(SimulationOptions simulationOptions) : base("ІПРАЙ")
{
var logger = Logger.New(typeof(PrTabViewModel));
using (logger.LogPerf("Init"))
{
m_SimulationOptions = simulationOptions;
m_Simulator = new PrSimulator(m_SimulationOptions);
m_VisualizationProvider = GridDataVisualizationProvider.Table();
m_Player = new Player(() =>
{
using (logger.LogPerf("Step simulation"))
{
m_Simulator.SimulateSteps();
}
}, () =>
{
using (logger.LogPerf("Auto simulation"))
{
m_Simulator.SimulateSteps(5);
}
}, () =>
{
UpdateVisualization.Execute().Subscribe();
}, TimeSpan.FromMilliseconds(10), DispatcherPriority.ContextIdle);
UpdateVisualization = ReactiveCommand.Create(() =>
{
using (logger.LogPerf("Visualization"))
{
Visualization = m_VisualizationProvider.ProvideVisualization(m_Simulator.GetData());
SimulationInfo = m_Simulator.SimulationInfo;
}
});
var notRunningOrPlaying = m_Player.WhenAny(x => x.RunningOrPlaying, r => !r.Value);
var notSingleStepRunning = m_Player.WhenAny(x => x.SingleStepRunning, r => !r.Value);
Step = ReactiveCommand.Create(() =>
{
m_Player.StepOnce();
}, notRunningOrPlaying);
PlayPause = new ReactivePlayPauseCommand("Програти", "Пауза", notSingleStepRunning);
PlayPause.Subscribe(p =>
{
if (p)
{
m_Player.Start();
}
else
{
m_Player.Stop();
}
});
Restart = ReactiveCommand.Create(() =>
{
m_Simulator.Reset();
}, notRunningOrPlaying);
Restart.InvokeCommand(UpdateVisualization);
VisualTypeSelector = new ReactiveSelectorCommand <string>(x => (string)x, "Table");
VisualTypeSelector.Selected
.Subscribe(option =>
{
switch (option)
{
case "Table":
m_VisualizationProvider = GridDataVisualizationProvider.Table();
break;
case "2D":
m_VisualizationProvider = GridDataVisualizationProvider.Color();
break;
case "3D":
m_VisualizationProvider = GridDataVisualizationProvider.Model3D(m_SimulationOptions.Size);
break;
}
});
VisualTypeSelector.Selected
.ToSignal()
.InvokeCommand(UpdateVisualization);
OpenSimulationOptions = ReactiveCommand.Create(() =>
{
SimulationOptionsDialog dialog = new SimulationOptionsDialog(m_SimulationOptions);
dialog.ShowDialog();
if (!dialog.DialogResult.GetValueOrDefault(false))
{
return;
}
m_SimulationOptions = dialog.SimulationOptions;
m_Simulator = new PrSimulator(m_SimulationOptions);
m_VisualizationProvider = m_VisualizationProvider.Copy(m_SimulationOptions.Size);
}, notRunningOrPlaying);
OpenSimulationOptions
.InvokeCommand(UpdateVisualization);
ExportToCsv = ReactiveCommand.Create(() =>
{
SaveFileDialog saveFileDialog = new SaveFileDialog()
{
Filter = "Файл CSV (*.csv)|*.csv"
};
if (saveFileDialog.ShowDialog(Application.Current.MainWindow).GetValueOrDefault())
{
CsvUtil.ExportToFile(m_Simulator.GetData(), saveFileDialog.FileName);
}
});
Settings.SettingsChange
.InvokeCommand(UpdateVisualization);
Settings.SettingsChange
.Subscribe(_ =>
{
Pallete = Settings.Current.VisualizationOptions.Pallete;
});
Pallete = Settings.Current.VisualizationOptions.Pallete;
}
}
