public static SimulationModel Initialize(this CpuZ80 cpu, byte[] program, byte[] ioSpace = null)
{
new InstructionLogger(cpu);
var model = new SimulationModel();
model.Cpu = cpu;
model.Cpu.Name = "U1";
model.ClockGen = new SignalGenerator();
model.ClockGen.Output.ConnectTo(model.Cpu.Clock, "Clock");
model.Memory = MemoryTestExtensions.NewRam(program);
model.Memory.Name = "U2";
model.Cpu.MemoryRequest.ConnectTo(model.Memory.ChipEnable, "MREQ");
model.Cpu.Read.ConnectTo(model.Memory.OutputEnable, "RD");
model.Cpu.Write.ConnectTo(model.Memory.WriteEnable, "WE");
model.Address = cpu.Address.ConnectTo(model.Memory.Address, "Address");
model.Data = cpu.Data.ConnectTo(model.Memory.Data.Slave, "Data");
new MemoryLogger <BusData16, BusData8>().Attach(model.Memory);
if (ioSpace != null)
{
model.IoSpace = MemoryTestExtensions.NewRam(ioSpace);
model.IoSpace.Name = "U3";
model.Cpu.IoRequest.ConnectTo(model.IoSpace.ChipEnable, "IORQ");
model.IoSpace.OutputEnable.ConnectTo(model.Cpu.Read.DigitalSignal);
model.IoSpace.WriteEnable.ConnectTo(model.Cpu.Write.DigitalSignal);
model.IoSpace.Address.ConnectTo(cpu.Address.Bus);
model.IoSpace.Data.ConnectTo(cpu.Data.Bus);
new MemoryLogger <BusData16, BusData8>("IO").Attach(model.IoSpace);
}
model.LogicAnalyzer = new LogicAnalyzer();
model.LogicAnalyzer.Clock.ConnectTo(model.ClockGen.Output.DigitalSignal);
model.Cpu.MachineCycle1.ConnectTo(model.LogicAnalyzer.AddInput("M1"));
model.Cpu.Refresh.ConnectTo(model.LogicAnalyzer.AddInput("RFSH"));
model.LogicAnalyzer.ConnectInput(model.Cpu.MemoryRequest.DigitalSignal);
if (ioSpace != null)
{
model.LogicAnalyzer.ConnectInput(model.Cpu.IoRequest.DigitalSignal);
}
model.LogicAnalyzer.ConnectInput(model.Cpu.Read.DigitalSignal);
model.LogicAnalyzer.ConnectInput(model.Cpu.Write.DigitalSignal);
model.LogicAnalyzer.ConnectInput(model.Address);
model.LogicAnalyzer.ConnectInput(model.Data);
model.LogicAnalyzer.Start();
return(model);
}
public static void Lab3()
{
const double creatorDelay = 1.0f;
const double processDelay = 2.5f;
const int processMaxQueue = 5;
var creator = new Creator(creatorDelay);
//var process1 = new Process("process1", processDelay, processMaxQueue, 2);
//var process2 = new Process("process2", processDelay * 3, processMaxQueue, 2);
//var process3 = new Process("process3", processDelay * 7, processMaxQueue, 1);
//var process4 = new Process("process4", processDelay * 10, processMaxQueue, 1);
var process1 = new Process("process1", processDelay, processMaxQueue, 1);
var process2 = new Process("process2", processDelay, processMaxQueue, 1);
var process3 = new Process("process3", processDelay, processMaxQueue, 1);
var process4 = new Process("process4", processDelay, processMaxQueue, 1);
var despose1 = new Despose("despose1");
var despose2 = new Despose("despose2");
var branch1 = new Branch(new List <(Element element, int weight)> {
(process1, 4), (despose2, 1)
});
var branch2 = new Branch(new List <(Element element, int weight)> {
(process2, 3), (process3, 2)
});
creator.nextElement = branch1;
process1.nextElement = branch2;
process2.nextElement = despose1;
process3.nextElement = process4;
process4.nextElement = despose2;
var model = new SimulationModel(new List <Element>
{
creator,
process1,
process2,
process3,
process4,
despose1,
despose2
},
SimulateTime);
model.Simulate(false);
model.PrintResultStatistic();
}
/// <summary>
/// Get Project, Cost related data from dynamic table Report_x_y, x = Network Id, y = Simulation Id
/// </summary>
/// <param name="simulationModel"></param>
/// <param name="dbContext"></param>
/// <param name="simulationYears"></param>
/// <returns></returns>
public IQueryable <ReportProjectCost> GetReportData(SimulationModel simulationModel, BridgeCareContext dbContext, List <int> simulationYears)
{
IQueryable <ReportProjectCost> rawQueryForReportData = null;
var years = string.Join(",", simulationYears);
var listOfBudgets = dbContext.CriteriaDrivenBudgets.Where(y => y.SIMULATIONID == simulationModel.simulationId)
.Select(cri => "'" + cri.BUDGET_NAME + "'").ToList();
var budgets = string.Join(",", listOfBudgets);
var selectReportStatement = $"SELECT SECTIONID, TREATMENT, COST_, YEARS FROM REPORT_{simulationModel.networkId}_{simulationModel.simulationId} " +
$"WITH (NOLOCK) WHERE BUDGET IN (" + budgets + ") AND YEARS IN (" + years + ")";
rawQueryForReportData = dbContext.Database.SqlQuery <ReportProjectCost>(selectReportStatement).AsQueryable();
return(rawQueryForReportData);
}
public void TestInitialize()
{
var builder = CreateModelBuilder(HelloWorldBin);
var ioAddress = new BusTap(8);
ioAddress.ConnectTo(builder.Model.Address);
builder.AddOutputPort(ioAddress, builder.Model.Data, 0x20, "ConsoleOut");
builder.AddLogicAnalyzer(false);
builder.Model.LogicAnalyzer.ConnectInput(
builder.Model.OutputPorts.Values.First().PortEnable.DigitalSignal);
builder.Model.LogicAnalyzer.Start();
_model = builder.Model;
}
private static void ApplyAddedRegions(SimulationModel model, ModelResponse diff)
{
for (int i = 0; i < diff.AddedRegionsLength; i++)
{
Region addedRegion = diff.GetAddedRegions(i);
Vector3 lower = addedRegion.Position.ToVector3();
Vector3 size = addedRegion.Size.ToVector3();
Vector3 position = lower + size / 2;
model.Regions[addedRegion.Index] = new RegionModel(addedRegion.Index, addedRegion.Name, addedRegion.Type,
position, size);
}
}
private void ApplyObservers(SimulationModel model, ModelResponse diff)
{
for (int i = 0; i < diff.ObserverResultsLength; i++)
{
ObserverResult observerData = diff.GetObserverResults(i);
NeuronId neuronId = observerData.Observer.NeuronId;
var definition = new ObserverDefinition(neuronId.Neuron, neuronId.Region, observerData.Observer.Type);
model.Observers[definition] = new ObserverData(
CopyObserverArrayData(observerData.MetadataLength, (n => observerData.GetMetadata(n))),
observerData.GetPlainDataBytes()?.ToArray(),
CopyObserverArrayData(observerData.FloatDataLength, (n => observerData.GetFloatData(n))));
}
}
public SimulationUI(SimulationModel model, bool isNewProject)
{
InitializeComponent();
this.Model = model;
this.SimulationEventHandler = new SimulationEventHandler(this);
this.ConnectionCreator = new ConnectionCreator(this.Model, this.target);
//this.StartDate.SelectedDate = DateTime.Now;
//this.StartDate.SelectedDate = DateTime.Now.AddMonths(1);
if (!isNewProject)
{
PrintProject();
}
}
private void ApplyRemovedRegions(SimulationModel model, ModelResponse diff)
{
for (int i = 0; i < diff.RemovedRegionsLength; i++)
{
uint regionIndex = diff.GetRemovedRegions(i);
if (!model.Regions.ContainsKey(regionIndex))
{
Log.Warn("Cannot remove region with index {regionIndex}, region not found", regionIndex);
continue;
}
model.Regions.Remove(regionIndex);
}
}
public async Task <IHttpActionResult> RunSimulation([FromBody] SimulationModel model)
{
var result = await Task.Factory.StartNew(() => repo.RunSimulation(model));
if (result.IsCompleted)
{
repo.SetSimulationLastRunDate(model.SimulationId, db);
}
else
{
return(InternalServerError(new Exception(result.Result)));
}
return(Ok());
}
private void ApplyRemovedSynapses(SimulationModel model, ModelResponse diff)
{
for (int i = 0; i < diff.RemovedSynapsesLength; i++)
{
var synapse = diff.GetRemovedSynapses(i);
ProcessSynapse(model, synapse, "remove", (fromRegion, fromNeuron, toRegion, toNeuron) =>
{
var synapseModel = fromNeuron.Outputs[toNeuron.Index];
fromNeuron.Outputs.Remove(toNeuron.Index);
fromRegion.Synapses.Remove(synapseModel);
toNeuron.Inputs.Remove(fromNeuron.Index);
});
}
}
private void ProcessConnector(SimulationModel model, uint regionIndex, string connectorName, string actionName, Action <RegionModel> action)
{
RegionModel targetRegionModel = model.Regions[regionIndex];
if (targetRegionModel == null)
{
Log.Warn(
"Cannot " + actionName + " connector {connectorName}, region with index {regionIndex} was not found",
connectorName,
regionIndex);
return;
}
action(targetRegionModel);
}
/// <summary>
/// Bsaic constructor
/// </summary>
/// <param name="type">Type of health care control unit</param>
/// <param name="name">String identifier of control unit</param>
/// <param name="parentControlUnit">Parent control unit if this is not the root control unit of the control tree</param>
/// <param name="parentSimulationModel">Parent simulation model</param>
/// <param name="inputData">Input data for the department</param>
public ControlUnitHealthCareDepartment(ControlUnitType type,
string name,
ControlUnit parentControlUnit,
SimulationModel parentSimulationModel,
IInputHealthCareDepartment inputData)
: base(type,
name,
parentControlUnit,
parentSimulationModel)
{
_childOrganizationalUnits = new ControlUnitOrganizationalUnit[] { };
_organizationalUnitsPerName = new Dictionary <string, ControlUnitOrganizationalUnit>();
_inputData = inputData;
} // end of ControlUnitHealthCare
public string[] InvestmentData(SimulationModel data)
{
var db = new BridgeCareContext();
var budgetOrder = db.Investments.Where(_ => _.SIMULATIONID == data.SimulationId)
.Select(_ => _.BUDGETORDER)
.First();
if (string.IsNullOrEmpty(budgetOrder))
{
throw new Exception("Budget types not found in Investments table for the id : " + data.SimulationId);
}
var budgetTypes = budgetOrder.Split(',');
return(budgetTypes);
}
public HttpResponseMessage ExportCommittedProjects([FromBody] SimulationModel model)
{
var response = Request.CreateResponse();
var userInformation = ESECSecurity.GetUserInformation(Request);
byte[] byteArray = repo.ExportCommittedProjects(model.simulationId, model.networkId, db, userInformation);
response.Content = new ByteArrayContent(byteArray);
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = "CommittedProjects.xlsx"
};
return(response);
//return Ok(response);
}
public void TestInitialize()
{
var builder = CreateModelBuilder(EchoBin);
//var ioAddress = new BusTap(8);
//ioAddress.ConnectTo(builder.Model.Address);
var ioAddress = builder.Model.Address;
var outputPort = builder.AddOutputPort(ioAddress, builder.Model.Data, 0x20, "ConsoleOut");
var inputPort = builder.AddInputPort(ioAddress, builder.Model.Data, 0x20, "ConsoleIn");
inputPort.DataBuffer.Write(Encoding.ASCII.GetBytes(Message));
builder.AddLogicAnalyzer();
LogExecutionPath(builder.Model);
_model = builder.Model;
}
public async Task <IHttpActionResult> RunSimulation([FromBody] SimulationModel model)
{
UserInformationModel userInformation = ESECSecurity.GetUserInformation(Request);
var result = await Task.Factory.StartNew(() => SimulationRunMethods[userInformation.Role](model, userInformation));
if (result.IsCompleted)
{
repo.SetSimulationLastRunDate(model.simulationId, db);
}
else
{
return(InternalServerError(new Exception(result.Result)));
}
return(Ok());
}
/// <summary>
/// Generate Bridge Summary Report for given simulation details.
/// </summary>
/// <param name="simulationModel"></param>
/// <returns></returns>
public byte[] GenerateExcelReport(SimulationModel simulationModel)
{
// Get data
var simulationId = simulationModel.SimulationId;
var simulationYearsModel = commonSummaryReportData.GetSimulationYearsData(simulationId);
var simulationYears = simulationYearsModel.Years;
var simulationYearsCount = simulationYears.Count;
var dbContext = new BridgeCareContext();
using (ExcelPackage excelPackage = new ExcelPackage(new System.IO.FileInfo("SummaryReport.xlsx")))
{
// Bridge Data tab
var bridgeDataModels = new List <BridgeDataModel>();
var worksheet = excelPackage.Workbook.Worksheets.Add("Bridge Data");
var workSummaryModel = summaryReportBridgeData.Fill(worksheet, simulationModel, simulationYears, dbContext);
// Bridge Work Summary tab
var bridgeWorkSummaryWorkSheet = excelPackage.Workbook.Worksheets.Add("Bridge Work Summary");
var chartRowsModel = bridgeWorkSummary.Fill(bridgeWorkSummaryWorkSheet, workSummaryModel.SimulationDataModels, workSummaryModel.BridgeDataModels, simulationYears, dbContext, simulationId);
// NHS Condition Bridge Cnt tab
worksheet = excelPackage.Workbook.Worksheets.Add("NHS Condition Bridge Cnt");
nhsConditionChart.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.NHSBridgeCountPercentSectionYearsRow, Properties.Resources.NHSConditionByBridgeCountLLCC, simulationYearsCount);
// NHS Condition DA tab
worksheet = excelPackage.Workbook.Worksheets.Add("NHS Condition DA");
nhsConditionChart.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.NHSBridgeDeckAreaPercentSectionYearsRow, Properties.Resources.NHSConditionByDeckAreaLLCC, simulationYearsCount);
// Condition Bridge Cnt tab
worksheet = excelPackage.Workbook.Worksheets.Add("Condition Bridge Cnt");
conditionBridgeCount.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.TotalBridgeCountSectionYearsRow, simulationYearsCount);
// Condition DA tab
worksheet = excelPackage.Workbook.Worksheets.Add("Condition DA");
conditionDeckArea.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.TotalDeckAreaSectionYearsRow, simulationYearsCount);
// Poor Bridge Cnt tab
worksheet = excelPackage.Workbook.Worksheets.Add("Poor Bridge Cnt");
poorBridgeCount.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.TotalPoorBridgesCountSectionYearsRow, simulationYearsCount);
// Poor Bridge DA tab
worksheet = excelPackage.Workbook.Worksheets.Add("Poor Bridge DA");
poorBridgeDeckArea.Fill(worksheet, bridgeWorkSummaryWorkSheet, chartRowsModel.TotalPoorBridgesDeckAreaSectionYearsRow, simulationYearsCount);
return(excelPackage.GetAsByteArray());
}
}
protected void RunTest(SimulationModel model, ushort endAddress = EndOfProgram)
{
bool stop = false;
model.Cpu.InstructionExecuted += (s, e) => {
stop = e.Opcode.Address == endAddress ||
model.Cpu.Halt.Level == Zim80.DigitalLevel.Low;
};
model.ClockGen.SquareWave((c) => stop);
if (model.LogicAnalyzer != null)
{
model.LogicAnalyzer.Stop();
Console.WriteLine(model.LogicAnalyzer.ToWaveJson());
}
}
/// <summary>
/// Runs a single simulation with passed parameters and tests it
/// </summary>
/// <param name="clusterId">Id of the cluster used in simulation</param>
/// <param name="mapId">Id of the map used in simulation</param>
/// <param name="vehicleIds">Ids of the vehicles used in simulation</param>
/// <param name="interactive">Ids of the vehicles used in simulation</param>
/// <returns>IEnumerator</returns>
private IEnumerator RunSimulation(long clusterId, long mapId, long[] vehicleIds, bool interactive)
{
var vehicles = new ConnectionModel[vehicleIds.Length];
for (var i = 0; i < vehicleIds.Length; i++)
{
var vehicleId = vehicleIds[i];
vehicles[i] = new ConnectionModel()
{
Connection = "",
Id = 0,
Vehicle = vehicleId,
Simulation = 0
};
}
var simulationModel = new SimulationModel()
{
Cluster = clusterId,
Headless = false,
Interactive = interactive,
Vehicles = vehicles,
Map = mapId,
ApiOnly = false,
UsePedestrians = true,
UseTraffic = true
};
yield return(RunSimulation(simulationModel));
yield return(WaitForClients());
yield return(new WaitForSecondsRealtime(1.0f));
if (interactive)
{
SimulatorManager.Instance.UIManager.PauseButtonOnClick();
}
yield return(PerformPingsTests(10));
Loader.StopAsync();
while (Loader.Instance.CurrentSimulation != null)
{
yield return(null);
}
}
private void ApplyRepositionedRegions(SimulationModel model, ModelResponse diff)
{
for (int i = 0; i < diff.RepositionedRegionsLength; i++)
{
Region repositionedRegion = diff.GetRepositionedRegions(i);
RegionModel regionModel;
if (!model.Regions.TryGetModel(repositionedRegion.Index, out regionModel))
{
Log.Warn("Could not reposition region {region}, not found", repositionedRegion.Index);
continue;
}
regionModel.Position = repositionedRegion.Position.ToVector3();
regionModel.Size = repositionedRegion.Size.ToVector3();
}
}
} // end of ActionsAfterFinishingSimulationRun
#endregion
#region NonVisualizationLoop
public void NonVisualizationLoop()
{
DateTime originalTimerTime = CurrentTime;
while (BackgroundWorkerNonVisualization.CancellationPending == false &&
!SimulationModel.StopSimulation(CurrentTime))
{
DateTime newTime;
bool modelRunning = SimulationEngine.RunSingleStepSimulationModel(_currentTime, out newTime);
if (modelRunning)
{
BackgroundWorkerNonVisualization.ReportProgress(SimulationEngine.SimulationModel.GetSimulationProgress(newTime));
_currentTime = newTime;
} // end if
} // end while
} // end of
public void SetSimulationModel(SimulationModel value)
{
lock (monitor) {
SimulationModel oldValue = simModel;
if (value != oldValue)
{
simModel = value;
if (oldValue != null)
{
oldValue.SimulationModelModifiedEvent -= SimulationUpdated;
}
if (value != null)
{
value.SimulationModelModifiedEvent += SimulationUpdated;
}
}
}
}
public void Start()
{
Stop();
m_requestModelEvent = new AutoResetEvent(false);
m_modelReadEvent = new AutoResetEvent(false);
m_cancellation = new CancellationTokenSource();
m_getFullModel = true;
Task task = RepeatGetModelAsync(m_cancellation);
m_currentModel = new SimulationModel();
m_previousModel = new SimulationModel();
// The empty model is what we have at the beginning.
m_isNewModelReady = true;
}
//--------------------------------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------------------------------
#region Constructor
/// <summary>
/// Constructor that sets string representations for entities for logging purposes
/// </summary>
/// <param name="parentSimulationModel">Simulation model that is executed</param>
public BaseLoggingEngine(SimulationModel parentSimulationModel)
{
_parentSimulationModel = parentSimulationModel;
_simulationResult = new List <SimulationState>();
_defaultEntityStringReps = new Dictionary <Type, string>();
_defaultEntityStringReps.Add(typeof(EntityDoctor), "EntityDoctor");
_defaultEntityStringReps.Add(typeof(EntityPatient), "EntityPatient");
_defaultEntityStringReps.Add(typeof(EntityNurse), "EntityNurse");
_defaultEntityStringReps.Add(typeof(EntityTreatmentFacility), "EntitiyTreatmentFacility");
_defaultEntityStringReps.Add(typeof(EntityWaitingArea), "EntityWaitingArea");
_defaultEntityStringReps.Add(typeof(EntityMultiplePatientTreatmentFacility), "EntityMultiplePatientTreatmentFacility");
_defaultEntityStringReps.Add(typeof(EntityWaitingListSchedule), "EntityWaitingListSchedule");
_defaultEntityStringReps.Add(typeof(EntityPath), "EntityPath");
//_defaultEntityStringReps.Add(typeof(EntityBreastCancerPatient), "EntityBreastCancerPatient");
_defaultEntityStringReps.Add(typeof(EntitySingleBookingModelWaitingList), "EntitySingleBookingModelWaitingList");
} // end of BaseLoggingEngine
} // end of StopSimulation
#endregion
#region PlaySimulationTick
public void PlaySimulationTick(object sender, EventArgs e)
{
// security call in case the timer ticks bfore
// it disabled by stop simulation
if (!VisualizationEnabled)
{
return;
}
DateTime timeOfCall;
if (TickCallIsSimulationCall)
{
timeOfCall = CurrentTime;
DateTime newTime;
bool modelRunning = SimulationEngine.RunSingleStepSimulationModel(CurrentTime, out newTime);
// in case end of model is reached the simulation is stopped
if (!modelRunning)
{
StopSimulation(false);
return;
} // end if
SimulationDisplayClock.SetDateTime(CurrentTime);
SimulationModel.SimulationDrawingEngine.CreateModelVisualization(CurrentTime, SimulationModel, SimulationEngine.CurrentlyTriggeredEvents);
ProgressBarSimulationProgress.Value = SimulationModel.GetSimulationProgress(CurrentTime);
_nextSimulationTime = newTime;
_currentTime = newTime;
}
else
{
timeOfCall = NextTimerTime;
SimulationDisplayClock.SetDateTime(NextTimerTime);
SimulationModel.SimulationDrawingEngine.CreateModelVisualization(NextTimerTime, SimulationModel, new List <Event>());
ProgressBarSimulationProgress.Value = SimulationModel.GetSimulationProgress(CurrentTime);
_nextTimerTime += ConstantTimerStep;
} // end if
SimulationTimer.Interval = TimeSpan.FromMilliseconds(Math.Max((int)(((NextTime - timeOfCall).Ticks / ConstantTimerStep.Ticks) * SimulationSpeed), 1));
} // end of PlaySimulationTick
public SimulationModel Get(Project project)
{
SimulationModel model = new SimulationModel();
SupplierBroker supplierBroker = new SupplierBroker();
ShopBroker shopBroker = new ShopBroker();
BuyerBroker buyerBroker = new BuyerBroker();
ConnectionBroker connectionBroker = new ConnectionBroker();
model.Project = project;
using (IDbConnection connection = new ConnectionProvider().GetConnection(true))
{
model.Buyers = buyerBroker.GetAllFromProject(connection, model.Project.Id).ToList();
model.Shops = shopBroker.GetAllFromProject(connection, model.Project.Id).ToList();
model.Suppliers = supplierBroker.GetAllFromProject(connection, model.Project.Id).ToList();
model.Connections = connectionBroker.GetAllFromProject(connection, model.Project.Id).ToList();
}
foreach (Connection conn in model.Connections)
{
switch (conn.ConnectionType)
{
case DataModel.EnumTypes.ConnectionTypes.ShopToBuyer:
conn.ActorA = model.Shops.Find(x => x.Id == conn.ActorAId);
conn.ActorB = model.Buyers.Find(x => x.Id == conn.ActorBId);
break;
case DataModel.EnumTypes.ConnectionTypes.ShopToShop:
conn.ActorA = model.Shops.Find(x => x.Id == conn.ActorAId);
conn.ActorB = model.Shops.Find(x => x.Id == conn.ActorBId);
break;
case DataModel.EnumTypes.ConnectionTypes.SupplierToShop:
conn.ActorA = model.Suppliers.Find(x => x.Id == conn.ActorAId);
conn.ActorB = model.Shops.Find(x => x.Id == conn.ActorBId);
break;
default:
break;
}
}
return(model);
}
public void ShowNewProjectDialog()
{
var w = new NewProjectWindow();
if (w.ShowDialog() == true)
{
Project project = w.Project;
if (project != null)
{
Model = new SimulationModel(project);
SimulationUI ui = new SimulationUI(Model, true);
ui.InitializeComponent();
simulationUI.Content = ui;
SetTitle(project.Name);
MnuSave.IsEnabled = true;
MnuSaveAs.IsEnabled = true;
}
}
}
protected void RunTest(SimulationModel model, params ushort[] endAddresses)
{
var stopList = new List <ushort>(endAddresses);
bool stop = false;
model.Cpu.InstructionExecuted += (s, e) => {
stop = stopList.Contains(e.Opcode.Address) ||
model.Cpu.Halt.Level == DigitalLevel.Low;
};
model.ClockGen.SquareWave((c) => stop);
if (model.LogicAnalyzer != null)
{
model.LogicAnalyzer.Stop();
Console.WriteLine(model.LogicAnalyzer.ToWaveJson());
}
}
public Simulations(Dictionary <string, string> megagridAddressDictionary, Digest digest)
{
foreach (KeyValuePair <string, string> kvp in megagridAddressDictionary)
{
if (!simulations.ContainsKey(kvp.Value.Trim()))
{
SimulationModel simModel = new SimulationModel();
CompiledCode code = digest.FindByName(kvp.Value);
Grid grid = Pivot.ToGrid(new Code(code.minimalCode));
RectList rects = Pivot.ToRects(grid);
simModel.grid = grid;
RasterLib.RasterApi.BuildCircuit(rects, true);
simModel.rects = rects;
simModel.Build();
simulations.Add(kvp.Value.Trim(), simModel);
}
}
}
internal void Fill(ExcelWorksheet targetReport, SimulationModel model, int[] totalYears)
{
var targetResults = repo.GetTarget(model, totalYears, db);
if (targetResults.Targets.Rows.Count > 0)
{
targetReport.Cells[2, 3, targetResults.Targets.Rows.Count + 1, targetResults.Targets.Columns.Count]
.Style.Fill.PatternType = ExcelFillStyle.Solid;
targetReport.Cells[2, 3, targetResults.Targets.Rows.Count + 1, targetResults.Targets.Columns.Count]
.Style.Fill.BackgroundColor.SetColor(Color.LightCoral);
}
foreach (var(row, column) in targetResults.Address.Cells)
{
targetReport.Cells[row, column + 1].Style.Fill.BackgroundColor.SetColor(Color.LightGreen);
}
targetReport.Cells.LoadFromDataTable(targetResults.Targets, true);
targetReport.Cells.AutoFitColumns();
}