Iván García-Magariño

Modular design of a hybrid genetic algorithm for a flexible job-shop scheduling problem

The aim of the job-shop scheduling problem is to optimize the task planning in an industrial plant satisfying time and technological constraints. The existing algorithmic and mathematical methods for solving this problem usually have high computational complexities making them intractable. Flexible job-shop scheduling becomes even more complex, since it allows one to assign each operation to a resource from a set of suitable ones. Alternative heuristic methods are only able to satisfy part of the constraints applicable to the problem. Moreover, these solutions usually offer little flexibility to adapt them to new requirements. This paper describes research within heuristic methods that combines genetic algorithms with repair heuristics. Firstly, it uses a genetic algorithm to provide a non-optimal solution for the problem, which does not satisfy all its constraints. Then, it applies repair heuristics to refine this solution. There are different types of heuristics, which correspond to the different types of constraints. A heuristic is intended to evaluate and slightly modify a solution that violates a constraint in a way that avoids or mitigates such violation. This approach improves the adaptability of the solution to a problem, as some changes can be addressed just modifying the considered chromosome or heuristics. The proposed solution has been tested in order to analyse its level of constraint satisfaction and its makespan, which are two of the main parameters considered in these types of problems. The paper discusses this experimentation showing the improvements over existing methods.

Model Transformation By-Example: An Algorithm for Generating Many-to-Many Transformation Rules in Several Model Transformation Languages

Practitioners of model-driven engineering usually find that producing model transformations still requires much effort. The Model Transformation By-Example (MTBE) approach softens this problem by means of the automated creation of model transformations from pairs of source and target model examples. However, the current techniques and tools for MTBE are limited in the sense that they can only produce transformations rules that are limited to just one element in some of the patterns. In addition, some transformation languages cannot directly represent many-to-many transformation rules. To overcome both limitations, this paper presents a MTBE algorithm, that can generate many-to-many rules in several transformation languages even if the transformation language cannot directly represent these kinds of rules. In particular, the implementation of this algorithm with the ATL language is available for practitioners, and it has already generated several MTs that are applied in software development. Finally, the paper compares this algorithm with existing techniques for MTBE.

A technique for defining agent-oriented engineering processes with tool support

The formalization of engineering processes is necessary for guaranteeing the quality and cost of the products involved. Agent-oriented engineering has already proposed development processes that still need to be further formalized to be applicable by non-researchers. This paper proposes a technique to instantiate processes for specific agent-oriented methodologies. This technique is based on three orthogonal views that are respectively related with lifecycles, disciplines and guidances. In addition, processes are modeled with a tool, which is automatically generated from a process metamodel inspired by the software & systems process engineering metamodel. Accordingly, engineers can choose the methodology-process pair best-suited for the characteristics of their project. The paper illustrates the approach based on the unified development process and the scrum process for the INGENIAS methodology and compares the results with other existing alternatives.

A Kinect-Based System for Lower Limb Rehabilitation in Parkinson's Disease Patients: a Pilot Study

This work brings together the emerging virtual reality techniques and the natural user interfaces to offer new possibilities in the field of rehabilitation. We have designed a rehabilitation game based on a low cost device (Microsoft KinectTM) connected to a personal computer. It provides patients having Parkinson’s Disease (PD) with a motivating way to perform several motor rehabilitation exercises to improve their rehabilitation. The experiment was tested on seven Parkinson’s Disease patients and results demonstrated significant improvements in completion time score and in the 10 Meters Walk Test score. Nevertheless, additional research is needed to determine if this type of training has a long-term impact. Both the device and protocol were well accepted by subjects, being safe and easy to use. We conclude that our work provides a simple and suitable tool resulting in a more enriching rehabilitation process where motivation is highly encouraged in PD patients. Feedback coming from participants corroborate the hypothesis that the system can be applied not only in clinical rehabilitation centers but at home.

Agent-oriented modeling and development of a system for crisis management

The management of crisis situations has been a challenging problem from different points of views, such as communication efficiency and avoiding casualties. This paper presents a novel approach that includes an interaction organization pattern for Multi-agent Systems (MASs) in crisis management, abstracted from several existing case studies in which the agents follow a sequence of interactions and the organization must optimize the use of human resources. The pattern considers an emergent organization of peers that adopt different roles according to the circumstances. The key features of the organization are its robustness, scalability (in terms of both agents and roles), flexibility to deal with a changing environment, and the efficient use of resources. In order to validate the organization, the paper presents its modeling and development with the Ingenias methodology, conforming the corresponding MAS. This development follows a model-driven approach, which allows a smooth transition from the specification to the code, and a low-cost testing of the system with different settings. Another key aspect is the application of metrics for validating and improving the MAS in terms of response time. The MAS has been tested with 600 agents representing 200 citizens, showing its performance.

