// contains the algorithms of updating properties, convergence checking and time cut off.
private static int Update(SimulationData data, double[] convergenceError, double[] delta, int counter)
{
UpdatePropertiesFromNewP(data, delta);
// check convergence errors.
bool repeat = CheckConvergence(data, convergenceError);
//bool repeat = false;
if (!repeat && (data.maximumNonLinearIterations - counter) != 1)
{
// increment the counter.
counter += 1;
}
else
{
data.timeStep *= data.timeStepSlashingFactor;
for (int i = 0; i < data.grid.Length; i++)
{
data.grid[i].Reset(data);
}
// reset the convergenceError array so that it violates the convergence criteria
convergenceError[0] = 0;
convergenceError[1] = data.MBE_Tolerance;
//convergenceError[1] = 0;
// reset the counter.
// this way we begin repeating the same time step with all the number of non linear iterations.
counter = 0;
}
return(counter);
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseWell"/> class.
/// </summary>
/// <param name="data">The <see cref="SimulationData"/>.</param>
/// <param name="index">The index of the block the well is located into.</param>
/// <param name="type">The well type<see cref="Global.WellType"/>.</param>
/// <param name="control">The well control method <see cref="Global.WellControl"/>.</param>
/// <param name="radius">The well radius.</param>
/// <param name="skin">The skin factor.</param>
/// <param name="specifiedMinimumBHP">The specified_minimum BHP.</param>
/// <param name="specifiedFlowRate">The specified flow rate.</param>
/// <param name="method">The well rate method used <see cref="Global.WellRateCalculation"/>.</param>
public BaseWell(SimulationData data, int index, Global.WellType type, Global.WellControl control, double radius, double skin, double specifiedMinimumBHP = 0, double specifiedFlowRate = 0, Global.WellRateCalculation method = Global.WellRateCalculation.Explicit)
{
this.index = index;
this.type = type;
this.control = control;
this.method = method;
data.grid[index].type = Global.BlockType.WellBlock;
this.radius = radius;
this.skin = skin;
this.R_equivalent = GetR_Equivalent(data.grid[index], data.grid);
this.WI = GetWI(data.grid[index]);
this.specifiedMinimumBHP = specifiedMinimumBHP;
this.specifiedFlowRate = specifiedFlowRate;
if (type == Global.WellType.Injection)
{
this.specifiedFlowRate = -1 * specifiedFlowRate;
}
this.BHP = new double[Global.STEPS_MEMORY];
this.q_oil = new double[Global.STEPS_MEMORY];
this.q_free_gas = new double[Global.STEPS_MEMORY];
this.q_solution_gas = new double[Global.STEPS_MEMORY];
this.q_water = new double[Global.STEPS_MEMORY];
}
/// <summary>
/// Deinitialization method cleaning all the created objects
/// </summary>
public async Task Deinitialize()
{
//Client should wait for master to break the connection
if (IsClient)
{
while (Client.Connection.ConnectedPeersCount > 0)
{
await Task.Delay(20);
}
}
StopConnection();
var type = Type;
var clearObjectsAction = new Action(() =>
{
ClearNetworkObjects(type);
});
ThreadingUtilities.DispatchToMainThread(clearObjectsAction);
LocalAddresses.Clear();
MasterAddresses.Clear();
Type = ClusterNodeType.NotClusterNode;
CurrentSimulation = null;
Log.Info("Deinitialized the Simulation Network data.");
}
public void callTrackingDelegate()
{
stopTrack();
if (sendTrack)
{
Debug.Log("<color=green>Sending Track</color>");
string date = DateTime.Now.ToString();
sendText.enabled = true;
simData = new SimulationData(date, user, targetInfo, cube, vPath, headTrackingList.ToArray(), toolTrackingList.ToArray(), timeout, LoginManager.GetComponent <LoginScript>().debugging);
string url = "https://api.mlab.com/api/1/databases/medicart/collections/simulations?apiKey=SmvExKbpTZ9D_lSWBX9WEEo_nEboqR6q";
string json = JsonUtility.ToJson(simData);
WWW request = POST(json, url);
simHeader = new SimulationHeader(user, date, toolTrackingList [toolTrackingList.Count - 1].time - toolTrackingList [0].time);
string url2 = "https://api.mlab.com/api/1/databases/medicart/collections/simheaders?apiKey=SmvExKbpTZ9D_lSWBX9WEEo_nEboqR6q";
string json2 = JsonUtility.ToJson(simHeader);
WWW request2 = POST(json2, url2);
}
sendText.enabled = false;
sendTrack = false;
timeout = false;
vPath = Vector3.zero;
officialStart = 100000f;
}
// Start is called before the first frame update
void Start()
{
transform.position = new Vector3(-3.53f, 0.05f, -2);
//EndingText = GameObject.Find("TimeOrCrashed");
infoObject = (InfoObject)UnityEngine.Object.FindObjectOfType(typeof(InfoObject));
SimulationData simData = infoObject.simulationData;
History = simData.history;
score = simData.score;
tps = History.tps;
history = History.history;
//crashed = (score.successful==false);
crashed = true;
swpl = history.Length;
time = score.time;
secTime = time / tps;
sentwps = new float[swpl, 2];
Vector2 currentPosition = this.transform.position;
var i = 0;
while (i < swpl)
{
var temp = ConvertPos(history[i].pos, currentPosition);
sentwps[i, 0] = temp[0];
sentwps[i, 1] = temp[1];
i++;
}
}
// the iteration cycle
private static void IterativeSolver(SimulationData data, double[][] Jacobi, double[] minusR, double[] delta)
{
// an array containing previous "index 0" and current "index 1" material balance errors.
double[] MBE = new double[2];
// resets time step to its original value at the beginning of each new time step.
ResetTimeStep(data);
// reset relaxation factor.
data.relaxationFactor = data.originalRelaxationFactor;
// non-linear iteration counter.
int counter = 0;
do
{
// formulation.
NumericalPerturbation.CalculateMinusR_Matrix(data, minusR);
NumericalPerturbation.CalculateJacobi_Matrix(data, minusR, Jacobi);
WellTerms.Add(data, Jacobi, minusR);
// solving the equations.
delta = SolveForDelta(Jacobi, minusR);
// update properties with better approximations.
counter = Update(data, MBE, delta, counter);
// repeat the cycle if the material balance error is larger than the tolerance specified.
// as long as the repetitions are smaller than the maximum number of non-linear iterations specified.
} while (MBE[1] >= data.MBE_Tolerance && counter <= data.maximumNonLinearIterations);
// update properties of the new time step after successful convergence.
UpdateProperties(data);
}
// updates the n1 time level properties with better approximation after solving the Ax=B equation.
private static void UpdatePropertiesFromDeltas(SimulationData data, double[] delta)
{
double P, So, Sg, Sw;
int counter = 0;
for (int i = 0; i < data.grid.Length; i++)
{
P = data.grid[i].P[1] + delta[counter];
// assert p is always greater than 0.
P = P > 0 ? P : 0;
Sg = data.grid[i].Sg[1] + delta[counter + 1];
// assert Sg is always greater than 0.
Sg = Sg > 0 ? Sg : 0;
Sw = data.grid[i].Sw[1] + delta[counter + 2];
// assert Sw is always greater than 0.
Sw = Sw > 0 ? Sw : 0;
So = 1 - Sw - Sg;
data.grid[i].UpdateProperties(data, P, Sw, Sg, So, 1);
counter += data.phases.Length;
}
}
private SimulationData CreateSimulationData()
{
var tempSimulationData = new SimulationData
{
CodingMode = new SimulationData.Mode
{
Name = CodingModes[CodingIndex],
Index = CodingIndex
},
ModulationMode = new SimulationData.Mode
{
Name = ModulationModes[ModulationIndex],
Index = ModulationIndex
},
FrameLength = this.FrameLength,
DecisionDepth = this.DecisionDepth,
SNR = this.SNR,
TransmitterAuthor = CurrTrans,
ReceiverAuthor = CurrReceiv,
BitsSend = 0,
BitsLost = 0
};
return(tempSimulationData);
}
public SimulationConfig(SimulationData simulation)
{
Name = simulation.Name;
Clusters = simulation.Cluster != null && simulation.Cluster.Instances.Length > 1 ? simulation.Cluster.Instances.SelectMany(i => i.Ip).ToArray() : new string[] { };
ClusterName = simulation.Cluster.Name;
ApiOnly = simulation.ApiOnly;
Headless = simulation.Headless;
Interactive = simulation.Interactive;
TimeOfDay = simulation.TimeOfDay;
Rain = simulation.Rain;
Fog = simulation.Fog;
Wetness = simulation.Wetness;
Cloudiness = simulation.Cloudiness;
Damage = simulation.Damage;
UseTraffic = simulation.UseTraffic;
UsePedestrians = simulation.UsePedestrians;
Seed = simulation.Seed;
if (simulation.Vehicles == null || simulation.Vehicles.Length == 0 || simulation.ApiOnly)
{
Agents = Array.Empty <AgentConfig>();
}
else
{
Agents = simulation.Vehicles.Select(v => new AgentConfig(v)).ToArray();
}
TestReportId = simulation.TestReportId;
}
private void SelectSnapshot(int offset)
{
if (offset != 0)
{
SimDateTime actualSdt = null;
if (offset == short.MinValue)
{
actualSdt = _min;
}
else if (offset == short.MaxValue)
{
actualSdt = _max;
}
else if (offset == -3)
{
actualSdt = SimulationData.SelectPreviousSnapshot(_crtSnapshot);
}
else if (offset == 3)
{
actualSdt = SimulationData.SelectNextSnapshot(_crtSnapshot);
}
else
{
SimDateTime sdt = _crtSnapshot.AddHours(offset);
actualSdt = SimulationData.SelectNearestSnapshot(sdt);
}
cmbSnapshots.SelectedItem = actualSdt;
}
}
private IEnumerator LoadScene()
{
simulationData = ScriptableObject.CreateInstance <SimulationData>();
simulationData.populationDensity = (uint)populationDensitySlider.value;
simulationData.infectivity = infectivitySlider.value;
simulationData.launchSickNumber = launchSickNumberSlider.value;
simulationData.launchImmunedNumber = launchImmunedNumberSlider.value;
simulationData.diseaseDuration = (uint)diseaseDurationSlider.value;
simulationData.deathStatistic = deathStatisticSlider.value;
simulationData.diseaseTransmissionDistance = transmissionDistanceSlider.value;
yield return(null);
m_openSimulationScene = SceneManager.LoadSceneAsync(simulationSceneName);
m_openSimulationScene.allowSceneActivation = false;
while (!m_openSimulationScene.isDone)
{
//Output the current progress
Debug.Log("Loading progress: " + (m_openSimulationScene.progress * 100).ToString() + "%");
// Check if the load has finished
if (m_openSimulationScene.progress >= 0.9f)
{
m_openSimulationScene.allowSceneActivation = true;
}
yield return(null);
}
}
// the iteration cycle
private static void IterativeSolver(SimulationData data, double[][] pressureCoefficients, double[] constants, double[] deltaP)
{
// an array containing previous "index 0" and current "index 1" material balance errors.
double[] MBE = new double[2];
// resets time step to its original value at the beginning of each new time step.
ResetTimeStep(data);
// non-linear iteration counter.
int counter = 0;
do
{
// formulation.
IMPES_Preparation.CalculateConstantsMatrix(data, constants);
IMPES_Preparation.CalculatePressureCoefficientsMatrix(data, pressureCoefficients);
IMPES_Preparation.AddWellTerms(data, pressureCoefficients, constants);
// solving the equations.
deltaP = SolveForNewP(pressureCoefficients, constants);
// update properties with better approximations.
counter = Update(data, MBE, deltaP, counter);
// repeat the cycle if the material balance error is larger than the tolerance specified.
// as long as the repetitions are smaller than the maximum number of non-linear iterations specified.
} while (MBE[1] >= data.MBE_Tolerance && counter <= data.maximumNonLinearIterations);
// update properties of the new time step after successful convergence.
UpdateProperties(data);
}
void OnEnable()
{
Instance = this;
EditorApplication.playModeStateChanged += HandlePlayMode;
EditorApplication.update += OnEditorUpdate;
Settings = (DevelopmentSettingsAsset)AssetDatabase.LoadAssetAtPath("Assets/Resources/Editor/DeveloperSettings.asset", typeof(DevelopmentSettingsAsset));
if (Settings == null)
{
Settings = (DevelopmentSettingsAsset)CreateInstance(typeof(DevelopmentSettingsAsset));
Debug.Log("Initialized new developer settings");
Settings.VersionOverride = Application.version;
AssetDatabase.CreateAsset(Settings, "Assets/Resources/Editor/DeveloperSettings.asset");
}
if (Settings.developerSimulationJson != null)
{
DeveloperSimulation = JsonConvert.DeserializeObject <SimulationData>(Settings.developerSimulationJson);
}
if (DeveloperSimulation == null)
{
DeveloperSimulation = new SimulationData()
{
Name = "DeveloperSettings",
TimeOfDay = DateTime.Now,
};
}
Refresh();
}
public void reportStatus(SimulatorStatus value, string message = "")
{
Console.WriteLine($"[LOADER] Update simulation status {status} -> {value}");
var previous = reportedStatus(status);
var newStatus = reportedStatus(value);
status = value;
if (value == SimulatorStatus.Error && SimulatorManager.InstanceAvailable)
{
SimulatorManager.Instance.AnalysisManager.AddErrorEvent(message);
}
if (previous == newStatus)
{
return;
}
if (ConnectionManager.instance != null)
{
ConnectionManager.instance.UpdateStatus(newStatus, CurrentSimulation.Id, message);
}
if (value == SimulatorStatus.Idle)
{
currentSimulation = null;
}
if (status == SimulatorStatus.Running)
{
WindowFlasher.Flash();
}
}
public BaseSceneContext(SimulationData data)
{
this.data = data;
this.backgroundLayer = LayerMask.NameToLayer(backgroundLayerName);
this.staticForegroundLayer = LayerMask.NameToLayer(staticForegroundLayerName);
this.dynamicForegroundLayer = LayerMask.NameToLayer(dynamicForegroundLayerName);
}
// miscellaneous internal helper methods
// returns the absolute value of the gas material balance error of the whole model.
private static bool CheckConvergence(SimulationData data, double[] convergenceError)
{
bool firstIteration = convergenceError[0] == 0;
convergenceError[0] = convergenceError[1];
data.MBE_Oil = Math.Abs(MBE.CheckOil(data));
data.MBE_Gas = Math.Abs(MBE.CheckGas(data));
data.MBE_Water = Math.Abs(MBE.CheckWater(data));
convergenceError[1] = Math.Max(data.MBE_Gas, Math.Max(data.MBE_Oil, data.MBE_Water));
bool MBE_Increasing = (convergenceError[1] > convergenceError[0]);
//bool slowConvergence = convergenceError[1] / convergenceError[0] > data.maximumConvergenceErrorRatio;
// if this is not the first iteration and either one of the following conditions is true:
// 1- material balance error is increasing not decreasing.
// 2- the rate of convergence is slow.
if (!firstIteration && (MBE_Increasing /*|| slowConvergence*/))
{
return(true);
}
return(false);
}
/// <summary>
/// Add the well terms "flow rates and derivatives" of each phase to their respective position in the Jacobi and the minus R matrices.
/// </summary>
/// <param name="data">The <see cref="SimulationData"/> data.</param>
/// <param name="Jacobi">The Jacobi matrix.</param>
/// <param name="minusR">The minus R matrix.</param>
public static void Add(SimulationData data, double[][] Jacobi, double[] minusR)
{
int index = 0;
for (int i = 0; i < data.wells.Length; i++)
{
index = 3 * data.wells[i].index;
minusR[index] += data.wells[i].q_oil[1];
minusR[index + 1] += data.wells[i].q_free_gas[1] + data.wells[i].q_solution_gas[1];
minusR[index + 2] += data.wells[i].q_water[1];
}
for (int i = 0; i < data.wells.Length; i++)
{
index = 3 * data.wells[i].index;
Jacobi[index][index] -= data.wells[i].dq_oil_dP;
Jacobi[index][index + 1] -= data.wells[i].dq_oil_dSg;
Jacobi[index][index + 2] -= data.wells[i].dq_oil_dSw;
Jacobi[index + 1][index] -= (data.wells[i].dq_free_gas_dP + data.wells[i].dq_solution_gas_dP);
Jacobi[index + 1][index + 1] -= (data.wells[i].dq_free_gas_dSg + data.wells[i].dq_solution_gas_dSg);
Jacobi[index + 1][index + 2] -= (data.wells[i].dq_free_gas_dSw + data.wells[i].dq_solution_gas_dSw);
Jacobi[index + 2][index] -= data.wells[i].dq_water_dP;
Jacobi[index + 2][index + 1] -= data.wells[i].dq_water_dSg;
Jacobi[index + 2][index + 2] -= data.wells[i].dq_water_dSw;
}
}
void simulation_MarkServer(object sender, MarkServerEventArgs e)
{
Node serverNode;
NodeIdMap.TryGetValue(e.Id, out serverNode);
if (serverNode != null)
{
serverNode.Highlight = true;
SimulationServerNode = serverNode;
var nodeIds = GetNodeIds();
foreach (var id in nodeIds)
{
if (id == SimulationServerNode.Id)
{
SimulationData.Add(id, new List <int>());
continue;
}
var data = new List <int>();
data.Add(id);
SimulationData.Add(id, data);
}
}
}
/// <summary>
/// Extract the data
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public override double Extract(SimulationData data)
{
IParameterized c = (IParameterized)data.GetObject(Component);
return(c.Ask(Parameter, data.Circuit));
// return c.Ask(Parameter);
}
public void Add(SimulationData data)
{
using (var db = DatabaseManager.Open())
{
db.Insert(data);
}
}
void Start()
{
var env = GameObject.FindGameObjectWithTag("AgentEnvironment");
if (!env)
{
return;
}
var agentEnvironment = env.GetComponent <AgentEnvironment>();
if (agentEnvironment)
{
m_environment = agentEnvironment;
}
m_simulationData = ScriptableObject.FindObjectOfType <SimulationData>();
simulationDataText.text += "\n" +
$"Density : {m_simulationData.populationDensity.ToString()} \n " +
$"Infectivity : {m_simulationData.infectivity.ToString()} \n " +
$"Launch Sick nb : {m_simulationData.launchSickNumber.ToString()} \n " +
$"Launch Immuned nb : {m_simulationData.launchImmunedNumber.ToString()} \n " +
$"Disease duration : {m_simulationData.diseaseDuration.ToString()} \n " +
$"Death statistic : {m_simulationData.deathStatistic.ToString()} \n " +
$"Disease transmission distance : {m_simulationData.diseaseTransmissionDistance.ToString()} \n ";
m_bastCitizensStatText = currentCitizensStatText.text;
m_bastMayorStatText = currentMayorStatText.text;
}
/// <summary>
/// Store the result of the AC simulation
/// </summary>
/// <param name="sender">Simulation invoking the event</param>
/// <param name="data">Simulation data</param>
private void StoreResult(object sender, SimulationData data)
{
for (int i = 0; i < Analysis.Sweeps.Count; i++)
{
Sweeps[i].Add(Analysis.Sweeps[i].CurrentValue);
}
Results.Add(extractsim(data));
}
public MatrixBuilder(Mesh mesh, SimulationData simulationData)
{
_points = new IntegrationPoints();
_deviratives = new Deviratives(_points);
_mesh = mesh;
_simulationData = simulationData;
buildJacobianMatrix();
initializeLocalMatrixes();
}
public void RenderSimState(SimulationData simulationData, SimulationState stateToRender)
{
RenderVehicles(simulationData, stateToRender.Vehicles, stateToRender.IndexToID);
foreach (var list in stateToRender.Projectiles)
{
RenderProjectiles(list);
}
mPrimitiveRenderer.Render();
}
public static WeatherYear WeatherYear(this SimulationData simulationData, int year = 2018)
{
if (simulationData == null)
{
return(null);
}
return(WeatherYear(simulationData.GetBuildingData(), year));
}
/// <summary>
/// Gets the CGG term.
/// </summary>
/// <param name="block">The block.</param>
/// <param name="data">The <seealso cref="SimulationData"/> data.</param>
/// <returns></returns>
public static double GetCGG(this BaseBlock block, SimulationData data)
{
CGG = 1 / (Global.a * data.timeStep) * (block.Vp[1] / block.Bg[1] - (block.Vp[1] / block.Bo[1]) * block.Rso[1]);
//bhp = Well.WellData.calculatePwf(block, block.P[1], block.Kro[2], block.viscosityOil[1], block.Bo[1]);
//temp = (Well.WellData.calculateFlow_Rate(block.P[1], bhp, block.Krg[2], block.viscosityGas[1], block.WI, block.Bg[1]) - block.q_gas[1]) / (block.Sg[2] - block.Sg[1]);
return(CGG + temp);
}
// get data from input data file.
private static void InitializeRUNSPEC(SimulationData data, List <string> section)
{
int index;
// first : single-line keywords
// phases
List <Global.Phase> phases = new List <Global.Phase>();
if (section.Contains("OIL"))
{
phases.Add(Global.Phase.Oil);
}
if (section.Contains("WATER"))
{
phases.Add(Global.Phase.Water);
}
if (section.Contains("GAS"))
{
phases.Add(Global.Phase.Gas);
}
if (section.Contains("DISGAS"))
{
//phases.Add(Global.Phase.DissolvedGas);
data.solubleGasPresent = true;
}
data.phases = phases.ToArray();
if (section.Contains("IMPES"))
{
data.solutionProcedure = Global.SolutionProcedure.IMPES;
}
else
{
data.solutionProcedure = Global.SolutionProcedure.FullyImplicit;
}
// second : two-lines keywords
// title
index = section.FindIndex(x => x.Contains("TITLE"));
data.title = section[index + 1];
// grid dimensions
index = section.FindIndex(x => x.Contains("DIMENS"));
string[] dimens = section[index + 1].Split(new char[] { }, StringSplitOptions.RemoveEmptyEntries);
data.x = int.Parse(dimens[0]);
data.y = int.Parse(dimens[1]);
data.z = int.Parse(dimens[2]);
// well dimensions
index = section.FindIndex(x => x.Contains("WELLDIMS"));
dimens = section[index + 1].Split(new char[] { }, StringSplitOptions.RemoveEmptyEntries);
data.wells = new Well.BaseWell[int.Parse(dimens[0])];
}
private void simulation_End(object sender, EventArgs e)
{
UnmarkSimulationParticpants();
if (SimulationServerNode != null)
{
SimulationServerNode.Highlight = false;
}
SimulationData.Clear();
}
private StrategySimulationData GetSimulationData(object ti)
{
StrategySimulationData data;
if (SimulationData.TryGetValue(ti, out data))
{
return(data);
}
return(null);
}
/// <summary>
/// this method detects oscillations or stagnations and applies relaxation if needed.
/// </summary>
/// <remarks>
/// The only time this method triggered was when i ran the model using <see cref="AccumulationTermExpansion"/> near the bubble point pressure.
/// </remarks>
/// <param name="data">the <see cref="SimulationData"/>.</param>
/// <param name="delta_x">The result of solving the Ax=B equation</param>
/// <param name="convergenceError">
/// <para>An array containing previous and current iteration material balance error.</para>
/// <para>This way we can detect oscillations or stagnation based on comparing current and previous iteration values.</para>
/// </param>
/// <returns>
/// <para>True if relaxation fails. This requires repition of the step using a different time step</para>
/// <para>False if relaxation is applied.</para>
/// </returns>
/// <seealso cref="SimulationData.timeStepSlashingFactor"/>.
private static void StabilizeNewton(SimulationData data, double[] delta_x, double[] convergenceError)
{
if (data.relaxationFactor != 1)
{
for (int i = 0; i < delta_x.Length; i++)
{
delta_x[i] = data.relaxationFactor * delta_x[i];
}
}
}
public unsafe override void PerformSimulationStage(SimulationData data)
{
_data = data;
Disease disease = _data.DiseaseToSimulate;
if (_arrayHeight == 0 /* || _arrayWidth == 0 */) //Checking one value should be enough, only happens in first round
{
_arrayHeight = _data.ImageHeight;
_arrayWidth = _data.ImageWidth;
_arrayMaxIndex = _arrayHeight * _arrayWidth;
}
//Let each Cell calculate its probability
for (int index = 0; index < data.Cells.Length; ++index)
{
PopulationCell cell = data.Cells[index];
if (cell != null)
cell.Probability = CalculateProbability(index, disease.Transferability);
}
//Let Humans get Infected by chance
fixed (Human* humanptr = data.Humans)
{
Human* startPtr = humanptr;
Parallel.For(0, _data.Humans.Length, Constants.DEFAULT_PARALLELOPTIONS,
index =>
{
Human* ptr = startPtr + index;
if (!ptr->IsDead() && !ptr->IsInfected())
{
int probability = 0;
lock (_data.Cells[ptr->CurrentCell])
probability = _data.Cells[ptr->CurrentCell].Probability;
TryInfection(ptr, disease, probability);
}
});
//TODO: Old code for speed boost reference.. DELETE when done
//for (Human* ptr = humanptr; ptr < humanptr + _data.Humans.Length; ++ptr)
//{
// if (!ptr->IsDead() && !ptr->IsInfected())
// {
// TryInfection(ptr, disease, _data.Cells[ptr->CurrentCell].Probability);
// }
//}
}
}
public unsafe override void PerformSimulationStage(SimulationData data)
{
if (_currentDay != data.CurrentDay)
_currentDay = data.CurrentDay;
else
return;
fixed (Human* humanptr = data.Humans)
{
Human* startPtr = humanptr;
Parallel.For(0, data.Humans.Length, Constants.DEFAULT_PARALLELOPTIONS,
index =>
{
Human* ptr = startPtr + index;
if (ptr->IsDead() || ptr->IsTravelling() || ptr->GetAge() == EAge.Senior || ptr->GetAge() == EAge.Baby)
{
return;
}
if (ptr->IsAtHome())
{
if (ptr->IsDiseased())
{
ptr->SetMindset(EMindset.HomeStaying);
}
else
{
if (data.CurrentDay != DayOfWeek.Saturday && data.CurrentDay != DayOfWeek.Sunday)
{
if (RANDOM.Next(365) < 20)
ptr->SetMindset(EMindset.Vacationing);
else
ptr->SetMindset(EMindset.Working);
}
else
{
if (RANDOM.Next(365) < 20)
ptr->SetMindset(EMindset.Vacationing);
else
ptr->SetMindset(EMindset.DayOff);
}
}
}
});
}
}
public unsafe override void PerformSimulationStage(SimulationData data)
{
_data = data;
fixed (Human* humanptr = data.Humans)
{
Human* startPtr = humanptr;
Parallel.For(0, _data.Humans.Length, Constants.DEFAULT_PARALLELOPTIONS,
index =>
{
Human* ptr = startPtr + index;
if (ptr->IsDead())
return;
//Handle each Human like the component specifies through the HandleHuman method
for (int i = 0; i < _simulationIntervall; i++)
{
HandleHuman(ptr);
}
});
}
}
public override void PerformSimulationStage(SimulationData data)
{
#if DEBUG
Console.WriteLine("DEBUG SIMULATION TICK");
#endif
}
private unsafe void UpdateHumanChangeToCell(Human* hptr, SimulationData data, EAge previousAge)
{
EAge newAge = hptr->GetAge();
if (previousAge != newAge)
{
lock (data.Cells[hptr->CurrentCell])
{
PopulationCell currentcell = data.Cells[hptr->CurrentCell];
if (hptr->GetGender() == EGender.Female)
{
if (newAge == EAge.Child)
{
--currentcell.FemaleBabies;
++currentcell.FemaleChildren;
}
else if (newAge == EAge.Adult)
{
--currentcell.FemaleChildren;
++currentcell.FemaleAdults;
}
else if (newAge == EAge.Senior)
{
--currentcell.FemaleAdults;
++currentcell.FemaleSeniors;
}
}
else
{
if (newAge == EAge.Child)
{
--currentcell.MaleBabies;
++currentcell.MaleChildren;
}
else if (newAge == EAge.Adult)
{
--currentcell.MaleChildren;
++currentcell.MaleAdults;
}
else if (newAge == EAge.Senior)
{
--currentcell.MaleAdults;
++currentcell.MaleSeniors;
}
}
}
}
}
public unsafe override void PerformSimulationStage(SimulationData data)
{
_counter = ++_counter;
if (_counter % TicksPerYear != 0) return;
// Year(s) have passed
#if DEBUG
Console.WriteLine(YearsPerTick.ToString() + " Year(s) have passed!");
#endif
var deadPeople = new List<HumanSnapshot>();
fixed (Human* humanptr = data.Humans)
{
Human* startPtr = humanptr;
Parallel.For(0, data.Humans.Length, Constants.DEFAULT_PARALLELOPTIONS,
index =>
{
Human* human = startPtr + index;
if (human->IsDead())
return;
EAge previousAge = human->GetAge();
if (_counter % TicksPerLeapYear == 0)
human->DoAgeTick((byte)(YearsPerTick + 1)); // "LeapTick" we need to increase YearsPerTick for this tick
else
human->DoAgeTick((byte)YearsPerTick);
UpdateHumanChangeToCell(human, data, previousAge);
AssignProfession(human, previousAge);
if (human->GetAgeInYears() <= AgeLimit) return;
lock (deadPeople)
{
deadPeople.Add(HumanSnapshot.InitializeFromRuntime((byte)human->GetGender(),
(byte)human->GetAgeInYears(), (byte)human->GetProfession(),
human->HomeCell, human->CurrentCell, false));
}
human->KillHuman();
var genderIndex = (int)human->GetGender();
genderIndex = genderIndex == 128 ? 0 : 4;
switch (human->GetAge())
{
case EAge.Baby:
break;
case EAge.Child:
genderIndex++;
break;
case EAge.Adult:
genderIndex += 2;
break;
case EAge.Senior:
genderIndex += 3;
break;
}
lock (data.Cells[human->CurrentCell])
{
PopulationCell currentCell = data.Cells[human->CurrentCell];
currentCell.Data[genderIndex]--;
if (human->IsInfected())
{
--currentCell.Infecting;
if (human->IsSpreading())
--currentCell.Spreading;
if (human->IsDiseased())
--currentCell.Diseased;
}
}
});
}
lock (data.Deaths)
data.AddDeadPeople(deadPeople);
#if DEBUG
Console.WriteLine("Dead people this Iteration: " + deadPeople.Count);
Console.WriteLine("Total dead people: " + data.DeathCount);
#endif
}
public override void PerformSimulationStage(SimulationData data)
{
_data = data;
fixed (Human* humanptr = _data.Humans)
{
Human* startPtr = humanptr;
Parallel.For(0, _data.Humans.Length, Constants.DEFAULT_PARALLELOPTIONS,
index =>
{
Human* ptr = startPtr + index;
//Stationary Mindset implies the human chosen won't move this day regardless of profession
//If the human is dead he won't move....
if (ptr->IsDead() ||
ptr->GetMindset() == PopulationData.EMindset.Stationary)
{
return;
}
//Travelling implies ignoring the Mindset until the human reached its Destination
else if (ptr->IsTravelling())
{
//reduce counter, if counter == 0 remove flag travelling else continue
--ptr->TravellingCounter;
if (ptr->TravellingCounter == 0)
{
ptr->SetTravelling(false);
MoveHuman(ptr, ptr->DesiredCell);
}
else
{
//CurrentPosition + DesiredPosition
int currentX = ptr->CurrentCell % _data.ImageWidth;
int currentY = ptr->CurrentCell / _data.ImageWidth;
int desiredX = ptr->DesiredCell % _data.ImageWidth;
int desiredY = ptr->DesiredCell / _data.ImageWidth;
//The Desiredposition might be far away, farther than the human can travel in one step
int travelDistanceX = Math.Abs(currentX - desiredX);
if (travelDistanceX > 350)
travelDistanceX = 350;
int travelDistanceY = Math.Abs(currentY - desiredY);
if (travelDistanceY > 350)
travelDistanceY = 350;
int nextCell = 0;
if (currentX < desiredX)
{
if (currentY < desiredY)
{
nextCell = ptr->CurrentCell + travelDistanceX + travelDistanceY * _data.ImageWidth;
}
else
{
nextCell = ptr->CurrentCell + travelDistanceX - travelDistanceY * _data.ImageWidth;
}
}
else
{
//y-currentposition < y desiredposition
if (currentY < desiredY)
{
nextCell = ptr->CurrentCell - travelDistanceX + travelDistanceY * _data.ImageWidth;
}
else
{
nextCell = ptr->CurrentCell - travelDistanceX - travelDistanceY * _data.ImageWidth;
}
}
//TODO |h| Make an algorith that tries another route?
if (_data.Cells[nextCell] == null)
nextCell = ptr->CurrentCell;
MoveHuman(ptr, nextCell);
}
}
//Staying Home doesn't vary no matter what profession the human is having.
else if (ptr->GetMindset() == PopulationData.EMindset.HomeStaying)
{
if (_data.CurrentHour > 6 && _data.CurrentHour < 19)
{
if (!ptr->IsAtHome())
{
if (RANDOM.Next(3) == 0)
LetHumanTravelHome(ptr);
}
else
{
if (RANDOM.Next(5) == 0)
LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 2, 75));
}
}
else if (_data.CurrentHour == 19)
{
if (!ptr->IsAtHome())
LetHumanTravelHome(ptr);
}
else
return;
//chance every day to go out 1-3 hours
//if ill -> go to hospital
//if healthy wander around aimlessly in departement (short range)
}
else if (ptr->GetMindset() == EMindset.Vacationing)
{
if (_data.CurrentHour == 8 && ptr->IsAtHome())
{
LetHumanTravel(ptr, FindCellInReach(ptr->CurrentCell, 400, 800));
}
else if (_data.CurrentHour == 6 && !ptr->IsAtHome())
{
if (RANDOM.Next(14) == 13)
{
LetHumanTravelHome(ptr);
}
}
else
return;
}
//Handle Movement for Mindsets which are dependent on the profession od the selected human
else
{
switch (ptr->GetProfession())
{
case EProfession.Pupil: MovePupil(ptr); break;
case EProfession.Student: MoveStudent(ptr); break;
case EProfession.Housewife: MoveHousewife(ptr); break;
case EProfession.Plumber: MovePlumber(ptr); break;
case EProfession.DeskJobber: MoveDeskJobber(ptr); break;
case EProfession.Commuter: MoveCommuter(ptr); break;
case EProfession.TravellingSalesman: MoveTravellingSalesman(ptr); break;
default: return;
}
}
});
}
}
// -------------------------------------------------------------------
// Private
// -------------------------------------------------------------------
private SimulationStats Simulate(Simulation simulation)
{
Diagnostic.Info("Starting simulation for " + simulation.Class);
// Create the struct and pass it to the logic
ISimulationData simulationData = new SimulationData(this.data, simulation, this.randomValues);
// Todo: choose which modules to use
IList<ISimulationModule> modules = new List<ISimulationModule>
{
new SimulationBasicAttack()
};
if (simulationData.Class.Skills != null)
{
foreach (D3Skill skill in simulationData.Class.Skills)
{
modules.Add(new SimulationBasicSkill(skill.Name));
}
}
foreach (ISimulationModule module in modules)
{
simulationData.ClearTargets();
simulationData.CurrentTime = 0.0f;
SimulationSampleSet sampleSet = module.Simulate(simulationData);
if (sampleSet == null)
{
Diagnostic.Warning("No sample returned for {0}", module.Name);
continue;
}
simulationData.Stats.SampleSets.Add(sampleSet);
}
return simulationData.Stats;
}
