Requirement traceability links missing after CAD data import

PLM ENOVIA
, , , , , , ,
1

We’re facing a compliance risk issue where requirement traceability links are not being preserved when importing CAD data into the requirements management module. Our engineering teams embed requirement references in CAD metadata, but after import these relationships disappear completely.

The import template mapping includes fields for requirement IDs, and the requirements linking tool shows no errors during import. However, when we generate coverage reports, the imported CAD parts show zero requirement associations despite having valid requirement IDs in the source data.

This breaks our entire traceability chain for regulatory compliance. We need to demonstrate that every CAD component satisfies specific requirements, but the coverage report generation produces incomplete results. The CAD Import utility completes successfully with no warnings, yet the critical traceability data is lost. Has anyone successfully maintained requirement links through CAD imports in R2020x?

system 2

I’ll provide a comprehensive solution addressing import template mapping, requirements linking tool configuration, and coverage report generation to restore your traceability:

Import Template Mapping Enhancement: Your template needs explicit relationship mapping beyond attribute fields. Add this RelationshipMapping block to your CAD import template XML:

<ImportTemplate>
  <AttributeMapping>
    <Field source="CAD_REQ_ID" target="RequirementReference"/>
  </AttributeMapping>

  <RelationshipMapping>
    <Relationship type="Satisfies">
      <Source objectType="CADPart" idField="PartNumber"/>
      <Target objectType="Requirement" idField="RequirementID"
              lookupField="CAD_REQ_ID"/>
      <ValidationRequired>true</ValidationRequired>
      <CreateIfMissing>false</CreateIfMissing>
    </Relationship>
  </RelationshipMapping>
</ImportTemplate>

Key elements:

  • lookupField tells the importer which CAD metadata field contains the requirement ID
  • ValidationRequired ensures target requirements exist before creating links
  • CreateIfMissing=false prevents orphaned relationships if requirements are missing

Requirements Linking Tool Configuration: The linking tool needs proper validation and error handling enabled. Update requirements-import.properties:


requirementsLink.validateTargets=true
requirementsLink.logMissingTargets=true
requirementsLink.failOnMissingTargets=false
requirementsLink.relationshipType=Satisfies
requirementsLink.batchSize=100

The logMissingTargets is critical - it creates a detailed report of requirement IDs that couldn’t be linked, which you need for compliance tracking. Setting failOnMissingTargets=false allows partial imports to succeed while logging issues.

Pre-Import Validation: Before running CAD imports, validate requirement existence with this validation script approach:

  1. Extract requirement IDs from CAD metadata
  2. Query requirements management module for existence
  3. Generate validation report showing missing requirements
  4. Create missing requirements or update CAD metadata before import

This prevents silent link creation failures.

Coverage Report Generation Configuration: Your coverage reports must query the correct relationship type. Update report configuration:

<CoverageReport>
  <Query>
    <SourceType>CADPart</SourceType>
    <RelationshipType>Satisfies</RelationshipType>
    <TargetType>Requirement</TargetType>
    <IncludeIndirect>true</IncludeIndirect>
  </Query>
</CoverageReport>

The IncludeIndirect setting is important - it follows relationship chains (Part->Assembly->Requirement) which is often needed for full traceability.

Import Service Account Permissions: Verify the CAD import service account has these specific privileges:

  • Create: CADPart objects
  • Create: Satisfies relationships
  • Read: Requirement objects
  • Modify: RequirementLink objects (for bidirectional traceability)

Without RequirementLink creation rights, relationships fail silently. Check in Access Manager under the import service account role.

Post-Import Verification: After updating your template and configuration:

  1. Run import on small test dataset (10-20 CAD parts with known requirement IDs)
  2. Check import logs for relationship creation confirmations
  3. Query created relationships directly:
    • Navigate to imported CAD part
    • Check Requirements tab for Satisfies links
  4. Generate coverage report for test dataset
  5. Compare coverage report results against expected traceability

For Your Compliance Risk: Since you have existing imported CAD data without links, you’ll need to run a remediation import:

  1. Export current CAD part data with embedded requirement IDs
  2. Configure template with RelationshipMapping as shown above
  3. Run relationship-only import (update existing objects, create missing links)
  4. Validate coverage reports show complete traceability
  5. Document the remediation process for audit trail

Regulatory Compliance Documentation: For audit purposes, maintain:

  • Import logs showing relationship creation
  • Validation reports from pre-import checks
  • Coverage reports demonstrating complete traceability
  • Traceability matrix export from requirements module

The combination of proper RelationshipMapping in your template, requirements linking tool validation, and correct coverage report configuration will restore your traceability chain. The key insight is that R2020x requires explicit relationship mapping - attribute values alone don’t create the relationship objects needed for compliance reporting.

Test with a small dataset first, verify the relationships are created correctly, then scale to your full CAD library. The pre-import validation step is critical for identifying missing requirements before they cause traceability gaps.

This draft is based on general ENOVIA knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.

3

I’ve seen this before - the import template mapping might be reading the requirement IDs but not actually creating the relationship objects. Check if your template has a separate relationship mapping section beyond just attribute mapping. The requirements linking tool needs explicit relationship definitions to create traceability links, not just attribute values.

5

Our template has attribute mappings for RequirementID fields, but I don’t see a dedicated relationship mapping section. Is this a separate XML block that needs to be added? We copied this template from an older implementation and may have missed R2020x-specific configurations.

6

Yes, R2020x separated relationship creation from attribute mapping. You need a RelationshipMapping block that specifies source object type, target object type, and relationship type. Without this, the importer just sets attributes but never creates the actual traceability relationship objects that the coverage report queries. This is a common migration issue from pre-R2019x templates where relationships were implicit.

8

Beyond template configuration, verify that the requirement IDs in your CAD metadata actually exist in the requirements management module before import. The requirements linking tool fails silently if target requirements aren’t found - it logs a warning but continues processing. Your coverage reports would show zero associations because the link creation failed validation. Run a pre-import validation script to check requirement ID existence first.

9

Also check your import user’s permissions. Creating traceability relationships requires specific access rights beyond basic object creation. If the import service account lacks RequirementLink creation privileges, the relationships won’t be established even with correct template configuration.

10

The coverage report generation might also be querying the wrong relationship type. R2020x has multiple requirement relationship types - Satisfies, Verifies, Derives, etc. Make sure your template creates the relationship type that your coverage reports are configured to query.