Table of contents
  1. Story
  2. Slides
    1. TBCME Workspace
    2. FIBO Files Directory
    3. TopBraid Composer ME: Loading Workbench
    4. TopBraid Composer ME Help
    5. FIBO Knowledge Base in a Spreadsheet
    6. MindTouch Knowledge Base for TopBraid Composer
    7. TopBraid Composer Multiple Views of an Ontology: Overview
    8. TopBraid Composer Multiple Views of an Ontology: Profile
    9. TopBraid Composer Multiple Views of an Ontology: Statistics
    10. TopBraid Composer Multiple Views of an Ontology: Form
    11. TopBraid Composer Multiple Views of an Ontology: Browser
    12. TopBraid Composer Multiple Views of an Ontology: Graph
    13. TopBraid Composer Multiple Views of an Ontology: Source Code
  3. Spotfire Dashboard
  4. Research Notes
  5. TopBraid Enterprise Vocabulary Net User and Reference Guide
    1. Introducing EVN
      1. 1. This guide
      2. 2. Conventions
    2. Getting started
      1. 1. Selecting a vocabulary
      2. 2. The vocabulary management screen
      3. 3. Editing a working copy
      4. 4. Reviewing and publishing your changes
      5. 5. Learning more
    3. User guide
      1. EVN Home Screen
      2. Concept Hierarchy
      3. Exporting a Vocabulary Concept Overview to Spreadsheet Format
    4. Administrator guide
      1. 1. Installing EVN
      2. 2. Your data and the SKOS standard
    5. Glossary
      1. attribute property
      2. clone
      3. concept
      4. concept type
      5. ontology
      6. production vocabulary
      7. properties
      8. relationship property
      9. scheme
      10. Teamworks
      11. working copy
  6. TopBraid Composer
    1. Getting Started
      1. What is TopBraid Composer?
      2. What are Ontologies?
      3. Help File Conventions
      4. Updating TopBraid Composer
      5. Workspaces, Projects, Folders and Files
    2. User Interface Overview
      1. Opening Views
      2. Labels Display Mode
      3. View Specific Icons and Menu Options
      4. Opening, Moving and Resizing Views
      5. Drag and Drop
      6. Navigation
    3. Resource Editor
      1. Form Panel
      2. Browser Panel
      3. Diagram Panel
      4. Graph Panel
      5. Form Layout Panel
      6. Source Code Panel
      7. Ontology Overview
      8. Ontology Profile
      9. Ontology Statistics
    4. Classes View
    5. Properties View
    6. Navigator View
    7. Associations View
    8. Basket View
    9. Domain View
    10. Relevant Properties View
    11. Inheritance View
    12. Instances View
    13. SPARQL View
    14. Inferences View
    15. Triples View
    16. Jena Rules View
    17. RDFa Editor
    18. Imports View
    19. Change History View
    20. Problems View
    21. Tasks View
    22. File Registry View
    23. Geography View
    24. Matrix View
    25. Configuring Preferences
      1. View Preferences
      2. View Preferences
      3. Forms Preferences
      4. Diagram Preferences
      5. Graph Preferences
      6. Turtle Preferences
      7. Source Code Preferences
      8. SPIN Preferences
    26. Web Data Basket
    27. Editing Ontologies and RDF Data
      1. Editing Ontologies
      2. Editing Instance Data
      3. Working with the Currently Displayed Resource
    28. Developing Semantic Web Applications
      1. SPARQL Web Pages (SWP)
      2. SWP Applications Library (SWA)
      3. Web Services
    29. TopBraid Live Integration
      1. Overview of TopBraid Live Integration
      2. SWP with TopBraid Live
      3. TopBraid Enterprise Vocabulary Net (EVN)
      4. SPARQL Endpoint
      5. SPIN Template Service
      6. The DESCRIBE Servlet
      7. The Edit Servlet (used by SWA edit forms)
      8. The Search Servlet
    30. Application Development Tools
      1. SPIN
        1. SPIN Overview
        2. SPIN Inferencing
        3. SPIN Statistics View
        4. User-Defined SPIN Functions and Templates
        5. Using JavaScript to define SPIN/SPARQL Functions
        6. Ontology Mapping with SPINMap
        7. SPIN Box
        8. SPIN Preferences
      2. SPARQLMotion Scripts (ME)
        1. SPARQLMotion Overview
        2. Editing SPARQLMotion Scripts
        3. Executing and Debugging SPARQLMotion Scripts
        4. Importing SPARQLMotion Scripts as RDF Graphs
        5. Understanding SPARQLMotion
        6. SPARQLMotion Module Library Reference
        7. SPARQLMotion Functions Reference
    31. Importing Data Sources
      1. Working with imported ontologies
      2. Import external information
        1. Import EMails
        2. Import Relational Databases with D2RQ
        3. Import RDFa data sources
        4. Import SPARQL endpoints
        5. Import Spreadsheets
          1. Import Tab-Separated Spreadsheets
          2. Handling Table documents with Semantic Tables
          3. Importing Excel File into Spreadsheet Ontology
        6. Import Text and HTML with the Calais Text Analysis web service
        7. Import Triples from selected File into current Model
        8. Import RDF Files into a new TDB
        9. Import XML Schema
        10. Import UML
        11. XSD to OWL Importer
        12. Add or Import External Triples
    32. Exporting Data Sources
      1. Export / Merge / Convert RDF Graphs
      2. Export Java RDFS/OWL Schema class
      3. Export XML from RDF/OWL
      4. Export XML Schemas from RDF/OWL
      5. Creating documentation for review
    33. Working with Data Back Ends
      1. Working with RDF Databases
      2. Working with Relational Databases
        1. Import Relational Databases with D2RQ​​
        2. Working with MySQL or Microsoft SQL Server Databases
      3. Secure Storage and Passwords
    34. Working with XML and Table files
      1. Handling Table documents with Semantic Tables
        1. How does Semantic Tables work?
        2. Importing Table Files
      2. Creating, Importing, Querying, Saving XML documents with Semantic XML
    35. Developing Web Data (Microdata, RDFa)
      1. Microdata and RDFa Web Data Sites
        1. Getting Started
        2. Working with Sites
      2. Web Data Basket
    36. RDF and TopBraid
      1. ​Semantic Web Standards
      2. Naming Conventions and Namespaces
      3. Named Graphs and Base URIs
      4. Using Reified Statements (statements about statements)
    37. Enterprise Vocabulary Net (EVN)
    38. Extending TopBraid Suite
    39. Data Integration
      1. Turning data into RDF
      2. Modeling data federations: owl:imports
      3. SPARQLMotion
      4. Federated SPARQL queries
    40. How to?
      1. Create a new ontology
      2. Open an existing ontology
      3. Create a new class
      4. Create a new property
      5. Create a local restriction
      6. Create a new instance
      7. Create an enumeration
      8. Define classes as intersections, unions and complements
      9. Specify disjoint classes
      10. Set domains and ranges
      11. Modify classes
      12. Create subclasses
      13. Modify properties
      14. Create subproperties
      15. Modify instances
      16. Define and execute rules
      17. Modify namespaces and prefixes
      18. View and edit ontology annotations
      19. Manage annotations
      20. Split classes and instances
      21. Run and configure inference engines
      22. Make inferences persistent
      23. Use search
      24. Compare RDF Models
      25. Test and debug ontologies
      26. Refactor ontologies
      27. Create SPARQL Queries by Example
      28. Resolve Out of Memory Problems
    41. Tips and Tricks
    42. Reference
      1. Icons Legend
      2. Manchester OWL Syntax
      3. SPARQLMotion Module Library Reference
      4. SPARQL Functions Reference
      5. TopBraid's SPARQL Property Functions
  7. Workbench User Guide
    1. Eclipse platform overview
    2. Getting started
    3. Concepts
    4. Tasks
    5. Reference
    6. Tips and tricks
    7. What's new
    8. Legal
  8. EGit Documentation
    1. EGit User Guide
    2. JGit User Guide
    3. EGit 1.0 New and Noteworthy
    4. JGit 1.0 New and Noteworthy
    5. Git for Eclipse Users
  9. Subversive User Guide
    1. Subversive overview
    2. Getting started
    3. Preferences
    4. Team support with SVN®
    5. Installation and migration
    6. FAQ
    7. Special Thanks
    8. Legal

TopBraid Composer

