dataesr/scientific-paragraphs-categorization huggingface dataset:
History and System Architecture The OpenModelica effort started by developing a rather complete formal specification of the Modelica language. This specification was developed in Operational Semantics, which still is the most popular and widely used semantics specification formalism in the programming language community. It was initially used as input for automatic generation of the Modelica translator implementations which are part of the OpenModelica environment. The RML compiler generation tool (our implementation of Operational Semantics)  (Fritzson et al. , 2009a)  was used for this task. However, inspired by our vision of integrated interactive environments with self-specification of programs and data, and integrated modeling and simulation environments), in 2005 we designed and implemented an extension to Modelica called MetaModelica  (Pop et al.
In 2006 our whole formal specification of Modelica static and translational semantics, at that time about 50 000 lines, was automatically translated into MetaModelica. After that, all further development of the symbolic processing parts of the OpenModelica compiler (the run-time parts were mainly written in C), was done in MetaModelica. At the same time we embarked on an effort to completely integrate the MetaModelica language extension into the Modelica language and the OpenModelica compiler. This would enable us to support both Modelica and MetaModelica by the same compiler. This would allow modeling the Modelica tool and the Open-Modelica compiler using its own language. This would get rid of the limitations of the RML compiler kernel and the need to support two compilers. Moreover, additional tools such as our Modelica debugger can be based on a single compiler.
OMC -The OpenModelica Model Compiler OMC is the OpenModelica compiler which translates Modelica models into simulation code, which is compiled and executed to perform simulations. The Open-Modelica compiler is generated from formal specifications in RML (earlier) or MetaModelica (currently). At the time of this writing the OpenModelica compiler (OMC) is generated from a specification of about three hundred thousand lines of MetaModelica. Moreover, OMC is able to compile itself, i. e. , it is bootstrapped  (Sjölund et al. , 2014). There is also a compilation mode to generate low-footprint code for embedded systems (Section 4. 20). 1. Lexical Analysis Keywords, operators and identifiers are extracted from the model.
MetaModelica for Symbolic Programming and Meta-Programming The need for integrating system modeling with advanced tool capabilities is becoming increasingly pronounced. For example, a set of simulation experiments may give rise to new data that is used to systematically construct a series of new models, e. g. for further simulation and design optimization. Such combined symbolic-numeric capabilities have been pioneered by dynamically typed interpreted languages such as Lisp  (Teitelman, 1974)  and Mathematica  (Wolfram, 2003). Such capabilities are also relevant for advanced modeling and simulation applications but lacking in the standard Modelica language. Therefore, this is a topic of long-running design discussions in the Modelica Design group. One contribution in this direction is the MetaModelica language extension  (Pop and Fritzson, 2006; Fritzson et al.
, 2011 Fritzson et al. , , 2019) )  that has been developed to extend Modelica with symbolic operations and advanced data structures in a backwards-compatible way, while preserving safe engineering practices through static type checking and a compilation-based efficient implementation. The MetaModelica language is an efficiently compiled language that provides symbolic programming using tree and list data structures. This is similar to what is provided by the rather young language Julia  (Bezanson et al. , 2017; Julialang, 2018)  which has recently ap- peared, Julia 1. 0 was released in August 2018. A comparison between MetaModelica and Julia is presented by  Fritzson et al. (2019). MetaModelica is also used for modeling/specification of languages (including the Modelica language) and for Modelica-style programming of model transformations, where the OpenModelica compiler itself is the currently largest application.
The OpenModelica LLVM backend (OMLB) The OpenModelica LLVM backend (OMLB) is an experimental OpenModelica prototype backend to investigate just-in-time compilation using the LLVM compiler framework  (Tinnerholm, 2019). The goal was to investigate the advantages and disadvantages of having OMC target LLVM instead of C. The investigation was also performed to examine if targeting LLVM would be a viable option to achieve efficient Just-intime compilation (JIT). Another approach with similar goals was conducted by  (Agosta et al. , 2019). While OMLB currently is not complete enough for bootstrapping, it demonstrates the benefits of having an LLVM based backend and JIT. OMLB is presently able to compile the algorithmic subsets of MetaModelica and Modelica interactively. Inspired by the design goals of the Julia programming language and the successful use of Julia for equation-based modeling as done by  Elmqvist et al.
Template-Based Code Generation The OMC code generation uses a text-template based approach. The Susan text template language  (Fritzson et al. , 2009b)  based on MetaModelica was developed for this purpose. It facilitates generation of code for multiple target platforms from the low-level intermediate code in and enables writing concise code generation specifications. Several alternative regular code generators are available to produce the simulation code as C or C++ code (or Java or C# code using experimental code generators), which is compiled and executed to perform simulations or to export FMUs.
Tearing For every algebraic loop some of the assigned variables are chosen as tearing-variables, such that all other variables can be evaluated explicitly on the basis of those variables. The goal is to efficiently find small sets of tearing-variables. Many algorithms are already implemented in the OpenModelica Compiler and published in  Cellier and Kofman (2006). One can influence this process by providing tearingSelect annotations, similar to the stateSelect attribute. Since this is not part of the Modelica language and specific to Open-Modelica, it must be provided as an annotation (e. g. x annotation(tearingSelect = prefer); see Table  2. Discrete variables can never be tearing variables. More information for this process regarding a specific model can be gained using the compiler flags -d=dumpLoops or -d=iterationVars.
The Performance Profiler/Analyzer By using performance profiling analysis it is possible to detect which equations or functions cause low performance during a simulation. The OpenModelica profiler  (Sjölund, 2015)  uses compiler-assisted source code instrumentation. There is one call to a real-time clock before executing the equation block or function call and one call to the clock after execution of the block. Associated with each call is a counter that keeps track of how many times this function was triggered for the given time step. Similarly, each call is associated with clock data -one variable for the total time spent in the block for all time steps and one variable for the total time spent in the block for the current time step. The time measurement uses the best real-time clock available on the used platform.
, 2019)  and OMMatlab  (OpenModelica, 2020). This gives the user the possibility to use Modelica together with the rich set of facilities and libraries in these languages, e. g. for tasks such as control design and post processing of simulation results. More precisely, the scripting language APIs (OMPython, OMJulia, OMMatlab) provide methods for -the causality of ports has to be fixed. The Open-Modelica toolset can be used to both export any given Modelica model as an FMU and import FMUs to create a composite model.
This is provided via wrappers to models in tools such as ADAMS (MSCSoftware, 2020), Beast  (Fritzson et al. , 2014; Fritzson, 2018) , Simulink (MathWorks, 2019a), Hopsan  (Axin et al. , 2010) , or cosimulation of FMUs with embedded solvers. The system can optionally be used with TLM (Transmission Line Modeling) connectors, which provide numerically more stable co-simulation. The previous version, OMSimulator 1. 0 (2017) was already made available in OpenModelica 1. 12. 0  (Fritzson et al. , 2018a). However, it was strictly restricted to TLM-connections between components. OMSimulator is provided together with a composite model editor integrated in OMEdit (Figure  13 ), that allows combining external models (e. g. FMUs for both model-exchanged and co-simulation) into new composite models, simulating them and in some cases (for the TLM version) perform 3D animation.
Parameter System Identification OMSysIdent (2020) is a system parameter identification module built on top of the OMSimulator (2020) API. For estimating the sought parameter values, a system model needs to be provided as FMU, as well as respective measurement data of the system. The API of OMSysIdent is integrated with the scripting interfaces of OMSimulator and OpenModelica (using Lua or Python scripting). Internally, the module uses the Ceres Solver  (Agarwal et al. , 2018)  library for the optimization task.
Synchronous Modelica for Model-Based Control Continuous-time physical models are treated with discrete sample times in digital control applications. Modelica's synchronous language elements extension was introduced for precisely defining and synchronizing sampled-data systems with different sampling rates (Modelica Association, 2017). OpenModelica was the second Modelica tool which supported this extension, implemented both on top of the OpenModelica C runtime and the C++ run-time. This can be used for model-based control, using Modelica and FMI  (Franke et al. , 2017).
Embedded System Support OpenModelica provides code generation of real-time controllers from Modelica models, for small foot-print platforms such as Arduino boards or in tools for RexRoth PLCs  (Menager et al. , 2014). One example of code generation to small targets is the Single board heating system (Figure  28 ) from IIT Bombay  (Arora et al. , 2010). It is used for teaching basic control theory, and usually controlled by a serial port (set fan value, read temperature, etc. ). OpenModelica can generate code targeting the ATmega16 on the board (and other AVR microcontrollers  (Thiele et al. , 2017)  or STM32F4  (Berger et al. , 2017) ). The program size is 4090 bytes including LCD driver and PID-controller (out of 16 kB flash memory available). The ATmega16 we target has 1 kB SRAM available for data (stack, heap, and global variables).
In this case, only 130 bytes is used for data variables. To simplify interfacing of low-level devices from Modelica, OpenModelica supports the Modelica DeviceDrivers library  (Thiele et al. , 2017) , which is a free library for interfacing hardware drivers that is developed primarily for interactive real-time simulations. The library is cross-platform (Windows and Linux). Using this library, modeling, parameterization and configuration can be done at a high level of abstraction using Modelica, avoiding the need for low level C programming. Another example using the embedded system support is the Arduino controlled electromagnetic levitation system depicted in.
However, this also means that there is an additional overhead involved in performing the monitoring and profiling of simulation executions. An explicit parallelization approach and language extension, ParModelica  (Gebremedhin, 2011; Gebremedhin et al. , 2012; Gebremedhin, 2019) , based on the OpenCL (2018) framework targeting shared memory multi-core processors is also currently available in OpenModelica. The explicit parallelization brings support for expressing parallelization directly in a Modelica model using language constructs that are partially based on familiar General-Purpose Graphics Processing Unit (GPGPU) frameworks such as CUDA  (Nvidia, 2008)  and OpenCL. The Modelica language is extended with constructs such as parallel for-loops and parallel functions among others. These constructs can be utilized to write an explicit parallel program in the algorithmic parts of a Modelica model.
Examples of Crowd-Sourced Applications with OpenModelica One of the benefits of OpenModelica being open source software is that it is possible to engage the community to contribute to appropriate content generation. An example of this is already provided in Section 4. 8, wherein the Textbook Companion effort is explained. In this section, we describe a few crowd-sourced simulation activities using OpenModelica. Very few open source chemical process simulators are available to the community. The situation is worse when it comes to general purpose dynamic simulation of chemical processes. A prerequisite for this is the ability to simultaneously solve all equations that make up the flowsheet or the circuit. As there could be tens of thousands of nonlinear equations in such problems, Figure  34 : A restaurant process model using PNLib in OpenModelica, with ordering, waiting, serving, eating.
Acknowledgment This work has been supported by  Vinnova  in the ITEA OPENPROD, MODRIO, OPENCPS, EMPHYSIS and EMBRACE projects and in the Vinnova RTISIM and EMISYS projects. Support from the  Swedish Government  has been received from the  ELLIIT  project. Support has also been received from the  Swedish Strategic Research foundation (SSF)  in the  LargeDyn  project. The OpenModelica development is supported by the  Open Source Modelica Consortium. Many students, researchers, engineers have contributed to the Open-Modelica system -there is not room here to mention all these people, but we gratefully acknowledge their contributions. The development of Spoken Tutorials and text-book companions was funded by the  Ministry of Education, Govt. of India , through a grant given to FOSSEE and Spoken Tutorial projects.
Recent developments in information technology such as the Internet of Things and the cloud computing paradigm enable public and private organisations to collect large amounts of data to employ various data analytic techniques for extracting important information that helps improve their businesses. Unfortunately, these benefits come with a high cost in terms of privacy exposures given the high sensitivity of the data that are usually processed at powerful third-party servers. Given the ever-increasing of data breaches, the serious damage they cause, and the need for compliance to the European General Data Protection Regulation (GDPR), these organisations look for secure and privacy-preserving data handling practices. During the workshop, we aimed at presenting an approach to the problem of user data protection and control, currently being developed in the scope of the PoSeID-on and PAPAYA H2020 European projects.
Introduction Several European projects address the topical area of privacy, data protection, and digital identities. PAPAYA  [1] , and PoSeID-on  [2] , described next, are exploring ways of cooperation to enhance privacy assurances to end-users. The goal of the PAPAYA project is to devise and develop a platform of privacy-preserving modules that protects the privacy of users on an end-to-end basis without sacrificing data analytics functionalities. The PAPAYA platform will integrate several privacy-preserving data analytics modules each of them dedicated to specific analytics operations and specific settings (e. g. , single data owner, multiple data owners). The platform aims to be usable in the sense that it also includes proper transparency and control mechanisms through a dashboard. The PoSeID-on solution is based on innovative technologies such as blockchain, cloud and smart contracts.
Not only bilaterally, but also from all the workshop attendees. During the workshop, we presented our approach to the problem of user data protection and control that is currently being developed in the scope of the PoSeID-on H2020 European project. The presented solution complies with EU's General Data Protection Regulation and explores the use of Blockchain technology to provide data transactions protection and accountability, as well as full control of users over their data. The goal of this workshop was to identify and present the privacy challenges related to data analysis by public and private organisations and to encompass research advances in the privacy-enhancing technologies that will enable privacypreserving data management and GDPR compliance. Moreover, the workshop served as a discussion environment for those familiar with cryptographic tools, and discuss possible concerns and risks when it comes to applying such tools in different areas when data is critical and sensitive.
Workshop Format The allocated time for the workshop was two hours. The objective was to first introduce both projects and then focus on the specific objectives and challenges. It was possible to present and discuss the previously agreed topics. The workshop was organized as follows: -Opening (5 min. ): The workshop program presentation (Orhan Ermis). -PoSeID-on Project Presentation (20 min. ): The presentation introduced the PoSeID-on H2020 EU project Project 6  (Alessandra Bagnato). -PoSeID-on Project Dashboard Demo (10 min. ): Offered an insight about the dashboard and its functionalities (Paulo Silva). -Papaya Presentation (25 min. ): The presentation introduced the Papaya Project 7  H2020 EU project (Orhan Ermis). -The End User requirements in PAPAYA Presentation (10 min. ): Highlighted human aspects and results from end-user studies (Ala Sarah Alaqra).
The second presented PoSeID-on Private sector organization use case was related to Softeam, a private French software vendor with about 1000 employees. Softeam develops a software called e-Citiz -a platform for Business Process Management for both e-government and companies, and which has been on the market since 2004. Softeam has a big experience in personal data management due to several business projects and some research projects. With the e-Citiz platform, Softeam proposes the SVE ("Saisine par Voie Electronique" which means Seizure by Electronic Way), an eService product allowing users to apply for a claim or any sort of demand to the company. The SVE pilot privacy challenge will imply the customization of the SVE product to integrate PoSeID-on solution to provide the users of the current SVE services with a single platform for personal data management, as well as to support SVE to be compliant with the GDPR.
Dashboard and Data Analysis Modules The team then presented the PoSeID-on Web Privacy Enhanced Dashboard as a web application giving Data Subjects access to the PoSeID-on functionalities. Access to the Web Dashboard is managed by national systems compliant with eIDAS (e. g. , SPID, @firma, FRANCEconnect). Such systems guarantee users secured access to the digital services of Public Administrations. These "electronic Identities" are released by Identity Providers, accredited bodies that release the credentials (User ID and Password), after verifying the user's identity. The session was very positive and interactive. The dashboard mock-ups were well accepted and had positive feedback. The participants wondered about the dashboard compliance with W3C Standards, which is one of the aspects that PoSeID-on project takes into consideration.
The architecture of PoSeID-on was also presented and the audience was particularly interested in the PoSeID-on analytics capabilities, in particular, the Risk Management Module (RMM) and Personal Data Analyser (PDA). These components will be used to evaluate and manage a risk score as well as to monitor all personal data flow and usage in addition to related warnings generated, to detect and prevent anomalies and misbehaved transactions (data flow and usage). The RMM leverages Apache Spark Streaming and associated machine learning library MLlib to build a data analysis pipeline in order to perform anomaly detection on incoming logs from system components. All data is stored in Cas-sandraDB to guarantee throughput of writes and the partition of distributed data according to the deployment each RMM instance and Cassandra node.
The PDA explores the potentialities of Natural Language Processing (NLP), more precisely Named Entity Recognition (NER) to analyse personal information. It comprises an ensemble learning mechanism with the best-performing machine learning algorithms (e. g. , Random Forest, Conditional Random Fields, Convolutional Neural Networks), NLP tools (e. g. , Stanford CoreNLP or SpaCy) and regular expressions to provide an accurate analysis of data. Moreover, since it does not store any data and is open source, it is trustworthy and transparent. With the Blockchain, Dashboard, RMM and PDA, the user could be aware of data privacy exposure and have control over his/her data. The audience particularly appreciated that PoSeID-on Users can be advised on which service they could eventually disable in case of anomalies or high exposure of their data to privacy risks.
Moreover, the participants were also very interested in the way PoSeID-on Dashboard handles such amount of information. One aspect that came out from the workshop discussion was that how much it is necessary to write a statement which clearly details and clarifies the provided transparency and add it to PoSeID-on Dashboard web site. It was also noticeable the interest in better understanding how we handle the data flowing through PoSeID-on. More specifically, over how the data is managed, kept, analysed by our modules. Therefore, this valuable input is going to be considered during the next stages of development as well as dissemination and presentation of the project.
The three different human actors in the use case scenario are the patient, pharmacist, and cardiologist. The eHealth use-case involves electrocardiogram (ECG) medical data that is to be collected from the patient via a wearable device and uploaded to the medical healthcare platform by the pharmacist. Data is then encrypted and send to the PAPAYA platform, where data is analyzed and sent back to the platform. Finally, the cardiologist receives the results of the analysis alongside raw data and other medical records to perform the diagnosis and send a report back to the patient. In total, there were 11 participants in the workshop. We had optional demographic questions included in the questionnaire and the following are the responses for work/field, ages and genders for those who chose to answer those fields.
Perspectives/mental models. In order to understand the mental model of participants, we inquired about their sharing behaviours and their opinions about privacy. We asked participants whether they are active on social media, personal (e. g. , Facebook) and professional (e. g. , Researchgate), so that we get an indication about their data sharing behaviour. Similarly in previous work, where it was shown that different stakeholders have different values for privacy that affect their privacy sharing behaviours  [6]. 10 out of 11 participants indicated their responses, 6 indicated yes/occasionally on personal social media where 4 indicated no, whereas 7 indicated yes/occasionally on professional social media and 3 no. When asked whether privacy is not always the most important incentive on 5-point Likert scale from strongly disagree to strongly agree.
3 participants disagreed, 2 were neutral, 5 agreed, and 1 strongly agreed. A comment related to that question highlighted that privacy is the most important incentive just in research environment. Key challenges. Several challenges and concerns were highlighted by participants, they specified the need to address challenges with technologies, actors involved and trust factors for both use-case scenarios. It was indicated that technical challenges to PAPAYA for implementing and guaranteeing data accuracy should be addressed, as well as confidentiality, data security and privacy, and scope of data use and limitations. Additionally, considerations for ethical, legal and social factors pose trust challenges, such as the safety and the need for guarantees for patient's safety in the first use case scenario.