EventManager.cpp 17.6 KB
Newer Older
Ulrich Kemloh's avatar
Ulrich Kemloh committed
1 2 3
/**
 * \file        EventManager.cpp
 * \date        Jul 4, 2014
4 5
 * \version     v0.7
 * \copyright   <2009-2015> Forschungszentrum Jülich GmbH. All rights reserved.
Ulrich Kemloh's avatar
Ulrich Kemloh committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
 *
 * \section License
 * This file is part of JuPedSim.
 *
 * JuPedSim is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * JuPedSim is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
 *
 * \section Description
 *
 *
 **/


#include <string>
#include <cstdio>
#include <cstdlib>
#include <iostream>
33
#include <algorithm>
Ulrich Kemloh's avatar
Ulrich Kemloh committed
34 35 36 37
#include <fstream>
#include <vector>
#include <math.h>
#include <stdio.h>
38
#include "../pedestrian/Pedestrian.h"
Ulrich Kemloh's avatar
Ulrich Kemloh committed
39
#include "../pedestrian/Knowledge.h"
40
#include "../mpi/LCGrid.h"
Ulrich Kemloh's avatar
Ulrich Kemloh committed
41 42 43 44 45 46 47 48
#include "../geometry/Building.h"
#include "../geometry/SubRoom.h"
#include "../geometry/Transition.h"
#include "../geometry/Point.h"
#include "../tinyxml/tinyxml.h"
#include "../IO/OutputHandler.h"
#include "../IO/IODispatcher.h"
#include "../routing/RoutingEngine.h"
49 50 51 52 53 54
#include "../routing/GlobalRouter.h"
#include "../routing/QuickestPathRouter.h"
#include "../routing/MeshRouter.h"
#include "../routing/DummyRouter.h"
#include "../routing/SafestPathRouter.h"
#include "../routing/CognitiveMapRouter.h"
55
#include "EventManager.h"
Ulrich Kemloh's avatar
Ulrich Kemloh committed
56
#include "Event.h"
57 58 59

using namespace std;

60
/*******************
Ulrich Kemloh's avatar
Ulrich Kemloh committed
61
 constructors
62 63
 ******************/

