3D PLM PPR Hub Open Gateway

Configuration Management

Configuring a Product Structure and Using Filters

Working with a Product structure

Use Case

Abstract

This article discusses the CAAVpiConfigurateStructure use case. This use case explains how to configurate a Product Structure, and use filters on it.

What You Will Learn With This Use Case
TheCAAVpiConfigurateStructure Use Case
Step-by-Step
In Short
References

What You Will Learn With This Use Case

This use case is intended to help you make your first steps in programming the ENOVIA Configuration Management. Its main intent is to create a configuration structure on a product structure, and use configuration filters .

[Top]

The CAAVpiConfigurateStructure Use Case

CAAVpiConfigurateStructure is a use case of the CAAVPMInterfaces.edu framework that illustrates VPMInterfaces framework capabilities.

[Top]

What Does CAAVpiConfigurateStructure Do

The goal of CAAVpiConfigurateStructure case is to show how to use Configuration Management interfaces to configurate a simple Product Structure. Then, some filters are defined and applied to the Configurated Product Structure. More precisely CAAVpiConfigurateStructure:

Creates a simple Product Structure
Creates basics Configuration objects such as: Configurable Root, Configurable View, Modifications
Defines different kind of Effectivities for Modifications, using Specifications, Ranges, Dates
Defines Configuration Filters on the Configurated Structure, and applies them.

[Top]

How to Launch CAAVpiConfigurateStructure

To launch CAAVpiConfigurateStructure, you will need to set up the build time environment, then compile CAAVpiConfigurateStructure 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:>CAAVpiConfigurateStructure
With UNIX
$ CAAVpiConfigurateStructure

[Top]

Where to Find the CAAVpiConfigurateStructure Code

The CAAVpiConfigurateStructure use case is made of a single class named CAAVpiConfigurateStructure located in the CAAVpiConfigurateStructure.m module of the CAAVPMInterfaces.edu framework:

