PLM Object Data Update via Dependency Graph Traversal
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing Product Lifecycle Management (PLM) solutions face challenges in updating object data due to the complexity of interrelated objects and collaborative work environments, often resulting in failed updates.
Innovation Solution
A method involving the construction of a directed graph to represent dependence relations between objects, allowing for incremental and reliable updates by browsing the graph along directed arcs, ensuring that ancestor objects are up-to-date before updating dependent objects.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If all object data is loaded into memory for updating, then update completeness is improved, but system memory requirements and processing complexity increase significantly
Solution Approach 1:
The patent segments the update process by dividing objects into two categories: those requiring full data loading (simple objects) and those that can be updated through dependency graph traversal (complex interrelated objects). This segmentation allows the system to handle large datasets without loading everything into memory, reducing processing complexity while maintaining update completeness.
Solution Approach 2:
The patent performs preliminary action by building a dependency graph before the actual update process. This graph captures the relationships between objects and is used to determine the update sequence, ensuring that dependencies are resolved before updates are applied. This preliminary structuring enables efficient updates without requiring full data loading during the update operation.
2Productivity
If objects are updated independently without checking dependencies, then update speed is improved, but update failures increase due to inconsistent data
Solution Approach 1:
The patent performs preliminary action by constructing a dependency graph that maps relationships between objects before executing updates. This graph is used to determine a valid update sequence, ensuring that parent objects are updated before their children. This preliminary dependency analysis enables fast updates while preventing data inconsistencies and update failures.
Solution Approach 2:
The patent implements feedback mechanisms where the dependency graph continuously monitors and enforces update sequences. When an update is requested, the system checks the dependency graph to determine the correct update order, providing feedback that prevents invalid updates. This feedback loop maintains data consistency without significantly impacting update speed.
3Reliability
If the system checks all dependencies before updating, then data consistency is improved, but update time increases
Solution Approach 1:
The patent performs preliminary action by pre-computing and storing the dependency graph structure before updates are needed. This pre-computed graph is then efficiently traversed during updates to quickly determine update sequences without re-analyzing all dependencies. This preliminary structuring enables fast consistency checks while maintaining data integrity.
Solution Approach 2:
The patent makes the dependency checking process dynamic by adapting the traversal depth and scope based on the specific update operation and current data state. The system dynamically adjusts which dependencies to check and in what order, optimizing the balance between consistency verification and update speed for different scenarios.
Data Source
AI summary
The invention is directed to a Product Lifecycle Management (PLM) update process for updating objects with respect to specifications. The process invokes dependence relations between objects. It relies on building a directed graph, wherein objects are the nodes of the graph. An arc (also called “edge”) is directed from a second object to a first object, the latter depending on the second object according to dependence relations of the PLM system. Thus, the update can be carried by browsing the graph along the direction of the arcs in the graph. Owing to the reversion of the graph with respect to the dependence of objects, the simple solution of the invention guarantees that the update of an object occurs only when the ancestor object it depends on is up to date, and so on. This drastically reduces failures at update in practice.