Last modified
Table of contents
  1. Story
  2. Slides
    1. TBCME Workspace
    2. FIBO Files Directory
    3. TopBraid Composer ME: Loading Workbench
    4. TopBraid Composer ME Help
    5. FIBO Knowledge Base in a Spreadsheet
    6. MindTouch Knowledge Base for TopBraid Composer
    7. TopBraid Composer Multiple Views of an Ontology: Overview
    8. TopBraid Composer Multiple Views of an Ontology: Profile
    9. TopBraid Composer Multiple Views of an Ontology: Statistics
    10. TopBraid Composer Multiple Views of an Ontology: Form
    11. TopBraid Composer Multiple Views of an Ontology: Browser
    12. TopBraid Composer Multiple Views of an Ontology: Graph
    13. TopBraid Composer Multiple Views of an Ontology: Source Code
  3. Spotfire Dashboard
  4. Research Notes
  5. TopBraid Enterprise Vocabulary Net User and Reference Guide
    1. Introducing EVN
      1. 1. This guide
      2. 2. Conventions
    2. Getting started
      1. 1. Selecting a vocabulary
      2. 2. The vocabulary management screen
      3. 3. Editing a working copy
      4. 4. Reviewing and publishing your changes
      5. 5. Learning more
    3. User guide
      1. EVN Home Screen
      2. Concept Hierarchy
      3. Exporting a Vocabulary Concept Overview to Spreadsheet Format
    4. Administrator guide
      1. 1. Installing EVN
      2. 2. Your data and the SKOS standard
    5. Glossary
      1. attribute property
      2. clone
      3. concept
      4. concept type
      5. ontology
      6. production vocabulary
      7. properties
      8. relationship property
      9. scheme
      10. Teamworks
      11. working copy
  6. TopBraid Composer
    1. Getting Started
      1. What is TopBraid Composer?
      2. What are Ontologies?
      3. Help File Conventions
      4. Updating TopBraid Composer
      5. Workspaces, Projects, Folders and Files
    2. User Interface Overview
      1. Opening Views
      2. Labels Display Mode
      3. View Specific Icons and Menu Options
      4. Opening, Moving and Resizing Views
      5. Drag and Drop
      6. Navigation
    3. Resource Editor
      1. Form Panel
      2. Browser Panel
      3. Diagram Panel
      4. Graph Panel
      5. Form Layout Panel
      6. Source Code Panel
      7. Ontology Overview
      8. Ontology Profile
      9. Ontology Statistics
    4. Classes View
    5. Properties View
    6. Navigator View
    7. Associations View
    8. Basket View
    9. Domain View
    10. Relevant Properties View
    11. Inheritance View
    12. Instances View
    13. SPARQL View
    14. Inferences View
    15. Triples View
    16. Jena Rules View
    17. RDFa Editor
    18. Imports View
    19. Change History View
    20. Problems View
    21. Tasks View
    22. File Registry View
    23. Geography View
    24. Matrix View
    25. Configuring Preferences
      1. View Preferences
      2. View Preferences
      3. Forms Preferences
      4. Diagram Preferences
      5. Graph Preferences
      6. Turtle Preferences
      7. Source Code Preferences
      8. SPIN Preferences
    26. Web Data Basket
    27. Editing Ontologies and RDF Data
      1. Editing Ontologies
      2. Editing Instance Data
      3. Working with the Currently Displayed Resource
    28. Developing Semantic Web Applications
      1. SPARQL Web Pages (SWP)
      2. SWP Applications Library (SWA)
      3. Web Services
    29. TopBraid Live Integration
      1. Overview of TopBraid Live Integration
      2. SWP with TopBraid Live
      3. TopBraid Enterprise Vocabulary Net (EVN)
      4. SPARQL Endpoint
      5. SPIN Template Service
      6. The DESCRIBE Servlet
      7. The Edit Servlet (used by SWA edit forms)
      8. The Search Servlet
    30. Application Development Tools
      1. SPIN
        1. SPIN Overview
        2. SPIN Inferencing
        3. SPIN Statistics View
        4. User-Defined SPIN Functions and Templates
        5. Using JavaScript to define SPIN/SPARQL Functions
        6. Ontology Mapping with SPINMap
        7. SPIN Box
        8. SPIN Preferences
      2. SPARQLMotion Scripts (ME)
        1. SPARQLMotion Overview
        2. Editing SPARQLMotion Scripts
        3. Executing and Debugging SPARQLMotion Scripts
        4. Importing SPARQLMotion Scripts as RDF Graphs
        5. Understanding SPARQLMotion
        6. SPARQLMotion Module Library Reference
        7. SPARQLMotion Functions Reference
    31. Importing Data Sources
      1. Working with imported ontologies
      2. Import external information
        1. Import EMails
        2. Import Relational Databases with D2RQ
        3. Import RDFa data sources
        4. Import SPARQL endpoints
        5. Import Spreadsheets
          1. Import Tab-Separated Spreadsheets
          2. Handling Table documents with Semantic Tables
          3. Importing Excel File into Spreadsheet Ontology
        6. Import Text and HTML with the Calais Text Analysis web service
        7. Import Triples from selected File into current Model
        8. Import RDF Files into a new TDB
        9. Import XML Schema
        10. Import UML
        11. XSD to OWL Importer
        12. Add or Import External Triples
    32. Exporting Data Sources
      1. Export / Merge / Convert RDF Graphs
      2. Export Java RDFS/OWL Schema class
      3. Export XML from RDF/OWL
      4. Export XML Schemas from RDF/OWL
      5. Creating documentation for review
    33. Working with Data Back Ends
      1. Working with RDF Databases
      2. Working with Relational Databases
        1. Import Relational Databases with D2RQ​​
        2. Working with MySQL or Microsoft SQL Server Databases
      3. Secure Storage and Passwords
    34. Working with XML and Table files
      1. Handling Table documents with Semantic Tables
        1. How does Semantic Tables work?
        2. Importing Table Files
      2. Creating, Importing, Querying, Saving XML documents with Semantic XML
    35. Developing Web Data (Microdata, RDFa)
      1. Microdata and RDFa Web Data Sites
        1. Getting Started
        2. Working with Sites
      2. Web Data Basket
    36. RDF and TopBraid
      1. ​Semantic Web Standards
      2. Naming Conventions and Namespaces
      3. Named Graphs and Base URIs
      4. Using Reified Statements (statements about statements)
    37. Enterprise Vocabulary Net (EVN)
    38. Extending TopBraid Suite
    39. Data Integration
      1. Turning data into RDF
      2. Modeling data federations: owl:imports
      3. SPARQLMotion
      4. Federated SPARQL queries
    40. How to?
      1. Create a new ontology
      2. Open an existing ontology
      3. Create a new class
      4. Create a new property
      5. Create a local restriction
      6. Create a new instance
      7. Create an enumeration
      8. Define classes as intersections, unions and complements
      9. Specify disjoint classes
      10. Set domains and ranges
      11. Modify classes
      12. Create subclasses
      13. Modify properties
      14. Create subproperties
      15. Modify instances
      16. Define and execute rules
      17. Modify namespaces and prefixes
      18. View and edit ontology annotations
      19. Manage annotations
      20. Split classes and instances
      21. Run and configure inference engines
      22. Make inferences persistent
      23. Use search
      24. Compare RDF Models
      25. Test and debug ontologies
      26. Refactor ontologies
      27. Create SPARQL Queries by Example
      28. Resolve Out of Memory Problems
    41. Tips and Tricks
    42. Reference
      1. Icons Legend
      2. Manchester OWL Syntax
      3. SPARQLMotion Module Library Reference
      4. SPARQL Functions Reference
      5. TopBraid's SPARQL Property Functions
  7. Workbench User Guide
    1. Eclipse platform overview
    2. Getting started
    3. Concepts
    4. Tasks
    5. Reference
    6. Tips and tricks
    7. What's new
    8. Legal
  8. EGit Documentation
    1. EGit User Guide
    2. JGit User Guide
    3. EGit 1.0 New and Noteworthy
    4. JGit 1.0 New and Noteworthy
    5. Git for Eclipse Users
  9. Subversive User Guide
    1. Subversive overview
    2. Getting started
    3. Preferences
    4. Team support with SVN®
    5. Installation and migration
    6. FAQ
    7. Special Thanks
    8. Legal

  1. Story
  2. Slides
    1. TBCME Workspace
    2. FIBO Files Directory
    3. TopBraid Composer ME: Loading Workbench
    4. TopBraid Composer ME Help
    5. FIBO Knowledge Base in a Spreadsheet
    6. MindTouch Knowledge Base for TopBraid Composer
    7. TopBraid Composer Multiple Views of an Ontology: Overview
    8. TopBraid Composer Multiple Views of an Ontology: Profile
    9. TopBraid Composer Multiple Views of an Ontology: Statistics
    10. TopBraid Composer Multiple Views of an Ontology: Form
    11. TopBraid Composer Multiple Views of an Ontology: Browser
    12. TopBraid Composer Multiple Views of an Ontology: Graph
    13. TopBraid Composer Multiple Views of an Ontology: Source Code
  3. Spotfire Dashboard
  4. Research Notes
  5. TopBraid Enterprise Vocabulary Net User and Reference Guide
    1. Introducing EVN
      1. 1. This guide
      2. 2. Conventions
    2. Getting started
      1. 1. Selecting a vocabulary
      2. 2. The vocabulary management screen
      3. 3. Editing a working copy
      4. 4. Reviewing and publishing your changes
      5. 5. Learning more
    3. User guide
      1. EVN Home Screen
      2. Concept Hierarchy
      3. Exporting a Vocabulary Concept Overview to Spreadsheet Format
    4. Administrator guide
      1. 1. Installing EVN
      2. 2. Your data and the SKOS standard
    5. Glossary
      1. attribute property
      2. clone
      3. concept
      4. concept type
      5. ontology
      6. production vocabulary
      7. properties
      8. relationship property
      9. scheme
      10. Teamworks
      11. working copy
  6. TopBraid Composer
    1. Getting Started
      1. What is TopBraid Composer?
      2. What are Ontologies?
      3. Help File Conventions
      4. Updating TopBraid Composer
      5. Workspaces, Projects, Folders and Files
    2. User Interface Overview
      1. Opening Views
      2. Labels Display Mode
      3. View Specific Icons and Menu Options
      4. Opening, Moving and Resizing Views
      5. Drag and Drop
      6. Navigation
    3. Resource Editor
      1. Form Panel
      2. Browser Panel
      3. Diagram Panel
      4. Graph Panel
      5. Form Layout Panel
      6. Source Code Panel
      7. Ontology Overview
      8. Ontology Profile
      9. Ontology Statistics
    4. Classes View
    5. Properties View
    6. Navigator View
    7. Associations View
    8. Basket View
    9. Domain View
    10. Relevant Properties View
    11. Inheritance View
    12. Instances View
    13. SPARQL View
    14. Inferences View
    15. Triples View
    16. Jena Rules View
    17. RDFa Editor
    18. Imports View
    19. Change History View
    20. Problems View
    21. Tasks View
    22. File Registry View
    23. Geography View
    24. Matrix View
    25. Configuring Preferences
      1. View Preferences
      2. View Preferences
      3. Forms Preferences
      4. Diagram Preferences
      5. Graph Preferences
      6. Turtle Preferences
      7. Source Code Preferences
      8. SPIN Preferences
    26. Web Data Basket
    27. Editing Ontologies and RDF Data
      1. Editing Ontologies
      2. Editing Instance Data
      3. Working with the Currently Displayed Resource
    28. Developing Semantic Web Applications
      1. SPARQL Web Pages (SWP)
      2. SWP Applications Library (SWA)
      3. Web Services
    29. TopBraid Live Integration
      1. Overview of TopBraid Live Integration
      2. SWP with TopBraid Live
      3. TopBraid Enterprise Vocabulary Net (EVN)
      4. SPARQL Endpoint
      5. SPIN Template Service
      6. The DESCRIBE Servlet
      7. The Edit Servlet (used by SWA edit forms)
      8. The Search Servlet
    30. Application Development Tools
      1. SPIN
        1. SPIN Overview
        2. SPIN Inferencing
        3. SPIN Statistics View
        4. User-Defined SPIN Functions and Templates
        5. Using JavaScript to define SPIN/SPARQL Functions
        6. Ontology Mapping with SPINMap
        7. SPIN Box
        8. SPIN Preferences
      2. SPARQLMotion Scripts (ME)
        1. SPARQLMotion Overview
        2. Editing SPARQLMotion Scripts
        3. Executing and Debugging SPARQLMotion Scripts
        4. Importing SPARQLMotion Scripts as RDF Graphs
        5. Understanding SPARQLMotion
        6. SPARQLMotion Module Library Reference
        7. SPARQLMotion Functions Reference
    31. Importing Data Sources
      1. Working with imported ontologies
      2. Import external information
        1. Import EMails
        2. Import Relational Databases with D2RQ
        3. Import RDFa data sources
        4. Import SPARQL endpoints
        5. Import Spreadsheets
          1. Import Tab-Separated Spreadsheets
          2. Handling Table documents with Semantic Tables
          3. Importing Excel File into Spreadsheet Ontology
        6. Import Text and HTML with the Calais Text Analysis web service
        7. Import Triples from selected File into current Model
        8. Import RDF Files into a new TDB
        9. Import XML Schema
        10. Import UML
        11. XSD to OWL Importer
        12. Add or Import External Triples
    32. Exporting Data Sources
      1. Export / Merge / Convert RDF Graphs
      2. Export Java RDFS/OWL Schema class
      3. Export XML from RDF/OWL
      4. Export XML Schemas from RDF/OWL
      5. Creating documentation for review
    33. Working with Data Back Ends
      1. Working with RDF Databases
      2. Working with Relational Databases
        1. Import Relational Databases with D2RQ​​
        2. Working with MySQL or Microsoft SQL Server Databases
      3. Secure Storage and Passwords
    34. Working with XML and Table files
      1. Handling Table documents with Semantic Tables
        1. How does Semantic Tables work?
        2. Importing Table Files
      2. Creating, Importing, Querying, Saving XML documents with Semantic XML
    35. Developing Web Data (Microdata, RDFa)
      1. Microdata and RDFa Web Data Sites
        1. Getting Started
        2. Working with Sites
      2. Web Data Basket
    36. RDF and TopBraid
      1. ​Semantic Web Standards
      2. Naming Conventions and Namespaces
      3. Named Graphs and Base URIs
      4. Using Reified Statements (statements about statements)
    37. Enterprise Vocabulary Net (EVN)
    38. Extending TopBraid Suite
    39. Data Integration
      1. Turning data into RDF
      2. Modeling data federations: owl:imports
      3. SPARQLMotion
      4. Federated SPARQL queries
    40. How to?
      1. Create a new ontology
      2. Open an existing ontology
      3. Create a new class
      4. Create a new property
      5. Create a local restriction
      6. Create a new instance
      7. Create an enumeration
      8. Define classes as intersections, unions and complements
      9. Specify disjoint classes
      10. Set domains and ranges
      11. Modify classes
      12. Create subclasses
      13. Modify properties
      14. Create subproperties
      15. Modify instances
      16. Define and execute rules
      17. Modify namespaces and prefixes
      18. View and edit ontology annotations
      19. Manage annotations
      20. Split classes and instances
      21. Run and configure inference engines
      22. Make inferences persistent
      23. Use search
      24. Compare RDF Models
      25. Test and debug ontologies
      26. Refactor ontologies
      27. Create SPARQL Queries by Example
      28. Resolve Out of Memory Problems
    41. Tips and Tricks
    42. Reference
      1. Icons Legend
      2. Manchester OWL Syntax
      3. SPARQLMotion Module Library Reference
      4. SPARQL Functions Reference
      5. TopBraid's SPARQL Property Functions
  7. Workbench User Guide
    1. Eclipse platform overview
    2. Getting started
    3. Concepts
    4. Tasks
    5. Reference
    6. Tips and tricks
    7. What's new
    8. Legal
  8. EGit Documentation
    1. EGit User Guide
    2. JGit User Guide
    3. EGit 1.0 New and Noteworthy
    4. JGit 1.0 New and Noteworthy
    5. Git for Eclipse Users
  9. Subversive User Guide
    1. Subversive overview
    2. Getting started
    3. Preferences
    4. Team support with SVN®
    5. Installation and migration
    6. FAQ
    7. Special Thanks
    8. Legal

Story

Using TopBraid Composer ME on FIBO Ontologies

I downloaded and installed TopBraid Composer Maestro Edition 30-day free trial.

I explored the Help which has four sections:

From a quick perusal of the last three, I do not think I need to review those now.

So the idea was to extract enough from the TopBraid Composer Documentation (see excerpts for the 18 sections below) to build an application:

 

First, I found Open an existing ontology: In order for TopBraid Composer to see an ontology, it must be located in one of the workspace folders.

 

So I created a workspace folder for FIBO and then subfolders for the two types of FIBO ontologies: BE and FND

 

Then I opened TBCME and those ontologies.

 

See slides below for screen captures of the major steps:

 

Some highlights for building applications were:

  • Import Relational Databases with D2RQ​​
    • D2RQ is an open-source project by Chris Bizer and colleagues at the Free University of Berlin. D2RQ is a declarative language to describe mappings between relational database schemata and RDF/OWL ontologies. You may find it useful to familiarize yourself with the D2RQ mapping language before using this feature.
  • Import external information
    • TopBraid Composer provides various import wizards that can be used to convert files in other formats into RDF/OWL. All of these are available if you right-click on a folder in the Navigator and then select Import...
  • Enterprise Vocabulary Net (EVN)
    • If your data is not stored using the RDF data model, but is in a spreadsheet, a tab-delimited file, a relational database, or an XML file, TopBraid Composer can automate the conversion of these and other formats into RDF.
  • Data Integration
    • TopBraid provides several ways to support data integration. In all cases, the first step is to render all datasets to be integrated as RDF. Once these datasets are available as RDF, there are several ways to merge them.

 

