Electrical Functions

CreateAdvancedConnectionPoint(DeviceReference : VPMReference, TypeOfConnectionPt : String, ListOfGeometries : List [, NameOfCnctPt : String]) : Boolean

Boolean

Example

You can create and execute the following rule. The rule creates a segment connection point using the advanced connection point method on single insert connector reference.

DevInst : VPMReference

Let index (INTEGER)
Let size (INTEGER)
Let sMessgae (STRING)
Let sName (STRING)
Let result (Boolean)
Let plane (Plane)
Let point (Point)
Let ListObjects (LIST)
Let ListGeometries (LIST)

set sName = ""
/* Find the Point*\
ListObjects = DevInst->Query("Point", "")
index = 1
size = ListObjects.Size()
for index while index <= size
{
   set point = ListObjects->GetItem(index)
  	if(NULL <> point)
   {
       set sName = point.Name
       if(sName == "Point.2")    
       {
         ListGeometries.Append(point) /* For representation */
           ListGeometries.Append(point) /* For Contact */
           set size = 0
       }
   }
 }

/* Find the plane */
   index = 1
   ListObjects.RemoveAll()
   ListObjects = DevInst->Query("Plane", "")
   for index while index <= ListObjects.Size()
   {
     set plane = ListObjects->GetItem(index)
      if(NULL <> plane)
      {
        set sName = plane .Name
        if (sName == "Plane.1")
        {
         ListGeometries.Append(plane ) /* For Tangency */
        }
      }
   }

/* Create the connection point */
result = CreateAdvancedConnectionPoint(DevInst, "SegmentConnectionPoint", ListGeometries)
if (result == true) Message("Advance connection Point created successfully")

CreateStandardConnectionPoint(DeviceReference : VPMReference, TypeOfConnectionPt : String, AxisSystem : AxisSystem, NameOfCnctPt : String) : Boolean

Boolean

Example

You can create and execute the following rule. This rule creates a cavity using the CreateStandardConnectionPoint function on a single insert connector reference.

DevInst : VPMReference

Let Ref(VPMReference)
Let Axis (AxisSystem)
Let ListAxis (List)
Let index (INTEGER)
Let size (INTEGER)
Let sName (STRING)
Let result (Boolean)

set index = 1
ListAxis = DevInst->Query("AxisSystem", "")
for index while index <= ListAxis.Size()
{
       set Axis = ListAxis->GetItem(index)
       if(NULL <>Axis)
       {			
          set sName =Axis.Name
			       if(0 == sName.Search("Cavity"))
          {
             result = CreateStandardConnectionPoint(Ref, "Cavity", Axis)
				         if(result == false)
                Message = "Standard Connection Point created successfully"
           }
       }
    }
}

DistanceWireProduct(Wire : Feature, Object : Feature) : LENGTH

LENGTH

Example 1

The DistanceWireProduct user function can be used with the f(x) command to display the distance between a wire and a component in the session. This formula: DistanceWireProduct(EB.1\Wire.1 ,GB1.1\Muffler.1 ) returns the following value: 171.964mm.

Example 2

The DistanceWireProduct user function can be used in Quality Rules Reuse to find all the wires in the session that have a minimum distance to defined components smaller than a critical value chosen by the user. The components can be defined as heat-resistant. Properties have been added to the product (load the ElectricalMeasure package) and to the wires (set the Separation Code to NOT_HEAT_RESISTANT). DistanceWireProduct(EB.1\Wire.1 ,GB1.1\Muffler.1 ) returns the following value: 171.964mm. A check is defined as follows:

/*Check created by xxx 11/27/2007*/ 
(Object > HasAttribute('Zone') ) and 
(Object > GetAttributeString('Zone')== 'HOT' and 
mywire\Elec_Sep_Cod == 'NOT_HEAT_RESISTANT') => 
( DistanceWireProduct (mywire,Object)> 130.00mm)

Updating the session displays a status light on the check. A report is generated showing the check result: some wires verify the condition, other don't.

Example 3

The DistanceWireProduct user function can be used in Engineering Rules Capture to define a rule that displays a warning message if a minimum distance between a wire and an object is smaller than a critical value defined by the user.

