vrprouting::problem::Fleet Class Reference

#include "fleet.h"

Inheritance diagram for vrprouting::problem::Fleet:

Collaboration diagram for vrprouting::problem::Fleet:

Public Member Functions
	Fleet ()=delete
	creating a fleet without information is not allowed More...
	Fleet (const Fleet &fleet)=default
	Copy constructor. More...
	Fleet (Vehicle_t *vehicles, size_t size_vehicles, const Orders &p_orders, std::vector< Vehicle_node > &p_nodes, size_t &node_id)
	Create a fleet based on the Vehicles of the problem. More...
	Fleet (Vehicle_t *vehicles, size_t size_vehicles, const std::vector< Short_vehicle > &new_stops, const Orders &p_orders, std::vector< Vehicle_node > &p_nodes, size_t &node_id)
	Create a fleet based on the Vehicles of the problem. More...
void	clean ()
	removes from fleet all invalid vehicles More...
Identifiers< size_t >	feasible_orders () const
Vehicle_pickDeliver	get_phony () const
	Get a vehicle from the user's defined vehicles. More...
Vehicle_pickDeliver	get_truck ()
	Finds an unused vehicle. More...
Vehicle_pickDeliver	get_truck (size_t order_idx)
	Finds an unused vehicle where the order can fit. More...
std::vector< Vehicle_pickDeliver >	get_unused_trucks ()
	Get all the unused vehicles. More...
std::vector< Vehicle_pickDeliver >	get_used_trucks ()
	Get all the used vehicles. More...
bool	is_fleet_ok () const
bool	is_order_ok (const Order &order) const
	Given an order, Cycle trhugh all the trucks to verify if the order can be served by at least one truck. More...
Pgr_messages &	msg ()
void	set_compatibles (const Orders &orders)
	sets the compatability of orders on the fleet More...
void	set_initial_solution (const Orders &, Identifiers< size_t > &, Identifiers< size_t > &, TTimestamp, bool)
	set the vehicle's user's initial solution More...

Protected Member Functions
void	add_vehicle (const Vehicle_t &, const std::vector< Short_vehicle > &, const Orders &, std::vector< Vehicle_node > &p_nodes, size_t &node_id)
	add a new vehicle to the fleet More...
void	build_fleet (Vehicle_t *, size_t, const std::vector< Short_vehicle > &, const Orders &, std::vector< Vehicle_node > &p_nodes, size_t &node_id)
	build the fleet More...
void	invariant () const

Protected Attributes
T	elements
	STL member. More...
Identifiers< size_t >	m_invalid
	set of invalid vehicles More...
Pgr_messages	m_msg
size_t	m_size
Identifiers< size_t >	m_unused
	set of unused vehicles More...
Identifiers< size_t >	m_used
	set of used vehicles More...

Friends
std::ostream &	operator<< (std::ostream &log, const Fleet &f)

Detailed Description

Definition at line 52 of file fleet.h.

Constructor & Destructor Documentation

Fleet() [1/4]

vrprouting::problem::Fleet::Fleet ( Vehicle_t *  vehicles, size_t  size_vehicles, const Orders &  p_orders, std::vector< Vehicle_node > &  p_nodes, size_t &  node_id  )

inline

Create a fleet based on the Vehicles of the problem.

Definition at line 61 of file fleet.h.

      : m_used(),
      m_unused() {
        build_fleet(vehicles, size_vehicles, {}, p_orders, p_nodes, node_id);
      }

References build_fleet().

Fleet() [2/4]

vrprouting::problem::Fleet::Fleet ( Vehicle_t *  vehicles, size_t  size_vehicles, const std::vector< Short_vehicle > &  new_stops, const Orders &  p_orders, std::vector< Vehicle_node > &  p_nodes, size_t &  node_id  )

inline

Create a fleet based on the Vehicles of the problem.

Definition at line 70 of file fleet.h.

      : m_used(),
      m_unused() {
        build_fleet(vehicles, size_vehicles, new_stops, p_orders, p_nodes, node_id);
      }

References build_fleet().

Fleet() [3/4]

vrprouting::problem::Fleet::Fleet ( )

delete

creating a fleet without information is not allowed

Fleet() [4/4]

vrprouting::problem::Fleet::Fleet ( const Fleet &  fleet )

default

Copy constructor.

Member Function Documentation

