pgrouting::vrp::Vehicle Class Reference

Vehicle with time windows. More...

#include "vehicle.h"

Inheritance diagram for pgrouting::vrp::Vehicle:

Collaboration diagram for pgrouting::vrp::Vehicle:

Public Types
typedef std::tuple< int, int, size_t, double, double >	Cost

Public Member Functions
	Vehicle (const Vehicle &)=default
	Vehicle (size_t idx, int64_t id, const Vehicle_node &starting_site, const Vehicle_node &ending_site, double p_capacity, double p_speed, double p_factor)
std::pair< POS, POS >	drop_position_limits (const Vehicle_node node) const
std::vector< General_vehicle_orders_t >	get_postgres_result (int vid) const
int64_t	id () const
size_t	idx () const
bool	is_phony () const
std::pair< POS, POS >	position_limits (const Vehicle_node node) const
void	reset_id (int64_t)
double	speed () const
void	swap (POS i, POS j)
	Swap two nodes in the path. More...

Static Public Member Functions
static Pgr_messages &	msg ()
	Access to the problem's message. More...

Static Public Attributes
static Pgr_pickDeliver *	problem
	Pointer to problem. More...

Protected Types
using	difference_type = std::deque< Vehicle_node >::difference_type
typedef size_t	POS

Protected Attributes
std::deque< Vehicle_node >	m_path

Private Member Functions
POS	getDropPosLowLimit (const Vehicle_node &node) const
POS	getPosHighLimit (const Vehicle_node &node) const
POS	getPosLowLimit (const Vehicle_node &node) const

Private Attributes
double	m_capacity
double	m_factor
int64_t	m_id
size_t	m_idx
double	m_speed

Friends
class	PD_problem

