Functional Tolerancing & Annotations Automation Functions

This page describes the exposure of a function in to EKL package of app.

This page discusses:

LogicalGlobalCopySetTo

The function lets you copy the entire annotation set into a target 3D shape representation using logical reroute.

The function lets you copy the entire annotation set into a target 3D shape representation using logical reroute. The system uses the tag identifier on faces to reconnect the copied FTA features to the target geometrical elements. During processing, the system compares the tag identifier of faces of the target 3DSR with the tag identifier of faces of the source 3DSR. The FTA feature reroute is done only if these tag identifiers are identical.

Table 1. Arguments
Name Input/Output Required? Type Comment
AnnotationSet In CATTPSSet Input set to be replicated
TargetPart In PartFeature Target 3D shape representation
Bodies In List

List of bodies and geometrical sets on which the reroute of the FTA features will apply.

If this list is empty, the system uses all the bodies and geometrical sets of the given Part Feature to reroute the copied FTA features.

ImportOnce In Boolean When set to TRUE the system launches one import which is applied on all the bodies and geometrical sets of the previous list.

When set to FALSE, the system imports the annotation set several times.: One per selected body per geometrical set (except if the body per geometrical set does not contain the source logical identifier).

CaptureNameFilter In String String used to filter FTA features. The system keeps only the FTA features that belong to the captures FTA that contain the string.
AsResultWithLink In Boolean When set to TRUE activates copy of annotations as result with link behavior.

By default, the value is FALSE.

Signature

LogicalGlobalCopySetTo(AnnotationSet : CATTPSSet, TargetPart : PartFeature, Bodies : List, ImportOnce : Boolean, CaptureNameFilter : String [, AsResultWithLink : Boolean]) : Boolean

ReturnType

Boolean

Example

// Annotation set retrieved and dedicated to provide input schema to logical
// reroute
Let TPSSet (CATTPSSet)

// Arguments preparation.
// Retrieve the PartFeature providing the target destination
Let PrtPart(PartFeature)
...

// Refinement of the geometrical domain in case end user is willing to
// specify a much precise area than the PartFeature scope
Let ListBodies(List)
...

// Processing flag to state if import can occur as many time as possible
// or once for the entire scope when "true" value is assigned
Let ImportOnce(Boolean)
ImportOnce = false
...

// String used to filter FTA features.
// The system keeps only the FTA features that belong to the captures FTA that contain the string CaptureNameFilter
Let CaptureNameFilter(String)
...

// Optional argument. When set to TRUE activates copy of annotations as result with link behavior
Let AsResultWithLink(Boolean)
AsResultWithLink = true
...

// Invoke import handling
if ( LogicalGlobalCopySetTo( TPSSet, PrtPart, ListBodies, ImportOnce, CaptureNameFilter, AsResultWithLink ) <> true )
{
	// Error handling
	...
}

GenerateRequirementsFromAnnotationSets

Generates FTA requirement specifications.

This function generates or (given a precedent run) updates PLM view with relevant FTA requirements corresponding to the provided annotation sets.

This call is analyzing existing requirement specifications and based on input list of annotation sets computes how many FTA requirements are new, modified, unchanged (in some extent ignored).

To execute the function properly scope of work should be saved for all the modifications and have required manager role. Else, the call is returning a FALSE value to report an error.

ARGUMENTS

Name Input/Output Required? Type Comment
ListOfAnnotationSets In List Input list must only contains annotation sets (CATTPSSet).

Input collection of annotation Sets are considered within a single transaction and underlying FTA annotations are treated as one consistent set of annotations for requirement generation.

ListOfRequirementSpecifications Out List This output is made up of the resulting requirement specifications (requirement specification) aggregating FTA requirements (FTARequirementModel) entities issued from this processing
ListOfProcessOutcomeMetrics Out List This list contains integer parameters only.

Example

// Arguments preparation.
// Annotation sets list to consider in following run
Let ListOfAnnotationSets( list )
...

// Declare the output list containing the Requirement Specification nodes
// under which FTA requirements are aggregated
Let ListOfRequirementSpecifications( list )

// Declare an output list of integers.
// This list provides the quantitative details of the modifications brought
// into PLM view with respect to FTA requirement distribution.
Let ListOfProcessOutcomeMetrics( list )
...