if( DistanceWireProduct (EB.1\Wire.22 ,GB1.1\Muffler.1
)<Critical_Distance 
and Muffler\Properties\Zone == "HOT" and 'EB1\Wire.22\Separation
Code'
== "NOT_HEAT_RESISTANT" 
Message("> WARNING: # is not heat-resistant and the minimum
distance with # is smaller than the critical distance #. 
",'Wire.22\Part Number'
, 'Muffler\PartNumber' 
,Critical_Distance)

Running this rule displays the following message:

Rule.2: Information 
WARNING: Wire.22 is not heat-resistant and the minimum distance with Muffler is smaller than the critical distance 303.648mm.

Example 4

Still in Engineering Rules Capture, an action can be defined using the DistanceWireProduct user function, to know the distance between a wire and an object selected in the tree.

a: Wire, b: Product
Message("The distance between the wire '#' and the product
'#' is #.", 
a.Name,b.Name, DistanceWireProduct(a,b) )

Run the action using the Action.1 context menu: select a wire and a product in the tree, and then validate.

Running this rule displays the following message:

Action.1: Information 
The distance between the wire 'Wire.1' and the product 'Muffler.1' is 171.964mm

Elec_DistanceCommon(FirstWire : Feature, SecondWire : Feature) : LENGTH

LENGTH

Example

The Elec_DistanceCommon user function can be used in Quality Rules Reuse to find all the couples of wires in the session that have a common length greater than a given value.

/*Rule created by xxx 11/27/2007*/ 
if(a>b) and Elec_DistanceCommon (a,b)> 400mm) 
Message("# and # have a common length. 
It is equal to",a.Name,b.Name,round(Elec_DistanceCommon(a,b)*1000),"mm.")

Example 2

In Engineering Rules Capture, it can be used to define a rule giving the common length of two specific wires sharing properties.

/*Rule created by xxx 11/27/2007*/ 
if(Elec_DistanceCommon('Wire Harness1.1\Wire-check','Wire Harness1.1\Wire-minus3')>400mm)
Message("The specified wires,",'Wire_Harness1\Wire-check1\Reference_designator'," and
",'PN-AMP-3403B.2\Part_Number',",whose separation code is set to Wet, have a common length greater than 400mm: namely "
,(Elec_DistanceCommon('Wire Harness1.1\Wire-check1','Wire Harness1.1\Wire-minus3')))

Applying the rule displays the following message if the condition is met:

The specified wires, Wire-check1 and PN-AMP-3403B.2, whose separation code is set to Wet, have a common length greater than 400 mm: namely 407.069mm

Example 3

Still in Engineering Rules Capture, to verify that two wires selected in the tree have a common length, the following action can be defined:

/**/ Message("The common length between # and # is equal to "
,a.Name,b.Name, Elec_DistanceCommon(a,b),".")

Select two wires in the tree and click OK to validate.

Running this rule displays the following message:

The common length between Wire-minus2 and Wire-check1 is equal to 332.17mm.

ElectricalConnect(DeviceInstance : VPMInstance, ConnectionPointName : String, ToConnectObject : VPMInstance, ToConnectionPointName : String) : Boolean

Boolean

Example

Dev1: PLMProductInstanceDS 
Dev2: PLMProductInstanceDS 


Let Dev1Name(STRING) 
Let Dev2Name(STRING) 
Let bConnected(Boolean)
Dev1Name = Dev1.V_Name (Title)
Dev2Name = Dev2.V_Name (Title)

bConnected = ElectricalConnect (Dev1,"BackshellCnctPt.1",Dev2,"BackshellCnctPt.1") if(bConnected == true) { Message("Connected") }

ElectricalDisconnect(DeviceInstance : VPMInstance, ConnectionPointName : String) : Boolean

Boolean

Example

Dev1: PLMProductInstanceDS 

Let Dev1Name(STRING) 
Let bDisconnected(Boolean) 
Dev1Name = Dev1.V_Name (Title) 

bDisconnected = ElectricalDisconnect (Dev1,"BackshellCnctPt.1")
if(bDisconnected == true) 
{
Message("Disconnected") 
}

ElectricalDisconnect(DeviceInstance : VPMInstance, ConnectionPointName : String) : Boolean

Boolean

Example 1

Device: PLMProductInstanceDS 

/* disconnect all branches */

Let bDisconnected(Boolean) 
bDisconnected = ElectricalDisconnectBranch (Device)
if(bDisconnected == true) 
{
   Message("Disconnected") 
}

Example 2

Device: PLMProductInstanceDS 

/* disconnect branch connected at a specific connection point  */

Let ConnectionPointID(STRING) 
Let bDisconnected(Boolean)
ConnectionPointID =”SegmentCnct.1”
 
bDisconnected = ElectricalDisconnectBranch ( Device, ConnectionPointID )
if(bDisconnected == true) 
{
   Message("Disconnected") 
}

GetConnectedArcs(iDeviceOccurrence : ProductOccurrence, iElecPort : VPMPort, oConnectedNode : Elec3DDeviceNode, oListConnectedArcs : List) : Boolean

Boolean

Example

The following sample illustrates how to retrieve the node and arcs connected to the segment connection point of a connector occurrence.

For each arc retrieved as output in the arcs list, the Elec3DNetworkArc.GetComponent method is used to retrieve the associated segment.

 /* Retrieve not connected segment connection point of a selected device  */

let index(Integer)

let ConnectorRef(Elec3DSingleInsertConnector)
let BCP(Elec3DSegmentConnectionPoint)
let  BCPNode(Elec3DDeviceNode)
let  ListNetworkArc(List)
let nb_arc(Integer)
let i_arc(Integer)
let NetworkArc(Elec3DNetworkArc)
let ArcFeature(Feature)
let ArcSegment(Segment)
let ArcBranch(Branch)
let LElecPortType(List)
let LSegmentConnectionPoint(List)
let nb_bcp(Integer)
let nb_connected(Integer)

set ConnectorRef=myConnectorOcc.Reference
LElecPortType.Append("Elec3DSegmentConnectionPoint")
ListElectricalConnectionPoints(ConnectorRef,LElecPortType,LSegmentConnectionPoint)
nb_bcp=LSegmentConnectionPoint.Size()

nb_connected=0
index=1
for index while index <= nb_bcp
{
	set BCP = LSegmentConnectionPoint->GetItem(index) 
	
	GetConnectedArcs(myConnectorOcc,BCP,BCPNode, ListNetworkArc)
	
	if ( BCPNode ==  NULL)   // not connected
	{
		// notify segment connection point status : not connected 
		Notify ( BCP.V_FunctionalName," is not connected to branch ")	
	}
	else  // connected
	{
		nb_connected = nb_connected + 1
		
		//  --- number of arc connected node  
		nb_arc = ListNetworkArc.Size()
				
		i_arc=1
		for i_arc while i_arc <= nb_arc
		{
			set NetworkArc = ListNetworkArc->GetItem(i_arc)
			// retrieve the arc component : a segment
			NetworkArc.GetComponent(ArcFeature)
			set ArcSegment=ArcFeature
			// retireve the branch from segment 
			set ArcBranch=ArcSegment.Owner
			// notify segment connection status point  : connected 
			Notify (  BCP.V_FunctionalName, " connected to ",ArcBranch.Name,"/",ArcFeature.Name)
		}
	} 
	index = index+1
}

// display the status 
if ( nb_bcp == nb_connected )  Message (  "   ok : all segment connection points are connected to branch " )
else Message (  "   warning :  segment connection points not connected to branch " )

 GetConnectedDevice(iDeviceOccurrence : ProductOccurrence, iElectricalPort : VPMPort, oConnectedOccurrence : ProductOccurrence, oConnectedPort : VPMPort) : Boolean

Boolean

Example

The following sample illustrates how to retrieve a device connected to the cavity connection point of a connector.

/* check single insert connector not plugged into cavity   */ 
/* input :  iSingleConnectorOcc  Elec3DSingleInsertConnectorOccurrence */

let LElecPortType(List)

let iSingleConnectorRef(Elec3DSingleInsertConnector)
let LCavityCnctPt(List)
let nb_cavity_cnctpt(Integer)
let CavityCnctpt(Elec3DCavityConnectionPoint)

let ElecConnectedDeviceOcc(ProductOccurrence)
let ConnectedCavity(VPMPort)

set iSingleConnectorRef=iSingleConnectorOcc.Reference

/* retrieve cavity connection point on connector reference  */
LElecPortType.Append("Elec3DCavityConnectionPoint")
ListElectricalConnectionPoints(iSingleConnectorRef,LElecPortType,LCavityCnctPt)
nb_cavity_cnctpt=LCavityCnctPt.Size()
if ( nb_cavity_cnctpt == 1 )  set CavityCnctpt = LCavityCnctPt->GetItem(1)
	
/* retrieve device connector to cavity connection point of sincle connector */
GetConnectedDevice(iSingleConnectorOcc,CavityCnctpt,ElecConnectedDeviceOcc,ConnectedCavity)

if (  ElecConnectedDeviceOcc == NULL )
{  
 Message("  Connector : ",iSingleConnectorOcc.Name," is not plugged")
}
else Notify ( "  Connector : ",iSingleConnectorOcc.Name," is  plugged")

GetLogicalRoutable(PhysicalRoutable : Feature, LogicalRoutable : EleLogicalConductorOcc) : Boolean

Boolean

Example

let bool(BOOLEAN)
let logicalConductor(EleLogicalConductor)
let sMessage(STRING)
bool = Object.GetLogicalConductor( Object, logicalConductor) 
if(NULL <> logicalConductor)
{
  sMessage="Name of Logical Conductor: "+logicalConductor.Name
}
else
{
  sMessage="Logical Conductor not found!!"
}
Notify(sMessage)

GetPhysicalRoutable(LogicalRoutable : EleLogicalConductorOcc, PhysicalRoutable : Feature) : Boolean

Boolean

Example

let bool(BOOLEAN)
let physicalConductor(Conductor)
let sMessage(STRING)
bool = Object.GetPhysicalConductor( Object, physicalConductor) 
if(NULL <> physicalConductor)
{
  sMessage="Name of Physical Conductor: "+physicalConductor.Name
}
else
{
  sMessage="Logical Conductor not found!!"
}
Notify(sMessage)

InstanciateProtectionCenteredOnPoint(Segment : Segment, ProtectionType : String, Length : LENGTH, Point : Point, Protection : InternalProtection) : Boolean

Boolean

Example

/* Check  created by ie6 9/26/2013 */ 
Let Ref(VPMReference)
Let Inst(VPMInstance)
let Protection(internalProtection)
let Ext1(SegmentExtremity)
let Ext2(SegmentExtremity)

let Protectiontype(String)
let ResultExt(Boolean)
let ResultIP(Boolean)
let Protectionlength(Real)
let InputSegment(Segment)
let Name(String)
let CenterPoint(Point)
let SegOwner(Feature)
let sSegOwnerName(String)
let sMessage(String)
let BranchOwner(Feature)
let sBranchOwnerName(String)
Let ListObjects (LIST)
let sMidPointName(String)
let index (INTEGER)

set Protectionlength = 50mm
set Protectiontype = "InternalTape"
SegOwner= Obj.Owner
sSegOwnerName = SegOwner.Name
set sMessage = "Owner of this segment is " + sSegOwnerName
/*Message(sMessage)*/
ResultExt=Obj.Elec_BundleSegmentExtremities(Ext1,Ext2)
Name=Obj.Name

BranchOwner=SegOwner.Owner
sBranchOwnerName = BranchOwner.Name
set sMessage = "Owner of this Branch is " + sBranchOwnerName 
/*Message(sMessage)*/

set Inst=BranchOwner
set Ref = Inst.Reference
if (NULL <> Ref )
{
	set index = 1
	ListObjects=Ref->Query("Point","")
	for index while index <= ListObjects.Size()
	{

		set CenterPoint= ListObjects->GetItem(index)
		if(NULL <>CenterPoint)
		{
			set sMidPointName=CenterPoint.Name
			if(0 == sMidPointName.Search("MidPoint"))
			{

  			    ResultIP=InstanciateProtectionCenteredOnPoint(InputSegment,Protectiontype,Protectionlength,CenterPoint,Protection)
                                                    if(ResultIP<>True)
                                                           Message("Protection not instantiated")
                                                    else
                                                          Message("Protection instantiated")
                                                         
			}
		}
	}
}
else set sMessage = "Reference not found"
/*ResultIP=InstanciateProtectionCenteredOnPoint(InputSegment,Protectiontype,Protectionlength,CenterPoint,Protection)
if(ResultIP<>True)
	Message("Protection not instantiated")*/

InstantiateProtectionExtremityToExtremity(Segment : Segment, ProtectionType : String, LengthfrmExt1 :LENGTH, LengthfrmExt2 : LENGTH, Protection : InternalProtection) : Boolean

Boolean

Example

let Protection(InternalProtection)
let ProtectionType(STRING)
let resultIP(BOOLEAN)
let Name(STRING)
let length1(LENGTH)
let length2(LENGTH)

set length1 = 5mm
set length2 = 5mm


Name = Obj.Name

if(Name == "TapeSegment")
{
	ProtectionType= "InternalTape"
		resultIP = InstantiateProtectionExtremityToExtremity(Obj,ProtectionType,length1, length2, Protection)
	if(resultIP<>True)
	Message("Protection for Internal Tape is not instantiated")
	else
	Message("Protection for Internal Tape is instantiated")
}

set length1 = 10mm
set length2 = 10mm


if(Name == "AdaptiveSegment")
{
	ProtectionType= "InternalAdaptive"
	resultIP=InstantiateProtectionExtremityToExtremity(Obj,ProtectionType,length1, length2,Protection)
	if(resultIP<>True)
	Message("Protection for Internal Tape is not instantiated")
	else
	Message("Protection for Adaptive Segment is  instantiated")
}

set length1 = 15mm
set length2 = 15mm

if(Name == "CorrugateSegment")
{
	ProtectionType= "InternalCorrugate"
	resultIP=InstantiateProtectionExtremityToExtremity(Obj,ProtectionType,length1, length2,Protection)
	if(resultIP<>True)
	Message("Protection for Corrugate Segment is not instantiated")
	else
	Message("Protection for Corrugate Segment is  instantiated")
}
set length1 = 20mm
set length2 = 20mm


if(Name == "FixedSegment")
{
	ProtectionType= "InternalFixed"
	resultIP=InstantiateProtectionExtremityToExtremity(Obj,ProtectionType,length1, length2,Protection)
	if(resultIP<>True)
	Message("Protection for Internal Tape is not instantiated")
	else
	Message("Protection for Fixed Segment is  instantiated")

	
}

InstanciateProtectionOnProtection(ProtectionType : String, Protection : InternalProtection, Length : LENGTH, ListOfProtection : List) : Boolean

Boolean

Example

ProtectionObj : InternalProtection

let result(BOOLEAN)
let Type(STRING)
let Length(Length)
let ListOfProtections(LIST)

Type = "InternalTape"
Length = 20mm

if(ProtectionObj.Name == "Tape.1")
{
	result = InstanciateProtectionOnProtection (Type, ProtectionObj, Length, ListOfProtections)
	if(result <> true)
	{
		Message("Internal protection instanciation Failed on #",ProtectionObj.Name)
	}
}

InstanciateProtectionOnSegmentExtremity(SegmentExtremity : SegmentExtremity, ProtectionType : String, Length : LENGTH, Protection : InternalProtection) : Boolean

Boolean

Example

Seg : Segment

let result(BOOLEAN)
let SegExt1(SegmentExtremity)
let SegExt2(SegmentExtremity)
let lengthOfProtection(Length)
let ProtectionType(String)
let oProtection(InternalProtection)

set lengthOfProtection = 10mm
set result = False
if(Seg.Name == "Segment.1")
{
	ProtectionType= "InternalAdaptive"
	
	result = Seg->Elec_BundleSegmentExtremities(SegExt1, SegExt2)
	set result = False
	
	if(SegExt1.Name == "SegmentEnd.1")
	result = InstanciateProtectionOnSegmentExtremity( SegExt1, ProtectionType, lengthOfProtection, oProtection)
	
	if(result <> True) 
	Message("Protection not instantiated on the SegmentExtremity, #", SegExt1.Name )
	
	set result = False
	
	if(SegExt2.Name == "SegmentEnd.2")
	result = InstanciateProtectionOnSegmentExtremity( SegExt2, ProtectionType, lengthOfProtection, oProtection)
	
	if(result <> True) 
	Message("Protection not instantiated on the SegmentExtremity, #", SegExt2.Name )
}

LinkedSpecification(Instance : VPMInstance, Conductor : Conductor) : Boolean

LinkedSpecification(Instance : VPMInstance, ConductorGroup : ConductorGroup) : Boolean

Boolean

Example

ElecSystem : VPMInstance

let sRelatedInstance(STRING)
let condSpec(Conductor)
let sCondSpec(String)
let condGrpSpec(ConductorGroup)
let sCondGrpSpec(String)
let bVal(Boolean)

set  sRelatedInstance = ElecSystem.Name

if ( sRelatedInstance == "Conductor01")
{
bVal = LinkedSpecification(ElecSystem, condSpec)
set  sCondSpec = condSpec.Name
if((true <> bVal) or ( sCondSpec <> "ConductorSpec01_01"))
Message("No Related Spec found for #", sRelatedInstance)	
}


if ( sRelatedInstance == "ConductorGroup01.1")
{
bVal = LinkedSpecification(ElecSystem, condGrpSpec)
set  sCondGrpSpec = condGrpSpec.Name
if((true <> bVal) or ( sCondGrpSpec <> "ConductorGroupSpec02_01.1"))
Message("No Related Spec found for #", sRelatedInstance)	
}

ListAllOuterLayerObjects(SegmentExtremity : Feature, Offset : Real, ListOfAllCoveringProducts(Protections/Supports) : List [, TypeToList : Integer]) : Boolean

Boolean

Example

A check (in KWE advanced language) to determine the protective coverings and supports at 150 mm from end 1 (Extremity 1) of the segment is written as follows:

mysegment:Segment

let ListCovering(List) 
let ListCovered(List) 
let return(Boolean) 
let NbCovering(INTEGER) 
let NbCovered(INTEGER) 
let Offset(Real)
let CoveringObject(String) 
let CoveredObject(String)
let i(INTEGER) 
let Offset(Real) 
let Extremity1(BundleSegmentExtremity) 
let Extremity2(BundleSegmentExtremity)

Message("OBJECT = #",mysegment > Name())

mysegment.Elec_BundleSegmentExtremities(Extremity1,Extremity2)

Message("#### TEST ListAllOuterLayerObjects ####") 
Offset = 150
return =
ListAllOuterLayerObjects(Extremity1,Offset,ListCovering)
NbCovering = ListCovering_>Size() 
Message("Number of covering objects = "",NbCovering) 
i = 1 
for i while i<=NbCovering 
{ 
CoveringObject
= ListCovering > GetItem(i) 
Message("Covering Object: #",CoveringObject) 
}

ListConnectedDevices(iDeviceOccurrence : ProductOccurrence, iListElectricalPort : List, oListConnectedOccurrence : List, oListConnectedPort : List) : Boolean

Boolean

Example

The following sample illustrates how to list the devices connected to the cavities of an equipment.

/* check number of free cavities on mounting equipment  */ 
/*  input  iMountingEqtOcc :  MountingEquipmentOccurrence */ 

let LElecPortType(List)

let iMountingEqtRef(MountingEquipment)
let LCavities(List)
let nb_cavity(Integer)
let ElecCavity(Elec3DCavity)

let ElecConnectedDeviceOcc(Elec3DSingleInsertConnectorOccurrence)
let ElecConnectedCavityCnctPt(Elec3DCavityConnectionPoint)
let nb_connected(Integer)
let index(Integer)

let LConnectedDevices(List)
let LConnectedCavityConnectionPoint(List)

set iMountingEqtRef=iMountingEqtOcc.Reference

/* retrieve cavities on mounting equipment reference  */
LElecPortType.Append("Elec3DCavity")
ListElectricalConnectionPoints(iMountingEqtRef,LElecPortType,LCavities)
nb_cavity=LCavities.Size()

/* retrieve connected cavities on mounting equipment occurrence */
nb_connected = 0
ListConnectedDevices(iMountingEqtOcc,LCavities,LConnectedDevices,LConnectedCavityConnectionPoint)

index=1
for index while index <= nb_cavity
{
	set ElecCavity = LCavities->GetItem(index)  
	set ElecConnectedDeviceOcc=LConnectedDevices->GetItem(index)
	set ElecConnectedCavityCnctPt=LConnectedCavityConnectionPoint->GetItem(index)
	if (  ElecConnectedDeviceOcc<>NULL AND  ElecConnectedCavityCnctPt <> NULL  )
	{
		nb_connected=nb_connected+1
		Notify( " cavity : ", ElecCavity.V_FunctionalName," connected to : ",ElecConnectedDeviceOcc.Name,"/",ElecConnectedCavityCnctPt.V_FunctionalName)
	}
	else
	{
		Notify( " cavity : ", ElecCavity.V_FunctionalName," not connected  ")
	}
}

if (  nb_cavity-nb_connected  > 0 )
{  
	Message("  Equipment : ",iMountingEqtOcc.Name," has ", nb_cavity-nb_connected," free cavities")
}

ListConnectedNodes(iDeviceOccurrence : ProductOccurrence,  oListConnectedNodes : List) : Boolean

Boolean

Sample

The following sample illustrates how to retrieve the segments connected to cavities or segment connection points.

For each node, the Elec3DDeviceNode.GetComponents method is used to retrieve:

• The device occurrence
• The connection point
• The segment extremities. For each extremity, the segment and branch are retrieved.

/* Retrieve the segments connected to a selected device  */


let  NodeList(List)
let  myNode(Elec3DDeviceNode) // init device node 

let NodeOccurrence(ProductOccurrence)
let NodeCnctPt(VPMPort)
let  NodeFeatures(List)
let  nb_elem(Integer)
let i_elem(Integer)

let  nb_node(Integer)
let  index(Integer)
let  Bns_ext(SegmentExtremity)
let  Bns(Segment)
let  Bns_branch(Branch) 

//  
// retrieve connected nodes ( segment connection points or cavities connected to segment extremity ) 
ListConnectedNodes(myDeviceOccurrence,NodeList)   
nb_node=NodeList.Size()

index=1
for index while index <= nb_node
{
	set myNode= NodeList->GetItem(index)  // node 
	
	if ( myNode <> NULL )
	{
		// retrieve the node components : device occurrence - connection point - segment extremities connected 
		myNode->GetComponents(NodeOccurrence,NodeCnctPt,NodeFeatures)
		nb_elem = NodeFeatures.Size()
		i_elem=1
		for i_elem while i_elem <= nb_elem 
		{
			set Bns_ext= NodeFeatures->GetItem(i_elem)  //  segment extremity expected
			if (  Bns_ext <> NULL )
			{
				set Bns=Bns_ext.Owner
				set Bns_branch=Bns.Owner
				Notify (  "Connection point : ",NodeCnctPt.V_FunctionalName, " connected to ",  Bns_branch.Name,"/",   Bns.Name  )
			}			
			i_elem=i_elem+1
		}
	}
	index = index+1
}	
 

Message ( " number of connection point connected to branch :",nb_node )

ListDirectlyCoveredObjects((Protection/Support) : Feature, ListOfCoveredProducts(Segments/Protections/Supports) : List) : Boolean

Boolean

Example

• Tape A is placed directly over the segment.
• Corrugated tubes B and C are linked to the segment, and corrugated tube B covers tube C.
• Standard support D is linked to the segment.

A check (in KWE advanced language) to determine the list of segments, protective coverings and supports under corrugated tube C is written as follows:

myprotection:Protectionlet ListCovered(List) 

let return(Boolean)
let NbCovered(INTEGER) 
let Offset(Real)
let CoveredObject(String)
let i(INTEGER)

return = ListDirectlyCoveredObjects(mysegment, ListCovered) 
NbCovered = ListCovered > Size() 
Message("Component analyzed: #",myprotection > Name()) 
Message("Number of objects
covered = #",NbCovered) 
i = 1
for i while i<=NbCovered{
CoveredObject = ListCovered > GetItem(i) 
Message("Covered Object: #",CoveriedObject)

Running this check returns:

• The name of the analyzed component, in our case, corrugated tube C.
• The number of objects covered by corrugated tube C: Information: Number of objects covered = 1
• Followed by the name of this component: the segment.

ListDirectlyOuterLayerObjects((Segment/Protection/Support) : Feature, ListOfCoveringProducts(Protections/Supports) : List) : Boolean

Boolean

Example

• Tape A is placed directly over the segment.
• Corrugated tubes B and C are linked to the segment, and corrugated tube B covers tube C.
• Standard support D is linked to the segment.

A check (in KWE advanced language) to determine the list of outer layers that directly cover the segment in the example is written as follows:

mysegment:Segment

let ListOuterLayer(List) 
let return(Boolean) 
let NbOuterLayer(INTEGER) 
let Offset(Real) 
let OuterLayerObject(String)
let i(INTEGER)

return = ListDirectlyOuterLayerObjects(mysegment, ListOuterLayer) 
NbOuterLayer = ListOuterLayer > Size()
Message("Component analyzed: #",mysegment > Name())
Message("Number of outer layers = #",NbOuterLayer) 
i = 1 for i
while i<=NbOuterLayer{
OuterLayerObject = ListOuterLayer > GetItem(i) 
Message("Outer Layer: #",OuterLayerObject) }

Running this check returns:

• The name of the analyzed component, in our case, the segment.
• The number of outer layers over the segment: Information: Number of outer layers = 3. Only three are found because corrugated tube B does not directly cover the segment since it covers corrugated tube C.
• Followed by the names of these components: Information Outer Layer: Tube_20x3-2004_10_27-10_01_49_842.1

ListElectricalConnectedObjects(DeviceInstance : VPMInstance, ConnectionPointName : String, ListConnectedDevice : List, ListConnectedConnectionPoint : List, ListConnectionActivity : List) : Boolean

Boolean

Example

For a common example about ListElectricalConnectionPointsNames and ListElectricalConnectedObjects, see ListElectricalConnectionPointsNames below.

ListElectricalConnectionPoints(Reference : VPMReference, TypesToList : List, ListOfCnctPoints : List) : Boolean

Boolean

Example

let typesToList(List)
let listOfCnctPt1(List)
let cnCtPt (ElecPort)
let index(Integer)
let size(Integer)
let sName (String)
let sMessage (String)
let bool (Boolean)

/* Start:----- EQT ----------*/
/* Creation of input type name list */
/* Case 1 */
typesToList.Append("Elec3DCavity")

/* Case 2: Comment above lines and uncomment */
/* typesToList.Append("Elec3DCavityV5") */

/* Case 3: Comment above lines and uncomment */
/*typesToList.Append("Elec3DCavityConnectionPoint")*/

/* Case 4: Comment above lines and uncomment */
/*typesToList.Append("Elec3DCavityConnectionPointV5")*/

/* Case 5: Comment above lines and uncomment */
/*typesToList.Append("Elec3DCavity") 
typesToList.Append("Elec3DCavityV5") 
typesToList.Append("Elec3DCavityConnectionPoint")*/

/* Case 6: Comment above lines and uncomment */
/*typesToList.Append("PipingPort")*/
/* End: ----- EQT ----------*/

/* Start:----- Splice ----------*/
/* Creation of input type name list */
/* Case 7 Comment above lines and uncomment */
/*typesToList.Append("Elec3DSegmentConnectionPoint")*/

/* Case 8: Comment above lines and uncomment */
/* typesToList.Append("Elec3DSegmentPositionPoint") */

/* Case 9: Comment above lines and uncomment */
/*typesToList.Append("Elec3DSegmentConnectionPoint")
typesToList.Append("Elec3DSegmentPositionPoint") */

/* Case 10: Comment above lines and uncomment */
/*typesToList.Append("Elec3DSplicePositionPoint")*/
/* End: ----- Splice ----------*/

/* Start:----- PipingPort ----------*/
/* Creation of input type name list */
/* Case 11 Comment above lines and uncomment */
/*typesToList.Append("Elec3DCavity")*/

/* Case 12: Comment above lines and uncomment */
/* typesToList.Append("Elec3DCavityConnectionPoint") */

/* Case 13: Comment above lines and uncomment */
/*typesToList.Append("Elec3DSegmentConnectionPoint")*/
/* End: ----- PipingPort ----------*/

/* Start:----- EBG ----------*/
/* Creation of input type name list */
/* Case 14 Comment above lines and uncomment */
/*typesToList.Append("Elec3DCavityV5")*/

/* Case 15: Comment above lines and uncomment */
/* typesToList.Append("Elec3DSplicePositionPoint") */
/* End: ----- EBG ----------*/

Notify("---------------------------------------------------")
Notify("Reference Treated : #", ref.Name)
bool = ListElectricalConnectionPoints (ref, typesToList, listOfCnctPt1)
if(bool == TRUE)
{
	set index = 1
	size = listOfCnctPt1.Size()
	Notify("Result = True, Elements in list - #", size)

	sMessage = " ("
	for index while index <= size
	{
		sName = "NULL"
		set cnCtPt = listOfCnctPt1->GetItem(index)
		if(cnCtPt <> NULL)
		{
			set sName = cnCtPt.V_FunctionalName
		}
		sMessage = sMessage + sName + ","
		
	}
	sMessage = sMessage + ")"
	Notify(sMessage)
}	
else
{
		Notify("Result = ListElectricalConnectionPoint fails: May be Input list of type is incorrect")
}

ListElectricalConnectionPointsNames(DeviceInstance : VPMInstance, ListOfNames : List, ListOfTypeNames : List) : Boolean

Boolean

Example

Here is a common example for ListElectricalConnectionPointsNames and ListElectricalConnectedObjects:

Dev1: PLMProductInstanceDS 

let ListCxn(LIST) 
let ListCxnType(LIST)
let ListConnectedDev(LIST) 
let ListConnectedCxnPtNames(LIST) 
let ListCxnActivity(LIST) 
let Size (Integer) 
let i(Integer) 
let iCxn(Integer) 
let sizeCxn(Integer) 
let Boolean(Boolean) 
let NewLine(STRING) 
let CxnName(STRING) 
let CxnType(STRING)
let sMessage(STRING) 
let ConnectedDev(FEATURE) 
let ConnectedCxn(STRING) 

NewLine = "" 
sMessage = "" Boolean = ListElectricalConnectionPointsNames (Dev1, ListCxn, ListCxnType)
if(Boolean == true) 
{ 
      sMessage = sMessage + " 
      " + Dev1.V_Name (Title) + NewLine 
      Size = ListCxn->Size()
      if(Size == ListCxnType->Size()) 
      {
         sMessage = sMessage + "Number of connection Points = 
         " + ToString(Size) + NewLine 
         i = 1 
         for i while i<= Size 
         { 
            CxnName = ListCxn->GetItem(i) 
            CxnType = ListCxnType->GetItem(i) 
            Boolean = ListElectricalConnectedObjects (Dev1,CxnName, ListConnectedDev, ListConnectedCxnPtNames, ListCxnActivity) 
            
           if(true == Boolean) 
           {
              sizeCxn = ListConnectedDev->Size() 
              if( (sizeCxn == ListConnectedCxnPtNames->Size()) AND (sizeCxn == ListCxnActivity->Size()) ) 
              {
              sMessage = sMessage + ToString(i) + ": " + CxnName + " (" + CxnType + ") 
              Connected to - " + ConnectedDev.Name + " -> " + ConnectedCxn + NewLine 
              iCxn = 1
              for iCxn while iCxn <= sizeCxn 
              { 
                 set ConnectedDev = ListConnectedDev->GetItem(iCxn) 
                 if(NULL <> ConnectedDev) 
                 {
                    set ConnectedCxn = ListConnectedCxnPtNames->GetItem(iCxn)
                    bCxnActivity = ListCxnActivity->GetItem(iCxn)
                    if(true == bCxnActivity) 
                       sCxnActivity = "true"
                    else
                       sCxnActivity = "false" 
                    sMessage = sMessage + NewLine + ToString(iCxn) + 
                    ConnectedDev.Name + " -> " + ConnectedCxn + "Activity" + sCxnActivity + NewLine 
                 }
              }
              sMessage = sMessage + NewLine 
           } 
        } 
        else 
           sMessage = sMessage + ToString(i) + ": " + CxnName + " (" + CxnType + ") 
        Not Connected" + NewLine 
     }
   } 
   Message("#",sMessage) 
}

ListElectricalWires(DeviceInstance : VPMInstance, ListOfWires : List, ListOfConnectionPointName : List) : Boolean

Boolean

Example

SIC: PLMProductInstanceDS 

Let bln(Boolean) 
Let ListOfWires(List)
Let ListCnctPtName(List) 

bln = ListElectricalWires (SIC,ListOfWires,ListCnctPtName) 
if(1==ListOfWires.Size())
{
   Message("One wire connected to the input device") 
}

ListOuterLayerProtections(Point : Point, ListOfProtections : List) : Boolean

Boolean

Example

Point : Point

let ListOfProtections(LIST)
let NbProt(INTEGER)
let Protection1(String)
let Protection2(String)
let result(Boolean)
let Prot1(InternalProtection)
let Prot2(InternalProtection)

if(Point.Name == "Point.5")
{
	result = ListOuterLayerProtections (Point, ListOfProtections)
	if(result <> true)
	{
		Message("Outer Layer Protections Not found on #",Point.Name)
	}
	NbProt = ListOfProtections->Size()
	if(NbProt <> 2)
	{
		Message("Incorrect number of Outer Layer Protections # found on #",NbProt,Point.Name)
	}
	Prot1 = ListOfProtections->GetItem(1)
	Protection1 = Prot1.Name
	Prot2 =  ListOfProtections->GetItem(2)
	Protection2 = Prot2.Name
	if(("Tape.1"<>Protection1 ) OR ( "Adaptive diameter.1" <>Protection2 ))
	{
		Message("Incorrect Outer Layer Protection # # found on #",Protection1,Protection2,Point.Name)	
	}
}

ListProtectionsFromExtremity(SegmentExtremity : SegmentExtremity, ListOfProtection : List) : Boolean

Boolean

Example

Seg : Segment

let result(BOOLEAN)
let ListOfProtection(List)
let NbProt(INTEGER)
let SegExt1(SegmentExtremity)
let SegExt2(SegmentExtremity)
let Protection(STRING)
let Prot(InternalProtection)

if(Seg.Name == "Segment.2")
{
	result = Seg->Elec_BundleSegmentExtremities(SegExt1, SegExt2)
	if(SegExt1.Name == "SegmentExtremity.1")
	{
		result = ListProtectionsFromExtremity (SegExt1, ListOfProtection)
		if(result <> true)
		{
			Message("Protections not found on #",SegExt1.Name)
		}
		NbProt = ListOfProtection->Size()
		if(NbProt <> 1)
		{
			Message("Incorrect number of Protections # found on #",NbProt,SegExt1.Name)
		}
		Prot = ListOfProtection->GetItem(1)
		Protection = Prot.Name
		if("Corrugated tube.1"<>Protection)
		{
			Message("Incorrect Protection # found on #",Protection,SegExt1.Name)
		}		
	}
}

ListUsedSupports(Segment : Segment, Supports : List) : Boolean

Boolean

Example

A rule (in KWE advanced language) to determine the number and names of the supports through which each segment is routed is written as follows:

bns : Segment

let SupportList(List) 
let return(Boolean) 
let i(INTEGER) 
let UsedSupport(String)
let NbUsedSupports(INTEGER)

return = ListUsedSupports(bns, SupportList)
Message("Segment: #",bns > Name()) 
NbUsedSupports = SupportList > Size() 
Message("No. Used Supports = #",NbUsedSupports) 
i = 1
for i while i<=NbUsedSupports{ 
UsedSupport = SupportList > GetItem(i)
Message("Used Support: #",UsedSupport )
}

Solving this rule returns:

• The name of the analyzed segment.
• The number of supports through which the segment is routed Information No. Used Supports = 7 . Only three are found because corrugated tube B does not directly cover the segment since it covers corrugated tube C.
• Followed by the names of these supports Information Used Support : Plastic-A.14

ListUsedSupportsWithAbscissa(Segment/Branch : Feature, Supports : List, EntryPointAbscissa : List, ExitPointAbscissa : List) : Boolean

Boolean

Example

An expert rule (created using Quality Rules Reuse) to determine the list of all the supports located along all segments in the document that also outputs support entry and exit point coordinates is written as follows:

bs:Branchlet SptList(List)

let inList(List) 
let outList(List) 
let ret(Boolean) 
let i(INTEGER) 
ret = ListUsedSupportsWithAbscissa (bs,SptList, outList, inList)

Message("BS=",bs > Name())
i=1
for i while i<=(SptList > Size()){ 
Message("Abs In #, Abs Out #",outList > GetItem(i), inList > GetItem(i)) 
}

Elec3DCable.RemoveJunctionDeviceAtPosition(Position : Integer, KeepFirstRoute : Boolean) : Integer

Integer

Example