Struct google_api_proto::google::cloud::optimization::v1::ShipmentModel

pub struct ShipmentModel {

    pub shipments: Vec<Shipment>,
    pub vehicles: Vec<Vehicle>,
    pub max_active_vehicles: Option<i32>,
    pub global_start_time: Option<Timestamp>,
    pub global_end_time: Option<Timestamp>,
    pub global_duration_cost_per_hour: f64,
    pub duration_distance_matrices: Vec<DurationDistanceMatrix>,
    pub duration_distance_matrix_src_tags: Vec<String>,
    pub duration_distance_matrix_dst_tags: Vec<String>,
    pub transition_attributes: Vec<TransitionAttributes>,
    pub shipment_type_incompatibilities: Vec<ShipmentTypeIncompatibility>,
    pub shipment_type_requirements: Vec<ShipmentTypeRequirement>,
    pub precedence_rules: Vec<PrecedenceRule>,
    pub break_rules: Vec<BreakRule>,
}

A shipment model contains a set of shipments which must be performed by a set of vehicles, while minimizing the overall cost, which is the sum of:

• the cost of routing the vehicles (sum of cost per total time, cost per travel time, and fixed cost over all vehicles).
• the unperformed shipment penalties.
• the cost of the global duration of the shipments

Fields

shipments: Vec<Shipment>

Set of shipments which must be performed in the model.

vehicles: Vec<Vehicle>

Set of vehicles which can be used to perform visits.

max_active_vehicles: Option<i32>

Constrains the maximum number of active vehicles. A vehicle is active if its route performs at least one shipment. This can be used to limit the number of routes in the case where there are fewer drivers than vehicles and that the fleet of vehicles is heterogeneous. The optimization will then select the best subset of vehicles to use. Must be strictly positive.

global_start_time: Option<Timestamp>

Global start and end time of the model: no times outside of this range can be considered valid.

The model’s time span must be less than a year, i.e. the global_end_time and the global_start_time must be within 31536000 seconds of each other.

When using cost_per_*hour fields, you might want to set this window to a smaller interval to increase performance (eg. if you model a single day, you should set the global time limits to that day). If unset, 00:00:00 UTC, January 1, 1970 (i.e. seconds: 0, nanos: 0) is used as default.

global_end_time: Option<Timestamp>

If unset, 00:00:00 UTC, January 1, 1971 (i.e. seconds: 31536000, nanos: 0) is used as default.

global_duration_cost_per_hour: f64

The “global duration” of the overall plan is the difference between the earliest effective start time and the latest effective end time of all vehicles. Users can assign a cost per hour to that quantity to try and optimize for earliest job completion, for example. This cost must be in the same unit as [Shipment.penalty_cost][google.cloud.optimization.v1.Shipment.penalty_cost].

duration_distance_matrices: Vec<DurationDistanceMatrix>

Specifies duration and distance matrices used in the model. If this field is empty, Google Maps or geodesic distances will be used instead, depending on the value of the use_geodesic_distances field. If it is not empty, use_geodesic_distances cannot be true and neither duration_distance_matrix_src_tags nor duration_distance_matrix_dst_tags can be empty.

Usage examples:

• There are two locations: locA and locB.
• 1 vehicle starting its route at locA and ending it at locA.
• 1 pickup visit request at locB.

model {
   vehicles { start_tags: "locA"  end_tags: "locA" }
   shipments { pickups { tags: "locB" } }
   duration_distance_matrix_src_tags: "locA"
   duration_distance_matrix_src_tags: "locB"
   duration_distance_matrix_dst_tags: "locA"
   duration_distance_matrix_dst_tags: "locB"
   duration_distance_matrices {
     rows {  # from: locA
       durations { seconds: 0 }   meters: 0    # to: locA
       durations { seconds: 100 } meters: 1000 # to: locB
     }
     rows {  # from: locB
       durations { seconds: 102 } meters: 990 # to: locA
       durations { seconds: 0 }   meters: 0   # to: locB
     }
   }
}

• There are three locations: locA, locB and locC.
• 1 vehicle starting its route at locA and ending it at locB, using matrix “fast”.
• 1 vehicle starting its route at locB and ending it at locB, using matrix “slow”.
• 1 vehicle starting its route at locB and ending it at locB, using matrix “fast”.
• 1 pickup visit request at locC.