add_vehicle()

void vrprouting::problem::Fleet::add_vehicle ( const Vehicle_t &  vehicle, const std::vector< Short_vehicle > &  new_stops, const Orders &  p_orders, std::vector< Vehicle_node > &  p_nodes, size_t &  node_id  )

protected

add a new vehicle to the fleet

Parameters

[in]	vehicle
[in]	p_orders
[in,out]	p_nodes
[in,out]	node_id

skip illegal values on vehicles information

Set the starting site and ending site

Add the starting site and ending site to the problem's nodes

Add the vehicle

Definition at line 196 of file fleet.cpp.

                     {
 
    if ((vehicle.start_close_t < vehicle.start_open_t)
        || (vehicle.end_close_t < vehicle.end_open_t)
        // || (vehicle.capacity < 0)   // the comparison of unsigned expression < 0 is always false
       ) {
      m_msg.error << "Illegal values found on vehicle";
      m_msg.log << "On vehicle " << vehicle.id
        << " a condition is not met:\n"
        << "verify that:\n"
        << "-  start_open <= start_close: "
        << vehicle.start_open_t << "<"  << vehicle.start_close_t << "\n"
        << "-  end_open <= end_close: "
        << vehicle.end_open_t << "<"  << vehicle.end_close_t << "\n"
        << "-  capacity > 0" << vehicle.capacity << "\n";
      throw std::make_pair(m_msg.get_error(), msg().get_log());
      return;
    }
 
    auto starting_site = Vehicle_node({node_id++, vehicle, NodeType::kStart});
    auto ending_site = Vehicle_node({node_id++, vehicle, NodeType::kEnd});
 
    pgassert(starting_site.is_start() && ending_site.is_end());
 
    p_nodes.push_back(starting_site);
    p_nodes.push_back(ending_site);
 
    auto v_id = vehicle.id;
    auto vehicle_new_stops_ptr = std::find_if(new_stops.begin(), new_stops.end(), [v_id]
        (const Short_vehicle& v) -> bool {return v.id == v_id;});
    bool replace_stops = vehicle_new_stops_ptr != new_stops.end();
 
    for (Amount i = 0; i < vehicle.cant_v; ++i) {
      if (replace_stops) {
        this->emplace_back(
            this->size(),
            vehicle.id,
            starting_site,
            ending_site,
            /*
             * stops can only be assigned when there is only one vehicle
             */
            vehicle.cant_v == 1? vehicle_new_stops_ptr->stops : std::vector<int64_t>(),
            vehicle.capacity,
            vehicle.speed,
            p_orders);
      } else {
        this->emplace_back(
            this->size(),
            vehicle.id,
            starting_site,
            ending_site,
            /*
             * stops can only be assigned when there is only one vehicle
             */
            vehicle.cant_v == 1 ?
              std::vector<int64_t>(vehicle.stops, vehicle.stops + vehicle.stops_size) :
              std::vector<int64_t>(),
 
            vehicle.capacity,
            vehicle.speed,
            p_orders);
      }
    }
}

References Vehicle_t::cant_v, Vehicle_t::capacity, Vehicle_t::end_close_t, Vehicle_t::end_open_t, vrprouting::Pgr_messages::error, vrprouting::Pgr_messages::get_error(), Vehicle_t::id, vrprouting::problem::Tw_node::is_end(), vrprouting::problem::kEnd, vrprouting::problem::kStart, vrprouting::Pgr_messages::log, m_msg, msg(), pgassert, Vehicle_t::speed, Vehicle_t::start_close_t, Vehicle_t::start_open_t, Vehicle_t::stops, and Vehicle_t::stops_size.

build_fleet()

void vrprouting::problem::Fleet::build_fleet ( Vehicle_t *  vehicles, size_t  size_vehicles, const std::vector< Short_vehicle > &  new_stops, const Orders &  p_orders, std::vector< Vehicle_node > &  p_nodes, size_t &  node_id  )

protected

build the fleet

builds a fleet from a vector of Vehicle_t

Parameters

[in]	vehicles	the list of vehicles
[in]	size_vehicles	size of vehicles
[in]	p_orders
[in,out]	p_nodes
[in,out]	node_id

Sort vehicles: ASC start_open_t, end_close_t, id

Add the vehicles

creating a phony vehicle with max capacity and max window with the start & end points of the first vehicle given

