Line data    Source code

       1              : #include "crpropa/module/Tools.h"
       2              : #include "crpropa/Clock.h"
       3              : 
       4              : #include <iostream>
       5              : #include <sstream>
       6              : 
       7              : using namespace std;
       8              : 
       9              : namespace crpropa {
      10              : 
      11            0 : PerformanceModule::~PerformanceModule() {
      12              :         double total = 0;
      13            0 :         for (size_t i = 0; i < modules.size(); i++) {
      14              :                 _module_info &m = modules[i];
      15            0 :                 total += m.time;
      16              :         }
      17            0 :         cout << "Performance for " << calls << " calls:" << endl;
      18            0 :         for (size_t i = 0; i < modules.size(); i++) {
      19              :                 _module_info &m = modules[i];
      20            0 :                 cout << " - " << floor((1000 * m.time / total) + 0.5) / 10 << "% -> "
      21            0 :                                 << m.module->getDescription() << ": " << (m.time / calls)
      22              :                                 << endl;
      23              :         }
      24            0 : }
      25              : 
      26            0 : void PerformanceModule::add(Module *module) {
      27              :         _module_info info;
      28            0 :         info.module = module;
      29            0 :         info.time = 0;
      30            0 :         modules.push_back(info);
      31            0 : }
      32              : 
      33            0 : void PerformanceModule::process(Candidate *candidate) const {
      34            0 :         vector<double> times(modules.size());
      35            0 :         for (size_t i = 0; i < modules.size(); i++) {
      36              :                 _module_info &m = modules[i];
      37            0 :                 double start = Clock::getInstance().getMillisecond();
      38            0 :                 m.module->process(candidate);
      39            0 :                 double end = Clock::getInstance().getMillisecond();
      40            0 :                 times[i] = end - start;
      41              :         }
      42              : 
      43            0 : #pragma omp critical(PerformanceModule)
      44              :         {
      45            0 :                 for (size_t i = 0; i < modules.size(); i++) {
      46              :                         _module_info &m = modules[i];
      47            0 :                         m.time += times[i];
      48              :                 }
      49            0 :                 calls++;
      50              :         }
      51            0 : }
      52              : 
      53            0 : string PerformanceModule::getDescription() const {
      54            0 :         stringstream sstr;
      55            0 :         sstr << "PerformanceModule (";
      56            0 :         for (size_t i = 0; i < modules.size(); i++) {
      57              :                 _module_info &m = modules[i];
      58            0 :                 if (i > 0)
      59            0 :                         sstr << ", ";
      60            0 :                 sstr << m.module->getDescription();
      61              :         }
      62            0 :         sstr << ")";
      63            0 :         return sstr.str();
      64            0 : }
      65              : 
      66              : // ----------------------------------------------------------------------------
      67            0 : ParticleFilter::ParticleFilter() {
      68              : 
      69            0 : }
      70            1 : ParticleFilter::ParticleFilter(const std::set<int> &ids) : ids(ids) {
      71              : 
      72            1 : }
      73            0 : void ParticleFilter::addId(int id) {
      74              :         ids.insert(id);
      75            0 : }
      76            0 : void ParticleFilter::removeId(int id) {
      77              :         ids.erase(id);
      78            0 : }
      79              : 
      80            0 : std::set<int> &ParticleFilter::getIds() {
      81            0 :         return ids;
      82              : }
      83              : 
      84            7 : void ParticleFilter::process(Candidate* candidate) const {
      85           14 :         if (ids.find(candidate->current.getId()) == ids.end())
      86            5 :                 reject(candidate);
      87              :         else
      88            2 :                 accept(candidate);
      89            7 : }
      90              : 
      91            0 : string ParticleFilter::getDescription() const {
      92            0 :         stringstream sstr;
      93            0 :         sstr << "ParticleFilter: ";
      94            0 :         for (std::set<int>::const_iterator i = ids.begin(); i != ids.end(); i++) {
      95            0 :                 sstr << *i << ", ";
      96              :         }
      97            0 :         sstr << ")";
      98            0 :         return sstr.str();
      99            0 : }
     100              : 
     101              : // ----------------------------------------------------------------------------
     102            0 : EmissionMapFiller::EmissionMapFiller(EmissionMap *emissionMap) : emissionMap(emissionMap) {
     103              : 
     104            0 : }
     105              : 
     106            0 : void EmissionMapFiller::setEmissionMap(EmissionMap *emissionMap) {
     107            0 :         this->emissionMap = emissionMap;
     108            0 : }
     109              : 
     110            0 : void EmissionMapFiller::process(Candidate* candidate) const {
     111            0 :         if (emissionMap) {
     112            0 :                 #pragma omp critical(EmissionMap)
     113              :                 {
     114            0 :                         emissionMap->fillMap(candidate->source);
     115              :                 }
     116              :         }
     117            0 : }
     118              : 
     119            0 : string EmissionMapFiller::getDescription() const {
     120            0 :         return "EmissionMapFiller";
     121              : }
     122              : 
     123              : } // namespace crpropa