model {
   vehicles { start_tags: "locA" end_tags: "locB" start_tags: "fast" }
   vehicles { start_tags: "locB" end_tags: "locB" start_tags: "slow" }
   vehicles { start_tags: "locB" end_tags: "locB" start_tags: "fast" }
   shipments { pickups { tags: "locC" } }
   duration_distance_matrix_src_tags: "locA"
   duration_distance_matrix_src_tags: "locB"
   duration_distance_matrix_src_tags: "locC"
   duration_distance_matrix_dst_tags: "locB"
   duration_distance_matrix_dst_tags: "locC"
   duration_distance_matrices {
     vehicle_start_tag: "fast"
     rows {  # from: locA
       durations { seconds: 1000 } meters: 2000 # to: locB
       durations { seconds: 600 }  meters: 1000 # to: locC
     }
     rows {  # from: locB
       durations { seconds: 0 }   meters: 0    # to: locB
       durations { seconds: 700 } meters: 1200 # to: locC
     }
     rows {  # from: locC
       durations { seconds: 702 } meters: 1190 # to: locB
       durations { seconds: 0 }   meters: 0    # to: locC
     }
   }
   duration_distance_matrices {
     vehicle_start_tag: "slow"
     rows {  # from: locA
       durations { seconds: 1800 } meters: 2001 # to: locB
       durations { seconds: 900 }  meters: 1002 # to: locC
     }
     rows {  # from: locB
       durations { seconds: 0 }    meters: 0    # to: locB
       durations { seconds: 1000 } meters: 1202 # to: locC
     }
     rows {  # from: locC
       durations { seconds: 1001 } meters: 1195 # to: locB
       durations { seconds: 0 }    meters: 0    # to: locC
     }
   }
}

duration_distance_matrix_src_tags: Vec<String>

Tags defining the sources of the duration and distance matrices; duration_distance_matrices(i).rows(j) defines durations and distances from visits with tag duration_distance_matrix_src_tags(j) to other visits in matrix i.

Tags correspond to [VisitRequest.tags][google.cloud.optimization.v1.Shipment.VisitRequest.tags] or [Vehicle.start_tags][google.cloud.optimization.v1.Vehicle.start_tags]. A given VisitRequest or Vehicle must match exactly one tag in this field. Note that a Vehicle’s source, destination and matrix tags may be the same; similarly a VisitRequest’s source and destination tags may be the same. All tags must be different and cannot be empty strings. If this field is not empty, then duration_distance_matrices must not be empty.

duration_distance_matrix_dst_tags: Vec<String>

Tags defining the destinations of the duration and distance matrices; duration_distance_matrices(i).rows(j).durations(k) (resp. duration_distance_matrices(i).rows(j).meters(k)) defines the duration (resp. the distance) of the travel from visits with tag duration_distance_matrix_src_tags(j) to visits with tag duration_distance_matrix_dst_tags(k) in matrix i.

Tags correspond to [VisitRequest.tags][google.cloud.optimization.v1.Shipment.VisitRequest.tags] or [Vehicle.start_tags][google.cloud.optimization.v1.Vehicle.start_tags]. A given VisitRequest or Vehicle must match exactly one tag in this field. Note that a Vehicle’s source, destination and matrix tags may be the same; similarly a VisitRequest’s source and destination tags may be the same. All tags must be different and cannot be empty strings. If this field is not empty, then duration_distance_matrices must not be empty.

transition_attributes: Vec<TransitionAttributes>

Transition attributes added to the model.

shipment_type_incompatibilities: Vec<ShipmentTypeIncompatibility>

Sets of incompatible shipment_types (see ShipmentTypeIncompatibility).

shipment_type_requirements: Vec<ShipmentTypeRequirement>

Sets of shipment_type requirements (see ShipmentTypeRequirement).

precedence_rules: Vec<PrecedenceRule>

Set of precedence rules which must be enforced in the model.

break_rules: Vec<BreakRule>

👎Deprecated

Deprecated: No longer used. Set of break rules used in the model. Each vehicle specifies the BreakRule that applies to it via the [Vehicle.break_rule_indices][google.cloud.optimization.v1.Vehicle.break_rule_indices] field (which must be a singleton).

Implementations

impl ShipmentModel

pub fn max_active_vehicles(&self) -> i32

Returns the value of max_active_vehicles, or the default value if max_active_vehicles is unset.

Trait Implementations

impl Clone for ShipmentModel

fn clone(&self) -> ShipmentModel

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ShipmentModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ShipmentModel

fn default() -> Self

Returns the “default value” for a type.

impl Message for ShipmentModel

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for ShipmentModel

fn eq(&self, other: &ShipmentModel) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ShipmentModel