operators
std::ostream &	operator<< (std::ostream &log, const Vehicle &v)
	@ { More...
bool	operator< (const Vehicle &lhs, const Vehicle &rhs)
std::string	tau () const

Detailed Description

Vehicle with time windows.

General functionality for a vehicle in a VRP problem

Recommended use:

Class my_vehicle : public vechicle

Note

All members return true when the operation is successful

A vehicle is a sequence of Vehicle_node from starting site to ending site. has: capacity speed factor TODO(vicky)

See also

Vehicle_node

Definition at line 73 of file vehicle.h.

Member Typedef Documentation

Cost

typedef std::tuple< int, int, size_t, double, double > pgrouting::vrp::Vehicle::Cost

Definition at line 90 of file vehicle.h.

difference_type

using pgrouting::vrp::Vehicle::difference_type = std::deque<Vehicle_node>::difference_type

protected

Definition at line 76 of file vehicle.h.

POS

typedef size_t pgrouting::vrp::Vehicle::POS

protected

Definition at line 75 of file vehicle.h.

Constructor & Destructor Documentation

Vehicle() [1/2]

pgrouting::vrp::Vehicle::Vehicle ( const Vehicle &  )

default

Vehicle() [2/2]

pgrouting::vrp::Vehicle::Vehicle	(	size_t	idx,
		int64_t	id,
		const Vehicle_node &	starting_site,
		const Vehicle_node &	ending_site,
		double	p_capacity,
		double	p_speed,
		double	p_factor
	)

Definition at line 419 of file vehicle.cpp.

                         :
    Identifier(p_idx, p_id),
    m_capacity(p_m_capacity),
    m_factor(p_factor),
    m_speed(p_speed) {
#if 0
        ENTERING();
#endif
        m_path.clear();
        pgassert(starting_site.opens() <= starting_site.closes());
        pgassert(ending_site.opens() <= ending_site.closes());
        pgassert(capacity() > 0);
#if 0
        msg().log << "p_idx: " << p_idx << "\t idx(): " << idx() << "\n";
        msg().log << "p_id: " << p_id << "\tid(): " << id() << "\n";
#endif
 
        m_path.push_back(starting_site);
        m_path.push_back(ending_site);
 
        evaluate(0);
        msg().log << tau() << "\n";
        invariant();
#if 0
        EXITING();
#endif
    }

References capacity(), pgrouting::vrp::Tw_node::closes(), ENTERING, evaluate(), EXITING, pgrouting::Identifier::id(), pgrouting::Identifier::idx(), invariant(), pgrouting::Pgr_messages::log, m_path, msg(), pgrouting::vrp::Tw_node::opens(), pgassert, and tau().

Member Function Documentation

capacity()

double pgrouting::vrp::Vehicle::capacity ( ) const

inline

Definition at line 238 of file vehicle.h.

{return m_capacity;}

References m_capacity.

Referenced by Vehicle().

cost()

Vehicle::Cost pgrouting::vrp::Vehicle::cost

(

)

const

Definition at line 175 of file vehicle.cpp.

                    {
    return std::make_tuple(
            twvTot(), cvTot(), m_path.size(),
            total_wait_time(), duration());
}

References cvTot(), duration(), m_path, total_wait_time(), and twvTot().

Referenced by insert().

cost_compare()

bool pgrouting::vrp::Vehicle::cost_compare	(	const Cost &	lhs,
		const Cost &	rhs
	)		const

Definition at line 97 of file vehicle.cpp.

                                                            {
    /*
     * capacity violations
     */
    if (std::get<1>(lhs) < std::get<1>(rhs))
        return true;
    if (std::get<1>(lhs) > std::get<1>(rhs))
        return false;
 
    /*
     * time window violations
     */
    if (std::get<0>(lhs) < std::get<0>(rhs))
        return true;
    if (std::get<0>(lhs) > std::get<0>(rhs))
        return false;
 
    /*
     * waiting time
     */
    if (std::get<3>(lhs) < std::get<3>(rhs))
        return true;
    if (std::get<3>(lhs) > std::get<3>(rhs))
        return false;
 
    /*
     * duration
     */
    if (std::get<4>(lhs) < std::get<4>(rhs))
        return true;
    if (std::get<4>(lhs) > std::get<4>(rhs))
        return false;
 
    /*
     * truck size
     */
    if (std::get<2>(lhs) < std::get<2>(rhs))
        return true;
    if (std::get<2>(lhs) > std::get<2>(rhs))
        return false;
 
    return false;
}

Referenced by insert().

cvTot()

int pgrouting::vrp::Vehicle::cvTot ( ) const

inline

Definition at line 216 of file vehicle.h.

                       {
         return m_path.back().cvTot();
     }

References m_path.

Referenced by cost(), has_cv(), and tau().

drop_position_limits()

std::pair< size_t, size_t > pgrouting::vrp::Vehicle::drop_position_limits

(

const Vehicle_node

node

)

const

Definition at line 306 of file vehicle.cpp.

                                                           {
    POS high = getPosHighLimit(node);
    POS low = getDropPosLowLimit(node);
    return std::make_pair(low, high);
}

References getDropPosLowLimit(), and getPosHighLimit().

Referenced by pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

duration()

double pgrouting::vrp::Vehicle::duration ( ) const

inline

Definition at line 201 of file vehicle.h.

                             {
         return m_path.back().departure_time();
     }

References m_path.

Referenced by cost(), pgrouting::vrp::Vehicle_pickDeliver::insert(), and tau().

empty()

bool pgrouting::vrp::Vehicle::empty

(

)

const

return true when no nodes are in the truck

True: S E
False: S <nodes> E

Definition at line 259 of file vehicle.cpp.

                     {
    invariant();
    return m_path.size() <= 2;
}

References invariant(), and m_path.

Referenced by pgrouting::vrp::Optimize::move_order().

end_site()

Vehicle_node pgrouting::vrp::Vehicle::end_site ( ) const

inline

Definition at line 235 of file vehicle.h.

                                   {
         return m_path.back();
     }

References m_path.

Referenced by is_ok().

erase() [1/2]

void pgrouting::vrp::Vehicle::erase

(

const Vehicle_node &

node

)

Erase node.id()

Note

start and ending nodes cannot be erased

Numbers are positions before: S .... node.id() .... E after: S .... .... E

Todo:

TODO evaluate with matrix also

Definition at line 198 of file vehicle.cpp.

                                       {
    invariant();
 
    POS pos = 0;
    for ( ; pos < m_path.size() ; ++pos) {
        if (node.idx() == m_path[pos].idx())
            break;
    }
 
    erase(pos);
    evaluate(pos);
 
    invariant();
}

References evaluate(), pgrouting::Identifier::idx(), invariant(), and m_path.

Referenced by pgrouting::vrp::Vehicle_pickDeliver::erase(), pgrouting::vrp::Vehicle_pickDeliver::insert(), and pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

erase() [2/2]

void pgrouting::vrp::Vehicle::erase

(

POS

pos

)

Erase node at pos from the path.

Note

start and ending nodes cannot be erased

Numbers are positions before: S 1 2 3 4 5 6 pos 8 9 E after: S 1 2 3 4 5 6 8 9 E

Parameters

[in]

pos

to be erased.

Definition at line 219 of file vehicle.cpp.

                     {
    invariant();
 
    pgassert(m_path.size() > 2);
    pgassert(at < m_path.size());
    pgassert(!m_path[at].is_start());
    pgassert(!m_path[at].is_end());
 
    m_path.erase(m_path.begin() + static_cast<difference_type>(at));
    evaluate(at);
 
    invariant();
}

References evaluate(), invariant(), m_path, and pgassert.

evaluate() [1/2]

void pgrouting::vrp::Vehicle::evaluate

(

)

@ {

Evaluate: Evaluate the whole path from the start.

Definition at line 250 of file vehicle.cpp.

                  {
    invariant();
 
    evaluate(0);
 
    invariant();
}

References invariant().

Referenced by erase(), insert(), pgrouting::vrp::Vehicle_pickDeliver::push_back(), pgrouting::vrp::Vehicle_pickDeliver::push_front(), swap(), and Vehicle().

evaluate() [2/2]

void pgrouting::vrp::Vehicle::evaluate

(

POS

from

)

Evaluate: Evaluate a path from the given position.

Parameters

[in]

from

The starting position in the path for evaluation to the end of the path.

Definition at line 271 of file vehicle.cpp.

                          {
    invariant();
    // preconditions
    pgassert(from < m_path.size());
 
 
    auto node = m_path.begin() + static_cast<difference_type>(from);
 
    while (node != m_path.end()) {
        if (node == m_path.begin()) {
            node->evaluate(m_capacity);
        } else {
            node->evaluate(*(node - 1), m_capacity, speed());
        }
 
        ++node;
    }
    invariant();
}

References invariant(), m_capacity, m_path, pgassert, and speed().

get_postgres_result()

std::vector< General_vehicle_orders_t > pgrouting::vrp::Vehicle::get_postgres_result

(

int

vid

)

const

Definition at line 144 of file vehicle.cpp.

                       {
    std::vector<General_vehicle_orders_t> result;
    /* postgres numbering starts with 1 */
    int stop_seq(1);
    msg().log << "getting solution: " << tau() << "\n";
    for (const auto &p_stop : m_path) {
        General_vehicle_orders_t data = {
            vid,
            id(),
            stop_seq,
            /* order_id
             * The order_id is invalid for stops type 0 and 5
             */
            (p_stop.type() == 0 || p_stop.type() == 5)? -1 : p_stop.order(),
            p_stop.id(),
            p_stop.type(),
            p_stop.cargo(),
            p_stop.travel_time(),
            p_stop.arrival_time(),
            p_stop.wait_time(),
            p_stop.service_time(),
            p_stop.departure_time()};
        result.push_back(data);
        ++stop_seq;
    }
    return result;
}

References pgrouting::Identifier::id(), pgrouting::Pgr_messages::log, m_path, msg(), and tau().

getDropPosLowLimit()

size_t pgrouting::vrp::Vehicle::getDropPosLowLimit ( const Vehicle_node &  node ) const

private

Definition at line 327 of file vehicle.cpp.

                                                           {
    invariant();
 
    POS low = 0;
    POS high = m_path.size();
    POS low_limit = high;
 
    /* J == m_path[low_limit - 1] */
    while (low_limit > low
            && m_path[low_limit - 1].is_compatible_IJ(nodeI, speed())
            && !m_path[low_limit - 1].is_pickup()) {
        --low_limit;
    }
 
    invariant();
    return low_limit;
}

References invariant(), m_path, and speed().

Referenced by drop_position_limits().

getPosHighLimit()

size_t pgrouting::vrp::Vehicle::getPosHighLimit ( const Vehicle_node &  node ) const

private

Definition at line 392 of file vehicle.cpp.

                                                        {
    invariant();
 
    POS low = 0;
    POS high = m_path.size();
    POS high_limit = low;
 
    /* I == m_path[high_limit] */
    while (high_limit < high
            && nodeJ.is_compatible_IJ(m_path[high_limit], speed())) {
        ++high_limit;
    }
 
    invariant();
    return high_limit;
}

References invariant(), pgrouting::vrp::Tw_node::is_compatible_IJ(), m_path, and speed().

Referenced by drop_position_limits(), and position_limits().

getPosLowLimit()

size_t pgrouting::vrp::Vehicle::getPosLowLimit ( const Vehicle_node &  node ) const

private

Definition at line 360 of file vehicle.cpp.

                                                       {
    invariant();
 
    POS low = 0;
    POS high = m_path.size();
    POS low_limit = high;
 
    /* J == m_path[low_limit - 1] */
    while (low_limit > low
            && m_path[low_limit - 1].is_compatible_IJ(nodeI, speed())) {
        --low_limit;
    }
 
    invariant();
    return low_limit;
}

References invariant(), m_path, and speed().

Referenced by position_limits().

has_cv()

bool pgrouting::vrp::Vehicle::has_cv ( ) const

inline

Definition at line 222 of file vehicle.h.

                         {
         return cvTot() != 0;
     }

References cvTot().

Referenced by pgrouting::vrp::Vehicle_pickDeliver::insert(), is_feasable(), and pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

has_twv()

bool pgrouting::vrp::Vehicle::has_twv ( ) const

inline

Definition at line 219 of file vehicle.h.

                          {
         return twvTot() != 0;
     }

References twvTot().

Referenced by is_feasable(), and pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

id()

int64_t pgrouting::Identifier::id ( ) const

inherited

Definition at line 42 of file identifier.cpp.

                     {
    return m_id;
}

References pgrouting::Identifier::m_id.

Referenced by pgrouting::vrp::Dnode::distance(), get_postgres_result(), is_phony(), pgrouting::vrp::operator<<(), pgrouting::operator<<(), pgrouting::vrp::Tw_node::operator==(), tau(), and Vehicle().

idx()

size_t pgrouting::Identifier::idx ( ) const

inherited

Definition at line 37 of file identifier.cpp.

                      {
    return m_idx;
}

References pgrouting::Identifier::m_idx.

Referenced by erase(), pgrouting::vrp::Vehicle_pickDeliver::erase(), pgrouting::vrp::Vehicle_pickDeliver::has_order(), pgrouting::vrp::Vehicle_pickDeliver::insert(), insert(), pgrouting::vrp::operator<<(), pgrouting::operator<<(), pgrouting::vrp::Tw_node::operator==(), pgrouting::vrp::Vehicle_pickDeliver::push_back(), pgrouting::vrp::Vehicle_pickDeliver::push_front(), pgrouting::vrp::Vehicle_pickDeliver::semiLIFO(), pgrouting::vrp::Order::set_compatibles(), tau(), and Vehicle().

insert() [1/2]

void pgrouting::vrp::Vehicle::insert	(	POS	pos,
		Vehicle_node	node
	)

@ {

Insert node at pos position.

Parameters

[in]	pos	The position that the node should be inserted.
[in]	node	The node to insert.

Definition at line 183 of file vehicle.cpp.

                                         {
    invariant();
    pgassert(at <= m_path.size());
 
    m_path.insert(m_path.begin() + static_cast<difference_type>(at), node);
    evaluate(at);
 
    pgassert(at < m_path.size());
    pgassert(m_path[at].idx() == node.idx());
    invariant();
}

References evaluate(), pgrouting::Identifier::idx(), invariant(), m_path, and pgassert.

Referenced by pgrouting::vrp::Vehicle_pickDeliver::insert(), insert(), and pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

insert() [2/2]

size_t pgrouting::vrp::Vehicle::insert	(	std::pair< POS, POS >	position_limits,
		const Vehicle_node &	node
	)

Insert node in best position of the position_limits.

Parameters

[in]	position_limits
[in]	node	The node to insert

Returns

position where it was inserted

Definition at line 63 of file vehicle.cpp.

                                                                           {
    invariant();
    pgassert(position_limits.first <= m_path.size());
    pgassert(position_limits.second <= m_path.size());
 
    auto low = position_limits.first;
    auto high = position_limits.second;
    auto best = low;
 
 
    insert(low, node);
 
    Vehicle::Cost best_cost(cost());
 
 
    while (low < high) {
        swap(low, low + 1);
        ++low;
        if (cost_compare(best_cost, cost())) {
            best_cost = cost();
            best = low;
        }
    }
    return best;
 
    pgassert(best < m_path.size());
    pgassert(m_path[best].idx() == node.idx());
    invariant();
}

References cost(), cost_compare(), pgrouting::Identifier::idx(), insert(), invariant(), m_path, pgassert, position_limits(), and swap().

invariant()

void pgrouting::vrp::Vehicle::invariant

(

)

const

Invariant The path must:

• have at least 2 nodes
• first node of the path must be Start node
• last node of the path must be End node

path: S ..... E

Definition at line 56 of file vehicle.cpp.

                         {
    pgassert(m_path.size() >= 2);
    pgassert(m_path.front().is_start());
    pgassert(m_path.back().is_end());
}

References m_path, and pgassert.

Referenced by pgrouting::vrp::Vehicle_pickDeliver::do_while_feasable(), empty(), erase(), pgrouting::vrp::Vehicle_pickDeliver::erase(), evaluate(), getDropPosLowLimit(), getPosHighLimit(), getPosLowLimit(), pgrouting::vrp::Vehicle_pickDeliver::insert(), insert(), pgrouting::vrp::operator<(), pgrouting::vrp::operator<<(), path(), pgrouting::vrp::Vehicle_pickDeliver::push_back(), pgrouting::vrp::Vehicle_pickDeliver::push_front(), pgrouting::vrp::Vehicle_pickDeliver::semiLIFO(), size(), swap(), Vehicle(), and pgrouting::vrp::Vehicle_pickDeliver::Vehicle_pickDeliver().

is_feasable()

bool pgrouting::vrp::Vehicle::is_feasable ( ) const

inline

Definition at line 226 of file vehicle.h.

                              {
         return !(has_twv() ||  has_cv());
     }

References has_cv(), and has_twv().

Referenced by pgrouting::vrp::Vehicle_pickDeliver::do_while_feasable(), pgrouting::vrp::Vehicle_pickDeliver::insert(), and pgrouting::vrp::Vehicle_pickDeliver::semiLIFO().

is_ok()

bool pgrouting::vrp::Vehicle::is_ok

(

)

const

Definition at line 410 of file vehicle.cpp.

                     {
    pgassert((m_path.front().opens() <= m_path.front().closes())
        && (m_path.back().opens() <= m_path.back().closes())
        && (m_capacity > 0));
    return (start_site().opens() <= start_site().closes())
        && (end_site().opens() <= end_site().closes())
        && (m_capacity > 0);
}

References pgrouting::vrp::Tw_node::closes(), end_site(), m_capacity, m_path, pgrouting::vrp::Tw_node::opens(), pgassert, and start_site().

is_phony()

bool pgrouting::vrp::Vehicle::is_phony ( ) const

inline

Definition at line 105 of file vehicle.h.

{return id() < 0;}

References pgrouting::Identifier::id().

Referenced by pgrouting::vrp::Optimize::move_order().

msg()

Pgr_messages & pgrouting::vrp::Vehicle::msg ( )

static

Access to the problem's message.

Returns

reference to the problem's message

Definition at line 51 of file vehicle.cpp.

             {
    return problem->msg;
}

References pgrouting::vrp::Pgr_pickDeliver::msg, and problem.

Referenced by pgrouting::vrp::Vehicle_pickDeliver::do_while_feasable(), get_postgres_result(), and Vehicle().

path()

std::deque< Vehicle_node > pgrouting::vrp::Vehicle::path

(

)

const

@ {

Definition at line 292 of file vehicle.cpp.

                    {
    invariant();
    return m_path;
}

References invariant(), and m_path.

Referenced by pgrouting::vrp::operator<<().

position_limits()

std::pair< size_t, size_t > pgrouting::vrp::Vehicle::position_limits

(

const Vehicle_node

node

)

const

Definition at line 299 of file vehicle.cpp.

                                                      {
    POS high = getPosHighLimit(node);
    POS low = getPosLowLimit(node);
    return std::make_pair(low, high);
}

References getPosHighLimit(), and getPosLowLimit().

Referenced by pgrouting::vrp::Vehicle_pickDeliver::insert(), and insert().

reset_id()

void pgrouting::Identifier::reset_id ( int64_t  _id )

inherited

Definition at line 47 of file identifier.cpp.

                                {
    m_id = _id;
}

References pgrouting::Identifier::m_id.

Referenced by pgrouting::vrp::Tw_node::Tw_node().

size()

size_t pgrouting::vrp::Vehicle::size

(

)

const

return number of nodes in the truck

True: S E
False: S <nodes> E

Definition at line 265 of file vehicle.cpp.

                    {
    invariant();
    return m_path.size() - 2;
}

References invariant(), and m_path.

Referenced by pgrouting::vrp::Optimize::move_order().

speed()

double pgrouting::vrp::Vehicle::speed

(

)

const

Definition at line 477 of file vehicle.cpp.

                     {
    return m_speed/m_factor;
}

References m_factor, and m_speed.

Referenced by evaluate(), getDropPosLowLimit(), getPosHighLimit(), getPosLowLimit(), pgrouting::vrp::operator<<(), and pgrouting::vrp::Vehicle_pickDeliver::set_compatibles().

start_site()

Vehicle_node pgrouting::vrp::Vehicle::start_site ( ) const

inline

Definition at line 232 of file vehicle.h.

                                     {
         return m_path.front();
     }

References m_path.

Referenced by is_ok().

swap()

void pgrouting::vrp::Vehicle::swap	(	POS	i,
		POS	j
	)

Swap two nodes in the path.

Before: S <nodesA> I <nodesB> J <nodesC> E
After: S <nodesA> J <nodesB> I <nodesC> E

Parameters

[in]	i	The position of the first node to swap.
[in]	j	The position of the second node to swap.

Definition at line 234 of file vehicle.cpp.

                          {
    invariant();
    pgassert(m_path.size() > 3);
    pgassert(!m_path[i].is_start());
    pgassert(!m_path[i].is_end());
    pgassert(!m_path[j].is_start());
    pgassert(!m_path[j].is_end());
 
    std::swap(m_path[i], m_path[j]);
    i < j ? evaluate(i) : evaluate(j);
 
    invariant();
}

References evaluate(), invariant(), m_path, and pgassert.

Referenced by insert().

tau()

std::string pgrouting::vrp::Vehicle::tau

(

)

const

Definition at line 457 of file vehicle.cpp.

                   {
    pgassert(m_path.size() > 1);
    std::ostringstream log;
    log << "Truck " << id() << "(" << idx() << ")"
        << " (";
    for (const auto &p_stop : m_path) {
        if (!(p_stop == m_path.front()))
            log << ", ";
        log << p_stop.id();
    }
    log << ")" << " \t(cv, twv, wait_time, duration) = ("
        << cvTot() << ", "
        << twvTot() << ", "
        << total_wait_time() << ", "
        << duration() << ")";
 
    return log.str();
}

References cvTot(), duration(), pgrouting::Identifier::id(), pgrouting::Identifier::idx(), m_path, pgassert, total_wait_time(), and twvTot().

Referenced by get_postgres_result(), pgrouting::vrp::Vehicle_pickDeliver::insert(), pgrouting::vrp::operator<<(), and Vehicle().

total_service_time()

double pgrouting::vrp::Vehicle::total_service_time ( ) const

inline

Definition at line 210 of file vehicle.h.

                                       {
         return m_path.back().total_service_time();
     }

References m_path.

total_travel_time()

double pgrouting::vrp::Vehicle::total_travel_time ( ) const

inline

Definition at line 207 of file vehicle.h.

                                      {
         return m_path.back().total_travel_time();
     }

References m_path.

total_wait_time()

double pgrouting::vrp::Vehicle::total_wait_time ( ) const

inline

Definition at line 204 of file vehicle.h.

                                    {
         return m_path.back().total_wait_time();
     }

References m_path.

Referenced by cost(), and tau().

twvTot()

int pgrouting::vrp::Vehicle::twvTot ( ) const

inline

Definition at line 213 of file vehicle.h.

                        {
         return m_path.back().twvTot();
     }

References m_path.

Referenced by cost(), has_twv(), and tau().

Friends And Related Function Documentation

operator<

bool operator< ( const Vehicle &  lhs, const Vehicle &  rhs  )

friend

Definition at line 502 of file vehicle.cpp.

                                                  {
    lhs.invariant();
    rhs.invariant();
 
    if (lhs.m_path.size() < rhs.m_path.size()) return true;
 
    /* here because sizes are equal */
 
    if (lhs.m_path.back().total_travel_time()
            < rhs.m_path.back().total_travel_time()) return true;
 
    return false;
}

operator<<

std::ostream& operator<< ( std::ostream &  log, const Vehicle &  v  )

friend

@ {

Definition at line 484 of file vehicle.cpp.

                                                {
    v.invariant();
    int i(0);
    log << "\n\n****************** " << v.idx() << "th VEHICLE*************\n";
    log << "id = " << v.id()
        << "\tcapacity = " << v.m_capacity
        << "\tfactor = " << v.m_factor << "\n"
        << "\tspeed = " << v.m_speed << "\n"
        << "\tnew speed = " << v.speed() << "\n";
 
    for (const auto &path_stop : v.path()) {
        log << "Path_stop" << ++i << "\n";
        log << path_stop << "\n";
    }
    return log;
}

PD_problem

friend class PD_problem

friend

Definition at line 79 of file vehicle.h.

Member Data Documentation

m_capacity

double pgrouting::vrp::Vehicle::m_capacity

private

Definition at line 82 of file vehicle.h.

Referenced by capacity(), evaluate(), is_ok(), and pgrouting::vrp::operator<<().

m_factor

double pgrouting::vrp::Vehicle::m_factor

private

Definition at line 83 of file vehicle.h.

Referenced by pgrouting::vrp::operator<<(), and speed().

m_id

int64_t pgrouting::Identifier::m_id

privateinherited

Definition at line 53 of file identifier.h.

Referenced by pgrouting::Identifier::id(), and pgrouting::Identifier::reset_id().

m_idx

size_t pgrouting::Identifier::m_idx

privateinherited

Definition at line 52 of file identifier.h.

Referenced by pgrouting::Identifier::idx().

m_path

std::deque< Vehicle_node > pgrouting::vrp::Vehicle::m_path

protected

Definition at line 77 of file vehicle.h.

Referenced by cost(), cvTot(), duration(), empty(), end_site(), erase(), evaluate(), get_postgres_result(), getDropPosLowLimit(), getPosHighLimit(), getPosLowLimit(), pgrouting::vrp::Vehicle_pickDeliver::insert(), insert(), invariant(), is_ok(), pgrouting::vrp::operator<(), path(), pgrouting::vrp::Vehicle_pickDeliver::push_back(), pgrouting::vrp::Vehicle_pickDeliver::push_front(), pgrouting::vrp::Vehicle_pickDeliver::semiLIFO(), size(), start_site(), swap(), tau(), total_service_time(), total_travel_time(), total_wait_time(), twvTot(), and Vehicle().

m_speed

double pgrouting::vrp::Vehicle::m_speed

private

Definition at line 84 of file vehicle.h.

Referenced by pgrouting::vrp::operator<<(), and speed().

problem

Pgr_pickDeliver * pgrouting::vrp::Vehicle::problem

static

Pointer to problem.

Definition at line 315 of file vehicle.h.

Referenced by msg(), and pgrouting::vrp::PD_problem::PD_problem().

---

The documentation for this class was generated from the following files:

• vehicle.h
• vehicle.cpp