// Invoke FTA generation processing
DisableErrors()
if ( GenerateRequirementsFromAnnotationSets( ListOfAnnotationSets, ListOfRequirementSpecifications, ListOfProcessOutcomeMetrics ) <> true )
{
    // Prompt errors
    Let listOfErrors( list )
	Let AnErrorToPrompt( EvaluationError )
	listOfErrors = EnableErrors( )
	for AnErrorToPrompt inside listOfErrors
	{
		Trace(1,"!!! => Error message: #", AnErrorToPrompt.Message)
		Trace(1,"     -----    ")
	}

	// Error handling
	...
}

// Test processing details list size; must be constant and equals to 8
if ( ListOfProcessOutcomeMetrics->Size( ) <> 8 )
{
	// Error handling
	...
}

// Read processing metrics
// Total of FTAs considered based on the input Set list
Let ProcessedFTAs( integer )
ProcessedFTAs = ListOfProcessOutcomeMetrics[ 1 ]

// New FTAs count with respect to previous FTA requirement processing
Let NewFTACount( integer )
NewFTACount = ListOfProcessOutcomeMetrics[ 2 ]

// Number of modified FTAs
Let ModifiedFTACount( integer )
ModifiedFTACount = ListOfProcessOutcomeMetrics[ 3 ]

// Number of FTAs considered as unchanged
Let UnchangedFTACount( integer )
UnchangedFTACount = ListOfProcessOutcomeMetrics[ 4 ]

// Ignored FTAs
Let IgnoredFTACount( integer )
IgnoredFTACount = ListOfProcessOutcomeMetrics[ 5 ]

// New requirement specification nodes issued of current procedure
Let NewReqSpecCount( integer )
NewReqSpecCount = ListOfProcessOutcomeMetrics[ 6 ]

// Total of FTA requirements resulting from current treatment
Let FTARequirementCount( integer )
FTARequirementCount = ListOfProcessOutcomeMetrics[ 7 ]

// And finaly, Detached FTA requirements according to Requirement Specification baseline at start of this run
Let DetachedFTARequirementCount( integer )
DetachedFTARequirementCount = ListOfProcessOutcomeMetrics[ 8 ]

// Access to Requirement Specifications doing as suggested next:
Let ReqSpecItem( Requirement Specification )
For ReqSpecItem inside ListOfRequirementSpecifications
{
  //... Body of specific development ... 
  if ( ReqSpecItem <> NULL )
                    ...
}

GetFTAFeatures

Retrieves the annotation set and the FTA native entity that generate this FTA Requirement within the indicated requirement specification.

This method introspects the FTA requirement contained in the expressed requirement specification to find out the annotation set it comes from, and inside this set, the annotation it derives from.

The proper execution of this processing is mainly conditioned to the fact that physical representation containing the original FTA definition is well loaded in the session where this EKL execution is run. When this condition not met, this call returns a FALSE value to report an error.

Attributes

Name Input/Output Required? Type Comment
FTA Requirement In FTARequirementModel This is an entity upon which the method is invoked.
Requirement Specification In Requirement Specification This input is corresponding to the requirement node which is containing the FTA requirement object.
Annotation Set Out CATTPSSet This output is the annotation set feature into the physical representation that contains the annotation ancestor of the FTA Requirement object.
Annotation Out CATTPSAllAnnotations This entity belongs to the returned annotation set. It also defines the FTA native authoring data from which the FTA Requirement model object is issued from.

Example

// Arguments preparations.
// Inputs
// FTA Requirement and its containing Requirement Specification node are known
Let FTAReq( FTARequirementModel )
Let FatherReqSpec( 'Requirement Specification' )
...

// Outputs
// Declare 2 outputs; one for the annotation set and another one for the native FTA annotation
Let FTAAnnotationSet( CATTPSSet )
Let FTANativeEntity( CATTPSAllAnnotations )
...

// Invoke the FTA entity reverse link resolution from the FTA Requirement model element
DisableErrors()
if ( FTAReq->GetFTAFeatures( FatherReqSpec, FTAAnnotationSet, FTANativeEntity ) <> true )
{
    // Prompt errors
    Let listOfErrors( list )
	Let AnErrorToPrompt( EvaluationError )
	listOfErrors = EnableErrors( )
	for AnErrorToPrompt inside listOfErrors
	{
		Trace(1,"!!! => Error message: #", AnErrorToPrompt.Message)
		Trace(1,"     -----    ")
	}

	// Error handling
	...
}