modules.applications.optimization.pvc.pvc.PVC

class PVC

Bases: Optimization

In modern vehicle manufacturing, robots take on a significant workload, including performing welding jobs, sealing welding joints, or applying paint to the car body. While the robot’s tasks vary widely, the objective remains the same: Perform a job with the highest possible quality in the shortest amount of time, optimizing efficiency and productivity on the manufacturing line.

For instance, to protect a car’s underbody from corrosion, exposed welding seams are sealed by applying a polyvinyl chloride layer (PVC). The welding seams need to be traversed by a robot to apply the material. It is related to TSP, but different and even more complex in some aspects.

The problem of determining the optimal route for robots to traverse all seams shares similarities with Traveling Salesman Problem (TSP), as it involves finding the shortest possible route to visit multiple locations. However, it introduces additional complexities, such as different tool and configuration requirements for each seam, making it an even more challenging problem to solve.

__init__()

Constructor method.

Methods

__init__()	Constructor method.
evaluate(solution)	Calculates the tour length for a given valid tour.
generate_problem(config)	Uses the reference graph to generate a problem for a given config.
get_application()	Gets the application.
get_available_submodule_options()	Gets the list of available options.
get_available_submodules(option)	If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.
get_default_submodule(option)	Returns the default submodule based on the provided option.
get_depending_parameters(option, config)	If the module has parameters depending on certain options, this method should return the parameters for the given option.
get_parameter_options()	Returns the configurable settings for this application.
get_requirements()	Returns requirements of this module.
get_solution_quality_unit()	Returns the unit of measure for solution quality.
get_submodule(option)	Submodule is instantiated according to the information given in self.sub_options.
postprocess(input_data, config, **kwargs)	For optimization problems, we process the solution here, then validate and evaluate it.
preprocess(input_data, config, **kwargs)	For optimization problems, we generate the actual problem instance in the preprocess function.
process_solution(solution)	Converts solution dictionary to list of visited seams.
save(path, iter_count)	Saves the generated problem graph to a file.
validate(solution)	Checks if all seams and the home position are visited for a given solution.
visualize_solution(processed_solution, path)	Plot a graph representing the possible locations where seams can start or end, with arrows representing either idle movements or the sealing of a seam

class Config

Bases: TypedDict

Configuration attributes for PVC problem generation.

Attributes:

seams (int): Number of seams for the graph

clear() → None.  Remove all items from D.

copy() → a shallow copy of D

fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values

evaluate(solution: list) → tuple[float, float]

Calculates the tour length for a given valid tour.

Parameters:

solution -- List containing the nodes of the solution

Returns:

Tour length, time it took to calculate the tour length

generate_problem(config: Config) → Graph

Uses the reference graph to generate a problem for a given config.

Parameters:

config -- Config specifying the number of seams for the problem

Returns:

Networkx graph representing the problem

get_application() → any

Gets the application.

Returns:

self.application

get_available_submodule_options() → list

Gets the list of available options.

Returns:

List of module options

get_available_submodules(option: list) → list

If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.

Parameters:

option -- List of chosen options

Returns:

List of available submodules

get_default_submodule(option: str) → Core

Returns the default submodule based on the provided option.

Parameters:

option -- Option specifying the submodule

Returns:

Instance of the corresponding submodule

Raises:

NotImplementedError -- If the option is not recognized

get_depending_parameters(option: str, config: dict) → dict

If the module has parameters depending on certain options, this method should return the parameters for the given option.

Parameters:

• option -- The chosen option

• config -- Current config dictionary

Returns:

The parameters for the given option

get_parameter_options() → dict

Returns the configurable settings for this application.

Returns:

Dictionary containing parameter options

return {
        "seams": {
            "values": list(range(1, 18)),
            "description": "How many seams should be sealed?"
        }
    }

static get_requirements() → list[dict]

Returns requirements of this module.

Returns:

List of dict with requirements of this module

get_solution_quality_unit() → str

Returns the unit of measure for solution quality.

Returns:

Unit of measure for solution quality

get_submodule(option: str) → Core

Submodule is instantiated according to the information given in self.sub_options. If self.sub_options is None, get_default_submodule is called as a fallback.

Parameters:

option -- String with the options

Returns:

Instance of a module

postprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

For optimization problems, we process the solution here, then validate and evaluate it.

Parameters:

• input_data -- Data which should be evaluated for this optimization problem

• config -- Config for the problem creation

• kwargs -- Optional additional arguments

Returns:

Tuple with results and the postprocessing time

preprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

For optimization problems, we generate the actual problem instance in the preprocess function.

Parameters:

• input_data -- Input data (usually not used in this method)

• config -- Config for the problem creation

• kwargs -- Optional additional arguments

Returns:

Tuple with output and the preprocessing time

process_solution(solution: dict) → tuple[list, float]

Converts solution dictionary to list of visited seams.

Parameters:

solution -- Unprocessed solution

Returns:

Processed solution and the time it took to process it

save(path: str, iter_count: int) → None

Saves the generated problem graph to a file.

Parameters:

• path -- Path to save the problem graph

• iter_count -- Iteration count for file versioning

validate(solution: list) → tuple[bool, float]

Checks if all seams and the home position are visited for a given solution.

Parameters:

solution -- List containing the nodes of the solution

Returns:

Boolean whether the solution is valid and time it took to validate

visualize_solution(processed_solution, path: str)

Plot a graph representing the possible locations where seams can start or end, with arrows representing either idle movements or the sealing of a seam

Parameters:

• processed_solution -- The solution already processed by process_solution(), a list of tuples representing seam start points and the config and tool needed to seal the seam.

• path -- File path for the plot

Returns:

None