public MainWindow()
{
InitializeComponent();
SizeToContent = SizeToContent.WidthAndHeight;
myDataContext = new SimulationViewModel();
DataContext = myDataContext;
myDataContext.TargetDistance = DefaultTargetDistance;
myDataContext.TargetBearing = DefaultTargetBearing;
MyCanvas.SizeChanged += CanvasSizeChanged;
myTargetShip = new Ship(0, 0, 0, 0);
myShip = new Ship(0, 0, 0, 0);
InitLines();
InitEllipses(8);
InitDegreeLables();
InitTexboxes();
InitParamsDictionary();
// ReSharper disable once ObjectCreationAsStatement
new DispatcherTimer(
new TimeSpan(0, 0, 0, 0, 100),
DispatcherPriority.Background,
TimerTick,
Dispatcher.CurrentDispatcher)
{
IsEnabled = true
};
myShownTimer = new Timer();
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
//dependency injection timer
var container = new UnityContainer();
container.RegisterInstance <IUnityContainer>(container);
container.RegisterType <ITimeService, TimeService>();
UnityServiceLocator locator = new UnityServiceLocator(container);
ServiceLocator.SetLocatorProvider(() => locator);
Simulation simulation = new Simulation();
SimulationViewModel vm = new SimulationViewModel(simulation);
var main = new MainWindow();
main.DataContext = vm;
main.initSideWindows();
main.Show();
}
public ActionResult simulator()
{
//var importClient = db.Import.OrderByDescending(d => d.Date).Where(c => c.Type == TypeImport.Client).First();
//var proc = db.assort.Where(a => a.ImportId == importClient.Id).GroupBy(e => e.Ean13);
List <AssortViewModelcs> Lassort = new List <AssortViewModelcs>();
Import import = this.db.Import.OrderByDescending(d => d.Date).Where(c => c.Type == TypeImport.Client).OrderByDescending(d => d.Date).First();
var proc = db.Procurement.ToList().GroupBy(e => e.Ean13);
using (var context = new ScanDbContext())
{
Lassort = context.Database
.SqlQuery <AssortViewModelcs>("GETSimulator")
.ToList();
}
List <SimulationViewModel> LSimulationViewModel = new List <SimulationViewModel>();
foreach (var item in Lassort)
{
SimulationViewModel sm = new SimulationViewModel();
sm.Ean13 = item.Ean13;
sm.label = item.Label;
sm.StockReel = item.quantity;
//sm.Price = item.Price;
sm.OrderedQte = 0;
sm.QteSales = 0;
sm.M1 = 0;
sm.M2 = 0;
sm.M3 = 0;
LSimulationViewModel.Add(sm);
}
return(PartialView("_simulator", LSimulationViewModel));
}
public async Task <IActionResult> Simulation()
{
ViewData["Title"] = "Simulation Module";
var tournament = await fantasySoccerService.GetCurrentTournament();
var numberOfRounds = await fantasySoccerService.GetNumberOfRoundsForATournament(tournament.ID);
var viewModel = new SimulationViewModel
{
TournamentId = tournament.ID,
TournamentName = tournament.Name,
CurrentRound = tournament.CurrentRound,
Rounds = Enumerable.Range(1, numberOfRounds)
.Select(r => new SelectListItem
{
Text = r.ToString(),
Value = r.ToString(),
Selected = tournament.CurrentRound == r
}
)
};
return(View("Simulation", viewModel));
}
public void OpenSimulation()
{
var dialog = new OpenFileDialog()
{
Title = "Open Simulation Configuration Settings file...",
Filter = "JSON Files|*.json;*.js|All Files|*.*"
};
if (dialog.ShowDialog(Application.Current.MainWindow).GetValueOrDefault())
{
try
{
var json = File.ReadAllText(dialog.FileName);
var model = JsonConvert.DeserializeObject <Models.Simulation>(json);
var viewModel = new SimulationViewModel(Runtime)
{
Model = model,
DisplayName = model.Name
};
ActivateItem(viewModel);
}
catch (Exception ex)
{
Runtime.ShowError("Error opening file.", ex);
}
}
}
/// <summary>
/// <c>Index</c> (GET) - "webová" metoda pro vykreslení formuláře, kde se zadávají parametry simulace (URL: /Simulation nebo /Simulation/Index; HTTP GET).
/// </summary>
/// <remarks><para>ViewModel: SimulationViewModels.cs, třída SimulationViewModel.</para><para>Views: Simulation/Index.cshtml + _IndexPartial.cshtml.</para><para>Pouze pro přihlášené uživatele.</para></remarks>
//
// GET: Simulation
public ActionResult Index()
{
string resInitBE;
Initialize();
resInitBE = InitializeBackEnd(); // připojení k serveru s back-endem
if (resInitBE != null)
{
TempData.Add("error", resInitBE); // chybové hlášení pro přesměrování
return(RedirectToAction("Error", "Simulation"));
}
proxy_simulation.Close(); // odpojení od back-endu
for (int a = 0; a < algo.Count; a++) // konverze dvojteček na mezery v názvech algoritmů
{
algo[a].AlgorithmName = ConvertAlgorithmName(algo[a].AlgorithmName);
}
// seznam senátů přihlášeného uživatele:
Session["senates"] = null; // vyprázdnit data od minule (pokud již proběhla jiná simulace)
Session["equiv"] = null;
GetSenates(true); // explicitně vybereme data o senátech z DB (mohly nastat změny)
// hodnoty pro View:
ViewBag.alg_n = algo.Count;
ViewBag.sen_n = mySenates.Count;
ViewBag.Message = null;
SimulationViewModel SVM = new SimulationViewModel(mySenates, 1, algo, 1); // implic. hodnoty do formuláře
Session["senates"] = mySenates;
Session["equiv"] = SVM.IsEquiv;
ViewBag.senates = HtmlSenates(); // výpis vybraných senátů do HTML
return(View(SVM));
}
public ShellViewModel(SimulationViewModel simulationViewModel, ResultDisplayViewModel resultDisplayViewModel, IEventAggregator eventAggregator)
{
SimulationTab = new TabViewModel <SimulationViewModel>("Simulation", simulationViewModel);
ResultTab = new TabViewModel <ResultDisplayViewModel>("Results", resultDisplayViewModel);
eventAggregator.Subscribe(this);
ActivateItem(SimulationTab);
}
public MainWindow(SimulationViewModel sim)
{
InitializeComponent();
this.DataContext = sim;
this.simulation = sim;
Start();
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
string jsonStr;
using (var sr = new StreamReader(bindingContext.HttpContext.Request.Body))
{
jsonStr = sr.ReadToEnd();
}
if (string.IsNullOrEmpty(jsonStr))
{
return(Task.CompletedTask);
}
var json = JObject.Parse(jsonStr);
var vm = new SimulationViewModel();
vm.Trucks.AddRange(GetStandardTrucks((JArray)json["standardTrucks"]));
vm.Trucks.AddRange(GetCustomTrucks((JArray)json["customTrucks"]));
vm.Deliveries.AddRange(GetDeliveries((JArray)json["deliveries"]));
bindingContext.Result = ModelBindingResult.Success(vm);
return(Task.CompletedTask);
}
public void NewSimulation()
{
var viewModel = new SimulationViewModel(Runtime)
{
DisplayName = string.Format("Simulation {0:yyMMdd-HHmmss}", DateTime.Now)
};
ActivateItem(viewModel);
}
public MainWindow()
{
InitializeComponent();
var filename = @"G:\Projects\HumanGenome\Protein-PDBs\2mgo.pdb";
//var filename = @"G:\Projects\HumanGenome\AminoseqFiles\CFTR.aminoseq";
ApproximatePeptide approximatePeptide;
Peptide peptide;
if (filename.ToLowerInvariant().EndsWith(".pdb"))
{
peptide = PeptideLoader.Load(filename);
peptide.Molecule.MarkBackbone(peptide.MoleculeReference);
peptide.Molecule.PositionAtoms(peptide.MoleculeReference.FirstAtomId, peptide.MoleculeReference.LastAtomId);
approximatePeptide = ApproximatePeptideBuilder.FromPeptide(peptide);
}
else
{
approximatePeptide = ApproximatePeptideBuilder.FromSequence(new string('A', 8), 1);
//approximatePeptide = ApproximatePeptideBuilder.FromSequence(File.ReadAllLines(filename).Aggregate((a,b) => a + b));
approximatePeptide.UpdatePositions();
peptide = new ApproximatePeptideCompleter(approximatePeptide).GetFullPeptide();
}
var simulationSettings = new ApproximatePeptideSimulationSettings
{
TimeStep = 2.To(SIPrefix.Femto, Unit.Second),
SimulationTime = 10.To(SIPrefix.Nano, Unit.Second),
ResetAtomVelocityAfterEachTimestep = false,
UseCompactingForce = true,
UseRamachandranForce = true
};
var ramachadranDataDirectory = @"G:\Projects\HumanGenome\ramachadranDistributions";
var ramachandranPlotDistributionSource = new RamachandranPlotGradientDistributionFileSource(ramachadranDataDirectory);
//var ramachandranPlotDistributionSource = new RamachandranPlotDistributionFixedSource(
// new RamachandranPlotFixedDistribution(AminoAcidName.Alanine, new UnitPoint2D(-57.To(Unit.Degree), -47.To(Unit.Degree))));
//var simulationRunner = ApproximatePeptideFoldingSimulatorFactory.Create(
// approximatePeptide, simulationSettings, ramachadranDataDirectory);
var simulationRunner = new ApproximatePeptideFoldingSimulator(approximatePeptide,
simulationSettings,
new CompactingForceCalculator(),
new RamachandranForceCalculator(ramachandranPlotDistributionSource),
new BondForceCalculator());
//var simulationRunner = new MoleculeDynamicsSimulator(peptide.Molecule, new List<CustomAtomForce>(),
// new MoleculeDynamicsSimulationSettings
// {
// TimeStep = 2.To(SIPrefix.Femto, Unit.Second),
// SimulationTime = 10.To(SIPrefix.Pico, Unit.Second)
// });
MoleculeViewModel = new MoleculeViewModel();
//MoleculeViewModel.DrawAtoms(AtomExtractor.FromApproximatePeptide(approximatePeptide));
MoleculeViewModel.DrawAtoms(AtomExtractor.FromMolecule(peptide.Molecule));
simulationRunner.TimestepCompleted += (sender, args) => Application.Current.Dispatcher.BeginInvoke(new Action(() => MoleculeViewModel.DrawAtoms(args.Atoms)));
SimulationViewModel = new SimulationViewModel(simulationRunner);
}
private async Task <SimulationViewModel> GetViewModel()
{
var model = new SimulationViewModel
{
Companies = await _companyService.GetCompanies(),
StartDate = new DateTime(2006, 01, 01),
EndDate = DateTime.Today,
Strategies = await _strategyService.GetStrategies(CurrentUserId),
CompanyGroups = await _companyService.GetCompanyGroups()
};
return(model);
}
public IActionResult Simulate(SimulationViewModel simulationViewModel)
{
if (ModelState.IsValid)
{
_simulationRunner.Simulate(simulationViewModel);
}
ModelState.Clear();
simulationViewModel.UnitDescription1.IsAttacking = false;
simulationViewModel.UnitDescription2.IsAttacking = false;
return(View("Index", simulationViewModel));
}
private async Task <SimulationDto> ConvertViewModelToDto(SimulationViewModel viewModel)
{
return(new SimulationDto
{
StartDate = viewModel.StartDate,
EndDate = viewModel.EndDate,
SelectedStrategyId = viewModel.SelectedStrategyId,
SelectedCompanyIds = viewModel.AllCompanies ?
(await _companyService.GetCompanies()).Select(c => c.Id).ToList() :
viewModel.SelectedCompanyIds,
UserId = CurrentUserId,
Budget = viewModel.Budget,
HasMaximalTransactionLimit = viewModel.HasMaximalTransactonLimit,
MaximalBudgetPerTransaction = viewModel.MaximalBudgetPerTransaction,
HasMinimalTransactionLimit = viewModel.HasMinimalTransactionLimit,
MinimalBudgetPerTransaction = viewModel.MinimalBudgetPerTransaction
});
}
public async Task <ActionResult> RunSimulation(SimulationViewModel model)
{
if (!ModelState.IsValid)
{
model.Strategies = await _strategyService.GetStrategies(CurrentUserId);
model.Companies = await _companyService.GetCompanies();
model.CompanyGroups = await _companyService.GetCompanyGroups();
return(View(model));
}
var results = await _simulationService.RunSimulation(await ConvertViewModelToDto(model));
var resultsModel = await BuildSimulationResultViewModel(model, results);
return(View("Results", resultsModel));
}
public IActionResult Index()
{
#if DEBUG
var model = new SimulationViewModel()
{
Group1 = new GroupViewModel()
{
HitPoint = 100,
UnitCount = 20
},
Group2 = new GroupViewModel()
{
HitPoint = 100,
UnitCount = 20
},
UnitDescription1 = new UnitDescriptionViewModel()
{
Name = "HobGob",
ArmorClass = 17,
DamageBonus = 1,
DamageDice = Dice.D6,
HitBonus = 2,
HitPoint = 5
},
UnitDescription2 = new UnitDescriptionViewModel()
{
Name = "HobGob",
ArmorClass = 17,
DamageBonus = 1,
DamageDice = Dice.D6,
HitBonus = 2,
HitPoint = 5
},
};
return(View(model));
#else
return(View());
#endif
}
public void Setup()
{
_diceRoller = new Mock <IDiceRoller>();
_simulationModel = new SimulationViewModel()
{
Group1 = new GroupViewModel()
{
HitPoint = _unitCount1 * _hitPoint1,
UnitCount = _unitCount1
},
Group2 = new GroupViewModel()
{
HitPoint = _unitCount2 * _hitPoint2,
UnitCount = _unitCount2
},
UnitDescription1 = new UnitDescriptionViewModel()
{
Name = _name1,
ArmorClass = _armorClass1,
DamageBonus = _damageBonus1,
DamageDice = _damageDice1,
HitBonus = _hitBonus1,
HitPoint = _hitPoint1
},
UnitDescription2 = new UnitDescriptionViewModel()
{
Name = _name2,
ArmorClass = _armorClass2,
DamageBonus = _damageBonus2,
DamageDice = _damageDice2,
HitBonus = _hitBonus2,
HitPoint = _hitPoint2
},
};
_simulationRunner = new SimulationRunner(_diceRoller.Object);
}
public void Simulate(SimulationViewModel simulationViewModel)
{
var sb = new StringBuilder();
if (simulationViewModel.UnitDescription1.IsAttacking == true)
{
Simulate(simulationViewModel.UnitDescription1,
simulationViewModel.Group1,
simulationViewModel.UnitDescription2,
simulationViewModel.Group2,
sb);
}
else
{
Simulate(simulationViewModel.UnitDescription2,
simulationViewModel.Group2,
simulationViewModel.UnitDescription1,
simulationViewModel.Group1,
sb);
}
sb.AppendLine("----------------");
simulationViewModel.Description += sb.ToString();
}
void SetupSimulation(object sender, RoutedEventArgs e)
{
DrawingTool.SetupDrawingTool(ref fieldCanvas);
_simulation = new SimulationViewModel(ref fieldCanvas, 10);
}
public SimulatorView()
{
this.SVM = new SimulationViewModel();
this.InitializeComponent();
}
public ActionResult Index(int NumCases, int NumIters, int?[] algos) //([Bind(Include = "NumCases,NumIters,alg[]")] SimulationViewModel SVM)
{
int i = 1; // pro číslování chyb, které mohly nastat "mimo" během vyplňování formuláře
string resInitBE;
List <Senate> senatesToSim = new List <Senate>();
List <AlgorithmInfo> algInfo = new List <AlgorithmInfo>();
ViewBag.Error = null;
Initialize();
resInitBE = InitializeBackEnd(); // připojení k serveru s back-endem
if (resInitBE != null)
{
TempData.Add("error", resInitBE); // chybové hlášení pro přesměrování
return(RedirectToAction("Error", "Simulation"));
}
proxy_simulation.Close(); // odpojení od back-endu
for (int a = 0; a < algo.Count; a++) // konverze dvojteček na mezery v názvech algoritmů
{
algo[a].AlgorithmName = ConvertAlgorithmName(algo[a].AlgorithmName);
}
// seznam senátů přihlášeného uživatele (prioritně ze session, příp. z DB):
GetSenates(); // nastaví vlastnost "mySenates"
if (mySenates.Count == 0) // máme teď nějaké senáty?
{
ViewBag.Error += "Chyba" + i++.ToString() + ": v průběhu nastavování parametrů simulace došlo k odstranění senátů!<br>";
ViewBag.sen_n = 0;
}
if (NumCases < 1 || NumCases > 10000)
{
ViewBag.Error += "Chyba" + i++.ToString() + ": počet případů musí být číslo od 1 do 10000!<br>";
}
if (NumIters < 1 || NumIters > 10000)
{
ViewBag.Error += "Chyba" + i++.ToString() + ": počet iterací musí být číslo od 1 do 10000!<br>";
}
if (algo.Count == 0) // jsou algoritmy na serveru dostupné?
{
ViewBag.Error += "Chyba" + i++.ToString() + ": algoritmy pro simulaci nejsou dostupné! (Pravděpodobně došlo ke změně back-endu aplikace.)<br>";
ViewBag.alg_n = 0;
}
if (algo.Count > 0 && algos == null)
{
ViewBag.Error += "Chyba" + i++.ToString() + ": musíte vybrat alespoň jeden algoritmus!<br>";
}
// rozhodnutí o tom, zda se bude provádět simulace nebo se zpět zobrazí formulář (s chybou)
if (ViewBag.Error != null)
{
SimulationViewModel SVM = new SimulationViewModel(mySenates, NumCases, algo, NumIters);
ViewBag.senates = HtmlSenates();
return(View(SVM)); // byla chyba ve formuláři nebo někdo smazal senáty nebo na serveru nejsou algoritmy
}
else
{
for (int k = 0; k < algos.Length; k++)
{
// if (algos[k] == k)
algInfo.Add(algo[(int)algos[k]]); // do simulace půjdou jen vybrané algoritmy
}
foreach (WebSenateModels senat in mySenates)
{
senatesToSim.Add(new Senate(senat.SenateName, true, senat.Load, senat.Acases)); // senáty do simulace (jiná třída na back-endu)
}
TempData["Senates"] = senatesToSim;
TempData["NumCases"] = NumCases;
TempData["NumIters"] = NumIters;
TempData["AlgInfo"] = algInfo;
return(RedirectToAction("Run")); // přesměrování na výsledky
}
}
private async Task <SimulationResultViewModel> BuildSimulationResultViewModel(SimulationViewModel model, SimulationResultDto ret)
{
var ids = ret.CurrentCompanyQuantity.Keys.ToList();
ids.AddRange(ret.TransactionsLog.Select(item => item.CompanyId));
var companies = await _companyService.GetCompanies(ids);
return(new SimulationResultViewModel
{
CurrentCompanyQuantity = ret.CurrentCompanies,
Chart = new LineChartModel {
Name = "Budget", CompanyId = 0, Data = ret.BudgetHistory.Select(item => new[] { item.Key.ToJavaScriptTimeStamp(), item.Value }).ToList()
},
TransactionsLog = ret.TransactionsLog.Select(item => new SimulationTransaction
{
Date = item.Date,
Price = item.Price,
Action = item.Action,
BudgetAfter = item.BudgetAfter,
Quantity = item.Quantity,
Company = companies.FirstOrDefault(x => x.Id == item.CompanyId),
Profit = item.Profit
}).ToList(),
StartBudget = model.Budget,
TotalSimulationValue = ret.SimulationTotalValue,
PercentageProfit = ret.PercentageProfit,
AverageLossOnTransaction = ret.TransactionStatistics.AverageLossOnTransaction,
AverageGainOnTransaction = ret.TransactionStatistics.AverageGainOnTransaction,
MaximalSimulationValue = ret.MaximalSimulationValue,
MinimalSimulationValue = ret.MinimalSimulationValue,
SuccessTransactionPercentage = ret.TransactionStatistics.SuccessTransactionPercentage,
FailedTransactionPercentage = ret.TransactionStatistics.FailedTransactionPercentage,
KeepStrategyProfit = (double)ret.KeepStrategyProfit
});
}
public MainWindow()
{
InitializeComponent();
DataContext = new SimulationViewModel();
}
private void openSimulation(CMWrappedSimulation sim)
{
SimulationViewModel m = new SimulationViewModel(sim, _canCloseService);
Models.Add(m);
SelectedItem = m;
}
