LateralEuclidianDistanceConnectionPredicate.h

Go to the documentation of this file.

#ifndef LATERALEUCLIDIANDISTANCECONNECTIONPREDICATE_H
#define LATERALEUCLIDIANDISTANCECONNECTIONPREDICATE_H

#include <ConnectionDecisionPredicateSpecialization.h>

#include <cmath>
#include "Point2D.h"


class LateralEuclidianDistanceConnectionPredicate : public SpatialConnectionDecisionPredicate
{
public:
    LateralEuclidianDistanceConnectionPredicate(double C,
                                                double lambd,
                                                bool toroid=false,
                                                double toroid_off=0.0,
                                                int src_shape_x=1, int src_shape_y=1,
                                                int dst_shape_x=1, int dst_shape_y=1,
                                                double src_scale=1.0,
                                                double dst_scale=1.0,
                                                double src_center_x=0.0, double src_center_y=0.0,
                                                double dst_center_x=0.0, double dst_center_y=0.0
                                                )
        : m_C(C)
        , m_L2(lambd*lambd)
        , m_distance(toroid, toroid_off,
                     src_shape_x, src_shape_y,
                     dst_shape_x, dst_shape_y,
                     src_scale, dst_scale,
                     Point2D<double>(src_center_x, src_center_y),
                     Point2D<double>(dst_center_x, dst_center_y))
        , m_unirnd(0.0, 1.0)
    {
    };

/*
    virtual void init( SimObjectPopulation const& src, SimObjectPopulation const& dst, RandomEngine *rnd)
    {
        SpatialConnectionDecisionPredicate::init(src, dst, rnd);
    };
*/


    virtual bool decide( size_t src, size_t dst, RandomEngine *rnd )
    {
        if (m_sourcePopulation->getID(src) == m_destinationPopulation->getID(dst))
            return false;

        Point2D<double> s(m_sourcePopulation->getLocation(src));
        Point2D<double> d(m_destinationPopulation->getLocation(dst));

        double sqr_dist=m_distance.sqr_distance(s, d);

        return (m_unirnd(*rnd) < m_C*exp(-0.5* sqr_dist/ m_L2));
    };

private:
    double m_C;
    double m_L2;

    Point2DDistance<double> m_distance;
    UniformDistribution m_unirnd;
};

#endif

---