Windows	`InstallRootDirectory\CAAVPMInterfaces.edu\CAAVpiConfigurateStructure.m\`
Unix	`InstallRootDirectory/CAAVPMInterfaces.edu/CAAVpiConfigurateStructure.m/`

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

[Top]

Step-by-Step

There are ten main steps in CAAVpiConfigurateStructure Code:

Prolog
Getting a Configuration Manager
Creating a Configurable Root
Creating a Configurable View (Configurable Object)
Attaching a Program and Milestones to a Configurable Root
Attaching a Specification Category and Specifications to a Configurable Root
Creating a Modification
Defining Effectivities for Modification
Performing "Add" and "Cut "operations on a Object
Creating a Filter
Applying a Filter

We will now comment each of these sections in detail.

[Top]

Prolog

CAAVpiConfigurateStructure creates first a simple product tree, made of one product root class (uidPRC1), and under it, two item instances (uidII11 and uidII12). The creation process won't be detailed here, as it's not the purpose of this use case, but a prerequisite. Please refer to Product Structure samples to get more explanations about Product Structure management.

[Top]

Getting a Configuration Manager

...
//--Get Session
  VPMSession* session = VPMSession::OpenSession();
	 
//--Get FactoryManager
  CATIVpmFactoryManager_var FactoManager = NULL_var;
  session->GetVPMObjectFactory(FactoManager);
...
//--Get Configuration Manager
  CATICfgManager_var CfgManager(FactoManager);
...

The configuration manager manages most object creations and queries used in the context of product configuration. It's a generic object used as a factory for a number of objects like modifications, configurable objects, specification categories, and filters. It also serves as a base object supporting methods dedicated to queries.

A session is needed to retrieve a smart pointer to the standard factory manager. Then the specific configuration manager is retrieved using a CATICfgManager pointer.

[Top]

Creating a Configurable Root

...
  CATIConfigurable_var ConfigurableRoot;
  CATUnicodeString ConfigurableRootName("CR1");
  ret = CfgManager->CreateConfigurable(uidPRC1,ConfigurableRootName,ConfigurableRoot); 
  if FAILED(ret) {return ret;}
...

This is an example of a configuration entity creation, here the configurable root, using the configuration manager. A configurable root is an image of a product root class, root of a product tree, in the "configuration world". It's a view of a product root class on which it's possible to define configuration entities, such as specifications and milestones. These entities are then used to define effectivities on item instances under a product root class.

[Top]

Creating a Configurable View (Configurable Object)

...
  CATIConfigurableObject_var ConfigurableView;
  CATUnicodeString CVName("CV1");
  ret = ConfigurableRoot->CreateConfigurableView(CVName,ConfigurableView); 
  if FAILED(ret) return ret;
...

A configurable view is created under a configurable root. Several configurable views can be created under a configurable root. A configurable view is an entity supporting modifications, thus defining a configuration tree based on the product tree.

Attaching a Program and Milestones to a Configurable Root

...
//--Create Program 
  CATICfgProgram_var Program;
  CATUnicodeString ProgName("ProgVpiConfigurateStructure");
  ret = CfgManager->CreateProgram(ProgName,Program);
  if FAILED(ret) return ret;

  //--Create Milestones
  CATICfgMileStone_var MSA, MSB;
  CATUnicodeString MSAName("BSF"), MSBName("END");

  ret = Program->CreateMileStone(MSAName, MSA);
  if FAILED(ret) return ret;
  MSA->SetValue(10);

  ret = Program->CreateMileStone(MSBName,MSB);
  if FAILED(ret) return ret;
  CATTime Date = CATTime(2003,08,12,15,12,25);
  MSB->SetValue(Date);

//--Attachements
ret = ConfigurableRoot->AttachProgram(Program);
if FAILED(ret) return ret;

...

The configuration manager is used to create a program. A program aggregates milestones under its unique name.

To create milestones, a smart pointer to CATICfgMileStone is needed. Here, two milestones under Program are created.
Milestones are one of the configuration variables. Their value could be changed using the method SetValue.

[Top]

Attaching a Specification Category and Specifications to a Configurable Root

...
//--Create Category
  CATICfgSpecCategory_var SpecCategory;
  CATUnicodeString CatName("Category1");
  CATUnicodeString CatDescription("Description");

  ret = CfgManager->CreateSpecCategory (CatName, CatDescription,SpecCategory);
  if FAILED(ret) return ret;
	 
//--Create Specifications	
  CATICfgSimpleSpecification_var SpecA, SpecB;
  CATUnicodeString SpecAName("SpecA"), SpecBName("SpecB");

  ret =SpecCategory->CreateSpecification(SpecAName,SpecA);
  if FAILED(ret) return ret;

  ret =SpecCategory->CreateSpecification(SpecBName,SpecB);
  if FAILED(ret) return ret;
	 
//--Attachements
  ret = ConfigurableRoot->AttachSpecCategory(SpecCategory);
  if FAILED(ret) return ret;
  ret = ConfigurableRoot->AttachSpec(SpecA);
  if FAILED(ret) return ret;
  ret = ConfigurableRoot->AttachSpec(SpecB);
  if FAILED(ret) return ret;
...

The configuration manager is used again to create a specification category. A specification category aggregates specifications under its unique name. It's a good way of gathering specifications that are conceptually linked to each other.

To create specifications, a smart pointer to CATICfgSpecCategory is needed. Here, two specifications under Category1 are created.

A specification is a label referencing a special context for the configurated product. As a simple example, a car configurated with Germany specification, and a car configurated with the GreatBritain specification won't have the driving wheel located at the same place.

A category Country may gather these two specifications.

[Top]

Creating a Modification

...
  CATICfgModification_var Mod1;
  CATUnicodeString ModName1("Mod01");
  ret=  ConfigurableView->CreateModificationEffectivity(ModName1,Mod1);
  if FAILED(ret)   return ret;
...

The configurable view is used to create a modification.

A modification keeps track of a configuration operation made on an item instance. It defines condition for which a configured item instance is present or absent in a a configured tree. A modification is often associated with an action, which makes the link between Configuration Management and Workflow.

[Top]

Defining Effectivities for Modifications

...
  CATICfgBasicEffectivity_var BasEff1;
  ret = CfgManager->CreateBasicEffectivity(BasEff1);
  if FAILED(ret) return ret;
...
  CATICfgEffectivity_var Effectivity1; ret = CfgManager->CreateEffectivity(Effectivity1);
  if FAILED(ret) return ret;
...
  ret = Effectivity1->AddEffectivity(BasEff1);
  if FAILED(ret) return ret;
...
//--Domain for wich Effectivity will be set. CATUnicodeString
  DomainName("VALIDE"); ret =  Mod1->
  SetX_Effectivity(DomainName, Effectivity1);
  if FAILED(ret) return ret;

An effectivity is defined for a specific Domain such as Engineering Domain or Maintenance Domain, which refers to a special context for the Effectivity.

An effectitivity is from type CATICfgEffectivity and is built from one or several objects whose type is CATICfgBasicEffectivity.

Each "Basic Effectivity" plays the role of one logical OR Expression member.

It means, if two "basic effectivities" are added to an effectivity, the resulting expression will be: "BasicEffectivity 1" OR "Basic Effectivity 2"

Defining Simple Date and Range Basic Effectivities

...
  CATTime StartDate = CATTime(2001,02,01,0,0,0);
  CATTime EndDate   = CATTime(2001,03,01,0,0,0);
	 
  ret = BasEff1->SetDateInterval(StartDate, EndDate);
  if FAILED(ret) return ret;
...
  int StartRange2 = 1;
  int EndRange2   = 10;
	 
  ret = BasEff2->SetRangeInterval(StartRange2, EndRange2);
  if FAILED(ret) return ret;
...

Defining Milestone Date and Range Basic Effectivities

...
  ret = BasEff1->SetStartMilestone(MSA);
  if FAILED(ret) return ret;
...
  ret = BasEff1->SetEndMilestone(MSB);
  if FAILED(ret) return ret;
...

Defining Basic Effectivities with a Specification Expression

...
  CATICfgSignedSpec_var SignedSpecA;
  ret = CfgManager->CreateSignedSpec(SignedSpecA);
  if FAILED(ret) return ret;
	 
  SignedSpecA->SetSpec(SpecA);
  SignedSpecA->SetSign(1);
...
  CATICfgSignedSpec_var SignedSpecB;
  ret = CfgManager->CreateSignedSpec(SignedSpecB);
  if FAILED(ret) return ret;
   
  SignedSpecB->SetSpec(SpecB);
  SignedSpecB->SetSign(-1);
   
  CATICfgSpecANDExpression_var SpecANDExp3;
  ret = CfgManager->CreateSpecANDExp(SpecANDExp3);
  if FAILED(ret) return ret;
   
  SpecANDExp3->AddSignedSpec(SignedSpecA);
  if FAILED(ret) return ret;
  SpecANDExp3->AddSignedSpec(SignedSpecB);
  if FAILED(ret) return ret;
...
  ret = BasEff3->SetSpecExp(SpecANDExp3); 
  if FAILED(ret) return ret;
...

The specification expression created is "SpecA AND NOT SpecB".

For this we need to create CATICfgSignedSpec and CATICfgSpecANDExpression objects.

A signed specification is necessary to define a NOT operator applying to a specification.

Signed specifications added on the same specification expression are linked with AND logical operator.

[Top]

Performing Add and Cut Operations on an Object

...
//-- Add Operations
  ret = Mod2->Modify(CATICfgModification::Add, uidII1);
  if FAILED(ret) return ret;
...
//-- Cut Operation
  ret = Mod2->Modify(CATICfgModification::Cut, uidII2);
  if FAILED(ret) return ret;
...

The Add and Cut operations are made using the method Modify on a modification object.

[Top]

Creating a Filter

...
//--Filter Creation
  CATICfgFilter_var Filter1, Filter2, Filter3;
  ret = CfgManager->CreateFilter(ConfigurableView, DomainName, Filter1); 
  if(FAILED(ret)) return ret;
	 
//--Config Handler Creation (Persisten Filter)
  CATIConfigHandler_var PersistentFilter1;
  ret = ConfigurableView->CreateConfigHandler("Filter Name",
                                              "Filter Description",
                                              PersistentFilter1);
  if FAILED(ret) return ret;

//--To Filter all objects pointed by a Modification whose Effectivity contains SpecA
  CATICfgNormalValue_var NVFilter1, NVFilter2, NVFilter3;
  ret =  CfgManager->CreateNormalValue(SpecA,NVFilter1);
  if(FAILED(ret)) return ret;

//--To define a Range Filter int StartFilterRange = 5;
  int EndFilterRange = 10;
  ret = CfgManager->CreateNormalValue(StartFilterRange,  EndFilterRange, NVFilter2);
  if(FAILED(ret)) return ret;

//--To Filter all objects pointed by a Modification Mod1
  ret = CfgManager->CreateNormalValue(Mod1,NVFilter3);
  if(FAILED(ret)) return ret;

//--Add Conditions to Filters.
  ret = Filter1->AddCondition (NVFilter1);
  if(FAILED(ret)) return ret;
...

Here are described the three main steps necessary to define a filter: filter creation, normal value definition, and link normal value and filter.

Filter creation: the configuration manager creates the filter. A filter is defined for a specific Configurable View and a specific Domain.
By efault filters are not persistent. To make it persistent, a ConfigHandler has to be created.
Normal value definition: a specific normal value can be created according to the kind of filter to define
Link normal value to filter: the normal value defines a condition, that will be compared to modification effectivities when filtering.

[Top]

Applying a Filter

...
//-- Returns the UUIDs which are TRUE according to the filter.
  SEQUENCE(CORBAAny) UIDList1, UIDList2, UIDList3;
  ret = Filter1->AllFilteredObjects(UIDList1);
  if(FAILED(ret)) return ret;
  ret = Filter2->Filter(UIDList1, UIDList2);
  if(FAILED(ret)) return ret;
...

First, Filter1 is applied to every object under the configurable view used to create the filter. Then, Filter2 is applied to UIDList1 only.

[Top]

In Short

This use case has demonstrated the way to create a configuration structure and use filters on it.

[Top]

References

[1]	Building and Launching a CAA V5 Use Case
[Top]

History

Version: 1 [Apr 2001]	Document created
[Top]