GRANITE Interoperability Kernel FAQ
This document provides answers to frequently asked questions about PTC's GRANITE interoperability platform.
- What is GRANITE?
- Who should build on GRANITE?
- How does GRANITE compare to other component technologies?
- Is GRANITE designed to enable collaboration?
- What are the benefits a CAD vendor will realize via integrating GRANITE for unified associative access to multiple authoring applications' native data?
- Who is eligible to use GRANITE?
- How is GRANITE different from Creo Elements/Pro Toolkit?
- Where did GRANITE come from?
- Why did PTC decide to release GRANITE as a development solution?
- How can I get a copy of GRANITE?
- What language bindings and platforms does GRANITE support?
- What is the concept of a GRANITE feature?
- How does one keep track of entity names using GRANITE?
- How does GRANITE handle undo and rollback deltas?
- Does GRANITE take advantage of multi-processor platforms?
- How does GRANITE handle memory management?
- How do applications store and read GRANITE data?
- How does GRANITE handle errors and exceptions?
- What geometric representation does GRANITE use for curves and surfaces?
- Is there a journaling capability built in the kernel to assist in debugging and reporting bugs?
- Is there a test harness to explore new functionality and to identify bugs?
- What technical support exists for GRANITE?
- What documentation is available for GRANITE?
What is GRANITE?
GRANITE is a feature-based three-dimensional surface and solid modeling kernel with a technology that allows CAD/CAM/CAE applications to become associatively interoperable. Derived from PTC's best-in-class suite of products, GRANITE contains technology to enable applications to read each other's files natively and to evaluate, analyze and create geometry. The goal of GRANITE is enable true concurrent engineering through associative, heterogeneous design processes. It includes associative modeling libraries and a development environment that enables rapid prototyping and debugging of CAD applications.
Who should build on GRANITE?
- Vendors of commercial solid modeling authoring applications can use GRANITE's feature-based modeling engine to perform their core modeling functions and to interoperate with other CAD systems built on GRANITE. This approach is similar to how PTC is using GRANITE in its own Creo Elements/Pro and Creo Elements/Pro Mechanica products.
- Vendors of applications that do not author solid models, but view, analyze, and otherwise leverage content from CAD data built on GRANITE would use GRANITE in their applications to load and evaluate those models associatively. For example, a manufacturing vendor could use GRANITE to read Creo Elements/Pro files. When the Creo Elements/Pro files change, the manufacturing application can see those changes intelligently and update its tool paths associatively.
- Sophisticated end users can integrate proprietary modeling or analysis technology into GRANITE to provide compatibility with their GRANITE-based authoring applications. By using GRANITE, those proprietary applications would be associatively interoperable with their authoring applications. For example, an aerospace customer may combine existing proprietary code with GRANITE to create a special application that generates wing surfaces that can be used via its native file in Creo Elements/Pro designs.
How does GRANITE compare to other component technologies?
GRANITE offers many unique benefits over components provided by other vendors, including:
- Native file interoperability
Applications built on GRANITE can read native files created in authoring tools that are built on GRANITE, removing the need to export or transfer "neutral" files. GRANITE also has the technology to allow applications that do not use GRANITE for modeling to build a GRANITE model on-the-fly when requested, thus facilitating them to interoperate with other applications built on GRANITE.
Applications built on GRANITE are associatively interoperable with other applications built on GRANITE, including Creo Elements/Pro. That means a part may be designed in one application, analyzed in another, and manufactured in a third. If the original model is modified, the downstream applications may update automatically. The analysis and manufacturing applications combine with the native file interoperability to permit true concurrent engineering in a heterogeneous environment.
- Creo Elements/Pro reliability
GRANITE's modeling code uses the exact same geometry libraries as Creo Elements/Pro, the most robust solid modeler in the world. Accordingly, over 300,000 engineers use applications built on GRANITE today, and GRANITE has been used to design every variety of manufactured product, including mission-critical projects such as the X-38 Crew Return Vehicle for the International Space Station and the US Department of Energy's test facilities and style-intensive consumer products such as Mattel's Barbie® products or the Compaq iPAQ® handheld.
- Feature-based modeling
GRANITE contains a feature-based modeling kernel, which greatly simplifies the work of developing a modeling application with feature-level controls. Feature objects are part of the GRANITE model. All geometry in a GRANITE model is contained in features with built in history to show how the geometry is created. This allows easy rollback and undo / redo at the feature level. Undo is therefore available at the model level, not just the session level, and per-model deltas are saved in the model so they do not need to be regenerated when opened. Applications built on GRANITE can see the features and history in other applications' GRANITE data.
- Built-in translators
To enable data exchange with systems that do not employ GRANITE, GRANITE also includes translators for IGES, STEP, VDA, ACIS (SAT), JT (no libs), Parasolid, Creo Elements/View (neutral) and Creo Elements/Pro (neutral) for import and export, facilitating applications standards compatibility.
Of course, GRANITE can also read files from other applications built on GRANITE without translation or export.
- Support for metadata
GRANITE supports many types of non-geometric data through the metadata layer. Model data like color, parameter, name etc... can be associated with any GRANITE model, feature or entity.
- Modern architecture and bindings
Designed for use on the desktop and today's Internet infrastructure, the GRANITE API is exposed through objects with sophisticated interfaces available in Java and COM bindings, as well as C++.
A Java-based test harness used to display GRANITE models and support their interrogation and evaluation. It features a Java command-line interpreter for Java and GRANITE commands. Using gStudio, a user can prototype new code in the test harness and use journal files from the application to investigate software performance.
Is GRANITE designed to enable collaboration?
In today's engineering world, the ability to share design data is as important as the ability to create it. CAD data should be easily moved from application to application without being stripped of intelligence. GRANITE provides the power to share design data in highly diverse heterogeneous Product Development environments. Simply, applications built on GRANITE are empowered to share native CAD data with each other. Yes, GRANITE applications read each other’s native file formats directly. Aside from GRANITE's inherent ability to natively understand Creo Elements/Pro's (.prt, .asm and .neu) formats any licensee may also leverage GRANITE's gPlug architecture. The gPlug is a simple plug-in (.dll) supplied by the GRANITE licensed vendor of an application that authors data. The gPlug communicates with the GRANITE applications, resident in any environment, to recognize specific file formats. It directs the target application within a given file to the location of the relevant data. GRANITE itself then facilitates that stream of information into the target application. GRANITE enables collaboration by making data available in its native format to the users of multiple diverse applications.
What are the benefits a CAD vendor will realize via integrating GRANITE for unified associative access to multiple authoring applications' native data?
GRANITE files are associative and shared in their native format. Every time a change is made in a GRANITE-based authoring application downstream applications can update without the rework associated with cumbersome export processes. In the past, vendors have needed to maintain different integrations for each CAD program to allow end users to benefit from associativity. That cost dramatically added to software development expenses, because those vendors were required to keep their interfaces up-to-date with every release of each CAD application they supported.
This duplication of effort forces vendors to focus on only the best-selling CAD programs, and leaves new, innovative CAD technologies at a disadvantage.
Additionally, these CAD-specific integrations would require their users to purchase an additional and often redundant seat of the expensive CAD software. Since GRANITE allows for associativity at a native file level, users are not forced to pay a "CAD tax" and retain extra installations of the CAD application to simply leverage its data.
Who is eligible to use GRANITE?
PTC is eager to provide GRANITE development and distribution licenses to interested CAD application vendors who create and/or leverage 3D models, Creo Elements/Pro customers, and other interested parties.
How is GRANITE different from Creo Elements/Pro Toolkit?
Pro/TOOLKIT is a development solution for customizing the Creo Elements/Pro environment. Since Creo Elements/Pro Toolkit directly links with running Creo Elements/Pro sessions, in order to use a Creo Elements/Pro Toolkit -based product, Creo Elements/Pro must be purchased and installed. Creo Elements/Pro Toolkit is most useful to Creo Elements/Pro customers and developers creating extensions to Creo Elements/Pro typically through customization of the Creo Elements/Pro interface. Several areas of Creo Elements/Pro, such as drawings, sketches, and Pro/INTRALINK, have Creo Elements/Pro Toolkit API but are not within the scope of GRANITE.
GRANITE is a small library for inclusion in stand-alone applications. While it provides deeper access to geometry creation than Creo Elements/Pro Toolkit, it does not provide direct access to the Creo Elements/Pro application. In fact, other than its native ability to read Creo Elements/Pro files, GRANITE does not assume any knowledge of Creo Elements/Pro.
Where did GRANITE come from?
At PTC, we are proud of our in best-in-class collaboration and solid modeling technology, and we continually invest in Creo Elements/Pro's architecture, keeping it in a constant state of revitalization. As we've acquired design products and made them part of our associative solution set, we have enabled them with Creo Elements/Pro technology. Throughout that process, we have diligently created reusable technology components to most efficiently share these technologies with our multiple development teams worldwide. To release GRANITE, we have simply taken the decision to package and support these technologies for third parties.
Why did PTC decide to release GRANITE as a development solution?
We have created unprecedented interoperability between our own products, and we have actively embraced and participated in many committees for CAD data exchange, helping to extend and support STEP, IGES, and other protocols. Still, we decided to take it one step further. With our competency in solid modeling and data management, strong industry partners, and proven development track record, we intend to redefine the MCAD industry's expectations of CAD interoperability. GRANITE's associativity and native-file interoperability exemplify this strategy. Of course, GRANITE also includes translators for IGES, STEP, VDA, ACIS (SAT), JT (no libs), Parasolid, Creo Elements/View (neutral) and Creo Elements/Pro (neutral) for import and export, facilitating applications standards compatibility.
How can I get more information about GRANITE or obtain a copy of it?
Please contact: GRANITE@ptc.com
Architecture and Concepts
What language bindings and platforms does GRANITE support?
GRANITE's API is exposed through highly object-oriented interfaces, supporting Java, COM, and C++ language bindings.
Currently GRANITE is released and supported on Windows XP, Vista, Windows XP x64, Vista x64, SUN AMD 64bit.
What is the concept of a GRANITE feature?
GRANITE provides feature objects to structure modeling operations into a sequence of meaningful, discrete operations. Every modeling operation belongs to a feature, which then owns the geometry created by the feature operation.
- As an element of a model, a feature is a unit of Undo/Redo and Rollback.
- As a data container, features contain geometry created by modeling operations. The feature object provides methods to collect, search, visit faces, edges, curves, histories, and diagnostic items that belong to the feature.
- As a collection of methods, the feature object contains high-level modeling operations like Extrude, Revolve, and such, as well as low level modeling tools. GRANITE also includes advanced feature modeling extensions such as sweep, tweak, and round.
How does one keep track of entity names using GRANITE?
GRANITE automatically keeps track of the entity identification numbers (ids) consistently every time the model is regenerated, to provide associativity. The same modeling operation on the same inputs in the same feature will produce output faces and edges with the same ids. These ids are stable under geometric and, when possible, topological changes. Where they are ambiguous due to topology changes, GRANITE exposes a function to find alternates for referenced ids that have become unavailable.
Secondly, history and history searching mechanisms achieve a persistent per-feature mapping of very low-level operations and input ids to output ids. You can create your own semantic for an entity-tracking scheme via direct access to this history table.
How does GRANITE handle undo and rollback deltas?
GRANITE provides two mechanisms for part rollback: feature suppression and undo. These facilities work together to enable high-performance modeling.
Undo provides the ability to restore the state of the model to a previous state. Changes to each model can be undone and redone independently. Applications can set any number of marks on model and can undo and redo to those marks. Tracking a mark is as simple as holding a reference to it. Redo is supported by the same functions.
Rollback is a different mechanism, normally used when suppressing a feature, which reverts geometry and topology changes made by a feature. Rollback information is also persisted with the model, which means saved models need not be regenerated when loaded.
Does GRANITE take advantage of multi-processor platforms?
Yes, the most processor-intensive parallelizable operations are able to run in as many threads as the machine has processors.
How does GRANITE handle memory management?
With the same memory-management scheme used by Creo Elements/Pro, GRANITE requests memory from the operating system heap using standard techniques. The application does not need to provide any additional memory management utilities to the kernel. Heap memory is requested in large chunks, which are then allocated internally according to algorithms highly optimized for 3D geometric data.
How do applications store and read GRANITE data?
GRANITE serializes models as a stream of bytes. The application provides callback functions to store these data to whatever file or database is required by the application, and to read the data back from the file or database. Thus, the application has full control over the location and persistence of the data, while the geometric construction and interpretation of the data are handled by GRANITE.
The gPlug architecture builds on this concept by allowing any authoring application to create a small piece of code with standardized interfaces that provides access to the GRANITE stream and serves as a plug-in for other applications built on GRANITE.
How does GRANITE handle errors and exceptions?
In C++ and Java, GRANITE throws exceptions to signal error conditions. Exceptions in COM are handled using COM's standard error-handling facilities. The exception object contains detailed information about the error, such as the severity and type of error, the action that should be taken to recover, and specific geometric information depending on the particular error condition.
What geometric representation does GRANITE use for curves and surfaces?
GRANITE contains representations for construction geometry, quilts of surfaces, and boundary representations of solid models. These representations are optimized for mechanical design and handle common non-manifold situations that occur in mechanical designs.
All the curves and surfaces stored in GRANITE are non-procedural, and evaluators provided are precise and efficient. Analytic geometry is always used when possible.
GRANITE exposes the definition of a number of curve and surface types. Curves types include line, arc, ellipse, parabola, hyperbola, spline, bspline, and composite curves. Surface types include plane, cylinder, cone, torus, revolved, spline surface, and bspline surface.
Testing, Bug Reporting, and Support
Is there a journaling capability built in the kernel to assist in debugging and reporting bugs?
The GRANITE API calls can be recorded in a language neutral format that is easily converted to Java or C++ for execution in a debugging environment. You can also send journal files to PTC for bug reporting.
Is there a test harness to explore new functionality and to identify bugs?
gStudio, the GRANITE development environment, is a Java-based prototyping tool and test harness that displays GRANITE models, allows interrogation and evaluation, and has a Java command line interpreter of Java and GRANITE commands. Using gStudio, you can quickly prototype new code in the test harness and replay journal files from your application to identify bugs. You can also convert those files to C++ or Java code and reuse that code in your application.
What technical support exists for GRANITE?
GRANITE licensees under maintenance are entitled to call or email the GRANITE Support Hotline for implementation guidance or defect reporting. PTC will work to drive all questions and issues to resolution.
What documentation is available for GRANITE?
The GRANITE documentation set, supplied as on-line documentation to be read in a standard web browser, comprises:
- A functional overview of the GRANITE data model and modeling concepts
- A task guide that teaches the basics of the GRANITE API
- A browser-based class explorer API reference
- User documentation for supporting applications such as the gStudio
- GRANITE FAQs while using APIs from different modules
- Training classes and consultancy are also available