Definition at line 364 of file fleet.cpp.

                     {
    std::sort(vehicles, vehicles + size_vehicles,
            [] (const Vehicle_t &lhs, const Vehicle_t &rhs) {
                if (lhs.start_open_t == rhs.start_open_t) {
                    if (lhs.end_close_t == rhs.end_close_t) {
                        return lhs.id < rhs.id;
                    } else {
                        return lhs.end_close_t < rhs.end_close_t;
                    }
                } else {
                    return lhs.start_open_t < rhs.start_open_t;
                }
            });
 
    for (size_t i = 0; i < size_vehicles; ++i) {
        add_vehicle(vehicles[i], new_stops, p_orders, p_nodes, node_id);
    }
    Vehicle_t phony_v({
            /*
             * id, capacity
             */
            -1,
            (std::numeric_limits<PAmount>::max)(),
            vehicles[0].speed,
            1,
            nullptr,
            0,
 
            /*
             * Start values
             */
            vehicles[0].start_node_id,
            0,
            (std::numeric_limits<TTimestamp>::max)(),
            0,
            vehicles[0].start_x,
            vehicles[0].start_y,
 
            /*
             * End values
             */
            vehicles[0].end_node_id,
            0,
            (std::numeric_limits<TTimestamp>::max)(),
            0,
            vehicles[0].end_x,
            vehicles[0].end_y,
    });
 
    /*
     * Add the phony vehicle
     */
    add_vehicle(phony_v, new_stops, p_orders, p_nodes, node_id);
 
    Identifiers<size_t> unused(this->size());
    m_size = size();
    m_unused = unused;
    pgassert(m_unused.size() == size());
    invariant();
}

References Vehicle_t::start_open_t.

Referenced by Fleet().

clean()

void vrprouting::problem::Fleet::clean

(

)

removes from fleet all invalid vehicles

Remove the vehicles that have problems with the time windows.

Definition at line 107 of file fleet.cpp.

             {
  pgassert(m_used.size() == 0);
  pgassert(m_unused.size() == size());
  pgassert(m_invalid.size() == 0);
  for (auto &v : *this) {
    if (!v.is_ok()) {
      m_invalid += v.idx();
      m_unused -= v.idx();
    }
  }
  invariant();
}

References invariant(), m_invalid, m_unused, m_used, pgassert, and Identifiers< T >::size().

Referenced by vrprouting::problem::PickDeliver::PickDeliver().

feasible_orders()

Identifiers< size_t > vrprouting::problem::Fleet::feasible_orders

(

)

const

Definition at line 97 of file fleet.cpp.

                             {
  invariant();
  return std::accumulate(this->begin(), this->end(),  Identifiers<size_t>(),
      [](Identifiers<size_t> i, const Vehicle_pickDeliver& v) {return v.feasible_orders() + i;});
}

References vrprouting::problem::Vehicle_pickDeliver::feasible_orders(), and invariant().

Referenced by get_truck(), and vrprouting::initialsol::tabu::Initial_solution::Initial_solution().

get_phony()

Vehicle_pickDeliver vrprouting::problem::Fleet::get_phony ( ) const

inline

Get a vehicle from the user's defined vehicles.

Definition at line 91 of file fleet.h.

{return back();}

Referenced by vrprouting::initialsol::tabu::Initial_solution::process_unassigned().

get_truck() [1/2]

Vehicle_pickDeliver vrprouting::problem::Fleet::get_truck

(

)

Finds an unused vehicle.

Definition at line 121 of file fleet.cpp.

                 {
    auto idx = m_unused.front();
    m_used += idx;
    if (this->size() > 1) m_unused -= idx;
    return at(idx);
}

References Identifiers< T >::front(), m_unused, and m_used.

Referenced by vrprouting::initialsol::simple::Initial_solution::do_while_foo(), and vrprouting::initialsol::simple::Initial_solution::one_truck_all_orders().

get_truck() [2/2]

Vehicle_pickDeliver vrprouting::problem::Fleet::get_truck

(

size_t

order_idx

)

Finds an unused vehicle where the order can fit.

Definition at line 132 of file fleet.cpp.

                                 {
    for (const auto &idx : m_unused) {
        if (at(idx).feasible_orders().has(order_idx)) {
            m_used += idx;
            if (m_unused.size() > 1) m_unused -= idx;
            return at(idx);
        }
    }
    return at(m_unused.back());
}

