private int UpdateKillsCount(int currentCount, FightResult result, SimulationType type)
{
int count = currentCount;
switch (type)
{
case SimulationType.MinimalDamage:
count -= result.KilledMin;
break;
case SimulationType.MaximalDamage:
count -= result.KilledMax;
break;
case SimulationType.AverageDamage:
count -= result.KilledAvg;
break;
default:
break;
}
if (count < 0)
{
count = 0;
}
return(count);
}
private static void ConsolidateMachineWorkload(MasterDBContext context, int simulationId,
SimulationType simType)
{
var kpis = context.Kpis.Where(x => x.SimulationConfigurationId == simulationId &&
x.SimulationType == simType &&
x.KpiType == KpiType.MachineUtilization &&
x.IsKpi && x.IsFinal).ToList();
var machines = kpis.Select(x => x.Name).Distinct();
var summary = (from machine in machines
let machineValues = kpis.Where(x => x.Name == machine).ToList()
select new Kpi()
{
Name = machine,
Value = Math.Round(machineValues.Sum(x => x.Value) / machineValues.Count, 2),
ValueMin = 0,
ValueMax = 0,
IsKpi = true,
KpiType = KpiType.MachineUtilization,
SimulationConfigurationId = simulationId,
SimulationType = simType,
SimulationNumber = 0,
IsFinal = true
}).ToList();
context.Kpis.AddRange(summary);
context.SaveChanges();
}
internal Default(IConfirmation jobConfirmation, SimulationType simulationType = SimulationType.None)
: base(childMaker: null, simulationType: simulationType)
{
_jobConfirmation = jobConfirmation;
_resourceDistinctResourceStates = new Dictionary <IActorRef, StateHandle>();
_dissolveRequested = false;
}
public int GetSimulationNumber(int simulationConfigurationId, SimulationType simType)
{
var anySim = SimulationWorkschedules
.Where(x => x.SimulationType == simType && x.SimulationConfigurationId == simulationConfigurationId);
return(anySim.Any() ? anySim.Max(x => x.SimulationNumber) + 1 : 1);
}
public void SetView(SimulationType type)
{
if (_currentSimulationType == type)
{
return;
}
_currentSimulationType = type;
switch (type)
{
case SimulationType.TwoDimensional:
transform.position = BaseTransform.position;
transform.rotation = BaseTransform.rotation;
_camera.orthographic = true;
_camera.farClipPlane = 999999;
break;
case SimulationType.ThreeDimensional:
transform.position = Transform3D.position;
transform.rotation = Transform3D.rotation;
_camera.orthographic = false;
_camera.farClipPlane = 60000;
break;
}
}
internal GuardianBehaviour(Func <IUntypedActorContext, AgentSetup, IActorRef> childMaker,
SimulationType simulationType, IMessageHub messageHub)
: base(childMaker: childMaker
, simulationType: simulationType)
{
_messageHub = messageHub;
}
public static IBehaviour Get(M_Stock stockElement, SimulationType simType)
{
switch (simType)
{
default:
return(Default(stockElement: stockElement));
}
}
protected Behaviour(Func <IUntypedActorContext, AgentSetup, IActorRef> childMaker = null
, object obj = null
, SimulationType simulationType = SimulationType.Default)
{
ChildMaker = childMaker;
Object = obj;
SimulationType = simulationType;
}
public static IBehaviour Get(SimulationType simType)
{
switch (simType)
{
default:
return(Default());
}
}
public virtual void Read(PackFileDeserializer des, BinaryReaderEx br)
{
m_bodyBufferCapacity = br.ReadInt32();
br.ReadUInt64();
br.ReadUInt32();
m_motionBufferCapacity = br.ReadInt32();
br.ReadUInt64();
br.ReadUInt32();
m_constraintBufferCapacity = br.ReadInt32();
br.ReadUInt64();
br.ReadUInt64();
br.ReadUInt32();
m_materialLibrary = des.ReadClassPointer <hknpMaterialLibrary>(br);
m_motionPropertiesLibrary = des.ReadClassPointer <hknpMotionPropertiesLibrary>(br);
m_qualityLibrary = des.ReadClassPointer <hknpBodyQualityLibrary>(br);
m_simulationType = (SimulationType)br.ReadByte();
br.ReadUInt16();
br.ReadByte();
m_numSplitterCells = br.ReadInt32();
br.ReadUInt64();
m_gravity = des.ReadVector4(br);
m_enableContactCaching = br.ReadBoolean();
m_mergeEventsBeforeDispatch = br.ReadBoolean();
m_leavingBroadPhaseBehavior = (LeavingBroadPhaseBehavior)br.ReadByte();
br.ReadUInt64();
br.ReadUInt32();
br.ReadByte();
m_broadPhaseAabb = new hkAabb();
m_broadPhaseAabb.Read(des, br);
m_broadPhaseConfig = des.ReadClassPointer <hknpBroadPhaseConfig>(br);
m_collisionFilter = des.ReadClassPointer <hknpCollisionFilter>(br);
m_shapeTagCodec = des.ReadClassPointer <hknpShapeTagCodec>(br);
m_collisionTolerance = br.ReadSingle();
m_relativeCollisionAccuracy = br.ReadSingle();
m_enableWeldingForDefaultObjects = br.ReadBoolean();
m_enableWeldingForCriticalObjects = br.ReadBoolean();
br.ReadUInt16();
m_solverTau = br.ReadSingle();
m_solverDamp = br.ReadSingle();
m_solverIterations = br.ReadInt32();
m_solverMicrosteps = br.ReadInt32();
m_defaultSolverTimestep = br.ReadSingle();
m_maxApproachSpeedForHighQualitySolver = br.ReadSingle();
m_enableDeactivation = br.ReadBoolean();
m_deleteCachesOnDeactivation = br.ReadBoolean();
br.ReadUInt16();
m_largeIslandSize = br.ReadInt32();
m_enableSolverDynamicScheduling = br.ReadBoolean();
br.ReadUInt16();
br.ReadByte();
m_contactSolverType = br.ReadInt32();
m_unitScale = br.ReadSingle();
m_applyUnitScaleToStaticConstants = br.ReadBoolean();
br.ReadUInt64();
br.ReadUInt32();
br.ReadUInt16();
br.ReadByte();
}
/// <summary>
/// calls all implemented Kpi-calculating methods
/// </summary>
/// <param name="context"></param>
/// <param name="simulationId"></param>
/// <param name="simulationType"></param>
/// <param name="simulationNumber"></param>
/// <param name="final"></param>
/// <param name="time"></param>
public static void CalculateAllKpis(ProductionDomainContext context, int simulationId,
SimulationType simulationType, int simulationNumber, bool final, int time = 0)
{
CalculateLeadTime(context, simulationId, simulationType, simulationNumber, final, time);
CalculateMachineUtilization(context, simulationId, simulationType, simulationNumber, final, time);
CalculateTimeliness(context, simulationId, simulationType, simulationNumber, final, time);
ArticleStockEvolution(context, simulationId, simulationType, simulationNumber, final, time);
CalculateLayTimes(context, simulationId, simulationType, simulationNumber, final, time);
}
/// <summary>
/// Execute simulation with reference implementation to checkpoint and compare with expected state
/// </summary>
/// <param name="sim">Simulation</param>
/// <param name="simType">Simulation type</param>
/// <param name="stateName">State name</param>
public static void DoStepsReferenceToCheckpointAndAssert(SimulationBase sim, SimulationType simType, string stateName)
{
for (int i = 0; i < StepCountToCheckpoint; i++)
{
sim.DoStepReference();
}
AssertSimulationWithState(sim, simType, stateName);
}
public static string CampaignSimulation(long customerId, long campaignId,
SimulationType type, SimulationModificationMethod modificationMethod,
DateTime startDate, DateTime endDate)
{
return($"customers/{customerId}/campaignSimulations/{campaignId}~" +
$"{ProtobufUtilities.GetOriginalEnumFieldName(type)}~" +
$"{ProtobufUtilities.GetOriginalEnumFieldName(modificationMethod)}~" +
$"{startDate:yyyy-MM-dd}~{endDate:yyyy-MM-dd}");
}
// Constructor for Unity simulation
public unsafe Contacts(BlockStream contactStream, Scheduler.SolverSchedulerInfo ssi)
{
m_SimulationType = SimulationType.UnityPhysics;
m_ContactWriter = new BlockStream.Writer(contactStream);
m_NumContactsAdded = 0;
m_ContactStream = contactStream;
m_PhaseInfo = ssi.PhaseInfo;
m_MaxNumWorkItems = ssi.NumWorkItems;
}
public MainViewModel()
{
// try to change this value to TimeSimulation
SimulationType = SimulationType.Waves;
// SimulationType = SimulationType.TimeSimulation;
Function = (t, x, a) => Math.Cos(t * a) * (x == 0 ? 1 : Math.Sin(x * a) / x);
SetupModel();
}
public static string AdGroupCriterionSimulation(long customerId, long adGroupId,
long criterionId, SimulationType type, SimulationModificationMethod modificationMethod,
DateTime startDate, DateTime endDate)
{
return($"customers/{customerId}/adGroupCriterionSimulations/{adGroupId}~" +
$"{criterionId}~{ProtobufUtilities.GetOriginalEnumFieldName(type)}~" +
$"{ProtobufUtilities.GetOriginalEnumFieldName(modificationMethod)}~" +
$"{startDate:yyyy-MM-dd}" +
$"~{endDate:yyyy-MM-dd}");
}
public MainViewModel()
{
// try to change this value to TimeSimulation
SimulationType = SimulationType.Waves;
// SimulationType = SimulationType.TimeSimulation;
Function = (t, x, a) => Math.Cos(t * a) * (x == 0 ? 1 : Math.Sin(x * a) / x);
SetupModel();
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="simulationId"></param>
/// <param name="simulationType"></param>
/// <param name="simulationNumber"></param>
/// <param name="final"></param>
/// <param name="time"></param>
public static void CalculateTimeliness(ProductionDomainContext context, int simulationId,
SimulationType simulationType, int simulationNumber, bool final, int time)
{
var simConfig = context.SimulationConfigurations.Single(a => a.Id == simulationId);
/*var orderTimeliness = final ? context.SimulationOrders.Where(a => a.State == State.Finished
* && a.CreationTime > simConfig.SettlingStart
* && a.CreationTime < simConfig.SimulationEndTime
* && a.SimulationType == simulationType)
* .Select(x => new { x.Name, x.FinishingTime, x.DueTime }).ToList() :
* context.SimulationOrders.Where(a => a.State == State.Finished
* && a.FinishingTime >= time - simConfig.DynamicKpiTimeSpan
* && a.SimulationType == simulationType)
* .Select(x => new { x.Name, x.FinishingTime, x.DueTime }).ToList();
*
*
*/
var orderTimeliness = final ?
//then
context.SimulationOrders
.Where(x => x.SimulationConfigurationId == simulationId && x.SimulationType == simulationType)
.Where(a =>
a.State == State.Finished && a.CreationTime >= simConfig.SettlingStart &&
a.FinishingTime <= simConfig.SimulationEndTime &&
a.CreationTime < simConfig.SimulationEndTime)
.Select(x => new { x.Name, x.FinishingTime, x.DueTime }).ToList()
// Else
: context.SimulationOrders
.Where(x => x.SimulationConfigurationId == simulationId && x.SimulationType == simulationType)
.Where(a => a.State == State.Finished && a.FinishingTime >= time - simConfig.DynamicKpiTimeSpan)
.Select(x => new { x.Name, x.FinishingTime, x.DueTime }).ToList();
if (!orderTimeliness.Any())
{
return;
}
var kpis = orderTimeliness.GroupBy(g => g.Name).Select(o => new Kpi()
{
Name = o.Key,
Value = Math.Round((o.Count(x => (x.DueTime - x.FinishingTime) >= 0) / (double)o.Count()), 2),
ValueMin = Math.Round((double)o.Min(m => m.FinishingTime - m.DueTime), 2),
ValueMax = Math.Round((double)o.Max(n => n.FinishingTime - n.DueTime), 2),
Count = o.Count(c => c.Name == o.Key),
IsKpi = final,
KpiType = KpiType.Timeliness,
SimulationConfigurationId = simulationId,
SimulationType = simulationType,
SimulationNumber = simulationNumber,
Time = time,
IsFinal = final
}).ToList();
context.Kpis.AddRange(kpis);
context.SaveChanges();
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="simulationId"></param>
/// <param name="simulationType"></param>
/// <param name="simulationNumber"></param>
public static void MachineSattleTime(ProductionDomainContext context, int simulationId,
SimulationType simulationType, int simulationNumber)
{
var simConfig = context.SimulationConfigurations.Single(a => a.Id == simulationId);
var ts = simConfig.DynamicKpiTimeSpan;
for (var i = ts; i < simConfig.SimulationEndTime; i = i + ts)
{
CalculateMachineUtilization(context, simulationId, simulationType, simulationNumber, false, i);
}
}
/// <summary>
/// Executes simulation with OpenCL implementation in batch to checkpoint and compares with expected state
/// </summary>
/// <param name="sim">Simulation</param>
/// <param name="simType">Simulation type</param>
/// <param name="stateName">State name</param>
public static void DoBatchOpenCLToCheckpointAndAssert(SimulationBase sim, SimulationType simType, string stateName)
{
OpenCLDispatcher dispatcher;
OpenCLDevice device;
GetOpenCLDispatcherAndDevice(out dispatcher, out device);
sim.DoBatchOpenCL(dispatcher, device, StepCountToCheckpoint);
AssertSimulationWithState(sim, simType, stateName);
}
public WorldCinfo()
{
Gravity = 9.8f;
GravityDirection = -Vector3.UnitY;
WorldSize = 150;
CollisionTolerance = 0.1f;
HavokSimulationType = SimulationType.SIMULATION_TYPE_DISCRETE;
HavokSolverType = SolverType.SOLVER_TYPE_4ITERS_MEDIUM;
FireCollisionCallbacks = false;
EnableDeactivation = true;
}
public SimulationHandler(SimulationType st)
{
_simType = st;
_error = new List <CircuitError>();
_warning = new List <CircuitWarning>();
_comps = SystemGrid.ComponentGrid.Values;
_nodes = SystemGrid.MainGrid;
_SimOutput = new List <string>();
Informer = new SimInformer();
clock = new Stopwatch();
}
public static IBehaviour Get(SimulationType simType)
{
switch (simType)
{
case SimulationType.Bucket:
return(Bucket());
default:
return(Default());
}
}
public IEnumerable <SimulationLineChart> GetSimulationLineCharts(SimulationType type)
{
if (type == SimulationType.Avg)
{
return(_simulationContext.GetSimulationAvgLineCharts());
}
else
{
return(_simulationContext.GetSimulationSumLineCharts());
}
}
public static IBehaviour Get(SimulationType simType)
{
IBehaviour behave;
switch (simType)
{
case SimulationType.DefaultSetup: behave = Default(simType); break;
default: behave = Default(simType); break;
}
return(behave);
}
public static void UpdateSimulationId(int simulationId, SimulationType simluationType, int simNumber)
{
var simItems = AgentSimulation.SimulationWorkschedules
.Where(x => x.SimulationConfigurationId == -1).ToList();
foreach (var item in simItems)
{
item.SimulationConfigurationId = simulationId;
item.SimulationType = simluationType;
item.SimulationNumber = simNumber;
}
}
private async Task OnInitialized(Guid checkoutSessionRefId, SimulationType simulationType)
{
this.stateFlags = this.stateFlags | TicketSimulationStateType.Initialized;
// map the values
this._TicketStatus.CheckoutSessionRefId = checkoutSessionRefId;
//this._TicketStatus.SimulationType = simulationType;
await AddOrUpdateEntityStateAsync();
ActorEventSource.Current.ActorMessage(this, $"Actor [{this.GetActorReference().ActorId.GetGuidId()}] initialized.");
}
public static IBehaviour Get(M_Stock stockElement, SimulationType simType)
{
IBehaviour behaviour;
switch (simType)
{
default:
behaviour = Default(stockElement: stockElement, simType);
break;
}
return(behaviour);
}
public static IBehaviour Get(SimulationType simType, WorkTimeGenerator workTimeGenerator, int resourceId, ToolManager toolManager)
{
switch (simType)
{
case SimulationType.DefaultSetup:
return(DefaultSetup(workTimeGenerator: workTimeGenerator, resourceId: resourceId, toolManager: toolManager));
case SimulationType.Bucket:
return(Bucket(workTimeGenerator: workTimeGenerator, resourceId: resourceId, toolManager: toolManager));
default:
return(Default(workTimeGenerator: workTimeGenerator, resourceId: resourceId, toolManager: toolManager));
}
}
/// <summary>
/// Executes simulation with OpenCL implementation to checkpoint and compares with expected state
/// </summary>
/// <param name="sim">Simulation</param>
/// <param name="simType">Simulation type</param>
/// <param name="stateName">State name</param>
public static void DoStepsOpenCLToCheckpointAndAssert(SimulationBase sim, SimulationType simType, string stateName)
{
OpenCLDispatcher dispatcher;
OpenCLDevice device;
GetOpenCLDispatcherAndDevice(out dispatcher, out device);
for (int i = 0; i < StepCountToCheckpoint; i++)
{
sim.DoStepOpenCL(dispatcher, device);
}
AssertSimulationWithState(sim, simType, stateName);
}
public void AddValueInOrderOfAppearance(double value, SimulationType simulationType)
{
// EXPLICACION DE ESTE CODIGO: los datos de entrada son siempre mensuales (así está definido el formato de entrada), entonces, si la simulacion
// será diaria, debe dividerse cada dato mensual por 30 e ingresarlo como un suceso 30 veces para luego calcular la media y el desvio standard de
// manera adecuada.
// Similar sería si se pretende una simulación semanal, deberia dividirse el dato ingresado por 4 e ingresarlo como que ocurrió en 4 oportunidades.
var valueToAdd = value / (int)simulationType;
for (int i = 1; i <= (int)simulationType; i++)
{
AddValueInOrderOfAppearance(valueToAdd);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NSA.Model.BusinessLogic.Rule"/> class.
/// </summary>
/// <param name="StartNode">Start node.</param>
/// <param name="EndNodes">End nodes.</param>
/// <param name="Options">Options.</param>
/// <param name="SimulationType">Simulation type.</param>
/// <param name="ExpectedResult">the expected result: True or False</param>
/// <param name="N">Network</param>
public Rule(string StartNode, List <string> EndNodes, Dictionary <string, int> Options, SimulationType SimulationType, bool ExpectedResult, Network N)
{
StartNodeString = StartNode;
EndNodesString = EndNodes;
SimulType = SimulationType;
if (!Options.ContainsKey("TTL"))
{
Options["TTL"] = 64;
}
this.Options = Options;
this.ExpectedResult = ExpectedResult;
network = N;
}
/// <summary>
/// The Actor is Created by calling it, this initializes base values required to be an minimaly viable CheckoutSession
/// </summary>
/// <param name="authorityRefId"></param>
/// <param name="brandRefId"></param>
/// <param name="simulationType"></param>
/// <returns></returns>
public async Task <Guid> TicketInitialize(
Guid checkoutSessionRefId,
SimulationType simulationType
)
{
if (this.machine.IsInState(TicketSimulationStateType.Created))
{
await this.machine.FireAsync(initializedTrigger, checkoutSessionRefId, simulationType);
return(this.GetActorReference().ActorId.GetGuidId());
}
ActorEventSource.Current.ActorMessage(this, $"{nameof(TicketSimulationActor)} already initialized.");
throw new InvalidOperationException($"{nameof(TicketSimulationActor)} [{this.GetActorReference().ActorId.GetGuidId()}] has already been initialized.");
}
/// <summary>
/// Initializes a new instance of the <see cref="APSIMFileWriter"/> class.
/// This object is used to write the fields to the SDML xml file
/// passed from an AusFarmSpec object via the AusFarmFiles host.
/// </summary>
public AusFarmFileWriter(SimulationType templateType)
{
// Load the template file.
string scriptTemplate = "";
switch (templateType)
{
case SimulationType.stCropOnly:
scriptTemplate = "APSIM.Cloud.Shared.Resources.ausfarm_crop_only.sdml";
break;
case SimulationType.stSingleFlock:
scriptTemplate = "APSIM.Cloud.Shared.Resources.ausfarm_warooka.sdml";
break;
case SimulationType.stDualFlock:
scriptTemplate = "APSIM.Cloud.Shared.Resources.ausfarm_dual_flock.sdml";
break;
}
if (scriptTemplate.Length > 0)
{
Stream s = Assembly.GetExecutingAssembly().GetManifestResourceStream(scriptTemplate);
StreamReader reader = new StreamReader(s);
xmlScriptDoc = new TCompParser(reader.ReadToEnd());
simulationXMLNode = xmlScriptDoc.rootNode();
}
else
simulationXMLNode = null;
}
private void SimulateModule(ModuleClient module, SimulationType simulationType)
{
SimulateModule(module, simulationType, 1.0);
}
public WorldCinfo()
{
Gravity = 9.8f;
GravityDirection = -Vector3.UnitY;
WorldSize = 150;
CollisionTolerance = 0.1f;
HavokSimulationType = SimulationType.SIMULATION_TYPE_DISCRETE;
HavokSolverType = SolverType.SOLVER_TYPE_4ITERS_MEDIUM;
FireCollisionCallbacks = false;
EnableDeactivation = true;
}
private void SimulateModule(ModuleClient module, SimulationType simulationType, double simulationRatio)
{
bool wasRunning;
if ((module == null) || (blackboard == null) || (selectedMC == blackboard.VirtualModule))
return;
tcLog.Enabled = false;
if (wasRunning = module.IsRunning)
{
module.Stop();
while (module.IsRunning)
Application.DoEvents();
}
if (simulationType == SimulationType.SimulationDisabled)
module.Simulation.SuccessRatio = 2;
else
module.Simulation.SuccessRatio = simulationRatio;
if (wasRunning)
{
module.Start();
while (!module.IsRunning)
Application.DoEvents();
}
tcLog.Enabled = true;
ShowModuleInfo();
}
