The origin of organic emission in NGC 2071

Context: The physical origin behind organic emission in embedded low-mass star formation has been fiercely debated in the last two decades. A multitude of scenarios have been proposed, from a hot corino to PDRs on cavity walls to shock excitation. Aims: The aim of this paper is to determine the location and the corresponding physical conditions of the gas responsible for organics emission lines. The outflows around the small protocluster NGC 2071 are an ideal testbed to differentiate between various scenarios. Methods: Using Herschel-HIFI and the SMA, observations of CH3OH, H2CO and CH3CN emission lines over a wide range of excitation energies were obtained. Comparisons to a grid of radiative transfer models provide constraints on the physical conditions. Comparison to H2O line shape is able to trace gas-phase synthesis versus a sputtered origin. Results: Emission of organics originates in three spots: the continuum sources IRS 1 ('B') and IRS 3 ('A') as well as a outflow position ('F'). Densities are above 10$^7$ cm$^{-3}$ and temperatures between 100 to 200 K. CH3OH emission observed with HIFI originates in all three regions and cannot be associated with a single region. Very little organic emission originates outside of these regions. Conclusions: Although the three regions are small (<1,500 AU), gas-phase organics likely originate from sputtering of ices due to outflow activity. The derived high densities (>10$^7$ cm$^{-3}$) are likely a requirement for organic molecules to survive from being destroyed by shock products. The lack of spatially extended emission confirms that organic molecules cannot (re)form through gas-phase synthesis, as opposed to H2O, which shows strong line wing emission. The lack of CH3CN emission at 'F' is evidence for a different history of ice processing due to the absence of a protostar at that location and recent ice mantle evaporation.Comment: 10 Pages, 8 figures, Accepted for Astronomy and Astrophysic

Parallel Execution of ATL Transformation Rules

International audienceIndustrial environments that make use of Model-Driven Engineering (MDE) are starting to see the appearance of very large models, made by millions of elements. Such models are produced automatically (e.g., by reverse engineering complex systems) or manually by a large number of users (e.g., from social networks). The success of MDE in these application scenarios strongly depends on the scalability of model manipulation tools. While parallelization is one of the traditional ways of making computation systems scalable, developing parallel model transformations in a general-purpose language is a complex and error-prone task. In this paper we show that rule-based languages like ATL have strong parallelization properties. Transformations can be developed without taking into account concurrency concerns, and a transformation engine can automatically parallelize execution. We describe the implementation of a parallel transformation engine for the current version of the ATL language and experimentally evaluate the consequent gain in scalability

Refining Models with Rule-based Model Transformations

Several model-to-model transformation languages have been primarily designed to easily address the syntactic and semantic translation of read-only input models towards write-only output models. While this approach has been proven successful in many practical cases, it is not directly applicable to transformations that need to modify their source models, like refactorings. In this paper we investigate the application of a model-to-model transformation language to in-place transformations, by providing a systematic view of the problem, comparing alternative solutions and proposing a transformation semantics to address this problem in ATL

Improving memory efficiency for processing large-scale models

International audienceScalability is a main obstacle for applying Model-Driven Engineering to reverse engineering, or to any other activity manipulating large models. Existing solutions to persist and query large models are currently ine cient and strongly linked to memory availability. In this paper, we propose a memory unload strategy for Neo4EMF, a persistence layer built on top of the Eclipse Modeling Framework and based on a Neo4j database backend. Our solution allows us to partially unload a model during the execution of a query by using a periodical dirty saving mechanism and transparent reloading. Our experiments show that this approach enables to query large models in a restricted amount of memory with an acceptable performance

Transforming Very Large Models in the Cloud: a Research Roadmap

International audienceModel transformations are widely used by Model-Driven Engineering (MDE) platforms to apply different kinds of operations over models, such as model translation, evolution or composition. However, existing solutions are not designed to handle very large models (VLMs), thus facing scalability issues. Coupling MDE with cloud-based platforms may help solving these issues. Since cloud-based platforms are relatively new, researchers still need to investigate if/how/when MDE solutions can benefit from them. In this paper, we investigate the problem of transforming VLMs in the Cloud by addressing the two phases of 1) model storage and 2) model transformation execution in the Cloud. For both aspects we identify a set of research questions, possible solutions and probable challenges researchers may face

Map-Based Transparent Persistence for Very Large Models

International audienceThe progressive industrial adoption of Model-Driven Engineering (MDE) is fostering the development of large tool ecosystems like the Eclipse Modeling project. These tools are built on top of a set of base technologies that have been primarily designed for small-scale scenarios, where models are manually developed. In particular, efficient runtime manipulation for large-scale models is an under-studied problem and this is hampering the application of MDE to several industrial scenarios.In this paper we introduce and evaluate a map-based persistence model for MDE tools. We use this model to build a transparent persistence layer for modeling tools, on top of a map-based database engine. The layer can be plugged into the Eclipse Modeling Framework, lowering execution times and memory consumption levels of other existing approaches. Empirical tests are performed based on a typical industrial scenario, model-driven reverse engineering, where very large software models originate from the analysis of massive code bases. The layer is freely distributed and can be immediately used for enhancing the scalability of any existing Eclipse Modeling tool

Using Models of Partial Knowledge to Test Model Transformations

International audienceTesters often use partial knowledge to build test models. This knowledge comes from sources such as requirements, known faults, existing inputs, and execution traces. In Model-Driven Engineering, test inputs are models executed by model transformations. Modelers build them using partial knowledge while meticulously satisfying several well-formedness rules imposed by the modelling language. This manual process is tedious and language constraints can force users to create complex models even for representing simple knowledge. In this paper, we want to simplify the development of test models by presenting an integrated methodology and semi-automated tool that allow users to build only small partial test models directly representing their testing intent. We argue that partial models are more readable and maintainable and can be automatically completed to full input models while considering language constraints. We validate this approach by evaluating the size and fault-detecting effectiveness of partial models compared to traditionally-built test models. We show that they can detect the same bugs/faults with a greatly reduced development effort