This is like Be Informed: Vocabulary and Taxonomy/Thesaurus comes before Ontology/Rules, but different because one needs a Model to build an application. Be Informed can covert an Ontology into a Model using their Be Free Studio Business Process Platform, but clearly one needs so much more that an Ontology that why not start with a Model in the first place.

 

Postscript

The TopBraid Composer Getting Started Guide (PDF - Version 3.0-July 18, 2011) is a tutorial that will help you get familiar with the TopBraid Composer interface, the creation and editing of ontologies, OWL classes, and RDF data, as well as SPARQL queries, file management, and the use of imports. As you edit your ontologies and data instances, also remember the User Interface Overview, which gives details on each of the views in the TopBraid Composer interface.)​

 

For more information about TopBraid Suite and TopQuadrant visit http://www.topquadrant.com. For additional information about TopBraid Composer, please visit http://www.topbraidcomposer.com

 

In order to be notified if a major version exists, and to learn about other new developments, please subscribe to our mailing list http://groups.google.com/group/topbraid-users

Slides

TBCME Workspace

TBCMEWorkspace.png

FIBO Files Directory

FIBODirectory.png

TopBraid Composer ME: Loading Workbench

TopBraidComposerMELoadingWorkbench.png

TopBraid Composer ME Help

TopBraidComposerHelp.png

FIBO Knowledge Base in a Spreadsheet

FIBOSpreadsheet-KnowledgeBase.png

MindTouch Knowledge Base for TopBraid Composer

TopBraidComposerMindTouchKnowledgeBase.png

 

TopBraid Composer Multiple Views of an Ontology: Overview

TopBraidComposerControlParties.rdfOverview.png

 

TopBraid Composer Multiple Views of an Ontology: Profile

TopBraidComposerControlParties.rdfProfile.png

 

TopBraid Composer Multiple Views of an Ontology: Statistics

TopBraidComposerControlParties.rdfStatistics.png

 

TopBraid Composer Multiple Views of an Ontology: Form

TopBraidComposerControlParties.rdfForm.png

 

TopBraid Composer Multiple Views of an Ontology: Browser

TopBraidComposerControlParties.rdfBrowser.png

 

TopBraid Composer Multiple Views of an Ontology: Graph

TopBraidComposerControlParties.rdfGraph.png

 

TopBraid Composer Multiple Views of an Ontology: Source Code

TopBraidComposerControlParties.rdfSourceCode.png

Spotfire Dashboard

 

Research Notes

 

TopBraid Enterprise Vocabulary Net User and Reference Guide

Source: http://topquadrant.com/topbraid/evn/43doc/

Introducing EVN

TopQuadrant's TopBraid Enterprise Vocabulary Net™ (EVN) is a flexible, web-based solution for managing semantic information models (taxonomies, business vocabularies, master and reference data) to support a variety of business objectives such as content delivery, search, navigation, data integration and disambiguation of terms.

EVN gives you:

  • An intuitive graphical user interface
  • Multi-user support
  • Editing and review of multiple working copies of a model without affecting the production model until changes are published
  • Support for unlimited number of custom concept types (classes) and associated properties
  • Different access to models and their working copies for different staff members depending on their assigned roles
  • Change tracking
  • Data quality rules
  • Custom reports, saved searches and web services
  • Integration with third party systems and Linked Data clouds
  • Support for all relevant W3C standards such as SKOS and RDF
  • Easy extensibility of features using TopQuadrant's TopBraid platform

EVN lets you create, edit, and use vocabularies, ontologies, and content tag sets.

Vocabularies are datasets that are based on SKOS, the W3C standard and ontology designed for the needs of people managing taxonomies, thesauruses, and other controlled vocabularies with associated metadata.

