Schem A Editor
Schem A Editor
User's Guide
DSPF1-PE-200008K
Copyright
Copyright © 2002-2011 Intergraph Corporation. All Rights Reserved.
Including software, file formats, and audiovisual displays; may be used pursuant to applicable software license agreement;
contains confidential and proprietary information of Intergraph and/or third parties which is protected by copyright law, trade
secret law, and international treaty, and may not be provided or otherwise made available without proper authorization from
Intergraph Corporation.
U.S. Government Restricted Rights Legend
Use, duplication, or disclosure by the government is subject to restrictions as set forth below. For civilian agencies: This was
developed at private expense and is "restricted computer software" submitted with restricted rights in accordance with
subparagraphs (a) through (d) of the Commercial Computer Software - Restricted Rights clause at 52.227-19 of the Federal
Acquisition Regulations ("FAR") and its successors, and is unpublished and all rights are reserved under the copyright laws of
the United States. For units of the Department of Defense ("DoD"): This is "commercial computer software" as defined at DFARS
252.227-7014 and the rights of the Government are as specified at DFARS 227.7202-3.
Unpublished - rights reserved under the copyright laws of the United States.
Intergraph Corporation
P.O. Box 240000
Huntsville, AL 35813
Terms of Use
Use of this software product is subject to the End User License Agreement ("EULA") delivered with this software product unless
the licensee has a valid signed license for this software product with Intergraph Corporation. If the licensee has a valid signed
license for this software product with Intergraph Corporation, the valid signed license shall take precedence and govern the use
of this software product. Subject to the terms contained within the applicable license agreement, Intergraph Corporation gives
licensee permission to print a reasonable number of copies of the documentation as defined in the applicable license agreement
and delivered with the software product for licensee's internal, non-commercial use. The documentation may not be printed for
resale or redistribution.
Warranties and Liabilities
All warranties given by Intergraph Corporation about equipment or software are set forth in the EULA provided with the software
or applicable license for the software product signed by Intergraph Corporation, and nothing stated in, or implied by, this
document or its contents shall be considered or deemed a modification or amendment of such warranties. Intergraph believes
the information in this publication is accurate as of its publication date.
The information and the software discussed in this document are subject to change without notice and are subject to applicable
technical product descriptions. Intergraph Corporation is not responsible for any error that may appear in this document.
The software discussed in this document is furnished under a license and may be used or copied only in accordance with the
terms of this license. No responsibility is assumed by Intergraph for the use or reliability of software on equipment that is not
supplied by Intergraph or its affiliated companies. THE USER OF THE SOFTWARE IS EXPECTED TO MAKE THE FINAL
EVALUATION AS TO THE USEFULNESS OF THE SOFTWARE IN HIS OWN ENVIRONMENT.
Intergraph is not responsible for the accuracy of delivered data including, but not limited to, catalog, reference and symbol data.
Users should verify for themselves that the data is accurate and suitable for their project work.
Trademarks
Intergraph, the Intergraph logo, PDS, SmartPlant, SmartMarine, FrameWorks, I-Convert, I-Export, I-Sketch, IntelliShip, INtools,
ISOGEN, MARIAN, SmartSketch, SPOOLGEN, SupportManager, and SupportModeler are trademarks or registered trademarks
of Intergraph Corporation or its subsidiaries in the United States and other countries. Microsoft and Windows are registered
trademarks of Microsoft Corporation. MicroStation is a registered trademark of Bentley Systems, Inc. Other brands and product
names are trademarks of their respective owners.
Contents
Preface .......................................................................................................................................................... 9
SmartPlant Foundation Product Documentation .................................................................................... 9
Documentation Comments ................................................................................................................... 11
Define the Storage Location for Your Personalized Menu Configurations ..................................... 68
Modify an Existing Personalized Menu Configuration .................................................................... 69
Layouts .................................................................................................................................................. 70
Create a Layout .............................................................................................................................. 70
Schema Editor Naming Rules ............................................................................................................... 72
Define Naming Rules for Objects ................................................................................................... 79
SmartPlant P&ID Example: Define Mapping to Publish Variable Frequency Drives ................... 446
SmartPlant Electrical Example: Mapping a New String Property Starting in the
Tool ............................................................................................................................................... 447
SmartPlant Electrical Example: Mapping a New Enumerated List Starting in the
Tool ............................................................................................................................................... 451
Example: Extending an Existing Enumerated List ....................................................................... 457
Example: Define and Map Naming Conversions from SmartPlant P&ID to ................................. 463
Example: Adding Map Edge Definition to Publish Properties of Related Objects ....................... 469
Integration Documentation
SmartPlant Foundation Core Functionality & Enterprise Integration Capabilities Release
Bulletin - Provides information on new SmartPlant Foundation and integration features for
the current release.
SmartPlant Enterprise Overview - Provides an overview of SmartPlant Enterprise and
integration concepts and data exchange among integrated SmartPlant Enterprise authoring
tools.
SmartPlant Enterprise Data Exchange Diagrams - Includes full-size graphics that describe
the exchange of data among SmartPlant Enterprise authoring tools. These graphics are also
included in the SmartPlant Enterprise Overview.
SmartPlant Enterprise Integration Example Guide - Provides an overview of integrating
SmartPlant Enterprise and describes a typical example of full integration within SmartPlant
Enterprise, including publishing and retrieving plant information using SmartPlant authoring
tools and Aspen Basic Engineering™.
SmartPlant Enterprise Hardware and Software Recommendations - Provides information
about the hardware recommendations and software requirements of the authoring tools that
are part of the SmartPlant Enterprise suite.
Integration Setup Guide - Provides information about setting up and using SmartPlant
Enterprise products in an integrated environment. Also provides integration troubleshooting
information.
Integrated Line List Configuration and User's Guide - Provides configuration and user
information for creating, publishing, or retrieving line list documents in SmartPlant
Foundation and SmartPlant Materials.
SmartPlant Enterprise Backup and Restore Guide - Provides backup, restore, and
resynchronization procedures for SmartPlant Foundation, SmartPlant Basic Integrator, and
integrated SmartPlant Enterprise authoring tools. The procedures are designed to minimize
data loss and downtime when restoring data in an integrated environment.
Documentation Comments
Send documentation comments or suggestions to PPMdoc@intergraph.com
(mailto:ppmdoc@intergraph.com?subject=documentation comments).
2009 R3 SP3
Typographical corrections were made to this document.
2009 R3 SP2
You can automatically correlate an enumerated list from a tool with an enumerated list in the
schema. See Automatically Correlate a Tool Enumerated List with a Schema Enumerated
List (on page 339).
Schema Editor includes a new feature that automatically maps multiple enumerations
existing in an authoring tool to the SmartPlant Schema. In the previous release, automatic
mapping was possible only with an enumeration. This feature benefits the administrator by
expediting the schema mapping process.
You can export schema data from Schema Editor to Microsoft Excel to make changes. You
can import the edited schema from Excel to Schema Editor. The following data can be
exported to Excel: any schema displayed in a tabular view, Pseudo file configuration (CMF),
and Schema container (XML file or CMF active configuration). See Using Excel to Export
and Import Schema (on page 211).
Schema Editor includes a new feature that supports filtering by a component schema only
that set of properties are available for mapping. Filtering by component schema narrows
the set of properties available to the user to only those properties that are used within the
particular component schema.
A number of new features have been added to the Schema Editor to facilitate faster loading
of the schema into SmartPlant Foundation:
Added ContainerID as a property for pseudo-file configurations and modified the edit
form for configurations to support the definition of this property.
Added the Tools > Schema > Generate Component Schema command and a new
API to generate a single component schema (as opposed to all component schemas).
Added SPFMeta attribute to Container element and added support for automatic loading
of SmartPlant Foundation metadata inside Schema Editor based on this attribute value.
2009
The Schema Editor displays validation errors and messages in a new user-friendly interface
to help you more easily diagnose problems.
The Selectively Update command allows you to compare schemas, tool map schemas,
and data files, then selectively choose which objects to add, update, or delete. Schema
Editor also provides the ability to compare either the CMF files or XML files between two
different configurations.
A new Layout menu allows you to build your own Schema Editor user interface by opening
multiple intelligent controls that update automatically when you select an object on one of
the forms.
The Auto-create command can be used to automatically add new properties to view
definitions. This feature only allows you to add new properties to a view definition and does
not update existing properties on view definitions.
The New SmartPlant Enumerated List with Correlated Entries command establishes
publish and retrieve relationships or only a publish relationship for the SmartPlant
enumerated lists. A message appears allowing you to click Yes to establish both publish and
retrieve relationships or click No to establish only a publish relationship.
2008 SP 1
The Schema Editor provides usability improvements through an updated user interface that
uses tabs and toolbars to help you navigate in the software. You can access this new user
interface by clicking Workflows > Standard Workflows in the Schema Editor or by
launching the Schema Editor from the following location on the Start menu: Start > All
Programs > Intergraph SmartPlant Foundation > SmartPlant Schema Component >
SmartPlant Schema Editor - Standard. The previous Schema Editor user interface,
featuring the Overall Workflows dialog box, is still available by clicking Workflows > Overall
Workflows or by clicking Start > All Programs > Intergraph SmartPlant Foundation >
SmartPlant Schema Component > SmartPlant Schema Editor - Developer. For more
information, see Standard Workflows Window (on page 50), Schema Editor Toolbars (on
page 53), and Schema Editor - Standard Overview (on page 56).
You can use the new Edit > Turn AutoValidation On command to perform real-time
validation on any changes that you make to the schema or tool map schemas when you end
a transaction (complete a command or action) in the Schema Editor. The Problems
Detected dialog box displays any validation errors with detailed explanations of the errors
and their solutions.
For more information about the validation rules the Schema Editor uses to validate files, see
the Validation section in the SmartPlant Schema Component API Reference Guide.
Every time you make a change to the contents of any CMF, XML, or CFG file in the Schema
Editor, the Schema Editor sets a validation flag to false. The next time you save the file, the
Schema Editor prompts you to validate the file. Once you have validated the file and no
errors have been found, the Schema Editor sets the validation flag to true. For CMF files, all
configurations must be validated with no errors before the entire CMF file is considered
validated.
The new Layout menu allows you to build your own Schema Editor user interface by
opening multiple intelligent controls that update automatically when you select an object on
one of the forms.
You can create name display rules from the MetaSchema Extension environment in the
Schema Editor. Name display rules define how names of objects are displayed in the
Schema Editor user interface. You can also create name display rules by double-clicking the
NameDisplayRule node in any meta schema view in the Schema Editor. For more
information, see Schema Editor Naming Rules (on page 72).
2008
The SmartPlant Schema Editor is now the application used to modify the SmartPlant
Foundation data model.
The Schema Editor supports modifying multiple SmartPlant schema configurations at the
same time using configuration (CMF) files.
The SmartPlant schema can be managed as an object in SmartPlant Foundation. To edit
the SmartPlant schema for integration, you can check out the schema CMF file in the
SmartPlant Foundation Desktop Client and then launch the Schema Editor by right-clicking
the CMF file.
The Schema Editor also supports session files. Session files allow you to save registered
tool information, file configuration information, tool map schema information for loaded map
files, and displayed windows and dialog boxes that you want to restore when you reopen the
Schema Editor. When you exit the Schema Editor, the software prompts you to save your
session file so that you can return to your work easily. You can create, modify, and open
session files in the Schema Editor using the File > Session Files commands. When you edit
the CMF file from SmartPlant Foundation in version 2008 and above, the Schema Editor
automatically saves a session file and uses it to determine the state of the Schema Editor
when you launch it again from the Desktop Client.
To provide a comprehensive representation of the mapping supported by an authoring tool
adapter, the Schema Editor provides a new "for information only" map relationship. This
allows authoring tool developers to identify hard-coded mapping for documentation
purposes. You can flag a map relationship for information only by clicking the For
Information Only button on the Publish and Retrieve tabs in the Edit Map Class
Definition window. ForInformationOnly is a property on the IMapRel interface.
The Schema Editor now supports comparison for retrieve mapping. You can also specify
properties that you do not want to map for retrieve. Previously, this functionality was only
available for publish.
During mapping, you can now select existing application enumerations or properties and
automatically create the corresponding SmartPlant enumerations or properties. During
creation of these objects, the Schema Editor also maps the application objects to the
automatically-generated SmartPlant schema objects by creating map relationships between
the two.
The Schema Editor provides auto-correlation during mapping, which allows users to view a
list of the best matches, based on a default algorithm, for mapping between map property
definitions, map enumerated lists, and map unit of measure lists and existing objects in the
schema. The Auto-map button is available on the Publish and Retrieve tabs on edit dialog
boxes for map class definitions, map enumerated list definitions, and map unit of measure
definitions.
You can now select multiple view definitions for publish and retrieve in the Mapping
Environment.
During synchronize between the authoring tool meta data and the authoring tool map file,
you can export the synchronization information into an Excel spreadsheet.
The Schema Editor now supports merging a property definition into another, existing
property definition. Merging property definitions adds a Transform object to the schema file
that is copied to the transformations file when that file is created by the Schema Editor.
When you export tool-to-tool mapping to Excel, the tool map file names appear at the top
above each set of Tool columns to make it easier to read the mapping spreadsheet.
If you select specific class definitions for searching, the Schema Editor saves the selected
class definitions for your next search.
Defining data sheets for SmartPlant Foundation is now done by system administrators in the
Desktop Client.
Class Definitions
A class definition is a named description of a set of objects that support or realize the same
interface definitions and share the same property definitions and relationships. In the schema,
class definitions can represent physical things, such as pumps, or conceptual things, such as
projects.
Class definitions have the following characteristics:
Every class definition belongs to one and only one component schema.
Every class definition has a primary interface definition that defines the set of possible roles
(interface definitions) for the class definition.
Every instance of a class definition is instantiated by a class factory.
Class definitions have a Realizes relationship with interface definitions. This means that
instances of a particular class definition support or implement the realized interface definitions.
For example, the Vessel class definition realizes the IVessel interface definition. The IVessel
interface definition exposes property definitions, such as RatedVolume, for class definitions that
realize the IVessel interface definition.
Class definitions must also realize implied interface definitions. If an interface definition implies
another interface definition, then any class definition that realizes the first interface definition
must also realize the implied interface definition.
Model Definitions
A model is a non-redundant description of an object. For example, a 3D plant model is a
non-redundant 3D description of a plant (non-redundant = non-excessive).
A model definition (ModelDef) is the schema information used to describe the model. Model
definitions in the SmartPlant schema are roughly based on the POSC- CAESAR model.
The primary function of a model definition is to identify those objects that can be shared through
a ModelClass relationship. Objects can only be shared if they exist within the same model
definition. Objects in different model definitions can be related, but they cannot be shared.
Model definitions define domains of data. The SmartPlant schema contains seven model
definitions:
MetaModel - Used only by the class definitions in the meta schema. You should never use
this model for schema.
OrganizationModel - Used for class definitions that are organizational concepts. Examples
would be User, Company, Department, Manufacturer, Vendor, and so on.
WorkBreakdownModel - Used for class definitions that provide organizations of work. This
includes the class definitions that you see in the WBS documents such as Project and
Contract as well as all the document class definitions defined in the schema.
FacilityModel - Used for class definitions that represent abstract concepts in a process
plant. Examples include Plant, Area, Unit, System, Discipline (although you could put
Discipline in the OrganizationModel instead.)
PlannedMaterialModel - Used for class definitions that represent real objects that you plan
to purchase to construct your design. This is the "design" arena in which engineering tools
like Aspen Basic Engineering, SmartPlant P&ID, and SmartPlant Instrumentation work. In a
traditional SmartPlant Foundation model, this would be the "tag".
TypicalMaterialModel - Used for class definitions that represent real objects offered by
manufacturers or vendors. When an engineer looks for an object to fulfill the requirements of
his design, he might look through a manufacturer catalog. This is the domain of this model.
In a traditional SmartPlant Foundation model, this would be the "model", "catalog", or
"standard equipment".
ActualMaterial - Used for class definitions that represent what is purchased and assembled
to construct the plant. In a traditional SmartPlant Foundation model, this would be the
"asset".
Evolution for objects is normally from planned facility (FacilityModel) to planned material
(PlannedMaterialModel) to actual material (ActualMaterialModel). Catalog parts are part of the
typical material model. Meta schema objects are part of the meta model. The organization
model contains objects that are outside the normal set of designed objects; these objects
describe the organization rather than the design. The work breakdown model contains object
associated with the work being performed rather than the objects for that work.
All model definitions are predefined in the meta schema and cannot be modified.
See Also
Shared Object Definitions (on page 21)
In each authoring tool, the pump (P100) is published with a different class definition, including
PFDProcessEquipment, PIDProcessEquipment, and EQDCentrifugalPump. However, a shared
object definition called SharedEquipment_PM indicates that these three class definitions all
define the same object in an integrated environment. The three class definitions coexist in a
sharing relationship. The shared object definition collects information to indicate this sharing
relationship.
If you look at the realizes relationship for each class definition, you can see many of the same
properties because, as the object moves from one tool to another, properties are updated and
the information is enriched.
When an object is created in the PFD, it has a unique identifier for the object (UID). For
example, PFD UID AA1 (P100) gets published. Then, SmartPlant P&ID retrieves P100, some
additional work is done, and it gets published as PID UID AA2 (P100). The two publishes
establish a Same As relationship. The Same As relationship indicates that object AA1 is the
same as object AA2.
See Also
Schema Modification Rules (on page 144)
Model Definitions (on page 20)
Interface Definitions
An interface definition is a named collection of property definitions. Every interface definition is
realized by one or more class definitions. Interface definitions expose the property definitions for
class definitions. By sharing specific interface definitions, class definitions can also share
property definitions, but not the data associated with the properties.
However, class definitions that share the IObject interface also realize other interface definitions
that define other roles for them. These interface definitions expose other property definitions for
the objects.
IObject
Every persistent object must be identified by a unique identifier (UID) which is a property on the
IObject interface for that object.
Every relationship and relationship definition has a property UID1 that identifies the UID of the
object at end 1 of the relationship and a second property UID2 that identifies the object at end 2
of the relationship.
The description of an interface definition includes its properties, methods and
relationships. Since any interface definition is a potential end for a relationship or relationship
definition, the extended definition of an interface, which includes the interface definitions directly
or indirectly implied by that interface definition, must include IObject. Therefore, every interface
definition must directly or indirectly Imply IObject.
For every interface definition that doesn't directly or indirectly imply IObject, an error will be
reported during validation.
Realizes Relationship
The first and most common relationship between class definitions and interface definitions is the
Realizes relationship. A class definition Realizes an interface definition. The Realizes
relationship may be required or optional. If it is required, the Schema Component will require
that an instance of that class definition realize an instance of the required interface definition.
example, the IEquipmentOcc interface definition defines what a piece of equipment is in the
schema, and IInstrumentOcc defines what an instrument is.
A class definition does not necessarily include all the roles of the primary interface definition
because the class definition is the view that a single authoring tool or component schema has of
that object. For instance, PIDProcessEquipment does not realize all the interface definitions in
the implies hierarchy for IEquipmentOcc because SmartPlant P&ID does not manage all those
interfaces, properties, and relationships, only a subset of them.
This complete set of roles for a class definition, defined by the primary interface, is used in
several ways in an integrated environment:
Validation - Class definitions may not realize any interface definition outside of the implies
hierarchy of the primary interface definition.
Sharing - Class definitions that are shared must have the same primary interface definition
or must imply the same primary interface definition. For example, PFDProcessEquipment
and PIDProcessEquipment have the same primary interface definition and are defined as
shared. EQDReactorVessel does not have the same primary interface definition, but it does
imply the same primary interface definition (IReactorVesselOcc implies IEquipmentOcc).
Therefore, EQDReactorVessel is defined as shared with PFDProcessEquipment and
PIDProcessEquipment.
Mapping - You can map the SmartPlant schema to an authoring tool schema using class
definitions. However, you might end up mapping the same interfaces and properties over
and over. For example, if your application retrieved equipment tags, you would want to
retrieve PFD, P&ID, and EQD. To map by class definition, you would end up mapping to
PFDProcessEquipment, PIDProcessEquipment, and dozens of EQD* class definitions. If
you map to the primary interface definition for these class definitions (IEquipmentOcc), you
only have to map to it once, and you can retrieve any object that realizes that interface
definition.
The primary interface is used for schema modeling; it bears no relation to instantiation in
SmartPlant Foundation. Only Realizes relationships are instantiated in SmartPlant
Foundation.
An interface must be realized to be used on a form in SmartPlant Foundation.
In the SmartPlant schema, primary interfaces typically end in "Occ".
Implies Relationship
The definition of an object is completed through Implies relationships between interface
definitions. When you consider the complete hierarchy of Implies relationships for the primary
interface definition that a class definition realizes, you know everything about that object in an
integrated environment.
If an interface definition implies another interface definition, then any class definition that
realizes the first interface definition can also realize the implied interface definition. For example,
IEquipmentOcc implies the IDrawingItem. Therefore, any class definition, such as
PIDProcessEquipment, that realizes IEquipmentOcc can also realize ISolidItem. If an Implies
relationship between two interface definitions is required, then all class definitions that realize
the first interface definition must also realize the second.
Properties Categories
The property category helps organize properties in the Properties window in SmartPlant
Foundation. Property categories can be defined by the interface definition or edge definition. If
no property definition is defined for the edge definition, properties across the edge definition are
assigned a property category based on the property category defined for the interface definition
that exposes the properties.
Special Handling for PropCategory Property Definition
Property Category is a special property definition in that it is a consolidated enumerated value in
which the individual enumerated values are separated by semi-colons (;). When you create or
edit an interface definition, select the Browse next to the Property category box. The Values
for PropCategory dialog box allows your to define this property value.
Value - Displays enumerated values separated by the semi-colon delimiter for property value.
Unused enumerated values - Lists all the entries in the enumerated list that have not been
used as part of the Property Category value
Used property values - Lists all the enumerated values that have been used as part of the
Property Category value.
A number of options exist for editing the Property Category value:
The value can be keyed into the Value box.
Unused enumerated values can be selected and then by clicking Add inserted into the list of
used enumerated values.
Used enumerated values can be selected and then by clicking Remove deleted from the list
of used enumerated values
The order of the used enumerated values can be changed by selecting a value from this list
control and then clicking Move Up or Move Down
In addition, this form allows the addition of a new combination of values (or simply a new value)
to the enumerated list by clicking the Add to List.
Property Definitions
All property definitions for an object are exposed through its interface definitions and never
directly by the object. The property definitions that apply to a particular interface definition are
defined by the Exposes relationship between objects of type InterfaceDef and objects of type
PropertyDef in the schema. A particular property definition for a given class definition is typically
exposed by one, and only one, interface definition.
For example, the IObject interface definition exposes the following property definitions:
UID - Unique identifier for the object. This identifier is only required to be unique within the
SmartPlant schema.
Name - Name of the object
Description - Description of the object
All objects in the schema have these properties because all class definitions realize the IObject
interface definition.
Property Types
Property types define the set of possible values for a property definition. The scoped by
relationship definition specifies the property type that defines acceptable values, or scopes, a
particular property definition. Every property definition is scoped by one and only one property
type. All properties of that property definition must be of that property type.
Each property type is actually a class definition in the meta schema that realizes IPropertyType,
which allows it to be a scoping property type for property definitions.
Basic varieties of property types in the SmartPlant schema include the following:
Boolean - Specifies that the property can have only one of two values: True or False.
Double - Specifies that the property is a double-precision floating point number.
EnumListLevelType - Specifies that the property definition is a special property type that is
used to describe all enumerations at a given level in an enumeration hierarchy.
EnumListType - Specifies that property values are defined by an enumerated list. For more
information about enumerated list types, see Enumerated Lists (on page 27).
Int - Specifies that property values for this property are integers.
String - Specifies that values for the property can contain alphanumeric strings with some
punctuation, such as periods (.), underbars (_), question marks (?), and so on.
Commas are automatically replaced with semicolons when entered in properties of
type string.
UoMListType - Specifies that values for the property can be a numeric value (double)
combined with a unit of measure from the appropriate unit of measure list, along with some
optional criteria. For more information about unit of measure list types, see Units of
Measurement (on page 31).
YMD - Specifies that the property value is a date (year, month, day).
See Also
Schema Modification Rules (on page 144)
Create a Property Definition (on page 194)
Enumerated Lists
In the SmartPlant schema, some property definitions are of the enumerated list type
(EnumListType). These property definitions have a list of possible string property values defined
for them in an enumerated list (sometimes called a "picklist" or "lookup"). Any value for a
property definition of this type must match an entry in the list of enumerated property values
defined for the property type.
Each enumerated list contains one or more enumerated entries (EnumEnum). Each enumerated
entry represents a possible value for a property scoped by that enumerated list.
Enumeration Hierarchies
Enumerated lists can contain all the possible enumerated entries for a property definition, or
they can be combined to form an enumeration hierarchy. When you combine enumerated lists
this way, you create child enumerated lists that are referenced by other enumerated lists. When
this happens, a special property type (enumerated list level type) can be used to describe all
enumerations at a given level in the enumeration hierarchy. When a property definition has an
associated enumerated list level type, it effectively allows dependent picklists to be defined.
All nodes in the hierarchy that are EnumListTypes are enumerated entries for the EnumListType
above them. All EnumListTypes must contain EnumEnums (list entries) or other EnumListTypes
(enumerated lists).
The following UML diagram presents the SmartPlant schema model for enumerated lists and
enumerated entries.
The EnumListType class definition is used for enumerated list property types. EnumListType
realizes IPropertyType. EnumListType also realizes IEnumListType, the interface definition that
supports enumerated list behavior. IEnumListType has a Contains relationship definition to
IEnumEnum. Instances of this relationship are used to indicate the enumerated entries
contained within the enumerated list.
Leaf nodes within an enumerated list hierarchy are instances of the EnumEnum class definition.
This class definition realizes IEnumEnum, the interface definition that supports enumerated
entry behavior, and IObject, the interface that contains the short (Name) and long (Description)
text values for the enumerated entry. Branch nodes within an enumerated list hierarchy are
instances of the EnumListType class. EnumListType has an optional realizes relationship to
IEnumEnum, which means that an enumerated list may or may not be an enumerated entry as
well. For branch nodes within an enumerated list hierarchy, the EnumListType object will realize
this optional interface.
By adding support for IEnumEnum to the EnumListType class definition, the need for the
ConstrainsList between IEnumListType and IEnumListType and ConstrainsEntry between
IEnumEnum and IEnumEnum relationship definitions has been eliminated. Therefore, these
relationship definitions are no longer part of the SmartPlant meta- schema.
EnumMetadata Relationship
Sometimes enumerated entries are not just short and long text strings. In some cases
enumerated entries have additional properties and/or additional behavior associated with them.
The EnumMetadata relationship definition is used to relate an enumerated entry (or an
enumerated list that also supports the IEnumEnum interface) to other objects that provide
additional properties and/or additional behavior to the enumerated entry.
Each level in an enumerated list hierarchy is a specialization of the level above it. For example,
pumps and compressors are specializations of mechanical equipment and reciprocating and
centrifugal pumps are specializations of pumps. Therefore, type specialization can be
considered to be an enumerated list hierarchy.
At each level of specialization in the type hierarchy, there can be EnumMetadata relationships
to other objects that provide additional information and behavior about that enumerated entry.
One of the class definitions that supports IEnumMetadata is InterfaceDef. This means that an
enumerated entry (or enumerated list that supports IEnumEnum) can have as EnumMetadata
relationship to an interface definition that defines additional properties and behavior for that
enumerated entry. For example, the Pump enumerated list could have an EnumMetadata
relationship to IPump, which would then define additional properties and behavior common to
pumps.
Since the various nodes in the type specialization hierarchy can have corresponding roles
(interface definitions), the type specialization can have a corresponding role specialization. For
the type specialization, each node in the enumerated list hierarchy would have a Contains
relationship to its more generalized parent whereas the corresponding role specialization would
have similar Implies relationships between the interface definitions.
The interface definition involved in the EnumMetadata relationship will normally have (unless it
corresponds to a leaf node) an exposed property definition that is scoped by the related
enumerated list. Therefore, IPump exposes a property PumpType that is scoped by the Pump
enumerated list.
See Also
Property Definitions (on page 26)
Schema Modification Rules (on page 144)
Units of Measurement
A unit of measure list type (UoMListType) is a special type of enumerated list with additional
semantic information.
Conversion Factors
Each enumerated entry in the unit of measure list has conversion factors to convert from the SI
units for that list to the specific units of measure selected by the user. In the schema, a
UoMEnum contains two conversion factors: a multiplier (A) and an addend (B). These
conversion factors are used to convert the value to SI units. For example, the given unit (x) is
multiplied by A and then B is added to that value to determine the SI value (y = Ax + B).
A UoMListType is a composition of enumerated unit of measure entries. One entry in every unit
of measure list has a relationship of HasDefaultSI with the UoMListType, which means that the
entry is the default SI unit of measure for the list. For example, in the TimeUoM list, "s"
(seconds) is the default SI unit of measure for time.
Relationship Definitions
Relationship definitions are associations between interface definitions. They identify two specific
objects that fulfill the roles on each end of the relationship.
All relationship definitions in the schema are of class RelDef, which is part of the meta schema.
A relationship definition has two ends, End1 and End2. The positive direction for navigating this
relationship is from End1 to End2. The reverse direction is from End2 to End1. A relationship
can only exist between objects that support (realize) the interface definitions at each end of the
relationship definition.
Relationship definitions also define cardinalities on each end of the relationship. Cardinalities
provide the constraints for relationships by defining the minimum and maximum numbers of
participants at each end of a relationship. For example, in the
EquipmentComponentComposition relationship there can be zero to many (0..*) objects that
have the role of Equipment Components but only zero or one (0..1) object that can have the
role of Equipment in each instance of the relationship.
The following graphic shows the UML for the EquipmentComponetComposition relationship
definition:
For example, if you create a relationship between a company and employee, you could use the
IEmployee interface to expose link attributes (properties) like employee number, salary, office
number, and e-mail address on the relationship.
See Also
Schema Modification Rules (on page 144)
Edge Definitions
An edge definition is the definition of a path to follow to get from a starting object to one or more
related objects. An edge definition can also include criteria to filter the objects across the
specified relationships to only include a specific set.
Edge definitions have the following properties:
A starting interface definition (required)
A path definition that specifies the relationships to traverse from the starting interface
definition along related interface definitions and the direction to traverse those relationships
(required)
Discrimination criteria that can be applied to objects at the end of the path (optional)
Position criteria that can select a specific object from the set of objects that satisfy the
discrimination criteria at the end of the path (optional)
Implicit Edges
Two implicit edge definitions exist for every relationship definition in the schema: one that is
positive (going from end 1 to end 2 of the relationship), and one that is negative (going from end
2 to end 1). The following graphic shows the positive and negative relationship edges (+Rel1
and -Rel1) between object A and object B.
The following graphic shows an explicit edge definition that traverses multiple relationships by
going from object A to object C through the relationship that each object has with object B. The
path for this relationship is +Rel1, -Rel2.
Discrimination Criteria
Edge definitions can specify discrimination criteria, including position, to help you filter the
objects at the end of the path defined by the edge definition. For example, you can use position
criteria in an edge definition to return the fifth nozzle on a piece of equipment by specifying a
numeric position of 5 when you define the edge definition. Another option is to specify that you
want the first or last object in the path by defining named criteria for the edge definition. You can
also use discrimination criteria based on property values to specify that you only want to see
objects with a Process Case of Minimum by creating an edge definition whose discrimination
criteria included ProcessCase = Min.
Another way to use discrimination criteria to filter results is to specify that all objects at the end
of the path must support a particular interface. For example, if you want to create an edge
definition to display the P&ID an object is on, you could specify that all objects at the end of the
path must support IPIDDrawing to make sure that only P&IDs and not other objects that
participate in the DwgRepresentationComposition relationship are returned by the edge
definition.
The following UML diagram shows an edge definition that uses discrimination criteria to go from
a piece of equipment to the P&ID on which the piece of equipment appears:
Without an edge definition, to get from object A to object D you would have to traverse from A to
B, B to C, and then from C to D. With an edge definition, you could traverse directly from Object
A to Object D.
System administrators might also create an edge definition to traverse directly from a plant to a
unit. In SmartPlant Foundation, units are directly related to functional areas. However, a custom
edge definition would allow the user to expand the plant to see the units without expanding a
functional area first.
You can a set flag on the edge definition to determine whether all users have access to the edge
definition. If the Filter out edge in display option is selected on the edge definition, then only
those users in user groups that have been associated with the edge definition can see the edge
definition in the SmartPlant Foundation client. Edge definitions show up in the relationships
section of the shortcut menu for user groups that have access to the edge definitions.
See Also
Graph Definitions (on page 37)
Graph Definitions
A graph consists of nodes and edges. The nodes (typically represented as circles) are
connected to each other by the edges (lines). A directed graph is a special type of graph in
which each of the lines goes in one direction only (typically represented using arrows). A
directed graph traversal across an edge is always done in the one direction specified, never in
the opposite direction.
The Schema Editor supports directed graph definitions (GraphDefs) for which the nodes are
interface definitions and the edges are edge definitions. These directed graph definitions consist
of a set of interface definitions (nodes) connected by a set of edge definitions (edges).
The definition of a directed graph begins by identifying the starting node (interface definition) for
the graph. Once the starting interface definition has been defined, the next step in the process is
to identify an edge (edge definition) to traverse. The list of edge definitions that can be used are
the set of edge definitions that start at the specified interface definition or that start at an
interface definition directly or indirectly implied by that interface definition.
When an edge (edge definition) is added to the graph, the node (interface definition) at the end
of the edge is given a name. This name is used to identify the node for purposes of adding
edges to the graph from that node.
After the starting node (interface definition) and the first edge (edge definition) have been
defined, the directed graph consists of two nodes: one for the starting interface definition and
one for the named interface definition at the end of the first edge. You can extend the graph
definition by adding an edge to either the starting node (interface definition) or the node
(interface definition) at the end of the first edge. You can continue to extend the graph definition
this way until you have the graph definition that you want.
Occasionally, you may need to extend the graph from a specific node (interface definition) using
an edge (edge definition) that starts at an interface definition that is not the interface definition
for that node or an interface definition directly or indirectly implied by the interface definition for
that node. In this case, you must identify a more "specialized" interface definition that either is or
implies the starting interface definition for the edge definition that you want.
For example, consider a graph definition that starts at IEquipment and traverses the
EquipmentEquipmentComponent relationship definition to reach a node corresponding to
IEquipmentComponent. If you want to continue this graph definition from the node
corresponding to IEquipmentComponent using a relationship definition that starts with INozzle,
you must explicitly select INozzle rather than IEquipmentComponent for that node in the graph
definition. Because INozzle is not implied by IEquipmentComponent, the relationships from
INozzle are not, by default, available for continuing the graph definition.
Directed Graphs
When a directed graph definition is applied to an object (or a set of objects), the result is a
directed graph in which the nodes are objects and the edges are edges. A directed graph is
therefore an instance of a directed graph definition (just as an object is an instance of a class).
Where the directed graph definition consists of nodes that are interface definitions and edges
that are edge definitions, the directed graph consists of nodes that are objects and edges that
are edges. Therefore, a directed graph definition can start at interface definition IEquipment and
traverse EquipmentEquipmentComponent to get to IEquipmentComponent. The corresponding
directed graph can start at vessel V-100 and traverse to equipment components N1, N2, N3 and
N4.
View Definitions
Directed graph definitions are useful for defining a network of objects to be traversed. While the
objects resulting from traversing a graph definition (the graph for that graph definition) can be
viewed as objects (the Schema Editor frequently does this), there is also a desire to see these
objects from a flattened perspective.
Viewing objects from a flattened perspective can be useful for
Viewing the graph as a table where each row in the table corresponds to one set of objects
from the graph
Viewing the graph as an Excel data sheet where cells in the data sheet correspond to
specific properties from specific objects in the graph
View definitions are used to support this flattening of the directed graph. A view definition
includes a selected subset of the complete set of properties that a graph definition exposes.
View definitions are SmartPlant equivalents of relational database views. A relational database
view is a combination of joins and projects where the joins are used to retrieve the desired
objects and the projects are used to determine which properties (columns) to include and what
to call those properties. SmartPlant equivalents of relational database joins are directed graph
definitions. The projection of this graph data is accomplished using view definitions.
View definitions consist of the following:
A starting interface definition
Identification of the directed graph definition for the view definition
A definition of the projection of property definitions from the directed graph definition,
including modified display names as needed
A view definition is based on a directed graph definition and, therefore, like the directed graph
definition, has a relationship to its starting interface definition. This interface definition should
always be the same interface definition as that for its directed graph definition.
See Also
Edge Definitions, Graph Definitions, and View Definitions (on page 33)
View Definitions (on page 39)
Class Definitions (on page 19)
Meta Schema
The meta schema is a set of schema objects that describe the objects in the SmartPlant
schema. The schema, on the other hand, is a set of schema objects that describe data objects.
The meta schema provides the building blocks upon which the SmartPlant schema is built. The
classes in the meta schema do not directly describe data that is part of the schema. Instead,
these classes describe the classes in the schema.
In the following UML diagram, for example, ClassDef is the meta schema object that describes
the Pump object in the schema. The Pump class in the schema is an instance of ClassDef in the
meta schema. The Pump class in the schema describes P-100, which is the data. P-100 is an
instance of the Pump class.
All classes in the schema are instances of the ClassDef class in the meta schema. Similarly, all
relationship definitions in the schema are of class RelDef, which is part of the meta schema.
The meta schema also describes itself. For example, all classes in the meta schema are also of
the class ClassDef, which is defined as part of the meta schema.
Viewing the meta schema without a schema or data is useful if you want to understand the
classes that the meta schema contains.
When you open the Schema Editor, the meta schema is already available for viewing before you
open any other files. The meta schema is not stored in an external file and is always available in
the Schema Editor.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
Tool Map Schemas (on page 244)
XML Files (on page 43)
Component Schemas
A component schema is a subdivision of the complete SmartPlant schema. It contains the set of
class definitions that are used within a specific domain or application area. For example, the
PIDComponent component schema contains all the class definitions that are relevant to P&IDs.
Component schemas break up the SmartPlant schema into manageable chunks that correspond
almost one-to-one to a document type being published by the authoring tools, such as a PFD,
Equipment Data Sheet, or P&ID. At a minimum, there is a component schema defined for each
authoring tool that publishes data. You can extract component schemas from the SmartPlant
schema using the Schema Editor.
One of the primary purposes of the component schema is performance. When an authoring tool
like SmartPlant P&ID indicates it is going to publish a certain document type, the SmartPlant
Client loads only the necessary component schema instead of the entire SmartPlant schema.
Component schemas contain the following:
The set of class definitions that have a componentization relationship with the component
schema. For example, the Vapor, Liquid, Solid, and BulkPhase class definitions belong to
the PFDComponent component schema, which means that the PFDComponent schema
has componentization relationships with each of these class definitions.
The interface definitions realized by those class definitions.
The property definitions exposed by those interface definitions.
The property types scoped by those property definitions.
To modify component schemas, edit the SmartPlant schema in the Schema Editor
and then regenerate the component schemas from the SmartPlant schema. Otherwise, your
component schema changes could be lost.
Shared Objects
The component schemas are full of examples of shared objects that appear in more than one
component schema. Virtually all of the schema data defined in a component schema, including
class definitions, interface definitions, property definitions, and property types, may be shared by
one or more other component schemas.
The unique identity of an object is defined by its unique identifier (UID) and does not depend in
any way on its classification. Therefore, an object can be classified differently by different
components and still be one shared object in the SmartPlant Foundation database. For more
information about shared object definitions, see Shared Object Definitions (on page 21).
For example, if an object in one component schema is classified as class AA1 and the same
object with the same UID is classified as class AA2 by another component schema, then the
shared object in the SmartPlant Foundation database contains the information associated with
the union of classes AA1 and AA2.
XML Files
All documents that are published or retrieved in an integrated environment are in XML format.
These XML files must conform to the structure defined by the SmartPlant schema.
When a set of objects, grouped by document, are published or retrieved, an XML file container
is used to house those objects in XML format. The following XML format is used by the XML file
container:
<Container>
<classA>
<interfaceX property1="value" property2="value">
<interfaceY property1="value">
.
.
.
</classA>
<classB>
.
.
.
</classB>
</Container>
The <class> elements identify objects of a particular class. Within each <class> element, there
are the interfaces for that class. The <interface> elements expose the properties for the class.
The property type for each property defines the acceptable values for that property in the XML
file.
The following graphic displays a sample XML container file with authoring tool data as it might
look in Internet Explorer:
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
Meta Schema (on page 41)
Tool Map Schemas (on page 244)
UML Notation
In order to understand the UML diagrams used in the Schema Browser view, you must
understand the basics of UML notation.
In UML all class objects are shown as rectangles with the name of the object and its stereotype
at the top. Stereotypes define the types for classes and relationships. Stereotypes are always
depicted in UML using the string <<stereotype>>, where stereotype is replaced by the
appropriate value, such as ClassDef.
For example, Pump is stereotyped as a ClassDef, which means that Pump is a class definition
in the schema.
Relationships in UML are shown as lines that connect objects. In the SmartPlant schema, the
UML for each relationship has a stereotype that identifies the relationship type. Therefore, the
following UML indicates that a relationship of type ScopedBy exists between the UID object,
which is of type PropertyDef, and the String object, which is of type StringType.
One special type of relationship, a Realizes relationship, has a special symbology within UML
and may or may not have a stereotype because the stereotype is redundant with the special
symbology. For example, this graphic shows the PFDNozzlePort and the interfaces it realizes.
Certain relationships, called relationship definitions, not only have a stereotype but are also
named and have roles and cardinalities defined at both ends of the relationship. A relationship
definition not only defines a relationship but also establishes the type for a set of other
relationships. For example, the Realizes relationship is typed by the Realizes relationship
definition in the following graphic.
In this example, the Realizes relationship definition has a RealizedByClassDefs role and a
cardinality of one-to-many at end 1. At end 2, it has a RealizedInterfaceDefs role and one to
many cardinality. Because relationship definitions can be identified by the relationship name,
roles, and cardinalities, the stereotype for relationship definitions (RelDef) is frequently left out of
the UML.
Menu Bar
The Schema Editor menu bar appears across the top of the Schema Editor application window.
Depending on your personalized menu configuration, you may not have access to
specific menus or commands. For more information about user interface configurations, see
Personalized Menus (on page 64).
The File menu provides standard file-based commands, such as New, Open, and Save.
The Edit menu allows you to undo and redo recent commands, edit and delete selected objects,
and locate objects in the Schema Editor. You can use the Cut, Copy, Paste/Create
Relationships, and Paste/Copy and Edit commands to modify open files. You can use the
Transaction Log command to start and stop transaction logging and view processed
transactions.
The View menu allows you to view the meta schema, schema, tool map schemas, and data files
in a variety of ways. You can also display the Editor views, which allow you to modify the
schema, tool map schemas, and data files, from the View dialog boxes displayed by commands
on the View menu.
The Tools menu provides access to various data-specific, non-viewing commands. For
example, you can validate files and set various viewing options using commands on the Tools
menu.
The Window menu provides access to standard window manipulation commands, such as
Cascade, Tile Horizontally, and Tile Vertically.
The Workflows menu allows you to open different workflows windows and dialog boxes to help
you work in the Schema Editor more efficiently.
The Help menu provides access to the Schema Editor online Help, the printable user's guide for
the Schema Editor, and information about the Schema Editor application.
Toolbars
Schema Editor toolbars provide easy access to the most commonly used commands. You can
move the toolbars around in the Schema Editor window and dock them wherever you want. For
descriptions of the commands on the Schema Editor toolbars, see Schema Editor Toolbars (on
page 53).
Workflows
When you open the Schema Editor, a dialog box or window containing the most common
workflows typically appears by default in the Schema Editor application window. This dialog box
or window provides quick access to many of the same commands that appear on the Schema
Editor menu bar.
You can use the following workflows in the Schema Editor:
Standard Workflows (see "Standard Workflows Window" on page 50)
Overall Workflows (see "Other Workflows Dialog Boxes" on page 60)
Basic Workflows (see "Other Workflows Dialog Boxes" on page 60)
The Workflows dialog box or window that you see when you open the Schema Editor
depends on your personalized menu configuration and what Start menu link you used to open
the Schema Editor.
View Windows
In the Schema Editor, the view windows allow you to view the meta schema, schema, tool map
schemas, and data files in a variety of different way. For example, you can see data in the
Schema Editor in tree views, table views, properties tables, UML views, and so on. For more
information about the various view windows, see example view topics for the meta schema,
schema, tool map schemas, and data files.
Shortcut Menus
When you right-click any object in any of the view windows, the software displays a shortcut
menu. This menu displays context-sensitive commands for the selected object. These
commands also appear on the Actions menu when an object is selected.
You can use shortcut menus to do everything from editing and creating objects and relationships
in the schema, tool map schemas, and data files to changing UML views.
2 - Vertical Tabs
Vertical tabs in the Standard Workflows window allow you to access different types of data in the
Schema Editor.
Active Tab
The Active tab allows you to select a startup file and view related files. You can also open tool
schema files, connect to SmartPlant Foundation for mapping, and synchronize tool map
schemas and tool metadata for tools with metadata adapters. You can also change the active
schema and open tool schemas from the Active tab.
Schema Tab
The Schema tab allows you to search the active schema for specific objects or browse the
schema in the tree view. When you select an object in the tree view, information for that object is
displayed on the active tab on the right side of the window.
Tool Schema Tab
The Tool Schema tab allows you to search the active tool schema for specific objects or browse
the schema in the tree view. When you select an object in the tree view, information for that
object is displayed on the active tab on the right side of the window.
Mapping Tab
The Mapping tab allows you to view loaded tool map schemas, expand them, and select tool
map schema objects for which you want to define mapping.
3 - Horizontal Tabs
Horizontal tabs across the top of the Standard Workflows window provide easy access to
different views of schema, tool schema, and mapping. To change the view, click a tab. The
context of the tabs change depending on your selections on the vertical tabs on the left of the
Standard Workflows window. You can add your own custom views to the list of horizontal tabs
by right-clicking one of the tabs and clicking Update MultiTab Options on the shortcut menu.
4 - Command Buttons
Command button on the Schema Editor vertical tabs allow you to identify commands easily with
icons. The following standard command buttons are available on some of the tabs in the
Standard Workflows window.
5 - Status Bar
The Schema Editor status bar allows you to view active files and settings and modify those
settings.
- Connected
- Offline. This icon appears when you open the tool map
schema directly from the file system.
F Specifies the name of the active tool map schema.
Double-click the file name to open another tool map schema.
See Also
Schema Editor - Standard Overview (on page 56)
Schema Editor Toolbars (on page 53)
Standard Toolbar
Open Session File - Click this to open a Schema Editor session file. Session files allow you
to save registered tool information, file configuration information, tool map schema information
for loaded map files, and displayed windows and dialog boxes that you want to restore when
you reopen the Schema Editor.
Save Session File - Click this to save the active Schema Editor session file.
Cut - Click this to remove the selected text or object from the Schema Editor. You can insert
the object at a selected location using Paste .
Copy - Click this to copy the selected object or text in the Schema Editor.
Paste - Click this to insert the copied text or object into the selected dialog box, tree view, or
other Schema Editor option or view.
Undo - Click this to cancel the last action you performed in the Schema Editor. If there are
multiple actions that can be canceled, click beside the Undo button and select the action that
you want to undo in the list.
Redo - Click this to repeat the last action you canceled in the Schema Editor. If there are
multiple actions that can be repeated, click beside the Redo button and select the action that
you want to redo in the list.
Find - Click this to search for objects in the Schema Editor. For more information about
searching in the Schema Editor, see Finding Objects in the Schema Editor (on page 121) and
Find Objects Using Search Criteria (on page 121).
Edit - Click this to modify the selected object in the Schema Editor tree view.
Schema Toolbar
Open Schema File - Click this to open a schema file in the Schema Editor.
Save Schema File - Click this to save the active schema file.
Set Active Configurations - Click this to set the active configuration for editing in the
Schema Editor. The active configuration defines the version of the schema to which you want
your changes to apply and where you want to store your schema extensions. Although the
command is available in the 2007 Schema Editor, it is typically used in 2008 and greater
versions of the Schema Editor for managing schema changes for integration.
View Active Schema - Click this to display the active schema file in the view you select.
The active schema is the one that you are editing and searching. Although you can see multiple
schemas at once, you can only edit one at a time.
Create Property Definition - Click this to create a new property definition in the schema.
Depending on your startup options, your changes may be saved to an extensions file.
Create Enumerated List - Click this to create a new enumerated list definition in the
schema. Depending on your startup options, your changes may be saved to an extensions file.
Compare/Display Results - Click this to compare the active schema file to another
schema file that you select. For more information about comparing schema files, see
Comparison (on page 487). Comparison results are displayed in a text editor.
Validate/Display Results - Click this to validate the active schema file and display
validation results. When you validate a schema file, the Schema Editor checks the file against
the meta schema and a set of semantic rules. Validation results are displayed in a text editor.
Open Tool Schema File - Click this to open a tool schema file.
Save Tool Schema File - Click this to save the active tool schema file.
Another Tool Schema File - Click this to open another tool schema file.
Set Active Tool Schema File - Click this to set the active tool schema file when multiple
tool schema files are open in the Schema Editor. The active tool map schema is the file that you
are editing and searching. Although you can see multiple tool map schemas at once, you can
only edit one at a time.
View Tool Schema (Active) - Click this to view the active tool schema file in the view you
select.
Create Map Property Definition - Click this to create a tool map property definition in the
active tool map schema file.
Create Map Enumerated List - Click this to create a tool map enumerated list definition in
the active tool map schema file.
Compare/Display Results - Click this to compare the active tool map schema with another
tool map schema file. Comparison results are displayed in a text editor.
Validate/Display Results - Click this to validate the active tool map schema. When you
validate a schema file, the Schema Editor checks the file against the SmartPlant schema and a
set of semantic rules. Validation results are displayed in a text editor.
Mapping Toolbar
Edit Engineering Tool Options - Click this to select an authoring tool, load the map
schema, and connect to the tool's metadata adapter. Selecting an authoring tool allows you to
synchronize the tool map schema and the tool metadata and define mapping for that tool in the
Schema Editor.
View Map Environment - Click this to display the Schema Editor Map Environment. The
Map Environment allows you to view loaded tool schemas and meta data adapters and define
mapping between the tool schemas and the SmartPlant schema.
Compare (Active Tool Schema) with Schema (Publish) - Click this to compare the active
tool map schema with the SmartPlant schema to determine which map properties, map
enumerated lists, and map unit of measure lists have not been mapped or flagged as not to be
mapped for publish. For more information about comparing the active tool schema with the
SmartPlant schema, see Comparing Tool Map Schema with the SmartPlant Schema (on page
285).
Compare (Active Tool Schema) with Schema (Retrieve) - Click this to compare the
active tool map schema with the SmartPlant schema to determine which map properties, map
enumerated lists, and map unit of measure lists have not been mapped or flagged as not to be
mapped for retrieve.
Synchronize Another Tool Map Schema with Tool Metadata (on page 57)
Search for Schema Objects (on page 58)
Search for Tool Schema Objects (on page 59)
Define Mapping (on page 59)
Different startup files open differently in the Schema Editor. For example, a
configuration file (CFG) can open multiple schemas and tool schemas and sets the
active files. Opening a session file, on the other hand, opens schemas and tool
schemas but also maintains the open dialog boxes and connections to SmartPlant
Foundation that were active when the user saved the session file.
The options on the Active tab change depending on the type of startup file you select to
open.
Open a Schema
1. On the Active tab, click Open Schema File beside the SmartPlant schema file box.
2. Browse to the schema that you want to open, and click Open.
Connecting to the metadata adapter and generating a comparison of the tool metadata
and the tool map schema can be a time consuming task, depending on your computer
memory and processor speed.
When you click Finish, the Schema Editor generates tool schema objects from the tool
metadata in the tool database and compares them to the tool map schema file.
If no changes have been made to the authoring tool metadata or the tool map schema
since you installed the software, there may no differences to synchronize.
Once you are familiar with synchronization and the default actions for the authoring tool
you are working with, you may want to select the Automatically synchronize schemas
check box before you click Finish to avoid reviewing synchronization results every time
you load a tool map schema and tool metadata.
You can click Save to Excel to save the synchronization results to a Microsoft Excel
spreadsheet.
5. In the Synchronize dialog box, select the appropriate action in the <Tool> Database or
<Tool Map Schema Path> column in the appropriate row for the change to update
inconsistencies between the tool metadata and tool map schema. Default actions appear in
blue in the appropriate column and row for each difference.
Some applications do not support both possible synchronization actions that
appear in the Synchronization dialog box. For example, SmartPlant P&ID does not support
deleting existing properties or enumerated lists. If properties exist in the SmartPlant P&ID
tool metadata that are not in the tool map schema, then the missing properties must be
added to the tool map schema. They cannot be deleted from the tool metadata database. If
you select a synchronization action that is not supported by the selected authoring tool, the
Schema Editor displays a message box to let you know that the action is not supported.
6. Click OK to synchronize the tool map schema and tool metadata.
After you synchronize the last tool map schema, the Map Environment appears.
2. Under Match object names and descriptions, type text you want to include and exclude
from your search.
3. Click Find to search for objects matching your criteria in the active file.
Search results appear in a tree view under the search criteria. Nodes are organized by the
type of results, such as ClassDef and InterfaceDef.
4. Select an object in the tree view to view more information about that object on the tabs in
the right pane. To switch between tabs, click the tab name at the top of the Standard
Workflows window.
Define Mapping
1. On the Mapping tab, expand the Tool node, and then expand the node for the appropriate
authoring tool.
2. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
3. Expand the node for the type of map schema object that you want to create or modify.
4. Use the horizontal tabs across the top of the Standard Workflows window to modify
mapping.
For more information about defining mapping in the Schema Editor, see Work Processes for
Mapping for Tools with Metadata Adapters (on page 309).
Basic Workflows - Provides access to functionality that basic users of the Schema Editor
need, including opening schemas and a tool map schema. After you open a file or files in the
Schema Editor, you can click the Actions button for the file type you opened to access the
basic commands that users need to interact with the file. For example, if you click Actions
under Schema, you can define the PBS hierarchy in the schema and edit schema objects
and tool metadata.
Overall Workflows - Provides most of the commands available on the Schema Editor's
menus in a workflow format. The Workflows dialog box provides tabs that allow you to
isolate the type of functionality that you need. For example, all the commands for interacting
with the schema appear on the Schema tab. The Overall Workflows dialog box is accessible
when you open the Schema Editor from the Schema Editor - Developer link on the Start
menu.
SPF Workflows - Provides access to functionality that a user needs to edit the SmartPlant
Foundation schema in a non-integrated environment. You can also view the object contents
of a configuration and edit those contents. Once you have made your changes in Schema
Editor, you can validate the schema, then save your configuration and modified files.
The tabs in the Workflows dialog box may change depending on your personalized menu
configuration.
When you use one of these workflows, you can use a series of Open buttons to open different
types of files, such as schema files, tool map schema files, and data files. These Open buttons
appear above the file type that you can open using that button. For example, Open buttons
appear above the Schema File, Tool Schema File, and Data File buttons to allow you to open
a schema file, tool map schema file, and data file from the Overall Workflows dialog box:
After you open a schema file, other buttons in the Overall Workflows dialog box become
available to you. For example, when you open a schema file, you can then compare it with
another schema or open a tool map schema file or data file.
After you open a particular file type, the button for that type of data turns white. For example, if
you open a schema, the Schema File button has a white background to indicate that you can
interact with the schema file that you opened using the Workflows dialog box.
Some types of data are always available; therefore, the buttons that represent those data types
always have light blue backgrounds. For example, when you open the Schema Editor, the meta
schema and integration programming reference documentation are always available, which
means that the Meta Schema button is always white and available.
Clicking the View button beside a button, such as Meta Schema or Schema File, displays the
View dialog box for that type of data.
You can click buttons with white backgrounds to display a list of commands that are available for
that type of data. These same commands are available on a submenu of the Tools menu. For
example, if you click the Schema File button when a schema file is open, the software displays
the following shortcut menu:
These commands are also available on the Tools > Schema (Active) submenu.
You can display or hide the Workflows dialog boxes using the View > Workflows
command.
Personalized Menus
Personalized menus allow you to define the menu commands, startup options, find options, and
view options that you use most in the Schema Editor. Personalized menus simplify the Schema
Editor user interface so that you can access the commands that you need more quickly. You
can also use personalized menus to define which Workflows dialog box or window that you
want to see when you open the Schema Editor, which file configuration that you want to work
with, what the default find and view options are, which edge definitions you see when you view
files in the Schema Editor, and so on.
For example, if you only use the Schema Editor for mapping between an authoring tool and the
SmartPlant schema, you can hide other commands and functionality that you do not use. You
can save your preferences as a personalized menu configuration file.
Personalized menu configuration files are also used to define the default Schema Editor roles
available on the Start menu. For more information, see Schema Editor Roles (on page 65).
If more than one person will be using the same personalized menu configuration file on a
computer, you can set a user environment variable to store the configuration file. Users can
make additional modifications to the personalized menu configuration file without affecting other
users.
See Also
Schema Editor User Interface (on page 49)
Create a Personalized Menu Configuration (on page 65)
Define the Storage Location for Your Personalized Menu Configurations (on page 68)
Modify an Existing Personalized Menu Configuration (on page 69)
Open a Personalized Menu Configuration File (on page 68)
Schema Editor Roles (on page 65)
2. If you want to display a Workflows dialog box when you open the Schema Editor, select the
Display workflow form check box, and then select the name of the dialog box in the list
The options under Schema Editor Open only apply to personalized menu files that are
opened using the command line when the Schema Editor is opened. You can add a
personalized menu file to your Schema Editor shortcut by right-clicking the shortcut in
Windows Explorer and adding %TEFUser%\FileName.gui or the path to the
personalized menu file after the path to the Schema Editor executable. For example,
"C:\Program Files\Common Files\Intergraph\Schema Component\SchemaEditor.exe"
%TEFUser%\MyMenus.gui or "C:\Program Files\Common Files\Intergraph\Schema
Component\SchemaEditor.exe" C:\MyFiles\MyMenus.gui.
The %TEFUser% option is only required if you use an environment variable to define
the location of stored personalized menus. For more information, see Define the
Storage Location for Your Personalized Menu Configurations (on page 68).
If you selected Overall Workflows in the Display workflow form list, the tabs that are
available in the Workflows dialog box in the Schema Editor change depending on the
menu commands that you select on the View menu. For example, if you do not include
any of the tool map schema commands on the View menu, the Tool Schema tab does
not appear in the Workflows dialog box.
3. If you want to work with a particular file configuration, select the Open file configuration
check box, and then click to browse to the file configuration.
4. If you want to change the type of data that you can view in the Schema Editor, select View
data for, and then select the type of data in the list.
5. Under Select menus and commands to show, select the check box beside the names of
the menus and menu commands that you want to use in the Schema Editor.
You can click + beside a menu or submenu node in the tree to view the commands for
that menu or submenu.
Menus and menu commands that are not selected will still appear in the Schema Editor,
but they will be unavailable to you.
6. Click OK to save your changes to the menu and startup configuration.
7. To define the default find and view options for your personalized menu configuration, click
File > Personalized Menu > Edit Find/View.
8. On the View tab, select the type of view for which you want to define options.
The other tabs in the dialog box change depending on the type of view you select. For
example, if you select a Tree view, the Tree Options tab is available.
9. Define the view options that you want to use by default.
Set View Options (on page 119)
10. On the Find tab, define the default find options that you want to use.
For example, if you want to search for particular types of objects by default, click Only
classes, and then click to select the classes that you want to search for.
11. Click OK to save the find and view options you defined.
12. To save your settings as a personalized menu configuration, click File > Personalized
Menu > Save As Personalized Menu.
See Also
Define the Storage Location for Your Personalized Menu Configurations (on page 68)
Modify an Existing Personalized Menu Configuration (on page 69)
Open a Personalized Menu Configuration File (on page 68)
The display of the Workflows dialog box or window, your options for viewing files, your
options for finding information, and the menu commands that are available to you may
change when you open a personalized menu configuration file.
By default, the delivered personalized menu configuration files that make up the default
Schema Editor roles are delivered to the ..\Program Files\Common Files\Intergraph\Schema
Component folder. You can change the default location of these files for each Schema
Editor user on a specific computer. For more information, see Define the Storage Location
for Your Personalized Menu Configurations (on page 68).
See Also
Create a Personalized Menu Configuration (on page 65)
Define the Storage Location for Your Personalized Menu Configurations (on page 68)
Modify an Existing Personalized Menu Configuration (on page 69)
Personalized Menus (on page 64)
Schema Editor Roles (on page 65)
7. Click OK.
If you are the only user who uses the Schema Editor on your computer and you want to
change the default storage location for personalized menu files, double-click TEFUser under
System variables, and change the default path.
See Also
Create a Personalized Menu Configuration (on page 65)
Modify an Existing Personalized Menu Configuration (on page 69)
Open a Personalized Menu Configuration File (on page 68)
Personalized Menus (on page 64)
Schema Editor Roles (on page 65)
Layouts
By default, Schema Editor opens with its user interface docked in a tabular layout (Schema
Editor - Standard) or with the Overall Workflows dialog box open (Schema Editor - Developer).
The new Layout menu allows you to build your own Schema Editor user interface by opening
multiple intelligent controls that update automatically when you select an object on one of the
forms.
Create a Layout
1. To define your window layouts, click Layout from the menu bar.
To view the Layout menu in Schema Editor - Standard, click File > Personalized Menu
> Edit Menu/Startup, then select the check box beside Layout.
2. Select the windows that you want to use in Schema Editor. For example, you can select
Schema, Tool Schema, Properties, Grid, and Table as your default layout.
3. Click an object in the Schema window or Tool Schema window. The information in the
other windows is updated.
Selecting objects in windows other than Schema or Tool Schema only updates the
information in that window. For example, selecting IBlockBrowser from the Properties
window only updates the Properties window.
Modifications made in any window updates the information in all windows. For example,
changing the Description in the Grid window updates the information in all other
windows.
4. To re-use the layout in Schema Editor, click File > Session File > SaveAs Session File.
When you open the session file, only the position and starting data state of the layout is
remembered. The last object open is not remembered.
See Also
Personalized Menus (on page 64)
In the Properties windows, the text “Schema Object” displays with a dark background. Below it
are a set of property names (“Display Name” through “Analysis Comment”). “Schema Object” is
the DisplayName for ISchemaObj, “Display Name” is the DisplayName for DisplayName,
“Analysis Comment” is the DisplayName for AnalysisComment and so on.
For this display (“Schema Object” through “Analysis Comment”), ISchemaObj display as
schema. Note that the display of ISchemaObj as schema is different than the display of
ISchemaObj as data (contrast the property names in the tree control (AnalysisComment through
SchemaVer) with the corresponding names in the Properties control (for example, Analyis
Comment).
When defining rules on how to display object names, you have the flexibility of defining whether
the rule applies to display of objects as data objects or display as schema objects.
The Schema Editor is normally used to view and edit schema and map (tool) schema. For both
the schema and the map schema, the class definitions for the displayed objects are part of the
meta-schema and any name display rules that are defined must be done as meta-schema
extensions to apply. Occasionally, the Schema Editor is used to view data files. For this case of
viewing data files, the name display rules need to be defined as part of the schema rather than
the meta-schema because the class definitions for the data objects are part of the schema not
the metaschema.
The schema class definition PIDPipingComponent is an instance of ClassDef, which is a
meta-schema class definition. Likewise, IPipingComponent is an instance of InterfaceDef (a
meta-schema class definition) and NominalDiameter is an instance of PropertyDef (a
meta-schema class definition). Therefore, to define a name display rule that impacts how the
Schema Editor presents PIDPipingComponent, that rule must be added as a meta-schema
extension to apply.
Valve V-100 is an instance of PIDPipingComponent (a schema class definition). Therefore, to
define a name display rule that impacts how V-100 displays using the Schema Editor, that rule
must be part of the schema (not a meta-schema extension).
Alternatively, the Rules and Constraints entry from the class list selection form can be used to
view the name display rules.
In the New Name Display Rule dialog box, the Scope for Rule window determines the scope
of applicability from the rule. In this particular example, the scope has been defined to be for
class definition ClassDef when displayed as data.
The name display rule for the specified scope is defined in the Rule area. The options at the top
of this area indicate whether the first defined property value is to be used or whether the
property values are to be combined to form the “name”.
The list of properties to be included in the “name” displays in the grid control. If only one
property value is to be included in the “name”, then the first of these that apply for a particular
object will be displayed as the “name”. For example, if there exists a MapClassToClass
relationship for the ClassDef object (at least one tool schema has been opened and loaded) and
Name is defined for that map class, then that value will be used as the “name”. If no
MapClassToClass relationship exists or the map class does not have a Name value, then the
rule identifies that the Name for the class definition object. Finally, if Name is not be defined for
the class definition, then the UID is used.
Select Move Up and Move Down to reorder the properties in the rule.
Click Remove to remove a property from the rule.
Click Always Include to toggle between always including the property in the “name” versus
only including the property if it has a non-null value. This Boolean value only applies if the
rule says that the property values are to be combined to form the displayed “name”. Note
that the Always Include text will change to Include If Defined if the selected property has a
True value for this flag.
Click Add to add a property to the rule. The Select Property to Add to Rule dialog box
displays. Expanding the tree for this interface definition shows the properties for that role (as
well as the edges for that role).
3. Select the Editor check box on the View Schema dialog box.
4. Click the Editor tab and scroll down to the Environment tree.
6. Use the Extend Meta Schema dialog box to create and edit name display rules. The rules
control the "name" used by the Schema Editor to display meta-schema and schema objects.
7. If a meta-schema extensions file is opened and the session saved, the session file that is
created will contain the meta-schema extensions file. The same is true if a configuration
file is created. If this session file is opened, the meta-schema extensions file automatically
load.
8. Click New Rule to create a new name display rule (instance of NameDisplayRule). The
Edit dialog box displays.
9. Define the new name display rule. Existing name display rules can be edited by first
selecting the name display rule from the combo box drop-down list and then selecting the
Edit Rule button.
10. When the extensions to the meta-schema have been completed, the schema file needs to
be converted to a meta-schema file. To convert the schema file to a meta-schema file, open
the schema file in Notepad or another text editor.
11. Change the Scope entry on the first line from “Schema” to “MetaSchema”. If the need
arises to further extend the meta-schema, then this same process can be done in reverse
and the Scope changed back to “Schema”.
SECTION 5
Make changes that apply to both 2007 and 2008 schemas (for data exchanged between the
2007 tool and the 2008 tool).
And so on for multiple versions of the schema and authoring tools in the future.
However, if you publish new properties that are only available in a newer version of the
SmartPlant schema to an older schema version supported by an older tool, the new properties
that you add in the newer version of the schema will not be supported.
CMF files have the following features:
Every configuration in the CMF file is available for viewing. For more information, see
Viewable Configurations.
Every configuration is available for editing. For more information, see Editable
Configurations.
Multiple configurations can be worked on simultaneously. For more information, see Multiple
Editable Configurations.
Single active configuration can be viewed but new objects that are created go into multiple
configurations. For more information, see Single Active Configuration with New Objects in
Multiple Configurations.
Pseudo files allow logical separation of objects within configurations and support a variety of
options (for example, controlling whether the objects are loaded into memory). For more
information, see Pseudo Files.
A variety of commands are available specifically for editing individual or multiple
configurations. For more information, see Special Configuration Commands.
CMF files can be opened in the Schema Editor, but their most common use is managing the
schema configuration for integration in the SmartPlant Foundation Desktop Client. When you
manage your schema configurations this way, the following work process is required:
Check out the SmartPlant schema CMF file from the SmartPlant Foundation Desktop Client.
Right-click the new revision of the CMF file in SmartPlant Foundation, and click Launch
Schema Editor. This provides the Schema Editor with the appropriate plant and SmartPlant
Foundation site for connection.
Select the schema version or versions in which you want to make modifications in the
Active Configurations dialog box. For example, to modify the 2008 schema, select the
2008 configuration for new objects.
By default, both the 2007 and 2008 configurations are checked to allow forwards and
backwards compatibility between schema versions when creating new objects or modifying
existing objects.
See Also
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
Viewable Configurations
You can view all of the available (non-obsolete) configurations. Any available configuration
within the CMF file can be made the active configuration. You can view and navigate the
objects, similar to a tool such as SourceSafe or Team Foundation Server.
Editable Configurations
You can view the object contents of a configuration and edit those contents. When you make a
configuration active, you can view and edit all of the objects in that configuration. You can
modify all non-obsolete configurations in the CMF file as desired.
Pseudo Files
Pseudo files allow for the objects within the configurations to be logically organized into files.
Pseudo file functionality is also useful for defining behavioral characteristics for those objects.
The following set of characteristics can be defined against a pseudo file and apply to all the
objects within that pseudo file:
Characteristics Features
Pseudo-file properties support a variety of workflows. For example, the properties that
govern output suppression allow control over what is viewable versus what is included in a
generated (SaveAs) file in a development environment.
The pseudo-file properties support workflows for which inadvertent additions or
modifications of the existing objects within the pseudo-file can be prevented.
The SuppressLoad property allows for completely hiding those objects even from viewing.
The IsObsolete and the control modification properties, such as ReadOnly, ReadOnlyFile,
and WriteDisable, are used to control whether objects can be added to the pseudo-file
(IsObsolete) or whether existing objects can be modified or deleted (ReadOnly,
ReadOnlyFile and WriteDisable).
See Also
Create a New Pseudo File in the Schema Editor (on page 150)
Merge a Previously Generated Schema into a Pseudo File (on page 152)
Convert an Existing Pseudo File into a Physical Pseudo File (on page 154)
Some of these commands are used to set properties for the configurations and are a
fundamental part of those workflows that require the modification of one of these property
values.
The Detect Duplicate UIDs and Merge Identical Objects commands are used to address
unintentional differences that are between objects in different configurations.
The Compare Configurations and Compare Configurations and Selectively Update
Active Configuration commands are useful in comparing two configurations and in fixing
the active configuration based on the compared-with configuration.
The Merge Configuration into Configurations command compares and automatically
adds (no selectivity) objects from the specified configuration into the active configurations.
The Move Between Pseudo Files command handles cases where objects are in the
incorrect pseudo-file and need to be moved to the correct pseudo-file.
The Merge File into Active Configuration command is useful for importing objects defined
within an XML file into active configurations.
5. In the Open CMF File for Comparison dialog box, select the other CMF file (i.e., the one
that is not the master) from which to update.
6. In the Set Comparison Configuration dialog box, select the configuration in the other CMF
file that should be used.
Be careful to pick the same configuration as the active configuration that was
used for the master CMF file.
7. Select OK to begin the comparison
After the comparison is performed, the differences are displayed in the Selectively Update
dialog box. In the tree view, the differences are grouped as New Objects, Modified Objects,
and Deleted Objects.
8. Check the object groups to update. By default, none of the nodes are checked and simply
selecting OK before checking any of the boxes will result in no updates
9. Expand the nodes to view more information about the objects that were added, modified and
deleted.
Checking a node in the tree will check that parent node and all children nodes. For
example, checking Modified Objects checks all the nodes for all the modified objects.
Likewise, unchecking a node will uncheck all the children nodes.
To view information about an object in the list, click the node for that object. For a new or
deleted object, the edit dialog box for that object appears. For a modified object, the
View/Compare Objects dialog box displays the differences in the object.
In almost all cases, the New Objects node should be checked, indicating that all objects
and relationships created within the other CMF file should be copied to the master CMF
file
For Modified Objects, the user should go through each object individually and click it to
see the differences (form above). The user should then make a decision for that object
whether the differences on the right should replace the object on the left. If the
decision is yes, then that node should be checked. If the decision is no, then that node
should be left unchecked. Unfortunately, there is no support for taking some of the
changes.
In general, none of the Deleted Objects should be checked. However, the user may
want to go through the nodes for the individual deleted objects and decide that some of
them actually should be deleted.
10. When all changes are identified, click OK on the Selective Update dialog box to update the
active configuration in the master CMF file with the selected additions and changes.
11. When complete, exit the Schema Editor and save the changes to the master CMF file.
If more than one configuration is to be updated, the procedure described above should be
repeated for the other configurations that are to be updated.
Session Files
Session files allow you to save registered tool information, file configuration information, tool
map schema information for loaded map files, and displayed windows and dialog boxes that you
want to restore when you reopen the Schema Editor. When you exit the Schema Editor, the
software prompts you to save your session file so that you can return to your work easily. You
can create, modify, and open session files in the Schema Editor using the File > Session Files
commands. When you edit the CMF file from SmartPlant Foundation in version 2008 and above,
the Schema Editor automatically saves a session file and uses it to determine the state of the
Schema Editor when you launch it again from the Desktop Client.
When you create a session file manually in the Schema Editor or the Desktop Client creates a
session file for you, the session file is saved in your My Documents folder on your computer.
The file extension for session files is .SES.
See Also
Open a Session File (on page 92)
Create a Session File (on page 93)
See Also
Session Files (on page 92)
File Configurations
In the Schema Editor, you can use file configurations to save time by grouping the files that you
want to open, the order in which you want to open them, dependencies among schema files,
and whether schema files are editable. File configurations also determine which file is the active
file in the Schema Editor when you open multiple files of the same type.
File configurations are especially important for extending the schema for stand-alone SmartPlant
Foundation installations and for mapping for tools without metadata adapters. When you need to
make modifications to the SmartPlant schema without managing the schema in the SmartPlant
Foundation Desktop Client, we recommend that you save your changes in a schema extension
file. After you create a schema extension file, you can create a file configuration that
automatically opens the SmartPlant schema as read-only and then opens your schema
extensions file so that you can make the required changes.
You can save file configurations and open saved configuration files with the File > File
Configurations commands.
See Also
Set the Active Schema File (on page 98)
Set the Active Tool Schema File (on page 98)
Create a File Configuration (on page 94)
Modify a File Configuration (on page 94)
Open a File Configuration (on page 94)
Opening Files (on page 96)
An X in a numbered column in the row for the schema file indicates a dependency for
that schema file.
The numbered columns across the top of the table correspond to the numbered rows
along the left side of the table.
You can also click the Another Tool Schema button in the Workflows dialog box to
set the active schema.
5. Click X in the title bar of the Edit Configuration window to close the window and save your
changes.
See Also
Set the Active Schema File (on page 98)
Set the Active Tool Schema File (on page 98)
Create a File Configuration (on page 94)
Open a File Configuration (on page 94)
4. In the Set Container Dependencies dialog box, click the schemas on which the active
schema depends, and click OK.
After you define dependencies for a schema file, you can save the open files and
dependencies to a file configuration so that you do not have to open the schema files and
set dependencies every time you make modifications. To save the dependencies as part of
a file configuration, click File > File Configuration > Save As File Configuration.
You can define which files in the file configuration are editable after you save the file
configuration. For more information, see Modify a File Configuration (on page 94).
See Also
Create a Schema Extension File (on page 183)
Extending the SmartPlant Schema (on page 143)
Work Process for Extending the SmartPlant Schema for Integration (on page 147)
Create a File Configuration (on page 94)
Modify a File Configuration (on page 94)
Open a File Configuration (on page 94)
Opening Files
In the SmartPlant Schema Editor, you can also open the schemas, tool map schemas, and data
files you want to view and edit. Generally, customers should use CMF files or CFGs to avoid
opening files manually and make schema editing easier.
If you do decide to open files manually, you must open a schema file before you can start
viewing schemas, tool map schemas, or data files. You can open a schema file directly using
the commands on the File menu or on the buttons on the Workflows dialog box.
File Configurations
To open the files you need to work on in the Schema Editor, you can also create a file
configuration. When you open a file configuration, the Schema Editor automatically opens the
files that you selected. For more information about file configurations, see File Configurations
(on page 93).
Active Files
When you open multiple schema files or tool map schema files, the file that you see in various
views in the Schema Editor is called the active file. When you have multiple files open, you can
change which file you are viewing by using the Tools > Another Schema > Set Active
Schema File and Tools > Another Tool Schema > Set Active Tool Schema File commands.
These commands are only available when you have multiple schema files or multiple tool map
schema files open.
When you save a file configuration, the Schema Editor stores the active file as well.
See Also
Set the Active Schema File (on page 98)
Set the Active Tool Schema File (on page 98)
Open a Schema
Before you can begin viewing the schema, data files, or a tool map schema, you must open the
schema in the Schema Editor.
1. Click File > Open > Schema File.
Typically, you should open and edit the SmartPlant schema using the delivered
configuration file (EFSchema.cfg).
The SmartPlant schema configuration file references the SmartPlant schema file
(read-only), other schema files (read-only), and your schema extensions file (editable).
The delivered schema extensions file is named Extensions1.xml, and when you open
EFSchema.cfg, your changes are saved in Extensions1.xml by default. However, you
can specify additional extensions files to store your schema modifications. For more
information, see Modify a File Configuration (on page 94).
The SmartPlant schema configuration file is delivered with the SmartPlant Server and
Client components. By default, it is installed in the following location: ..\Program
Files\Common Files\Intergraph\EFSchema\7.x. However, if you use different SmartPlant
schemas for each SmartPlant Foundation site, your schema file may be in a different
location.
If multiple sites share the same SmartPlant schema file, then any changes that you
make to the shared schema file will affect every site. Therefore, Intergraph strongly
recommends that you make a copy of the delivered SmartPlant schema folder for each
site. Store each customized folder within the site folder, for example,
<drive>:\SmartPlant Foundation 2007 Server
Files\Web_Sites\<site_name>\EFSchema\03.08. The folders containing the customized
schema files must be network shared with read-only access.
If you already have a schema open in the Schema Editor, you can click File > Open >
Another Schema File to open another schema.
2. Browse to the directory where the schema file is located.
3. Select the schema file that you want to open.
4. Click Open.
You can open XML schema files (.XML) and XML DOM schema files (.DOM) in the
Schema Editor.
See Also
Set the Active Schema File (on page 98)
Set the Active Tool Schema File (on page 98)
In Advanced mode, click Options to display the View tab. The Options dialog box has multiple
tabs that allow you to select a view, set options for views, set the scope for your view, and so
on.
You can switch between modes in the View dialog box by clicking the Advanced button to
switch to Advanced mode and the Simple button to switch to Simple mode.
View Navigation
After you select the view that you want, you can navigate in the view in different ways. In tree
views, you can click + beside a node to expand it. In table views, you can select an object in the
associated tree view to display data in the table. In UML views, you can drag and drop objects to
create new UML views and modify existing UML views.
See Also
Tree/Table View: An Example (on page 105)
For example, in the Schema Tree, you can trace the PIDDrawing class all the way to the
relationship definitions for the interfaces it realizes.
However, the schema tree is not a true hierarchy. The Implies relationships in the schema allow
you to navigate through the schema almost endlessly.
Bold text in the tree view represents relationship edges. Relationship edges define paths
that go from one point to another point in the data without traversing the entire tree. Blue
relationships are relationships across which only limited operations can be performed. For
example, adding or deleting relationships is not supported as shortcut menu commands across
blue relationship edges whereas they are supported across black relationships.
Blue edges either involve more than one relationship traversal or they involve traversal across
special relationships. A special relationship is actually not a relationship at all, but is instead
something that the software determines. For example, the Class Definition for an object is not a
relationship between the object and its class definition (ClassDef) but is instead something that
the software determines through other information.
To view a file in the standard tree view, do the following:
1. After you open schemas, tool schemas, or data files, click the type of file that you want to
view on the View menu. For example, to view the schema, click View > Schema (All).
2. Click Options on the View Schema dialog box.
3. On the View tab, click Tree.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. Click OK.
5. To traverse the relationships in the tree view, expand the nodes.
See Also
Navigating Files and Data in the Schema Editor (on page 101)
In the table view, bold text is used in class definitions and interface definitions to identify
required entries. Bold interfaces in the table view indicate that the interface is required for the
associated class. For example, in the previous example, bold text shows that IDocument is a
required interface for PFDDrawing.
Properties that appear in bold text in the table view are required for the associated interface. For
example, DocCategory, DocTitle, and DocType are required properties for the IDocument
interface, while DocSubtype is not required.
Bold property types in the table view indicate that the value for the property cannot be null. For
example, for the IObject interface, the UID property is required, and its string value cannot be
null.
Bold text in the tree view represents relationship edges. Relationship edges define paths that go
from one point to another point in the data without traversing the entire tree.
There are two types of tables that you can choose from: vertical and horizontal. The vertical
table displays row headers along the left side of the table and data in vertical columns.
The horizontal table displays column headers across the top of the table, with the data displayed
in horizontal rows.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
If you want to change how data is displayed in the table view, make changes on the
Table Options tab.
4. Click OK.
5. To traverse the relationships in the tree view, expand the nodes.
6. To see the predefined table view for an object, click the object in the tree view.
See Also
Navigating Files and Data in the Schema Editor (on page 101)
Relationship definitions include the objects on both ends of the relationship and the roles
specified for both ends of the relationship. For example, in the graphic a
ReferencedDocumentCollection relationship exists between IDocument and
IReferencedDocumentCollection. The first end of the relationship has a role of Referenced
Documents and a cardinality of zero-to-many, which means any number of objects can be
involved on this end of the relationship. On the second end of the relationship, the role is
Referenced by, and the cardinality is also zero to many.
Bold text in the tree view represents relationship edges. Relationship edges define paths
that go from one point to another point in the data without traversing the entire tree.
To view a file in the tree/UML view, do the following:
1. After you open schemas, tool schemas, or data files, click the type of file that you want to
view on the View menu. For example, to view the schema, click View > Schema (All).
2. Click Options on the View Schema dialog box.
3. On the View tab, click Tree/UML.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
If you want to change how data is displayed in the tree view, make changes on the Tree
Options tab on the Options dialog box.
If you want to change how data is displayed in the UML view, make changes on the
Viewable UML tab on the Options dialog box.
4. Click OK.
5. To view the UML for an object, click the object in the tree view.
6. To center the UML view on another object in the current view, click the object in the UML
view.
7. To go back to the last UML view, click Back on the toolbar.
8. If you browse back to a previous view, click Next to see the next UML view.
9. To select a particular UML view that you have recently viewed, click the name of the view
that you want to see in the view list.
10. To move through the view list, use the Up and Down buttons on the toolbar.
See Also
Navigating Files and Data in the Schema Editor (on page 101)
For example, dragging the INDXInstrument, ILoopMember, and IInstrument classes and
interfaces from the tree view to the UML view without displaying the default UML views for each
object results in the UML diagram shown in this graphic:
In the resulting UML view, you can see the realizes and implies relationships between the
selected objects and the relationship ends for each one.
You can also use the Tree/Editable UML view to select an existing UML view that you want to
display using the Packages tree. Packages are used to organize UML diagrams. Clicking a
UML diagram in the Packages tree or dragging and dropping the UML diagram from the
Packages tree to the UML view displays that UML diagram. You can also create your own UML
views, name them, and store them as part of a package.
After you create your own UML view by selecting the objects that you want to display in the UML
view or select a UML view from the Packages tree, you can customize the display even further
by doing one of the following:
Moving objects and labels
Changing the display color for objects
Removing objects, relationships, and labels
Changing the display of interfaces
Aligning objects
To move an object in the UML view, drag the object to a new location. You can move classes,
interfaces, and other objects in the UML view. As you move objects in the UML view, they
remain attached to each other by their relationships.
To use commands for modifying the UML display for a particular object, right-click the object in
the UML view, and then click the appropriate command on the shortcut menu. To align objects
in the UML view, right-click the background of the UML view, and then click Align on the
shortcut menu.
After you create a UML view, you can clear the view and start again. To create a new UML view,
right-click the background of the UML view, and then click New UML view definition on the
shortcut menu.
To view a file using the Tree/Editable view, do the following:
1. After you open schemas, tool schemas, or data files, click the type of file that you want to
view on the View menu. For example, to view the schema, click View > Schema (All).
2. Click Options on the View Schema dialog box.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
If you want to change how data is displayed in the tree view, make changes on the Tree
Options tab on the Options dialog box.
If you want to change how data is displayed in the UML view, make changes on the
Drag/Drop Options tab on the Options dialog box.
4. Click OK.
5. Navigate to an object in the tree view at the bottom of the Tree/Editable UML window.
6. Drag the object to the UML view.
7. In the Schema Editor message box, click No to create a customized UML view.
To display the default UML view for the selected object type, click Yes in the Schema
Editor dialog box.
8. Beside the Package box, click to select the existing package in which you want to store
the UML view.
If you want to create a new package to store your UML view, click Create to define the
new package.
9. Define a display name and other properties for the UML view on the Properties tab of the
New UML View Definition dialog box.
10. Click OK to save the UML view definition.
11. Move the object around in the UML view as needed.
12. Right-click the object to change the display of the object.
13. Add additional objects to the UML view by browsing in the tree view and dragging the
objects to the UML view.
You can view existing UML views by browsing to the view in the Packages tree and then
selecting the UML diagram that you want to see in the UML view.
See Also
Navigating Files and Data in the Schema Editor (on page 101)
Objects in the UML diagram can be repositioned by dragging them to the desired location. To
remove displayed objects from the UML diagram, right-click on the selected object and then
click Erase.
Do not click Delete as this will delete the object and not just erase it from the
diagram.
Additional objects can be added to the UML diagram by simply dragging the objects from the
Tree view and dropping them onto the diagram at the desired location. For example,
expanding the InstrumentLoopDrawing node in the Tree view and dragging
NonDrawingItemCollection onto the UML diagram results in the following display.
The INonDrawingItemCollection interface definition was added to the diagram in order to show
the NonDrawingItemCollection relationship definition. A line for the Implies relationship from
INonDrawingItemCollection to IObject was added to the diagram.
The automatic addition of Implies relationships can become annoying so the user may want to
turn this option off by right-clicking in a whitespace area of the UML diagram, and then selecting
Edit display options on the shortcut menu.
On the Update Options dialog box, remove the check from the Add Implies relationships
check box. Turning this option off means that subsequent interface definitions added to the UML
diagram will not trigger the addition of the Implies relationships for that interface definition.
However, any existing Implies relationships on the UML diagram will not be affected.
Changing the option on this dialog box only changes the option for this view. Click Tools
> Options to change it for subsequent Editable UML views.
When you open the Tree/MultiTab view, the tabs are blank. After you select an object in the tree
on the left side of the window, the tabs update with information on the selected object. Additional
views that apply to the selected object in the tree view are also added to the right side of the
default tabs when you select an object in the main tree view.
For example, if you select the Document class in the main tree view, the following occurs on
some of the tabs:
The Properties tab displays the properties for the Document object in a view that is similar
to SmartPlant Foundation.
The interfaces and properties for the Document class appear horizontally on the Table (hor)
tab.
The Editable UML tab displays the UML view for the selected object. You can add other
objects to the view by dragging them from the tree view and dropping them on this tab.
The Viewable UML tab displays the default UML view for the Document class. This is the
same UML view displayed in the Schema Tree/UML view.
The Edit Form tab allows you to edit properties for the object you select in the tree view.
To view a file in the tree/multi-tab view, do the following:
1. After you open schemas, tool schemas, or data files, click the type of file that you want to
view on the View menu. For example, to view the schema, click View > Schema (All).
2. Click Options on the View Schema dialog box.
3. On the View tab, click MultiTab.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. Click OK.
5. Select an object in the tree view to see details for the object on the tabs.
6. Move from tab to tab to see different views of the object.
See Also
Navigating Files and Data in the Schema Editor (on page 101)
View Options
In the Schema Editor, you can set options for the behavior and appearance of tree views, table
views, drag-and-drop views, and UML views in the Options dialog box.
See Also
Set View Options (on page 119)
3. On the Find tab, enter the criteria that you want to use in your search. The criteria that you
can search by are the properties of IObject.
4. If you want the search to be case sensitive, select the Case sensitive check box.
5. Click Options on the View Schema dialog box.
6. On the View tab, click the type of view in which you want the software to display your search
results.
Depending on the type of view you select, you can also define view options on the
Tree, Table, Viewable UML, and Editable UML tabs.
7. Click OK.
If you select specific class definitions for searching, the Schema Editor saves the
selected class definitions for your next search.
See Also
Finding Objects in the Schema Editor (on page 121)
Check the class lists on which to search on the Select Class List dialog box .
In the Select Class List form, the user can choose exactly which classes to search, as seen in
the following image.
Using astericks in front of and at the end of a search indicates that anything may precede or
follow these letters in the name and description searches.
Keyword Search
The Schema Editor supports keyword searching of the Name and Description property values
using a Web-like syntax.
2. Type the criteria on which to search or select an existing keyword search from the list.
Any keywords entered into this field are used to search the Name and Description property
values for all objects of the selected classes for the specified information set(s). Entering a
keyword into this field is the equivalent of entering the same text into the Name and Description
fields with the following differences:
Keyword searches check both the Name and Description property values.
Wildcard asterisks surrounding the keywords are not required and, in fact, should not be
included as they are treated exactly as any other character.
Multiple keywords can be entered whereas only one keyword could be specified using the
UID, Name or Description test fields.
The ALL, ANY, and NOT operators can be used to qualify the search to be performed.
Multiple words in sequence can be specified by enclosing those words inside quotation
marks.
Keyword searches are case insensitive.
Keyword searches check both the Name and Description property values for each object
whereas criteria specified using the UID, Name and Description text fields only searches the
specified property value.
When using the keyword search, it is recommended that you do not use wildcards, such as
asterisks. Any asterisks included in the keyword search criteria will be treated like any other
character. For example, specifying *Piping* as a keyword would only match an object that
explicitly contained *Piping* (including the asterisks) in its Name or Description property value.
You can do a search on multiple keywords. For example, type Piping Component and the
search matches objects containing both Piping and Component in their Name or Description
property values. By default a match on the keyword criteria will only apply if the Name or
Description property values contain all the specified keywords (the criteria uses the AND
operator). However, the user can change that behavior by using the ANY and NOT operators.
Keywords using the ANY operator are treated like criteria using the OR operator. For example,
any object that matches any of the keywords after ANY will be considered to satisfy the criteria.
Therefore, specifying a keyword criteria of Any Piping Component attempts to match objects
containing either Piping or Component in their Name or Description property values.
Keywords using the NOT operator in the criteria identify keywords that are not to be found in the
Name or Description property values. For example, a keyword criteria of Piping Not
Component attempts to match objects that contain Piping in their Name or Description values
but do not include Component in that property value.
The ALL operator is also a special keyword. Its use defines that an object must match all of
the specified keywords in the criteria. There is an implied ALL at the start of any keyword
criteria and, therefore, normally ALL is not specified. For example, the keyword criteria Piping
Component and All Piping Component are equivalent.
ALL, ANY, and NOT operators can all be specified as part of the keyword criteria. For
example, the keyword criteria Piping Any Valve Component Not Gate specifies that a
matching object must include the Piping keyword, must include either Valve or Component
and must not include Gate.
Since ALL, ANY, and NOT are special keywords, if the keyword criteria should include one of
these special keywords, they must be enclosed within quotation marks (“”). The keyword
search criteria “All” Piping attempts to match objects that contain both the All and Piping
keywords in their Name or Description property values.
If a search matching multiple words in sequence is desired, then those words should be
enclosed inside quotation marks (“”). For example, the keyword search “Piping Component”
only matches objects that contain Piping Component in their Name or Description property
values.
Keyword searches, unlike criteria specified using UID, Name, and Description, is case
insensitive. Therefore, while a Name criteria of *Piping* only matches an object with a Name
value that contains Piping with a capital P, a keyword criteria of Piping will match a Name or
Description value that contains a lowercase p (i.e., piping).
Many of the named queries come with a requirement for the user to specify a value for one or
more of the individual criteria within the named query. For example, when you query on
PropertyDef – Between two strings, the Enter Query Variable Values dialog box appears.
For this type of Named query, you must type the strings that bound the matching property
names information on which to query; for example, specifying that only property names between
CompanyName and ConstructionStatus are to be matched.
The ANY operator along with the specified equivalent comparator and value should be used to
query for the existence of a particular related object across a to-many relationship edge. For
example, to query for class definitions that realize both IPipingComponent and
IInlineComponent, the criteria in the image below should be specified.
If the query is to locate objects that are missing a relationship to a specific objec, use the ALL
operator in conjunction with a negative comparator. For example, to locate all class definitions
that don’t realize IObject, do the following:
1. Select IClassDef from the Interface query list.
2. Select the Name property across the Realized Interface Definitions in the Edge/Property
tree, and then click All(?).
3. Click <> in the Comparator group to indicate that all realized relationship definitions should
not be IObject.
4. Select IObject as the realized interface definition in the Property Value box.
If a view definition has been defined for the selected interface, then the set of view properties for
that view definition will be available from the first list view under Show objects where. Select
the comparator from the middle list view.
Enter a value in the text box to specify the value for the comparison. If the selected property is
enumerated or has other information available, then Browse is available and you can select
the appropriate value from the form that appears.
Since view properties can be defined across edges, the criteria specified on the Filter tab may
involve the traversal of relationships as part of the criteria. This is the only way, other than
using the constraint language on the Full tab, of specifying criteria that involves relationship
traversal.
Once you provide a value for the specified property and comparator, another set of options
appear that can be used to specify additional criteria. In addition, an intermediate operator list
appears that allows you to specify whether the criteria is to use the AND or OR operator.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
View SmartPlant Schema Documentation (on page 142)
Not all objects in the SmartPlant schema have descriptions defined for them.
You can use the drop-down list above the tree view to change the tree view contents. For
example, if you want to only view property definitions in the tree view, select Properties in the
list. If you want to see class definitions, interface definitions, relationship definitions, enumerated
list types, and UoM list types, select Base Classes in the list.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
SmartPlant Schema Documentation (on page 141)
Creation Rules
New objects of any type can be created. However, relationships between new objects and
existing objects must not violate the Revision rules described later in this document.
New relationships between existing objects can only be created if they do not violate any of the
Revision rules defined in this document.
Deletion Rules
With a few exceptions, existing schema objects cannot be deleted (because this could easily
break publish and/or retrieval software). The exceptions to this rule are objects that are not
exposed in the published data. This includes, but is not limited to, edge definitions, graph
definitions, view definitions, and UML view definitions.
Revision Rules
The rules for changing existing schema objects are described in the following subsections. If a
schema object type is not included in this section of the document, then any type of revision of
the object is allowed.
Class Definitions
For existing class definitions, the following rules apply:
UID and Name cannot be changed.
Description and DeleteShared can be changed.
Class definitions may realize additional "optional" interface definitions.
An "optional" interface definition cannot be changed to "required."
A "required" interface definition cannot be changed to "optional."
The component schema for the class definition cannot be changed.
The model definition for the class definition cannot be changed.
The class factory definition for the class definition cannot be changed.
New Sharing relationships can be created.
Existing Sharing relationships cannot be deleted.
Interface Definitions
Although the COM rules state that interfaces are immutable, the rules for existing interface
definitions in the SmartPlant schema are not so rigid:
UID and Name cannot be changed.
Description, SpecializationValue, and InterfaceIcon can be changed.
"Optional" property definitions can be added to an interface definition.
Existing property definitions exposed by the interface definition cannot be deleted.
"Required" property definitions cannot be changed to "optional."
"Optional" property definitions cannot be changed to "required."
Existing Implies relationships cannot be deleted.
New "optional" Implies relationships can be added.
"Required" Implies relationships cannot be changed to "optional."
"Optional" Implies relationships cannot be changed to "required."
To handle the movement of property definitions from one interface definition to another,
adapters should be written to not explicitly hard-code interface UIDs for property definitions
unless the property definition is on the list of property definitions that cannot be moved.
Property Definitions
The following rules apply to existing property definitions:
Name and UID cannot be changed.
Description can be changed.
Although not currently used, TypeData and Default can be changed.
The ScopedBy type for the property definition cannot be changed.
The ScopedBy relationship cannot be changed from "required" to "optional," nor from
"optional" to "required."
Enumerated Lists
The following rules apply to existing enumerated lists:
UID cannot be changed.
Because Name is not tied to UID, it can be changed. However, changing the Name is
generally bad practice because some authoring tools (SmartPlant 3D, for example) use the
Name as part of the design basis and may not work properly if the Name is changed.
Description can be changed.
EnumNumber, if undefined, can be given a value. This property is generally part of the
SmartPlant 3D software, and it is treated as a secondary key. Changing the EnumNumber
may have undesired consequences.
EnumNumber, if defined, cannot be changed.
Existing Contains relationships cannot be deleted.
New Contains relationships can be added.
Enumerated Entries
The UID for an existing enumerated entry cannot be changed.
The Name (short description) can be changed. However, changing the Name is generally
bad practice because some authoring tools (SmartPlant 3D, for example) use the Name as
part of the design basis and may not work properly if the Name is changed.
Description can be changed.
EnumNumber, if undefined, can be given a value. If defined, EnumNumber cannot be
changed.
Unit of Measure
The UID for an existing unit of measure cannot be changed.
The Name (short description) can be changed. However, changing the Name is generally
bad practice because some authoring tools (SmartPlant 3D, for example) use the Name as
part of the design basis and may not work properly if the Name is changed.
Description can be changed.
EnumNumber, if undefined, can be given a value. If defined, EnumNumber cannot be
changed.
The A (ACnv) and B (BCnv) conversion factors can be changed. However, this should only
happen if there is an error in the value or if greater precision is necessary. If you find that
you need to change an A or B conversion factor, please contact Intergraph Support Services
so that the change can be propagated to all SmartPlant schema users.
Relationship Definitions
For existing relationship definitions, the revision rules are:
UID and Name cannot be changed.
Role names cannot be changed.
By default, both the 2007 and 2008 configurations are checked to allow forwards and
backwards compatibility between schema versions when creating new objects or modifying
existing objects. For more information, see Forward and Backward Schema Compatability
(on page 47).
Make changes to the schema as needed. For more information, see Extending the
SmartPlant Schema (on page 143).
Save your changes and the SmartPlant schema session file created by the Desktop Client.
Check in the updated CMF file.
Load the schema into SmartPlant Foundation. For more information, see Load Schema
Changes into the SmartPlant Foundation Database (on page 155).
See Also
Create a Schema Extension File (on page 183)
Extending the SmartPlant Schema (on page 143)
Set Dependencies for a Schema File (on page 95)
For more information about setting the active scope, see the Desktop Client Help.
3. Click Find > Integration > Schema Documents.
You must be logged on to the SmartPlant Foundation data warehouse
database and have a schema administrator role to be able to access commands on the
Integration menu.
4. Type CMF*, and click OK.
5. Right-click the CMF file, then click Edit > Check Out.
6. Click OK in the Check Out dialog box.
7. In the New Items window, right-click the CMF file, then click Launch Schema Editor.
8. On the Set Active Configurations dialog box, select the schema version to which you will
apply changes. For example to apply changes to the 2008 version only, click
EF_2008_R<#>.
9. Click OK.
10. To check out the schema CMF file, right-click the CMF file (in this case CMF_Ver), and click
Edit > Check Out on the shortcut menu.
11. Select a folder to check the file out to, and click OK.
12. Set your create scope to the appropriate plant.
13. In the New Items window, right-click the new revision of the CMF file and click Launch
Schema Editor on the shortcut menu.
14. In the Set Active Configurations dialog box, select the schema version or versions that
you want your changes to apply to, and click OK.
15. Make modifications to the schema, synchronize and modify tool schemas, and make any
other required changes in the Schema Editor.
16. In the Schema Editor, click File > Exit.
17. Click Yes in any message boxes to save changes to tool map schemas, the CMF file, and
your session file.
18. Open the Desktop Client.
19. Set your update scope back to Scope Not Set.
20. Right-click the CMF_Ver file you checked out previously, and click Edit > Check In.
21. Click OK in the Check In dialog box.
Checking the schema CMF file back into the Desktop Client does not load the
changes you made into the SmartPlant Foundation database. Loading requires several extra
steps. For more information, see Load Schema Changes into the SmartPlant Foundation
Database (on page 155).
See Also
Extending the Schema for SmartPlant Integration (on page 147)
The name must end in .xml in order to create the configuration as a physical
file.
You do not need to select an option for Starting configuration when creating a pseudo
file. Selecting the option Starting configuration creates the configuration as a primary
configuration rather than a pseudo file.
You do not need to enter values in the Path to pseudo file box. Leaving the Path to
pseudo file box blank creates the pseudo file in the same folder as the CMF file.
The ContainerID for the file is set automatically.
4. Click OK.
5. Click File > Save > Schema File to save schema files, including the new pseudo file.
6. Exit the Schema Editor.
The default ContainerID for a pseudo file is a numeric value automatically set when it
was created.
The ContainerID identifies schema previously loaded into the SmartPlant Foundation
database when performing the compare during a load.
The ContainerID in the header updates to match that in the pseudo file the next time the
CMF file is opened.
After setting the ContainerID for the pseudo file, the new schema can be modeled in the
Schema Editor, or it can be cut and pasted into the physical pseudo file.
3. Click Tools > Schema > Advanced > Merge file into Active Configuration to open the
Merge into Active Configuration dialog box.
By default the output directory is the My Documents folder for the current user.
By default the output directory is the My Documents folder for the current user.
If several pseudo files are attached to the schema document, you can select all of the
files, including the CMF file, to process at one time. You can also select specific files to
load by selecting individual files to process.
2. Under Select compare context, click Compare content of selected files against all
database items with a matching container ID.
3. Click Browse beside Select external schema file, and browse to the schema file in the
output folder defined in the Output path box in the Build Support dialog box.
4. Click Next.
5. In the Select changes to load table, select the schema changes you want to load into the
SmartPlant Foundation database, and then click Next.
6. Click Next.
7. Under Review Changes, review the schema changes, and then click Finish.
If you want to be able to see your new schema information in the Desktop Client, it
must be available in a view definition. You should create the view definition in the Schema
Editor prior to importing.
Load the Pseudo File Changes into the Data Warehouse Database
1. In the Desktop Client, click Administration > Schema Import Wizard.
2. In the Schema Import Wizard, select Compare content of selected file against all
database items with a matching container ID.
3. Under Select external schema file, browse to schema files generated by CMF File
manager in the directory where the software created the CMF files you prepared to be
loaded.
These files are named the same as the original Pseudo File with the suffix "-Gen" to
allow identification. For example, the generated file for CustomSchema 1.xml becomes
CustomSchema 1-Gen.xml.
4. Click Next.
Schema Import Wizard compares the generated schema with the SmartPlant
Foundation database and displays the results. This process can takes time, so please be
patient.
5. Under Comparison Results, select all the items, and then click Next.
If the items were all successfully loaded, then status in the Load State column is set
to Loaded. If not, the status if either Passed or Failed.
6. Click Finish.
See Also
Extending the Schema for SmartPlant Integration (on page 147)
You can use digits and special characters within the body of the plant name.
Special characters include ~ . + - = _ ! ? ' " , ; : & @ # ^ * < > ( ) | [ ] {} / \
The plant name is case-sensitive and cannot exceed 20 characters.
The plant name must be unique within the current domain. This limitation is imposed by
SmartPlant Instrumentation.
Intergraph recommends that the SmartPlant Instrumentation domain schema name and
domain name match the plant name.
Intergraph recommends that the plant name be the same name across all authoring tools.
Click the Query Scope on the Desktop Client status bar to validate that the plant(s) have
been removed.
After you load the files, log out of the Desktop Client, and perform an IISRESET.
5. In the Create PBS Item dialog box, define the name and display name. The software
automatically builds the relationship name to the parent item in the hierarchy.
Because plant is always the top-level class definition in PBS hierarchy in the schema
even if you change its display name, you cannot use "Plant" as the name of another
object in the PBS hierarchy.
The recommended naming convention for the relationship between an item and its
parent is <Parent><Item>s, for example, SitePlants. However, you can name this
relationship any name that you want.
The PBSHierarchy DirectedGraphDef is automatically created when you create the PBS
hierarchy.
6. Click OK.
7. Repeat steps 4-6 for each additional item that you want to add to the PBS hierarchy.
The PBS hierarchy cannot be changed after it is created in the SmartPlant Foundation
client.
9. In the Identify Configurations for Instructions dialog box, select the configuration or
configurations to which you want to apply the PBS changes. For example, if you want the
PBS structure to apply to both the 2007 and 2008 versions, select EF_2007 and EF_2008.
10. Click File > Save > Schema File to save your changes to the SmartPlant schema.
11. Close the Schema Editor.
12. Click OK.
After you make changes in the schema, you must load the updated schema into the
SmartPlant Foundation database. See Load Schema Changes into the SmartPlant Foundation
Database (on page 155).
2. Right-click the new version of the .cmf file and select Launch CMF File Manager (XML).
Load the CMF Data Changes into the Data Warehouse Database
1. In the Desktop Client, click Administration > Schema Import Wizard.
2. In the Schema Import Wizard, select Compare content of selected file against all
database items with a matching container ID.
4. Click Next.
Schema Import Wizard compares the generated schema with the SmartPlant Foundation
database and displays the results. This process can take about 10 minutes.
5. Under Comparison Results, select all the items, and then click Next.
If the items were all successfully loaded, then status in the Load State column is set
to Loaded. If not, the status if either Passed or Failed.
6. Click Finish.
2. Right-click the CMF file version (CMF_Ver), and click Launch CMF File manager (PBS).
The component schema and prefix are populated from the associated method.
3. Check the Combined Authoring and DW database check box.
4. Click Load.
8. Click Export.
This operation generates the schema, some basic SmartPlant Foundation administration
operations, and a tool schema with mappings to the SmartPlant schema. This information is
contained within 7 files in the output directory.
SPF_01_AuthoringSchema.xml SmartPlant
Foundation PBS
authoring
schema
SPF_02_AuthAdminData.xml New PBS This file holds the methods
Methods and and menus configuration
Menus (used to display your new
item in the authoring
environment).
SPF_03_AuthFormInstruction.xml PBS Form The instructions to
Instructions generate forms for newly
generated objects.
Generate Forms
Load the SPF_03_AuthFormInstruction.xml file. This will generate all forms defined under
the component schema.
Create a Vault
1. Click File > New > Administration > Vault in the Desktop Client.
2. Type a name and description for the vault.
3. In the Local path box, type the file location where you want the vault to be stored on the
SmartPlant Foundation server.
You must create the folder structure for your vault on the SmartPlant Foundation
server.
4. In the Sub directory property or name box, type
Obj->SPFFileComposition_12->SPFRevisionVersions_21->SPFDocumentRevisions_21.SP
FDocType. This property stores your published and non-published documents based on
document type.
5. In the Host list, select the host you created.
Do not set to local host.
6. Relate ISPFTEFPublishedDocVersion to the vault.
Click Find > Schema > Interface Definition. In the Find box, type
ISPFTEFPublishedDocVersion.
Drag the vault you created on to ISPFTEFPublishedDocVersion.
7. Relate ISPFNonPublishedDocVersion to the vault.
Click Find > Schema > Interface Definition. In the Find box, type
ISPFNonPublishedDocVersion.
Drag the vault you created on to ISPFNonPublishedDocVersion.
8. Relate the Owning Group to the vault.
Click Find > Administration > Vault to find the vault you created. Press CTRL and
drag the vault to the New Items window.
Click Find > Administration > Owning Group.
Drag the ADMIN owning group on to the vault.
Create a Plant
1. Click File > New > Organization / Support Items > Plant.
2. Type the name of your plant based on the guidelines in Plant Naming Guidelines (on page
161).
3. In the Status list, select Active.
4. Relate the vault to the plant.
Click Find > Administration > Vault to find the vault you created.
5. Drag the vault to the plant in the tree view.
Create a Unit
1. Click File > New > Organization / Support Items > Unit.
2. Type the name of your unit
3. Pick the Plant created in the previous step
4. Select New for Construction status
Create a System
1. Click File > New > Organization / Support Items > System.
2. Type the name of your system
3. Pick the Unit created in the previous step
4. Select New for Construction status
Testing
1. Click SmartPlant > PBS > Register.
2. Test the create, update and view functions of each item in the new structure.
3. Test the publish function.
Right-click the plant, then click Publish PBS.
Remember the PBS needs to be registered, and the Process Engineer needs to be
associated to the SmartPlantPublish and SmartPlantRetrieve roles defined in the database.
The new PBS is now ready to be retrieved by the authoring tools.
To activate a plant that has a status of Created, find the plant in the Desktop Client (Find >
Organization / Support Items), right-click the plant, and click Activate configuration.
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFCoreDocMgtSch
ema.xml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFClaimSchema.x
ml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFDesignDocumen
tSchema.xml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFProgressSchem
a.xml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFSchedTaskSche
ma.xml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFWorkflowSchem
a.xml!N
`AS`C:\Program
Files\SmartPlant\Foundation\2008\Models\Core\SCHEMA_SPFCoreXmtlSchem
a.xml!N
`AS`.\SCHEMA_CNDocs.xml!Y
`ActS`.\SCHEMA_CNDocs.xml!Y
3. Click Tools > Schema > Advanced > Merge File into Active Configuration.
You can also select the equivalent command from the Workflows menu.
4. On the Merge into Active Configuration dialog box, identify the name of the file
(…\Extensions.xml).
6. Click OK. The objects in the specified extensions file should then be added to both the 2007
(3.8) and 2008 (4.N) or higher configurations.
You can also create objects and relationships by right-clicking objects in various Schema
Editor views. For example, in the Schema Tree view, you can right-click a class and then
click Create New ClassDef on the shortcut menu to display the Create dialog box for class
definitions.
You can also drag and drop objects from the Create tree to the UML view to create them.
9. Beside the Component schema box, click , and select the component schema to which
the new class definition belongs.
If the object that you want to associate the new class with does not already exist, click
Create to define the object in the schema.
10. Beside the Shared object definitions box, click , and select the shared object definitions
for this class. You can select one or multiple shared objects.
Shared objects must exist in the same model. For example, if you select
ActualMaterialModel for the new class, all shared objects must also exist in the
ActualMaterialModel.
11. Beside the Class factory definition box, click , and select the class factory for the new
class.
12. Beside the Primary interface definition box, click , and select the primary interface
definition that this class realizes.
The primary interface for the class definition must also be realized by the class
definition.
If the primary interface definition for the class definition does not exist, create it by
clicking New in the Possible PrimaryInterfaceDef for <ClassDef>
13. Beside the Realized interface definition box, click , and then select additional interfaces
that this class realizes. You can select one or multiple interfaces.
Create a Relationship
You can create new relationships in the Schema Editor in three different ways: by creating a
relationship in an editor view, by modifying the object at one end of the relationship, and by
modifying individual relationship edge definitions.
The SmartPlant schema configuration file references the SmartPlant schema file
(read-only), other schema files (read-only), and your schema extensions file (editable).
The delivered schema extensions file is named Extensions1.xml, and when you open
EFSchema.cfg, your changes are saved in Extensions1.xml by default. However, you
can specify additional extensions files to store your schema modifications. For more
information, see Modify a File Configuration (on page 94).
The SmartPlant schema configuration file is delivered with the SmartPlant Server and
Client components. By default, it is installed in the following location: ..\Program
Files\Common Files\Intergraph\EFSchema\7.x. However, if you use different SmartPlant
schemas for each SmartPlant Foundation site, your schema file may be in a different
location.
If you used the File > SmartPlant > Connect to SmartPlant command to connect to a
SmartPlant Foundation plant and database and synchronize tool map schema files, the
SmartPlant schema is already open in the Schema Editor.
2. Click View > Schema (All).
3. On the View tab, select one of the Tree views or Editor views and then click OK.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. Right-click the object for which you want to add a relationship.
5. On the shortcut menu, click Edit <Object Type>.
6. In the Edit dialog box, make changes to the interfaces realized by the object, the model the
class belongs to, and so on.
Click to display a dialog box that allows you to select objects for each relationship
type.
To remove existing relationships, click selected objects in the list to clear them.
To remove all currently related objects, click Clear.
7. Click OK to save the new relationships.
The SmartPlant schema configuration file references the SmartPlant schema file
(read-only), other schema files (read-only), and your schema extensions file (editable).
The delivered schema extensions file is named Extensions1.xml, and when you open
EFSchema.cfg, your changes are saved in Extensions1.xml by default. However, you
can specify additional extensions files to store your schema modifications. For more
information, see Modify a File Configuration (on page 94).
The SmartPlant schema configuration file is delivered with the SmartPlant Server and
Client components. By default, it is installed in the following location: ..\Program
Files\Common Files\Intergraph\EFSchema\7.x. However, if you use different SmartPlant
schemas for each SmartPlant Foundation site, your schema file may be in a different
location.
If you used the File > SmartPlant > Connect to SmartPlant command to connect to a
SmartPlant Foundation plant and database and synchronize tool map schema files, the
SmartPlant schema is already open in the Schema Editor.
2. Click View > Schema (All).
3. On the View tab, click Tree/Drag-Drop UML.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. Click OK.
5. Navigate to an object in the tree view at the bottom of the Tree/Drag-Drop UML window.
6. Drag the object to the UML view.
7. To view the standard UML diagram associated with the object, click Yes in the Schema
Editor dialog box.
You can also create a customized UML view for the object. For more information, see
Tree/Drag-Drop UML View: An Example (see "Tree/Editable UML View: An Example" on
page 108).
8. In the UML view, right-click the object for which you want to modify relationships.
10. In the Edit dialog box, make changes to the interfaces realizes by the object, the model the
class belongs to, and so on.
Click to display a dialog box that allows you to select objects for each relationship
type.
To remove existing relationships, click selected objects in the list to clear them.
To remove all currently related objects, click Clear.
11. Click OK to save the new relationships.
See Also
Relationship Definitions (on page 31)
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
7. In the Possible RealizedByClassDefs dialog box, select the classes that realize the new
interface, and then click OK. You can select one or multiple classes.
8. Beside the Implies interface definitions box, click , and then select the interfaces that
this class realizes. You can select one or multiple interfaces.
All interfaces must imply at least one other interface.
9. Beside the Exposed property definitions box, click , and then select the properties that
this interface exposes. You can select one or multiple property definitions.
10. Beside the Implementation of enumeration box, click , and then select the enumerated
list used by this interface, if one is used.
11. In the New Interface Definition dialog box, click OK to save the new interface.
See Also
Interface Definitions (on page 22)
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
6. In the New Property Definition dialog box, type a name, description, and display name for
the new property definition in the Name, Description, and Display name boxes.
7. Beside the Exposed by interface definitions box, click .
8. In the Possible ExposedByInterfaceDefs dialog box, select the interface definitions that
expose this property definition. Typically, property definitions are exposed by one and only
one interface definition.
9. Beside the Scoped by property type box, click , and select the property type that
scopes this particular property.
You can select from standard property types like string, double, integer, Boolean, and
so on, or you can select an enumerated list or unit of measure list to scope this property.
If the property type that scopes this property definition does not exist, you can create it
by clicking Create in the Possible ScopedByPropertyType Values dialog box. For
example, if this property definition is scoped by a unit of measure (UoM) list and that list
does not exist, you can create it.
10. Click OK to create the new property definition.
See Also
Property Definitions (on page 26)
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
1. After you open schemas, tool schemas, or data files, click the type of file that you want to
view on the View menu. For example, to view the schema, click View > Schema (All).
2. Click Options on the View Schema dialog box.
3. On the View tab, click any of the tree views.
If you do not see the View tab, the View dialog box is in Simple mode. Click Editor in
the Form list instead.
4. Click OK.
5. In the tree view, find the property that you want to merge with another property on another
interface.
6. Right-click the property, and click Merge <Property Name> into another property.
7. In the Merge <Property Name> dialog box, define the interface, location, and property that
you want to merge the existing property with.
You can change the unique identifier (UID) supplied by the software. However, this
unique identifier must be unique within the SmartPlant schema.
When you change the short description of the enumerated list, the software replaces the
default UID with the short description in the enumerated entries tree.
7. If this enumerated list is contained in another list, click beside the Contained in box and
select the enumerated list to which the new list belongs.
When you select the enumerated list that this list belongs to, the enumerated entries
tree view updates with the entries from the selected enumerated list.
If the list you select is part of another list, that list appears in the enumerated entries tree
also.
8. If the list contains other enumerated lists, click beside the Contains box and select the
existing enumerated lists that this list contains.
9. Click OK.
When you click OK, the software updates the enumerated entries tree with the
selected enumerated lists.
10. If this property type definition scopes one or more property definitions, click beside the
Scoped property definitions box and select the property definitions that this property type
scopes. Defining this relationship indicates that all properties of that property definition are
of property type that you are creating.
11. Click OK.
12. To add a new child enumerated list, click New Child List and define properties for the list.
13. To add a new child enumerated entry to either the parent list or a child list, do the following:
Select the list that you want to add an entry to in the tree.
Click New Child Entry.
Define properties for the new entry.
14. After you add a new list entry, click New Sibling and repeat step 13 to create new
enumerated list entries.
15. To save the new enumerated list and entries, click OK.
You can also import enumerated lists and list entries from the Clipboard by clicking the
Import Lists from Clipboard and Import Entries from Clipboard buttons.
Import Enumerated List Entries from a Spreadsheet (on page 198)
To delete an entry or child list, select the entry or list in the tree view, and then click Delete.
See Also
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
Enumerated Lists (on page 27)
In an authoring tool map schema, you can also import enumerated list entries into a
tool map enumerated list and units of measure into a tool map unit of measure list using this
procedure.
2. In Excel, select the rows containing your enumerated list entries, and click Edit > Copy to
copy the entries to the Clipboard.
3. In the Schema Editor, create the enumerated list type to which you want to add the list
entries.
Create an Enumerated List (on page 196)
Create a Map Enumerated List Definition (on page 372)
4. In the New Enumerated List dialog box, click Import Entries from Clipboard.
To import entries into a tool map enumerated list or map UoM list, click Import
Clipboard Entries instead.
5. Verify that the default mapping between the columns in your copied spreadsheet and
properties of enumerated list entries is correct. If this mapping is correct, you can skip to
step 8 to import the entries.
6. If the default mapping is not correct, click the number for the column that you want to
change the mapping for in the Column list. Numbering for the columns starts with zero,
which is the first column in your spreadsheet.
7. In the Maps to property list, select the property that corresponds to the selected column in
your copied spreadsheet.
8. When the mapping is correct, click OK to import the enumerated list entries.
9. Click OK in the New Enumerated List dialog box to save the new entries.
11. In the A conversion factor box, type the multiplier used to convert from this unit of measure
to SI units.
Conversions are done using y = Ax + B, where x is the value in this unit of measure
and y is the value in SI units.
12. In the B conversion factor box, type the addend used to convert from this unit of measure
to SI units.
13. If this UoM is the default SI UoM for the list, select Yes in the Is default SI unit of
measure? list.
14. To add addition UoMs to the list, repeat steps 8-12.
15. Click OK.
To test the conversion for UoMs in the list, click Test. To be able to test conversions for
the list, you must specify that one of the UoMs is the default SI UoM for the list.
See Also
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
11. In the End interface tree, select the ending interface definition or class definition for the
edge definition.
The End interface tree displays the interface definition at the end of the current path.
You can expand Implied nodes under each interface definition to select from interface
definitions implied by the interface definition at the end of the current path. You can expand
the RealizedBy node to select from class definitions that realize the interface definition.
12. In the Edges list, select the relationship edge that you want to include in the edge definition.
By default, the edge definitions that appear in the Edges list are those that start at the
end interface definition or at an interface definition implied by that end interface
definition. You can change the list of available relationship edges by selecting a different
interface definition or class definition in the End interface tree.
When you select an edge definition, the software displays the UML for that edge
definition in the Edge preview pane under the Edges tree.
13. Click Add to Path to add the path for the selected edge definition to the path for the edge
definition you are defining.
When you add the edge definition to the path, the UML in the Current edge definition
pane is updated, and the End interface tree and Edges list are also updated for the
new ending interface definition.
To remove edges from the path definition, click Remove Last Edge from Path on the
Path tab. Clicking Remove Last Edge from Path only removes one edge at a time
starting with the last one added.
14. To define filtering criteria for the edge definition, click the Filter tab.
15. Under Criteria, specify the criteria that you want to use to display objects at the end of the
selected relationship by doing the following:
Select a property in the Property list.
Select a comparator value, such as equal to (=), less than (<), greater than (>), or not
equal to (<>) , in the Comparator list.
Type a value in the Comparison value box for the selected property.
For properties that are enumerated list types and UoM list types, you can click
beside the Comparison value box to select an enumerated list entry or define a
specific value and UoM as the comparison value.
If you do not want the edge to appear in the user interface by default, select the Filter
out edge in display check box. If this option is checked, user access for this edge
definition can be controlled in the SmartPlant Foundation client by user group security.
16. If you want to define criteria for multiple properties, repeat step 15 for each property.
If you want the criteria to include multiple values for a specific property, you can enter
multiple values separating the values with a colon. For example, you could enter both
Working and Current values for IssueState as shown below:
IssueState with Value = to WORKING:CURRENT
17. If the path specified for the edge definition includes traversal across an ordered relationship
definition, click Numeric position, and type the position number that identifies a specific
object from the set of objects at the end of the path.
For example, if you want to return the fifth nozzle on a piece of equipment, the numeric
position should be set to 5.
If you specify a position, a maximum of one object will be found when the edge
definition is traversed.
18. If you want the end object in the relationship to support a particular interface, click
beside the End objects must support one of the following interfaces box, and select the
interfaces.
For example, if you want to create an edge definition to display the P&ID an object is on,
you could select IPIDDrawing in this list to make sure that only P&IDs and not other objects
that participate in the DwgRepresentationComposition relationship are returned by the edge
definition.
19. Click OK to save the new edge definition.
You can also create edge definitions, graph definitions, and view definitions in the
Graph\View\Edge Environment. This environment allows you to see, edit, delete, and copy
existing graph definitions, edge definitions, and view definitions, create them individually, and
create graph definitions and view definitions at the same time. To open the environment,
double-click Graph/View/Edge in the Environment tree in either of the editor views.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
10. In the Interfaces and classes tree, select an interface definition or class definition to
display edges for that interface definition or class definition in the Edges list.
The Edges list displays the edge definitions that apply to the interface definition or class
definition selected in the Interfaces and classes tree. If you select an interface
definition in the Interfaces and classes tree, these edge definitions include those that
start at the selected interface definition or at an interface definition directly or indirectly
implied by the selected interface definition. If you select a class definition in the
Interfaces and classes tree, the edge definitions include those that start at an interface
definition realized by the selected class definition.
When you select an edge definition, the software displays the UML for that edge
definition in the Edge preview pane under the Edges tree.
If you select an interface definition in the Edges list, you can click New Edge Definition
to create an edge definition starting from the selected interface definition. For more
information about creating edge definitions, see Create an Edge Definition (on page
200).
11. Click Add to Graph to add the selected edge definition to the graph definition you are
defining.
Changing the name of a graph edge invalidates any view properties that use this
graph edge for view definitions that are tied to this graph definition.
12. To remove the active graph edge from the graph definition, click Remove from Graph.
Removing a graph edge from a graph definition invalidates any view properties
that use this graph edge for view definitions that are tied to this graph definition.
13. Click OK to save the new graph definition.
As you add edge definitions to the graph definition, the UML in the Current graph
definition pane is updated. The starting interface for the graph definition appears at the
upper left of the UML view. Any graph edges that originate from this starting interface
definition are shown with lines coming from the interface definition. For each graph edge in
the graph definition, the edge definition traversed and the name of the graph edge are
shown in the UML. The edge definition is shown to the left of the graph edge and the graph
edge is shown in italics.
You can also create edge definitions, graph definitions, and view definitions in the
Graph\View\Edge Environment. This environment allows you to see, edit, delete, and copy
existing graph definitions, edge definitions, and view definitions, create them individually,
and create graph definitions and view definitions at the same time.
To open the environment, double-click Graph/View/Edge in the Environment tree in either
of the editor views.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
7. If you want the display name for the edge definition to be different from the name, type the
display name in the Display name box.
8. Select the graph definition that you want to use as the starting point for the view definition
from the Graph name box.
9. Click the Layout tab.
10. In the Graph edges tree, expand the graph edge for which you want to select properties.
The Graph edges tree contains all of the graph edges for the directed graph definition
used by the view definition.
11. In the tree view, select the property category or graph edge for which you want to add
properties to the new view definition.
Under the graph edge node, expand the Property Categories node if you want to
select from property categories for the graph edge or the View Definitions node if you
want to select from other view definitions that start at the end interface definition for the
graph edge.
If no other view definitions start at the end interface definition for the selected graph
edge, the View Definitions node is not available.
When you select a property category, the software displays properties for that category
in the Properties for graph edge list.
When you select a graph edge under a view definition node, the software displays the
view properties for that view definition that use the selected graph edge in the
Properties for graph edge list.
12. In the Properties for graph edge list, select the checkbox beside property names to add
them to the view definition.
The properties that you select and add to your view definition show up as properties in
the SmartPlant Foundation Properties window for classes that expose the starting
interface you selected. These properties are also used in ad- hoc reporting in
SmartPlant Foundation.
When you select the check box beside a property name, the property appears in the
Current view definition table.
If a property with the same display name already exists in the view definition, the display
name for the property you add is changed to <graph edge name>_<property definition
name>. To change the display name, see step 16.
To find a property to add, you can type all or part of the property name that you want to
search for in the text box below the Properties for graph edge list, and then click Find.
To find the next property that matches the string you typed, click Find Next.
13. To add all unchecked properties to the view definition, click Add Unchecked.
14. If you want to remove a group of selected properties from the view definition, click Remove
Checked.
You can also remove a property from the view definition by right-clicking the property in
the Current view definition table and then clicking Delete on the shortcut menu or by
clearing the checkbox beside the property name in the Properties for graph edge list.
15. To change the display name or property category for a property in the view definition, select
the property in the Current view definition table, and type a new display name in the Name
box or select a new property category in the Category list below the table.
Defining a different display name for a property allows you to differentiate among
multiple properties with the same display name in the view definition. For example,
many properties have a display name of "Name". You can modify the display name to
be more specific than "Name" for all the name properties you add to the view definition.
The property category you select is used to organize properties in the Properties
window in SmartPlant Foundation.
You can change the property category for multiple properties by selecting several
properties in the table and then selecting a new property category in the Category list.
16. To change the order of properties in the view definition, do the following:
In the Current view definition table, select the property or properties that you want to
move. To select multiple properties, hold down the CTRL key while you click multiple
properties.
Right-click one of the selected properties.
Click Cut on the shortcut menu.
Right-click the row below where you want to move the properties in the table.
Click Past Insert. Properties are inserted above the row you select.
17. Click OK to save the new view definition.
You can also create edge definitions, graph definitions, and view definitions in the
Graph\View\Edge Environment. This environment allows you to see, edit, delete, and copy
existing graph definitions, edge definitions, and view definitions, create them individually,
and create graph definitions and view definitions at the same time.
To open the environment, double-click Graph/View/Edge in the Environment tree in either
of the editor views.
To locate an existing view definition property in the Graph edges tree and Properties for
graph edge list, right-click the property in the Current view definition table, and then click
Locate Property in Tree on the shortcut menu.
See Also
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
A default set of class view maps is delivered with the SmartPlant schema.
You can define which SmartPlant Foundation users see the view definitions defined by the
class view map when they select objects of the specified classes by associating user groups
with the class view map.
See Also
Creating New Objects and Relationships in the Schema (on page 187)
Naming Conventions in the SmartPlant Schema (on page 143)
SmartPlant Schema Overview (on page 19)
Class View Maps (on page 40)
2. Select the pseudo file to export on the Select Pseudo File Configuration dialog box, and
then click OK.
3. Type the name of the exported Excel file in the Save Spreadsheet File dialog box, then
click Save to export. The file is saved as a .xlm.
Export a View
1. To export a view, such as the construction status enumerated list, click the appropriate view
tab, such as HierEnumListView.
The view tabs are available by setting View Options. For example, to set
HierEnumListView, click the MultiTab tab, then click View Definitions on the View
Options dialog box. See Set View Options (on page 119).
2. Right-click inside the view, and then click Export an Importable Excel Workbook to export
the view.
3. Type the name of the exported Excel file in the Save Spreadsheet File dialog box, then
click Save to export. The file is saved as a .xlm.
The following is an example of an exported enumerated list.
Edit in Excel
Excel (.xlsm) File
Worksheets in .xlsm File
For every class definition of an object that is exported, an Excel worksheet will be created and
named the same as the class definition’s UID. Because UID and Name are the same for class
definitions, the worksheet’s name is also the class definition’s Name.
For relationship objects (class definition UID = Rel), a separate Excel worksheet will be created
containing every relationship type (DefUID). The worksheet will be named based on the UID for
the relationship definition for that relationship.
If a view is exported, the first worksheet in the Excel workbook will contain the view and will be
named based on the exported view.
The rest of the first row of each Excel worksheet contains the names of each of the properties
for the objects displayed on that worksheet.
For every object that is exported, a row in an Excel worksheet will be added. This row will
contain all the property information for that exported object.
The number of objects initially displayed on a particular worksheet should match the number of
rows in the Rows= comment in the upper left cell for that worksheet.
Cell Information
Each cell (other than those on the first row) should contain the value for the particular property
(from the first row) for the exported object for that row.
For relationship worksheets, the cells for the UID1 and UID2 columns contain a comment that
identifies the name for the object corresponding to the UID in that cell.
SchemaRevVer property values are exported along with all the other property information.
However, since these values for existing objects should never be changed by the user and
these values are automatically assigned to new objects, the column for this property is hidden.
The cells in the first worksheet for an exported view contain the values for that view. Cells that
are shown as underlined blue text are hyperlinked to the corresponding objects in the workbook.
Clicking a hyperlinked cell takes you to the corresponding object in the workbook. Cells on this
workbook that contain arrows, when clicked, take you to the corresponding relationship in the
workbook.
2. Click Enable this content in the Microsoft Office Security Options dialog box, and then
click OK.
UIDs File
In addition to the Excel file that is generated by the export process, a .UIDs file is created. This
text file contains the UID for every object and relationship that is exported.
Once the user selects OK, the checked changes are then made to the current schema.
After the changes are made the .UIDs and .xlsm files used for the import are deleted.
Parsing the .xlsm File - Other than the first worksheet for an exported view, all worksheets in
the .xlsm file are parsed. If the workbook contains a Sheet1 worksheet, then this worksheet is
ignored during parsing.
The upper left cell for the worksheet identifies the class definition for all objects for that
worksheet.
The remaining cells on the first row identify the properties for the objects for that worksheet.
The other rows on that worksheet contain the property information for each object for the class
definition identified by the upper left cell.
Parsing of object information is done on a row by row basis. If the UID cell for a row has a
blank value, that row will be ignored during parsing (even if other property values are defined on
that row). If the user deletes an object or relationship by deleting the corresponding row from
the workbook, he should leave that row (with blank cells) in the workbook as a reminder of the
deleted object (also to keep hyperlinks for exported views correct).
Validation Errors - Any new or resurrected objects encountered during the import process are
automatically validated. If any errors (warnings don’t count) are detected during this validation,
the validation message correction form will appear and the user can correct these errors (and
warnings) via this form.
If any errors are not corrected during this process, then the import process is terminated.
Selective Update Form - The form that appears at the end of the update process and is used to
identify the differences to apply is the same form used for all selective update comparisons.
Most applications use concrete class definitions to denote the existence of objects and use
interface definitions (or abstract class definitions), if they are used at all, to identify the roles for
the objects. The SmartPlant schema is based on a different approach where class definitions
indicate that a primary interface definition (which identifies the existence of an object) is used by
an authoring tool component (by a component schema).
As part of defining how the primary interface definition is used within a component schema, the
class definition identifies the roles supported by a component schema for that object. The
identification of the roles is done by the class definition realizing a subset of the interface
definitions implied (directly or indirectly) by the primary interface definition. This set of realized
interface definitions/roles defines the extent to which that object (primary interface definition) is
supported by that software component (component schema).
The same primary interface definition, when used in a different component schema, can have a
different class definition that realizes it.
The enumerations for an enumerated list may be either enumerated entries (EnumEnum
objects) or other enumerated lists. If enumerated lists are contained within other enumerated
lists, the result is an enumeration hierarchy where the enumerated lists are branches in the
hierarchy and the enumerated entries are leaf nodes within the hierarchy.
Since an enumerated list may be contained within another enumerated list, the EnumListType
class definition not only realizes IEnumListType but also IEnumEnum.
Enumeration Hierarchies
When enumerated lists are contained within other enumerated lists, the result is an enumeration
hierarchy. A typical enumeration hierarchy is show below.
Enumerated lists that are not part of enumeration hierarchies are considered to be single-level
lists. An enumeration hierarchy is considered to be a multi-level list, where the number of levels
is defined by the number of enumerated lists in the longest path through the hierarchy. For
ConstructionStati, shown in the screen shot above, the number of levels is two
(ConstructionStati and either Existing, Future, New or Undecided).
While most enumeration hierarchies in the SmartPlant schema are two or three levels deep,
they can go much deeper. The equipment types hierarchy, for example, has seven levels.
SPMapClassDef
Tool Class Definition
For every tool that integrates with SmartPlant, there should be one Tool object (an instance of
the Tool class definition). This object and related objects are used to define the information
specific to that tool, including the progID for the tool's adapter, the tool (map) schemas for that
tool and the set of document types published and retrieved by that tool.
InterfaceDef Instances
IClassDef Interface Definition
Primary interface definition for class definitions.
MenuCmd Instances
Generate Tool MetaDatas Command
The Generate Tool MetaDatas command is used to generate the metadata file for each Tool
defined in the SmartPlant Schema. For each Tool defined, a file called <Tool>_Meta.xml is
created (for example, SmartPlantPID_Meta.xml).
This file contains the <Tool> object as well as the <DocumentType> objects for the tool (one
<DocumentType> object for each document type published and/or retrieved by the tool) and
the <ToolSchema> objects for that tool. In addition, the <ClassDef> object for each document
type and the <CompSchema> objects for those class definitions are also loaded into the
generated file.
All of the relationships between these objects are also loaded into the generated XML file.
However, although the EnumMetadata relationships between the <DocumentType> objects and
the corresponding SmartPlant enumerations (<EnumEnum> or <EnumListType>) are included,
the corresponding enumerations are not included. Likewise, the ToolInstantiates relationships
between the <ToolSchema> objects and the <SPMapClassDef> objects are included, but the
corresponding <SPMapClassDef> objects are not included.
Because the generated tool metadata file contains <ClassDef> and <CompSchema> objects,
the tool metadata must be loaded into a container in a unique container composition and this
container composition must be parented by the meta-schema container composition and not the
schema container composition (in order to avoid UID conflict on the ClassDef and CompSchema
objects - since those objects are loaded as part of the component schema).
Any IObject pointers to the <ClassDef> or <CompSchema> objects in the tool metadata
container should not be passed to outside applications since these pointers are not the same as
the corresponding objects in the schema container. For example, the <ClassDef> for
PIDDrawing from the loaded SmartPlantPID_Meta.xml file will not have the same IObject pointer
as the <ClassDef> for PIDDrawing from PIDComponent.xml.
The <ClassDef> and <CompSchema> objects are included in the Tool metadata file so that the
SmartPlant Client can determine the component schema to load for a particular document type.
The <EnumEnum>, <EnumListType> and <SPMapClassDef> objects are not included since the
resolution of the relationships to these objects can be done after the component schema and
tool schema have been loaded.
Menu Instances
Tools > Schema Menu
The Tools > Schema menu exposes the tool commands that apply to the Schema objects.
Tools Menu
The Tools menu exposes the various tool commands for each type of data supported by the
Schema Editor (that is, MetaSchema, Schema, and so forth).
RelDef Instances
Componentization Relationship Definition
The Componentization relationship definition is used to tie a class definition (realizes IClassDef)
to its component schema (realizes ICompSchema). Every class definition belongs to one and
only one component schema. A component schema can contain an arbitrary number of class
definitions.
Since a class definition can belong to only one component schema, the existence of a class
definition depends on the component schema. If a new component schema is introduced, then
every class definition for that component schema must be new and unique to that component
schema.
Every class definition has one and only one primary interface (an interface definition, on the
other hand, can be the primary interface for multiple class definitions). The many-to-one
relationship definition between a class definition and a component schema and between a class
definition and a component schema means that the class definition can be considered to be an
intersection object between a primary interface and a component schema.
Although the cardinalities on the individual relationship definitions would allow an interface
definition to be a primary interface for more than one class definition for a component schema,
this is not allowed. Therefore, there can be only one class definition for a component schema
that uses a particular interface definition as its primary interface.
Enumerations (objects that realize IEnumEnum) can be described by other schema objects that
realize IEnumMetadata.
An enumeration may be multiply-described by other schema objects or not described at all.
Likewise, other schema objects may describe multiple enumerations or no enumerations.
The EnumMetadata relationship is used to extend the definition of an enumeration beyond the
limited set of properties associated with the various enumeration property types. For example,
this relationship, when it ends at an interface definition, defines the semantics that apply to the
enumeration (for example, the enumeration Pump relates to IPump, which defines the property
definitions and relationship definitions that make up a pump).
6. In the bottom tree view, right-click DocumentType, and then click Create New
DocumentType.
7. In the New Document Type Definition dialog box, type a name and description for the new
document type.
8. Beside the Enumeration box, click and select the enumerated list for the new document
type. Because the document type list is a hierarchical enumerated list, you can expand
existing nodes to select a child list for the new document type.
9. To define authoring tools that can publish the new document type, click beside the
Published by tool schema box, and select the tool schema(s) for the publishing tool(s).
10. To define authoring tools that can retrieve the new document type, click beside the
Retrieved by tool schema box, and select the tool schema(s) for the retrieving tool(s).
If a class definition for the document type does not already exist, click New at the
bottom of the Possible ClassDef Values for <DocumentType> dialog box, and create a
new class definition with a relationship to the appropriate component schema.
11. Click OK to save the new document type and its relationships with the tool schemas that
publish and retrieve it.
See Also
Publish and Retrieve File Types for Tools (on page 223)
Externalize Authoring Tool Metadata (on page 224)
Generate Authoring Tool Metadata Files (on page 241)
4. In the bottom tree view, click Tool Metadata in the Select other classes list box to display
SmartPlant schema objects for tool metadata, including tool objects, tool schema objects,
and document types.
6. Under ToolSchema, double-click the tool schema to which you want to add publish and
retrieve file types. The tool schema defines publishable and retrievable file types for an
authoring tool.
7. In the Edit Tool Schema Definition dialog box, click beside Published document
types to add document types that this tool can publish.
8. In the PublishableDoc Types for <Tool Schema> dialog box, select the existing document
types that you want the authoring tool to publish, and click OK.
9. To add document types that this tool can publish, click beside Retrieved document
types, and select the existing document types to retrieve.
10. Click OK in the Edit Tool Schema Definition dialog box.
11. Click File > Save Schema File to save the changes in the SmartPlant schema.
12. Edit the EFSchma.cfg file to make EFSchema.xml read-only again.
Modify a File Configuration (on page 94)
See Also
Publish and Retrieve File Types for Tools (on page 223)
Externalize Authoring Tool Metadata (on page 224)
The SmartPlant schema configuration file references the SmartPlant schema file
(read-only), other schema files (read-only), and your schema extensions file (editable).
The default schema extensions file is Extensions1.xml, and when you open
EFSchema.cfg, your changes are saved in Extensions1.xml by default. However, you
can specify additional extensions files to store your schema modifications. For more
information, see Modify a File Configuration (on page 94).
2. Click Tools > Schema > Generate Tool Metadatas.
The software generates metadata XML files for each authoring tool that has metadata
defined in the SmartPlant schema. The XML file names are in the following format:
<ToolID>_meta.xml, where ToolID is the authoring tool's ID defined in the SmartPlant
schema. The tool metadata files are placed in the same location as the SmartPlant schema
file you opened as part of the SmartPlant schema configuration file.
classes (multiple levels of inheritance). A class may also inherit from multiple classes (multiple
inheritance).
The following diagram illustrates a class inheritance model with both multiple levels of
inheritance and multiple inheritance at one level. Arrows are used to show the inheritance.
Therefore, class C inherits from class A and class B. Class E inherits from class C and class D.
Class/Interface Model
A class/interface model is similar to a class inheritance model with the following differences:
A class/interface model only has two levels (class and interface), but a class inheritance
model can have multiple levels.
The classes (actually interfaces) inherited from have no implementation in a class/interface
model, but classes inherited from in a class inheritance model can have implementation
(software methods).
A simple class inheritance model is shown below. In this model, class A inherits from (realizes)
interfaces IA, IB, and IC.
See Also
Tool Map Schemas (on page 244)
The following UML diagram represents the modeling of a class/interface model using a tool map
schema:
Notice that inheritance in the class inheritance model uses MapClassMapClass relationships,
but the relationships between the class and interface in the class/interface model are instances
of the MapClassRealizesMapClass relationship definition.
OR
A map unit of measure list is a specialization of a map enumerated list as indicated by the
Implies relationship between IMapUoMListDef and IMapEnumListDef. Therefore, the same
relationship types are used for both map enumerated lists and map unit of measure lists.
A map property that is scoped by a map enumerated list (or a map unit of measure list) should
have a MapPropertyMapEnumList from the map property to the map enumerated list (or map
unit of measure list).
Application enumerated lists are described using map enumerated lists (instances of
SPMapEnumListDef) and map enumerations (instances of SPMapEnumDef). Using these
objects, an application enumerated list for TrafficLightColors would be modeled as:
If an enumerated list contains more than one level, then it is modeled using a map enumerated
list definition for each level. The map enumerated list definitions are related as are the individual
map enumerations. For example, the enumerated list for ConstructionStatuses would look like
the following:
The same relationship types (MapEnumListMapEnum) are used for unit of measure lists and
enumerated lists.
See Also
Tool Map Schemas (on page 244)
For each of the various map objects, there are two relationship definitions that are used for
mapping:
Map<Object>To<Object>, where <Object> is the type of map object, is used for defining
mapping from the tool schema into the SmartPlant schema for publish.
<Object>ToMap<Object> is used for defining mapping from the SmartPlant schema to the
tool schema for retrieve.
IMappableClass is realized by both ClassDef and InterfaceDef. Therefore, map class definitions
can be mapped to either class definitions or interface definitions.
IMappableProperty is realized by PropertyDef and EdgeDef. Therefore, a map property
definition can be mapped to either property definitions or edge definitions.
The following UML diagram shows the relationship definitions used to define mapping for tool
enumerated lists and entries and unit of measure lists and entries:
Like the other map objects, map enumerated lists, map unit of measure lists, map enumerations,
and map units of measure have two map relationships to SmartPlant schema objects,
Map<Object>To<Object> for publish and <Object>ToMap<Object> for retrieve.
Because IMapUoMListDef implies IMapEnumListDef, map unit of measure lists and map
enumerated lists both map to IMappableEnumList, an interface common to both SmartPlant unit
of measure lists and SmartPlant enumerated lists. Although in theory this allows a map unit of
measure list to be mapped to a SmartPlant enumerated list and vice versa, in actuality map
enumerated lists map to SmartPlant enumerated lists, and map unit of measure lists map to
SmartPlant unit of measure lists.
Map enumerations can map to either SmartPlant enumerations or SmartPlant enumerated lists.
Map units of measure can map to SmartPlant units of measure. Because IMapUoMDef implies
IMapEnumDef, the mapping relationships used for map enumerations and map units of measure
are the same. As for the unit of measure lists and enumerated lists, this would appear to make it
possible for map enumerations to map to SmartPlant units of measure and vice versa, but in
actuality map enumerations map to SmartPlant enumerations, and map units of measure map to
SmartPlant units of measure.
See Also
Tool Map Schemas (on page 244)
In one-to-many (1:M) mapping, map properties for one map class definition map to properties on
more than one SmartPlant object. In the following example, map properties for map class
definition B map to properties on SmartPlant class definitions SmartPlantA and SmartPlantB.
The line connecting SmartPlantA and SmartPlantB in this diagram is an edge definition that
goes between interface definitions realized by the two class definitions.
In many-to-one (M:1) mapping, map properties on related map class definitions map to one
SmartPlant class or interface definition. In the following diagram, the line connecting map class
B with map class F is a map edge definition.
In many-to-many (M:N) mapping, map properties on related map class definitions map to
property definitions on more than one class and/or interface definition.
See Also
Tool Map Schemas (on page 244)
Direct Mapping
The simplest mapping type is direct mapping. In direct mapping, only map properties for the
map class being mapped are used. Any generalized or realized map classes for the map class
are not used in the mapping.
For example, if direct mapping is used for map class E, shown in the following diagram, then
only property PE will be mappable. Properties on generalized map classes A, B, C and D will not
be included in the mapping.
Like mapping using generalized map classes, mapping involving realized map classes can
result in a map property for a map interface being mapped differently depending on the realizing
map class.
See Also
Tool Map Schemas (on page 244)
use for publish and retrieve. If the user selects a class definition or interface definition for the
mapping, the software determines if a view definition has been defined for mapping to this class
or interface definition. If an existing view definition is found that is suitable for defining mapping,
then that view definition will be used. If no view definition is found, then a view definition will be
dynamically generated.
The SmartPlant schema contains a small set of predefined view definitions that you can
use for mapping. However, not all objects for which you may want to define mapping have view
definitions defined in the schema. Dynamically generated view definitions may not be as helpful
as predefined view definitions for simplifying mapping.
The general approach for defining publish mapping using a view definition includes the following
steps:
For each application map property, find a corresponding view definition property and map
the application property to that view definition property.
When all application properties for which a corresponding view definition property was found
have been mapped, evaluate the remaining application properties and determine which, of
any, of those properties should still be mapped. For each application not mapped that should
be mapped, either create a new property definition and add it to the view definition or find an
existing property definition not in the view definition and add it to the view definition. In either
case, after adding the property to the view definition, map the application property to the
added view property.
After all map properties that should be mapped have been mapped, use the Set
Application Properties Not to be Mapped button to mark the rest of the application
properties as "not to be mapped" for publish and retrieve.
Evaluate the remaining view definition properties and determine if there are any view
definition properties for which an application map property should be created. Create a new
application property for each of these view properties (in some cases, the properties may
exist on a related application class, and mapping across a map edge definition may be used
instead of creating a new application property) and map that new application property to the
view property.
After all view properties that should be mapped have been mapped, use the Set
SmartPlant Properties Not to be Mapped button to mark the rest of the SmartPlant
view definition properties as "not to be mapped" for publish and retrieve.
See Also
Tool Map Schemas (on page 244)
The Publish Map and Retrieve Map buttons available from the Overview tab on the Edit
windows for map class definitions can be used to map directly against the SmartPlant schema.
For example, selecting the Publish Map button for a map class definition displays the following
window to allow mapping directly against the SmartPlant schema:
A similar window is available when you click the Retrieve Map button on the Edit window for a
map class definition.
UML diagram below. Notice the arrow going from map property PE on SPMapClassDef IE
(realized by SPMapClassDef E) to PropB on SmartPlantF. In this case, the one instance of E
maps to both SmartPlantA and SmartPlantF (that is, one application object maps to two
SmartPlant objects).
related map objects (E and F) are mapped to two related SmartPlant objects (SmartPlantA and
SmartPlantF). This is an example of a many-to-many mapping.
The Retrieve Map for Tool Class Definition window works similarly to the Publish Map for
Tool Class Definition window. The following example shows retrieve mapping for retrieving
from interface definition ISmartPlantA into map class definition E. The arrows represent
drag-and-drop operations that were performed to produce the displayed mapping. Note that the
Map Edge Def column for map properties PA, PB, PE, and PG is blank (because these are map
properties for the E map class), but the Map Edge Def column for PD shows the UID for map
edge definition IA2F.
The UML diagram below illustrates the many-to-many mapping shown in the previous retrieve
graphic:
See Also
Tool Map Schemas (on page 244)
If you select a node from the tree view on the left, the options on the right update accordingly.
For example, selecting the To be relocated node from the tree view looks like the following. The
MapEnumMapEnum relationship between To be relocated and Existing appears in the
Constrained by box.
Several buttons in this window can be used to create new map enumerations, including New
Child, New Sibling, and Import Clipboard Entries. If you create a new second level entry,
such as To be relocated, it should be related to the appropriate first level entry using the
Constrained by field.
This same form is used for map unit of measure lists. However, all map unit of measure
lists are one level. Therefore, the Constrains and Constrained by options should never be
used for map units of measure.
process very simple, you should use it only when there is no existing list in the SmartPlant
schema that can be used instead. Creating a new SmartPlant enumerated list when a suitable
one already exists introduces ambiguity into the SmartPlant schema.
The Publish Map, Retrieve Map, and Publish and Retrieve Maps buttons display separate
windows that can be used to define the mapping. All of these windows work by dragging a node
from a tree view on one side of the window and dropping it in the appropriate column of the table
on the other side of the window.
To establish a map relationship using the Publish Map for Tool Enumerated List window, you
can drag an enumeration from the SmartPlant schema tree control on the right and drop it in the
Enum column in the table for the appropriate map enumeration.
To create a map relationship using the Retrieve Map for Tool Enumerated List window, drag a
map enumeration from the tool schema tree on the right and drop it in the Map Enum column in
the table for the appropriate enumeration.
To create a publish map relationship using the Publish and Retrieve Maps for Tool
Enumerated List window, drag a map enumeration from the tool schema tree and drop it in the
From Map Enum column in the table. To create a retrieve map relationship, drag a map
enumeration from the tool schema tree and drop it in the To Map Enum column.
Selecting one or more rows from the bottom table and then clicking Unmap results in the
deletion of those map relationships.
See Also
Tool Map Schemas (on page 244)
Metadata adapters are authoring tool software that make two-way communication between the
Schema Editor and the authoring tools possible for mapping. Metadata adapters allow the
Schema Editor to connect to the tool database and synchronize the tool map schema with the
tool metadata by updating one or the other, depending on user selections. Metadata adapters
can be developed for third-party applications. For more information, see the SmartPlant
Metadata Adapter Reference Guide, delivered with the SmartPlant Foundation programming
documentation.
In previous releases, all authoring tools were required to add properties, enumerated lists, and
enumerated entries in the tool database, add them to the tool map schema and the SmartPlant
schema in the Schema Editor, and then map, each in separate steps. Metadata adapters
streamline the tool map schema extension and mapping work process.
For properties, enumerated lists, and enumerated entries, metadata adapters allow you to enter
the object in the authoring tool and have it automatically added to the tool map schema during
synchronization in the Schema Editor. You can also enter enumerated lists and their entries to
the tool map schema in the Schema Editor, and the metadata adapter automatically adds those
same objects to the metadata in the tool database. For more information, see Synchronize Tool
Metadata with the Tool Map Schema (on page 315).
Metadata adapters can simplify the process of editing tool map schemas by automatically
handling special requirements of the corresponding authoring tool adapter. For example, the
SmartPlant P&ID adapter requires that new enumerated list definitions have a UID of
SP_<Codelist_Index>, for example, SP_12001. The metadata adapter can supply this UID
automatically so that the user is not required to look up the codelist index in the Enumerations
database table for the SmartPlant P&ID Data Dictionary user in the SmartPlant P&ID database.
Metadata adapters also automatically locate the tool map schema on the file system, eliminating
the need for the user to specific the location.
SmartPlant 3D does not support adding properties to system-defined interfaces (also referred to
as packages). However, users can add new properties on existing interfaces in the user-defined
package.
Rules for Application Enumerations
Adding new enumerated lists (code lists) is supported in the tool.
Publish mapping is not required for enumerated lists (code lists) because the SmartPlant 3D
adapter maps automatically based on the enumerated list entry number. However, the
number must match in the SmartPlant schema, the SmartPlant 3D tool map schema, and
the tool metadata.
Rules for Application UoMs
Changes to SPMapUoMListDefs will only be made in the tool map schema
(SP3DPublishMap.xml). The tool database will not be updated with these changes.
Rules for Application Relationships
Adding and deleting SPMapRelDefs is supported in the tool. However, adding and deleting
SPMapRelDefs to certain objects defined in the system package are not allowed in the tool.
Rules for Application Edges
Any changes to SPMapEdgeDefs will only be made in the tool map schema
(SP3DPublishMap.xml). Tool database will not be updated with these changes.
schema. This is referred to as connected mode, which is currently required by all tool metadata
adapters.
For more information about connecting to SmartPlant Foundation and synchronizing tool map
schemas with tool metadata, see Synchronize Tool Metadata with the Tool Map Schema (on
page 315).
Selecting a tool from the Registered tool list displays whatever information has been defined
for that application.
Tool Object
If a Tool object exists for the application, then the Name for that Tool object appears under Tool
object. If the Tool object does not exist, you can create one by clicking Create button under
Tool object to display the Edit Tool Definition dialog box.
If the Tool object already exists for the specified application, the progID specified for the
metadata adapter is used to activate the specified DLL/software class. Alternatively, if the user
creates a Tool object for the specified application, the software attempts to activate the
metadata adapter when the user clicks OK.
If the metadata adapter is successfully activated, the Status text under Metadata adapter in the
Define Tool/Map Schema dialog box reflects that the metadata adapter has been activated. If
the specified metadata adapter cannnot be activated, then an error message appears, and the
Status text reflects this failure.
ToolSchema Object
If the Tool object is related to one or more ToolSchema objects, then the Name list under
ToolSchema in the Define Tool/Map Schema dialog box lists these ToolSchema objects.
Selecting one of these objects activates the Edit button, and, if the map schema for that
application has been loaded, the software attempts to locate the SPMapSoftware object that is
related to the ToolSchema object.
If no ToolSchema object exists, then the Create button can be used to create the ToolSchema
object in the Edit Tool Schema Definition dialog box.
SPMapSoftware Object
To determine if the SPMapSoftware object exists, you can use the File > SmartPlant > Edit
Engineering Tool Options command and select the desired application. When you click Finish
after synchronization is completed, Map Environment that appears should include the selected
application in the tree view. If expanding this application in the tree view in the Map
Environment fails to show the data for that application, then the SPMapSoftware object is
missing and needs to be created.
To create the missing SPMapSoftware object, click Create under MapSoftware in the Define
Tool/Map Schema dialog box. The dialog box for creating/editing the SPMapSoftware object is
shown in the following graphic:
The Schema Editor, when working with application metadata adapters, relies on the version
supported information in the SPMapSoftware object. If the SPMapSoftware object for a given
application doesn't indicate support for the version of the schema being used, then a message
will be displayed to the user warning him about proceeding.
See Also
Tool Map Schemas (on page 244)
For every difference detected between the application's metadata and the tool map schema file,
a row is displayed in this form. The Class column shows the class for the difference. The Parent
Name column identifies the parent object's name. For map enumerations, the parent object is
the map enumerated list. For map units of measure, the parent object is the map unit of
measure list, and for map properties, the parent object is the map class. For all other map
objects, this column is blank.
The Name column shows the name of the object with the difference. If the difference is in a
particular property value for the object, then the Property column shows the particular property
that is different.
The <Tool> Database and <Tool Map Schema Path> columns show the particular actions that
can be taken to eliminate the difference. Eliminating all differences results in the application's
metadata and tool schema file being "synchronized". When the Synchronize dialog box
appears, one of the two columns for each row is automatically selected. This is the default
action that the software takes to eliminate the difference. The application's metadata adapter
specifies the default actions for that application. Most of the time the software automatically
selects the option in the <Tool Map Schema Path> column to eliminate the difference. You can
change the action to be taken to eliminate the difference by selecting the other column for a
particular row. However, changes that are not allowed by the metadata adapter result in an error
message and are prevented by the software.
When the appropriate changes are selected to eliminate the differences, you can click OK. The
software performs the various actions that have been selected. You are not currently allowed to
cancel synchronization.
For more information about synchronizing tool map schemas with tool metadata, see
Synchronize Tool Metadata with the Tool Map Schema (on page 315).
The File > SmartPlant > Compare (Active Tool Schema) With Schema command determines
the map classes, map enumerated lists, and map unit of measure lists that have not been fully
mapped (those that still have one or more unmapped objects that haven't been flagged as not to
be mapped). These incompletely mapped objects appear in the View Comparison Results
window.
When you expand one of the nodes in the View Comparison Results tree view, the objects of
the selected type that have not been mapped at all appear in red, and those objects that have
been partially mapped appear as blue. Selecting one of these objects display its Edit Form tab
on the right side of the View Comparison Results window. You can use this tab to complete
the mapping for that object.
When an object is completely mapped, the software removes it from the tree view in the View
Comparison Results window. When all map objects have been fully mapped, the comparison
should result in an empty tree view. Therefore, using comparison is a good way to track the
progress of the publish mapping process.
After all the mapping has been completed for an application, only changes made in the
application or changes made by another application that impact the application should impact
the mapping. Changes made in this application can readily be resolved by connecting to
SmartPlant Foundation and synchronizing the tool map schema with the tool metadata
database.
For more information about comparing tool map schemas with the SmartPlant schema, see
Compare a Tool Map Schema to the SmartPlant Schema (on page 358).
See Also
Tool Map Schemas (on page 244)
Not all authoring tools externalize all of their mapping in tool map schemas or map files.
Some mapping may be defined in the authoring tool adapter code. This kind of mapping
does not appear in mapping spreadsheets generated in the Schema Editor.
Spreadsheets containing the out-of-the-box mapping for the current releases of the
authoring tools are delivered with the SmartPlant Foundation software. You can open the
spreadsheets from SmartPlant Foundation by clicking Help > Printable Guides in the
SmartPlant Foundation client or administration software, and then clicking the SmartPlant
Enterprise Mapping Spreadsheets link to download the .zip file containing the Excel
spreadsheets.
You can also download these spreadsheets from the Intergraph Process, Power & Marine
eCustomer Web site. To download the spreadsheets, browse to the following Web address,
and type your eCustomer user name and password: http://crmweb.intergraph.com
(http://crmweb.intergraph.com/ecustomer_enu). Click Download Software Updates >
Products > SmartPlant Foundation > Technical Notes and Documentation, and then
click the link to the mapping spreadsheets to download them to your computer.
See Also
View Tool-to-SmartPlant Mapping in a Viewable UML View (on page 290)
View Tool-to-Tool Mapping in a Editable UML View (on page 294)
View Tool-to-Tool Mapping for Enumerated Lists (on page 299)
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
View Tool-to-Tool Mapping for Units of Measure (on page 302)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click View > Tool Schema.
3. Click Options on the View Schema dialog box.
4. On the View tab, click Tree/UML, and click OK.
To view the mapping for a tool class, expand the SPMapClassDef node in the tree
view, and then click the class for which you want to view mapping.
Under the class in the UML view, you can see a list of the tool map properties for the
class.
To the right of the map properties, you can see the classes and properties in the
SmartPlant schema to which those properties are mapped for publish.
If the tool map schema contains retrieve mapping for the map properties, the
SmartPlant schema properties that map to the tool properties on retrieve appear on the
left side of the UML view.
5. To see how a particular SmartPlant schema property maps to and from the various tools,
you can click the property in the UML view.
For example, clicking the NominalDiameter property in the previous example displays the
following UML:
6. To see the complete mapping for the SmartPlant property in another UML view, click the
Mapping button.
For example, the following property map shows the mapping associated with the
NominalDiameter property in the SmartPlant P&ID map file.
For each tool property that maps to or is mapped to by the selected SmartPlant
property, the name of the tool property appears on a button on the left side of the UML
view.
The ID for the tool class, if applicable, appears above the button. For example, the
NominalDiameter property in the SmartPlant schema maps to Nominal Diameter from a
variety of SmartPlant P&ID classes.
If multiple tool map schemas are open in the Schema Editor, you can also see how the
property is mapped to and maps from other authoring tools.
7. To see the mapping for an individual tool property, expand the MapProperties node under
the appropriate class definition, and then click the property in the tree view.
The UML view that you see when you click a property may be different depending on
the type of mapping that was used (for example, direct mapping, mapping using realized
classes, or mapping using specialization). However, for each type of mapping, the UML view
shows the property for each tool class, where applicable, and how the property is mapped to
from the SmartPlant schema and how the property maps to the SmartPlant schema.
8. To view the mapping for a SmartPlant interface or class, click the interface or class in the
tree or UML view, and then click Mapping.
9. To see the full mapping for the class or interface, click the Mapping button in the UML view.
10. To go back to the last UML view, click Back on the toolbar.
11. If you browse back to a previous view, click Next to see the next UML view.
12. To select a particular UML view that you have recently viewed, click the name of the view
that you want to see in the view list.
13. To move through the view list, use the Up and Down buttons on the toolbar.
See Also
View Tool-to-Tool Mapping in a Editable UML View (on page 294)
View Tool-to-Tool Mapping for Enumerated Lists (on page 299)
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
View Tool-to-Tool Mapping for Units of Measure (on page 302)
Viewing Authoring Tool Mapping (on page 289)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. In the Map Environment, expand the Tool node, and then expand the node for the
authoring tool for which you want to view mapping.
3. Under the authoring tool node for the second authoring tool in the tree view, expand Loaded
Map Schemas and the <Authoring Tool> Tool Schema node to display contents of the
authoring tool map schema.
5. Drag and drop the map class definition onto the Editable UML tab to see how it maps to the
other tool's map class definition.
Dragging a map class from another application and dropping it on the Editable UML
tab adds the map class to the diagram. If there is a data pathway or, in some cases, two
pathways between the map classes, the software adds an arrow connector between the two
map classes.
6. Continue dragging and dropping map class definitions from authoring tools to see mapping
among them.
Adding the InstrumentInline map class into this diagram resulted in two connectors
being added to the diagram. The connector from InstrumentInline to the SmartPlant
Electrical Instrument map class definition represents a valid point-to-point data pathway.
The arrow between the SmartPlant P&ID Instrument map class and the InstrumentInline
map class represents a data pathway that, based on the mapping defined in the map
schema, is a potential data pathway, but in actuality is not valid because an application will
not be retrieving data from one of its map classes into another of its map classes.
7. To view point-to-point mapping for two map class definitions in a tabular view, click + on the
connector between the two map class definitions. The Show Mapping Between Classes
window appears with the two map class definitions populated based on the chosen
connector.
For example, click + on the connector between the SmartPlant Electrical Instrument map
class and the SmartPlant P&ID Instrument map class displays the following window:
You can sort the mapping and export it to an Excel spreadsheet from this window.
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
Export Tool Mapping to a Spreadsheet (on page 305)
See Also
View Tool-to-SmartPlant Mapping in a Viewable UML View (on page 290)
View Tool-to-Tool Mapping for Enumerated Lists (on page 299)
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
View Tool-to-Tool Mapping for Units of Measure (on page 302)
Viewing Authoring Tool Mapping (on page 289)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click Tools > Another Tool Schema > Show Mapping Between Classes.
You can also click the Another Tool Schema File button in the Workflows dialog box
to view mapping between tools.
You can also open the Show Mapping Between Classes window by clicking + on the
connector between two map class definitions on the Drag/Drop UML tab in the Map
Environment.
3. Under From, select the tool map schema from which you want to see mapping in the Tool
schema container list.
You can select the "to" information followed by the "from" information. Alternatively,
you can also begin in the middle with the class definition and then select the two tool
classes.
4. In the Tool class list, select the authoring tool class for which you want to view mapping.
If the tool class is specialized by another class definition, you can select the
specialization for which you want to view mapping in the Is specialized by list.
5. If the selected class definition maps to multiple class definitions in the SmartPlant schema,
click the SmartPlant class definition for which you want to view mapping in the Class
definition list.
If the selected tool class only maps to a single class definition in the SmartPlant
schema, the class definition is automatically selected by default in the Class definition
list.
If the publish mapping for the map class is to an interface definition, then all class
definitions that realize that interface definition appear in the list for the class definition.
6. Under To, select the tool map schema that you want to see how the selected schema maps
to in the Tool schema container list.
7. In the Tool class list, select the tool class that you want to see mapping to.
The properties for the selected class appear in the table at the bottom of the Show
Mapping Between Classes window.
If the tool class is specialized by another class definition, you can select the
specialization for which you want to view mapping in the Is specialized by list.
At the left of this control are the tool (map) classes and tool (map) properties. The
middle two columns show the SmartPlant class definition selected and the SmartPlant
property definitions for that class definition (via the realized interface definitions). Where
a "from" map property appears in the same row as a SmartPlant property, there is a
mapping relationship between the tool (map) property and the SmartPlant property.
The rightmost two columns show the "to" tool (map) class and the "to" tool (map)
property. As before, wherever a SmartPlant property and a "to" map property exist on
the same row, there is a map relationship between the property and map property.
For cases where a "from" map property and a "to" map property exist in the same row,
there is a point-to-point mapping between the two (via the SmartPlant property in the
middle).
8. To view properties that map across the selected tool map schemas at the top of the table,
click Move Pt -> Pt to Top.
Not all authoring tools externalize all of their mapping in tool map schemas or map files.
Some mapping may be defined in the authoring tool adapter code. This kind of mapping
does not appear in mapping spreadsheets generated in the Schema Editor.
To generate a spreadsheet containing the mapping, click Create Spreadsheet. For more
information about creating mapping spreadsheets, see Export Tool Mapping to a
Spreadsheet (on page 305).
The table in the Show Mapping Between Classes window helps you see how properties
map across tools. The columns in the table include:
Tool Class/Map Edge - Displays the selected class definition or edge definition in the
tool map schema you are viewing mapping from.
Tool Property - Displays the properties for the class definition defined in the tool map
schema you are viewing mapping from.
SmartPlant ClassDef/EdgeDef - Displays the class definition or edge definition in the
SmartPlant schema that is mapped to by the selected class definition or edge definition
in the tool map schema you are viewing mapping from.
SmartPlant PropertyDef - Displays the property definition in the SmartPlant schema for
the class definition (via the realized interface definitions) in the SmartPlant
ClassDef/EdgeDef column.
Tool Property - Displays the properties for the class definition defined in the tool map
schema you are viewing mapping to.
Tool Class/Map Edge - Displays the selected class definition or edge definition in the
tool map schema you are viewing mapping to.
If a SmartPlant property and a "to" map property exist on the same row in the Show
Mapping Between Classes table, there is a map relationship between the property and
map property. If a "from" map property and a "to" map property exist in the same row, there
is a point-to-point mapping between the two (via the SmartPlant property in the middle).
See Also
View Tool-to-SmartPlant Mapping in a Viewable UML View (on page 290)
View Tool-to-Tool Mapping in a Editable UML View (on page 294)
View Tool-to-Tool Mapping for Enumerated Lists (on page 299)
View Tool-to-Tool Mapping for Units of Measure (on page 302)
Viewing Authoring Tool Mapping (on page 289)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click Tools > Another Tool Schema > Show Mapping Between Enum Lists.
You can also click the Another Tool Schema File button in the Workflows dialog box
to view mapping between tools.
3. Under From, select the tool map schema from which you want to see mapping in the Tool
schema container list.
4. In the Tool enumerated list box, select the authoring tool enumerated list for which you
want to view mapping.
5. Under To, select the tool map schema that you want to see how the selected schema maps
to in the Tool schema container list.
6. In the Tool enumerated list box, select the tool list that you want to see mapping to.
The enumerated lists from each tool map schema and the SmartPlant schema appear in the
Show Mapping Between Enumerated Lists window. You can see how the enumerated
lists map across tools in the table at the bottom of the window.
7. To view the entire enumerated list in one of the tools or the SmartPlant schema, expand the
list in the appropriate tree view.
8. To view the mapping for a particular enumerated list entry, click the list entry in the tree view
to highlight its mapping in the table and the other tree views.
Not all authoring tools externalize all of their mapping in tool map schemas or map files.
Some mapping may be defined in the authoring tool adapter code. This kind of mapping
does not appear in mapping spreadsheets generated in the Schema Editor.
To generate a spreadsheet containing the mapping, click Create Spreadsheet. For more
information about creating mapping spreadsheets, see Export Tool Mapping to a
Spreadsheet (on page 305).
The table in the Show Mapping Between Enumerated Lists window helps you see how
properties map across tools. The columns in the table include:
Tool Enum List - Displays the selected enumerated list in the tool map schema you are
viewing mapping from.
Tool Enum - Displays the enumerated list entry from the selected enumerated list
defined in the tool map schema you are viewing mapping from.
SmartPlant Enum List - Displays the enumerated list type in the SmartPlant schema
that is mapped to by the selected enumerated list in the tool map schema you are
viewing mapping from.
SmartPlant Enum - Displays the enumerated list entry in the SmartPlant schema that is
mapped to by the enumerated list entry in the tool map schema.
Tool Enum - Displays the enumerated list entry defined in the tool map schema you are
viewing mapping to.
Tool Enum - Displays the selected enumerated list in the tool map schema you are
viewing mapping to.
If a SmartPlant enumeration and a "to" enumeration exist on the same row in the Show
Mapping Between Enumerated Lists table, there is a map relationship between the
enumeration and map enumeration. If a "from" map enumeration and a "to" map
enumeration exist in the same row, there is a point-to-point mapping between the two (via
the SmartPlant enumeration in the middle).
See Also
View Tool-to-SmartPlant Mapping in a Viewable UML View (on page 290)
View Tool-to-Tool Mapping in a Editable UML View (on page 294)
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
View Tool-to-Tool Mapping for Units of Measure (on page 302)
Viewing Authoring Tool Mapping (on page 289)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click Tools > Another Tool Schema > Show Mapping Between UoM Lists.
You can also click the Another Tool Schema File button in the Workflows dialog box
to view mapping between tools.
3. Under From, select the tool map schema from which you want to see mapping in the Tool
schema container list.
4. In the Tool UoM list box, select the authoring tool's unit of measure list for which you want
to view mapping.
5. Under To, select the tool map schema that you want to see how the selected schema maps
to in the Tool schema container list.
6. In the Tool UoM list box, select the tool list that you want to see mapping to.
The UoM lists from each tool map schema and the SmartPlant schema appear in the Show
Mapping Between UoM Lists window. You can see how the UoMs map across tools in the
table at the bottom of the window.
7. To view the entire UoM list in one of the tools or the SmartPlant schema, expand the list in
the appropriate tree view.
8. To view the mapping for a particular UoM, click the UoM in the tree view to highlight its
mapping in the table and the other tree views.
Not all authoring tools externalize all of their mapping in tool map schemas or map files.
Some mapping may be defined in the authoring tool adapter code. This kind of mapping
does not appear in mapping spreadsheets generated in the Schema Editor.
To generate a spreadsheet containing the mapping, click Create Spreadsheet. For more
information about creating mapping spreadsheets, see Export Tool Mapping to a
Spreadsheet (on page 305).
The table in the Show Mapping Between UoMs window helps you see how properties map
across tools. The columns in the table include:
Tool UoM List - Displays the selected UoM list in the tool map schema you are viewing
mapping from.
Tool UoM - Displays the UoM list entry from the selected UoM list defined in the tool
map schema you are viewing mapping from.
SmartPlant UoM List - Displays the UoM list type in the SmartPlant schema is mapped
to by the selected UoM list in the tool map schema you are viewing mapping from.
SmartPlant UoM - Displays the UoM list entry in the SmartPlant schema that is mapped
to by the UoM list entry in the tool map schema.
Tool UoM - Displays the UoM list entry defined in the tool map schema you are viewing
mapping to.
Tool UoM List - Displays the selected UoM list in the tool map schema you are viewing
mapping to.
If a SmartPlant enumeration and a "to" UoM exist on the same row in the Show Mapping
Between Enumerated Lists table, there is a map relationship between the UoM and map
UoM. If a "from" map UoM and a "to" map UoM exist in the same row, there is a
point-to-point mapping between the two (via the SmartPlant UoM in the middle).
See Also
View Tool-to-SmartPlant Mapping in a Viewable UML View (on page 290)
View Tool-to-Tool Mapping in a Editable UML View (on page 294)
View Tool-to-Tool Mapping for Enumerated Lists (on page 299)
View Tool-to-Tool Mapping for Classes and Properties (on page 297)
Viewing Authoring Tool Mapping (on page 289)
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click Tools > Another Tool Schema and then click the type of mapping that you want to
export. For example, to export enumerated list mapping, click Tools > Another Tool
Schema > Show Mapping Between Enum Lists.
You can also click the Another Tool Schema File button in the Workflows dialog box
to view and export mapping between tools.
3. Under From, select the tool map schema from which you want to see mapping and the
class definition, UoM list, or enumerated list for which you want to export mapping.
4. If the selected class definition, UoM, or enumerated list maps to multiple class definitions in
the SmartPlant schema, click the SmartPlant object for which you want to view mapping in
the Class definition list.
If the selected object only maps to a single class definition in the SmartPlant schema,
the class definition is automatically selected by default in the Class definition list.
5. Under To, select the tool map schema and the class definition, UoM list, or enumerated list
that you want to see how the selected schema maps to.
6. In the Name spreadsheet using list, select the type of object that you want to use to name
the mapping spreadsheet. For example, for a class definition spreadsheet, you can choose
to name the spreadsheet using the class definition name in the SmartPlant schema, the
class definition you are viewing mapping from, or the class definition you are viewing
mapping to.
7. Click Create Spreadsheet.
8. In the Update Spreadsheet File dialog box, type the name of a new Excel workbook or
browse to an existing workbook, and click Open.
If you select an existing Excel workbook, the new mapping spreadsheet is added as a
new tab in the existing workbook.
9. To view the spreadsheet, browse to the location where you saved the workbook, and
double-click the file to open it in Excel.
The columns in the spreadsheet correspond to the columns in the table in the Show
Mapping Between Classes, Show Mapping Between UoMs, and Show Mapping
Between Enumerated Lists windows. For more information, see View Tool-to-Tool
Mapping for Classes and Properties (on page 297), View Tool-to-Tool Mapping for Units of
Measure (on page 302), or View Tool-to-Tool Mapping for Enumerated Lists (on page 299).
You can download spreadsheets containing the latest authoring tool mapping for the
current releases of the authoring tools from the Intergraph Process, Power & Marine eCustomer
Web site. To download the spreadsheets, browse to the following Web address, and type your
eCustomer user name and password: http://crmweb.intergraph.com/ecustomer_enu
(http://crmweb.intergraph.com/ecustomer_enu). Click Download Software Updates >
Products > SmartPlant Foundation > Technical Notes and Documentation, and then click
the link to the mapping data sheets to download them to your computer.
See Also
Viewing Authoring Tool Mapping (on page 289)
Mapping for map enumerated lists or map UoM lists is defined from the map enumerated list or
map UoM list. All mapping for enumerated lists and UoM lists is one-to-one.
The authoring tool adapter determines the objects that you can add to your authoring tool
map schema and then map for publish and retrieve. For more information, see rules for your
authoring tool in the SmartPlant Mapping User's Guide or the tool documentation.
Understanding Mapping
Before you begin defining authoring tool mapping, you must understand the following:
The SmartPlant schema model and how it works. For more information, see SmartPlant
Schema Overview (on page 19) and A Gentle Introduction to the SmartPlant Schema,
delivered with SmartPlant Foundation.
How tool map schemas work and how they are used by the authoring tools. For more
information, see Tool Map Schemas (on page 244).
The authoring tool data model for which you are defining mapping. For more information,
see your authoring tool documentation.
The delivered tool map schema and mapping for the authoring tool. For more information
see Viewing Authoring Tool Mapping (on page 289) and rules for your authoring tool in the
SmartPlant Mapping User's Guide or the tool documentation.
To do mapping using an authoring tool's metadata adapter, that authoring tool must also be
registered with the appropriate SmartPlant Foundation plant.
This approach is most useful when you have existing metadata in the authoring tool that needs
to be entered in the SmartPlant schema and mapped. Intergraph recommends starting in the
authoring tool when you define new properties so that the property definition fits into the
authoring tool's data model appropriately.
Connecting to SmartPlant
Check out the SmartPlant schema CMF file from the SmartPlant Foundation Desktop Client.
Right-click the new revision of the CMF file in SmartPlant Foundation, and click Launch
Schema Editor. This provides the Schema Editor with the appropriate plant and SmartPlant
Foundation site for connection.
Select the schema version or versions in which you want to make modifications in the
Active Configurations dialog box. For example, to modify the 2008 schema, select the
2008 configuration for new objects.
By default, both the 2007 and 2008 configurations are checked to allow forwards and
backwards compatibility between schema versions when creating new objects or modifying
existing objects.
Opening the CMF file also allows you to see which authoring tools that are registered with the
SmartPlant Foundation plant have available metadata adapters.
synchronization process is required before you load the tool map schema to begin mapping in
the Schema Editor.
Defining Mapping Between the Tool Map Schema and the SmartPlant Schema
After you define the objects that you want to map in the tool map schema and the SmartPlant
schema, you can define the publish and retrieve mapping for those objects. Objects can have
different mapping defined for publish and retrieve.
Some authoring tools may have additional steps for performing the mapping between the
authoring tool and the SmartPlant schema. For mapping rules for each authoring tool, see rules
for your authoring tool in the SmartPlant Mapping User's Guide or the tool documentation.
Resolving Differences between the Tool Map Schema and the SmartPlant Schema
For those objects that appear in blue in the View Comparison Results window, you can
resolve these differences by double-clicking the node in the tree view to display the Map
Environment. You can use the Publish and Retrieve tabs in the Map Environment to resolve
differences by doing the following:
Adding objects to tool map schema and metadata using the toolbar on the left side of the tab
Mapping between the tool and SmartPlant schema by selecting objects on both sides of the
dialog box and clicking the Map button in the middle of the tab.
Defining properties that you do not want to map, which means that you do not want them to
show up in the Unmapped application properties or the Unmapped SmartPlant properties
tables on the Publish and Retrieve tabs
Defining properties that you want to ignore during mapping, which can be used for internal
application properties that are not required for mapping and that should not be synchronized
in the tool map schema
You can also switch between authoring tools for comparison to make adding objects to the tool
schema and metadata easier by loading multiple tool map schemas using the File > SmartPlant
> Edit Engineering Tool Options and then setting another tool map schema as the active
schema file.
You can repeat this process for each integrated authoring tool to propagate the change you
made for one tool into all the other authoring tools for which the change is relevant.
2. In the Schema Editor, click File > SmartPlant > Edit Engineering Tool Options.
A message box appears if authoring tools without metadata adapters are registered
with the SmartPlant Foundation plant. Mapping for these authoring tools can be defined by
opening their tool map schemas.
3. Under Engineering application/map schema, select the authoring tool and tool map
schema that you want to work with in the Schema Editor.
You can load multiple tool map schemas and metadata by repeating steps 2 and 3 for
each authoring tool.
The authoring tool that you want to define mapping for must be registered with the
SmartPlant Foundation site and plant from which you checked out the SmartPlant
schema CMF file to appear in the Engineering application/map schema list.
4. Under Startup options, select the Load map schema check box.
The software automatically selects the Connect to application schema check box because
the SmartPlant authoring tools do not currently support working in disconnected mode with
metadata adapters. In a future release, disconnected mode will allow users to modify the
tool map schema without connecting to the tool's metadata adapter, which means that no
synchronization will occur.
For specific details about what types of objects that you can edit in the authoring tool
via the metadata adapter and how save works for the tool's metadata adapter, select a tool
and then click the Details button.
5. To synchronize additional tool schemas at the same time, repeat steps 4-5 for each
authoring tool that you want to synchronize.
6. Click Finish to review synchronization details in the Synchronize dialog box.
Connecting to the metadata adapter and generating a comparison of the tool metadata
and the tool map schema can be a time consuming task, depending on your computer
memory and processor speed.
When you click Finish, the Schema Editor generates a tool schema from the tool
metadata in the tool database and compares it to the tool map schema file.
If no changes have been made to the authoring tool metadata or the tool map schema
since you installed the software, there may no differences to synchronize.
Once you are familiar with synchronization and the default actions for the authoring tool
you are working with, you may want to select the Automatically synchronize schemas
check box before you click Finish to avoid reviewing synchronization results every time
you load a tool map schema and tool metadata.
7. In the Synchronize dialog box, select the appropriate action in the <Tool> Database or
<Tool Map Schema Path> column in the appropriate row for the change to update
inconsistencies between the tool metadata and tool map schema. Default actions appear in
blue in the appropriate column and row for each difference.
Some applications do not support both possible synchronization actions that appear in
the Synchronization dialog box. For example, SmartPlant P&ID does not support
deleting existing properties or enumerated lists. If properties exist in the SmartPlant
P&ID tool metadata that are not in the tool map schema, then the missing properties
must be added to the tool map schema. They cannot be deleted from the tool metadata
database.
If you select a synchronization action that is not supported by the selected authoring
tool, the Schema Editor displays a message box to let you know that the action is not
supported.
You can export the synchronize instructions to Microsoft Excel by clicking Save to
Excel. Saving to a spreadsheet allows you to sort, filter, and share synchronization
information.
8. Click OK to synchronize the tool map schema and tool metadata.
If you selected more than one tool map schema to synchronize, repeat steps 7-8 for
each authoring tool that you selected.
After you synchronize the last tool map schema, the Map Environment appears.
See Also
Synchronize Dialog Box (on page 318)
Configuration Managed Files (CMFs) (on page 83)
Change the description of the 3-way fire hydrant in the tool map schema from "6Q4C13" to
"3-way ball valve" to match the value currently defined in the tool metadata database
Save Extensions - Saves the meta schema extensions added by the metadata adapter to an
XML file.
Save Metadata - Saves metadata to an XML file.
Save to Excel - Saves the contents of the Synchronize dialog box to a Microsoft Excel
spreadsheet.
In This Section
Create and Map New Enumerated List Entries Starting in the Tool 319
Create and Map New String Properties Starting in the Tool ......... 322
Create and Map New Properties with Enumerated Lists Starting in the Tool 325
Automatically Create and Map New Enumerated Entries Created in the Tool 331
Automatically Create and Map New Properties Created in the Tool 334
Automatically Correlate New Tool Map Objects with Schema Objects 337
Automatically Correlate a Tool Enumerated List with a Schema Enumerated List 339
Create and Map New Enumerated List Entries Starting in the Tool
The following procedure applies to authoring tools that have metadata adapters.
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Load the Tool Map Schema and Open the Map Enumerated List
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new enumerated list entry that you added in the authoring tool appears in the
Synchronization dialog box to be added to the tool map schema file.
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
5. Expand the Map Enumerated List node and double-click the map enumerated list to which
you added the new list entry.
3. In the New Enumerated Entry dialog box, type the name and long description for the new
enumerated list entry, and click OK.
The Schema Editor automatically fills in the appropriate number for the enumerated list
entry.
When you click OK, the new list entry appears in the Unmapped SmartPlant
enumerations table in the Edit Map Enumerated List Definition dialog box.
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Enumerated List Definition dialog box.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
Load the Tool Map Schema and Open a Map Class Definition
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new property that you added in the authoring tool appears in the Synchronization
dialog box to be added to the tool map schema file.
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
5. Expand the Map Classes node and double-click the map class definition to which you
added the new property.
3. In the New Property Definition dialog box, define the new SmartPlant schema property,
and click OK to create the property definition.
Create a Property Definition (on page 194)
In the Scoped by property type box, be sure to select string as the property type for
the new string property.
When you click OK, the new property appears in the Unmapped SmartPlant
properties table in the Edit Map Class Definition dialog box.
2. In the Unmapped SmartPlant properties table, select the SmartPlant property definition
that you want to map.
3. On the toolbar, click Map .
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Class Definition dialog box.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
Create and Map New Properties with Enumerated Lists Starting in the Tool
The following procedure applies to authoring tools that have metadata adapters.
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Create the Enumerated List, List Entries, and Property in the Authoring Tool
Use the appropriate authoring tool software to add new enumerated list, enumerated list
entries, and property that uses the enumerated list to the authoring tool metadata database.
Be sure to set the data type to string for a string property.
For example, for SmartPlant P&ID or SmartPlant Electrical, create a new select list, add
entries to the select list, and then create a property associated with the new select list in the
appropriate database table in Data Dictionary Manager. The new property should have a
data type of select list and a relationship to the select list that you created.
Terminology for enumerated lists differs from tool-to-tool. Some authoring tools call
enumerated lists select lists, picklists, codelists, or lookup tables. For more information, see
the documentation for the authoring tool for which you want to add metadata.
Load the Tool Map Schema and Open a Map Class Definition
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new property, enumerated list, and list entries that you added in the authoring tool
appear in the Synchronization dialog box to be added to the tool map schema file. As you
can see in the following graphic, if you add a property to the Plant Item table in Data
Dictionary Manager for SmartPlant P&ID, multiple map classes inherit that property, and
therefore, multiple map classes are updated in the tool map schema during synchronize.
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
2. In the Edit Map Enumerated List Definition dialog box, click the Advanced tab.
The enumerated list and entries that you created in the authoring tool appear in the Map
enumerated list definition tree on the Advanced tab.
3. To create the equivalent list in the SmartPlant schema, click New SmartPlant Enumerated
List with Correlated Entries.
4. Review the new SmartPlant schema enumerated list and entries in the Created Enumerated
List and Entries dialog box, and then click OK to create the enumerated list.
You can right-click the list or list entries to make changes before you save the list and its
entries in your schema extensions file.
The software creates the SmartPlant enumerated list definition and creates the publish
map for the authoring tool map enumerated list definition and entries to the new
enumerated list definition and entries in the SmartPlant schema.
5. Click OK in the Edit Map Enumerated List Definition dialog box.
When you define the SmartPlant schema enumerated list for retrieve, the Retrieve tab
becomes available.
3. In the Unmapped application enumerations table, select the tool map enumerated list
entry that you want to map.
4. In the Unmapped SmartPlant enumerations table, select the SmartPlant enumerated list
entry that you want to map.
5. On the toolbar, click Map .
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
6. Repeat steps 3-5 for each enumerated list entry in the tool map enumerated list definition.
7. Click OK in the New Map Enumerated List Definition dialog box.
2. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
3. To add a new property, expand the Map Classes node, and double-click the tool map class
to which you want to add the new property.
4. If you want to start by defining publish mapping for the new property, click the Publish tab.
If you only want to define retrieve mapping for the enumerated property, you can click the
Retrieve tab instead. The procedure for adding properties and mapping is the same for both
tabs.
5. Above Unmapped SmartPlant properties on the right side of the dialog box, click New
Property Definition on the toolbar.
6. In the New Property Definition dialog box, define the new SmartPlant schema property,
and click OK to create the property definition.
By default, the Schema Editor defines the interface definition that exposes the selected
property definition based on the tool map class definition you selected. However, the
default is only a suggestion based on context, and you can change the interface
definitions that expose this property definition in the Exposed by interface definitions
box.
In the Scoped by property type box, be sure to select the new enumerated list you
created previously as the property type for the new property.
When you click OK, the new property appears in the Unmapped SmartPlant
properties table in the Edit Map Class Definition dialog box.
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Class Definition dialog box.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
Load the Tool Map Schema and Open the Map Enumerated List
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new enumerated list entry that you added in the authoring tool appears in the
Synchronization dialog box to be added to the tool map schema file.
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
5. Expand the Map Enumerated List node and double-click the map enumerated list to which
you added the new list entry.
2. Under Unmapped application enumerations, select the tool map enumerations that you
want to create in the SmartPlant schema and map, and then click Create and map
enumerations on the toolbar.
3. In the Create and Map Enumerations dialog box, review the auto creation and mapping
information, and click OK to create and map the enumerated list entries.
4. Click OK in the Edit Map Enumerations dialog box to save your changes.
Create the Enumerated List, List Entries, and Property in the Authoring Tool
Use the appropriate authoring tool software to add new enumerated list, enumerated list
entries, and property that uses the enumerated list to the authoring tool metadata database.
Be sure to set the data type to string for a string property.
For example, for SmartPlant P&ID or SmartPlant Electrical, create a new select list, add
entries to the select list, and then create a property associated with the new select list in the
appropriate database table in Data Dictionary Manager. The new property should have a
data type of select list and a relationship to the select list that you created.
Terminology for enumerated lists differs from tool-to-tool. Some authoring tools call
enumerated lists select lists, picklists, codelists, or lookup tables. For more information, see
the documentation for the authoring tool for which you want to add metadata.
Load the Tool Map Schema and Open a Map Class Definition
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new property, enumerated list, and list entries that you added in the authoring tool
appear in the Synchronization dialog box to be added to the tool map schema file. As you
can see in the following graphic, if you add a property to the Plant Item table in Data
Dictionary Manager for SmartPlant P&ID, multiple map classes inherit that property, and
therefore, multiple map classes are updated in the tool map schema during synchronize.
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
3. In the Create and Map Properties dialog box, review the auto creation and mapping
information, and click OK to create and map the properties.
4. Click OK in the Edit Map Class Definition dialog box to save your changes.
5. Expand the Map Classes, Map Enumerated Lists, or Map UoM Lists node and
double-click the object that you want to automatically correlate with an existing object in the
SmartPlant schema.
6. Click the Publish or Retrieve tab.
7. In the Unmapped table on the left, select the map properties, map enumerations, or map
UoMs that you want the software to automatically correlate and map with existing
SmartPlant schema objects, and click Auto-map .
8. In the Correlate dialog box, review the proposed matches in the SmartPlant schema, and
select one to map.
9. Click Correlate to map the tool schema object to the selected SmartPlant schema object.
4. On the Advanced tab, click AutoCorrelate. The entries in the map enumerated list are
auto-correlated with the entries from the mapped-to enumerated list.
The Auto-Correlate Enumerations dialog box displays all possible relationships for publish
or retrieve that can be created.
5. In either the Create Publish Relationship or Create Retrieve Relationship, click in the
cell and select Create, Don't Create, or "-".
To set all publish relationships to Don't Create, click Clear All Publish Relationships.
To set all retrieve relationships to Don't Create, click Clear All Retrieve Relationships.
In This Section
Create and Map New Enumerated List Entries Starting in the SmartPlant Schema 342
Create and Map New String Properties Starting in the SmartPlant Schema 346
Create and Map New Properties with Enumerated Lists Starting in the SmartPlant Schema 350
Compare a Tool Map Schema to the SmartPlant Schema ........... 358
Create and Map New Enumerated List Entries Starting in the SmartPlant
Schema
The following procedure applies to authoring tools that have metadata adapters.
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Load the Tool Map Schema and Open the Map Enumerated List
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
5. To add new entries to an existing enumerated list, expand the Map Enumerated List node
and double-click the map enumerated list that you want to modify.
2. Above Unmapped SmartPlant enumerations on the right side of the dialog box, click New
SmartPlant Enumeration on the toolbar.
3. In the New Enumerated Entry dialog box, type the name and long description for the new
enumerated list entry, and click OK.
The Schema Editor automatically fills in the appropriate number for the enumerated list
entry.
When you click OK, the new list entry appears in the Unmapped SmartPlant
enumerations table in the Edit Map Enumerated List Definition dialog box.
Add the New List Entries to the Tool Map Schema and Metadata
1. Above Unmapped application enumerations on the left side of the dialog box, click New
Application Enumeration on the toolbar.
2. In the New SPMapEnumDef dialog box, type the name and long description for the new
enumerated list entry, and click OK.
The metadata adapter automatically fills in the appropriate unique identifier for the
enumerated list entry.
When you click OK, the new list entry appears in the Unmapped SmartPlant
enumerations table in the Edit Map Enumerated List Definition dialog box.
For some authoring tools, such as SmartPlant Instrumentation, changes to the
metadata in the tool database are made automatically when you add the object to the tool map
schema. For other authoring tools, changes are only saved when you click File > Save > Tool
Schema File command in the Schema Editor to save the tool map schema. This allows you to
cancel your changes when you are adding new tool properties, enumerated lists, or enumerated
entries before you save the tool map schema. For more information, see Mapping with Metadata
Adapters (on page 273).
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Enumerated List Definition dialog box.
Defining mapping for an object does not necessarily mean that you can publish and
retrieve that object. The authoring tool adapter determines the objects that you can publish and
retrieve. For more information, see rules for your authoring tool in the SmartPlant Mapping
User's Guide or the tool documentation.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
Propagating the Enumerated List Entry to Other Authoring Tools Using Compare
After you add new objects to the SmartPlant schema, do a compare with other authoring
tool map schemas to identify changes that need to be made in the other authoring tools and
then add new objects and define mapping in the Map Environment.
Compare a Tool Map Schema to the SmartPlant Schema (on page 358)
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
Create and Map New String Properties Starting in the SmartPlant Schema
The following procedure applies to authoring tools that have metadata adapters.
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
When you add new properties starting in the SmartPlant schema, the authoring tool
metadata adapter uses classes exposed in the tool map schema to determine where the
property can be placed in the authoring tool metadata. In some cases, the tool map schema
does not totally represent the tool data model, and because of this, classes available to add
properties to in the authoring tool may not be available in the tool map schema. For example, if
you want to add a property to the Plant Item table in the SmartPlant P&ID data dictionary so that
all plant item types in SmartPlant P&ID inherit the property, you must define the new property in
SmartPlant P&ID Data Dictionary Manager, not in the Schema Editor. However, if you want to
define a new property on a map class that exists in the tool map schema, you can use the
following procedure to do so.
Load the Tool Map Schema and Open a Map Class Definition
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
5. To add a new property, expand the Map Classes node, and double-click the tool map class
to which you want to add the new property.
3. In the New Property Definition dialog box, define the new SmartPlant schema property,
and click OK to create the property definition.
Create a Property Definition (on page 194)
In the Scoped by property type box, be sure to select string as the property type for
the new string property.
When you click OK, the new property appears in the Unmapped SmartPlant
properties table in the Edit Map Class Definition dialog box.
Add the New Property to the Tool Map Schema and Metadata
1. Above Unmapped application properties on the left side of the dialog box, click New Map
Property Definition on the toolbar.
2. In the New Map Property dialog box, type the name and any other information that you
want to define for the new map property definition, and click OK to create it.
By default, the authoring tool metadata adapter supplies the tool identifier (OID) and the
name for the map property definition. You can change the default name, which is always
a number, by selecting the existing number and typing the name you want.
In the Select criteria box, you can define the criteria that the tool adapter uses to select
or identify objects for this tool property definition. Some authoring tool metadata
adapters define this information by default. See the mapping rules for your authoring
tool for how to set the value for this property.
In the Process criteria box, you can define the criteria that the adapter uses to process
objects that are instances of this tool property definition. Some authoring tool metadata
adapters define this information by default. See the mapping rules for your authoring
tool for how to set the value for this property.
For example, if the tool adapter must do a conversion on an enumerated list or the unit
of measure for a property before the property is published, use the Process criteria box
to specify the method used for the conversion, for example,
EFAdapter.EnumConversions.
By default, the software creates the relationship between the map class definition you
selected to edit and the new map property definition. You can see which map class
definition exposes the map property definition in the Exposed by map classes box.
You can change the property category for the new map property definition in the
Category box. Changing the property category displays other properties that you can
define for the new map property definition.
When you click OK, the new map property definition is added to the Unmapped
application properties table in the Edit Map Class Definition dialog box.
For some authoring tools, such as SmartPlant Instrumentation, changes to the
metadata in the tool database are made automatically when you add the object to the tool map
schema. For other authoring tools, changes are only saved when you click File > Save > Tool
Schema File command in the Schema Editor to save the tool map schema. This allows you to
cancel your changes when you are adding new tool properties, enumerated lists, or enumerated
entries before you save the tool map schema. For more information, see Mapping with Metadata
Adapters (on page 273).
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Class Definition dialog box.
Defining mapping for an object does not necessarily mean that you can publish and
retrieve that object. The authoring tool adapter determines the objects that you can publish and
retrieve. For more information, see rules for your authoring tool in the SmartPlant Mapping
User's Guide or the tool documentation.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
Create and Map New Properties with Enumerated Lists Starting in the
SmartPlant Schema
The following procedure applies to authoring tools that have metadata adapters.
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
When you add new properties starting in the SmartPlant schema, the authoring tool
metadata adapter uses classes exposed in the tool map schema to determine where the
property can be placed in the authoring tool metadata. In some cases, the tool map schema
does not totally represent the tool data model, and because of this, classes available to add
properties to in the authoring tool may not be available in the tool map schema. For example, if
you want to add a property to the Plant Item table in the SmartPlant P&ID data dictionary so that
all plant item types in SmartPlant P&ID inherit the property, you must define the new property in
SmartPlant P&ID Data Dictionary Manager, not in the Schema Editor. However, if you want to
define a new property on a map class that exists in the tool map schema, you can use the
following procedure to do so.
Load the Tool Map Schema and Open a Map Class Definition
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
3. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
4. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
<Authoring Tool> Tool Schema node to display contents of the authoring tool map
schema.
Add the New Enumerated List to the Tool Map Schema and SmartPlant Schema
Before you add a new map property definition to the authoring tool map schema, you should add
the map enumerated list that scopes the property definition. Adding the map enumerated list
definition also allows you to automatically create the equivalent enumerated list definition and
entries in the SmartPlant schema. Before you create the list in the SmartPlant schema, you
need to verify that the enumerated list or a list that has an equivalent meaning does not already
exist.
1. To add a new enumerated list, expand the Map Enumerated Lists node, and right-click any
map enumerated list in the tree view.
2. On the shortcut menu, click Create New SPMapEnumListDef.
3. In the New Map Enumerated List Definition dialog box, type the name of the new map
enumerated list definition in the Name box on the Overview tab.
4. Click the Advanced tab.
5. In the Short Description box, type a name for the new map enumerated list.
By default, the authoring tool metadata adapter supplies the tool identifier (OID) and
the short description for the map enumerated list. You can change the default name, which
is always a number, by selecting the existing number and typing the name you want.
6. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool enumerated list definition and its entries. See the mapping rules for your
authoring tool for how to set the value for this property.
7. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool enumerated list definition and its enumerations. See the mapping
rules for your authoring tool for how to set the value for this property.
8. To create an enumerated list entry (MapEnum) for this map enumerated list, click New
Child in the New Map Enumerated List Definition dialog box.
If you have a spreadsheet containing your enumerated list entries, you can copy them
to the Clipboard and then add them to the enumerated list using the Import Clipboard
Entries button.
Import Enumerated List Entries from a Spreadsheet (on page 198)
9. In the Short description box, type the name of the enumerated list entry.
By default, the authoring tool metadata adapter supplies the tool identifier (OID), the
name, and the secondary numeric key for the map enumerated list entry. You can
change the default name, which is always a number, by selecting the existing number
and typing the name you want. However, you should not modify the value in the
Number box that is supplied by the metadata adapter.
When you move out of the Short description box, the new enumerated list entry is
automatically added to the Map enumerated list definition tree.
10. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool enumerated list entry. See the mapping rules for your authoring tool for
how to set the value for this property.
11. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool enumerated list entry. See the mapping rules for your authoring
tool for how to set the value for this property.
12. To create additional list entries, click New Sibling, and repeat steps 7-11 for each entry that
you want to add.
13. In the Map enumerated list definition tree, click the name of the map enumerated list
definition.
14. To create the equivalent list in the SmartPlant schema, click New SmartPlant Enumerated
List with Correlated Entries.
15. Review the new SmartPlant schema enumerated list and entries in the Created
Enumerated List and Entries dialog box, and then click OK to create the enumerated list.
You can right-click the list or list entries to make changes before you save the list and its
entries in your schema extensions file.
The software creates the SmartPlant enumerated list definition and creates the publish
map for the authoring tool map enumerated list definition and entries to the new
enumerated list definition and entries in the SmartPlant schema.
16. Click OK in the New Map Enumerated List Definition dialog box.
The software prompts you to enter any information that is required by the metadata
adapter, such as the long description. Required information varies by authoring tool.
3. To add a new property, expand the Map Classes node, and double-click the tool map class
to which you want to add the new property.
4. If you want to start by defining publish mapping for the new property, click the Publish tab.
If you only want to define retrieve mapping for the enumerated property, you can click the
Retrieve tab instead. The procedure for adding properties and mapping is the same for both
tabs.
5. Above Unmapped SmartPlant properties on the right side of the dialog box, click New
Property Definition on the toolbar.
6. In the New Property Definition dialog box, define the new SmartPlant schema property,
and click OK to create the property definition.
Create a Property Definition (on page 194)
By default, the Schema Editor defines the interface definition that exposes the selected
property definition based on the tool map class definition you selected. However, the
default is only a suggestion based on context, and you can change the interface
definitions that expose this property definition in the Exposed by interface definitions
box.
In the Scoped by property type box, be sure to select the new enumerated list you
created previously as the property type for the new property.
When you click OK, the new property appears in the Unmapped SmartPlant
properties table in the Edit Map Class Definition dialog box.
Add the New Property to the Tool Map Schema and Metadata
1. Above Unmapped application properties on the left side of the dialog box, click New Map
Property Definition on the toolbar.
2. In the New Map Property dialog box, type the name and any other information that you
want to define for the new map property definition, and click OK to create it.
In the Scoped by enumeration box, be sure to select the new enumerated list you
created previously as the enumerated list for the new property.
By default, the authoring tool metadata adapter supplies the tool identifier (OID) and the
name for the map property definition. You can change the default name, which is always
a number, by selecting the existing number and typing the name you want.
In the Select criteria box, you can define the criteria that the tool adapter uses to select
or identify objects for this tool property definition. Some authoring tool metadata
adapters define this information by default. See the mapping rules for your authoring
tool for how to set the value for this property.
In the Process criteria box, you can define the criteria that the adapter uses to process
objects that are instances of this tool property definition. Some authoring tool metadata
adapters define this information by default. See the mapping rules for your authoring
tool for how to set the value for this property.
For example, if the tool adapter must do a conversion on an enumerated list or the unit
of measure for a property before the property is published, use the Process criteria box
to specify the method used for the conversion, for example,
EFAdapter.EnumConversions.
By default, the software creates the relationship between the map class definition you
selected to edit and the new map property definition. You can see which map class
definition exposes the map property definition in the Exposed by map classes box.
You can change the property category for the new map property definition in the
Category box. Changing the property category displays other properties that you can
define for the new map property definition.
When you click OK, the new map property definition is added to the Unmapped
application properties table in the Edit Map Class Definition dialog box.
For some authoring tools, such as SmartPlant Instrumentation, changes to the
metadata in the tool database are made automatically when you add the object to the tool map
schema. For other authoring tools, changes are only saved when you click File > Save > Tool
Schema File command in the Schema Editor to save the tool map schema. This allows you to
cancel your changes when you are adding new tool properties, enumerated lists, or enumerated
entries before you save the tool map schema. For more information, see Mapping with Metadata
Adapters (on page 273).
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
4. If you want to define both publish and retrieve mapping for the enumerated list entry, click
the Retrieve tab, and repeat steps 1-3 in this procedure.
5. Click OK in the Edit Map Class Definition dialog box.
Defining mapping for an object does not necessarily mean that you can publish and
retrieve that object. The authoring tool adapter determines the objects that you can publish and
retrieve. For more information, see rules for your authoring tool in the SmartPlant Mapping
User's Guide or the tool documentation.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
Propagating the New Property and Enumerated List to Other Authoring Tools Using
Compare
After you add new objects to the SmartPlant schema, do a compare with other authoring
tool map schemas to identify changes that need to be made in the other authoring tools and
then add new objects and define mapping in the Map Environment.
Compare a Tool Map Schema to the SmartPlant Schema (on page 358)
See Also
Before You Begin Mapping for Tools with Metadata Adapters (on page 314)
Mapping with Metadata Adapters (on page 273)
In an authoring tool map schema, you can also import enumerated list entries into a
tool map enumerated list and units of measure into a tool map unit of measure list using this
procedure.
2. In Excel, select the rows containing your enumerated list entries, and click Edit > Copy to
copy the entries to the Clipboard.
3. In the Schema Editor, create the enumerated list type to which you want to add the list
entries.
Create an Enumerated List (on page 196)
Create a Map Enumerated List Definition (on page 372)
4. In the New Enumerated List dialog box, click Import Entries from Clipboard.
To import entries into a tool map enumerated list or map UoM list, click Import
Clipboard Entries instead.
5. Verify that the default mapping between the columns in your copied spreadsheet and
properties of enumerated list entries is correct. If this mapping is correct, you can skip to
step 8 to import the entries.
6. If the default mapping is not correct, click the number for the column that you want to
change the mapping for in the Column list. Numbering for the columns starts with zero,
which is the first column in your spreadsheet.
7. In the Maps to property list, select the property that corresponds to the selected column in
your copied spreadsheet.
8. When the mapping is correct, click OK to import the enumerated list entries.
9. Click OK in the New Enumerated List dialog box to save the new entries.
Results of the comparison appear in a tree view in the View Comparison Results window.
The following colors have special meaning in the View Comparison Results window.
Green - Fully mapped
Red - Not mapped
Blue - Incomplete mapping
The Schema Editor does not take retrieve mapping into account during comparison.
After you resolve all the outstanding issues for publish mapping for an object, the object
name changes to green in the tree view even if the retrieve mapping is not defined.
4. To review differences, expand the nodes in the tree view.
5. Click an object to review its publish and retrieve mapping on the Publish and Retrieve tabs
in the View Comparison Results window.
2. In the Map <object type> to map list, select the objects that you want to exclude from
mapping, and then click Remove.
Information for the selected object appears on the Edit Form tab.
2. On the Overview tab, make sure that the publish to and retrieve from objects are defined
properly.
Map class definitions can be mapped using view definitions. View definitions allow you
to see properties categorically. If a view definition does not exist for the interface
definition that you want to map to, the Schema Editor generates a view definition
automatically for mapping. The software does not save this view definition. In future
releases, additional mapping view definitions will be delivered to make mapping easier.
If a map class definition or an enumerated list definition have objects defined for both
publish and retrieve, then the inconsistency could be in the map property definitions for
the map class definition or the enumerated entries for the map enumerated list
definition. To continue resolving inconsistencies, see step 3.
3. On the Publish and Retrieve tabs, review publish and retrieve mapping for map property
definitions if you selected a map class definition or map enumerated entries if you selected a
map enumerated list.
4. If map property definitions or map enumerated list entries are missing on the authoring tool
side, click New on the toolbar and create the object.
5. If objects that need to be mapped are not mapped, select the objects that you want to map
and click Map .
Understanding Mapping
Before you begin defining authoring tool mapping, you must understand the following:
The SmartPlant schema model and how it works. For more information, see SmartPlant
Schema Overview in the Schema Editor User's Guide and A Gentle Introduction to the
SmartPlant Schema, delivered with SmartPlant Foundation.
How tool map schemas work and how they are used by the authoring tools. For more
information, see Tool Map Schemas (on page 244).
The authoring tool data model for which you are defining mapping. For more information,
see your authoring tool documentation.
The delivered tool map schema and mapping for the authoring tool. For more information
see Viewing Authoring Tool Mapping (on page 289) and rules for your authoring tool in the
SmartPlant Mapping User's Guide or the tool documentation.
Defining Mapping Between the Tool Map Schema and the SmartPlant Schema
After you define the objects that you want to map in the tool map schema and the SmartPlant
schema, you can define the publish and retrieve mapping for those objects. Objects can have
different mapping defined for publish and retrieve.
Some authoring tools may have additional steps for performing the mapping between the
authoring tool and the SmartPlant schema. For mapping rules for each authoring tool, see rules
for your authoring tool in the SmartPlant Mapping User's Guide or the tool documentation.
You can also create map class definitions by double-clicking the SPMapClassDef
node in any tree view in any Schema Editor view.
5. In the Name box, type a unique name for the map class definition.
6. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool class definition. See the mapping rules for your authoring tool for how to
set the value for this property.
7. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool class definition. See the mapping rules for your authoring tool for
how to set the value for this property.
For example, if you want SmartPlant P&ID to publish extended properties for
equipment, such as process data properties, you can set the process criteria of the
Equipment map class to EFAdapter.EqDataExchanger,True in the SmartPlant P&ID tool
map schema.
8. To define the properties associated with the tool map class, click beside the Map
properties box, and select the authoring tool map properties for the class definition.
If the properties that you want to associate with the map class do not already exist in the
tool map schema, you can click Create in the Possible MapProperties dialog box to
create them.
Create a Map Property Definition (on page 368)
As a general rule, when you define map class definitions for a tool class/interface
model, the Map properties box should be blank; in a typical class/interface model, only
interfaces (not classes) expose properties.
9. Under Publish map, click beside the Publish to SmartPlant Class/Interface box, and
select the SmartPlant schema class definitions or interface definitions to which you want to
map for publish operations.
Most mapping between map class definitions and the SmartPlant schema should be
done using SmartPlant interface definitions.
If you map to interface definitions, you should map to the primary interface definitions for
the SmartPlant objects that the tool class definition corresponds to.
10. Under Retrieve map, click beside the Retrieve to SmartPlant Class/Interface box, and
select the SmartPlant schema class definitions or interface definitions that map to the map
class definition for retrieve operations.
For retrieval, mapping should be defined using interface definitions rather than class
definitions.
11. If the map properties for this map class definition already exist in the tool map schema,
define the publish and retrieve maps for the properties under Publish map and Retrieve
map.
Define Publish Mapping for Tool Properties (on page 380)
Define Retrieve Mapping for Tool Properties (on page 385)
12. Click OK to save the map class definition.
Defining mapping for an object does not necessarily mean that you can publish and
retrieve that object. The authoring tool adapter determines the objects that you can publish and
retrieve. For more information, see rules for your authoring tool in the SmartPlant Mapping
User's Guide or the tool documentation.
When you create a map class definition, the Schema Editor automatically assigns a UID to
the map class definition. If you want to change the UID, click Change UID. See the mapping
rules for your authoring tool for information on UID values to use. Some application adapters
will not work correctly if the values for the UID do not follow the rules for that application.
The application schema model that you are using determines the value for the Is interface?
option and indicates whether the Specialization of, Generalization of, Realizes and Is
realized by boxes require a value for the map class definition.
If the application model is a simple class/property model, then Is interface? should be
False, and the Specialization of, Generalization of, Realizes, and Is realized by
boxes should be blank.
If the application model is a class inheritance model, Is interface? should be False, and
the Realizes and Is realized by boxes should be blank. If the tool map class inherits
from other tool classes, this inheritance should defined in the Specialization of box.
Likewise, if other tool classes specialize this tool class, this should be reflected in the
Generalization of box.
If the application model is a class/interface model, then both classes and interfaces are
modeled as tool map class definitions. The Is interface? option for a particular map
class definition should reflect whether that tool class refers to an interface (True) or a
class (False).
For both classes and interfaces, the Specialization of and Generalization of boxes
should be blank. For interfaces, the Realizes box should be blank, and the Is realized
by box should indicate the classes that realize this interface. For classes, the Is
realized by box should be blank, and the Realizes box should indicate the interfaces
realized by this class.
The Mapping option box identifies the type of mapping that you can use for the map class
definition. The possible values include:
Don't Map
Map Directly - The properties for the tool class or interface map directly to a SmartPlant
schema class definition or interface definition. The map properties that can be used for
mapping are defined for this tool class only. Map Directly is the default mapping type.
You should use this option if the properties for the tool class map exactly the same
regardless of the tool class that specializes them (class inheritance model) or the tool
class that realizes them (class interface model).
Include Generalized - If the tool map schema is using a class inheritance model and
the Map directly option is not satisfactory for the mapping, this option should be used.
The map properties that can be used for mapping for this option are the map properties
for this tool class and the map properties for any generalized class (including
generalizations of generalized classes or the entire inheritance tree).
This option allows different mapping for the properties of the generalized tool classes
depending on the specialized tool class. For example, one specialized tool class can
map the properties for a generalized tool class differently than another specialized tool
class maps those same properties.
Include Realized - If the tool map schema uses a class/interface model and the
interfaces do not map directly to SmartPlant schema interface definitions, then this
option should be used. The map properties that can be used for mapping for this option
are the map properties for each of the tool interfaces realized by this map class. This
option should never be used for an interface (Is interface? = True), only for a class (Is
interface? = False).
This option allows different mapping for the properties of an interface tool class based
on the realizing tool class. For example, one realizing tool class can map the properties
for a realized tool class differently than another realizing tool class maps those same
properties.
Unlike the SmartPlant schema where a property name can only be used once, property
names can be reused in the tool map schema for different map classes.
5. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool property definition. See the mapping rules for your authoring tool for how
to set the value for this property.
6. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool property definition. See the mapping rules for your authoring tool
for how to set the value for this property.
For example, if the tool adapter must do a conversion on an enumerated list or the unit
of measure for a property before the property is published to SmartPlant, use the Process
criteria box to specify the method used for the conversion, for example,
EFAdapter.EnumConversions.
7. To define the tool map class definitions that expose this map property definition, click
beside the Exposed by map classes box, and select the authoring tool class definitions.
If the map classes that you want to associate with the map property definition do not
already exist in the tool map schema, you can click Create in the Possible MapClass Values
dialog box to create them.
Create a Map Class Definition (on page 365)
8. If the map property definition has values defined by an enumerated list, click beside the
Scoped by enumeration box, and select the tool map enumerated list definition that
scopes this tool map property definition.
If the map enumerated list that you want to associate with the map property definition
does not already exist in the tool map schema, you can click Create in the Possible
MapEnumList Values dialog box to create it.
You can also create map edge definitions by double-clicking the SPMapCEdgeDef
node in any tree view in any Schema Editor view.
5. In the Name box, type a unique name for the map edge definition.
6. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool edge definition. See the mapping rules for your authoring tool for how to
set the value for this property.
7. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool edge definition. See the mapping rules for your authoring tool for
how to set the value for this property.
8. To define the starting map class definition for the edge definition, click beside the Starts
at map class box, and select the starting tool map class.
If the map class definition that you want to use as the starting point for the map edge
definition does not already exist in the tool map schema, you can click Create in the
Possible StartMapClassDef dialog box to create it.
Create a Map Class Definition (on page 365)
9. To define the ending map class definition for the edge definition, click beside the Ends
at map class box, and select the ending tool map class.
10. If you to be able to map to both ends of the edge definition, click beside the Only 1 end
map object? box, and then select True.
11. Click OK to save the new map edge definition.
The authoring tool adapter determines whether one-to-many, many-to-many, and many-to
one mapping is supported. For more information, see rules for your authoring tool in the
SmartPlant Mapping User's Guide or the tool documentation.
When you create a map edge definition, the Schema Editor automatically assigns a UID to
the map edge definition. If you want to change the UID, click Change UID. See the mapping
rules for your authoring tool for information on UID values to use. Some application adapters
will not work correctly if the values for the UID do not follow the rules for that application.
You can also create map enumerated list definitions by double-clicking the
SPMapEnumListDef node in any tree view in any Schema Editor view.
5. In the Short description box, type the name of the enumerated list.
6. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool enumerated list definition and its entries. See the mapping rules for your
authoring tool for how to set the value for this property.
7. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool enumerated list definition and its enumerations. See the mapping
rules for your authoring tool for how to set the value for this property.
8. To define the SmartPlant schema enumerated list type that the tool enumerated list
definition maps to for publish, click beside the Maps to box, and select the SmartPlant
enumerated list type.
9. To define the SmartPlant schema enumerated list type that maps to the tool map
enumerated list definition for retrieve, click beside the Mapped from box, and select the
SmartPlant enumerated list type.
10. To define the tool map properties that this list defines values for, click beside the
Scoped map properties box, and select the map property definitions that are scoped by
this map enumerated list.
11. To create an enumerated list entry (MapEnum) for this map enumerated list, click New
Child in the New Map Enumerated List Definition dialog box.
If you have a spreadsheet containing your list entries, you can copy them to the
Clipboard and then add them to the list using the Import Clipboard Entries button.
Import Enumerated List Entries from a Spreadsheet (on page 198)
12. In the Short description box, type the name of the enumerated list entry.
When you move out of the Short description box, the new enumerated list entry is
automatically added to the Map enumerated list definition tree.
13. If a secondary numeric key identified the enumerated list entry, type the key in the Number
box.
14. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool enumerated list entry. See the mapping rules for your authoring tool for
how to set the value for this property.
15. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool enumerated list entry. See the mapping rules for your authoring
tool for how to set the value for this property.
16. To create additional list entries, click New Sibling, and repeat steps 12-15 for each entry
that you want to add.
17. To save your changes, click OK.
For some authoring tools, you must change the system-generated UID so that the
adapter can correlate the enumerated list and its entries with the appropriate enumerated list
and entries in the tool database. For example, for SmartPlant P&ID, you must replace the
system- generated UID for the map enumerated list and the list entries with UIDs from the
SmartPlant P&ID database. For more information, see rules for your authoring tool in the
SmartPlant Mapping User's Guide or the tool documentation. To change the system- generated
UID, click Change UID.
If the map enumerated list constrains other enumerated lists or list entries in the authoring
tool map schema, you can select the effected tool enumerated lists by selected the
enumerated list name in the tree view, and then clicking beside the Constrains box.
Constrains relationships define tool enumerated list hierarchies much like the contains
relationships define enumerated list hierarchies in the SmartPlant schema.
If the map enumerated list is constrained by another enumerated list, you can select the tool
enumerated lists that constrains this one by selecting the enumerated list in the tree view,
and then clicking beside the Constrained by box.
To view properties for the map enumerated list or enumerated list entries, click the list or
entry in the tree view.
As you add enumerated list entries to the list, the software adds them to the Contains box
for the map enumerated list definition.
When you define enumerated list entries, the ContainedIn box is automatically populated
with the map enumerated list name. However, you can change the map enumerated list for
an enumerated list entry by clicking beside the ContainedIn box and selecting another
map enumerated list. The enumerated entry is automatically moved to the selected map
enumerated list.
In an authoring tool map schema, you can also import enumerated list entries into a
tool map enumerated list and units of measure into a tool map unit of measure list using this
procedure.
2. In Excel, select the rows containing your enumerated list entries, and click Edit > Copy to
copy the entries to the Clipboard.
3. In the Schema Editor, create the enumerated list type to which you want to add the list
entries.
Create an Enumerated List (on page 196)
Create a Map Enumerated List Definition (on page 372)
4. In the New Enumerated List dialog box, click Import Entries from Clipboard.
To import entries into a tool map enumerated list or map UoM list, click Import
Clipboard Entries instead.
5. Verify that the default mapping between the columns in your copied spreadsheet and
properties of enumerated list entries is correct. If this mapping is correct, you can skip to
step 8 to import the entries.
6. If the default mapping is not correct, click the number for the column that you want to
change the mapping for in the Column list. Numbering for the columns starts with zero,
which is the first column in your spreadsheet.
7. In the Maps to property list, select the property that corresponds to the selected column in
your copied spreadsheet.
8. When the mapping is correct, click OK to import the enumerated list entries.
9. Click OK in the New Enumerated List dialog box to save the new entries.
You can also create map unit of measure list definitions by double-clicking the
SPMapUoMListDef node in any tree view in any Schema Editor view.
5. In the Short description box, type the name of the UoM list.
6. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool UoM list definition and its entries. See the mapping rules for your
authoring tool for how to set the value for this property.
7. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool UoM list definition and its enumerations. See the mapping rules for
your authoring tool for how to set the value for this property.
8. To define the SmartPlant UoM list that the tool UoM list definition maps to for publish, click
beside the Maps to box, and select the SmartPlant UoM list.
9. To define the SmartPlant UoM list that maps to the tool map UoM list definition for retrieve,
click beside the Mapped from box, and select the SmartPlant UoM list.
10. To define the tool map properties that this list defines UoMs for, click beside the Scoped
map properties box, and select the map property definitions that are scoped by this map
UoM list.
11. To create a UoM list entry (MapEnum) for this map UoM list, click New Child in the New
Map Unit of Measure List Definition dialog box.
If you have a spreadsheet containing your list entries, you can copy them to the
Clipboard and then add them to the list using the Import Clipboard Entries button.
Import Enumerated List Entries from a Spreadsheet (on page 198)
12. In the Short description box, type the name of the list entry.
When you move out of the Short description box, the new list entry is automatically
added to the Map unit of measure list definition tree.
13. If a secondary numeric key identifies the UoM list entry, type the key in the Number box.
14. In the Select criteria box, define the criteria that the tool adapter uses to select or identify
objects for this tool UoM list entry. See the mapping rules for your authoring tool for how to
set the value for this property.
15. In the Process criteria box, define the criteria that the adapter uses to process objects that
are instances of this tool UoM list entry. See the mapping rules for your authoring tool for
how to set the value for this property.
16. To create additional list entries, click New Sibling, and repeat steps 12-15 for each entry
that you want to add.
17. To save your changes, click OK.
For some authoring tools, you must change the system-generated UID so that the
adapter can correlate the enumerated list and its entries with the appropriate enumerated list
and entries in the tool database. For example, for SmartPlant P&ID, you must replace the
system- generated UID for the map enumerated list and the list entries with UIDs from the
SmartPlant P&ID database. For more information, see rules for your authoring tool in the
SmartPlant Mapping User's Guide or the tool documentation. To change the system- generated
UID, click Change UID.
To view properties for the map UoM list or UoM list entries, click the list or entry in the tree
view.
As you add UoM list entries to the list, the software adds them to the Contains box for the
map UoM list definition.
When you define UoM list entries, the ContainedIn box is automatically populated with the
map UoM list name. However, you can change the map UoM list for a UoM list entry by
clicking beside the ContainedIn box and selecting another map UoM list. The UoM entry
is automatically moved to the selected map UoM list.
While the Schema Editor provides flexibility for defining the types of mapping that are
described in this section, the underlying authoring tool adapter ultimately defines whether
the different types of mapping are supported. Therefore, you may be able to define mapping
in the Schema Editor that is not supported by the authoring tool.
Before you define any mapping other than straightforward one-to-one mapping that does not
involve tool map edge definitions or SmartPlant schema edge definitions, check the
limitations of the authoring tool adapter to determine what types of mapping are supported.
Authoring tool programmers who are defining mapping for their authoring tools should be
aware that they are responsible for supporting, with the assistance of the Schema
Component API, any Schema Editor-defined mapping that they need.
Open the Tool Map Schema and Map Class Definition that You Want to Modify
1. After you open the tool map schema that you want to edit in the Schema Editor, click View >
Tool Schema.
2. Click Options on the View Schema dialog box.
3. On the View tab, select one of the Tree views or Editor views and then click OK.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. In the tree view, expand the SPMapClassDef node.
5. In the tree view, double-click the map class definition that exposes the properties that you
want to map.
generalized or realized tool class definitions. These properties will not appear in the Map
properties box but will be displayed when the mapping is defined.
2. If properties are missing, click beside the Map properties box, and select the authoring
tool map properties for the class definition.
If the properties that you want to associate with the map class do not already exist in
the tool map schema, you can click Create in the Possible MapProperties dialog box to
create them.
Create a Map Property Definition (on page 368)
If you need to add or modify class definitions or interface definitions, click beside the
Publish to SmartPlant Class/Interface box, and select the SmartPlant schema class
definitions or interface definitions to which you want to map for publish operations.
Most mapping between map class definitions and the SmartPlant schema should be
done using SmartPlant interface definitions instead of class definitions. The authoring
tool adapter defines whether an application supports mapping to interface definitions
instead of class definitions.
If you map to interface definitions, you should map to the primary interface definitions for
the SmartPlant objects that the tool class definition corresponds to.
If the authoring tool does not publish the map class definition, you are not required to
select a SmartPlant schema class definition or interface definition for mapping.
2. Under Publish map, click Map Properties to define property mapping for publish
operations.
3. In the Source tree in the Publish Map for Class Definition window, expand the SmartPlant
class definition or interface definition to which you want to map tool properties.
Nodes in bold text are edge definitions to other objects in the SmartPlant schema.
Clicking + to expand the nodes displays the properties available across those edge
definitions. If the underlying tool adapter does not support mapping across edge definitions
(for example, one-to-many or many-to-many mapping), then any mapping defined using
properties exposed by expanding these edge definitions will not actually be used and might
cause the tool adapter to fail.
You can map many properties from the SmartPlant schema to one property in the tool
map schema by dragging and dropping more than one property onto the Maps to
Property column for a single SmartPlant schema property. However, not all tool
adapters support mapping one tool property to multiple SmartPlant properties.
You can map multiple tool properties to one SmartPlant property by dragging and
dropping one SmartPlant property multiple times onto the Maps to Property column for
different tool properties. However, not all tool adapters support mapping one tool
property to multiple SmartPlant properties.
To find properties and edge definitions in the source tree, define search criteria under
Source tree at the bottom of the window, and then click Find first node. You can click
Find first node to go to the next node in the tree that matches the criteria you defined.
2. If you want to map a tool property to a relationship in the SmartPlant schema, drag an edge
definition from the Scope tree to the Maps to Property column for the tool property that you
want to map.
Not all tool adapters support this special type of mapping. See the mapping rules for your
authoring tool for more information.
Edge definitions in the Source tree are in bold text. When you expanding an edge
definition in the Source tree, the software displays the properties across that edge
definition.
In one-to-many mapping, one tool object corresponds to multiple SmartPlant objects.
2. Drag a property definition from beneath the expanded edge definition node in the Source
tree to the Maps to Property column for the tool property that you want to map.
Not all tool adapters support this special type of mapping. See the mapping rules for your
authoring tool for more information.
3. If you want to define many- to-many mapping between the tool map schema and the
SmartPlant schema, expand the map class definition tree, and then expand the
StartingMapEdgeDefs node to see the properties for the map edge definition in the table
view at the bottom of the window.
n many-to-many mapping, multiple tool objects correspond to multiple SmartPlant
objects.
4. Drag a property definition from beneath an expanded edge definition node in the Source
tree to the Maps to Property column for the map edge definition property that you want to
map.
Edge definitions in the Source tree are in bold text. When you expanding an edge
definition in the Source tree, the software displays the properties across that edge
definition.
Not all tool adapters support this special type of mapping. See the mapping rules for your
authoring tool for more information.
Publish and retrieve mapping do not have to be the same for the map class definition or the
map properties definitions.
Not all properties are mapped for both publish and retrieve.
See Also
Create a Map Class Definition (on page 365)
Create a Map Edge Definition (on page 370)
Create a Map Enumerated List Definition (on page 372)
Create a Map Property Definition (on page 368)
Create a Map Unit of Measure List Definition (on page 377)
Adding Objects to a Tool Map Schema (on page 365)
Define Mapping for a Tool Enumerated List (on page 390)
Define Retrieve Mapping for Tool Properties (on page 385)
Define Mapping for a Tool Unit of Measure List (on page 392)
While the Schema Editor provides flexibility for defining the types of mapping that are
described in this section, the underlying authoring tool adapter ultimately defines whether
the different types of mapping are supported. Therefore, you may be able to define mapping
in the Schema Editor that is not supported by the authoring tool.
Before you define any mapping other than straightforward one-to-one mapping that does not
involve tool map edge definitions or SmartPlant schema edge definitions, check the
limitations of the authoring tool adapter to determine what types of mapping are supported.
Authoring tool programmers who are defining mapping for their authoring tools should be
aware that they are responsible for supporting, with the assistance of the Schema
Component API, any Schema Editor-defined mapping that they need.
Open the Tool Map Schema and Map Class Definition that You Want to Modify
1. After you open the tool map schema that you want to edit in the Schema Editor, click View >
Tool Schema.
2. Click Options on the View Schema dialog box.
3. On the View tab, select one of the Tree views or Editor views and then click OK.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. In the tree view, expand the SPMapClassDef node.
5. In the tree view, double-click the map class definition that exposes the properties that you
want to map.
If the properties that you want to associate with the map class do not already exist in
the tool map schema, you can click Create in the Possible MapProperties dialog box to
create them.
Create a Map Property Definition (on page 368)
If you need to add or modify class definitions or interface definitions, click beside the
Retrieve to SmartPlant Class/Interface box, and select the SmartPlant schema class
definitions or interface definitions that map to the map class definition for retrieve
operations.
For retrieval, mapping should be defined using interface definitions rather than class
definitions.
2. Under Retrieve map, click Map Properties to define property mapping for retrieve
operations.
3. In the Tool Schema tree in the Map for Retrieving window, expand the tool map schema
map class definition to which you want to map SmartPlant schema properties for retrieve.
Drag a property from the Tool Schema tree to the Map Property Def column in the top
table for the SmartPlant schema property that you want to map.
2. If you want to map to a tool property from a relationship in the SmartPlant schema, do the
following:
In the top SmartPlant Schema tree, select the interface definition that exposes the
property that you want to map for retrieve.
In the Tool Schema tree, expand the StartingMapEdgeDefs node.
Drag an edge definition from the Tool Schema tree to the Map Property Def column in
the top table for the SmartPlant schema property that you want to map.
Not all tool adapters support this special type of mapping. See the mapping rules for your
authoring tool for more information.
4. Select the SmartPlant schema edge definition that you want to map in the tree view to
display properties in the table below the tree view.
Publish and retrieve mapping do not have to be the same for the map class definition or the
map properties definitions.
Not all properties are mapped for both publish and retrieve.
See Also
Create a Map Class Definition (on page 365)
Create a Map Edge Definition (on page 370)
Create a Map Enumerated List Definition (on page 372)
Create a Map Property Definition (on page 368)
Create a Map Unit of Measure List Definition (on page 377)
Adding Objects to a Tool Map Schema (on page 365)
Define Mapping for a Tool Enumerated List (on page 390)
Define Publish Mapping for Tool Properties (on page 380)
Define Mapping for a Tool Unit of Measure List (on page 392)
Open the Tool Map Schema and Map Enumerated List Definition that You Want to Modify
1. After you open the tool map schema that you want to edit in the Schema Editor, click View >
Tool Schema.
2. Click Options on the View Schema dialog box.
3. On the View tab, select one of the Tree views or Editor views and then click OK.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. In the tree view, expand the SPMapEnumListDef node.
5. In the tree view, double-click the map enumerated list definition that you want to define
mapping for.
Define Publish and Retrieve Mapping for the Map Enumerated List Entries
1. To define publish and retrieve mapping for the map enumerated list entries, click Publish
and Retrieve Maps in the Edit Map Enumerated List Definition dialog box.
You are not required to define both publish and retrieve mapping for map enumerated
list entries. If you want to define publish mapping only, click Publish Map. If you want to
define retrieve mapping only, click Retrieve Map.
2. In the Publish and Retrieve Maps for Tool Enumerated List window, expand the map
enumerated list in the Tool Schema tree.
3. Expand the MapEnum node to see the entries in the enumerated list.
4. To define the retrieve mapping for an enumerated list entry, drag the entry from the Tool
Schema tree to the From Map Enum column for the SmartPlant schema enumerated entry
that maps to the tool entry.
The table contains all entries in the SmartPlant schema enumerated list types that you
are defined as mapping to or mapped from the tool enumerated list.
Modifications that you make to the mapping have asterisks (*) around them, for
example, *CC1*.
5. To define the publish mapping for an enumerated list entry, drag the entry from the Tool
Schema tree to the To Map Enum column for the SmartPlant schema enumerated entry
that the tool entry maps to.
Publish and retrieve mapping for an enumerated list entry do not have to be the same.
6. Repeat steps 4 and 5 until all the entries that you want to map for publish and retrieve are
mapped.
7. Click X in the title bar of the Publish and Retrieve Maps for Tool Enumerated List
window to close the window and save your changes.
8. Click OK in the Edit Map Class Definition dialog box to save your mapping.
Publish and retrieve mapping does not have to be the same for map enumerated lists or
their list entries.
Not all enumerated list entries are mapped for both publish and retrieve.
See Also
Create a Map Class Definition (on page 365)
Create a Map Edge Definition (on page 370)
Create a Map Enumerated List Definition (on page 372)
Create a Map Property Definition (on page 368)
Create a Map Unit of Measure List Definition (on page 377)
Adding Objects to a Tool Map Schema (on page 365)
Define Publish Mapping for Tool Properties (on page 380)
Define Retrieve Mapping for Tool Properties (on page 385)
Define Mapping for a Tool Unit of Measure List (on page 392)
Open the Tool Map Schema and Map UoM List Definition that You Want to Modify
1. After you open the tool map schema that you want to edit in the Schema Editor, click View >
Tool Schema.
2. Click Options on the View Schema dialog box.
3. On the View tab, select one of the Tree views or Editor views and then click OK.
If you do not see the View tab, the View dialog box is in Simple mode. Select the view
that you want to use in the Form list instead.
4. In the tree view, expand the SPMapUoMListDef node.
5. In the tree view, double-click the map UoM list definition that you want to define mapping for.
Define Publish and Retrieve Mapping for the Map Units of Measure
1. To define publish and retrieve mapping for the map UoMs, click Publish and Retrieve
Maps in the Edit Map Unit of Measure List Definition dialog box.
You are not required to define both publish and retrieve mapping for map UoMs. If you
want to define publish mapping only, click Publish Map. If you want to define retrieve
mapping only, click Retrieve Map.
2. In the Publish and Retrieve Maps for Tool Enumerated List window, expand the map
UoM list in the Tool Schema tree.
3. Expand the MapEnum node to see the UoMs in the UoM list.
4. To define the retrieve mapping for a UoM, drag the UoM from the Tool Schema tree to the
From Map Enum column for the SmartPlant schema UoM that maps to the tool UoM.
The table contains all entries in the SmartPlant schema enumerated list types that you
are defined as mapping to or mapped from the tool UoM list.
Modifications that you make to the mapping have asterisks (*) around them, for
example, *CC1*.
5. To define the publish mapping for a UoM, drag the entry from the Tool Schema tree to the
To Map Enum column for the SmartPlant schema UoM that the tool UoM maps to.
Publish and retrieve mapping for a UoM do not have to be the same.
6. Repeat steps 4 and 5 until all the entries that you want to map for publish and retrieve are
mapped.
7. Click X in the title bar of the Publish and Retrieve Maps for Tool Enumerated List
window to close the window and save your changes.
8. Click OK in the Edit Map Class Definition dialog box to save your mapping.
Publish and retrieve mapping do not have to be the same for map UoM lists or the UoMs the
list contains.
Not all UoMs are mapped for both publish and retrieve.
See Also
Create a Map Class Definition (on page 365)
Create a Map Edge Definition (on page 370)
Create a Map Enumerated List Definition (on page 372)
Create a Map Property Definition (on page 368)
Create a Map Unit of Measure List Definition (on page 377)
Adding Objects to a Tool Map Schema (on page 365)
Define Mapping for a Tool Enumerated List (on page 390)
Define Publish Mapping for Tool Properties (on page 380)
Define Retrieve Mapping for Tool Properties (on page 385)
When mapping to an interface definition for publish or from one or more interface definitions for
retrieve, the view definition that is used includes all properties for all interfaces directly or
indirectly implied by the mapped-to interface. This will likely include properties that are outside
those used within a particular component schema and therefore properties that will not be
published and/or retrieved.
To limit the displayed properties to those that are on interfaces used within a particular
component schema, that component schema should be identified though the Constrain to
component schema list box. Specifying a component schema is optional for both publish and
retrieve. However, if a component schema is specified, only those properties used within that
component schema will be displayed through the Publish and Retrieve tabs as well as within
the various graphical mapping displays.
The view definition name displayed in the Publish using view definition or Retrieve using
view definition list boxes should update to reflect the view definition whenever a value is
entered for the component schema though the Constrain to component schema list box.
Description
Properties in the tool map schema that are available for publish
1
View definitions in the SmartPlant Schema to which publish and retrieve
2 relationships can be added
The relationships lines indicated properties that have been mapped for
3 publish or retrieve
Properties in the tool map schema that are available for retrieve
4
A tabular review that presents the same mapping information as selected
5 in the tree view. The table view lets you easily reorganize data.
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click View > Tool Schema.
3. In the SPFMapClass tree view, right-click the class definition you want to map, then click
Edit <object>. For example, from the tree view, right-click InstrumentInline, then click Edit
InstrumentInLine.
4. On the Overview tab, click the mapping option you want. For example, click Graphical
Publish and Retrieve Mapping to map both publish and retrieve properties.
You can select Graphical Publish Mapping to only map properties for publish. You
can select Graphical Retrieve Mapping to only map properties for retrieve.
The Show Mapping for <object> window appears.
5. Select a property in the publish tree view (left) or the retrieve tree view (right) to create
relationship for publish or retrieve. This example shows the creation of a publish
relationship.
6. Drag your cursor toward the View Property tree and a Relationship Line appears.
7. Click the View Property in the middle tree view for which you want to create a publish
relationship. A new relationship line should appear that connects the starting map property
with the ending property definition.
You can create a publish or retrieve relationship by selecting a view definition property
(middle tree view) as your starting point and dragging the relationship line to a map
property in either the publish or retrieve tree.
You can automatically map properties for publish by right-clicking a property in the
publish tree and selecting one of the following from the shortcut menu:
Auto-map property (publish) - Provides a list of the best matches for the selected
map property in the SmartPlant Schema. Selecting a property from this form and
clicking OK results in a relationship being created.
Auto-create properties from selected map properties - Creates a new property
definition, adds the property definition to a view definition, and then creates a
relationship between the selected map property in the tree view and the new
property.
You can automatically map properties for retrieve by right-clicking a property in the
retrieve tree and selecting Auto-map property (retrieve) from the shortcut menu.
Auto-map property (retrieve) provides a list of the best matches for the selected map
property in the SmartPlant Schema. Selecting a property form this form and clicking OK
results in a relationship being created.
If you have checked the SmartPlant schema CMF file out of the Desktop Client,
launched the Schema Editor, synchronized the tool map schema and the tool metadata,
and are working with the tool's metadata adapter to define mapping, the authoring tool
map schema is already open in the Schema Editor.
Before you can open a tool map schema, you must open a schema file.
You can also open a file configuration that contains the SmartPlant schema and the tool
map schema that you want to view.
The tool map schema for each authoring tool is installed with the authoring tool. For
more information about authoring tool map files and their locations, see your authoring
tool documentation.
2. Click View > Tool Schema.
3. In the SPMapEnumListDef, right-click the enumerated list you want to map, then click Edit
<object>. For example, right-click ConstructionStatus, then click Edit
ConstructionStatus.
4. On the Overview tab, click the mapping option you want. For example, click Graphical
Publish and Retrieve Mapping to map both publish and retrieve enumerations.
You can select Graphical Publish Mapping to only map enumerations for publish.
You can select Graphical Retrieve Mapping to only map enumerations for retrieve.
5. Select an enumeration in the publish tree view (left) or the retrieve tree view (right) to create
relationship for publish or retrieve. This example shows the creation of a publish
relationship.
6. Drag your cursor toward the mapped-to SmartPlant tree (middle) and a Relationship Line
appears.
7. Click the property in the mapped-to SmartPlant tree for which you want to create a publish
relationship.
The Relationship Line appears bold. The view property and related mappedproperty are
automatically highlighted.
The following shortcut menus are available by right-clicking the various cells within the table.
Edit <From Map Property> - Allows you to edit the property to be published from the tool
map schema using the Edit Map Property Definition dialog box.
View <View Property> - Allows you to edit the view property in the SmartPlant schema
using the Edit Property Definition dialog box.
Edit <To Map Property> - Allows you to edit the property to be retrieved from the tool map
schema using the Edit Map Property Definition dialog box.
Delete MapPropertyToProperty relationship between <From Map Property> and <View
Property> - Removes the relationship between the property being published in the tool map
schema and the SmartPlant schema.
Delete PropertyToMapProperty relationship between <View Property> and <To Map
Property> - Removes the relationship between the property being retrieved in the tool map
schema and the SmartPlant schema.
Add/delete displayed from map properties - Allows you to add or remove columns used
to display information about map properties available for publish.
Add/delete displayed schema properties - Allows you to add or remove columns used to
display information about SmartPlant Schema properties.
Add/delete displayed to map properties - Allows you to add or remove columns used to
display information about map properties available for retrieve.
Sort map data - Allows you to select the properties by which to sort the table.
You can sort the table by selecting a cell in the header row. For example, selecting
the View Property header will sort the contents of the table using the values within that
column.
Repaint - Updates the table to the default view and removes any sort criteria.
Copy to Clipboard - Copies the display within the graphical mapping user interface to the
clipboard. The display can then be pasted into other programs, such as Microsoft Word.
Print Form - Prints a copy of the graphical section of the mapping user interface to the
default printer.
Align - Aligns the tree views horizontally and vertically. This option should be used when the
graphical mapping user interface is used in Layout mode.
Stop lines at control edge - Stops the relationship lines at the edges of the tree view
frame.
Extend lines to text - Extends the relationship lines to the property names in the tree view.
To delete the relationship between an object and a property within an object; for example, a
class definition in a tool map schema and a property within that class definition, right-click
the property, then click Delete relationship between <object> and <property>.
3. Drag an object, for example, the InstrumentInline map class definition, from the tool
schema to the Mapping window.
4. In the Schema Editor message box, click No to create a customized mapping diagram.
To display the default mapping diagram for the selected object type, click Yes in the
Schema Editor message box.
5. Define a display name and package for the new mapping diagram on the Overview tab on
the New Mapping Diagram dialog box.
6. Click OK and the property tree for the object appears.
7. Move the tree view around as needed.
8. Right-click in a tree to change the display of the object.
9. Add additional objects to the Mapping window by browsing in the tool schema and dragging
object from the tree view for the toll schema to the mapping diagram.
10. Add the view definition for the class.
Click Layout >Schema
Click Filter > Select > Select Other Classes, then select Graphs/Views from the list.
Expand ViewDef in the tree view and browse to the view definition; for example,
PIDInlineInstrument_Map.
Drag PIDInlineInstrument_Map to the Mapping window.
6. In the Instrument Index dialog box, click Tables > Instrument Statuses.
7. In the Instrument Statuses dialog box, click New to define the new enumerated list item.
8. In the Instrument Statuses dialog box, type PRC as the prefix and Preconstruction as the
description.
9. To verify the new Instrument Status has been added, click Reports > Tables > Instrument
Statuses. The report appears.
10. Click Save As to save a copy of the report.
11. In the Save As dialog box, click Original, then click OK.
12. Save the file with a .CSV extension.
13. Open the report in Microsoft Excel.
14. Find PRC in column A and Preconstruction in column C. A number appears in column B.
2. In the Set Active Configurations dialog box, select the schema version or versions that
you want your changes to apply to, and click OK.
3. In the Schema Editor, click File > SmartPlant > Edit Engineering Tool Options and select
INtools in the list of authoring tools to load the INtools tool map schema.
4. Under Startup options, select the Load map schema.
Connect to Application Schema is checked by default.
5. Click Finish.
6. In the Synchronize dialog box, select the appropriate action in the <Tool> Database or
<Tool Map Schema Path> row to update inconsistencies between the tool metadata and
tool map schema, and click OK. Default actions appear in blue in the appropriate column
and row for each difference.
Default actions appear in blue in the appropriate column and row for each difference.
6. Click Map .
7. Click OK.
2. In the SmartPlant schema tree view on the left side of the Retrieve tab, click PRC, then on
the right side, click Preconstruction.
3. Click Map .
4. Click OK.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
4. Click Fields.
5. In the Custom Fields dialog box, select the appropriate plant and item type.
6. In the first blank row, type the information for the SystemCode property, and click Apply.
8. In the Item Type list, select loop, and type the information for another SystemCode
property.
8. Under Browser Groups, expand Instrument Index Standard Browser > Default View,
then select Style.
9. In the Style list at the bottom of the dialog box, select SystemCode, then click Edit.
Launch Schema Editor and Load the SmartPlant Instrumentation Tool Map Schema
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Set Active Configurations dialog box, select the schema version or versions that
you want your changes to apply to, and click OK.
3. In the Schema Editor, click File > SmartPlant > Edit Engineering Tool Options and select
INtools in the list of authoring tools to load the INtools tool map schema.
4. Under Startup options, select the Load map schema.
5. Click OK in the Synchronize dialog box to update the tool map schema.
5. Select IInlineInstrumentOcc and IInstrumentOcc from the list, and click OK.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
5. In the Add Property dialog box, define information for the System Code property, and click
OK. Be sure to select String in the Data Type list.
6. Click File > Save to save your changes in Data Dictionary Manager.
7. Click File > Exit.
Launch Schema Editor and Load the SmartPlant P&ID Tool Map Schema
1. In the Desktop Client, check out the SmartPlant schema CMF file and launch the Schema
Editor.
2. In the Set Active Configurations dialog box, select the schema version or versions that
you want your changes to apply to, and click OK.
3. In the Schema Editor, click File > SmartPlant > Edit Engineering Tool Options and select
SmartPlant P&ID in the list of authoring tools to load the SmartPlant P&ID tool map schema.
The new enumerated list entry that you added in the authoring tool appears in the
Synchronization dialog box to be added to the tool map schema file.
Because the SmartPlant P&ID tool map schema does not have a map class definition called
Plant Item, the new property that you added appears on several map class definitions that
inherit from Plant Item, such as equipment component and instrument loop.
4. Click OK in the Synchronize dialog box to update the tool map schema.
The Schema Editor creates a dynamic view definition that is used to display the SmartPlant
schema properties. Selecting the mapped class will show all of the property definitions
contained in the view definition.
3. In the New Property Definition dialog box, define the new SmartPlant schema
SystemCode property, and click OK to create the property definition.
In the Exposed by interface definitions box, click , and select IPBSItem as the
interface definition that exposes this property.
In the Scoped by property type box, be sure to select string8 as the property type for
the new string property.
4. Under Unmapped application properties, select SystemCode.
5. Under Unmapped SmartPlant properties, select SystemCode.
6. On the toolbar, click Map .
7. Click OK.
6. Repeat steps 1-5 in this section to map the SystemCode property for all SmartPlant P&ID
map class definitions that are associated with this property.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
Name EngSystem
Display Name Engineering System
Data Type Select List
Select List EngSys
Format Variable Length
Default Value None
Display to User Yes
User for Filtering Yes
Category Process
Depends on None
8. In the Exposed by interface definitions box, click , and select IPBSItem as the
interface definition that exposes this property.
9. In the Scoped by property type box, be sure to select EngSys as the property type.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
5. Define the property in the Edit Map Property Definition dialog box.
6. Type %ProcessPoint in the Select criteria box.
The Process criteria box is automatically filled with the value set to False. By setting
the Process criteria value to True, the SmartPlant P&ID adapter finds the extended
properties that contain the process properties for equipment.
9. Click the Publish tab.
10. In the Unmapped application properties table, select the
ProcessOperatingMaxTemperature property and the
ProcessOperatingMinTemperature property you created.
11. In the Unmapped SmartPlant properties table, select the PhaseTemperatureMax
property and the PhaseTemperatureMin property.
The mapping you defined appears in the mapped objects table at the bottom of the
dialog box.
13. Click OK in the Edit Map Class Definition dialog box.
14. Click File > Save > All Modified Files to save the SmartPlant schema extensions and the
tool map schema.
15. Repeat steps 3 - 14 for to create and map process data properties as needed.
16. Test your mapping by publishing equipment with process data related to it.
2. In the Set Active Configurations dialog box, select the schema version or versions that
you want your changes to apply to, and click OK.
Verify that the Corrosive Enumerated List Does Not Already Exist in the Schema
1. In the Schema Editor, click the Schema tab in the Overall Workflows dialog box.
2. Beside the Another Schema File button, click View to view the SmartPlant schema file.
3. Clicking the View button beside the Schema File button will allow you to view
extensions1.xml.
6. In the Edit Enumerated List dialog box, review the existing list entries.
4. In the Synchronize dialog box, select the appropriate action in the <Tool> Database or
<Tool Map Schema Path> row to update inconsistencies between the tool metadata and
tool map schema, and click OK. Default actions appear in blue in the appropriate column
and row for each difference.
2. Expand the Map Enumerated Lists node, and double-click Fluid System.
4. In the SmartPlant schema tree view on the right side of the Publish tab, right-click any entry
under the Fluid system node, and then click Create New EnumList Type on the shortcut
menu.
5. In the New Enumerated List dialog box, type Corrosive as the short description of the new
list, Corrosive Fluid System as the long description, and 1100 as the number.
6. Click New Child Entry, and create a fluid code of KA with a description of (KA) Ammonia,
Anhydrous.
7. Repeat step 6 for each fluid code in the following list, and click OK.
Fluid Code (Short Description) Long Description
Add the New Corrosive List to the SmartPlant P&ID Tool Map Schema and Map
1. In the authoring tool map schema tree view on the left side of the Publish tab, right-click
any entry under the Fluid system node, and then click Create New SPMapEnumDef on
the shortcut menu.
2. In the New SPMapEnumDef dialog box, replace the default number supplied by the
metadata adapter in the Name box with Corrosive.
3. Type Corrosive Fluid System in the Description box, and then click OK.
4. The new list appears in the Unmapped application enumerations table.
7. Click Map .
8. Click OK.
4. Repeat steps 1 and 2 for each fluid code in the following list:
Fluid Code (Short Description) Long Description
7. Click Map .
8. Repeat steps 5-7 for each enumerated entry in the Fluid Code list.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
4. In the Selected list box, click Fluid System and review the new Corrosive entry in the
table.
5. In the Selected list box, click Fluid Code and review the entries that you added in the table.
6. In the tool map schema view on the left side of the Publish tab, right-click any node, then
select Create New SPMapEnumDef.
7. Type Variable Frequency Drive in the Name box and provide a description.
8. Click OK.
9. The new list appears in the Unmapped application enumerations table.
10. In the Unmapped application enumerations table, select Variable Frequency Drive.
11. In the Unmapped SmartPlant enumerations table, select Variable-frequency Drive.
12. Click Map .
13. Click OK.
14. Click File > Save > All Modified Files to save the SmartPlant schema extensions and the
tool map schema. For some tools, saving the tool map schema also saves changes to the
tool metadata database.
7. Click File > Save to save your changes in Data Dictionary Manager.
8. Click File > Exit.
3. After you open the SmartPlant schema in the Schema Editor, to the right of Another
Schema File in the Overall Workflows dialog box, click View.
4. On the View Schema dialog box, select Tree/Drag-Drop UML.
5. Click OK.
6. In the Map Environment, expand SmartPlant Electrical > Loaded Map Schemas >
SmartPlant Electrical Tool Schema.
7. Expand the Map Classes > PIDInstrumentLoop and select ELEElectricMotor.
8. Expand the Realized Interface Definitions
9. Repeat steps 7-8 for ELECable, ELEWire, and ELEInstrument.
IPBSItem is a common interface definition.
Synchronize
1. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
Synchronize Tool Metadata with the Tool Map Schema (on page 315)
The new property that you added in the authoring tool appears in the Synchronization
dialog box to be added to the tool map schema file.
2. Click OK in the Synchronize dialog box to update the tool map schema.
In the Exposed by interface definitions box, click , and select IPBSItem as the
interface definition that exposes this property.
In the Scoped by property type box, be sure to select string8 as the property type for
the new string property.
9. Under Unmapped application properties, select SystemCode1.
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
Name EngSystem
Display Name Engineering System
Data Type Select List
Select List EngSys
Format Variable Length
Default Value None
Display to User Yes
User for Filtering Yes
Category Miscellaneous
Depends on None
3. In the Schema Editor, synchronize the authoring tool map schema for which you want to
define mapping.
The new enumerated list entry that you added in the authoring tool appears in the
Synchronization dialog box to be added to the tool map schema file.
5. Above Unmapped SmartPlant properties on the right side of the dialog box, click New
Property Definition on the toolbar.
6. In the New Property Definition dialog box, define the new SmartPlant schema
EngineeringSys property, and click OK to create the property definition.
In the Exposed by interface definitions box, click , and select IPBSItem as the
interface definition that exposes this property.
In the Scoped by property type box, be sure to select EngSys as the property type.
7. Under Unmapped application properties, select EngSystem.
8. Under Unmapped SmartPlant properties, select EngineeringSys.
9. On the toolbar, click Map .
When you close the Schema Editor, the software prompts you to save your connection
information, user interface options, and loaded tool map schemas to a session file. Click Yes
in the message box to save the session file.
If you extend the SmartPlant schema, you must load the changes into the SmartPlant
Foundation database. For more information, see the SmartPlant Schema Editor User's
Guide.
Recommended Workflow
Add the enumerated entries to the catalog schema.
Add the enumerated entries to the tool schema.
Map the enumerated entries to the tool schema and SmartPlant schema. This step makes
the new enumerated values available for publish or retrieve by .
Add the enumerated entries to the SmartPlant P&ID meta schema.
Map the enumerated entries to the SmartPlant P&ID tool schema and the SmartPlant
schema. This step makes the new enumerated values available for publish or retrieve by
SmartPlant P&ID.
Generate the design basis in . This step updates the catalog schema and generates the
designbasis_map.xml.
Test publish and retrieve the enumerated property
START
PRO Process w/ rice 10100
oil
PCO Process w/ corn 10101
oil
END
4. Click Save and name the new workbook CompanyCodeList.xls.
4. Under Catalog information and Schema information, select your Catalog database
server, Catalog database, Catalog schema database server, and Catalog schema
database.
5. Specify a path and file name for the log file.
6. Specify the symbols directory.
7. Click Load.
3. Click Query for Scheduled Tasks , then click Finish on the Scheduler Tasks dialog
box.
4. When the Generate Schema Files task has processed, click File > Exit to close the
Desktop Client.
4. Click Finish.
5. A warning dialog box appears. This dialog box warns you that some tools automatically
store the data in their tool databases as you make changes. Making changes to the schema
file updates the database, and in some cases, the changes cannot be removed from the
database. Make your changes carefully; we recommend that you back up your tool
databases so that you can recover the information if needed.
6. The software compares the mapping file for the tool and the tools database. The
Synchronize dialog box shows all of the properties that are different and on which side the
object is missing.
Map the Enumerated Entries to the Tool Schema and SmartPlant Schema
1. Under Tool, expand SmartPlant P&ID, then Loaded Map Schemas, then SmartPlant
P&ID Tool Schema, and then Map Enumerated Lists.
2. Right-click FluidCode, and then click Edit FluidCode.
3. Click the Publish tab.
4. On the Publish tab, the tool map data appears on the left and the SmartPlant data appears
on the right.
5. Select PCO in the Unmapped application enumerations table.
6. Select PCO in the Unmapped SmartPlant enumerations table.
7. On the toolbar, click Map .
8. Repeat steps 5 - 7 for the PRO enumeration.
9. Verify that the mapping you defined appears in the mapped objects table at the bottom of
the dialog box.
10. Click OK in the Edit Map Enumerated List Definition dialog box.
11. Click File > Save All Modified Files.
12. Click Yes to save the SPPIDDataMap.xml file
13. Click OK on the EditUtils message box.
14. Click Yes to save changes to the EFSchema.cmf.
15. Click OK on the EditUtils message box.
16. Click File > Exit to close the Schema Editor.
The changes made in this example will publish the pipeline and pipe run names as shown
below.
Pipeline: <ItemTag>
PipeRun: <NominalDiameter>-<ItemTag>-<PipingMaterialClass>-<InsulPurpose>
If you want to change the format or order of the item tag, you must edit the ItemTag.dll
using Visual Basic or the Configure Item Tag Utility delivered with the SmartPlant P&ID Support
Utilities Pack. The SmartPlant P&ID Support Utilities Pack is available on eCustomer (Products
> SmartPlant P&ID > Freeware Tools and Utilities).
Recommended Workflow
Add the item tag property to the Pipeline Name Attribute Setting field so that it can be
published for the pipeline name.
Edit the item Tag properties in the tool map schema.
Verify and publish a P&ID drawing.
5. Click Save.
7. Click OK.
8. Click Yes to continue when the message box appears.
After the metadata adapter generates a schema based on its application metadata, a
comparison is performed between the tool map schema and the generated schema. The
differences between the two schemas are displayed in the Synchronize dialog.
9. Click OK on the Synchronize dialog box. Schema Editor will read the tool meta-schema
and automatically add the changes to the tool map schema.
After you synchronize the last tool map schema, the Map Environment appears.
Edit the Item Tag Properties for the Pipeline and Pipe Run
1. In the Map Environment, expand the Tool node, and then expand the node for the
appropriate authoring tool.
2. Under the authoring tool node in the tree view, expand Loaded Map Schemas and the
SmartPlant P&ID Tool Schema node to display contents of the authoring tool map
schema.
3. In SmartPlant Foundation Desktop Client, click Find > Published Data > Pipe Runs.
4. Click OK.
Review the pipe run name.
Recommended Workflow
Add the new map edge definition to the tool mapping schema.
Add two new properties to the SmartPlant schema.
Map both the new properties in the Schema Editor.
Type the first few characters of the Start Map Class Definition value in the Starts with
box to locate the value in the list.
7. Click Browse next to Ends at map class box.
8. In the Possible EndMapClassDef Values for MemberPartToIJDMaterial dialog box,
select IJDMaterial.
9. Click Browse next to Only 1 end map object box.
10. Select True.
11. In the New Map Edge Definition dialog box, click OK.
Unmap the Material Type Property and Delete existing Map Edge Definition
1. Under SPMapClassDef, expand CSPSMemberPartPrismatic, then
StartingMapEdgeDefs, then MemberPartToIJDMaterial, and then EndMapClassDef.
2. Under EndMapClassDef, expand IJDMaterial, then MapProperties, then MaterialType
and then MapPropertyToProperty\Property.
3. Right click ShortMaterialDescription, and select Delete relationship between
MaterialType and Short material description.
4. Locate MemberPartMaterial.
5. Right click MemberPartMaterial, and select Delete MemberPartMaterial.
7. Drag and drop the MaterialGrade property from the source tree to the Maps To Property
column in the left side against the tool property that you want to map.
In order to ensure that the selected MaterialGrade property is exposed by the
I3DMaterialTypeData interface definition, do the following:
Right-click on MaterialGrade property in Maps to Property column.
Select Edit MaterialGrade.
In the Edit Property Definition dialog box, ensure that Exposed by interface
definition value is set to I3DMaterialTypeData.
Click OK.
8. In the Publish Map for Tool Class Definition dialog, click OK.
9. In the Edit Map Class Definition dialog box, click OK.
10. In the Schema Editor window, select File > Save All Modified Files.
11. Click Yes to save the SP3DPublishMap.xml.
12. Click OK.
13. Click Yes to save the EFSchema.cmf.
14. Click OK.
15. In the Schema Editor window, select File > Exit.
The session file is not saved as the steps to validate the schema are skipped.
3. Click Query for Scheduled Tasks , then click Finish on the Scheduler Tasks dialog
box.
4. When the Generate Schema Files task has processed, click File > Exit to close the
Desktop Client.
The default installation folder is C:. If you installed SmartPlant Foundation to a different
folder, substitute your installation path.
2. Verify the Date Modified column to ensure that the files have been successfully updated.
3. In the Windows menu, select Start > Run.
4. In the Run dialog box, type %temp% and click OK.
5. Select all the files in the Temporary folder and click Delete.
3. On the Add Component dialog box, select Folder on the General tab, and click OK.
4. Right-click the folder, and select Rename. In our example, use 3DModel.
6. On the Add Component dialog box, select 3D Model Data. This object type is the one that
you want to publish. Click OK to add the 3D Model Data category to this folder.
8. On the Setup dialog box under Filter, select More, and then click OK.
9. On the Select Filter dialog box, expand My Filters, and select My Filter. Then click OK.
If My Filter is not available, you must create a filter for this example. Click New Filter
at the top of the Select Filter dialog box. Then, select EFPLANTSC2 to select ALL objects
in this model. You have the option to select individual objects in the list if you do not want to
publish all of the model objects. Click OK to save this configuration filter.
10. Back on the Setup dialog box, verify that My Filter is selected. Click OK.
11. Next, create a publish drawing object by right-clicking 3D Model Data and selecting Create
Drawing.
12. The software creates an empty drawing template. Right-click the template, and select
Revise. All published drawings must be revised for input into SmartPlant Foundation.
13. On the Revise dialog box, select a revision scheme (RevA1 in this example). Then, enter A
for the Major revision for this drawing, and enter 1 in the Count field. Click OK.
14. In the Management Console, right-click the drawing object, and select Update Now.
When the update is complete, a green check appears on the drawing icon.
16. On the Publish dialog box, verify the data, and click OK.
17. A process dialog box shows the publish process, and when the process is complete, a
success message box appears.
18. To verify that the new properties published properly, open the published metadata XML file
in the SmartPlant Foundation vault. On the SmartPlant Foundation server, the location is
[Drive Letter]\Smartplant 2007\FTP Vaults\EFPLANT-SC- 2_Vault\SP3D\{UID ID
NUMBER}.xml.
You can check the time and date of the files to verify which files were published last.
The metadata file is the largest file in the publish group. For the published file, the vault
contains one view file (3D Model) and three metadata files.
19. Click File > Exit.
The default installation folder is C:. If you installed SmartPlant Foundation to a different
folder, substitute your installation path.
2. Copy the P3DComponent.xml file and paste it into a new folder. For example, copy to
D:\Component.
3. Select Start > All Programs > Intergraph SmartPlant Review > SmartPlant 3D Label
Selector.
4. In the SmartPlant 3D Label Selector window, click Browse next to Schema file
name box.
5. Select the P3DComponent.xml file from D:\Component folder and click Open.
6. In the SmartPlant 3D Label Selector window, click Browse next to File output
directory box.
7. Select D:\Component folder and click OK.
8. In the SmartPlant 3D Label Selector window, click Select All.
9. Click Save and then Close.
10. Select Start > All Programs > Intergraph SmartPlant Review > SmartPlant Review.
11. In the SmartPlant Review window, click File > Open.
12. Browse to D:\Publish folder, where you saved your published files.
13. Select the vue file and click Open.
14. Click OK.
15. In the SmartPlant Review window, click View > Main.
16. Select View > Text to open the Object Data View.
17. In the Object Data View, select the member part and review the properties.
Comparison
In the Schema Editor, you can compare schemas, tool map schemas, and data files with other
files of the same type. Comparisons are valuable for seeing changes from one version of the
schema to another, for seeing changes in data files as they are generated by the integrated
authoring tools, and for seeing differences between the schemas from different authoring tools.
There are four types of comparisons in the Schema Editor:
Full Comparison
Selective Update
Detection of Tombstones
Comparison Using Views
Full Comparisons
A full comparison compares every object, relationship, and property in one file with the file you
select. When you do a full comparison, you can choose whether the software displays the full
results of the comparison, the comparison instructions only, or both the comparison results and
instructions.
After you perform a full comparison between files, you can view the modification instructions
generated by the software. These modification instructions define the changes required to go
from the objects in the file you selected for comparison to the objects in the original file. For
example, you can see which objects would be deleted, which ones would be updated, and which
ones would be created.
Selective Update
Selective update allows you to choose which objects to add, update, or delete after you have
compared schemas, tool map schemas, and data files with other files of the same type.
Because any addition, update, or deletion you make changes the file you are comparing, you
need to be cautious about the selections you make and aware of their impact.
Detection of Tombstones
An alternative to doing a full comparison between two files is to detect tombstones. Tombstones
are objects that have been deleted in one file that exist in another file. The Schema Editor
identifies items as tombstones when they do not exist in the original file you opened in the
Schema Editor but do exist in the second file you selected for comparison. After you detect
tombstones, you can view the tombstones that were found by reviewing the comparison
instructions for the two files.
Because tombstone detection does not involve a full comparison of two files, it typically runs
faster than a full comparison.
See Also
Full Comparison: An Example (on page 489)
Detect Tombstones (on page 491)
Tombstone Comparison Results: An Example (on page 492)
Compare Files
1. Open the schema, tool map schema, or data file to which you want to compare another file.
2. Click File > Compare with File, and then point to the type of file you want to compare with
the currently open file.
3. To select the type of comparison that you want, do one of the following:
To do a full comparison and view comparison results only, click Full Comparison >
Display Results.
To do a full comparison and view comparison instructions only, click Full Comparison >
Display Instructions.
To do a full comparison and view both comparison results and instructions, click Full
Comparison > Display Both.
To compare using a view definition, click Using Views.
To compare and choose the objects to add, update, or modify, click Selectively /
Update.
4. Browse to the file to which you want to compare the schema, data file, or tool map schema.
5. If the View File Type Instructions dialog box appears, click the view in which you want to
display the comparison results, and then click OK.
If you do a full comparison and only want to view comparison results or if you do a
comparison using views, you are not required to select the view in which you want to display
results.
After you do a full comparison, you can review the comparison instructions that would be
generated by the software if one file superseded the other. You can review these
comparison instructions using the appropriate Instructions command on the View menu.
For example, to view schema instructions, click View > Schema Instructions > Tree/Table.
You can save instructions by clicking File > Save > FileType Instructions, where FileType
is the type of file for which you want to save instructions. For example, to save data
instructions, click Data Instructions on the Save submenu.
If you selectively update objects, any addition, update, or deletion you make changes the file
you are comparing. You need to be cautious about the selections you make and aware of
their impact.
See Also
Full Comparison: An Example (on page 489)
Detect Tombstones (on page 491)
Comparison (on page 487)
3. Browse to the file that you want to compare to the file you opened previously.
4. Select the folder where you want the software to store the comparison results file, and then
click X to close the dialog box.
When the comparison is complete, the results appear in Notepad.
After you do a full comparison, you can review the instructions that would be generated
by the software if one file superseded the other. You can review these comparison instructions
using the appropriate Instructions command on the View menu. For example, to view schema
instructions, click View > Schema Instructions > Tree/Table.
5. Click OK.
You can also view instructions after a full compare by clicking View > Schema
Instructions, View > Data Instructions, or View > Tool Schema Instructions.
You can save instructions by clicking File > Save > FileType Instructions, where FileType
is the type of file for which you want to save instructions. For example, to save data
instructions, click Data Instructions on the Save submenu.
You can also view comparison instructions after a full compare by clicking View > Schema
Instructions, View > Data Instructions, or View > Tool Schema Instructions.
You can save instructions by clicking File > Save > FileType Instructions, where FileType
is the type of file for which you want to save instructions. For example, to save data
instructions, click Data Instructions on the Save submenu.
See Also
Comparing Files (see "Comparison" on page 487)
Detect Tombstones
1. Open the schema, tool map schema, or data file in which you want to detect deleted items.
2. Click File > Compare with File and then point to the type of file you want to use as the
basis for tombstone detection. For example, to compare two schemas, point to File >
Compare with File > Schema File.
3. Click Detect Tombstones on the submenu.
4. Browse to the file to which you want to compare the schema, data file, or tool map schema.
5. After tombstone detection is complete, select the view that you want to use for the delete
instructions on the View tab.
6. Click OK.
When you detect tombstones, only the delete instructions are displayed in the view you
selected.
You can save instructions by clicking File > Save > FileType Instructions, where FileType
is the type of file for which you want to save instructions. For example, to save data
instructions, click Data Instructions on the Save submenu.
See Also
Comparison (on page 487)
Tombstone Comparison Results: An Example (on page 492)
You can save instructions by clicking File > Save > FileType Instructions, where
FileType is the type of file for which you want to save instructions. For example, to save data
instructions, click Data Instructions on the Save submenu.
See Also
Comparison (on page 487)
Detect Tombstones (on page 491)
Selectively Update
Selectively Update is a very powerful tool for reconciling differences, but please use caution
when using this tool because you can introduce errors into your schema.
When a comparison is performed with Selectively Update, the results of the comparison are
presented in a Tree view, allowing you to choose which differences to resolve. This Tree view
can contain nodes New Objects, Modified Objects, and Deleted Objects depending on the
results of the comparison.
The New Objects node, when expanded, identifies all the objects that exist in the compared
with file (or configuration) that don’t exist in the opened file (or configuration).
The Modified Objects node, when expanded, identifies all the objects that exist in both files
(or configurations) but have at least property that has different values.
The Deleted Objects node identifies all the objects that exist in the opened file (or
configuration) that don’t exist in the compared with file (or configuration).
Selecting nodes from this tree control and then selecting OK will result in the changes for the
selected nodes being made to the opened file (or configuration). Therefore, selecting all the
nodes in this tree control and then selecting OK will result in the opened file being made to be
the same as the compared with file.
By selectively choosing which modifications to apply, you can control which changes are
actually made to the opened file (or configuration). Therefore, you can choose to take some
subset of the differences and apply them to the opened file.
Using Selectively Update improperly can introduce errors into the opened file.
Therefore, you should be careful for any case where you select a subset of the full set of
differences to be applied. The file (or configuration) should be validated after this command has
been executed and any new problems that are found by validation should be resolved before
proceeding further.
Validate Schemas
In the Schema Editor, you can validate the schema, meta schema, tool map schemas, and data
files. Although the Schema Editor provides commands to validate the schema, meta schema,
and tool map schemas, these tasks are typically performed by software developers when
changes are made to the SmartPlant schema and tool map schemas.
Tool schemas must be validated using the Schema Editor before they are delivered
and used with the authoring tool software. Error checking in the Schema Component assumes
that the tool map schema validates.
Data validation is typically performed by software vendors who want to successfully
communicate in an integrated environment. As data files are generated by authoring tools, they
can be validated in the Schema Editor to make sure that they conform to the SmartPlant
schema. You can set Schema Editor to automatically validate schemas or data files when
objects are created are modified. This helps identify errors and allows you to correct them as
immediately.
When you use the Validate commands on the Tools menu, the Schema Editor validates the
selected file against the SmartPlant schema and a set of semantic rules. Validating a file
performs a series of checks for potential problems with the data. If an authoring tool generates
illegal data, the Schema Editor validation creates a list of errors. The Schema Editor
automatically sets validation flag to indicate whether a set of objects have been successfully
validated with no errors and no modification commands have been executed since the
successful validation. This flag is set to True when a full validation is performed and no errors
are detected. It is set to False by each and every command that modifies or adds any object in
the set of objects.
After validation is complete, the Schema Editor displays validation errors in the Validation
Errors and Warnings dialog box for your review. These errors help you diagnose problems with
files. To help you more easily diagnose problems, you can filter the errors and warnings you see
during validations using the Set Validation Message Filtering command.
See Also
Validate Files (on page 495)
Validate Files
1. On the Tools menu, point to the type of file that you want to validate.
You can select Validate Schema/Display Results on the toolbar to validate the
active schema file and display validation results.
Click Tools > Another Schema > Validate All Schema Files > Display Results to
validated all opened schema files.
To view error messages and warnings in Notepad, click Generate & View Report.
6. In the Correct by list, select the action you want to take, then click Correct Selection(s).
To correct more than one object from the Error Table, hold the Shift key and select the
consecutive objects you want to correct. You can only select consecutive objects.
If you select more than one object from the Error Table, the Edit <object> dialog box
for the first object in the list appears first. When you click OK, the dialog box opens for
the next object.
7. In the Edit <object> dialog box, make your corrections, then click OK.
8. When all corrections you want to make are complete, click Close.
If you want to filter particular types of errors out of the validation results, click Tools > Set
Validation Message Filtering.
See Also
Validate Schemas (on page 495)
Automatic Validation
Click Edit > Turn AutoValidation On to automatically validate the schema and data files.
Turning automatic validation on helps you identify actions he is performing that cause validation
warnings and errors. If automatic validation is turned on and the user takes corrective steps to
fix the problems as they arise, then the number of problems detected during full validation
should be significantly less.
When automatic validation is turned on, any object created or modified during a command is
validated when that command is completed. The validation uses many of the same checks used
when a full validation of the schema is executed, but performs the check only against the set of
objects created or modified during the command. The Schema Editor displays validation errors
in the Validation Errors and Warnings dialog box for your review.
The use of automatic validation does not preclude the use of full validation since there are some
checks that are only performed during full validation and the partial validation performed at the
end of each command when automatic validation is on is insufficient to validate that the entire
set of objects are error-free.
Turning on automatic validation may slow performance of the Schema Editor. To improve
performance, turn off automatic validation and address validation problems with a full validation
on the schema rather than at the end of each command.
A
adapter
Authoring tool software that facilitates the sharing of data between the authoring tool and other
integrated tools. Tool adapters generate XML files for publish operations and consume XML
when tools retrieve documents. Adapters are also called SmartPlant adapters.
attribute
An object characteristic.
authoring tools
Applications where documents are created and then shared through integration. Integrated
authoring tools include Aspen Basic Engineering, SmartPlant P&ID, SmartPlant Electrical,
SmartPlant Instrumentation, SmartPlant 3D, SmartPlant Materials, and SmartPlant Foundation.
C
class view map
A schema object that specifies a set of class definitions and the default view definition that
should be used for each class definition in the set.
common UI
An ActiveX component (.dll) that provides a standard user interface for integration functionality,
such as publish, retrieve, and register. The authoring tools display the common UI when the
user clicks particular SmartPlant commands in the authoring tool.
component schema
A subdivision of the complete SmartPlant schema that contains the set of class definitions that
are used within a specific domain or application area.
container
An object used by the tool adapters and the SmartPlant software components to pass data back
and forth between a tool and SmartPlant Foundation. A container may hold data or metadata
related to the data model or actual instance data.
correlation
The relationship between items that represent the same object in multiple authoring tools.
D
database
Collection of files of comprehensive information that have predefined structure and organization;
a specific program can communicate, interpret, or process these files.
design basis
An item in an authoring tool that represents an item from an upstream application (an application
used earlier in the lifecycle of the plant). Plant items placed with the authoring tool correspond to
a particular design basis item.
Design basis items provide a means of determining if the plant items within the authoring tool
are consistent with the items from the upstream application and help users maintain consistency
as changes are made in all authoring tools.
design file
A file generated by a design tool, such as SmartPlant P&ID or Aspen Basic Engineering.
domain
A set of data (for example: tool data, SmartPlant Foundation administration data, and schema
data) that is segregated and managed independently in SmartPlant Foundation. Data
segregation improves performance and maintains data integrity. The SmartPlant Enterprise
authoring tools create data in one SmartPlant Foundation domain and publish into another
domain.
E
enumerated entry
A member of an enumerated list that defines one possible value for a property in the SmartPlant
schema. Enumerated values are sometimes called enumerated entries.
enumerated list
A list of possible string property values defined for a property definition in the SmartPlant
schema. Enumerated sets are sometimes called enumerated lists, picklists, codelists, and
lookups.
exposes
The relationship between interface definitions and property definitions in the SmartPlant
schema. Interface definitions expose the property definitions for class definitions.
G
graph definition
A connected network of edge definitions with structure. Each graph definition in the SmartPlant
schema starts at an interface definition and traverses through one or more relationship
definitions to another interface definition at the other end. Graph definitions are sometimes
referred to as directed graph definitions.
H
hierarchy
A classified structure with superiors, or roots, and subordinates, or dependents, used for
grouping data.
I
implies
The relationship between two interface definitions in the SmartPlant schema. If an interface
definition implies another interface definition, then any class definition that realizes the first
interface definition can also realize the implied interface definition.
integration
Technology that standardizes and improves the communication among the various SmartPlant
Enterprise authoring tools used in the course of designing, constructing, and operating a plant.
Integration manages data exchange among these authoring tools, which enables sharing and
re- use of plant information throughout the plant lifecycle.
interface definition
A named collection of property definitions that represents a role for a class definition in the
SmartPlant schema.
M
meta schema
A set of schema objects that describe the objects in the SmartPlant schema. The meta schema
provides the building blocks upon which the SmartPlant schema is built.
P
picklist
A list of applicable values for a given property in SmartPlant Foundation.
property
An object characteristic.
property definition
A basic attribute shared by all members of a class. Property definitions are grouped using
interface definitions in the SmartPlant schema.
publish
To share a document and its data with other authoring tools by exporting an XML file containing
the document data and relationships. When a document is published, the software places the
XML file in the appropriate SmartPlant Foundation vault and loads the data from the XML file
into the SmartPlant Foundation database. After the document is published, users can retrieve
the data from the XML file located in the SmartPlant Foundation vault into other authoring tools.
R
realizes
The relationship between class definitions and interface definitions in the SmartPlant schema.
Class definitions realize interface definitions. The interface definitions that are realized by a
class definition expose the properties for that class definition.
register
To map an authoring tool and all its projects to a SmartPlant Foundation URL, which points to
one SmartPlant Foundation database. You must register your authoring tool plant before you
can publish and retrieve in an integrated environment.
relationship definition
Associations between interface definitions in the SmartPlant schema. Relationship definitions
identify two specific objects that fulfill the roles on each end of the relationship.
resurrected object
A deleted authoring tool object that is reintroduced to the SmartPlant Foundation database when
recovered tool data is republished. For example, a tool initially publishes a document containing
an object, but later deletes the object and republishes. SmartPlant Foundation then detects that
the object is deleted. However, if the tool restores data that was backed up before the object
was deleted, through a data restoration or other tool-specific mechanism, and republishes, then
SmartPlant Foundation recognizes that the object was previously deleted but has been
reintroduced (resurrected).
S
schema
A model used to describe and validate the structure of XML files.
Schema Component
A suite of ActiveX components that provide functionality surrounding the creation, parsing,
validation, and comparison of the SmartPlant schema and data. The tool adapters interact with
the Schema Component to read the SmartPlant schema, to create data for publish, and to
retrieve data.
scoped by
The relationship between property definitions and property types in the SmartPlant schema. The
scoped by relationship specifies the property type that defines acceptable values, or scopes, a
particular property definition. Every property definition in the SmartPlant schema is scoped by
one and only one property type. All properties of that property definition must be of that property
type.
SI
International System of Units, sometimes referred to as the metric system. When values for
units of measure are published, they are converted to SI units and stored, regardless of the units
of measure selected when the user defined the value in the authoring tool.
SmartPlant Enterprise
A suite of Intergraph engineering applications that are delivered together.
SmartPlant schema
An XML file that describes the structure of the XML files generated by integrated authoring tools
in much the same way as a data dictionary describes the structure of a database. As tools
publish documents in XML format, those documents must adhere to the format defined by the
schema to ensure that the XML data can be loaded into SmartPlant Foundation and retrieved
into the other authoring tools.
T
TEF
The Engineering Framework; technology behind the integration of SmartPlant Enterprise
products.
tombstone
Delete instructions for an object that has been removed in one of the authoring tools. Upon
retrieval of a tombstone, delete tasks are created in the authoring tool's To Do List to allow the
tool to delete the object from its database.
tool
See authoring tool.
tool adapter
See adapter.
tool schema
A set of schema objects that describe the data in the authoring tool databases before it is
transformed into the format prescribed by the SmartPlant schema. The tool schema also
specifies the mapping between objects in the tool database and the SmartPlant schema.
tool signature
A unique identifier for the relationship between a plant in SmartPlant Foundation and a specific
plant in an authoring tool database. The relationship is created when an authoring tool registers
with SmartPlant Foundation.
U
unit of measure list
A collection of different units that measure the same property in SmartPlant Foundation.
UoM
A unit of measurement.
V
vault
A folder where files are stored on a host computer.
view definition
A named group of properties extracted from the possible properties that a graph definition
exposes. View definitions are used in an integrated environment to provide a different view of
data from that provided by the underlying schema.
W
Work Breakdown Structure (WBS)
The composition of the plant based on the construction work to be completed. The plant usually
occupies the top level of the hierarchy; it is typically followed by projects, contracts, and
documents.
X
XML
Extensible Markup Language; the format for all documents published or retrieved in an
integrated environment. These XML files must conform to the structure defined by the
SmartPlant schema.
Test Publish and Retrieve of the New View Mapping Relationships in Graphical
Properties • 467 Mapping • 405
tombstone • 511 View Options • 121
Tombstone Comparison Results View SmartPlant Schema Documentation •
An Example • 496 144
tool • 511 View Tool-to-SmartPlant Mapping in a
tool adapter • 511 Viewable UML View • 292
Tool Map Schema Objects • 248 View Tool-to-Tool Mapping for Classes and
Tool Map Schemas • 246 Properties • 299
Tool Objects Required for Metadata View Tool-to-Tool Mapping for Enumerated
Adapters • 281 Lists • 301
tool schema • 511 View Tool-to-Tool Mapping for Units of
Tool Schema Models • 246 Measure • 304
tool signature • 511 View Tool-to-Tool Mapping in a Editable
Tree View UML View • 296
An Example • 105 Viewable Configurations • 86
Tree/Editable UML View Viewing Authoring Tool Mapping • 291
An Example • 110
Tree/MultiTab View W
An Example • 119
Tree/Table View What's New in SmartPlant® Schema
An Example • 107 Editor? • 13
Tree/Viewable UML View Work Breakdown Structure (WBS) • 512
An Example • 109 Work Process for Creating a Custom PBS
Types of Mapping for Map Class Definitions Hierarchy • 164
• 258 Work Process for Extending the SmartPlant
Schema for Integration • 149
Work Process for Mapping for Tools without
U Metadata Adapters • 365
UIDs File • 222 Work Processes for Mapping for Tools with
UML Notation • 45 Metadata Adapters • 311
unit of measure list • 511
Units of Measurement • 31 X
UoM • 511
Update Document Types that Existing Tools XML • 512
Can Publish and Retrieve • 241 XML Files • 43
Using Excel to Export and Import Schema •
213
Using View Definitions to Define Mapping •
262
V
Validate Files • 499
Validate Schemas • 499
vault • 512
Verify New Naming Conventions in
SmartPlant P&ID • 472
Verify the New Pipeline Name Publishes to
SmartPlant Foundation • 473
View and Map Properties in the Graphical
Mapping Table • 406
view definition • 512
View Definitions • 39