References Identifiers< T >::back(), feasible_orders(), m_unused, m_used, and Identifiers< T >::size().

get_unused_trucks()

std::vector< Vehicle_pickDeliver > vrprouting::problem::Fleet::get_unused_trucks

(

)

Get all the unused vehicles.

Returns

the unused vehicles

Definition at line 80 of file fleet.cpp.

                         {
  ENTERING(m_msg);
  invariant();
  std::vector<Vehicle_pickDeliver> trucks;
  m_msg.log << "fleet size" << size();
  m_msg.log << m_unused;
  for (auto v_idx : m_unused) {
    pgassertwm(v_idx < size(), m_msg.get_log());
    if (!at(v_idx).is_phony()) {
      trucks.push_back(at(v_idx));
    }
  }
  invariant();
  return trucks;
}

References ENTERING, vrprouting::Pgr_messages::get_log(), invariant(), vrprouting::Pgr_messages::log, m_msg, m_unused, and pgassertwm.

Referenced by vrprouting::initialsol::tabu::Initial_solution::Initial_solution().

get_used_trucks()

std::vector< Vehicle_pickDeliver > vrprouting::problem::Fleet::get_used_trucks

(

)

Get all the used vehicles.

Returns

the used vehicles

Definition at line 64 of file fleet.cpp.

                       {
    invariant();
    std::vector<Vehicle_pickDeliver> trucks;
    for (auto v_idx : m_used) {
        if (!at(v_idx).is_phony()) {
            trucks.push_back(at(v_idx));
        }
    }
    invariant();
    return trucks;
}

References invariant(), and m_used.

Referenced by vrprouting::initialsol::tabu::Initial_solution::process_given_solution_from_user().

invariant()

void vrprouting::problem::Fleet::invariant ( ) const

protected

Definition at line 43 of file fleet.cpp.

                       {
  m_msg.log << "\n used v" << m_used;
  m_msg.log << "\n not used v" << m_unused;
  pgassertwm(m_size == size(), m_msg.get_log());
  auto m_total = m_used + m_unused + m_invalid;
  pgassertwm(m_total.size() == size(), m_msg.get_log());
  for (const auto &e : m_used) {
    pgassertwm(e < size(), m_msg.get_log());
  }
  for (const auto &e : m_unused) {
    pgassertwm(e < size(), m_msg.get_log());
  }
  for (const auto &e : m_invalid) {
    pgassertwm(e < size(), m_msg.get_log());
  }
}

References vrprouting::Pgr_messages::get_log(), vrprouting::Pgr_messages::log, m_invalid, m_msg, m_size, m_unused, m_used, and pgassertwm.

Referenced by clean(), feasible_orders(), get_unused_trucks(), and get_used_trucks().

is_fleet_ok()

bool vrprouting::problem::Fleet::is_fleet_ok

(

)

const

Definition at line 144 of file fleet.cpp.

                         {
    ENTERING(m_msg);
    if (!m_msg.get_error().empty()) return false;
    for (auto truck : *this) {
        if (!truck.is_ok()) {
            m_msg.error << "Illegal values found on vehicle";
            m_msg.log << "On vehicle " << truck.id()
                << " a condition is not met, verify that:\n"
                << "-  start_open <= start_close\n"
                << "-  end_open <= end_close\n"
                << "-  capacity > 0\n";
            return false;
        }
 
        if (!(truck.start_site().is_start()
                    && truck.end_site().is_end())) {
            pgassertwm(false, "should never pass through here");
            m_msg.error << "Illegal values found on vehicle";
            return false;
        }
        if (!truck.is_feasible()) {
            m_msg.error << "Truck is not feasible";
            return false;
        }
    }
    EXITING(m_msg);
    return true;
}

References ENTERING, vrprouting::Pgr_messages::error, EXITING, vrprouting::Pgr_messages::get_error(), vrprouting::Pgr_messages::log, m_msg, and pgassertwm.

is_order_ok()

bool vrprouting::problem::Fleet::is_order_ok

(

const Order &

order

)

const

Given an order, Cycle trhugh all the trucks to verify if the order can be served by at least one truck.

Definition at line 179 of file fleet.cpp.

                                           {
    for (const auto &truck : *this) {
        if (!order.is_valid(truck.speed())) continue;
        if (truck.is_order_feasible(order)) {
            return true;
        }
    }
    return false;
}