Ontologies are non SKOS-based datasets. Some ontologies may contain schema-level information only—that is, definitions of classes and properties. (The W3C's SKOS ontology is one example.) Other ontologies may contain data as well as schemas. Using imports, one can combine ontologies with SKOS-based vocabularies.

Content tag sets are datasets that link information in one dataset with the information in another one. Typically, one of the datasets is a vocabulary whose values are used to tag information in another dataset. The dataset containing tagged items often comes from a content management repository such as SharePoint. In this case, the information being tagged may not be stored in EVN, but rather accessed by EVN through a real-time connection to another store such as a content management system. When creating tags, any property or a set of properties may be used to link vocabulary values to content items for tagging. See Using EVN Tagger for information on creating tag sets.

1. This guide

This user and reference guide has the following chapters:

Introducing EVN This chapter.

Getting started with vocabulary editing A tutorial to get you up and running using the most important features of using EVN to manage SKOS-based vocabularies.

User guide A tutorial to get you up and running using the most important features of EVN.

Administrator guide Setup issues for EVN and advanced techniques for data preparation using TopBraid Composer.

Glossary Definitions of the key terminology used by EVN to manage your semantic models.

2. Conventions

Names for user interface widgets and menu options are presented in a style like this.

Where exercises require information to be typed into EVN, a monospaced font is used like this.

Exercises and required tutorial steps are presented like this:

Execute the first step.

Then, execute the second step.

Here is the third step to carry out.


 

Tips and suggestions for using EVN are presented like this.


 

Potential pitfalls and warnings are presented like this.


 

General notes are presented like this.

Getting started

This chapter shows you how to edit a vocabulary, manage a set of edits, and review the change history with TopBraid Enterprise Vocabulary Net (EVN).

1. Selecting a vocabulary

To start up the tutorial version of EVN, first make sure that TopBraid Composer Maestro Edition is up and running, and then send your browser to http://localhost:8083/evn. (If using the enterprise version of EVN, ask your system administrator about the appropriate URL.) If you are using the TopBraid Composer demo version of EVN, use the name Administrator, which is a default name included with the installation; otherwise, use the login name assigned to you for your system.

icon-tip.jpgNote also the "Guide to the Enterprise Vocabulary Net " link to the EVN documentation.

After you log in you'll see the program's main screen. The top part lists the vocabularies installed with the program and metadata about each one:

EVN home screen.png

icon-note.jpgFor a brand-new installation, you may only have the Geography and IPTCNewscodes vocabularies installed. For this tutorial, you'll work with the Geography vocabulary. (If you're using the enterprise version of EVN and don't see it, contact your system administrator.) For information on creating a new vocabulary, see Creating a new vocabulary in the User Guide chapter.

Metadata about each vocabulary includes the user name of the person who created it, the date and time of its creation, the number of working copies associated with that vocabulary, and the number of users who have been assigned Viewer, Editor, or Manager roles for the that vocabulary.

If you're logged in as the Administrator, the title of the Geography Vocabulary will be a hypertext link. Click that link to go to the management screen for that vocabulary.

2. The vocabulary management screen

A vocabulary's management screen gives you access to the production copy of the vocabulary and, if you have been granted the appropriate role, to working copies of that vocabulary. You can also create new working copies.

The production copy is the version of the vocabulary currently in use. For example, an online store that organizes menus of product categories based on a managed vocabulary would use the production vocabulary when it builds the menus used on their website.

A working copy is a virtual copy of the production vocabulary created for editing purposes. A working copy may go through a workflow approval process, after which the changes made to it may get published to the production vocabulary at the discretion of the vocabulary manager. There may be several working copies in existence at once as users in various roles make and review changes in those working copies.

3. Editing a working copy

Because you're logged in as Administrator, you are the Vocabulary Manager for the Geography vocabulary, so you have all possible permissions associated with it. Users assigned less powerful roles for the Geography Production Vocabulary or the South Korea Updates working copy will not see as many choices available on the working copy's management screen—for example, someone in a Vocabulary Viewer role would not see the Edit Working Copy link:

4. Reviewing and publishing your changes

icon-note.jpgIn a large metadata management environment, you might have one person creating the working copy, several others editing it, additional people reviewing the changes, and another person publishing the changes to the production copy, but for this tutorial, you're doing all of these yourself.

 

5. Learning more

You're now ready to explore the User guide chapter to learn about all the other features available as you use TopBraid Enterprise Vocabulary Net. You'll find out how to view reports on vocabularies, how to export them to and import them from spreadsheets and other formats, how to perform batch operations on them, and more.

User guide

This chapter shows you how you can use EVN to perform the basic tasks associated with the editing and maintenance of multi-user vocabularies.

EVN Home Screen

EVN home screen.png

Concept Hierarchy

Concept Hierarchy.jpg

Exporting a Vocabulary Concept Overview to Spreadsheet Format

Exporting a vocabulary concept overview to spreadsheet format.png

Geography Vocabulary Imported Into Microsoft Excel

Geography vocabulary imported into Microsoft Excel.jpg

Administrator guide

This chapter describes setup issues for EVN and advanced techniques for EVN data preparation using TopBraid Composer.

1. Installing EVN

A demo version of TopBraid EVN is included with the TopBraid Composer Maestro Edition so that TBCME users can try EVN without purchasing and setting up the EVN Server. No additional installation steps are required beyond the normal TBC install process. See the Getting Started guide for information on how to start using EVN with TBCME.

To deploy EVN in a multi-user environment, you will need the EVN server. See Supported Platform Configurations for Enterprise Vocabulary Net (EVN) for information on system requirements for running EVN with TBL. Running EVN in a multi-user server environment requires the use of EVN's Jena SDB interface for storage, which relies on a relational database backend. We recommend using either MySQL or Oracle relational databases.

Instructions for installing EVN on the server are provided to licensed customers of EVN. Please contact us at sales@topquadrant.com if you need to evaluate EVN on the server.


icon-note.jpgA collection of concepts is known as a concept scheme. If the vocabulary that you created did not have a concept scheme defined, the first time you view it in EVN the you'll see a concept scheme named "CONCEPT SCHEME UNDEFINED." Edit its preferred label to change it to a name appropriate to your vocabulary.

2. Your data and the SKOS standard

EVN uses the W3C SKOS (Simple Knowledge Organization System) standard to model vocabulary data and metadata. SKOS is an OWL ontology that defines properties for most of the information that vocabulary managers want to store. Because SKOS uses the OWL standard, you can easily extend it to include additional custom properties by using a tool such as TopBraid Composer.

SKOS (and OWL) data use the RDF data model. If you have data that follows the RDF model but does not use properties from the SKOS ontology, you can convert it using the SPARQL RDF query language in TopBraid Composer. If your data is not stored using the RDF data model, but is in a spreadsheet, a tab-delimited file, a relational database, or an XML file, TopBraid Composer can automate the conversion of these and other formats into RDF. Then, you can can use SPARQL CONSTRUCT queries to convert the data to SKOS so that you can manage it with EVN. For more information on running SPARQL queries in TopBraid Composer, see TopBraid Composer > User Interface Overview > SPARQL in the TopBraid Composer online help.

Glossary

attribute property

A value associated with a concept that is stored as a string, number, or some other kind of atomic value. A concept's preferred label is one example of an attribute property. Compare relationship property.

clone

A copy of a concept, with all its metadata. Creation and editing of clones can be a useful way to create new concepts with minimal data entry.

concept

The basic unit of a vocabulary. A concept is usually known by its preferred label, and can have various kinds of metadata assigned to it. See properties.

concept type

A subset of a vocabulary's concepts grouped together for easier management. The concepts within a given type may themselves be grouped into subtypes of that type. Different concept types can have different custom attribute and relationship properties. Also known as a class.

ontology

A description of concepts in a business area. Ontologies can be combined using EVN's import feature. An ontology is an information model.

production vocabulary

The version of an information model currently in use. For example, someone assigning keywords to magazine articles to make them easier to retrieve at a later point would be finding these terms to assign in the production vocabulary. Compare working copy.

properties

The data associated with a given concept, such as its preferred label, broader and narrower concepts, and annotations such as scope notes. See also attribute properties and relationship properties.

relationship property

A value associated with a concept that is a pointer to another concept. For example, a concept with the preferred label "dog" may have a value in its "broader" relationship property pointing to the concept with the preferred label "mammal" and a value in its "narrower" relationship property pointing to the concept with the preferred label "collie". Also known as an object property.

scheme

a set of concepts grouped together into a list or hierarchy. It might represent a taxonomy, a thesaurus, a code list, or any other controlled vocabulary. A vocabulary may be a single scheme, but because of EVN's ability to group several vocabularies together, some may appear as multiple schemes. For example, you might have a taxonomy of apparel products and another of colors in which the clothing was available both displayed at the same time.

Teamworks

Repository a version of the vocabulary data that stores an audit trail of changes made to the vocabulary along with the vocabulary itself.

A set of business concepts described using SKOS. These are typically used for taxonomies or reference data that is hierarchical in nature.

working copy

A virtual copy of the production information model created for editing purposes. A working copy may go through a workflow approval process, after which the changes made to it may or may not get made to the official production information model. There may be several working copies in existence at once as users in various roles make and review changes in those working copies.

TopBraid Composer

Getting Started

Welcome to TopBraid Composer, a standards-compliant tool for the development of Semantic Web applications and domain models.

Note that TopBraid Composer comes in three editions:

  • Free Edition (FE) is an introductory version with only a core set of features.
  • Standard Edition (SE) includes all the features of FE plus graphical viewers, import facilities, advanced refactoring support and much more.
  • Maestro Edition (ME) includes all the features of SE plus support for TopBraid Live, EVN and SWP as well as SPARQLMotion and many other power user features. These combine to make TBC-ME an Integrated Development Environment (IDE) for TopBraid Live and TopBraid solutions.

This section provides an introductory overview of TopBraid Composer. It describes all major user interface features and their functions.

If you are new to TopBraid Composer, you may want to switch on context-sensitive help using Help > Dynamic Help. This will open up a help window on the right part of your screen. This help window will suggest topics whenever you click on another view or editor in TopBraid. For example, clicking on the Classes View will suggest a link to the corresponding help page.

The help pages contain descriptions of all features, but clearly indicate the required edition for each feature. TopBraid Composer SE and ME require (different) license keys.

 

Getting Started.png

What is TopBraid Composer?

TopBraid Composer, a component of TopBraid Suite, is a professional development tool for semantic models (ontologies). It is a complete editor for RDF(S) and OWL models, as well as a platform for other RDF-based components and services.

TopBraid Composer enables individual users and communities to collaborate effectively in developing Semantic Web ontologies. Key features of TopBraid Composer include:

  • Standards-based, syntax directed development of RDFS and OWL ontologies, SPARQL queries and Rules
  • Re-use of the legacy models and data through XML, UML, spreadsheet and relational database imports
  • Visualization and diagramming
  • Support for re-factoring within and across ontologies
  • Consistency checking, debugging and reasoning with various inference engines
  • Support for the SPIN Inferencing Notation (SPIN)
  • Support for scalable database back-ends including AllegroGraph, Jena, Oracle and Sesame
  • Multi-User mode
  • Built-in mash-up facilities such as geographical mapping
  • Support for the visual scripting language SPARQLMotion that can be used to automate all kinds of data processing tasks and to create Web Services

TopBraid Composer is implemented as a collection of Eclipse plugins. This means that Composer is built on a solid platform with a large user base. Many other Eclipse plugins for editing other languages such as UML and XML exist, and therefore users can use a single tooling environment for many different modeling tasks. Furthermore, the foundation on the Eclipse plugin architecture means that developers can build additional services (such as custom visualization and reasoning engines) on top of TopBraid Composer. Composer provides new extension points to integrate custom-tailored components.

TopBraid Composer is built on top of Jena, a Semantic Web framework from HP Labs. Jena is open-source and plugin developers will be able to exploit arbitrary Jena-based services.

Finally, TopBraid Composer is shipped with various OWL and RDF inference engines including OWLIM, and TopSPIN. Additional inference engines can be integrated and specified in the configuration preferences.

For more information about TopBraid Suite and TopQuadrant visit http://www.topquadrant.com. For additional information about TopBraid Composer, please visit http://www.topbraidcomposer.com

What are Ontologies?

An ontology defines the concepts and relationships used to describe and represent an area of knowledge (subject matter). It provides:

  • A vocabulary
  • A shared language

An ontology is defined using constructs for:

  • Concepts - classes
  • Relationships - properties (object and data)
  • Rules - axioms and constraints
  • Instances of concepts - individuals (data)

Ontologies can be used for many purposes, including enterprise integration, information retrieval, network management and information interchange on the World Wide Web. Ontologies can contain business rules and definitions which are processed and enforced at run time by standard inferencing components. This enables application code for semantic (ontology-based) systems to be thinner and more generic.

TopBraid Composer supports the creation of semantic web ontologies - information models specified using the W3C standards RDFS and/or OWL.

RDFS and OWL are languages with clearly defined semantics or mathematical basis for the meaning of each construct. Semantics are defined in terms of inferences each statement entails. Since concepts in RDFS and OWL ontologies are expressed formally, they can be processed by computer programs. Because traditional modeling techniques (such as entity relationship) describe concepts only semi-formally, they cannot be handled automatically by software without significant human programming effort to make their meanings explicit.

Similarities and differences between ontologies and other types of information models can be described in the following way:

  • Like databases, ontologies are used by applications at run time (queried and reasoned over)
    • Unlike databases, relationships are first-class constructs
    • Unlike databases, ontologies can easily change their schema at run-time
  • Like object models, ontologies describe classes and attributes (properties)
    • Unlike object models, ontologies are set-based
  • Like business rules, ontologies encode rules
    • Unlike business rules, ontologies organize rules using axioms
  • Like XML schemas, ontologies are native to the web (and can be serialized in XML)
    • Unlike XML schemas, ontologies are graphs not trees and can be used for reasoning

Help File Conventions

This help file uses the following conventions:

  • Any option that you need to select (a button or icon, tab or menu option) is shown in bold.

For example:  Click the  Create Property icon.

  • Any text you need to enter and the names of RDF identifiers are shown in a Courier font.

For example: In the rdfs:subClassOf field, enter tqec:perform all tqec:BusinessActivity

  • TopBraid Composer uses a modified Manchester OWL Syntax. Elements of the syntax are shown in bold purple or bold navy as appropriate.

For example: all, some, and and or.       

Updating TopBraid Composer

To install the latest update of TopBraid Composer select Help > Software Updates from the menu. On the next screen select TopBraid Composer and then Update....

After install is complete you will be given an option to re-start Eclipse. Select Yes.

In order to be notified if a major version exists, and to learn about other new developments, please subscribe to our mailing list http://groups.google.com/group/topbraid-users

Workspaces, Projects, Folders and Files

TopBraid Composer is organized around a workspace containing the files and folders of RDF and OWL files that you are using. As TopBraid Composer starts up, the user specifies the "workspace" directory to use. While TopBraid Composer can in principle be used to open RDF and OWL files from anywhere on your hard drive (with File > Open...), it is strongly recommended to use the built-in "workspace" mechanism to manage your project. Depending on how TopBraid Composer has been installed, when it is started for the first time, the user specifies a home directory for the "workspace". Everything below this directory is considered part of the workspace, arranged into Projects, Folders and Files. The workspace is typically displayed in a view called Navigator. TopBraid Composer creates its own system projects within the workspace, most notably the "TopBraid" project which is used for system ontologies and for reference ontologies from the Web. TopBraid Composer Maestro Edition and TopBraid Live both have additional system projects that are used in some of the extended features. You can create additional projects within the workspace for your own work. In the Navigator screenshot below, you can see one project ("TopBraid"), five folders ("Common" etc), and several files (geotravel.owl etc).

Workspaces, Projects, Folders and Files.png

The files relevant to TopBraid Composer display their namespace behind them. Composer handles the following file types:

  • .owl, .rdf, .rdfs - OWL and RDF Schema files in the standard RDF/XML serialization
  • .ttl, .n3, .nt - OWL and RDF Schema files in the Turtle, N3 and N-Triple files serializations
  • .sdb and .tdb - Connection data for Jena SDB or TDB database
  • .oracle - Connection data for an Oracle RDF database
  • .s2r - Connection data for Sesame 2 databases
  • .ag4 - Connection data for an AllegroGraph 4 database (separate download)
  • .rdfa - RDFa sources
  • .smg - SPARQLMotion Graphs
  • .mds and .rds - Microdata and RDFa Sites

There are several other types of files that TopBraid Composer can use as sources for RDF triples in data integration scenarios.

  • .d2rq - Metadata for a mapping into a relational database using D2RQ
  • .xml - XML documents can be loaded using Semantic XML (ME)
  • .txt - Text files can be imported using OpenCalais
  • .xls, .csv or .tsv - Excel, comma-separated and tab-separated files using Semantic Tables

Additional formats such as UML can be imported using the Import wizards.

Files with different extensions can not be opened with Composer, but for example with the built-in Eclipse text editor.

You should start populating your workspace by creating a new project:

  • From the menu bar, select File > New > Project...
  • Select General / Project from the resulting dialog and enter project name.

Note that you should not create new files in the TopBraid project, which is reserved to system ontologies and may be updated when you install a new version of TopBraid Composer. All files in the TopBraid project (except in the Examples folder) will be automatically marked as read-only.

You can now create folders to organize your data sources.

To create a new folder use  File > NewFolder menu options.

Once a folder is created within Composer, you can copy and paste existing files into it using your File Management system, such as Windows Explorer. internet.

Note that by default Composer will only see folders that have been created using it. If you have an existing folder structure under the Workspace directory, it will not be recognized by Composer and will not appear in the Navigator View. Whenever you have made changes to files outside of Composer, you should refresh the navigator (F5) so that Eclipse (and Composer) can update its file registry. If you are working with multiple files and imports, you should get familiar with the mechanisms of import resolution of Composer.

If you have existing folder structures that lie outside of the workspace, and you don't want to copy them under the workspace root, then you can create linked folders in your workspace. In order to do so, uncheck the "Use default location" box and enter the absolute path to the external folder under "Location" in the folder creation dialog. This option will let you see and update your ontologies from their original location. In the screenshot below, the folder "models" links to a folder outside of the workspace file structure.

In order to maintain multiple workspaces on a single computer, the workspace directory can be modified using File > Switch Workspace menu option.

User Interface Overview

TopBraid Composer consists of the following views and editors:

  • Navigator shows the files in the Eclipse workspace
  • Classes, Properties and Associations views display the hierarchies of the current model
  • Instances shows the instances of the class selected in the Classes View
  • Domain shows those properties that have the selected class in their domain
  • Relevant Properties shows those properties that are likely to have values for the current resource
  • Inheritance shows the superclasses and inherited restrictions of the current class
  • Imports shows the imports of the ontology (hierarchically)
  • Change History shows the recent edit steps
  • Resource Editor is the main work area, it shows the currently selected resource
  • SPARQL provides an interface to run SPARQL queries
  • SPIN Statistics shows statistics about the execution time of SPIN queries
  • Jena Rules shows all Jena rules in the model
  • Triples View shows all RDF triples in your current model
  • File Registry shows a list of all files together with their namespaces
  • Basket can be used as a flexible drag-and-drop area for many purposes
  • Problems View shows violations of constraints in your ontologies
  • Task View can be used to manage open issues with a TODO item list
  • Geography and Matrix views can be used to visualize information for creating mash-ups
  • Web Data Basket View can be used to incrementally collect RDF triples from visited web pages
  • RDFa Editor is a text-based editor for RDFa

Opening Views

If a view does not appear in the TopBraid Composer perspective, use Window > Show View to choose a view and make it visible.

Labels Display Mode

TopBraid Composer supports two modes for displaying the labels of resources, for example in the classes tree and on forms: qnames and human-readable labels. The main tool bar has a button for switching between those two modes SwitchLabels.gif.

By default, resources are displayed with their "qname". A qname consists of a prefix and a local name. For example, the resource http://example.org/ontology#Person would be displayed as ex:Person if the namespace http://example.org/ontology# is abbreviated with the prefix ex. qnames make it easy to identify the namespace, which is especially relevant if your project consists of multiple files or modules. Furthermore, qnames are used in the syntax of all common RDF/OWL serializations as well as several languages including SPARQL. The following image shows the the Classes and Associations view in qnames.

User Interface Overview1.png

In the "human-readable" labels mode, the system will try to display resources by their rdfs:labels (or sub-properties of rdfs:label). If no such labels are found, or if there is a name conflict between multiple resources with the same label, then the system will fall back to displaying qnames as above. Human-readable labels are a good choice if the model contains cryptic URIs/qnames, or if you want to switch between languages. The preferred label language(s) can be configured in the main TopBraid Composer preferences page. The following image show the same model as the previous image in the labels mode.

 

User Interface Overview2.png

 

View Specific Icons and Menu Options

As shown in the screenshot of the Classes View below, each view has a set of icons unique to the view. These are used to create and delete objects. In this example, they are icons for creating , and deleting classes. In most cases, these commands (and additional items) are also accessible from the drop-down menu to the right of the icons.

User Interface Overview3.png

 

Opening, Moving and Resizing Views

To open or reopen a closed view, select Window > Show View from the main menu bar, then select the view to open it.

All Composer views can be dragged and rearranged as necessary. They can also be resized, collapsed and expanded.

To move a view, click on the tab with its name (the tab color will become blue) and move it to the desired location.

Drag and Drop

Drag and drop is available throughout the user interface. Class and property trees can be rearranged using drag and drop. Resources can be dragged and dropped on to the Resource Editor or into the Domain View. Drag and drop can also be used to move objects between ontologies. In many cases you will find the Basket view as a very convenient place to drop and collect resources.

Navigation

There is always one "selected" ontology model, and one "selected" ontology resource (class, property, individual, etc). The selected resource must always be from the selected model. The Resource Editor displays the currently selected resource, which is also shown in the toolbar. In the screenshot below, the class "Accommodation" is selected.

 

User Interface Overview4.png

 

 

A resource can be selected in various ways. In most views, you can double-click on the name or icon of the resource. If you click directly on the icon, then a single click is sufficient to select it. Alternatively, if a tree or list of resources has the keyboard focus, you can press Alt+UP/DOWN to change the global selection. Finally, you can enter the name of the resource in the toolbar field shown above. Here, CTRL+Space will help you enter a full name if you only enter the first few characters.

 

If a file is double-clicked in the Navigator, it will be loaded (unless it has been already opened and loaded, in which case it becomes the selected ontology model). When an owl file is first loaded into Composer, the selected resource is the main owl:Ontology in the file. It is displayed in the Resource Editor, enabling you to view and edit the namespaces.

Backward (ALT+Left) and forward (ALT+Right) arrows on Composer's tool bar enable quick navigation between current and previously selected resources.

On the forms, hover over a name with CTRL pressed to navigate to the resource under the mouse:

User Interface Overview5.png

Resource Editor

Form Panel

Browser Panel

Diagram Panel

Graph Panel

Form Layout Panel

Source Code Panel

Ontology Overview

Ontology Profile

Ontology Statistics

Classes View

Properties View

Navigator View

Associations View

Basket View

Domain View

Relevant Properties View

Inheritance View

Instances View

SPARQL View

Inferences View

Triples View

Jena Rules View

RDFa Editor

Imports View

Change History View

Problems View

Tasks View

File Registry View

Geography View

Matrix View

Configuring Preferences

View Preferences

View Preferences

Forms Preferences

Diagram Preferences

Graph Preferences

Turtle Preferences

Source Code Preferences

SPIN Preferences

Web Data Basket

Editing Ontologies and RDF Data

The TopBraid Composer Getting Started Guide (PDF) is a tutorial that will help you get familiar with the TopBraid Composer interface, the creation and editing of ontologies, OWL classes, and RDF data, as well as SPARQL queries, file management, and the use of imports. As you edit your ontologies and data instances, also remember the User Interface Overview, which gives details on each of the views in the TopBraid Composer interface.)

