Mechanical Design

What You Will Learn With This Use Case

This use case is intended to help you make your first steps in programming with CATIA Assembly Design. Its main intent is to create geometrical relations between products. More specifically, you will learn how to:

• Create a connector on a reference plane yz, and how to retrieve such a reference plane
• Create a connector on a plane of a part, and how to retrieve a plane
• Create a constraint using these two connectors.

[Top]

The CAAAuiCreateCstOnParts Use Case

CAAAuiCreateCstOnParts is a use case of the CAAAssemblyUI.edu framework that illustrates the CATAssemblyInterfaces framework capabilities.

Before discussing the use case, some main concepts have to be introduced:

• A parallelism constraint is a geometrical relation created between two components

• Making parallel two components means creating a geometrical parallelism between two geometrical elements, one in the first component and the other in the second one, such as lines, planes, etc.

• The constrained components must be child components of the active component

• To create a constraint between two components, a connector must be created in each of these components, and the constraint will apply to the components through these connectors.

[Top]

What Does CAAAuiCreateCstOnParts Do

CAAAuiCreateCstOnParts:

• Creates a Product document
• Creates an empty part in the Product document. This part is named Part1 and is displayed thanks to its YZ plane
• Inserts an existing component: the part named bishop
• Creates a connector on the YZ plane of the empty part
• Creates a connector on the first plane found in the planes belonging to the bishop part. This plane is parallel to the XY plane
• Creates a parallelism constraint between these two planes

The parallelism constraint appears in the specification tree at the same level as the child components and they are displayed in the geometry.

These concepts are the counterpart, on the programming side, of what the end users sees and manipulates on the screen. So we will start with the end user view in order to infer what the program manipulates inside.

[Top]

How to Launch CAAAuiCreateCstOnParts

To launch CAAAuiCreateCstOnParts, you will need to set up the build time environment, then compile CAAAuiCreateCstOnParts along with its prerequisites, set up the run time environment, and then execute the use case [1].

Launch the use case as follows:

• With Windows

  e:>CAAAuiCreateCstOnParts InputDirectory\Fou.CATPart OutputDirectory\

• With UNIX

  $ CAAAuiCreateCstOnParts InputDirectory/Fou.CATPart OutputDirectory/

where:

[Top]

Where to Find the CAAAuiCreateCstOnParts Code

The CAAAuiCreateCstOnParts use case is located in the CAAAuiCreateCstOnParts.m module of the CAAAssemblyUI.edu framework:

where InstallRootDirectory is the directory where the CAA CD-ROM is installed.

[Top]

Step-by-Step

There are five main steps in CAAAuiCreateCstOnParts:

1. Prolog
2. Creating of a Connector on a Reference Plane YZ
3. Creating a Connector on a Plane
4. Creating a Constraint
5. Epilog

We will now comment each of those sections by looking the code.

[Top]

Prolog

CAAAuiCreateCstOnParts begins by checking that the command lines contains two arguments. It then creates a session, and creates a new Product document, reffered to using a pointer to the CATDocument class named pDoc, and retrieves the document's root product handled using the piProductOnRoot pointer. This is the usual sequence for creating a Product document and accessing its root product [2] [3]. Then, a new part component and an existing part component are successively added to the product structure [3]. The following variables are created to be used in the following steps:

[Top]

Creating of a Connector on a Reference Plane XY of the Empty Part

  ...
  CATIConnector * pConnector1 = NULL; 
  CATILinkableObject_var spLO_InstProd1; 
  if( SUCCEEDED(piInstanceProd1->GetShapeRep(spLO_InstProd1, "Default", CATPrd3D, TRUE)) )
  {
    CATIPrtPart *pPart_InstProd1 = NULL;
    rc = spLO_InstProd1->QueryInterface(IID_CATIPrtPart, (void **) &pPart_InstProd1);
    if( SUCCEEDED(rc) )
    {
      CATListValCATISpecObject_var spListRefPlanes = pPart_InstProd1->GetReferencePlanes();
      // defines the yz plane as the first sketch plane
      CATILinkableObject *pLO_xYPlane = NULL;
      if( spListRefPlanes.Size() )
      {
        CATISpecObject_var spXYPlane = spListRefPlanes[1];
        if( spXYPlane != NULL_var )
        {
          rc = spXYPlane->QueryInterface(IID_CATILinkableObject ,(void **) &pLO_XYPlane);
          if ( SUCCEEDED(rc) ) 
          {
            int iCreation = 0;
            rc = ::GetProductConnector(pLO_XYPlane,
                                       piInstanceProd1,
                                       piProductOnRoot,
                                       0,
                                       pConnector1,
                                       iCreation);
            pLO_XYPlane->Release();
            pLO_XYPlane = NULL;
          }
        }
      }
      pPart_InstProd1->Release();
      pPart_InstProd1 = NULL;
    }
  }
  ...

