Customizing the User Interface with Business Rules

The business rule is used to validate the branch routing to support.

This Business rule is used for the Routing Branches command.

The purpose of this BR is to check:

• if a branch can be added to a support instance
• the compatibility of branches already routed in the support instance with the branch user is willing to add
• check if the support instance is not overloaded

1. During the Branch Routing, select a support instance to be added to the Branch's route. The BR will check if the bundle segment can be added to the support. The BR can either:

   • validate the routing of Branch to the support (severity=0)
   • validate the routing of Branch to the support with a warning message computed from the rules context (severity=1)
   • forbid the routing of Branch to the support with a warning message computed from the rules context (severity=2)

2. Select the Opening ID for: EHIRouting_ValidateAddSegmentToSupport. This validation rule will be triggered when a support to be added is selected in Branch Routing.

   ThisObject: Branch Segment to route

   Parameters: Standard context, Message attribute will be displayed in a warning if the validation fails.
   

   • SupportInstance (input): Instance of support to be added in branch's route
   • SupportSection (input): integer; support section number
   • ListOfBranches (input): List of already routed branches in the support's section
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but it is used by the electrical command.

   Validation: Variable to set to know if the validation succeeded or failed.

   Here is an example of Business Rule syntax:

   /* CATRule signature (do not edit) : (ThisObject : #In Branch, Parameters 
    : #In RuleContext, Validation : #Out Boolean) : #Void */
   
   let Support(Support)
   let ListOfBranch(LIST)
   let SptName(String)
   let Branch(Branch)
   let SupportSection(INTEGER)
   let sBranchName(STRING)
   let bChecked(BOOLEAN)
   
   bChecked = false
   Parameters.Severity = 1
   Parameters.Message = "EHIRouting_ValidateAddSegmentToSupport Default Message"
   Validation = true
   
   set Support = Parameters.GetAttributeObject("SupportInstance")
   set ListOfBranch = Parameters.GetAttributeObject("ListOfBranches")
   set SupportSection = Parameters.GetAttributeInteger("SupportSection")
   
   SptName = Support.Name
   Trace(1, "Validating addition of Support to branch " + ThisObject.Name + "Support = " 
    + SptName + "--> Section ",SupportSection)
   
   if((3 == SupportSection) or (5 <= ListOfBranch->Size()))
   {
      /* Adding support to third section of Support is not allowed*/
      /* Adding more than 5 supports is not allowed*/
      Validation = false
      Parameters.Severity = 2
      Parameters.Message = "Addition is not possible on this section of Support"
      Trace (1, "Rule FAILED: " + Parameters.Message)
   }
   else if(2 <= ListOfBranch->Size())
   {
      /* If 2 branches are already routed show warning */
      Validation = true
      Parameters.Severity = 1
      Parameters.Message = "Warning: Two or more branches is already routed through 
       this section of Support;"
      Trace (1, "EHIRouting_ValidateAddSegmentToSupport Rule succeeded : " 
       + Parameters.Message)
   }
   else
   {
      /* else Allow routing */
      Validation = true
      Parameters.Severity = 0
      Parameters.Message = "Support Addition is possible"
      Trace (1, "EHIRouting_ValidateAddSegmentToSupport Rule succeeded : " + Parameters.Message)
   }
   

The BR allows you to compute the position of a branch inside a support while routing the branch to the support instance.

This Business rule is used for the Working with Segments command.

1. Select a support instance to be added to the Branch's route, the BR will allow to compute the default position of the branch inside the support, taking into account other branches already routed in the support.