The following help pages give more details on specific tasks to perform when editing ontologies and instance data:

  • Editing Ontologies
  • Editing Instance Data
  • Working with the Currently Displayed Resource

Editing Ontologies

When creating and editing ontologies, see the following help pages to learn how to:

  • Create a new ontology
  • Open an existing ontology
  • Create a new property
  • Create subclasses
  • Create subproperties
  • Create a new class
  • Modify classes
  • Modify properties
  • Set domains and ranges
  • Create an enumeration
  • Manage annotations
  • Specify disjoint classes
  • Split classes and instances
  • Define and execute rules
  • Create a local restriction
  • Define classes as intersections, unions and complements
  • View and edit ontology annotations

TopBraid Composer's Model menu offers a range of useful utilities for working with the currently displayed ontology:

  • Manage annotations displays a dialog box that lets you edit all of the model's values for a particular annotation property, such as rdfs:label or skos:historyNote, in the same place. See the Manage Annotations help panel for more information.

  • Assign XSD types to all untyped literals assigns datatypes to the model's untyped literals based on the rdfs:range values of the predicates in the triples with those literals.

  • Convert between RDF Schema and OWL displays a wizard that can convert in either direction. See the Convert between RDFS and OWL help panel for more detail.

  • Generate random triples prompts you for the number of triples to generate, with a default value of 100,000, and then creates instances of any classes declared in the current model with a local name consisting of the class name and a number—for example, instances of a Color class will be named Color-0, Color-1, and so forth. In addition to an rdf:type triple, each instance will also have owl:topDataProperty and owl:bottomDataProperty properties with random integers as values.

  • Refresh all caches and views updates the data in caches and views using data from the current version of the disk files.

  • Refresh TopBraid system registries updates various global registries used by TopBraid, including SPIN functions, templates, SPARQLMotion web services, and the workspace's globally shared SPARQL Web Pages graphs that are currently in memory from the copies stored on disk as *.ui.ttl files. See the SPARQL Web Pages help page for more information on using these.

  • Set up teamwork changes repository displays the wizard that creates a Teamwork Repository, which is used in applications such as TopBraid Enterprise Vocabulary Net (EVN) to store an audit trail. See Set up teamwork changes repository for more information.

  • Refresh and show TODO items displays and updates the Tasks View.

  • Refresh and show problems (constraints) displays an updated list of constraint violations in the Problems View.

  • Run SPARQL query from SPIN Template displays a wizard that lists SELECT and UPDATE SPIN templates. Selecting a template from the list displays any available comment about each query and a form where you enter arguments for the query before running it. See Editing SPIN Queries for more information on SPIN templates.

  • Display SPIN rules and constraints opens the SPIN Overview View with a list of rules and constraints with their associated classes and properties. See Editing SPIN Queries for further details.

  • Find all locally defined resources displays the Local Resources View, which lists resources that have their rdf:type defined in the currently open model. This is useful when exploring a large ontology with many imports and you want to figure out what the current file is actually adding, especially if the classes and instances are difficult to find in the classes tree.

  • Find workspace references to local resources displays the Usages in Workspace View, which lists all references by any models in the current workspace (including the currently open model) to the currently open model. For example, if you open the food.ttl model in the TopBraid/Examples folder and select this menu choice, you will see that the wine.ttl model in the same folder references several properties and classes defined in food.ttl. See Workspaces, Projects, Folders and Files for more on the role that workspaces play in application development.

  • Compare with compares the currently open model with one that you select from the file selection dialog box displayed by this menu choice. See Comparing RDF Models for further information.

Editing Instance Data

When creating and editing instances, see the following help pages to learn how to:

• Create a new instance
• Modify instances
• Split classes and instances

Working with the Currently Displayed Resource

TopBraid Composer's Resource menu offers shortcuts to features that make it easier to work with the resource currently displayed on the main form.

Developing Semantic Web Applications

SPARQL Web Pages (SWP)

This feature is available in TopBraid Composer - Maestro Edition only.

SPARQL Web Pages (SWP) (aka UISPIN) can be used to define user interfaces that can be rendered in HTML or Scalable Vector Graphics (SVG). SWP user interface definitions can be associated with classes, and SPARQL queries are used to populate the content of the user interfaces dynamically.

Please see the SWP web page for an introduction.

TopQuadrant's SWP web page has additional information.

SWP Applications Library (SWA)

This feature is available in TopBraid Composer - Maestro Edition only.

TopQuadrant's SPARQL Web Pages (SWP) technology can in principle be used to build any kind of RDF-based web applications. SWP makes it possible to generate arbitrary HTML, JavaScript, JSON and XML by embedding SPARQL queries into template documents. A key strength of SWP is the ability to define custom tags that can be used alongside of HTML elements to insert simple or complex snippets of reusable application building blocks. These application building blocks may be created by experienced HTML developers and published as reusable libraries to simplify the job of information workers who then only need to assemble the reusable components into their custom applications.

SWP Application Component Library (SWA) is a reusable collection of SWP components that are used by TopQuadrant to build the EVN family of tools as well as other customer-facing solutions. Using SWA, you can assemble your own applications more quickly, with all the power of SWP and Semantic Web standards at your disposal.

To see the default SWA application that lets you browse the data of a particular model in a web browser, open a model such as TopBraid/Examples/kennedys.ttl and select Open with Default SWA Application... from TopBraid Composer's Model menu. This displays the default application in your browser where you can navigate a tree of the data, select instances to see their data on a form, search, and perform other kinds of navigation and display of the model's data.

To learn more about how you can build applications with SWA, see the SWP Application Component Library (SWA) documentation (requires TBC-ME).

Web Services

This feature is available in TopBraid Composer - Maestro Edition only.

The features of the TopBraid platform can be accessed from web clients in various ways, for example via a built-in SPARQL end point. In addition to those bundled web services, TopBraid Live can also host any number of custom web services created by users/administrators. This page enumerates a few options on how to create such web services.

Common to all TopBraid custom web services is that they can be called either via GET or POST requests, and that they are created declaratively: the web services are stored in RDF and typically created with TopBraid Composer. This ensures that web services are seamlessly integrated with the data models/ontologies that they expose. Changes to an ontology will automatically update the web services etc. Furthermore, no "programming" in the traditional sense is needed to create those services. 

TopBraid Live Integration

Overview of TopBraid Live Integration

SWP with TopBraid Live

TopBraid Enterprise Vocabulary Net (EVN)

SPARQL Endpoint

SPIN Template Service

The DESCRIBE Servlet

The Edit Servlet (used by SWA edit forms)

The Search Servlet

Application Development Tools

SPIN

SPIN Overview
SPIN Inferencing
SPIN Statistics View
User-Defined SPIN Functions and Templates
Using JavaScript to define SPIN/SPARQL Functions
Ontology Mapping with SPINMap
SPIN Box
SPIN Preferences

SPARQLMotion Scripts (ME)

SPARQLMotion Overview
Editing SPARQLMotion Scripts
Executing and Debugging SPARQLMotion Scripts
Importing SPARQLMotion Scripts as RDF Graphs
Understanding SPARQLMotion
SPARQLMotion Module Library Reference
SPARQLMotion Functions Reference

Importing Data Sources

Working with imported ontologies

When creating or modifying ontologies in Composer, imports can be viewed and specified in the Imports View.

When you open a model created with another tool, TopBraid Composer will attempt to resolve the imports. It will search through your workspace and it will look for imported models on the web.

When Composer is started, the internal File Registry scans the current folder structure and inspects the first few lines of all files with a suitable suffix (e.g., .owl, .rdf, .rdfs) to determine the base URI defined in these files. Then, if an ontology imports another ontology, Composer would try to locate a local copy of the ontology's namespace. If a local file is found, it will always load from the file, so that users don't need to have an internet connection. The goal of this mechanism is to let the system do the right thing automatically in the background, without users having to worry about it.