PEABS: A Process for developing Efficient Agent-Based Simulators

Abstract Multi-agent systems have been commonly used for implementing simulators in which several individuals or components perform actions. Although these systems usually manage large amounts of data, the process for constructing efficient multi-agent simulators is still an open issue. This paper presents a Process for developing Efficient Agent-Based Simulators, called PEABS, which combines the use of an agent-oriented modeling language with a framework adapted for obtaining efficient agent-based simulators. The proposed process covers all the development phases from the requirements elicitation until the deployment of a complete functional multi-agent system for simulation. As a case study, a simulator, which consists of an agent-based system that imitates tourist behaviors when selecting routes in the historic center of Madrid city, is constructed following the new process. The process is evaluated with this simulator and another one that simulates the evolution of student sociograms. These simulators with the same specifications were developed using an alternative process. The experimental comparison shows that the time devoted to development are at least 22% shorter with the current process. The systems constructed with this new process are more efficient in terms of execution time and memory usage than the systems developed with the other process. The final systems developed with PEABS are also more usable for the domain experts than the ones developed with the alternative process.

A Tool for Generating Model Transformations By-Example in Multi-Agent Systems

Many Multi-Agent Systems (MAS) methodologies incorporate a model-driven approach. Model Driven Engineering is based on three main ideas: models are the “first-class citizens”, meta-models define modelling languages that are used to specify models and models are transformed during the development. However, model transformation is still a challenging issue in MAS. At first, MAS designers are not necessarily familiar with existing model transformation languages or tools. Secondly, existing tools for creating model transformations do not satisfy the necessities of agent-oriented software engineering, since they focused on coding with little support for developers. This paper proposes a tool for the creation of model transformations that is based on the generation of model transformations by-example. This tool overcomes the limitations of other similar tools in the sense that it can generate many-to-many transformation rules. The tool application is exemplified with two MAS methodologies, INGENIAS and ADELFE.

A framework for the definition of metamodels for Computer-Aided Software Engineering tools

Computer-Aided Software Engineering (CASE) tools support modeling-related activities in development projects. Given the variety of tools and functionalities, it is quite common to work with several tools in the same project. However, data cannot usually be exchanged between these tools without loss of information. Recent approaches address this model interchange problem using metamodels to characterize the involved information and transformations to export/import it. Nevertheless, most of these solutions focus on the abstract syntax of models. They fail to consider aspects such as the presentation of models or tool-specific information, which are either disregarded or represented in ad-hoc ways that make difficult their processing. In order to overcome these limitations, this paper introduces a framework to define metamodels of CASE tools and a process to carry out the model interchange using them. The proposed metamodels have a modular organization with several internal metamodels. Each of them is aimed at describing some specific information about content, structure and presentation for both models and tools. The paper illustrates this approach with a case study used for comparison with existing works for this problem.

TABSAOND: A technique for developing agent-based simulation apps and online tools with nondeterministic decisions

Abstract Agent-based simulators (ABSs) have successfully allowed practitioners to estimate the outcomes of certain input circumstances in several domains. Although some techniques and processes provide hints about the construction of these systems, some aspects have not been discussed yet in the literature. In this context, the current approach presents a technique for developing ABSs. Its focus is to guide practitioners in designing and implementing the decision-making processes of agents in nondeterministic scenarios. As an additional technological innovation, the ABSs are deployed as both mobile apps and online tools. This work illustrates the current approach with two case studies in the fields of (a) health and welfare and (b) tourism. These case studies have also been developed with the most similar technique from the literature for comparing both techniques. The presented technique improved the simulated outcomes in terms of their similarity with the real ones. The obtained ABSs were more efficient and reliable for large amounts of agents (e.g. 10,000 – 400,000 agents). The development time was lower. Both the framework and the implementation of a case study are freely distributed as open-source to facilitate the reproducibility of the experiments and to assist practitioners in applying the current approach.

Guideline for the definition of EMF metamodels using an Entity-Relationship approach

Metamodels are a formalism for defining the abstract syntax of modeling languages. However, designing a suitable metamodel from the features intended for the language is not a trivial task. This paper presents a guideline for defining such metamodels using an Entity-Relationship approach in the Eclipse Modeling Framework. This guideline proposes to begin by determining the structural features of the language, such as types of relationships and elements with attributes. Subsequently, it offers alternative representations for these features aimed at satisfying different requirements, such as changeability or optimized model processing. Two case studies illustrate the use of the guideline and its trade-offs.