2. Use the Opening ID: EHIRouting_ComputeUVAddSegmentToSupport . The computation rule will be triggered when a support to be added is selected in Branch Routing.

   ThisObject: Branch Segment to route.

   Parameters: Standard context, Message attribute will be displayed in a warning if the validation fails.
   

   • Support Instance (input): Instance of support to be added in branch's route
   • SupportSection (input): integer; support section number
   • ListOfBranches (input): List of already routed branches in the support's section
   • ListOfBranchesU (input): List of already routed branches Position (U) with regards to support entry point and plane
   • ListOfBranchesV (input): List of already routed branches Position (V) with regards to support entry point and plane
   • RoutedBranchU (output): U position of the branch relative to the support section origin
   • RoutedBranchV (output): V position of the branch relative to the support section origin

   The 3 lists are synchronized.

   Here is an example of Business Rule syntax:

   /* CATRule signature (do not edit) : (ThisObject : #In Segment, Parameters
     : #In RuleContext) : #Void */
   
   let Support(Support)
   let listU(LIST)
   let listV(LIST)
   let ListBranches(LIST)
   let UOut(REAL)
   let VOut(REAL)
   let ValueU(REAL)
   let ValueV(REAL)
   let NbBranch(INTEGER)
   let NbU(INTEGER)
   let NbV(INTEGER)
   let SupportSection(INTEGER)
   
   UOut = 0.0
   VOut = 0.0
   Parameters.Severity = 1
   Parameters.Message = "Could not compute U and V - use default 0.0 & 0.0"
   
   set Support = Parameters.GetAttributeObject("SupportInstance")
   set ListBranches = Parameters.GetAttributeObject("ListOfBranches")
   set SupportSection = Parameters.GetAttributeInteger("SupportSection")
   set listU = Parameters.GetAttributeObject("ListOfBranchesU")
   set listV = Parameters.GetAttributeObject("ListOfBranchesV")
   
   NbBranch = ListBranches->Size()
   NbU = listU->Size()
   NbV = listV->Size()
   
   Trace(1, "Validating addition of Support to branch " + ThisObject.Name + "Support 
    = " + Support.PLM_ExternalID + "--> Section ",SupportSection)
   Trace(1, "Numbers - Branch = " + NbBranch + "     Branch U = " + NbU + "    
    Branch V = " + NbV)
   
   if((NbU <> NbBranch) OR (NbV <> NbBranch))
   {
      Parameters.Severity = 2
      Parameters.Message = "Could not compute U and V - Since input list are invalid"	
   }
   else
   {
      if(NbU == 0) /* Any branch has not be routed through the support*/
      {
         UOut = 0.0
         VOut = 0.0
      }
      else
      {
         set ValueU = listU->GetItem(NbU)
         set UOut = ValueU + 20
      }
   }
   
   Parameters.SetAttributeReal("RoutedBranchU", UOut)
   Parameters.SetAttributeReal("RoutedBranchV", VOut)
   

The business rule is used to to check if a segment end can be connected to another object (other segment end or device).

This Business rule is used for the Electrical Branch Geometry command.

1. During the Branch Routing, select an object to connect (another branch extremity or an electrical device instance), the BR will check if the bundle segment extremity can be connected to this object. The BR can either:

   • validate the Branch connection to the object (severity=0)
   • validate the Branch connection to the object with a warning message computed from the rules context (severity=1)
   • forbid the Branch connection to the object with a warning message computed from the rules context (severity=2)

2. Use the Opening ID: EHIRouting_ValidateBranchExtremityConnection. This validation rule will be triggered when an object to be connected is selected in Branch Routing.

   ThisObject: BranchSegment to route

   Parameters: the standard context and the message attribute will be displayed in a warning if the validation fails.
   

   • SegmentExtremity (input): Extremity of the routed branch
   • SegmentExtremitytoConnect (input): Extremity of the branch to connect (may be null if connection to device instance)
   • InstanceToConnect (input): Instance of Product to connect (mainly electrical device instance)
   • PortToConnect (input): port of product to connect (mainly Bundle connection Point of electrical instance)
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but used by electrical command.

   Validation: a variable to know if the validation succeeded or failed.

The business rule is used to check the status of two segment ends and the attached text to display.

This Business rule is used for the Analyzing Networks command.

1. In the output of the BR, visualize the status of Bundle Segment extremity link:

   1. Change the colour of 3D line representing the segments connection.
   2. Change the 3D text.

   The business rule can either:
   

   • validate the bundle segment extremity link (severity=0 or validation successful). No specific bundle segment color nor 3D text are displayed
   • validate the bundle segment extremity link (severity=1 or 2 AND validation failed). Specific bundle segment color and 3D text are displayed from business rules result. Text is retrieved from context.

2. Use the Opening ID: EHINetwork_ValidateSegmentConnection. This validation rule will be triggered in analyze network when two connected Bundle Segment extremities are electrically connected but not geometrically at same position.

   ThisObject: FirstBundleSegmentExtremity.

   Parameters: Standard context, Message attribute will be displayed in the 3D Text of analyze network if the validation fails.
   

   • SecondBundleSegmentExtremity (input): second extremity electrically connected to firs extremity
   • FirstExtremityX (input) : first segment extremity X position (length relative to root)
   • FirstExtremityY (input) : first segment extremity Y position (length relative to root)
   • FirstExtremityZ (input) : first segment extremity Z position (length relative to root)
   • SecondExtremityX (input) : Second segment extremity X position (length relative to root)
   • SecondExtremityY (input) : Second segment extremity Y position (length relative to root)
   • SecondExtremityZ (input) : Second segment extremity Z position (length relative to root)
   • SharedSupportAtConnectedExtrimity (input): instance of shared support section ; null but when the 2 bundle segment extremities are sharing a same support section instance (segment extremities ending to the same support section instance AND connected)
   • FirstExtremityU (input) : first segment extremity U position in the shared support (length relative to support section origin), null if no shared support
   • FirstExtremityV (input) : first segment extremity V position in the shared support (length relative to support section origin), null if no shared support
   • SecondExtremityU (input) : Second segment extremity U position in the shared support (length relative to support section origin), null if no shared support
   • SecondExtremityV (input) : Second segment extremity V position in the shared support (length relative to support section origin), null if no shared support
   • Color (output string), 3D line color with possible values
     
     • G: Green
     • Y: Yellow
     • R: Red
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message)
     • Severity= 1 the treatment is to be continued and only a warning raised
     • Severity= 2 Not used (idem severity=1)

   Validation: a variable to know if the validation succeeded or failed.

   Here is an example of Business Rule syntax:

   /* CATRule signature (do not edit) : (ThisObject 
   : #In SegmentExtremity, Parameters : #In RuleContext, 
   Validation : #Out Boolean) : #Void */
   
   let X1(Length)
   let Y1(Length)
   let Z1(Length)
   
   let X2(Length)
   let Y2(Length)
   let Z2(Length)
   
   let U1(Length)
   let U2(Length)
   
   let V1(Length)
   let V2(Length)
   
   let bSupportShared(BOOLEAN)
   let Support(Support)
   let distance(Length)
   
   set bSupportShared = false
   
   Validation = true
   Parameters.Severity = 0
   Parameters.Message = "Valid connection"
   Parameters.SetAttributeString("Color","G")
   
   set X1 = Parameters.GetAttributeReal("FirstExtremityX")
   set Y1 = Parameters.GetAttributeReal("FirstExtremityY")
   set Z1 = Parameters.GetAttributeReal("FirstExtremityZ")
   
   set X2 = Parameters.GetAttributeReal("SecondExtremityX")
   set Y2 = Parameters.GetAttributeReal("SecondExtremityY")
   set Z2 = Parameters.GetAttributeReal("SecondExtremityZ")
   
   set U1 = Parameters.GetAttributeReal("FirstExtremityU")
   set V1 = Parameters.GetAttributeReal("FirstExtremityV")
   
   set U2 = Parameters.GetAttributeReal("SecondExtremityU")
   set V2 = Parameters.GetAttributeReal("SecondExtremityV")
   
   set Support = Parameters.GetAttributeObject
    ("SharedSupportAtConnectedExtremity")
   
   if(Support <> NULL)
   {
      distance = sqrt((U1 - U2)*(U1 - U2) + (V1 - V2)*
        (V1 - V2))
      set bSupportShared = true
   }
   else
   {
      distance = sqrt(  (X1 - X2)*(X1 - X2) + (Y1 - Y2)*
       (Y1 - Y2) + (Z1 - Z2)*(Z1 - Z2)) 
   }
   if(false == bSupportShared)
   {
      if(distance < 0.001)
      {
         Validation = true
         Parameters.Severity = 0
         Parameters.Message = "Valid connection, length 
          between point = " + ToString(distance)
         Parameters.SetAttributeString("Color","G")
      }
      else if(distance <= 0.01)
      {
         Validation = false
         Parameters.Severity = 1
         Parameters.Message = "Distant link: length between 
          point = " + ToString(distance)
         Parameters.SetAttributeString("Color","Y")
       }
       else
       {
         Validation = false
         Parameters.Severity = 2
         Parameters.Message = "Far distant link: length 
          between point = " + ToString(distance) 
         Parameters.SetAttributeString("Color","R")
       }
   }
   else
   {
      if(distance < 0.001)
      {
         Validation = true
         Parameters.Severity = 0
         Parameters.Message = "Valid connection, length
          between point = " + ToString(distance)
         Parameters.SetAttributeString("Color","G")
      }
      else
      {
         Validation = false
         Parameters.Severity = 2
         Parameters.Message = "Distant link at shared
          support: length between point =
          " + ToString(distance) 
         Parameters.SetAttributeString("Color","R")
      }
   }
   

You can use the business rule to validate the target support for the copy arrangement of the segments.

This Business rule is used for the Copy Arrangement command. The purpose of this BR is to check that Copy Arrangement is allowed on the selected source and target support pair.

After selecting Copy Arrangement, the source support and the target support. The BR will check if the arrangement is to be copied or not. The BR can either:

• Validate the copying of arrangement on the target support (severity = 0)
• Validate the copying of arrangement on the target support with a warning message computed from the rules context (severity = 1)
• Forbid copy arrangement on the target support with a warning message computed from the rules context (severity = 2)

1. Click Copy Arrangement and select the source support.

2. Select the target support.

3. Use the Opening ID: EHI_ValidateTargetSupportCompatibilityForCopyArrangement. This rule is triggered when target support is selected during Copy Arrangement.

   ThisObject: Source support selected

   Parameters: Standard context, message attribute will be displayed in a warning if the validation fails.
   

   • SourceSupportInstance (input) Selected Source Support
   • TargetSupportInstance (input) Selected Target Support
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   Note: This notion is not mandatory but it is used by the electrical command.

   Validation: a variable to know if the validation succeeded or failed.

   Here is an example of Business Rule syntax:

    /* CATRule signature (do not edit) : (ThisObject : #In Support, 
   Parameters : #In RuleContext, Validation : #Out Boolean) : #Void */
   
   let SrcSpt(Support)
   let TgtSpt(Support)
   let SrcName(STRING)
   let TgtName(STRING)
   let SubType(STRING)
   set SrcSpt = Parameters.GetAttributeObject("SourceSupportInstance")
   set TgtSpt = Parameters.GetAttributeObject("TargetSupportInstance")
   
   if((NULL == SrcSpt) or (NULL == TgtSpt))
   {
      Validation = false
      Parameters.Severity = 2
      Parameters.Message = "Param NULL"
   }
   else
   {
      set SrcName = SrcSpt.Name
      set TgtName = TgtSpt.Name
   }
   {
   if (SrcName == TgtName)
   {
      Validation = false
      Parameters.Severity = 2
      Parameters.Message = "Not allowed"
   }
   else
   {
      Validation = true
      Parameters.Severity = 1
      Parameters.Message = "allowed with warning"
   }
   

You can use the business rule to validate the segment support pair at the target and source support for the Copy Arrangement command.

This Business rule is used for the Copy Arrangement command.

To check if Copy Arrangement is allowed on the current segment - support at source and segment - support at target. The BR will check if the arrangement is to be copied or not. The BR can either:

• Validate the copying of arrangement on the target support (severity = 0)
• Validate the copying of arrangement on the target support with a warning message computed from the rules context (severity = 1)
• Forbid copy arrangement on the target support with a warning message computed from the rules context (severity = 2)

1. Click Copy Arrangement and select the source support.

2. Select the target support.

3. Use the Opening ID: EHI_ValidateSegmentSupportAtSourceAndTargetForCopyArrangement. This rule is triggered when target support is selected during Copy Arrangement.

   ThisObject: Source support selected

   Parameters: Standard context, message attribute will be displayed in a warning if the validation fails.
   

   • SourceSupportInstance (input) Selected Source Support
   • SegmentAtSource (input) Segment at Source Support
   • TargetSupportInstance (input) Selected Target Support
   • SegmentAtTarget (input) Segment at Target Support
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message)
     • Severity= 1 the treatment is to be continued and only a warning raised)
     • Severity= 2 the treatment is supposed to be undone

   Note: This notion is not mandatory but it is used by the electrical command.

   Validation: a variable to know if the validation succeeded or failed.

   Here is an example of Business Rule syntax:

    /* CATRule signature (do not edit) : (ThisObject : #In Support, 
   Parameters : #In RuleContext, Validation : #Out Boolean) : #Void */
   
   let SrcSpt(Support)
   let SrcSeg(Segment)
   let TgtSpt(Support)
   let TgtSeg(Segment)
   let SrcName(STRING)
   let TgtName(STRING)
   let SubType(STRING)
   set SrcSpt = Parameters.GetAttributeObject("SourceSupportInstance")
   set SrcSeg = Parameters.GetAttributeObject("SegmentAtSource")
   set TgtSpt = Parameters.GetAttributeObject("TargetSupportInstance")
   set TgtSeg = Parameters.GetAttributeObject("SegmentAtTarget")
   
   
   if((NULL == SrcSpt) or (NULL == TgtSpt) or (NULL == SrcSeg) 
      or (NULL == TgtSeg))
   {
      Validation = false
      Parameters.Severity = 2
      Parameters.Message = "Param NULL"
   }
   else
   {
      set SrcName = SrcSpt.Name
      set TgtName = TgtSpt.Name
   }
   {
   if (SrcName == TgtName)
   {
      Validation = false
      Parameters.Severity = 2
      Parameters.Message = "Not allowed"
   }
   else
   {
      if(SrcSeg.Elec_SubType == TgtSeg.Elec_SubType)
      {
         Validation = true
         Parameters.Severity = 0
         Parameters.Message = "Copy Allowed - Both segments have same Subtype"
   }
   else
   {
         Validation = true
         Parameters.Severity = 1
         Parameters.Message = "Copy Allowed with warning- Subtypes of the 
         segments does not match"
      }
   }
   

You can compute the merging branches parameters using the business rule.

This Business rule is used for the Merging Branches command.

1. During the Merging Branches command, select the branches to be merged. The BR computes the default properties of the merging branches.

2. Use the Opening ID: EHIMerge_ComputeMergeBranchParameters. The computation rule will be triggered when merging of the branches starts.

   ThisObject: First branch to be merged.

   Parameters: Standard context. Message attribute will be displayed in a warning or error depending on the severity.
   

   • Branch2Instance (input): Second branch to be merged
   • MergeOnASupport (input integer):
     
     • 0 if merge point is not a support.
     • 1 if the first branch ends on a support and the second branch ends on a point coincident with the last support point.
     • 2 if the second branch ends on a support and the first branch ends on a point coincident with the last support point.
     • 3 if the first branch ends on a support and the second branch ends on the same section inside the same support.
   • MergeSegments (output): If not null, the two segments next to the merge point are merged at the end (default value is 0).
   • RemoveMergePoint (output): If not null, the object defining merge point is removed from branches if it becomes useless (possible only if MergeOnASupport=0) (default value is 0).

   • RemoveLocalSlack (output): If not null, the local slack defined on merge part is removed (possible only if MergeOnASupport=0) (default value is 0).

   • Message: Standard information to allow specifying a special message corresponding to severity (useful only if severity is not null).
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone and an error is raised (Merge operation is not performed).

You can use the business rule to check the synchronization of 3D position of logical and physical components linked to each other.

1. During the Logical to Physical synchronization, for the selected element, the BR will check whether the 3D position of logical and physical components are synchronized, during analysis of modification in physical. The BR can either:

   • Validate the synchronization (severity=0)
   • Validate the synchronization with a warning message computed from the rules context (severity=1)
   • Forbid the synchronization with a warning message computed from the rules context (severity=2)

2. Use the Opening ID for: L2P_ValidateComponentPositionSynchronization. This validation rule will be triggered when the physical component exists and the 3D positions of logical and physical components are different.

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element found synchronization with logical element (ThisObject).
   • L2PLogicalX: The X coordinate of logical element in logical root context.
   • L2PLogicalY: The Y coordinate of logical element in logical root context.
   • L2PLogicalZ: The Z coordinate of logical element in logical root context.
   • L2PPhysicalX: The X coordinate of physical element in physical root context.
   • L2PPhysicalY: The Y coordinate of physical element in physical root context.
   • L2PPhysicalZ: The Z coordinate of physical element in physical root context.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but it is used by the electrical command.

   Validation: Variable to set to know if the validation succeeded or failed.

   If the output Boolean of business rule is TRUE, the physical element position will be synchronized with logical 3D position.

You can use the business rule to check the synchronization of the instance names of logical and physical elements linked to each other.

1. During the Logical to Physical synchronization, for the selected element, the BR will check whether the instance names of logical and physical elements are synchronized. The BR can either:

   • Validate the synchronization (severity=0)
   • Validate the synchronization with a warning message computed from the rules context (severity=1)
   • Forbid the synchronization with a warning message computed from the rules context (severity=2)

   By default, the instance name of logical element will be set to the physical instance created through synchronization.

2. Use the Opening ID for: L2P_ValidateInstanceNameSynchronization. This validation rule will be triggered when the instance names of physical and logical components are different.

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element (It is null if no physical element is created).
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but it is used by the electrical command.

   Validation: Variable to set to know if the validation succeeded or failed.

   If the output Boolean of business rule is TRUE, the physical component instance name will be synchronized with logical.

You can use the business rule to check the synchronization of predefined part number of logical elements with part number of physical elements linked to each other.

1. During the Logical to Physical synchronization, for the selected element, the BR will check whether the predefined part numbers of logical elements are synchronized with part numbers of physical element. The BR can either:

   • Validate the synchronization (severity=0)
   • Validate the synchronization with a warning message computed from the rules context (severity=1)
   • Forbid the synchronization with a warning message computed from the rules context (severity=2)

   By default, if predefined part number of logical connector is different from the part number of corresponding physical connector, the physical instance is replaced with instance of reference whose part number matches with the predefined part number of logical.

2. Use the Opening ID for: L2P_ValidatePartNumberSynchronization. This validation rule will be triggered when the pre-defined part number of logical components differs from part number of existing physical component.

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but it is used by the electrical command.

   Validation: Variable to set to know if the validation succeeded or failed.

   If the output Boolean of business rule is TRUE, the physical component instance name will be synchronized with logical component instance name.

You can use the business rule to check the synchronization of the attributes of physical elements with logical elements.

Important: This business rule is valid only for routables (Wire and Wire group).

1. During the Logical to Physical synchronization, for the selected elements, the BR will check if the attributes of logical and physical elements can be synchronized. The BR can either:

   • Validate the synchronization (severity=0)
   • Validate the synchronization with a warning message computed from the rules context (severity=1)
   • Forbid the synchronization with a warning message computed from the rules context (severity=2)

2. Use the Opening ID for: L2P_ValidateAttributesSynchronization. This validation rule will be triggered when attribute values of logical components differs from attribute values of existing physical component.

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.
   • Note that this notion is not mandatory but it is used by the electrical command.

   Validation: Variable to set to know if the validation succeeded or failed.

   If the output Boolean of business rule is TRUE, the relevant attributes of existing physical element will be synchronized with attributes of corresponding logical element.

The business rule is used to compute the synchronization of a pair of logical and physical element linked to each other.

1. During the Logical to Physical synchronization, for the selected elements, the BR will compute if a pair of logical and physical elements can be synchronized through Logical to Physical command.

2. Use the Opening ID for: L2P_ComputeSynchronizationValidity. This computation rule will be triggered before analysis of a logical and physical element for synchronization.

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element found synchronization with logical element (ThisObject).
   • L2PSynchronizeElement: The output Boolean, to indicate the physical element should be synchronized with the logical element (ThisObject).
   • L2PSynchronizeChildren: The output Boolean, to indicate whether the children of the physical element should be synchronized with respective logical children element of ThisObject.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the output L2PSynchronizeElement is false, the element will not be analyzed for synchronization.

   Analysis of its children will depend on output L2PSynchronizeChildren. The children will be analyzed if L2PSynchronizeChildren is true. If both the outputs are false, the physical element and all its children will not be analyzed for synchronization.

The business rule is used to compute the part number of the element to be instantiate when the the predefined part number of logical element is not set.

1. During the Logical to Physical synchronization, for the selected elements, the BR will compute the part number of the element to be instantiated corresponding to logical element, if attribute predefined part number is unset.

   By default, if the attributes predefined part number is unset, the element is not synchronized. Warning will be logged in the Analysis Report.

2. Use the Opening ID for: L2P_ComputePartNumber. This computation rule will be triggered when the creation of physical element is not possible because of:

   • Predefined part number is unset / empty
   • The predefined part number is an invalid string

   ThisObject: The logical element to be synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalElement: The physical element
   • L2PPreDefinedPartNumber: The input/ output predefined part number of Logical element. This input string may not be empty if reference corresponding to the predefined part number set in logical is not available in database. You may valuate this parameter with part number which should be used for synchronization.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the business rule output L2PPreDefinedPartNumber is empty string, the element will not be synchronized. Message will be displayed based on Severity value.

   If the reference is not found in database corresponding to new part number L2PPreDefinedPartNumber, the element will not be synchronized and message will be displayed in Report.

The business rule is used to compute logical element of a physical element for synchronization.

1. During the Logical to Physical synchronization, for the selected elements, the BR will compute the logical element corresponding to the input physical element in input logical context. The rule will be applicable only if no implement link is found for the physical elements (system, devices, and routables).

   By default, if no implement link is found, synchronization of physical element is not performed. Such physical elements will be considered as extra elements.

2. Use the Opening ID for: L2P_ComputeCorrespondingLogical. This computation rule will be triggered during analysis if no implement link is found for a physical element.

   ThisObject: The physical element being analyzed for synchronization

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PLogicalRoot: The input logical root in which corresponding logical element is to be searched.
   • L2PLogicalElement: The output corresponding logical element.
   • L2PCreateImplementLink: The output Boolean, should be set as TRUE is implement link should be created during synchronization.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the business rule output L2PLogicalElement is invalid, the physical element will be treated as extra element and will not be synchronized.

The business rule is used to compute logical element of a physical element for synchronization.

1. During the Logical to Physical synchronization, for the selected elements, the BR will compute the physical element corresponding to the input logical element in input logical context. The rule will be applicable only if no implement link is found for the logical elements (system, devices, and routables).

   By default, if no implement link is found, logical elements will be considered as new elements and corresponding physical elements will be created.

2. Use the Opening ID for: L2P_ComputeCorrespondingPhysical. This computation rule will be triggered during analysis if no implement link is found for a physical element.

   ThisObject: The logical element being analyzed for synchronization

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalRoot: The input physical root in which corresponding physical element is to be searched.
   • L2PPhysicalElement: The output corresponding physical element.
   • L2PCreateImplementLink: The output Boolean, should be set as TRUE is implement link should be created during synchronization.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the business rule output L2PPhysicalElement is invalid, the logical element will be treated as new element and corresponding physical will be created.

The business rule is used to decide the aggregating product to place a logical element.

1. During the Logical to Physical synchronization, for the selected elements, the BR will allow you to decide the aggregating product in which equipment is to be placed during synchronization.

2. Use the Opening ID for: L2P_ComputeFatherForPlacingEquipment. This computation rule will be triggered during analysis of logical equipment which is to be created in physical.

   ThisObject: The logical element being analyzed for synchronization

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalRoot: The input physical root in which corresponding physical father element is to be searched.
   • L2PPhysicalFather: The output physical product in which equipment is to be instantiated.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the business rule output L2PPhysicalFather is invalid, default behaviour will be applicable.

The business rule is used to compute the attributes of the pathway for synchronization.

1. During the Logical to Physical synchronization, for the selected elements, the BR will allow you to compute the attribute to be set to the Pathway being synchronized. The attributes to be managed with this BR are bend radius, slack and bend radius ratio.

   By default, bend radius values of logical pathway will be imposed on corresponding physical branch. The default value of distributed slack used for creation of physical pathway will be 0.

2. Use the Opening ID for: L2P_ComputePathwayAttributes. This computation rule will be triggered during synchronization of pathways. With this business rule, you can revaluate the parameters to set desired properties of physical Pathway.

   ThisObject: The logical pathway being synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalBranch: The corresponding physical branch. It may be NULL during synchronization for creation.
   • L2PBendRadius: The input/ output Bend radius to be set.
   • L2PBendRadiusRatio: The output Bend radius ratio to be set.
   • L2PSlack: The input/ output Slack value to be set.
   • L2PUseBendRadiusRatio: The output Boolean to indicate if Bend radius ratio attribute is to be set to corresponding physical branch. If false, Bend radius will be used.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

The business rule is used to compute the attributes of the pathway segment for synchronization.

1. During the Logical to Physical synchronization, for the selected elements, the BR will allow you to compute the attribute to be set to the pathway segment being synchronized. The attribute currently managed with this BR are diameter and segregation.

   By default, the attributes of logical pathway segment will be set to corresponding physical segment.

2. Use the Opening ID for: L2P_ComputePathwaySegmentAttributes. This computation rule will be triggered during synchronization of pathway segments. With this business rule, you can valuate the parameters to set desired properties of physical segment.

   ThisObject: The logical pathway segment being synchronized

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PPhysicalSegment: The corresponding physical Segment. It may be NULL during synchronization for creation.
   • L2PUseBendRadiusRatio: The input to indicate if Bend radius ratio is to be used for computation of Branch.
   • L2PDiameter: The input/ output diameter to be set.
   • L2PSegregation: The input/ output Segregation to be set.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If user has set the bend radius Ratio of the branch through business rule L2P_ComputePathwayAttributes, the L2PDiameter will be ignored. It will be computed based on output values of Bend Radius and Bend radius ratio from L2P_ComputePathwayAttributes.

The business rule is used to compute segment connection point or cavity for pathway connection.

1. During the Logical to Physical synchronization, for the selected elements, the BR will allow you to get name of segment connection point or cavity to be used for routing the physical pathway during synchronization, if more than one segment connection points or cavities are found in the physical device.

   By default, the first segment connection point in the device will be used for routing the pathway.

2. Use the Opening ID for: L2P_ComputeSegmentConnectionPtOfDevice. This computation rule will be triggered during synchronization of pathways to be routed through a physical device, only if more than one segment connection points are found in the physical device.

   ThisObject: The logical connector connected to logical pathway being synchronized. The logical connector may be a logical connector component or a logical connector port.

   Parameters: Standard context, Message attribute will be displayed in the synchronization report.
   

   • L2PLogicalPathway: The logical pathway connected to ThisObject.
   • L2PPhysicalConnector: The physical connector to be routed.
   • L2PSegmentCnctPtName: The output, name of segment connection point to be used for routing the physical pathway.
   • Severity messages:
     
     • Severity= 0 the treatment is to be continued (no message).
     • Severity= 1 the treatment is to be continued and only a warning raised.
     • Severity= 2 the treatment is supposed to be undone.

   If the business rule output L2PSegmentCnctPtName is an empty string or if connection point with this name does not exists in physical connector, default behaviour will be applicable.