Ulrich Kemloh's avatar
Ulrich Kemloh committed
64 65
EventManager::EventManager(Building *_b)
{
Ulrich Kemloh's avatar
Ulrich Kemloh committed
66 67 68 69
     //     _event_times = vector<double>();
     //     _event_types = vector<string>();
     //     _event_states = vector<string>();
     //     _event_ids = vector<int>();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
70 71 72 73
     _building = _b;
     _eventCounter = 0;
     _dynamic = false;
     _lastUpdateTime = 0;
74 75 76
     //_deltaT = 0;
     _projectFilename=_building->GetProjectFilename();
     _projectRootDir=_building->GetProjectRootDir();
77 78
     _updateFrequency =1 ;//seconds
     _updateRadius =2;//meters
79
     _file = fopen("../events/events.txt", "r");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
80
     if (!_file) {
81 82
          Log->Write("INFO:\tFiles 'events.txt' missing. "
                    "Realtime interaction with the simulation not possible.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
83
     } else {
84
          Log->Write("INFO:\tFile 'events.txt' will be monitored for new events.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
85 86
          _dynamic = true;
     }
87

88 89
     //save the first graph
     CreateRoutingEngine(_b, true);
90 91
}

92 93 94 95
EventManager::~EventManager()
{
     if(_file)
          fclose(_file);
96 97

     _eventEngineStorage.clear();
98 99
}

Ulrich Kemloh's avatar
Ulrich Kemloh committed
100
bool EventManager::ReadEventsXml()
Ulrich Kemloh's avatar
Ulrich Kemloh committed
101
{
102
     Log->Write("INFO: \tLooking for pre-defined events in other files");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
103 104
     //get the geometry filename from the project file
     TiXmlDocument doc(_projectFilename);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
105
     if (!doc.LoadFile()) {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
106 107
          Log->Write("ERROR: \t%s", doc.ErrorDesc());
          Log->Write("ERROR: \t could not parse the project file.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
108
          return false;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
109 110 111
     }

     TiXmlElement* xMainNode = doc.RootElement();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
112
     string eventfile = "";
Ulrich Kemloh's avatar
Ulrich Kemloh committed
113
     if (xMainNode->FirstChild("events_file")) {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
114
          eventfile = _projectRootDir
115
                    + xMainNode->FirstChild("events_file")->FirstChild()->Value();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
116 117
          Log->Write("INFO: \tevents <" + eventfile + ">");
     } else {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
118
          Log->Write("INFO: \tNo events found");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
119
          return true;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
120 121 122 123
     }

     Log->Write("INFO: \tParsing the event file");
     TiXmlDocument docEvent(eventfile);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
124 125
     if (!docEvent.LoadFile()) {
          Log->Write("ERROR: \t%s", docEvent.ErrorDesc());
Ulrich Kemloh's avatar
Ulrich Kemloh committed
126
          Log->Write("ERROR: \t could not parse the event file.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
127
          return false;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
128 129 130
     }

     TiXmlElement* xRootNode = docEvent.RootElement();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
131
     if (!xRootNode) {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
132
          Log->Write("ERROR:\tRoot element does not exist.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
133
          return false;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
134 135
     }

Ulrich Kemloh's avatar
Ulrich Kemloh committed
136
     if (xRootNode->ValueStr() != "JPScore") {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
137
          Log->Write("ERROR:\tRoot element value is not 'JPScore'.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
138
          return false;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
139 140 141
     }

     TiXmlNode* xEvents = xRootNode->FirstChild("events");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
142
     if (!xEvents) {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
143
          Log->Write("ERROR:\tNo events found.");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
144
          return false;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
145
     }
146
     _updateFrequency = xmltoi(xEvents->ToElement()->Attribute("update_frequency"), 1);
147 148 149
     _updateRadius = xmltoi(xEvents->ToElement()->Attribute("update_radius"), 2);

     //Pedestrian::SetColorMode(BY_SPOTLIGHT);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
150

Ulrich Kemloh's avatar
Ulrich Kemloh committed
151 152
     for (TiXmlElement* e = xEvents->FirstChildElement("event"); e;
               e = e->NextSiblingElement("event")) {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
153 154 155 156 157 158 159 160 161 162

          //          _event_times.push_back(atoi(e->Attribute("time")));
          //          _event_types.push_back(e->Attribute("type"));
          //          _event_states.push_back(e->Attribute("state"));
          //          _event_ids.push_back(atoi(e->Attribute("id")));
          int id = atoi(e->Attribute("id"));
          double zeit = atoi(e->Attribute("time"));
          string state (e->Attribute("state"));
          string type (e->Attribute("type"));
          _events.push_back(Event(id,zeit,type,state));
Ulrich Kemloh's avatar
Ulrich Kemloh committed
163
     }
164
     Log->Write("INFO: \tEvents were initialized");
Ulrich Kemloh's avatar
Ulrich Kemloh committed
165
     return true;
166 167
}

168

Ulrich Kemloh's avatar
Ulrich Kemloh committed
169
void EventManager::ListEvents()
170
{
Ulrich Kemloh's avatar
Ulrich Kemloh committed
171
     for(const auto& event: _events)
172
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
173
          Log->Write("INFO:\t " + event.GetDescription());
Ulrich Kemloh's avatar
Ulrich Kemloh committed
174
     }
175 176
}

Ulrich Kemloh's avatar
Ulrich Kemloh committed
177 178 179 180 181 182 183 184 185 186
void EventManager::ReadEventsTxt(double time)
{
     rewind(_file);
     char cstring[256];
     int lines = 0;
     do {
          if (fgets(cstring, 30, _file) == NULL) {
               Log->Write("WARNING: \tCould not read the event file");
               return;
          }
187
          if (cstring[0] != '#') {// skip comments
Ulrich Kemloh's avatar
Ulrich Kemloh committed
188 189
               lines++;
               if (lines > _eventCounter) {
190
                    Log->Write("INFO:\tEvent: after %.2f sec: ", time);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
191 192 193 194 195
                    GetEvent(cstring);
                    _eventCounter++;
               }
          }
     } while (feof(_file) == 0);
196 197
}

198 199 200
/***********
 Update
 **********/
201 202
bool EventManager::UpdateAgentKnowledge(Building* _b)
{
Ulrich Kemloh's avatar
Ulrich Kemloh committed
203
     //#pragma omp parallel
204 205 206 207
     for(auto&& ped:_b->GetAllPedestrians())
     {
          for (auto&& door: _b->GetAllTransitions())
          {
208
               if(door.second->DistTo(ped->GetPos())<1)//distance to door to register its state
209 210 211
               {
                    //actualize the information about the newly closed door
                    if(door.second->IsOpen()==false)
212
                    {
213
                         ped->AddKnownClosedDoor(door.first, Pedestrian::GetGlobalTime());
214 215
                         ped->SetNewEventFlag(true);

216
                    }
217 218 219 220
               }
          }
     }

221 222 223 224
     //collect the peds that are allowed to forward the information.
     vector<Pedestrian*> informant;
     for(auto&& ped:_b->GetAllPedestrians())
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
225 226
          if (ped->GetNewEventFlag())
               informant.push_back(ped);
227
     }
Ulrich Kemloh's avatar
Ulrich Kemloh committed
228

229 230

     for(auto&& ped1:informant)
231 232 233 234 235
     {
          vector<Pedestrian*> neighbourhood;
          _b->GetGrid()->GetNeighbourhood(ped1,neighbourhood);
          for(auto&& ped2:neighbourhood)
          {
236
               if( (ped1->GetPos()-ped2->GetPos()).Norm()<_updateRadius)
237 238
               {
                    //maybe same room and subroom ?
239 240
                    vector<SubRoom*> empty;
                    if(_b->IsVisible(ped1->GetPos(),ped2->GetPos(),empty))
Ulrich Kemloh's avatar
Ulrich Kemloh committed
241 242 243 244
                    {
                         MergeKnowledge(ped1, ped2);  //ped1->SetSpotlight(true);
                         ped2->SetNewEventFlag(true);
                    }
245 246 247 248
               }
          }
     }

Ulrich Kemloh's avatar
Ulrich Kemloh committed
249 250 251
     //TODO: what happen when they all have the new event flag ? reset maybe?
     if(informant.size()==_b->GetAllPedestrians().size())
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
252

Ulrich Kemloh's avatar
Ulrich Kemloh committed
253 254 255 256
          for(auto&& ped:_b->GetAllPedestrians())
               ped->SetNewEventFlag(false);
     }

257
     // information speed to fast
Ulrich Kemloh's avatar
Ulrich Kemloh committed
258 259 260 261 262 263 264 265 266 267 268 269 270 271
     //     for(auto&& ped1:_b->GetAllPedestrians())
     //     {
     //          vector<Pedestrian*> neighbourhood;
     //          _b->GetGrid()->GetNeighbourhood(ped1,neighbourhood);
     //          for(auto&& ped2:neighbourhood)
     //          {
     //               if( (ped1->GetPos()-ped2->GetPos()).Norm()<_updateRadius)
     //               {
     //                    //maybe same room and subroom ?
     //                    if(_b->IsVisible(ped1->GetPos(),ped2->GetPos()))
     //                    MergeKnowledge(ped1, ped2);  //ped1->SetSpotlight(true);
     //               }
     //          }
     //     }
272

273 274 275 276 277 278 279 280 281
     //update the routers based on the configurations
     //#pragma omp parallel
     for(auto&& ped:_b->GetAllPedestrians())
     {
          if(UpdateRoute(ped)==false)
          {
               //Clear the memory and attempt to reroute
               //this can happen if all doors are known to be closed
               ped->ClearKnowledge();
282
               //Log->Write("ERROR: \t clearing ped knowledge");
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
               if(UpdateRoute(ped)==false)
               {
                    Log->Write("ERROR: \t cannot reroute the pedestrian. unknown problem");
                    //return false;
                    exit(EXIT_FAILURE);
               }
          }
     }
     return true;
}

bool EventManager::UpdateRoute(Pedestrian* ped)
{
     //create the key as string.
     //map are sorted by default
298
     string key= ped->GetKnowledgeAsString();
299 300 301 302 303 304 305 306 307 308 309
     //get the router engine corresponding to the actual configuration
     bool status=true;
     if (_eventEngineStorage.count(key)>0)
     {
          RoutingEngine* engine=_eventEngineStorage[key];
          //retrieve the old strategy
          RoutingStrategy strategy=ped->GetRouter()->GetStrategy();
          //retrieve the new router
          Router*rout =engine->GetRouter(strategy);
          //check for validity
          ped->SetRouter(rout);
310 311
          //clear all previous routes
          ped->ClearMentalMap();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
312
          //ped->ClearKnowledge();
313 314 315 316 317
          //overwrite/update the pedestrian router
          if(!rout) status= false;
     }
     else
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
318
          Log->Write("WARNING: \t unknown configuration <%s>", key.c_str());
319
          //Log->Write("WARNING: \t  [%d] router available", _eventEngineStorage.size());
Ulrich Kemloh's avatar
Ulrich Kemloh committed
320 321
          //Log->Write("       : \t trying to create");
          //CreateRoutingEngine(_building);
322 323 324 325 326 327 328
          status= false;
     }
     return status;
}

void EventManager::MergeKnowledge(Pedestrian* p1, Pedestrian* p2)
{
329 330
     auto const & old_info1 = p1->GetKnownledge();
     auto const & old_info2 = p2->GetKnownledge();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
331
     map<int, Knowledge> merge_info;
332 333 334 335 336 337 338

     //collect the most recent knowledge
     for (auto&& info1 : old_info1)
     {
          merge_info[info1.first] = info1.second;
     }

339
     for (auto&& info2 : old_info2)
340 341
     {
          //update infos according to a newest time
342
          if (merge_info.count(info2.first) > 0)
343
          {
344
               if (info2.second.GetTime() > merge_info[info2.first].GetTime())
345
               {
346
                    merge_info[info2.first] = info2.second;
347 348
               }
          }
349
          else //the info was not present, just add
350
          {
351
               merge_info[info2.first] = info2.second;
352 353 354 355 356 357 358 359
          }
     }

     //synchronize the knowledge
     p1->ClearKnowledge();
     p2->ClearKnowledge();
     for (auto&& info : merge_info)
     {
360 361
          p1->AddKnownClosedDoor(info.first, info.second.GetTime());
          p2->AddKnownClosedDoor(info.first, info.second.GetTime());
362 363 364 365 366
     }
}

void EventManager::ProcessEvent()
{
Ulrich Kemloh's avatar
Ulrich Kemloh committed
367
     if (_events.size() == 0) return;
368 369 370 371

     int current_time = Pedestrian::GetGlobalTime();

     if ( (current_time != _lastUpdateTime) &&
372
               ((current_time % _updateFrequency) == 0))
373 374 375 376 377 378
     {
          //update knowledge about closed doors
          //share the information between the pedestrians
          UpdateAgentKnowledge(_building);
          //actualize based on the new knowledge
          _lastUpdateTime = current_time;
Ulrich Kemloh's avatar
Ulrich Kemloh committed
379
          cout<<"updating..."<<current_time<<endl<<endl;
380 381 382 383 384
     }

     //update the building state
     // the time is needed as double
     double current_time_d = Pedestrian::GetGlobalTime();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
385 386

     for(const auto& event: _events)
387
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
388
          if (fabs(event.GetTime() - current_time_d) < J_EPS_EVENT) {
389
               //Event with current time stamp detected
390
               Log->Write("INFO:\tEvent: after %.2f sec: ", current_time_d);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
391 392
               if (event.GetState().compare("close") == 0) {
                    CloseDoor(event.GetId());
393
               } else {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
394
                    OpenDoor(event.GetId());
395 396
               }
          }
Ulrich Kemloh's avatar
Ulrich Kemloh committed
397

398 399 400 401 402 403 404
     }

     if (_dynamic)
          ReadEventsTxt(current_time);
}


405 406

/***************
407
 Event handling
408
 **************/
Ulrich Kemloh's avatar
Ulrich Kemloh committed
409
//close the door if it was open and relaunch the routing procedure
Ulrich Kemloh's avatar
Ulrich Kemloh committed
410 411 412
void EventManager::CloseDoor(int id)
{
     Transition *t = _building->GetTransition(id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
413 414
     if (t->IsOpen())
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
415
          t->Close();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
416
          Log->Write("INFO:\tClosing door %d ", id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
417 418 419 420 421
          //Create and save a graph corresponding to the actual state of the building.
          if(CreateRoutingEngine(_building)==false)
          {
               Log->Write("ERROR: \tcannot create a routing engine with the new event");
          }
Ulrich Kemloh's avatar
Ulrich Kemloh committed
422
     } else {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
423
          Log->Write("WARNING: \tdoor %d is already close", id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
424
     }
425 426 427

}

Ulrich Kemloh's avatar
Ulrich Kemloh committed
428
//open the door if it was open and relaunch the routing procedure
Ulrich Kemloh's avatar
Ulrich Kemloh committed
429 430 431
void EventManager::OpenDoor(int id)
{
     Transition *t = _building->GetTransition(id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
432 433
     if (!t->IsOpen())
     {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
434
          t->Open();
Ulrich Kemloh's avatar
Ulrich Kemloh committed
435
          Log->Write("INFO:\tOpening door %d ", id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
436 437 438 439 440
          //Create and save a graph corresponding to the actual state of the building.
          if(CreateRoutingEngine(_building)==false)
          {
               Log->Write("ERROR: \tcannot create a routing engine with the new event");
          }
Ulrich Kemloh's avatar
Ulrich Kemloh committed
441
     } else {
Ulrich Kemloh's avatar
Ulrich Kemloh committed
442
          Log->Write("WARNING: \tdoor %d is already open", id);
Ulrich Kemloh's avatar
Ulrich Kemloh committed
443
     }
444 445
}

Ulrich Kemloh's avatar
Ulrich Kemloh committed
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
void EventManager::GetEvent(char* c)
{
     int split = 0;
     string type = "";
     string id = "";
     string state = "";
     for (int i = 0; i < 20; i++) {
          if (!c[i]) {
               break;
          } else if (c[i] == ' ') {
               split++;
          } else if (c[i] == '\n') {

          } else {
               if (split == 0) {
                    type += c[i];
               } else if (split == 1) {
                    id += c[i];
               } else if (split == 2) {
                    state += c[i];
               }
          }
     }
     if (state.compare("close") == 0) {
          CloseDoor(atoi(id.c_str()));
     } else {
          OpenDoor(atoi(id.c_str()));
     }
474
}
475 476 477 478

bool EventManager::CreateRoutingEngine(Building* _b, int first_engine)
{
     std::vector<int> closed_doors;
479
     closed_doors.clear();
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545

     for(auto&& t:_b->GetAllTransitions())
     {
          if(t.second->IsOpen()==false)
               closed_doors.push_back(t.second->GetID());
     }
     std::sort(closed_doors.begin(), closed_doors.end());

     //create the key as string.
     string key="";
     for(int door:closed_doors)
     {
          if(key.empty())
               key.append(std::to_string(door));
          else
               key.append(":"+std::to_string(door));
     }

     //the first (default) engine was created in the simulation
     // collect the defined routers
     if(first_engine)
     {
          RoutingEngine* engine=_b->GetRoutingEngine();
          _eventEngineStorage[key]=engine;

          for(auto&& rout: engine->GetAvailableRouters())
          {
               _availableRouters.push_back(rout->GetStrategy());
          }
          Log->Write("INFO: \tAdding a new routing Engine with the key: "+key+"\n");
          return true;
     }

     // the engine was not created
     // create a new one with the actual configuration
     if (_eventEngineStorage.count(key)==0)
     {
          //std::shared_ptr<RoutingEngine> engine = std::shared_ptr<RoutingEngine>(new RoutingEngine());
          //engine.get()->Init(_b);
          //_eventEngineStorage[key]=engine.get();

          //populate the engine with the routers defined in the ini file
          //and initialize
          RoutingEngine* engine= new RoutingEngine();
          for(auto&& rout:_availableRouters)
          {
               engine->AddRouter(CreateRouter(rout));
          }

          if(engine->Init(_b)==false)
               return false;

          //save the configuration
          _eventEngineStorage[key]=engine;
          Log->Write("INFO: \tAdding a new routing Engine with the key: "+key+"\n");
     }
     else
     {
          Log->Write("INFO: \tA routing already exits with the key: "+key+"\n");
     }

     return true;
}

Router * EventManager::CreateRouter(const RoutingStrategy& strategy)
{
Ulrich Kemloh's avatar
Ulrich Kemloh committed
546
     Router * rout=nullptr;
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579

     switch(strategy)
     {
     case ROUTING_LOCAL_SHORTEST:
          rout = new GlobalRouter(ROUTING_LOCAL_SHORTEST, ROUTING_LOCAL_SHORTEST);
          break;

     case ROUTING_GLOBAL_SHORTEST:
          rout = new GlobalRouter(ROUTING_GLOBAL_SHORTEST, ROUTING_GLOBAL_SHORTEST);
          break;

     case ROUTING_QUICKEST:
          rout = new QuickestPathRouter(ROUTING_QUICKEST, ROUTING_QUICKEST);
          break;

     case ROUTING_NAV_MESH:
          rout = new MeshRouter(ROUTING_NAV_MESH, ROUTING_NAV_MESH);
          break;

     case ROUTING_DUMMY:
          rout = new DummyRouter(ROUTING_DUMMY, ROUTING_DUMMY);
          break;

     case ROUTING_SAFEST:
          rout = new SafestPathRouter(ROUTING_SAFEST, ROUTING_SAFEST);
          break;

     case ROUTING_COGNITIVEMAP:
          rout = new CognitiveMapRouter(ROUTING_COGNITIVEMAP, ROUTING_COGNITIVEMAP);
          break;

     default:
          Log->Write("ERROR: \twrong value for routing strategy [%d]!!!\n", strategy );
580
          exit(EXIT_FAILURE);
581 582 583 584 585
          break;

     }
     return rout;
}
586 587