private float doStepNotThreaded()
{
kdTree_.buildAgentTree();
for (int i = 0; i < agents_.Count; ++i)
{
Simulator.Instance.agents_[i].computeNeighbors();
Simulator.Instance.agents_[i].computeTargetVelocity();
}
time_ += timeStep_;
return(time_);
}
public float doStep()
{
if (_workers == null)
{
_workers = new Worker[_numWorkers];
_doneEvents = new ManualResetEvent[_workers.Length];
for (int block = 0; block < _workers.Length; ++block)
{
_doneEvents[block] = new ManualResetEvent(false);
_workers[block] = new Worker(block * getNumAgents() / _workers.Length, (block + 1) * getNumAgents() / _workers.Length, _doneEvents[block]);
}
}
kdTree_.buildAgentTree();
for (int block = 0; block < _workers.Length; ++block)
{
_doneEvents[block].Reset();
ThreadPool.QueueUserWorkItem(_workers[block].step);
}
WaitHandle.WaitAll(_doneEvents);
for (int block = 0; block < _workers.Length; ++block)
{
_doneEvents[block].Reset();
ThreadPool.QueueUserWorkItem(_workers[block].update);
}
WaitHandle.WaitAll(_doneEvents);
time_ += timeStep_;
return(time_);
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public float doStep()
{
updateDeleteAgent();
if (workers == null)
{
workers = new Worker[numWorkers];
doneEvents = new ManualResetEvent[workers.Length];
workerAgentCount = getNumAgents();
for (int block = 0; block < workers.Length; ++block)
{
doneEvents[block] = new ManualResetEvent(false);
workers[block] = new Worker(block * getNumAgents() / workers.Length, (block + 1) * getNumAgents() / workers.Length, doneEvents[block]);
}
}
if (workerAgentCount != getNumAgents())
{
workerAgentCount = getNumAgents();
for (int block = 0; block < workers.Length; ++block)
{
workers[block].config(block * getNumAgents() / workers.Length, (block + 1) * getNumAgents() / workers.Length);
}
}
kdTree.buildAgentTree();
if (workers.Length <= 1)
{
workers[0].step(null);
workers[0].update(null);
}
else
{
for (int block = 0; block < workers.Length; ++block)
{
doneEvents[block].Reset();
ThreadPool.QueueUserWorkItem(workers[block].step);
}
WaitHandle.WaitAll(doneEvents);
for (int block = 0; block < workers.Length; ++block)
{
doneEvents[block].Reset();
ThreadPool.QueueUserWorkItem(workers[block].update);
}
WaitHandle.WaitAll(doneEvents);
}
globalTime += timeStep;
return(globalTime);
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public float doStepST()
{
kdTree_.buildAgentTree(this);
int numAgents = getNumAgents();
for (int i = 0; i < numAgents; ++i)
{
agents_[i].computeNeighbors();
agents_[i].computeNewVelocity();
}
for (int i = 0; i < numAgents; ++i)
{
agents_[i].update();
}
globalTime_ += timeStep_;
return(globalTime_);
}
public float DoStep(Boolean looped)
{
if (workers_ == null || agents_.Count > workers_[workers_.Length - 1].end_)
{
workers_ = new Worker[numWorkers_];
doneEvents_ = new ManualResetEvent[workers_.Length];
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block] = new ManualResetEvent(false);
workers_[block] = new Worker(block * getNumAgents() / workers_.Length, (block + 1) * getNumAgents() / workers_.Length, doneEvents_[block], this, looped);
}
}
kdTree_.buildAgentTree(looped);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].step);
}
WaitHandle.WaitAll(doneEvents_);
detectGroups(looped);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].step2);
}
WaitHandle.WaitAll(doneEvents_);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].update);
}
WaitHandle.WaitAll(doneEvents_);
if (save)
{
new DataThread(this, looped, agents_[0].follows_);
}
globalTime_ += timeStep_;
if (looped)
{
virtual_and_agents_ = new List <Agent>();
}
pas++;
return(globalTime_);
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public float doStep()
{
updateDeleteAgent();
if (workers_ == null)
{
workers_ = new Worker[numWorkers_];
doneEvents_ = new ManualResetEvent[workers_.Length];
workerAgentCount_ = getNumAgents();
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block] = new ManualResetEvent(false);
workers_[block] = new Worker(block * getNumAgents() / workers_.Length, (block + 1) * getNumAgents() / workers_.Length, doneEvents_[block]);
}
}
if (workerAgentCount_ != getNumAgents())
{
workerAgentCount_ = getNumAgents();
for (int block = 0; block < workers_.Length; ++block)
{
workers_[block].config(block * getNumAgents() / workers_.Length, (block + 1) * getNumAgents() / workers_.Length);
}
}
kdTree_.buildAgentTree();
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].step);
}
WaitHandle.WaitAll(doneEvents_);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].update);
}
WaitHandle.WaitAll(doneEvents_);
globalTime_ += timeStep_;
return(globalTime_);
}
public void DoStep()
{
if (m_agents.Count == 0)
{
return;
}
m_kdTree.buildAgentTree();
for (int i = 0; i < m_agents.Count; i++)
{
m_agents[i].computeNeighbors();
m_agents[i].computePreferredVelocity();
m_agents[i].computeNewVelocity();
}
for (int i = 0; i < m_agents.Count; i++)
{
m_agents[i].update();
}
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public Fix64 doStep()
{
kdTree_.buildAgentTree();
foreach (var agent in agents_)
{
agent.computeNeighbors();
agent.computeNewVelocity();
}
foreach (var agent in agents_)
{
agent.update();
}
globalTime_ += timeStep_;
return(globalTime_);
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public IEnumerator doStep()
{
if (workers_ == null)
{
workers_ = new Worker[numWorkers_];
doneEvents_ = new ManualResetEvent[workers_.Length];
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block] = new ManualResetEvent(false);
workers_[block] = new Worker(block * getNumAgents() / workers_.Length, (block + 1) * getNumAgents() / workers_.Length, doneEvents_[block]);
}
}
if (obstacleIsDirty)
{
kdTree_.buildObstacleTree();
obstacleIsDirty = false;
}
kdTree_.buildAgentTree();
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].step);
}
WaitHandle.WaitAll(doneEvents_);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].update);
}
WaitHandle.WaitAll(doneEvents_);
yield return(null);
}
/**
* <summary>Performs a simulation step and updates the two-dimensional
* position and two-dimensional velocity of each agent.</summary>
*
* <returns>The global time after the simulation step.</returns>
*/
public KInt doStep_Update()
{
if (isError)
{
return(globalTime_);
}
try
{
updateDeleteAgent();
if (!singletonMode)
{
if (workers_ == null)
{
workers_ = new Worker[numWorkers_];
doneEvents_ = new ManualResetEvent[workers_.Length];
workerAgentCount_ = getNumAgents();
for (int index_block = 0; index_block < workers_.Length; ++index_block)
{
doneEvents_[index_block] = new ManualResetEvent(false);
workers_[index_block] = new Worker(index_block * getNumAgents() / workers_.Length, (index_block + 1) * getNumAgents() / workers_.Length, doneEvents_[index_block]);
}
}
if (workerAgentCount_ != getNumAgents())
{
workerAgentCount_ = getNumAgents();
for (int block = 0; block < workers_.Length; ++block)
{
workers_[block].config(block * getNumAgents() / workers_.Length, (block + 1) * getNumAgents() / workers_.Length);
}
}
}
kdTree_.buildAgentTree();
if (!singletonMode)
{
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].step_Update);
}
WaitHandle.WaitAll(doneEvents_);
for (int block = 0; block < workers_.Length; ++block)
{
doneEvents_[block].Reset();
ThreadPool.QueueUserWorkItem(workers_[block].update);
}
WaitHandle.WaitAll(doneEvents_);
}
else
{
for (int index = 0; index < getNumAgents(); ++index)
{
agents_[index].computeNeighbors();
agents_[index].computeNewVelocity();
}
for (int index = 0; index < getNumAgents(); ++index)
{
agents_[index].update();
}
}
globalTime_ += timeStep_;
return(globalTime_);
}
catch (Exception ex)
{
LogMgr.LogError(ex);
this.isError = true;
return(globalTime_);
}
}
public void BuildAgentTree()
{
kdTree_.buildAgentTree();
}