The XY plane is accessed by scanning the Part document structure [4]. First we retrieve the shape representation of piInstanceProd1, which is the Mechanical Part and ask it a pointer to CATIPrtPart. Then we get the reference planes thank to  and keep the first one, which is the XY plane. A CATILinkable pointer is retrieved from the plane and is used to create the connector using the GetProductConnector global function, whose arguments are:

[Top]

Creating a Connector on a Plane of the Bishop Part

  ...
  CATInit * piInitOnDoc = NULL;
  rc = pPartDoc2->QueryInterface(IID_CATInit, (void**)&piInitOnDoc2);
  if ( SUCCEEDED(rc) )
  {
    CATIPrtContainer *piPrtContainerOnRoot =
     (CATIPrtContainer*)piInitOnDoc2->GetRootContainer("CATIPrtContainer");
     piInitOnDoc2->Release();

    CATIPrtPart_var spiPrtPartOnPartBody (NULL_var);
    if( NULL != piPrtContainerOnRoot )
    {
      spiPrtPartOnPartBody = piPrtContainerOnRoot->GetPart();
      piPrtContainerOnRoot->Release();      
    }
    CATIDescendants *piDescendantsOnPart= NULL;
    CATLISTV(CATISpecObject_var) Planes;
    CATILinkableObject_var  spiLinkableOnPlane (NULL_var);
    CATIConnector * piConnector2 = NULL;
    if( SUCCEEDED(spiPrtPartOnPartBody->QueryInterface(IID_CATIDescendants,
                                                       (void**)&piDescendantsOnPart)) )
    {
      piDescendantsOnPart->GetAllChildren("CATPlane", Planes);
      piDescendantsOnPart->Release();
      if (Planes.Size())
      {
        int creationStatus = 0;
        spiLinkableOnGeometry = Planes[1];
        if ( NULL_var != spiLinkableOnGeometry )
        {
          ::GetProductConnector((CATILinkableObject *)spiLinkableOnPlane,
                                 piInstanceProd2,
                                 piProductOnRoot,
                                 0 ,
                                 piConnector2,
                                 creationStatus);
        }
      }
    }
  }
  ...

The plane onto which a connector will be created is retrieved by scanning the Part document structure [4]. First, we have a pointer, pPartDoc2, to the CATInit interface onto the Part document, and the Part document root container is retrieved as a pointer to CATIPrtContainer thanks to the GetRootContainer method of CATInit. Then the Mechanical Part is retrieved from this container as a CATIPrtPart smart pointer thanks to the GetPart method of CATIPrtContainer. The Mechanical Part is asked for a pointer to the CATIDescendants interface that enables a collection of all the objects that implement the CATPlane interface to be retrieved thanks to the GetAllChildren method. If at least one plane is retrieved, a CATILinkable pointer is retrieved from the plane and is used to create the connector using the GetProductConnector global function, whose arguments are:

[Top]

Creating a Constraint

  ...
  CATLISTV (CATBaseUnknown_var) ConnectorList;
  ConnectorList.Append(spiConnector1);
  ConnectorList.Append(piConnector2);
  piConnector2->Release();

  CATIAConstraint *piCst = NULL;
  rc = ::CreateConstraint(catCstTypeParallelism,
                          ConnectorList,
                          NULL,
                          piProductOnRoot,
                          piCst);
  ...

To create a constraints, the connectors must be first put in a collection. Then, the constraint can be created using the CreateConstraint global function. CreateConstraint has the following arguments.

[Top]

Epilog

The three documents created are saved:

Then, the session is closed, as usual [5].

[Top]

In Short

This use case has demonstrated the way to constrain two components of an assembly, by creating a connector onto a geometric object in each of the products to constrain, and creating a constraint using these two connectors.

[Top]

References

History

Copyright © 2000, Dassault Systèmes. All rights reserved.