Raphael Chenouard

Model-driven constraint programming

Constraint programming can definitely be seen as a model-driven paradigm. The users write programs for modeling problems. These programs are mapped to executable models to calculate the solutions. This paper focuses on efficient model management (definition and transformation). From this point of view, we propose to revisit the design of constraint-programming systems. A model-driven architecture is introduced to map solving-independent constraint models to solving-dependent decision models. Several important questions are examined, such as the need for a visual highlevel modeling language, and the quality of metamodeling techniques to implement the transformations. A main result is the s-COMMA platform that efficiently implements the chain from modeling to solving constraint problems

Automatically Discovering Hidden Transformation Chaining Constraints

Model transformations operate on models conforming to precisely defined metamodels. Consequently, it often seems relatively easy to chain them: the output of a transformation may be given as input to a second one if metamodels match. However, this simple rule has some obvious limitations. For instance, a transformation may only use a subset of a metamodel. Therefore, chaining transformations appropriately requires more information. We present here an approach that automatically discovers more detailed information about actual chaining constraints by statically analyzing transformations. The objective is to provide developers who decide to chain transformations with more data on which to base their choices. This approach has been successfully applied to the case of a library of endogenous transformations. They all have the same source and target metamodel but have some hidden chaining constraints. In such a case, the simple metamodel matching rule given above does not provide any useful information.

Constraint based approach for the steady-state simulation of complex systems: Application to ship control

When the steady states are largely predominant with respect to transitional phases, steady-state simulation seems sufficient to predict the behavior of a complex system. Over the past 20 years, different modeling languages and dedicated tools have been developed to improve steady state simulation. In this paper, focus is made on steady-state simulation for system control and design. A model combining an emission sub-model with a ship propulsion sub-model was implemented in a constraint programming (CP) approach. It will help to determine the efficiency (i.e. the ability to model and solve the problem) and complexity of implementation (i.e. difficulties encountered during the implementation) of this approach. First, requirements for the steady-state simulation of complex systems are defined. Then, CP approach is shown to be able to answer these issues through experiments. This approach is then compared to one of the main simulation languages: Modelica. Although the two approaches (i.e Modelica and CP) are able to reverse models, the study shows that the use of Modelica principles for steady-state simulation involves some crippling limitations, such as the non-management of under/over-constrained systems, or inequalities. This study also shows that the constraint programming approach permits to meet some needs for steady-state simulation not yet covered by current approaches.

High-level modeling of component-based CSPs

Most of modern constraint modeling languages combine rich constraint languages with mathematical notations to tackle combinatorial optimization problems. Our purpose is to introduce new component-oriented language constructs to manipulate hierarchical problems, for instance for modeling engineering system architectures with conditional sub-problems. To this end, an object-oriented modeling language is associated with a powerful constraint language. It offers the possibility of defining conditional components to be activated at solving time, declaring polymorphic components whose concrete types have to be determined, and overriding model elements. We illustrate the benefits of this new approach in the modeling process of a difficult embodiment design problem having several architectural alternatives.

Computational Design Synthesis Using Model-Driven Engineering and Constraint Programming

This paper introduces a new process for computational design synthesis. It starts from functional requirements to generate one or more topologies of components. This process is implemented using Model-Driven Engineering techniques and Constraint Programming solving capabilities. Model transformations are used to transform functions and available components to a CSP. This problem is solved with a CSP solver, which solutions are transformed to topological architectures. The process is successfully applied on the design synthesis of an autonomous generator. It produces about 60 relevant solutions from which we found some existing product architectures.

A framework for automatic architectural synthesis in conceptual design phase

ABSTRACT Architectural synthesis is a key phase of the conceptual design process. In the constant evolution of complex systems, architects have found it difficult to carry out an exhaustive search of all the feasible architectural solutions for a set of given requirements. This paper proposes a computational synthesis framework that automatically generates, from a set of formatted requirements and a sub-systems database, all architectures that are requirement consistent, minimalist regarding the number of components and non-redundant. The resolution principles are based on graph theory representations and Constraint Programming solving techniques. Key features of the framework and an application example are also detailed. Abbreviations: AO: architectural object; BPMN: business process model and notation; CSP: constraint satisfaction problem; DSM: design structure matrix; SE: systems engineering.

Extended Administration: Public-Private Management

In a difficult economic context, the control of public efficiency and the steering of public investment in the private sector are of paramount importance. Here we focus on the evaluation of public-private partnerships efficiency regarding key performance indicators relating to quality of service and financial cost. Computational results on a case study validate the potential of discrete-event simulation for the clothing function in the French army. Initial and final steps are simulated, but also transition steps.

A New Integration Framework for Modeling and Optimizing Systems in Preliminary Design Phase

In this paper we propose a new integration framework model for simplifying the feasible space exploration and product optimization in early design phases. Hence, modeling and optimizing tasks are core activities in this framework. Currently, system engineering problems are modeled and optimized using a wide range of domain-specific languages. One should not duplicate these languages by creating a new system engineering language capable of modeling and optimizing every aspect of a system. Thus we combine the UML2 language and the formalism of Constraint Optimization Problems (COPs). UML2 is a visual modeling language, which provides a set of diagrams and constructs for modeling the major aspects of a product. In order to optimize design parameters, we reformulate some of this modeling knowledge into a COP. A COP may be defined as a regular constraint satisfaction problem (CSP) augmented with a set of objective functions. Thus the optimization problem to be solved is stated declaratively with acausal constraints. Then, COP solvers are based on generic solving algorithms computing a set of optimal solutions. In this paper, generic concepts integrating variability modeling concepts and based on architecture description languages are introduced. We also briefly describe transformation strategy using ATL language to perform a bidirectional mapping between UML2 constructs and the corresponding COP models.© 2012 ASME