PrePostDependentDelay.cpp

Go to the documentation of this file.

#include "PrePostDependentDelay.h"


DelayCond::DelayCond(double v_mean, double v_SH, double v_min, double v_max)
    : v_mean(v_mean), v_SH(v_SH), v_min(v_min), v_max(v_max)
    , v_dist(v_mean, v_SH, v_min, v_max)
{
}


DelayCond::~DelayCond()
{
}


double DelayCond::generate(size_t src_idx, size_t dst_idx, RandomEngine *rnd)
{
    if(rnd != NULL)
        rnd_eng=rnd;

    Point3D<double> s = m_sourcePopulation->getLocation(src_idx);
    Point3D<double> d = m_destinationPopulation->getLocation(dst_idx);

    return distance(s, d)/v_dist(*rnd_eng);
}


ConnObjectValueGenerator* DelayCond::clone(void) const
{
    return new DelayCond(v_mean, v_SH, v_min, v_max);
}



DelayCondAndSyn::DelayCondAndSyn(double v_mean, double v_SH, double v_min, double v_max,
                                 double d_mean, double d_SH, double d_min, double d_max)
    : v_mean(v_mean), v_SH(v_SH), v_min(v_min), v_max(v_max)
    , d_mean(d_mean), d_SH(v_SH), d_min(d_min), d_max(d_max)
    , v_dist(v_mean, v_SH, v_min, v_max)
    , delay_dist(d_mean, d_SH, d_min, d_max)
{
}


DelayCondAndSyn::~DelayCondAndSyn()
{
}


double DelayCondAndSyn::generate(size_t src_idx, size_t dst_idx, RandomEngine *rnd)
{
    if(rnd!=NULL)
        rnd_eng=rnd;

    Point3D<double> s = m_sourcePopulation->getLocation(src_idx);
    Point3D<double> d = m_destinationPopulation->getLocation(dst_idx);

    return distance(s, d)/v_dist(*rnd_eng)+delay_dist(*rnd_eng);
}


ConnObjectValueGenerator* DelayCondAndSyn::clone(void) const
{
    return new DelayCondAndSyn(v_mean, v_SH, v_min, d_max, d_mean, d_SH, d_min, d_max);
}



LateralDelayCondAndSyn::LateralDelayCondAndSyn(double v_mean, double v_SH, double v_min, double v_max,
                                               double d_mean, double d_SH, double d_min, double d_max,
                                               bool toroid, double toroid_off, double z_scale,
                                               double src_scale, double dst_scale,
                                               double src_center_x, double src_center_y,
                                               double dst_center_x, double dst_center_y,
                                               double src_shape_x, double src_shape_y,
                                               double dst_shape_x, double dst_shape_y)

    : v_mean(v_mean), v_SH(v_SH), v_min(v_min), v_max(v_max)
    , d_mean(d_mean), d_SH(v_SH), d_min(d_min), d_max(d_max)       
    , m_toroid(toroid)
    , m_toroid_off(toroid_off)
    , m_z_scale(z_scale)
    , m_src_scale(src_scale)
    , m_dst_scale(dst_scale)
    , m_src_center_x(src_center_x)
    , m_src_center_y(src_center_y)
    , m_dst_center_x(dst_center_x)
    , m_dst_center_y(dst_center_y)
    , m_src_shape_x(src_shape_x)
    , m_src_shape_y(src_shape_y)
    , m_dst_shape_x(dst_shape_x)
    , m_dst_shape_y(dst_shape_y)
    , v_dist(v_mean, v_SH, v_min, v_max)
    , delay_dist(d_mean, d_SH, d_min, d_max)

{
  min_sx=min_sy=max_sx=max_sy=0.0;
  min_dx=min_dy=max_dx=max_dy=0.0;

  if (m_toroid)
    {      
      //x in centered coordinates
      min_sx= m_src_scale * (-(m_src_shape_x - 1.0) / 2.0 ) - m_toroid_off;
      max_sx= m_src_scale * ((m_src_shape_x - 1.0) / 2.0);
      
      min_dx= m_dst_scale * (-(m_dst_shape_x - 1.0) / 2.0) - m_toroid_off;
      max_dx= m_dst_scale * ((m_dst_shape_x - 1.0) / 2.0);
      
      //y
      min_sy= m_src_scale * (-(m_src_shape_y - 1.0) / 2.0) - m_toroid_off;
      max_sy= m_src_scale * ((m_src_shape_y - 1.0) / 2.0);
      
      min_dy= m_dst_scale * (-(m_dst_shape_y - 1.0) / 2.0) - m_toroid_off;
      max_dy= m_dst_scale * ((m_dst_shape_y - 1.0) / 2.0);
    }

}




LateralDelayCondAndSyn::~LateralDelayCondAndSyn()
{
}


double LateralDelayCondAndSyn::generate(size_t src_idx, size_t dst_idx, RandomEngine *rnd)
{
    if(rnd!=NULL)
        rnd_eng=rnd;

    Point3D<double> s = m_sourcePopulation->getLocation(src_idx);

    s.x((s.x()-m_src_center_x)*m_src_scale);
    s.y((s.y()-m_src_center_y)*m_src_scale);
    s.z(s.z()*m_z_scale);

    Point3D<double> d = m_destinationPopulation->getLocation(dst_idx);

    d.x((d.x()-m_dst_center_x)*m_dst_scale);
    d.y((d.y()-m_dst_center_y)*m_dst_scale);
    d.z(d.z()*m_z_scale);

    double dist=0.0;

    if (!m_toroid)
    {
        dist=distance(s,d);
    }
    else
    {
        double d1 = fabs(d.x() - s.x());
        double d2 = fabs(max_dx - d.x()) + fabs(min_sx - s.x());
        double d3 = fabs(max_sx - s.x()) + fabs(min_dx - d.x());
        
            double dx = min(min(d1,d2), d3);
        
        d1 = fabs(d.y() - s.y());
        d2 = fabs(max_dy - d.y()) + fabs(min_sy - s.y());
        d3 = fabs(max_sy - s.y()) + fabs(min_dy - d.y());
        
        double dy = min(min(d1,d2), d3);
        double dz = fabs(d.z() - s.z());

        dist = sqrt(dx*dx + dy*dy + dz*dz);
    }

    return dist/v_dist(*rnd_eng)+delay_dist(*rnd_eng);
}


ConnObjectValueGenerator* LateralDelayCondAndSyn::clone(void) const
{
    return new LateralDelayCondAndSyn(v_mean, v_SH, v_min, d_max, d_mean, d_SH, d_min, d_max, m_toroid,
                                      m_toroid_off, m_z_scale, m_src_scale, m_dst_scale, 
                                      m_src_center_x, m_src_center_y, 
                                      m_dst_center_x,  m_dst_center_y,
                                      m_src_shape_x, m_src_shape_y,
                                      m_dst_shape_x, m_dst_shape_y);
}

---