References vrprouting::problem::Order::is_valid().

msg()

Pgr_messages& vrprouting::problem::Fleet::msg ( )

inline

Definition at line 126 of file fleet.h.

{return m_msg;}

References m_msg.

Referenced by add_vehicle().

set_compatibles()

void vrprouting::problem::Fleet::set_compatibles

(

const Orders &

orders

)

sets the compatability of orders on the fleet

Parameters

[in]

orders

set of orders to work with

Cycle the orders

Cycle the vehicles

• Skip orders that start after the vehicle closes
• Skip the orders that end before the vehicle starts
• The order is feasible in the vehicle so its compatible

Set compatibility on the phony vehicle

Definition at line 313 of file fleet.cpp.

                                           {
    for (const auto &o : orders) {
        for (auto & m_vehicle : *this) {
            if (m_vehicle.end_site().closes() < o.pickup().opens()) continue;
 
            if (o.delivery().closes() < m_vehicle.start_site().opens()) continue;
 
            if (m_vehicle.is_order_feasible(o)) {
                m_msg.log << "Order " << o.id() << "is feasible on Vehicle " << m_vehicle.id() <<"\n";
                auto test_truck =  m_vehicle;
                test_truck.push_back(o);
                m_msg.log << test_truck;
 
                m_vehicle.feasible_orders() += o.idx();
            }
        }
 
        if (at(this->size() - 1).is_order_feasible(o)) {
            at(this->size() - 1).feasible_orders() += o.idx();
        }
    }
}

References vrprouting::Pgr_messages::log, and m_msg.

Referenced by vrprouting::problem::PickDeliver::PickDeliver().

set_initial_solution()

void vrprouting::problem::Fleet::set_initial_solution	(	const Orders &	orders,
		Identifiers< size_t > &	assigned,
		Identifiers< size_t > &	unassigned,
		TTimestamp	execution_date,
		bool	optimize
	)

set the vehicle's user's initial solution

Parameters

[in]	orders	The problem orders
[in,out]	assigned	The currently assigned orders
[in,out]	unassigned	The currently unassigned orders
[in]	execution_date	date reference to mark unmovable orders
[in]	optimize	c$Flag to prepare for optimization

Postcondition

assigned has the assigned orders of the user

unassigned has the orders that are not part of the user's solution

when optimize is true: unassigned has the orders that are:

• movable
• and are part of the user's solution
• and created a violation

• set the vehicle's user's initial solution

Definition at line 296 of file fleet.cpp.

                       {
    for (auto &v : *this) {
        v.set_initial_solution(orders, assigned, unassigned, execution_date, optimize);
    }
}

Referenced by vrprouting::initialsol::tabu::Initial_solution::process_given_solution_from_user().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  log, const Fleet &  f  )

friend

Returns

the fleet information in the ostream

Parameters

[in]	log
[in]	f

Definition at line 98 of file fleet.h.

                                                                   {
      log << "fleet\n";
      for (const auto &v : f) log << v;
      log << "end fleet\n";
      return log;
    }

Member Data Documentation

elements

T std::vector< T >::elements

inherited

STL member.

m_invalid

Identifiers<size_t> vrprouting::problem::Fleet::m_invalid

protected

set of invalid vehicles

Definition at line 150 of file fleet.h.

Referenced by clean(), and invariant().

m_msg

Pgr_messages vrprouting::problem::Fleet::m_msg

mutableprotected

Definition at line 152 of file fleet.h.

Referenced by add_vehicle(), get_unused_trucks(), invariant(), is_fleet_ok(), msg(), and set_compatibles().

m_size

size_t vrprouting::problem::Fleet::m_size

protected

Definition at line 155 of file fleet.h.

Referenced by invariant().

m_unused

Identifiers<size_t> vrprouting::problem::Fleet::m_unused

protected

set of unused vehicles

Definition at line 147 of file fleet.h.

Referenced by clean(), get_truck(), get_unused_trucks(), and invariant().

m_used

Identifiers<size_t> vrprouting::problem::Fleet::m_used

protected

set of used vehicles

Definition at line 144 of file fleet.h.

Referenced by clean(), get_truck(), get_used_trucks(), and invariant().

---

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

• fleet.h
• fleet.cpp