JPolicy.hh

Go to the documentation of this file.

#ifndef __JCOMPASS__JPOLICY__
#define __JCOMPASS__JPOLICY__

#include <map>
#include <vector>
#include <set>

#include "JDetector/JModuleRouter.hh"
#include "JDetector/JLocation.hh"

/**
 * \file
 *
 * Policy for invalid modules.
 * \author mdejong
 */

namespace JCOMPASS {}
namespace JPP { using namespace JCOMPASS; }

namespace JCOMPASS {

  using JDETECTOR::JModuleRouter;

  /**
   * Auxiliary class to define policy for invalid modules.
   *
   * The policy is defined as a map of the identifier of a module to a list of identifiers of valid modules.\n
   * For invalid modules, the valid modules in the nearest floors in the same string are selected.
   */
  struct JPolicy : 
    public std::map<int,                                // identifier of module
                    std::vector<int> >                  // identifiers of valid module(s)
  {
    /**
     * Constructor.
     *
     * \param  router            module router
     * \param  __begin           begin of list with identifiers of valid modules
     * \param  __end             end   of list with identifiers of valid modules
     * \param  size              minimum number of valid modules in case of an invalid module
     */
    template<class T>
    JPolicy(const JModuleRouter& router, T __begin, T __end, const size_t size = 1)
    {
      using namespace std;
      using namespace JPP;

      map<int, set<int> > zmap;                         // valid floors per string

      for (T i = __begin; i != __end; ++i) {
        
        if (router.hasModule(*i)) {

          const JLocation& location = router.getModule(*i);

          zmap[location.getString()].insert(location.getFloor());
        }
      }

      map<JLocation, int> detector;                     // inverse router

      for (JModuleRouter::const_iterator module = router->begin(); module != router->end(); ++module) {
        detector[module->getLocation()] = module->getID();
      }

      for (JModuleRouter::const_iterator module = router->begin(); module != router->end(); ++module) {

        if (module->getFloor() != 0) {

          const int id     = module->getID();
          const int string = module->getString();

          if (!zmap[string].empty()) {
          
            if (zmap[string].count(module->getFloor()) != 0) {

              (*this)[id].push_back(id);

            } else {

              for (size_t step = 1; (*this)[id].size() < size && (module->getFloor() + (int) step <= *zmap[string].rbegin() ||
                                                                  module->getFloor() - (int) step >= *zmap[string]. begin()); ++step) {
                for (int sign : { -1, +1 }) {

                  const int floor  = module->getFloor()  +  sign * step;

                  if (zmap[string].count(floor) != 0) {
                    (*this)[id].push_back(detector[JLocation(string,floor)]);
                  }
                }
              }
            }
          }
        }
      }
    }
  };
}

#endif