If the workspace contains multiple copies of the same namespace, for example multiple versions of a file, then the import will be resolved against the most recent file (using the file's time stamp). You can override this behavior by opening the non-primary file explicitly.

If an imported ontology exists in your workspace, but Composer did not find it, check the namespace definitions. The namespace defined in the imported ontology xml:base statement should match exactly the namespace specified in the owl:import statement.

If Composer does not find the imported ontology in your workspace, it will look for it on the web. If the ontology is found on the web, Composer will examine its xml:base statement. If any of your local files has the same xml:base statement as the ontology on the web, Composer will substitute the local file for the web version.

This means that Composer is able to use the web to resolve some inconsistencies between ontology URIs as identified in xml:base and owl:import statement. This is done transparently, without notifications or warnings. It also means that imports 'working' when you are web connected may not work as expected when you are off-line.

Imported objects are displayed in Classes, Properties and Instances views using a 'grayed out', faded icon. They can be edited in the same way as objects defined in the importing ontology:

  • Additional statements will be stored in the importing ontology
  • Modification to the existing statements such as deletions or changes in the existing restrictions will be stored in the imported ontology, provided that this ontology is local and it is not 'locked'. If imported ontology is on the web or is 'read only', you will not be able to delete existing statements

You can navigate to the definition of an imported resource in its imported model from the Name field in the Form Panel of Resource Editor. You can also navigate to an imported ontology from the Ontology Overview. 

Import external information

Most of these features require TopBraid Composer Standard or Maestro Edition.

TopBraid Composer provides various import wizards that can be used to convert files in other formats into RDF/OWL. All of these are available if you right-click on a folder in the Navigator and then select Import...

Currently the following import wizards are supported by Composer:

• Import EMails 
• Import Relational Databases with D2RQ
• Import RDFa data sources
• Import SPARQL endpoints
• Import Spreadsheets (see also: Import Table Files)
• Import Text and HTML with the Calais Text Analysis web service
• Import Triples from selected File into current Model
• Import RDF Files into a new TDB
• Import XML Schema
• Import UML

TopBraid Composer Maestro Edition can also open arbitrary XML files using Semantic XML. 

If you have links to "external" Linked Data resources such as DBpedia entries, you can also add those triples as described here.

Import EMails

This feature is available in TopBraid Composer - Maestro Edition only.

TopBraid Composer - Maestro Edition gives you the capability to import emails into an OWL ontology. In order to import emails, you would only need email connection metadata, which will be stored in a metadata file. Then, you can access emails by importing this metadata file into a model.

Import Relational Databases with D2RQ

See: Import Relational Databases with D2RQ​​

Import RDFa data sources

RDFa is a W3C standard to embed RDF/OWL data into XML documents. This is in particular useful to embed semantic information into XHTML web pages. In a nutshell, RDFa parsers can extract RDF triples from such HTML pages, so that these additional triples can be further processed by RDF-aware tools.

TopBraid Composer can use RDFa files as (virtual) RDF graphs. The RDFa files can be loaded from the Web or from local files. Since RDFa source files are not valid RDF documents on their own, Composer requires a placeholder file ending with ".rdfa" to represent the virtual RDF graph. Other RDF models can then import this virtual graph, which gets its contents from the original RDFa data source.

In order to connect to an existing RDFa data source, select a target folder or project in the Navigator and then select File > Import... > Create Connection File for RDFa Data Source. This will take you to the following wizard: 

Import SPARQL endpoints

This feature is available in TopBraid Composer - Maestro Edition only.

You can import SPARQL endpoints in TopBraid Composer - Maestro Edition. In order to import SPARQL endpoints, you would need the URL of the endpoint, a baseURI to define the connection and the file name. Optionally, you could also provide username and password, a default graph URI and/or a named graph URI. After you provide this metadata, they will be stored in a connection file with the extension sparqlep. The connection file uses basic authentication to access secure endpoints.

In a future version of TopBraid Composer, multiple default and named graph URIs will also be supported.

For connecting to a SPARQL endpoint, select a target folder or project in the Navigator and then select File > Import... > Create Connection File for SPARQL Endpoint. This will take you to the following wizard:

Import Spreadsheets

TopBraid Composer offers three choices for importing spreadsheet data. The first two are useful when your data is laid out in a straightforward table with clearly named rows and columns, because TopBraid Composer uses these names to dynamically create a model for your data:

  • Semantic Tables converts an Excel .xls, .csv or .tsv files to an RDF model, using column and row titles to declare properties and instances for that model. Conversion is done dynamically by simply opening the source file; no persistent RDF/OWL representation is created. As a result, this conversion is round-trippable. A user can edit Excel source in RDF and save it back in the original Excel format.

  • Import Spreadsheets converts a tab-delimited file, which can be created by any spreadsheet program, and defines classes and properties for the data. This option uses an import dialog that can map spreadsheet columns into properties of the currently opened ontology. It will create RDF file from the source file.

  • Importing Excel File into Spreadsheet Ontology uses an import dialog to read an Excel .xls file and create an RDF file with a resource for each data cell. Converted spreadsheet data is represented using the http://www.topbraidcomposer.org/owl/...readsheets.owl ontology, which defines the structure of the spreadsheet with classes such as ss:Cell, ss:Sheet, and ss:Workbook. You can then develop custom SPARQL transformations to extract the data you need from this model and arrange it with a structure that is best suited for your application. This option is often best for spreadsheets with a more complex structure.

Follow the links above for more details on each importing technique.

For additional capabilities in converting spreadsheets to RDF models, TopQuadrant's Enterprise Vocabulary Net product automates the mapping of a variety of popular spreadsheet layouts. 

Import Tab-Separated Spreadsheets

This feature is available in TopBraid Composer Standard or Maestro Edition.

Spreadsheets are a common format of structured data. For example, you can use Microsoft Excel to create a list of persons such as conference attendees together with their addresses. Most spreadsheet tools provide a mechanism to export the data from their native format into a text-based format consisting of tab-separated columns.

In TopBraid Composer, you can import a spreadsheet by either creating a new ontology with the spreadsheet data or importing it to the currently selected ontology:

Handling Table documents with Semantic Tables

This feature is available in TopBraid Composer Standard or Maestro Edition.

Semantic Tables is a technology from TopQuadrant for mapping arbitrary Table documents to RDF/OWL. Semantic Tables can be used to convert Table files to OWL so that you can run SPARQL queries etc on them. You can also manipulate the resulting OWL model and then save it back to the original format.

The following example screenshot shows how a simple example Table file has been rendered into OWL using TopBraid:

Importing Excel File into Spreadsheet Ontology

This feature is available in TopBraid Composer Standard or Maestro Edition.

Semantic Tables is a technology from TopQuadrant for mapping arbitrary Table documents to RDF/OWL. Semantic Tables can be used to convert Table files to OWL so that you can run SPARQL queries etc on them. You can also manipulate the resulting OWL model and then save it back to the original format.

The following example screenshot shows how a simple example Table file has been rendered into OWL using TopBraid:

Import Text and HTML with the Calais Text Analysis web service

This feature is available in TopBraid Composer Standard or Maestro Edition.

Calais is a Web Service that can extract RDF/OWL entities from arbitrary text and HTML documents. TopBraid Composer is supporting Calais as one of its import features so that users can benefit from text mining and analysis. For example, you can use Calais to find persons and countries mentioned in a news article.

Before you can use Calais, you need to get a free API Key from the Calais web page. Copy and paste this license key into the corresponding preferences page under Window > Preferences > TopBraid Composer. While you sign up for the API Key you should carefully check and follow the license agreement. TopQuadrant is not responsible for license violations by its users. Once you have set up your API Key you can start importing text.

Calais Logo

There are various ways to use Calais in TopBraid:

  • Use the Import Wizard to extract entities from an online HTML page. The page will be saved as an RDF/OWL file.
  • Use SPARQLMotion to run text analysis on arbitrary data, and link the output of Calais with other processing steps

Note that Calais currently only delivers instances but no class or property definitions. You either need to import an ontology that contains those class and property definitions, or run an inference engine (using the Run Inferences button with OWLIM selected in the main tool bar) to see the classes and properties so that you can navigate to the instances.

Note that OpenCalais is evolving and there might be alternative (beta) versions of the platform online at any given time. In order to use one of the alternative servers, you can specify its URL on the Calais preferences page under Override server URL. An example value is http://beta.opencalais.com/enlighten/

Import Triples from selected File into current Model

This import wizard can be used to add the contents of a given RDF file to the model that is currently open (has the focus of the resource editor) in TopBraid Composer. To use it: 

  1. Open the target file in Composer
  2. Open the Import wizard for the source file (e.g. right-click on it in the Navigator and then select Import > TopBraid Composer > Import Triples from this File into current Model)
  3. Read the description and click the Finish button to start
  4. The process can be stopped using the Stop button in the lower right corner of the wizard

The main use case of this feature is to load very large RDF (RDF/XML, N3, Turtle or NT) files that would not fit into memory otherwise. You could create a target database, e.g. a TDB database, then then run this import wizard with the database being the selected model. All triples will be immediately streamed into the database, bypassing any buffers or caches. When done, you should save the database to make sure all triples have been written to the store, and then you may want to refresh all caches and views or re-open the file. 

Import RDF Files into a new TDB

This wizard is the most performant option if you need to import large amounts of RDF data into a database that can be opened with TopBraid. Right click on a target folder or project in the workspace Navigator, go to import and find the Import RDF Files into a new TDB wizard. In the wizard, please specify the base name for the database files, e.g. "myTDB". Then enter a base URI that shall be used as named graph for the new triples originating from triple-based RDF files. Files with quads in them will ignore this setting. Finally, use the Add files button to select that files that you want to import. The wizard will populate the databases and finally create connection files.

Note that this wizard requires a 64 bit version of Java. 

Import XML Schema

See: XSD to OWL Importer

Import UML

This feature is available in TopBraid Composer Standard or Maestro Edition.

TopBraid Composer can import UML files and convert them into OWL files. The supported input format is the EMF-based UML serialization provided by the Eclipse UML2 Plugin (version 2.0.0 and above). This is also the format used by tools such as IBM Rational Software Architect. An example uml file (taken from the Eclipse UML2 web page) is supplied here.

XSD to OWL Importer

This feature is available in TopBraid Composer - Maestro Edition

The help file is organized as follows:

• Challenges importing XSD into OWL
• Using the Wizard

◦Getting Started
◦ Configuration Options

◾Controlling Class Names
◾Annotations for assisting XML to RDF Conversion
◾Controlling the names of declared properties
◾Controlling Enumerated Values
◾Controlling Labels
◾Controlling Descriptions
◾Controlling how XSD Datatypes are generated

◦Progress Monitor
◦Final Steps
◦Converting instance documents to use the generated ontology

• Summary of Supported Transformations
• Known Issues

Add or Import External Triples

If you have a link to an external resource (such as a DBpedia entry) on your form, then you can also open the context menu to the right of the resource and use: 

  • Add triples for this resource - tries to load RDF from the base URI of the resource, and if possible adds all triples from that URI to the currently open model. A confirmation dialog tells you how many triples have been added, and it's up to you whether you want to save your file with those changes or not.
  • Import triples for this resource - same as above, except that it will add an owl:imports statement to that URI so that you will always see the latest version of those triples, fresh from the web. 

Exporting Data Sources

Export / Merge / Convert RDF Graphs

This multi-purpose wizard can be access from File > Export... or through a right click on a target folder.

The wizard allows you to save parts of the currently open model into a different file, database or repository (possibly in a different format). This includes the ability to save a database into a file (and vice versa), and to convert between XML and Turtle serializations.

Export-Merge-Convert RDF Graphs.png

 

The wizard displays all sub-graphs of the currently selected ontology with check boxes. All selected graphs will be added into the target file, for example allowing you to merge classes and instances. Depending on the selected output format, the next wizard page will provide additional options.

Export Java RDFS/OWL Schema class

If you are a Java software developer who wants to use the identifiers from an RDF model in your source code, then you can use the Export > Java RDFS/OWL Schema feature. Open the ontology that you want to export, then open the corresponding wizard from File > Export, with a target folder selected in the Navigator. On the wizard page, enter a class name (typically an upper-case version of the main prefix in your model). Optionally, enter a package name for the new class. Finishing the wizard will create a Java class with Jena Resource and Property constants for all URIs used in the main namespace of your currently open file. 

Export XML from RDF/OWL

This feature is available in TopBraid Composer - Maestro Edition. 

The help file is organized as follows:

• How it works
• Using the Wizard
• Summary of Supported Transformations
• Limitations

How it works

XML from RDF/OWL wizard uses instances annotated with Semantic XML (SXML) triples to transform them to an XML document. In order to comply with an XML Schema, these instances could be defined against classes and properties that were imported from the XML Schema using the Import XSD wizard.

Export XML Schemas from RDF/OWL

This feature is available within TopBraid Information Exchange server. 

Creating documentation for review

This feature is available in TopBraid Composer Standard or Maestro Edition.

TopBraid Composer comes with a HTML generator that is useful to create online documentation of an ontology. Before you use this feature, you should create an empty folder in the Navigator. This folder will be filled with a large number of HTML files. Then right-click on this target folder in the Navigator to select Export... (or use File > Export...):

Creating documentation for review1.png

On the next screen you have various options:

Creating documentation for review2.png

After finishing, the system will generate a collection of HTML and image files into the target folder. An example set of documentation can be browsed here.

For a more flexible and powerful approach to generating arbitrary HTML-based documentation from your RDF/OWL models, see SPARQL Web Pages to convert RDF into HTML with embedded SPARQL queries. 

Working with Data Back Ends

Working with RDF Databases

This feature is available in TopBraid Composer Standard or Maestro Edition.

In addition to the ability to load and save models to files, TopBraid Composer also comes with database persistence. The main benefit of this is that much larger models with millions of triples can be maintained, without being constrained by memory limitations. Whether a model is stored in a database or in memory does not make a big difference to the system, i.e. essentially the same functionality is available in both cases. However, users of the database persistence should be aware of the following trade-offs:

  • Some operations take a bit longer in database mode, because each triple access may result in a transaction to the database. TopBraid Composer maintains a cache of most frequently needed queries, but depending on your model the response times may vary. See Database Performance and Caching for a discussion of this topic.
  • Due to the slower performance, some features have been disabled in database mode. In particular, if you are working in OWL, then the icons of "defined" classes will be identical to those from "primitive" classes. This is because checking this only to select an icon would slow down browsing.
  • The system may store information about owl:imports in the database connection files. This information (stored using a property called sml:imports) may become out of synch if someone else modifies the same database outside of your TopBraid environment. If that happens, you should open and save the database to overwrite the connection file with the latest imports metadata.

TopBraid Composer has several different database back-ends, each of which are described on separate pages:

  • Jena Databases (*.sdb and *.tdb)
  • Oracle 11g RDF Databases (*.oracle)
  • Sesame 2.x Remote Databases (*.s2r)
  • AllegroGraph 4 Databases (*.ag4)

Note that the database persistence described here relies on triple stores, i.e. custom tailored databases for RDF. If you are interested in connecting a legacy relational database with Composer, please have a look at the D2RQ plugin.

Creating a new database

For example, if you want to create a Jena SDB database project, or have an existing Jena SDB database that you wish to access with TopBraid Composer, you need to use File > New... > RDF/OWL Jena SDB Database... (or the corresponding items for AllegroGraph, Oracle, and Sesame). This will open a wizard in which you can fill in the connection metadata including passwords etc.

This will create a file ending with .sdb and connect to the given database. Also notice that there is a check box to overwrite an existing database with the same name. Leave this box unchecked if you want to connect to an existing database that for example has been created with some other program. In such cases you should be aware though that TopBraid Composer does not automatically get notified if other programs or users access the same database.

Working with database projects

After you have created a database, the database connection settings are stored in a metadata file (*.sdb, *.oracle, *.sesan etc). For Composer, these files serve as a placeholder of the database URI. This means that each database metadata file declares the base URI of its content, and this base URI is used to resolve imports. As a result you can treat the metadata files like plain OWL or RDF files, import them, open them etc.

Once you open or import a database model, the system will build some caches. While building these caches may take a few seconds and the caches consume additional memory, they significantly accelerate the browsing performance down the road. If you - for one reason or another - do not want to use these caches, you can configure them in TopBraid Composer's Preferences.

In other ontology editors, changes by the user are immediately written into the database. This leads to several problems such as slow performance and poor control of what gets committed. Therefore, Composer has a different approach. Like in file mode, changes in the editor are not directly written to the underlying database, but kept in an in-memory buffer until the user decides to commit them. Therefore you need to make sure to press the Save button (or File > Save in the menu) to persist the changes into the database. This will flush the buffer in a single database transaction. This also allows users to run local modeling experiments with the database without ruining it.

If you want to save an existing file-based project into a database, or need to convert an existing database into a file, you can use the Export Wizard. 

Working with Relational Databases

Import Relational Databases with D2RQ​​

This feature is available in TopBraid Composer Standard or Maestro Edition.

Many semantic technology projects have a repository of relational databases. These (legacy) databases often contain data that has not been converted into RDF or OWL, and is therefore not accessible for ontology-based services. D2RQ is an open-source project by Chris Bizer and colleagues at the Free University of Berlin. D2RQ is a declarative language to describe mappings between relational database schemata and RDF/OWL ontologies. The mappings allow RDF applications to access the content of huge, non-RDF databases using Semantic Web query languages like SPARQL and to run inferences based on rules or description logics on the databases.

TopBraid Composer provides an interface to arbitrary relational databases using D2RQ, so that the databases can be treated as a (read-only) triple store. The approach is based on mapping files that declare how the tables in the database map into individuals of an ontology. Since the mapping files are RDF models, Composer itself can be used to edit the mappings. You may find it useful to familiarize yourself with the D2RQ mapping language before using this feature.

Working with MySQL or Microsoft SQL Server Databases

TopBraid Composer supports a number of relational databases. The Oracle driver is included with TopBraid Suite. MySQL, SQL Server, and other drivers cannot legally be bundled with TopBraid. Instead, you need to download the appropriate drivers yourself and place them into the dropins folder under your TopBraid Suite installation folder.

In order to connect to MySQL, you need to place a suitable JAR file driver into the dropins folder under your TopBraid Suite installation folder. MySQL drivers can be downloaded from the MySQL Web site (http://dev.mysql.com/downloads/connector/j/).

{C}{C}{C}{C}

To connect to Microsoft SQL Server databases, you need to prepare Microsoft's JDBC Driver for SQL Server for use with the Eclipse environment using the bnd utility available here or from TopQuadrant's Resources page. The download is a zip file that includes the biz.aQute.bnd.jar utility. To use it, the following command creates a file called sqljdbc4.bar:

java -jar biz.aQute.bnd.jar wrap sqljdbc4.jar

Rename the sqljdbc4.bar file to have a .jar extension (for example, sqljdbc4_equinox.jar) and put it in the dropins folder of your TopBraid installation.

For the JAR file used with any database manager, make sure that it includes the import and export package data in MANIFEST.MF file under META-INF folder inside the JAR. 

Secure Storage and Passwords

This feature is available in TopBraid Composer Standard or Maestro Edition.

TopBraid Composer uses Eclipse secure storage system to store and retrieve database passwords. The passwords are stored through database wizards, SPARQLMotion database modules or from the menu at System > Add password to secure storage.... If the password was stored earlier, then there would be no need to specify it again in a wizard or database module. If the password is invalid or was not stored, then there would be a Password dialog prompting you to enter the new password for a given username and URL.

Working with XML and Table files

Handling Table documents with Semantic Tables

This feature is available in TopBraid Composer Standard or Maestro Edition.

Semantic Tables is a technology from TopQuadrant for mapping arbitrary Table documents to RDF/OWL. Semantic Tables can be used to convert Table files to OWL so that you can run SPARQL queries etc on them. You can also manipulate the resulting OWL model and then save it back to the original format.

The following example screenshot shows how a simple example Table file has been rendered into OWL using TopBraid:

Semantic Table Example 

How does Semantic Tables work?

Semantic Tables is based on a small ontology that defines three annotation properties to enable round-tripping between the Table file and OWL. It introduces tables:columnIndex, tables:rowIndex, and tables:sheetIndex that are used to define the mapping. When a Table file is opened with TopBraid, it will apply the following mapping strategy:

  • Sheets will be converted into classes. If the file format does not use the concept of sheets, then a single class will be created;
  • Columns, that is, the first row of the table file, will be converted into Datatype Properties, depending on the guessed type of the column. It is assumed that the table file will contain a row with the column names;
  • Rows will be converted into Instances, which will be identified by the sheet they belong to;
  • Cells will be converted into triples, where the subject is the row instance, the predicate is the column property, and the object is a literal with the value of the cell;
  • The Base URI will be the file path within the Workspace.
Importing Table Files

Table files can be automatically imported into TopBraid Composer by opening the desired file (as if they were a regular ontology file).

Currently supported files:

File Format Expected File Extension
Microsoft's Excel xls
Comma Separated Values csv
Tab Separated Values tsv

Any workspace file ending with .xls, .csv, and .tsv can be opened directly with TopBraid. The system will automatically convert its contents into Semantic Tables format. The table file can also be imported into other OWL ontologies using the Imports View.

Note: When importing .csv or .tsv files, the system will use the platform's default character encoding. If you want to use something else, e.g. UTF-8, then you need to specify a different encoding for the file in your Eclipse workspace prior to running the import. To do that, right-click on the file in the Navigator, select Properties and pick a custom encoding in the drop down box.

Reusing existing schemas with .semtables files

By default the system will create a completely new schema (classes and properties) for each tables file. However, in many cases it is desirable to reuse the same schema for multiple instance files, for example to reuse SPARQL mappings defined on those existing classes and properties. This can be achieved by means of .semtables files. These are metadata files that are placed in the workspace together with the tables files themselves. .semtables files contain information about which other graphs (base URIs) need to be present when the table file is loaded.

When a spreadsheet is loaded, the system will first try to find a file with the same name plus the suffix .semtables. For example, if you have a file example.tsv then the system will search for a file example.tsv.semtables in the same folder. If this is not present, the system will search for a file default.semtables in the same folder, and finally walk up the parent folder structure for any other default.semtables file.

The easiest way to create such .semtables files is to:

  1. Open the spreadsheet file with double-click in the Navigator.
  2. If no .semtables file has been found, the system will ask you whether you want to have one created. Click Yes to continue.
  3. On the following page, select the file that contains the Semantic Tables annotations on classes and properties.
  4. The system will create a .semtables file, either for this specific file, the folder or the project.

Note that if a column property defines a different range than xsd:string, the importer will create a typed literal. For example if a spreadsheet already contains well-formed xsd:date strings, then the schema may define xsd:date as the rdfs:range of the matching property. A common, and more powerful alternative to this datatype resolution is to use SPIN (especially SPINMap) to define mappings from the source schema into a target schema.

In order to prepare for the reuse of a schema file, you could simply load a spreadsheet without a .semtables file, delete all instances, adjust the base URI and save the file (now consisting only of classes and properties). Alternatively, if you already have a schema file, you could create a new file that imports the schema plus the http://topbraid.org/tables namespace. In this file, add the property tables:sheetIndex to the main class, with value 0. Then make sure that each column property has the main class as its rdfs:domain. Finally, give each column property a tables:colIndex, starting with 0.

Using and saving the ontology back to the Table File.

TopBraid Composer allows the editing of Table Files as if they were ontologies. Note that there is no traditional ontology file created, such as .rdf or .ttl.

Columns (converted into Properties) and Rows (converted into Instances) are specific for each Sheet (converted into Classes). Adding instances to classes will implicate in creating new rows in the original Table File.

Select Save to save the ontology back to the Table File.

If classes or properties were added to this structure, they will not be converted back into new Sheets and Columns, unless the sheetIndex, columnIndex, and rowIndex are correctly used. We do not recommend, however, that users modify the ontology in this manner. 

Creating, Importing, Querying, Saving XML documents with Semantic XML

This feature is available in TopBraid Composer - Maestro Edition only.

XML is one of the most widely used formats to exchange data between applications. In order to lift this XML-based data into a format that is processable by semantic technology tools, a suitable translation mechanism is required.

Semantic XML is a technology from TopQuadrant for mapping arbitrary XML documents to RDF/OWL. Semantic XML can be used to convert XML files to OWL so that you can run SPARQL queries etc on them. You can also manipulate the resulting OWL model and then save it back to XML. In order to control the Semantic XML mappings, you can use process ontologies, which can usually be generated by importing them from XML Schemas. (For information on importing XML Schemas, see the XSD to OWL Importer.)

Developing Web Data (Microdata, RDFa)

Microdata and RDFa Web Data Sites

This (experimental) feature is available in TopBraid Composer - Maestro Edition only. We may move it into different editions in the future. Note that Microdata and schema.org are not yet stable specifications, and that our current support reflects this ongoing work in progress.

There are currently two competing approaches for embedding structured metadata into web pages:

Both standards are supported by TopBraid, as the metadata embedded in either of those formats can be converted to RDF. TopBraid Composer supports two file types ending with *.mds and *.rds respectively. When opened, these file types load all RDF data embedded in the Microdata or RDFa files from the same folder (including sub-folders), and present it in a virtual RDF graph that can be browsed and processed with TopBraid.

Getting Started

We recommend that you create a new project for your HTML site, with a project name that mirrors your top-level domain. For example, if you have a web site http://example.org, then the project should be called example.org. Inside of that, you can create the usual sub-folders for images, CSS files etc, in addition to arbitrary .html or .htm files.

Use the New > Microdata Site... or New > RDFa Site... wizards to create a new site file. This file will serve as a placeholder for all the RDF triples found in the HTML files. In the wizard you can give it a unique base URI that will allow other RDF models developed with TopBraid to import the virtual graphs. Recommended file names are microdata.mds and rdfa.rds.

Working with Sites

You can use any of the built-in HTML editors to create the documents and their mark-up. If you open a Site file, it will scan all those files and convert them to an RDF graph automatically. Then, whenever you save changes to an HTML file in the scope of the Site, the RDF will update automatically. You can use any of the built-in TopBraid views and editors to view and process the resulting RDF. For example, you can use the Class tree to navigate to the relevant schema concepts, you can use the Instances view to find your embedded objects, and use the Form to view details of each object. You can even run SPARQL queries, perform SPIN constraint checking and inferencing and other advanced features.

Editing (or not!)

Although the resulting RDF graph is editable, it rarely makes sense to do this from the TopBraid views - the results are recreated each time the Site file is opened anyway and you will lose your changes. However, it is possible to edit the imports (using the Imports view) and to change namespace prefixes to make the model more readable.

While you are navigating the RDF model on the form, you can find a menu item Open HTML File in the context menu to the right of those triples that came from a Web Data graph. Alternatively, double-click on the icon to the left of the value on the form. This will open the HTML file containing the metadata, and you can edit this file, save your changes and see them reflected in the RDF model. If your file is using Microdata, then TopBraid Composer will also attempt to highlight the position of the corresponding text snippet on that page. Note however that this is currently using some simple heuristics, and may in some cases highlight a different occurrence of the same string elsewhere. Future versions may provide better understanding of the Microdata syntax to avoid such cases.

Constraint Checking

When you create a new Microdata site project, the system will automatically create a link to a SPIN library that contains several integrity constraints for the schema.org namespace. For example, this will warn you if a property value does not match the declared range for that property. Press the Refresh and show problems button in the main tool bar to see a list of current constraint violations. Note: This is work in progress and we will add more constraints in future versions. 

Web Data Basket

This feature is available in TopBraid Composer - Maestro Edition only.

The Web Data Basket can be opened using Window > Show View > Web Data Basket. Once opened, it will collect any Linked Open data triples found on the pages that the user navigates to with a web browser. For example, if you navigate to the DBpedia page about David Bowie, the basket will be automatically filled with the RDF triples representing this resource:

WebDataView-DavidBowie.png

The Web Data Basket will be populated with new triples whenever the loading of a page finishes. It will react on any navigation done within the embedded Web Browsers of Eclipse. For example, use Window > Show View > Other > General > Internal Web Browser to open a fully functional web browser inside of Eclipse.

Alternatively, it is possible to use some external browsers as long as you have a matching extension installed. TopQuadrant is providing a simple Firefox extension. When installed into Firefox, a TopQuadrant logo will appear in the lower right corner. Click on that logo to activate sending your browsing history to the currently running TBC-ME instance.

If a page has been fully loaded, the system will try to extract RDFa and Microdata mark-up from that page. If neither of those formats deliver any triples, it will request RDF/XML from the URL.

Buttons

  • The Assert triples button will add the triples currently in the basket into the currently open model. If triples are selected, then it will only add the selected ones, otherwise all triples. If you leave this button pushed down, it will continue to add all new triples automatically whenever it collects new information. The system will automatically add missing namespace prefixes and missing imports to namespaces that are represented as files in the workspace.
  • By default, the contents of the basket will be cleared whenever a new page has been visited. Push the button Add all incoming triples to make sure that new triples are being added without wiping the old contents out.
  • The Delete button will clear all (or the selected) triples from the basket. 

RDF and TopBraid

Semantic Web Standards

The Semantic Web provides a common framework that allows data to be shared and reused across application, enterprise, and community boundaries. It is a collaborative effort led by W3C (World Wide Web Consortium) with participation from a large number of researchers and industrial partners. The Semantic Web is often talked about as the next generation of the Web making it processable by machines (as well as humans). 

W3C has developed several standards to implement the Semantic Web. These include:

• RDF
• RDFS
• OWL
• SPARQL

In addition to those "official" standards, various groups are suggesting extensions to the Semantic Web stack, including 

• SPIN (W3C Member Submission by TopQuadrant)

Naming Conventions and Namespaces

Since ontologies are often shared within and between organizations, it makes sense to consider naming conventions before you start. It is very easy for two or more people to think of different ways of naming properties that may mean little to the other ontology modelers. The more time spent at the planning stage, the less time is likely to be spent working out problems with the ontologies at a later date. 

The following is a list of suggested basic conventions for ontology objects based on the naming conventions of RDFS and OWL:

• For class names, use initial capitals (for example, Activity)
• Use lowercase letters for properties (for example, impacts or hasPart)
• Within names, avoid using separators or spaces, but begin all new words with a capital letter (for example, isFunctionOf, InformationResource)
• Names of ontology objects can not have spaces or slashes, but commas, dashes and many other characters are permitted. Define a standard naming convention for your modeling effort that describes which characters are allowed and what should serve as replacements for unallowed characters.

Named Graphs and Base URIs

TopBraid Suite (TBS) implements named graphs as specified by the relevant W3C specifications. A TBS workspace defines a dataset consisting of multiple named graphs. Each named graph is defined by a file in the workspace, identified by its base URI. Thus, the best way to understand how a workspace works is to view it as a quad triple store that directly or indirectly stores a variety of named graphs.

Only one workspace (dataset) can be loaded for any TBS product, including TopBraid Composer (TBC), TopBraid Live (TBL) and Enterprise Vocabulary Network (EVN). Multiple workspaces can be defined, each representing a separate dataset, but only one can be loaded at a time. Since the workspace is a file directory, it can be located anywhere, but to avoid network latency, it is best for the workspace to be on the same machine as the TBS product. 

Using Reified Statements (statements about statements)

Reified statements are very useful to attach information about a statement, e.g. to annotate who has created the statement, or to attach other metadata for n-ary relationships. RDF Schema defines a standard class rdf:Statement and corresponding properties to enable people to talk about statements. Composer has support for editing reified relationships. Whenever you want to do a statement about a statement, you can now reify it using the statement's drop down menu.

Note that reified statements are independent resources on their own, and can exist without being instantiated with a "real" triple. TopBraid Composer does not restrict you in what you do with the reified statements, and also does not automatically synchronize reified statements with your model.

Enterprise Vocabulary Net (EVN)

TopBraid Composer - Maestro Edition includes a standalone demo version of TopBraid Enterprise Vocabulary Net, TopQuadrant's web-based solution for simplified development and management of interconnected controlled vocabularies. See EVN's online documentation for a Getting Started tutorial, the user guide, and the administrator guide.

Extending TopBraid Suite

TopBraid Suite (including TopBraid Live and TopBraid Composer) is an open platform that can be extended to meet custom needs. In many cases, no programming is needed to add new functionality to TopBraid: You can define new web services using SPARQLMotion, you can add new SPARQL functions through SPIN, embed JavaScript code into SPARQL functions using SPINx, build complex web applications using SWP and so on. You can also interface with existing external systems by making web service calls through our existing SPARQL based technologies. For example, you can use the SPARQLMotion module sml:PostRequest to send web service calls to external systems. These mechanisms are the recommended ways of extending TopBraid. 

However, in some cases you may need lower level hooks into the system to add capabilities implemented in a programming language. TopBraid Suite provides a Java API and an Eclipse extension point for that purpose. The following sections describe how to build Java plug-ins for TopBraid Suite. 

Data Integration

TopBraid provides several ways to support data integration. In all cases, the first step is to render all datasets to be integrated as RDF. Once these datasets are available as RDF, there are several ways to merge them.

Turning data into RDF

Many data sources are already available as RDF, and are published in one of the standard RDF serializations (Turtle, NTriples, RDF/XML). When data is available in one of these formats, there is no need to turn it into RDF; it can be used directly in TopBraid Composer simply by dragging and dropping the file into a project in the TopBraid workspace.

Many other forms of data (XML, Spreadsheets, etc.) can be converted into RDF in a one-time conversion step. See Importing External Information for details. These create RDF files with a snapshot of the data as it was in the input dataset at time of conversion.

For relational databases, they can be rendered as RDF dynamically, effectively creating a proxy file to the data in the database (see Import Relational Databases with D2RQ). This proxy stands in for the data that is the database at query time.

In each case, once the dataset has been rendered as RDF (either dynamically or as a snapshot), it is identified in TopBraid by a URI (called its "base URI"). This base URI is important for identifying the dataset in the various data integration scenarios.

Modeling data federations: owl:imports

The simplest way to federate data in TopBraid Composer is to construct a model using OWL of the desired federation. This model uses owl:imports, and can be managed using the Imports View. Any number of datasets can be merged together simply by importing one into another. A typical scenario is to create a new dataset (in the form of a simple RDF file) and to import a number of other datasets into it by dragging and dropping them into the Imports view.

DataInt1.jpg

The result is a virtual federation of all datasets. All user interface views and SPARQL queries act on this federation of datasets.

Constructing data federations using the Imports View is the easiest way to do data integration, but does not provide a lot of control over how the data is to be integrated. TopBraid provides two other means of data integration that provide the user more control over the data to be integrated.

SPARQLMotion

SPARQLMotion provides a scripting language for data management with fine-tuned control over what data is to be integrated. Data integration is achieved in a dataflow diagram. The diagram below shows the same simple data federation specified in the Imports View above, but done in SPARQLMotion.

DataInt2.jpg

The same three datasets are combined in a dataflow to create an ad hoc federation.

Any of these datasets can be filtered using the Apply Construct module of SPARQLMotion. This module specifies that some transformation is to be applied to the input dataset. In a simple case, the various Apply Construct modules could filter triples out of each of the input datasets. In a more complex case, each Apply Construct module could recognize a particular pattern in each dataset, and the results of these matched patterns could be merged and proceeded further.

SPARQLMotion can be used to cascade such federations; transforming datasets, merging them, transforming them again, merging with other datasets, etc., to provide a sophisticated recipe for data federation.

Federated SPARQL queries

Another approach to RDF-based data federation is through the query language SPARQL. SPARQL 1.1 provides a capability for querying multiple data sources in a single query, using the GRAPH and SERVICE keywords for named graphs in a data store and SPARQL endpoints, respectively.

SELECT ?rel
WHERE {
   GRAPH <http://sample.evn.topbraidlive.org/Screen/Dataset1>
   {?x a skos:Concept; skos:prefLabel ?label .}
   GRAPH <http://sample.evn.topbraidlive.org/Screen/Dataset2>
   {?y rdfs:label ?label .}
   GRAPH <http://sample.evn.topbraidlive.org/Screen/Dataset3>
   {?y skos:related ?rel }
}

Each dataset in the TopBraid workspace is available to a SPARQL query as a named graph (that is, referenceable via the GRAPH keyword in SPARQL 1.1), where the name of the graph is its base URI. The original source of the data is not important; relational databases, spreadsheets and RDF datasets are all treated equally as named graphs.

Similarly, external datasets that are published as SPARQL endpoints are available using the SERVICE keyword. The SERVICE and GRAPH keywords are both available in the same query:

SELECT ?concept ?item
WHERE {
   GRAPH <http://sample.evn.topbraidlive.org/Screen/Dataset1>
   {?concept a skos:Concept; skos:prefLabel ?label .}
   SERVICE <http://dbpedia.org/sparql>
   {?item rdfs:label ?label }
}

These methods are typically combined in a data integration solution using TopBraid; static structures of related data are specified as Imports, SPARQLMotion is used to coordinate detailed connections between datasets, and judicious use of the GRAPH and SERVICE keywords provide access to multiple local datasets (GRAPH) as well as remote data (SERVICE).

How to?

Create a new ontology

Open an existing ontology

In order for TopBraid Composer to see an ontology, it must be located in one of the workspace folders. Navigate to the appropriate folder in the Navigator View, then double-click on the file to open it. 

You can copy and paste a file in to the folder using you file management system, such as Windows Explorer. If this operation is performed after Composer has been started, make sure to refresh the files displayed in the Navigator view. This is done by right-clicking inside the Navigator View and selecting Refresh. 

If an ontology imports another ontology, Composer would try to locate a local copy of the ontology's namespace. If a local file is found, it will always load from the file, so that users do not need to have an internet connection. If the workspace contains multiple copies of the same namespace, for example multiple versions of a file, then the import will be resolved against the most recent file (using the file's time stamp). 

Important Note: You cannot have the same base URI open more than once. If you have 2 files which share the same URI, you will need to close one of them before opening the other. Composer associates a base URI with the name of the file. When you open another file with the same base URI as a previously opened file, Composer will display a message advising you that it will now associate the file you are opening with the URI. Press Yes to proceed. 

 

In order to open an RDF/OWL file that lies outside of your workspace, you can use File > Open... and select the file. However, this procedure is not recommended because external files are invisible to the imports resolution mechanism and will most likely lead to unexpected results. The preferred way is to use the Navigator and workspace. If you do not want (or cannot) copy all your files under the Eclipse workspace root, you can create placeholder/proxy folders that point from your workspace to external folders. The file open wizard will actually ask you to create such a project automatically and then open the file from that imported project. Alternatively, create a link project manually (see the Workspaces page for details). 

Create a new class

Create a new property

Create a local restriction

Create a new instance

Create an enumeration

Define classes as intersections, unions and complements

Specify disjoint classes

Set domains and ranges

Modify classes

Create subclasses

Modify properties

Create subproperties

Modify instances

Define and execute rules

Modify namespaces and prefixes

View and edit ontology annotations

Manage annotations

Split classes and instances

Run and configure inference engines

Make inferences persistent

Use search

Compare RDF Models

Test and debug ontologies

Refactor ontologies

Create SPARQL Queries by Example

Resolve Out of Memory Problems

Tips and Tricks

The following is a list of some tips and tricks about TopBraid Composer:

1. How can I navigate between different resources (classes, properties and instances) in Composer?

2. I am tired of typing in labels. Is there a way to automatically generate labels?

3. When I select a class, I can only see its direct instances in the Instances view. How can I see all the instances, including those belonging to the subclasses of the class?

4. Can I create and export reports using TopBraid Composer?

5. How can I save the SPARQL queries I create?

Reference

Icons Legend

Manchester OWL Syntax

TopBraid Composer uses the Manchester OWL Syntax for displaying and editing OWL class expressions. The Manchester OWL Syntax has been influenced by both the OWL Abstract Syntax and the DL style syntax, which uses description logic symbols such as the universal quantifier (upside-down A) or the existential quantifier (upside-down E). 

The sections below describe the most frequently used elements of the Manchester OWL Syntax used in TopBraid Composer.

SPARQLMotion Module Library Reference

SPARQL Functions Reference

TopBraid's SPARQL Property Functions

Workbench User Guide

Eclipse platform overview

The Eclipse platform itself is structured as subsystems which are implemented in one or more plug-ins.  The subsystems are built on top of a small runtime engine. The figure below depicts a simplified view.

Platform runtime base with groups of plug-ins adding function

Workbench

The term Workbench refers to the desktop development environment. The Workbench aims to achieve seamless tool integration and controlled openness by providing a common paradigm for the creation, management, and navigation of workspace resources.

Each Workbench window contains one or more perspectives.  Perspectives contain views and editors and control what appears in certain menus and tool bars.  More than one Workbench window can exist on the desktop at any given time.

Getting started

Concepts

Tasks

Reference

Tips and tricks

What's new

Legal

EGit Documentation

Getting Started

Overview

If you're new to Git or distributed version control systems generally, then you might want to read Git for Eclipse Users first. If you need more details and background read the Git Community Book or Git Pro. 

Basic Tutorial: Adding a project to version control

EGit User Guide

JGit User Guide

EGit 1.0 New and Noteworthy

JGit 1.0 New and Noteworthy

Git for Eclipse Users

Subversive User Guide

Subversive overview

Subversive is a totally new Eclipse plug-in, that provides you a probability to use supported SVN® clients easily directly from your workbench. Friendly user interface of Subversive makes it much more comfortable to operate repositories. All SVN® operations are supported and there are no difficulties while working with command line from now on.

For more information refer to the Getting started part of the documentation.

Getting SVN Connectors

In order to work with SVN the plug-in user should also install one of SVN connectors, which are distributed from different update-site through the legacy reasons. The plug-in won't work without SVN Connectors. So please pay special attention to this fact in the Installation instruction.

Getting started

Preferences

Team support with SVN®

Installation and migration

FAQ

Special Thanks

Legal

Page statistics
3344 view(s) and 64 edit(s)
Social share
Share this page?

Tags

This page has no custom tags.
This page has no classifications.

Comments

You must to post a comment.

Attachments