Time flies like an arrow
- - From a syntactic perspective, we can see that _time_ is the subject. A noun. - _Flies_ is the verb, and so on. - If we analyse literally the meaning, we can picture time moving with a motion alike that of an arrow. - - On the other hand, we know the real meaning of the sentence is different. - Here we can deduce that the arrow is used to represent a fast movement, - and that characteristic is then applied to time. This is the semantic knowledge. - - In a semantic approach, we don't just see words as a series of symbols, but as a link to a sign. - And we can apply different rules and behaviours to different concepts because of the properties inherent to each entity. - - If we now look at: - -Fruit flies like a banana
- - The moment we get to the word _banana_, - we realise something is wrong. Syntactically, this sentence could be equivalent to the previous one. - However, we know that _bananas_ do not usually fly. - And so we decide to change the syntactic interpretation. - _Fruit flies_ becomes the subject, _like_ the verb and _a banana_ the object. - Now it makes sense semantically as well. - - In this semantic realm, the concept of ontologies that will be presented in further sections plays a major role. -#### Requirement simplification - Since we know what a user means from the semantic approach, - we can use this to automatise and simplify the setup and initialisation of processes using default settings. - - For example, a user could decide they want to run a simple simulation, with a certain level of detail - (let's say low, medium or high). - This could be translated into a meaningful initial state that might suffice a general situation. -#### Coupling and linking - In the domain of physics simulations, another interesting use case is coupling and linking. - - For example, a certain engine might be useful for representing structures made up of atomistic particles - (molecular dynamics). - - Another software tool could be focussed on representing bodies of fluids (fluid dynamics). - If both tools can communicate (i.e. there exists some interoperability between them), - they could both be run and synced simultaneously to create more complex scenarios. - - Furthermore, a truly interoperable platform would enable users to store and - access data in databases or other repositories of information. - - - diff --git a/docs/source/ontologies_included.md b/docs/source/ontologies_included.md index 18a69f0..3474e0d 100644 --- a/docs/source/ontologies_included.md +++ b/docs/source/ontologies_included.md @@ -22,14 +22,11 @@ pico install city Take a look at our [examples](jupyter/cuds-api.md) to see how you can build your own city! -## Working with EMMO using OSP-core +## Working with EMMO The second ontology that is ready to be used out of the box is the European -Materials Modelling Ontology, or EMMO in short. This ontology is an effort -to develop an ontology for applied sciences. It is based on physics, -analytical philosophy and information and communication technologies. -Its source code is open and [available on Github](https://github.com/emmo-repo/EMMO). -If you want to develop an emmo compliant ontology, see [the documentation](https://ontology.pages.fraunhofer.de/documentation/latest/). +Materials Modelling Ontology, or EMMO in short. +For a short introduction, see the [fundamentals](./fundamentals.md#emmo). You can install EMMO using [Pico](utils.md#pico-installs-cuds-ontologies). diff --git a/docs/source/overview.md b/docs/source/overview.md new file mode 100644 index 0000000..10f4691 --- /dev/null +++ b/docs/source/overview.md @@ -0,0 +1,118 @@ +# Overview + +SimPhoNy is an ontology-based framework aimed at enabling interoperability between different simulation and data management tools, with a focus on materials science. + + + +## What can SimPhoNy be used for? + +### Manipulate ontology-based linked data, a format well suited for [FAIR data principles](https://en.wikipedia.org/wiki/FAIR_data) + + +[Linked data](https://en.wikipedia.org/wiki/Linked_data) is a format for structured data that facilitates the interoperability among different data sources. In particular, the data is structured as a directed graph, consistent of nodes and labeled arcs. With SimPhoNy, you can not only manipulate this linked data, **but also transform existing non-linked data into linked data**. + +To better understand the idea of linked data, take a quick glance at the toy example below. It shows data about a city from three different data sources: the city's traffic authority, a map from a city guide, and the university registry. As some of the concepts are present in multiple datasets, the linked data representation naturally joins all of them into a single one. + + + +Although the example above shows just plain linked data, in SimPhoNy, the linked data is enhanced with [ontologies](https://en.wikipedia.org/wiki/Ontology_(information_science)), which give **meaning** to the data. Specifically, SimPhoNy works with ontologies based on the [Web Ontology Language](https://en.wikipedia.org/wiki/Web_Ontology_Language), making the data compatible with the [Semantic Web](https://en.wikipedia.org/wiki/Semantic_Web). + +### Fetch data from a database, run a simulation and immediately store the results + +Ontology-based linked data is not only well suited for the interoperability of data, but also of software tools. In SimPhoNy, one can instantiate individuals from special ontology classes called _wrappers_. These wrappers are in fact a software interface between the core of SimPhoNy (ontology based) and external software tools, disguised to the user as an ontology class. We have already developed wrappers for a few database backends and popular simulation engines for materials science. You can have a look at the existing wrappers on our [GitHub organization](https://github.com/simphony). If needed, you may even consider [developing your own](./wrapper_development.md)! + +As a SimPhoNy user, you can see the data stored in the external software tools transparently as ontology individuals through the wrappers. In this way, moving data between different software tools becomes as simple as moving or copying it from one wrapper to another. + +For example, linked data stored in a SQLite database can be used to run a simulation just by adding the ontology individuals contained in the SQLite wrapper to the Simulation Engine wrapper. Similarly, the ontology individuals representing the results can be simply added back into the database wrapper. + + + +At this point, the results could be fetched again and for example, visualized with the help of a plotting library. + + + + + +### Couple simulation engines easily + +Exactly in the same way that the data can be moved between a database and a simulation engine using their respective wrappers, it can also be moved between simulation engines. + +This functionality facilitates the coupling and linking between such simulation engines. For example, in the domain of materials science, a certain engine might be useful for representing structures made up of atomistic particles (molecular dynamics), while another software tool could be focussed on representing bodies of fluids (fluid dynamics). As SimPhoNy can enable communication between the two tools, they could both be run and synced simultaneously to create more complex scenarios. + + + +In order achieve that, it would be necessary to translate the input and output formats of both simulation engines. However, given that the necessary wrappers exist, and their ontologies are compatible, this task becomes relatively simple thanks to SimPhoNy! At the end of the coupling process, just add the results to a database wrapper to store them. + + + +# Terminology +The name ‘SimPhoNy’ stems from the SimPhoNy EU-project in which it was originally developed (see more details [here](https://www.simphony-project.eu/)). + +Here are some additional terms that are used throughout the documentation: +1. `API`: Application Programming Interface. A set of functions that allow the interaction with an application or system. +1. `OSP`: Open Simulation Platform. + A set of common standards and related tools that form the basic environment on top of which compatible and compliant simulation workflows can be developed and run. + An OSP does not contain any simulation tools itself, it is the common framework enabling to couple and link them. +1. `backend`: a third party application or service. + Simulation engines and databases are examples of backends. +1. `wrapper`: a plugin for OSP-core that adds support to a new backend. + It must allow the user to interact with the backend through the same API as OSP-core. +1. `ontology`: an explicit, formal specification of a shared conceptualization. + In the context of ontology, other relevant terms are: + 1. `class`: a concept. E.g., 'City', 'Experiment'. + 1. `attribute`: a property of a class that has a data type. E.g., 'name' of the type String which could be used as an attribute of 'City'. + 1. `individual`: an instance of a class. E.g., an instance of the class 'City' can be used to represent the city of Freiburg in which case it would have the attribute 'name' with the value 'Freiburg'. + 1. `relationship`: a type of a way in which one individual relates to another. E.g., 'Has-A' which could use to form the relationship 'Freiburg (City) Has-A Dreisam (River)'. + 1. `entity`: a general term that can refer to a class, a relationship, attribute, or an individual. E.g., 'City', 'name', 'Has-A', the Freiburg individual are all entities. + 1. `namespace`: an ontology identifier. E.g., 'city_ontology' which could be used as a namespace for the ontology that consists of the entities 'City', 'name' and 'Has-A'. + - Each entity is uniquely identified by its name and the namespace it is contained in. We call \