Simon Allier
email: simon.allier@univ-ubs.fr

Salah Sadou
email: salah.sadou@univ-ubs.fr

Houari Sahraoui
email: sahraouh@iro.umontreal.ca

Régis Fleurquin
email: regis.fleurquin@univ-ubs.fr

From Object-Oriented Applications to Component-Oriented Applications via Component-Oriented Architecture

Keywords: automatic reengineering, object oriented applications, component-based architecture

Object-oriented applications of significant size are often complex and therefore costly to maintain. Indeed, they rely on the concept of class which has low granularity with varied dependencies not always explicit. The component paradigm provides a projection space well-structured and of highest level for a better understanding through abstract architectural views. But it is possible to go further. It may also be the ultimate target of a complete process of re engineering. The end-to-end automation of this process is a subject on which literature has made very little attention. In this paper, we propose such a method to automatically transform an object-oriented application in an operational component-oriented application. We illustrate this method on a real Java application which is transformed in an operational OSGi application.

I. INTRODUCTION

A system is complex and particularly difficult to understand and to maintain when it is described with a large number of highly interdependent parties. An object-oriented application is often complex because it uses hundreds or thousands of classes with many different dependencies more or less explicit. Conversely, the concept of component is deemed to provide modeling elements well suited to highlevel representation, synthetic and well-organized structure of complex software. A component view tends to a description characterized by a smaller number of parties loosely coupled, highly cohesive with clear inter-dependencies that are rigorously defined. Thus, the component paradigm can provide a "space of projection" that simplifies the understanding of a complex object-oriented system. It allows the construction of higher-level architectural views, simpler and more regular than those provided by an object-oriented system. Such views may facilitate the step of understanding a system prior to any activities of changing all or part of an object-oriented system.

In this case, the component-based architecture remains only a "contemplative" view. It is used only by the designer but is not the entry point of further automatic processing. It is possible to use such a view in a more "productive" way in the sense of Model Driven Engineering. One can use this view as a blueprint to do a complete re-engineering including a source code translation: transforming an operational object-oriented application into an equivalent operational component-based application. The new form of the application benefits from all the good properties associated with component-oriented paradigm. Indeed, the process of identifying a component is always guided by the relationships between classes while meeting certain criteria: implementation of a specific functionality, optimization of a given structural metric, etc. Thus, the provided and required interfaces, corresponding to interactions between these sets of classes (discovered components), enforce some good structural properties in terms of coupling and cohesion.

To achieve this goal, we must solve two problems: i) identifying classes that should be grouped to form abstract components and then constructing their required and provided interfaces. Thus we obtain a component-based architectural view of the application; ii) using this component-based architectural view to restructure the application into a new operational one, which conforms with a concrete component model. There are several works that partially deal with the first problem (a summary is given in Ducasse et al. [START_REF] Ducasse | Software architecture reconstruction: A process-oriented taxonomy[END_REF]). In CBSE of the last year, we have also presented an approach that improves the identification of components in objectoriented applications [START_REF] Allier | Restructuring object-oriented applications into component-oriented applications by using consistency with execution traces[END_REF]. Except works presented in [START_REF] Chardigny | Quality-driven extraction of a component-based aachitecture from an object-oriented system[END_REF], [START_REF] Medvidovic | Using software evolution to focus architectural recovery[END_REF], none of the other works propose provided and required interfaces. So most of the existing works do not provide a complete architectural view. To the best of our knowledge, there is no work dealing with the second problem. What we propose in this paper is an approach to completely automate the process of transforming an operational object-oriented application into an operational component-based application: identify abstract components (groups of classes), extract their interfaces (architectural view) and finally, transform the application using a concrete component model (OSGi).

The remaining of the paper is organized as follows: Section II describes some related works. In Section III we describe our approach to obtain a component-based architecture of the object-oriented application. Our approach to restructure the operational object-oriented application into an operational component-based application is describe in Section IV. Before concluding, we present a case study in Section V.

II. STATE OF ART

The complete re-engineering of object-oriented applications into component-based applications is not a trivial task. The first step is to identify the components by studying the clustering of the classes according to different criteria such as coupling and cohesion. Several works have focused on the problem of classes clustering with the aim of repackaging. A complete state of the art can be found in [START_REF] Ducasse | Software architecture reconstruction: A process-oriented taxonomy[END_REF]). For example, the Bunch algorithm [START_REF] Mitchell | On the evaluation of the bunch search-based software modularization algorithm[END_REF] extracts a high-level architecture by clustering modules (files in C or classes in C++ or Java) into subsystems based on module dependencies. This clustering is done using heuristic-search algorithms.

Some works specifically deal with components identification. For example, Kim et al. [START_REF] Kim | A systematic method to identify software components[END_REF] propose a systematic UMLbased method using, both functional and structural criteria, to identify the components. From use case, sequence or collaboration diagrams, they measure the dependency between use cases. These dependencies are used to cluster the use cases in components. Then, dependency between classes, involved in the use cases, are used to check and refine the identified components. Also based on UML diagrams, Lee et al. [START_REF] Lee | Component identification method with coupling and cohesion[END_REF] proposed a clustering algorithm that considers cohesion (functions supported by classes), class interaction (caused by method invocations) and class static coupling (caused by association, composition and inheritance). In the ROMANTIC method, Chandigny et al. [START_REF] Chardigny | Quality-driven extraction of a component-based aachitecture from an object-oriented system[END_REF] use an annealing clustering algorithm. The used fitness function is based on some quality characteristics (such as composability, maintenability, reliability, etc.) measured by existing metrics (such as complexity, class cohesion, etc.).

However all these approaches do not formally identify the provided and required interfaces of components. This is the second necessary step to build a complete component-based architecture. The FOCUS [START_REF] Medvidovic | Using software evolution to focus architectural recovery[END_REF] approach proposes a lightweight method to architectural recovery of OO systems. This approach recovers components (clustering classes using relation-ships among them with respect of some rules) but also high level connectors. However, these connectors indicate only that there are some communications between two components. Thus, they remain too abstract in regard of a complete identification of required and provided interfaces.

The third and final step consists in transforming the existing object-oriented application into a component-based application starting from the architectural view obtained previously. This step should lead to an executable version of the application in the target concrete component model. To the best of our knowledge, there is only one work that deals with this step: Washizaki et al. [START_REF] Washizaki | A technique for automatic component extraction from object-oriented programs by refactoring[END_REF] propose a method that gives a set of candidate components, starting from the relations between classes, in the source code, and a desired functionality represented by a given class. When a component is selected from the candidate ones, its corresponding set of classes is refactored into a JavaBean component. Thus, the aim is the extraction of reusable components. The use of this approach to automatically restructure an object-oriented application into a componentbased application raises two main problems: Identify all the functionalities that the application covers, and assemble the extracted components to rebuild the application. If the first problem can be solved using the initial specifications of the application, the second problem remains a real challenge.

III. FROM OBJECT-ORIENTED APPLICATION TO

COMPONENT-BASED ARCHITECTURE Two steps are necessary to produce an componentoriented architectural view from an object-oriented application: i) identify components, ii) identify the provided and required interfaces and to bind them together. We will examine each of these aspects in the following sub-sections.

A. Component Identification

A component is a group of classes collaborating to provide a function of the application. Thus, to build a componentoriented view of all the application, we have to define a partition of its classes. Each member of this partition will become a component. To do so, we apply an extension of a method that we already presented in [START_REF] Allier | Restructuring object-oriented applications into component-oriented applications by using consistency with execution traces[END_REF]. This method includes 3 steps (see Figure 1). In the first step, we use traces obtained by executing scenarios corresponding to application's use cases to identify what we call "core components". We use an heuristic search to find a near-optimal solution. In the second step, we rely on a static call graph to add, in the core components, some application's missing classes. Indeed, all classes of the application are not necessarily covered by the executions traces. This step uses the same heuristic search as the previous step. The last step is to manually refine the generated partition. In this step, the user benefits from some information provided by the tool on the generated solution.We will discuss each of these three steps in detail in the following subsections.

1) First step: Core component identification: A clustering algorithm allows to partition the classes of the application. Unfortunately, the number of possible partitions grows exponentially with the number of application classes. Makes for exhaustive search, for the optimal solution, infeasible in most cases. Thus, we decided to use a meta-heuristic. It designates a computational method that optimizes a problem by iteratively trying to improve a candidate solution. The improvement is done thanks to a given measure of quality using a fitness function. Meta-heuristics make few or no assumptions about the problem being optimized and can tackle a very large spaces of candidate solutions. However, meta-heuristics do not guarantee that the optimal solution will be found. In our approach, the search for the space of all possible partitions is implemented using an hybrid search [START_REF] Kelner | A hybrid optimization technique coupling an evolutionary and a local search algorithm[END_REF], which combines two different meta-heuristics: genetic algorithm (GA) [START_REF] Holland | Adaptation in natural and artificial systems[END_REF] and simulated annealing (SA) [START_REF] Metropolis | Equation of state calculations by fast computing machines[END_REF]. GA and SA algorithms are two well-known heuristic search algorithms used in many software engineering works [START_REF] Harman | The current state and future of search based software engineering[END_REF]. We will not discus theses in detail in this paper. GA is a global heuristic search that applies changes to multiple solutions and returns a solution that is near-optimal. We use a GA solution as the initial solution of a SA algorithm. SA algorithm performs a local search that explores the neighbourhood to refine the GA solution. In our cases, both SA and GA algorithms use the same data, solution representation (a partition of the classes) and fitness function.

The used data are execution traces. An execution trace is a tree where each node is the execution of a method and each edge is a call of a method. They are obtained by capturing the calls between instance of classes during the execution of a use case scenario. Every thread, created during the execution, produces an execution trace. The identification of core components from execution trace is relevant only if the execution traces cover the major part of the application functions. Therefore, to extract the traces, we apply all the recorded execution scenarios from the documentation. Execution traces capture a subset of the application classes and some of their dependencies. One of the advantages associated with the use of execution traces is getting a call graph simpler than a call graph built on the source code. Indeed, it only lists the dependencies observed and not the potential ones.

The used fitness function (Equation 1) evaluates the quality of a solution (a partition defining a set of core components) considering both the internal cohesion of components and the level of inter-component coupling of every component C.

eval(A) = 1 |Cl| ∑ C∈A (evalComp(C) * |C|) (1)
The function takes as input a solution A (a set of core components) and calculates the weighed average of the fitness of individual components. (Cl being the set of classes of the application covered by traces). The fitness of individual component (Equation 2) depends mostly on their cohesion unless the coupling level is too high, in which case the fitness score is heavily penalized. The used threshold cm corresponds to the average coupling of all the classes in the application. The cohesion and coupling are evaluated as follows:

evalComp(C) = { evalCoh(C)/2 if evalCoupling(C) < cm evalCoh(C)/2 + 0.5 otherwise. (2)
• Internal cohesion: a good component should include classes that interact with each other to provide a specific set of functionalities. Therefore, the strength of these interactions are what we call cohesion. The internal cohesion measure (evalCoh(C)) evaluates how close the different classes are in the execution traces. • Coupling: One of the strengths of component-based development is that its components are loosely coupled and can be combined to build applications. Therefore, the coupling of a component (evalCoupling(C)) is the number of its classes that are connected to classes from another component. We have shown in [START_REF] Allier | Restructuring object-oriented applications into component-oriented applications by using consistency with execution traces[END_REF] that this approach can lead to interesting architectures.

2) Second step: Adding the missing classes: At the end of the previous step, we get a partition of the classes covered by the execution traces. Thus, it is possible that some classes have been ignored. From a functional point of view, These classes have low contributions in the application functionalities. Consequently, we believe that they should have less influence on the final component-based architecture of the application. Therefore, we decided to consider them in a second round and only to refine the solution obtained in the first step. A class that is already present in a core component can not migrate to another component during this step. Each missing class must either be placed in an existing core components, or participate in the creation of a new one.

We use in this step the same meta-heuristics GA and SA. The search space is the same as in the previous step (the set of all the possible partitions) but with a strong additional constraint that no existing classes can migrate from one component to another. However, the used data are different. We use a static call graph (built using a type analysis algorithm) to identify all the (potential) dependencies between the missing classes and the existing ones. This call graph is a super-set of the previous dynamic call graph.

The fitness function of this step is still using the equation 1, but it relies on a new function to evaluate each component (equation 3). This function is always based on cohesion and coupling, but uses the static dependencies. The cohesion of a component C is evaluated by evalCoh ′ (C): the number of calls between the methods of the component's classes. The coupling of a component C is evaluate by evalCoupling ′ (C): the number of calls between the component's classes and the other classes.

evalComp ′ (C) = 1 - evalCoh ′ (C) evalCoupling ′ (C) + evalCoh ′ (C) (3)
Equation 3 is somewhat different from equation 2 because we wanted to promote the complement of existing core components with the missing classes rather than create new core components. At the end of this step we obtain a partition of all the classes of the application.

3) Third step: refining the architecture: With the two previous steps, we automatically obtain a partition of all the classes of the application. However, a meta-heuristic can not guarantee obtaining the optimal solution. The obtained solution is considered sufficiently close to the optimal. Moreover, thanks to the previous steps we have a lot of information about the solution: such as the score of each component (coupling, cohesion), the score of each class in its assigned component and the list of components to which it might belong to without significantly affecting the final score. Thus, a designer with good knowledge of the application, can significantly improve the solution, if she/he receives some recommendations derived from information on the solution. To this end, we added a step, called collaborative, where the designer can refine the solution thanks to some points raised by our system. For example, if a class is not cohesive with the classes of its component and strongly coupled with another component, our approach recommends to move this class from one component to another.

4) Object-Oriented Interfaces:

To finalize the distribution of elements coming from the object-oriented application into the core components we need to situate the interfaces (object-oriented meaning). In the object-oriented approach, an interface corresponds to the common definition of a type that may be implemented by several classes. In our case, a type implemented by a class only makes sense in the component that contains this class. Indeed, the types shared by the components are those defined by their provided interfaces (see next sub-section). Thus, the interfaces (objectoriented meaning) are placed in components that contain classes that need them. This implies that the same interface can be located in two different components.

B. Identifying Required and provided interfaces

In the first stage, we identified groups of classes working together to form components that provide high level features. However, in order to make an architectural view with these components, we need not only make their internal structure (classes and their relationships) invisible from the other components, but also provide them with provided and required interfaces to describe how they bind together. To build provided and required interfaces, we must first identify, respectively, provided and required services in order to organize them into consistent sets (interfaces).

1) Identifying component's services: In our case, provided and required services match to, respectively, incoming and outgoing method calls in respect with the component. Service identification is made from a system's call graph (CG). A CG is a graph whose nodes represent the system's methods and arcs represent calls between these methods. Provided services of a component correspond to all its methods (those defined in classes that it encompasses) that correspond to source nodes of arcs whose target node is in another component. Conversely, required services of a component corresponds to all its methods that correspond to target nodes of arcs whose source node is in another component.

As we said above, the identification of services uses a CG. But, there are two approaches to construct a CG:

• The first approach uses algorithms of type analysis. In this case, the obtained CG is called static. It contains a superset of all possible calls but not those related to dynamic class loading nor dynamic method invocations. Indeed, these calls are impossible to determine statically. Depending on the used type analysis algorithm, the CG will be more or less accurate (i.e. the super set of all possible calls will be more or less close to the set of all "real" calls). For example, the Variable Type Analysis (VTA) algorithm [START_REF] Sundaresan | Practical virtual method call resolution for java[END_REF] produce a more accurate CG than the Class Hierarchy Analysis algorithm [START_REF] Dean | Optimization of objectoriented programs using static class hierarchy analysis[END_REF].

VTA is a simple dataflow analysis that tracks, for each object reference (e.g., variable) in the program, the set of object types that it can contain. This information is used to further reduce the set of possible invocations at any given call site. • The second approach uses execution traces. In this case, the obtained CG is called dynamic.This approach gives precise CG (calls have actually taken place) but perhaps not complete (it may lack of method calls). Moreover, such CG may contain calls due to dynamic class loading and dynamic method invocation.

The used CG, to extract the services, must be both accurate and as complete as possible. Indeed, if the CG contains too many calls, we'll get noisy interfaces provided by unnecessary services (never used). Moreover, such a situation can lead to unnecessary dependencies between components. In contrast, if the CG is not complete, provided/required services could be omitted, which would lead to an inaccurate architecture of the application.

For these reasons, we built the CG as follows: First, we built a static CG using the VTA algorithm (which is sufficiently accurate). Then we completed It with the missing calls taken from a dynamic CG created using the execution traces that served for the step 1 of our process (see Figure 1). Thus we have a CG that combines the advantages of both approaches mentioned above. The analysis of this CG allows us to easily identify the required and provided services for each component. For example, in Figure 2 the set of provided services of component1 is: {C::getNewB(): B} and its set of required services is: {A::apply(C), E::mth(), E::mth(B)}.

2) Defining component's interfaces: So far, thanks to CG, we have identified the required and provided services for each component. To obtain the required and provided interfaces of a component,we need to distribute its provided, respectively required, services into coherent subsets, in regards to of the application domain, to form these provided, respectively required, interfaces. As the application was built using the object paradigm, we use this same paradigm to identify these subsets.

We begin by identifying subsets representing provided interfaces for each component. For this, we gather in the same subset, provided services of a component, which come from the same class. Thus, the component provided interfaces will be as many as the number of its classes with methods needed from the outside (of the component). As shown in Figure 3, the number of services in a provided interface may be less than the number of methods of the class that supports this provided interface. Thus, the provided interface, which is supported by the class C, contains only the service getNewB(). The other methods of this class will only be used by classes from the same component(Component1).

The required interfaces of a component are constructed by analysing its needs. when a component requires at least one service from another component, we will construct a required interface, of the same type as the provided interface of the latter, concerned by this service. Thus, the component Component11 of figure 3 will have two required interfaces, corresponding to its needs of interfaces provided by the component Component2.

At this point, we obtained an architectural representation, based on the component paradigm, with the bare necessities of interactions between components in order to have an abstract view on the application (see again Figure 3). The aim of this abstract view is to simplify the understanding of the application in a maintenance stage.

IV. FROM COMPONENT-BASED ARCHITECTURE TO

COMPONENT-ORIENTED APPLICATION the previous step leads to the construction of a componentbased architecture, of the object-oriented application, where components are represented by sets of classes with well identified provided and required interfaces. To restructure the operational object-oriented application into an operational component-based application, we will: i) use the objectoriented concepts, to implement the provided and required interfaces of the components; ii) map the identified components on a concrete component model. In this paper, we have chosen to show the mapping for the case of the OSGi component model.

A. Operational Interfaces

The previous step leads to an architecture composed with abstract components. The interfaces of these components are inferred elements which have no existence, as such, in the used object-oriented application. Threrefore, to make these components operational, we need to describe how their interfaces (required and provided) work with the classes they contain.

1) Making Provide Interfaces Operational: To be conform with component paradigms, only the services present in the provided interfaces should be accessible from outside the component, and only through these interfaces. It is not wise to modify existing classes to achieve this goal. Indeed, the modification of existing classes can cause problems with their internal consistency. Thus, we decided to use the Adapter design pattern. This is illustrated through the figure 4. The provided interface InterfaceE, from component Component2, is implemented by the adapter adaptE. The latter serves as a relay to the class E that actually implements the services of the provided interface The method mth receives, as a parameter, an object of type InterfaceB. In fact, in the object-oriented application, the parameter is of type B. No matter where stands the class B (Component2 in our example), the components only share objects of type defined by provided interfaces. Thus, before being passed as parameters, objects are wrapped into a type consistent with their corresponding provided interface (see next subsection). At the reception, as here in the method mth, objects are unwrapped in the correct type.

2) Satisfying Required Interfaces: In our case, when a component contains a required interface, it means that its classes need a class located in another component. Actually, they need only a subset of the methods from the needed class. This subset is represented by a provided interface in the component containing this class. To remain consistent with the component paradigm, and therefore, allow components to see only services that are visible through a provided interface of another component, we use the facade design pattern to represent a required interface. Thus, as shown in figure 4, each class is used by a component, but located in another, and replaced by a class of the same name that acts as a facade. The code of such a class is sketched below: The class E, in Component1, acts as a facade to access services provided by InterfaceE of component2. It keeps the same name (E) as the class located in Component2, in order to avoid modifications on classes of Component1, but it reduces the number of available methods to only those which are present in InterfaceE. Thus, it redirects calls through an object implementing InterfaceE. In addition, the facade class wraps objects, which must be passed as a parameter, in a type known by the other components (a corresponding provided interface). In the example above, this is achieved by wrapB() in the method mth().

The methods wrap() (facade object) and the method unwrap() (adapter object) together form a mechanism that ensures that only objects with a "public" type (a type corresponding to a provided interface) can be exchanged between components. Moreover, classes that use objects of type E can also ask for creation. In this case, the constructor of the facade class (see the constructor E() above), which will be called by those classes, forwards the request of creation to the adapter of the right class E, which stands in another component (Component2).

B. Component Deployment

Once the object-oriented application is restructured into a component-based application, we need to reorganize it according to a concrete component model to make it operational. To illustrate this, we chose to use the OSGi component model [START_REF] Alliance | OSGi Service Platform, Core Specification, Release 4, Version 4.2[END_REF]. Below we present the most important elements.

1) Creating the Bundles: In the OSGi framework, a component (called a bundle) is a set of classes organized into packages, which are by default not visible from outside the bundle. With the help of a manifest, it is possible to export packages. Classes and interfaces in these exported packages become visible from outside the bundle. Thus, they act as provided interfaces. Similarly, it is possible to indicate packages that the component requires to operate. Thus, classes and interfaces of these packages play the role of required interfaces.

In order to export the provided interfaces of our components, through the manifest, we placed them in specific packages. Similarly, the required interfaces are specified in the manifest by importing the packages containing them. For example, the bundle of figure 5 contains a provided interface InterfaceC that is located in the package interface_comp_2. Moreover, this bundle requires the interfaces InterfaceA and InterfaceE from the package interface_comp_1. All this is specified in the manifest as follow:

Import-Package: interface_comp_2 Export-Package: interface_comp_1
2) Management of the activators: Once the objectoriented application is restructured according to the concrete component model, its launch must conform with the framework of this model. The OSGi framework allows the specification of actions to be performed during the different phases of the bundle's lifecycle using the class BundleActivator. We use this mechanism to launch the restructured applications. Thus, for each class containing an entry point (the main() method in Java), we create in its corresponding bundle a subclass of the class BundleActivator that redefines the method start(BundleContext). These subclasses are the potential activators of the bundle. The redefined method is only used to call the original entry point (main() method) of the application. Its parameter (BundleContext) contains, among others, the parameter of the main() method. Among all the potential activators of a bundle, the designer should designate the actual one. It is identified in the fanifest as follows:

Bundle-Activator:

activator.Component1Activator

Finally, to build an OSGi bundle, the classes and the interfaces of a component, its activators (if any) and its manifest are archived in a jar file. For example, Figure 5 shows Component1 structured as a bundle. This bundle consists of classes C and F, its unique provided interface (InterfaceC and its adapter AdaptC) and its facade classes (A and E). As this component has an entry point (main() method of class C), then the class Component1Activator was created and added to the bundle.

V. CASE STUDY

In this section we present a case study on an interpreter of the logo language written in Java. Logo is a language created for learning programming. The interpreter has a graphical interface which allows writing the code and a window which shows the result graphically. It contains 40 classes and 2 interfaces. The purpose of this study is to demonstrate the feasibility of our approach.

A. Used Tools

All the necessary tools for our approach have been implemented in Java using Soot [START_REF] Vallée-Rai | Optimizing Java bytecode using the Soot framework: Is it feasible?[END_REF] as an API. Soot is a popular Java static analysis framework. It provides call graph construction algorithms and an API that allows various operations on or from a Java byte code.

The implemented tools are:

• Tracer: This tool allows the generation of execution traces. Using Soot, cookies are injected into the bytecode of classes in order to trace method calls. Subsequently, the execution of use cases generate the desired traces.

B. Process

The first step in our approach consists in obtaining the necessary data for identification of a the component-based Figure 6. The Parsor component architecture. For this, thanks to Tracer, cookies were injected into the classes of the Logo interpreter. Then, we executed scenarios corresponding to the 12 identified use cases. Examples of use cases are "file creation/saving", "code writing in the editor", "code interpretation", etc. We were given 26 execution traces (sequences of method calls) covering 38 classes of the interpreter. Two classes of the interpreter are not covered by these traces.

After that, the CBAExtracter is executed to build the component-based architecture. The latter builds a static call graph that allows on one hand to find dependencies of the missing classes, and on the other hand, to identify the component interfaces. The built static call graph contains 354 different method calls. The extracted component-based architecture is illustrated by Figure 7.

Let us look in more detail at the results of the different sub-steps (see Figure 2) necessary to obtain the componentbased architecture of the Logo interpreter.

The first sub-step consists of obtaining cores components: We identified five of these. Four of these core components are made of highly cohesive sets of classes and there are few coupled with other components. In addition, each of these four components contains classes involved in the same functionality. For example, the first core component contains the necessary classes to parse and tokenize a sentence of the Logo language (see figure 6). The second core component consists of classes responsible for the output of the Logo language instructions.

Similarly 2 classes of the application are not covered by the traces, thus third sub-step is executed. These two classes are related to the errors management in parsing and evaluation. They are respectively added to the core components related to parsing and evaluation of Logo. This was done using the static CG.

In the manual refinement sub-step, of our process, the fifth component is highlighted for consideration. This component, consisting of two classes, was poorly evaluated by the fitness function. In fact, its classes have no special relationship between them, but are more coupled with other components. We decided to put its classes in the components to which they are most coupled. Thus, this component will no longer exist.

Then, the two interfaces of the application are added to components that have classes which implement them. This is done by the 4th sub-step. For example, the interface TransConstants is added to the first component (see Figure 6).

During the step of identifying interfaces, the components have been manually named according to their provided interfaces. For example, the component of Figure 6 provides four interfaces: ITrans, ExceptionFctInconnue, textt-tIParseException and ITokenMgrError. The interface ITrans provides services for use of the Logo language parser. The 3 other interfaces provide services to manage the parse errors and these interfaces, all related to the parser, are mutually consistent. We call this component Parsor .

The identification of provided interfaces of the component display is an example of the need for a CG built using static and dynamic data. Indeed, in the class Evaluation of the component Evalaluator the method eval uses the dynamic method invocation to call the methods of the Logo interpreter which implements various functions of the Logo language. This is done as follows:

Object eval(List<Object> instr) { ... try { return ((Method)instr.get(1))).invoke(null,v,env); } ... } With a type analysis (static analysis), it is impossible to determine the targets of the method invoke and thus the CG will be incomplete. However, the methods providing the graphical functions of Logo are implemented by the class AffichageGraphe of the component Display, and these methods are used by the class Evaluation. Thus, without dynamic calls obtained from the use cases we could identify the interface IAffichageGraphe .

Finally, the interfaces are instantiated and components are packaged in OSGi bundles. This is done automatically by following the approach described in Section IV.

VI. CONCLUSION

As we saw in the introduction of this paper, despite the use of object-oriented approach, the task of maintenance is always the biggest part of the overall cost of an application. Thus, reducing this cost is a real challenge. Furthermore, having an abstract view of an application greatly facilitates its understanding. Moreover, if the implementation of the application is easily mappable on this this view, then the achievement of the maintenance will be greatly facilitated. So, what we proposed in this paper allows : i) to build the abstract view of an object-oriented application as a component-based architecture. ii) to restructure the application according to this architecture. iii) and, to implement it according to a concrete component model.

The proposed solution is complete. Indeed, it restructures an operational object-oriented application into its equivalent operational component-oriented application. To our knowledge, this problem has never been treated as a whole. Thus, we tried to propose the more generic solutions to points listed above. The first two points are generic solutions: they are based only on general concepts of object and component approaches. So, the solution maybe applicable on any objectoriented language and any component model. The last point naturally depends on a particular object-oriented language and a concrete component model. We chose as an example, for this paper, the Java language and the OSGi framework, as a concrete component model, because they simplify the understanding. With the information contained by the built architecture, it seems pretty easy to map it to any other specific concrete component model.

We wanted a solution that is as possible automatic. But to achieve the most satisfactory solution, a collaboration with the designer is required. Thus, we have identified in the restructuring process the step that requires help from the designer. In this step the designer can have relevant information from the system in order to greatly improve the proposed solution. To illustrate our approach and show the process from beginning to end, we presented a real case study. We are behind the implementation of this case study, which allowed us to draw good conclusions.

However, the components extracted with our approach are influenced by the application on which they depend. We do not claim that they are reusable in any context. This is because the way to design of object-oriented applications is quite different from that for component-oriented applications. As it was said by Lorenz "A good object-oriented design does not necessarily make a good component-based design, and vice versa" [START_REF] Lorenz | Designing components versus objects: a transformational approach[END_REF].

Currently, the definition of component's interfaces is based on existing classes. As future work, we want to capture more general semantics of a set of classes (component) to derive a better partitioning of services on the interfaces.

Figure 1 .

 1 Figure 1. The steps for component identification.

Figure 2 .

 2 Figure 2. The application's Call Graph.

Figure 3 .

 3 Figure 3. Component-oriented architecture of the application.

Figure 4 .

 4 Figure 4. Interface

  class E { private InterfaceE facade_object; public E() { facade_object = new AdaptE(); } public E(InterfaceE o) { facade_object = o; } public void mth3(){ facade_object.mth3(); } public void mth(B b){ InterfaceB ib = wrapB(b); facade_object.mth(ib); } }

Figure 5 .

 5 Figure 5. Example of a bundle

Figure 7 .

 7 Figure 7. The component-based architecture of Logo interpreter


Eric C Gaucher
email: e.gaucher@brgm.fr

Philippe Blanc

CEMENT/CLAY INTERACTIONS -A REVIEW: EXPERIMENTS, NATURAL ANALOGUES, AND MODELING

Keywords: Cement, Clay, Alkaline perturbation, Experiments, Natural analogues, Modeling

The concept of storing radioactive waste in geological formations calls for large quantities of concrete that will be in contact with the clay material of the engineered barriers as well as with the geological formation. France, Switzerland and Belgium are studying the option of clayey geological formations. The clay and cement media have very contrasted chemistries that will interact and lead to a degradation of both types of material. The purpose of this review is to establish an exhaustive list of laboratory experiments so as to identify the reaction sequences in the evolution of both the clay minerals and accessory minerals during their alteration in an alkaline environment. We review the data on clay dissolution kinetics in this environment, and include an invaluable study of natural analogues that allow one to correlate the phenomena in time. The available data and experiments make it possible to construct predictive numerical models. However, as the quality of the data is inhomogeneous, we recommend a continuation of the thermodynamic and kinetic data acquisition. It is obvious that the numerical modeling of the alkaline disturbance will be more relevant if it can combine the advantages of the different detailed models: mineralogical completeness, combined modeling of the clay and cement media, evolution of the porosity, consideration of the pCO 2 and all the surface reactions.

Introduction

It is likely, for the deep storage of radioactive waste, that significant use will be made of hydraulic binders for concrete, used as support material for the access galleries and certain storage cells, as well as containment material for low to moderately active wastes. These cement materials will be in contact with both the geological clay formation and the bentonite barriers. Due to their very aggressive nature, they will chemically disturb both the clay minerals and accessory minerals of the clay barriers (quartz, calcite, etc.). The concrete will begin to evolve as soon as it is saturated with pore water from the geological formation whose initial pH is close to neutral. This saturation will occur after the storage cells have been sealed. If commercial materials are used, the concrete degradation will initially generate a high-pH water (pH >13) rich in K, Na, Ca ions. This first period will be followed by a period in which the pH is dominated by equilibrium with portlandite, Ca(OH) 2 , (pH = 12.4), and finally by an equilibrium with the CSH-type minerals (pH ≥10) [START_REF] Berner | Evolution of pore water chemistry during degradation of cement in a radioactive waste repository environment[END_REF][START_REF] Taylor | Cement chemistry[END_REF].

This sequence of concrete-degradation states can be modified by using special "low pH"-type concretes that would lessen the destabilizing effects where the clays are concerned [START_REF] Glasser | Properties of cement waste composites[END_REF].

The clay barrier's geochemistry, mineralogy and texture will be modified near the concrete/clay interface because concrete degradation generates a diffusive alkaline plume. [START_REF] Takase | Discussion on PA model development for bentonite barriers affected by chemical interaction with concrete: Do we have enough evidence to support bentonite stability[END_REF] suggests the following rough calculation to initially determine the dimension of the montmorillonite/concrete interaction. If we take the following dissolution reaction for montmorillonite in an alkaline medium: Na 0.33 Mg 0.33 Al 1.67 Si 4 O 10 (OH) 2 + 4.68OH -+ 2H 2 O 0.33Na + + 0.33Mg 2+ + 1.67Al(OH) 4 -+ 4HSiO 3 the dissolution of one mole of montmorillonite consumes 4.68 moles of OH -, 1 m 3 of concrete (OPC + unreactive aggregate) produces 8000 moles of OH -, and one finds 1500 moles of montmorillonite in 1 m 3 of barrier (Kunigel V1 70% + sand 30%; dry density 1.6 g/cm 3 ); taking a molar volume of 220 cm 3 /mol for this montmorillonite therefore gives 4500 mol/m 3 in a mineralogically pure barrier with no porosity. These figures

show that approximately 1 m 3 of montmorillonite is required to buffer 1 m 3 of concrete. In fact, things are much more complex because the dissolution of the barrier's accessory phases and the precipitation of secondary phases will also modify the pH. For example, the precipitation of tobermorite consumes 4 moles of OH -per mole precipitated, whilst the precipitation of analcime liberates 2 moles of OH -per mole precipitated. Finally, carbonatation of the concrete is a well-known phenomenon that plays an essential buffer role with respect to the alkaline disturbance. In sedimentary formations the partial pressure of CO 2 (pCO 2 ) can be more than 10 to 100 times greater than atmospheric pCO 2 at 25 °C (Coudrain-Ribbstein et al., 1998;[START_REF] Gaucher | A new analytical method to constrain the partial pressure of CO 2 in mudrocks[END_REF]. We are therefore dealing with a complex and evolutionary system whose initial state we need to be know in detail and whose reaction pathways, taking into account the pH gradients and elemental concentrations, lead to a varied mineralogy.

The scientific community has used several tools to tackle this problem:

• laboratory experiments, to understand the reaction pathways and acquire thermodynamic and kinetic constants;

• characterization of artificial and natural analogues of the cement/rock interaction to describe the phenomena in temporal and spatial terms;

• numerical modeling of the alkaline disturbance to model the experiments and determine a predictive approach.

Many articles have been published on this subject, and it is now time to compile a working synthesis that can be used to analyse the performance of future radioactive waste storage. We start by discussing the experiments dealing with alkaline alteration of the clays used for the barriers, as well of their accessory minerals, and follow this with a summary of the experiments that have provided kinetic constants for the dissolution of montmorillonite. We then describe the work on natural analogues in Jordan where alkaline fluids have been circulating within limestone and marly limestone for some 100,000 years. Together, the experiments and the observations of natural analogues have enabled us to draw up a list of reaction pathways involving mineral evolution during the interaction between concrete and engineered clay barriers. In the last part, we discuss the numerical modeling aimed at assessing the importance of the clay-barrier degradation in time and space, detailing the uncertainties involved in this type of calculation.

Minerals and reaction pathways involved in the alkaline disturbance

The clay barriers will be made up mainly of smectite-type swelling clays. As these clays are natural materials, they will include accessory minerals that are both clays (illite(s), kaolinite, chlorite(s)) and non-clays (quartz, cristobalite, feldspar(s), mica(s), carbonate(s), sulfate(s), sulfide(s)). These minerals will have different stability under alkaline conditions and answer to a varied range of dissolution kinetics. The ions liberated by the dissolutions will in part be "reused" in the formation of new, more stable, mineral phases. The clays with the large reactive surfaces will also be subject to sorption reactions that will modify the chemistry of the clay pore water. We can thus expect the following reactions:

• modification of the adsorbed cation populations. The clay, which may initially be sodic, becomes more potassic and calcic given the greater affinity of these cations for clay and the presence of high K and Ca concentrations in the alkaline fluid. This evolution depends on Na/K and Na/Ca ratios in the alkaline fluid in function of the cement type. The precipitation of low-solubility magnesian phases causes desorption of the Mg fixed on the clays through the law of mass action. It should be noted that the clay's silanol and aluminol edge functional groups will ionize in an alkaline medium and may be involved in the adsorption reactions [START_REF] Gaucher | Specific determination of ion exchange constants: the Opalinus clay example[END_REF][START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF];

• a dissolution of the clays (smectites, illites, mixed layer clays, kaolinite). These clays disappear completely next to the cement/clay interface. This dissolution has a significant buffer effect limiting the pH rise within the barrier;

• a dissolution of the accessory minerals (quartz, cristobalite, amorphous glass, feldspars, plagioclases, micas, dolomite). The accessory minerals should not be disregarded because they can have an important buffer role with respect to the pH. Their dissolution liberates elements that favour the precipitation of certain phases (zeolites, CSH, CSAH);

• an important role of the pCO 2 in establishing the chemical conditions. This parameter can be fixed internally by an equilibrium with the mineralogy or externally by a diffusive flow from the geological formation. It is essential that this factor is taken into consideration when assessing the development of the high-pH zone, because CO 2(g) is an acid gas. It should be noted that the pCO 2 of sedimentary rocks is generally high (logpCO 2 > -2 bar) and that it exceeds atmospheric pCO 2 by two orders of magnitude [START_REF] Coudrain-Ribstein | Temperature-carbon dioxide partial pressure trends in confined aquifers[END_REF];

• a distribution of the neogenic minerals (cement phases, zeolites, carbonates, clays, silicates) as a function of distance from the concrete/bentonite interface and consequently, affects the pH gradient. Alteration of the montmorillonites generally begins with a modification of their adsorbed cation population [START_REF] Ramirez | Hydrothermal alteration of "La Serrata" bentonite (Almeria, Spain) by alkaline solutions[END_REF][START_REF] Ramirez | Alteration of the Callovo-Oxfordian Clay from Meuse-Haute Marne underground laboratory (France) by alkaline solution. I. A XRD and CEC study[END_REF], and then continues with a beidellitization or an illitization [START_REF] Mosser-Ruck | Experimental transformation of Na,Ca-smectite under basic conditions at 150 °C[END_REF][START_REF] Bouchet | Ecoclay II : Effect of cement on clay barrier performance phase II. Final report[END_REF][START_REF] Karnland | Laboratory experiments concerning compacted bentonite contacted to high pH solutions[END_REF]Bauer and Berger, 1998). The trend toward one or the other of the two reaction pathways depends mainly on the activity of K within the system. One notes a decrease in Cation Exchange Capacity (CEC) with illitization [START_REF] Eberl | Synthesis of illite-smectite from smectite at earth surface temperatures and high pH[END_REF]. This is the only case in which the CEC is lowered: precipitation of beidellite, zeolites and CSH tends to result in a strong CEC increase [START_REF] Ramirez | Hydrothermal alteration of "La Serrata" bentonite (Almeria, Spain) by alkaline solutions[END_REF][START_REF] Ramirez | Alteration of the Callovo-Oxfordian Clay from Meuse-Haute Marne underground laboratory (France) by alkaline solution. I. A XRD and CEC study[END_REF][START_REF] Bouchet | Ecoclay II : Effect of cement on clay barrier performance phase II. Final report[END_REF][START_REF] Karnland | Laboratory experiments concerning compacted bentonite contacted to high pH solutions[END_REF].

Review of the experiments on mineral alteration in an alkaline medium

The next stage in the alteration of the smectites is generally the formation of zeolites, the most common being phillipsite and analcime (de la [START_REF] De La Villa | Zeolite formation during the alkaline reaction of bentonite[END_REF][START_REF] Ramirez | Hydrothermal alteration of "La Serrata" bentonite (Almeria, Spain) by alkaline solutions[END_REF][START_REF] Ramirez | Alteration of the Callovo-Oxfordian Clay from Meuse-Haute Marne underground laboratory (France) by alkaline solution. I. A XRD and CEC study[END_REF][START_REF] Bouchet | Ecoclay II : Effect of cement on clay barrier performance phase II. Final report[END_REF][START_REF] Cuevas | Geochemical reactions between the FEBEX bentonite and Portland-type cement porewater[END_REF]Bauer and Berger, 1998;[START_REF] Nakayama | Dissolution of montmorillonite in compacted bentonite by highly alkaline aqueous solutions and diffusivity of hydroxide ions[END_REF][START_REF] Chermak | Low temperature experimental investigation of the effect of high pH KOH solutions on the opalinus shale, switzerland[END_REF]. Analcime requires higher Na levels than phillipsite in order to precipitate. One also notes the formation of variably well crystallized CSH and CASH [START_REF] Ramirez | Hydrothermal alteration of "La Serrata" bentonite (Almeria, Spain) by alkaline solutions[END_REF][START_REF] Ramirez | Alteration of the Callovo-Oxfordian Clay from Meuse-Haute Marne underground laboratory (France) by alkaline solution. I. A XRD and CEC study[END_REF][START_REF] Cuevas | Geochemical reactions between the FEBEX bentonite and Portland-type cement porewater[END_REF][START_REF] Bouchet | Ecoclay II : Effect of cement on clay barrier performance phase II. Final report[END_REF][START_REF] Bérubé | Effects on lime on common soil and rock forming minerals[END_REF][START_REF] Braney | A study of the effects of an alkaline plume from a cementitious repository on geological materials[END_REF].

Dissolution of the quartz by the cement waters enables the precipitation of CSH minerals such as tobermorite, hillebrandite, foshagite [START_REF] Bérubé | Effects on lime on common soil and rock forming minerals[END_REF][START_REF] Savage | Rate and mechanism of the reaction of silicates with cement pore fluids[END_REF][START_REF] Bateman | Experimental simulation of the alkaline disturbed zone around a cementitious radioactive waste repository: numerical modelling and column experiments[END_REF], while dissolution of the Al-bearing micas and feldspars enables precipitation of CASH-phases as hydrogrossular in addition to CSH [START_REF] Bérubé | Effects on lime on common soil and rock forming minerals[END_REF][START_REF] Savage | Rate and mechanism of the reaction of silicates with cement pore fluids[END_REF][START_REF] Bateman | Experimental simulation of the alkaline disturbed zone around a cementitious radioactive waste repository: numerical modelling and column experiments[END_REF][START_REF] Hodgkinson | The mineralogy and geochemistry of cement/rock reactions: highresolution studies of experimental and analogue materials[END_REF]1999). The Ca will thus be trapped by three phase types, i.e. CSH, CASH, CAH. Where magnesium is concerned, one notes an absence of brucite in most of the experiments. While the Mg-chlorites appear to be stable under alkaline conditions, they do contain brucite interlayers [START_REF] Bérubé | Effects on lime on common soil and rock forming minerals[END_REF]. In the presence of Si and Al, therefore, the Mg-chlorites are phases of the alkaline systems. Saponite or hydrotalcite can also trap the Mg [START_REF] Cuevas | Geochemical reactions between the FEBEX bentonite and Portland-type cement porewater[END_REF].

Finally, of note is the solubilization of organic matter in the high-pH clay systems. In the Callovian-Oxfordian argillite, for example, organic matter can form a weak acid buffer of the order of 0.1 mol/kg for the watersoluble organic acids [START_REF] Brevet | Characterization of the organic matter of argilite from the callovian-oxfordian[END_REF]. In addition, [START_REF] Claret | Experimental Investigation of the interaction of clays with high-pH solutions: a case study from the Callovo-Oxfordian formation, Meuse-Haute Marne underground laboratory (France)[END_REF] have shown that organic matter can preserve clays from dissolution.

Dissolution kinetics of montmorillonite in an alkaline medium

Among the experiments dealing with the dissolution of montmorillonite in an alkaline medium, some have endeavored to determine the kinetic laws; Bauer and Berger (1998), [START_REF] Cama | Smectite dissolution kinetics at 80°C and pH 8.8[END_REF], [START_REF] Huertas | Kinetics of montmorillonite dissolution in granitic solutions[END_REF], [START_REF] Huertas | Ecoclay II : Effect of cement on clay barrier performance phase II[END_REF]), Yamagushi et al. (2004), [START_REF] Madé | Geochemical behavior of a kaolinite/smectite clay material under neutral and alkaline conditions[END_REF] and [START_REF] Tsutsui | Reactive surface area in smectite dissolution under highly alkaline condition[END_REF]. Temperature and pH are two factors that accelerate the dissolution of montmorillonite. Figure 1 interprets the evolution the dissolution rates as a function of pH based on the results of Huertas et al. (2004) (dashes). These authors identified a first acceleration inflection at around pH 11 and a second acceleration inflection with a very steep slope at around pH 13.0-13.4. [START_REF] Madé | Geochemical behavior of a kaolinite/smectite clay material under neutral and alkaline conditions[END_REF] also find an increase of 2 orders of magnitude in the dissolution rate of the FoCa clay (interstratified kaolinite/smectite) between pH 7 and pH 12.2. This interpretation of a strong increase in the dissolution rate of the smectites with the most alkaline pH (>13) is not indicated by the earlier work of Bauer and Berger (1998) who found a fairly gentle evolution slope with the highest pH. However, the values (log molSi/m 2 /s) given by Bauer and Berger (1998) between pH 13 and 14 were already very high, being close to -11 at 35 °C and close to -10 at 80 °C. Also their beidellite smectite (Ibecco) has lower dissolution rates than Wyoming montmorillonite. [START_REF] Cama | Smectite dissolution kinetics at 80°C and pH 8.8[END_REF] shows how difficult it is to obtain kinetic constants. For a single pH of 8.8 at 80 °C, their values (log molSi/m 2 /s) range between -11 and -14 (Figure 1). The Si content is a dissolution inhibitor. As one approaches equilibrium with smectite, the dissolution rate reaches its lowest values. This is an important result for the study of clay barriers where, due to the very low porosity, the water/clay ratio favours rapid equilibration.

The work of Yamagushi et al. (2004) using compacted clays is probably the closest to actual barrier conditions in its approach. These authors also noted that their dissolution rates are lower than those of Bauer and Berger (1998), who worked with high solution/solid ratios. Finally, [START_REF] Tsutsui | Reactive surface area in smectite dissolution under highly alkaline condition[END_REF] shows that one must not use the total specific surface (BET) of the clays when calculating dissolution rates in an alkaline medium, but only the surfaces of the sheet edges at which preferential clay dissolution takes place. A quantification of these surfaces has been done by [START_REF] Bickmore | Methods for performing atomic force microscopy imaging of clay minerals in aqueous solution[END_REF][START_REF] Bickmore | In situ atomic force microscopy study of hectorite and nontronite dissolution: implications for phyllosilicate edge surface structures and dissolution mechanisms[END_REF] for kaolinite and hectorite, and by [START_REF] Tournassat | Nanomorphology of montmorillonite particles: Estimation of the clay edge sorption site density by low-pressure gas adsorption and AFM observations[END_REF] for montmorillonite. These new results should make it possible to re-evaluate the previously obtained dissolution rates in terms of the reactive area.

In conclusion, existing kinetic studies show the difficulty in obtaining dissolution rates; values scatter. It is clear that temperature and pH increase the dissolution rate. Conversely, it is necessary to undertake a study similar to that of [START_REF] Cama | Smectite dissolution kinetics at 80°C and pH 8.8[END_REF] to determine the effect of the silica content on the dissolution rate between pH 11 and 13.5. The use of kinetic constants for the smectites in numerical models seems to us to be premature, or at least very imprecise, in the absence of such data. Most authors who have undertaken kinetic modeling are well aware of the difficulty of evaluating kinetics [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF][START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF].

Underground laboratory experiments and natural analogues of the alkaline disturbance

Underground laboratory experiments give access to the full-scale complexity of the natural system and usefully complement off-site experiments, even though the interpretation is at times more difficult. The study of natural analogues gives access to very long interaction times, which is invaluable for evaluation and understanding the durability of the materials.

• [START_REF] Read | Mineralogical and microstructural changes accompanying the interaction of Boom Clay with ordinary Portland cement[END_REF] report experiments made at the Mol laboratory (Belgium). Cylinders of different concretes (CPA, CPA + fly ash, aluminous cement, etc.) were placed in the Boom Clay (smectite, illite, illite/smectite, chlorite, quartz, calcite, pyrite, feldspar, organic matter) at 85 °C for 12 to 18 months.

Overcoring enabled the concrete/clay interface to be sampled and characterized. The results show a zoning in element distribution; the clay alteration zone, 100 to 250 µm thick, is impoverished in Al, Si, Mg and enriched in Ca with respect to the unaltered clay. On the other side of the interface, the concrete alteration zone shows a reverse trend with a loss of Ca and an enrichment in Mg, S, Al, Si with respect to the unaltered concrete. The contact between the two media is marked by a Mg-Al-Si-rich zone (10 µm) containing a weakly crystalline gel whose composition could correspond to hydrotalcite and sepiolite.

• The study by [START_REF] Tinseau | Mineralogical characterization of Tournemire argillite after in situ interaction with cements[END_REF] gives us access to the results of 125 years of interaction between tunnel masonry and the Tournemire argillite (France). The interaction has taken place in both the water-saturated and -unsaturated zones. The saturated system is clearly the more reactive due to the constant water supply.

The system has remained open to the atmosphere throughout the entire period and is oxidizing. The major interaction has been pyrite oxidation with a precipitation of iron oxides. However, pyrite is a minor phase in this system. Carbonate (calcite and dolomite) precipitation is noted at the interface, the waters of the adjacent formation being in equilibrium with these two phases. Quartz and kaolinite have been dissolved

and the Fe-chlorites oxidized. Variations in the proportions of illite and illite/smectite are seen up to 17 cm from the interface. The saturated zone also reveals a precipitation of zeolites and calcium sulfates at the interface, plus a recrystallization of K-feldspars. An interesting aspect has arisen from the experimental study of alkaline alteration in the Tournemire argillites carried out at the same time by [START_REF] Devol-Brown | Interaction of Tournemire argillite with hyperalkaline fluids: batch experiments performed with powdered and/or compacted materials[END_REF]. These authors found the same overall mineralogical evolution during the accelerated tests they undertook in the laboratory.

• [START_REF] Hodgkinson | The mineralogy and geochemistry of cement/rock reactions: highresolution studies of experimental and analogue materials[END_REF] [START_REF] Lea | The chemistry of cement and concrete[END_REF]. Its persistence in a very old mortar implies a very low kinetics of reaction at low temperature. The maximum extension of reaction in the non-carbonate zones is 2.5 mm over 1800 years.

Carbonatation limits the size of the disturbance through a buffering effect.

• At Maquarin, in northern Jordan, the dissolution of natural portlandite, derived from the in situ combustion of bituminous marl, has given rise to circulating hyperalkaline waters. The "metamorphic" zone, in which the combustion of the bituminous marl took place, corresponds to the top of a thick marl unit and the base of the overlying impure limestone unit. The combustion was followed by rehydration and carbonatation that locally gave a mineralogy close to that of Portland cement. The water circulating through this "metamorphic" zone acquires a chemistry very close to the cement waters with a high pH (12.1 -13.5) and a high Ca content [START_REF] Smellie | Executive summary: Maquarin analogue study : Phase III[END_REF]. Downgradient from this zone, the hyperalkaline waters circulate through fractures in a clayey biomicrite. The fracture edges show dissolution of calcite, kaolinite, silica, traces of illite, albite and organic matter. Within the fractures themselves, different opening/closing episodes may have taken place to give a complex mineralogy. Aragonite precipitated first, followed by an ettringitethaumasite solid solution and gypsum. Reactivation of the fractures then enabled the precipitation of CSH (tobermorite and jennite). Zeolites corresponding to a last stage of mineralization are seen locally; these are yugawaralite, mordenite, diachardite for the quartz supersaturated waters, laumontite and epistilbite for the quartz equilibrated waters, and chabazite for the undersaturated waters. Intense alteration of the rock matrix extends for 1 to 4 mm with precipitation of thaumasite and ettringite. The area of influence of the disturbance can be assessed at 40 mm from the fracture for roughly 100,000 years of interaction [START_REF] Smellie | Executive summary: Maquarin analogue study : Phase III[END_REF][START_REF] Milodowski | Mineralogical alteration by hyperalkaline groundwater in northern Jordan[END_REF]Cassagnabère et al., 2001). However, it is not for sure that the rock/water contact was constant during the whole period as "dry periods" could have occurred.

6. Numerical modeling of the alkaline disturbance

• Intercomparison

Numerical modeling of the alkaline disturbance can be broken down into three categories: (i) simulations reproducing laboratory experiments (Vieillard et al., 2004 -KINDIS code), (ii) simulations of observed natural analogues (Steefel and Lichtner, 1998 -GIMRT code), and (iii) "predictive" simulations (Steefel and Lichtner, 1994 -1DREACT code;Savage et al., 2002 -PRECIP code;Soler, 2003 -modified GIMRT code;de Windt et al., 2004 -HYTEC;Gaucher et al., 2004 -PHREEQC code;Mäder and Traber, 2004 -CRUNCH code). The authors select either a purely thermodynamic approach (de [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF][START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF], or a mixed kinetic and thermodynamic approach (Steefel andLichtner, 1994, 1998;[START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF][START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF][START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF][START_REF] Mäder | Reactive transport modeling of cement-claystone interaction with application to a HLW repository in Opalinus Clay[END_REF]. All authors using the kinetic approach recognize the difficulties inherent in manipulating kinetic rates. [START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF] mention that few data are available for highly alkaline environments. The kinetic approach requires sensitivity tests, either through varying the reactive surfaces to be considered (Steefel andLichtner, 1994, 1998;[START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF], or through considering variable kinetic rates or laws [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF]. De [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF] and [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] consider that, in view of the very long interaction times (>1000 years) and very low water/rock ratio, simulations can be made using a purely thermodynamic mode. In view of the low porosities of the clayey media, these are the most suitable for attaining the thermodynamic water/rock equilibrium.

The studied geometries are more or less complex (1D, 2D), depending on the authors, with variable porosities being taken into account. Nevertheless, this aspect has relatively little impact on the data presentation and conclusions concerning the mineralogical sequences. As mineral reactions induced by chemical gradients have to be calculated for small (interface) volume, the discretization of the spatial grid is importance and must be finest as possible.

Two articles deal with temperature-based simulations after adapting the thermodynamic database (120 °C: [START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF]70 °C: Savage et al., 2002). [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF] were obliged to estimate a certain number of temperature-controlled dissolution or precipitation rates due to a lack of satisfactory data.

The pore diffusion coefficients used by the authors range between 10 -9 m 2 /s and 10 -11 m 2 /s. This large range comes from porosity differences in the clay materials that are considered or to maximize the extension of the perturbation with the largest coefficients. [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] made a sensitivity test on the amplitude of this variation range and suggested an empirical law to determine the extension of the disturbance in relation to time and the numerical value of the pore diffusion coefficient.

All the simulations give mineral phases with a higher molar volume than that of the original rock minerals. The PRECIP, GIMRT, 1DREACT, HYTEC, CRUNCH codes enable a return effect on the porosity during a phase's dissolution or precipitation. In extreme cases, the porosity can be sealed by the precipitation of minerals with high molar volumes. This results in modifying the transport conditions and can stop the transport in case of sealing. The calculations enabling this porosity return effect all indicate a total sealing of the porosity, sometimes within a very short period; 15 years in the case studied by [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF]. These authors also noted an unexpected consequence of the porosity sealing. Once the porosity was sealed at a certain distance from the cement/clay interface, the continued cementation had the effect of preventing the diffusion of OH -ions within the geological formation, thus confining the alkaline pH front toward the cement medium. [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF] show that the Ca content in the alkaline fluid, rather than the pH of the solutions, that possibly dominates sealing the porosity. [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF] show that the interdiffusion of Ca 2+ from the cement medium and CO 3 2from the geological formation causes a localized precipitation of calcite that seals the porosity at 1.5 cm from the fracture containing the alkaline solution. Sealing of the groundmass porosity appears to be well established in the case of the Jordanian natural analogues. The experiments of [START_REF] Melkior | Diffusion of an alkaline fluid through clayey barriers and its effect on the diffusion properties of some chemical species[END_REF] show a decrease (D e /1.5 to D e /2.0) in the diffusion coefficients of the tritiated water during a year-long alkaline disturbance; the authors explain this decrease as being due to pore blocking. Finally, precipitation of the cement phases with a large molar volume could have mechanical consequences on the barriers, because the volumes exceed those of the rock porosity [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF].

In simulations, the alkaline medium is represented by (i) pure solutions (NaOH at pH 13.5, KOH at pH 13.8, CaOH 2 at pH 12.5; [START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF], (ii) "young" alkaline-rich concrete solutions with pH >13.2 [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF][START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF][START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF], (iii) evolved concrete solutions (Steefel andLichtner, 1994, 1998;[START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF][START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] in equilibrium with the portlandite (pH 12.5), and (iv) degraded concrete solutions [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF] in equilibrium with a CSH gel (pH 11.2). Comparing the simulations shows that, in the absence of porosity sealing, the alkaline disturbance will extend roughly 10 times further when the pH is one order of magnitude higher. Of note is that none of the authors models the combined evolution of a complete concrete. Two articles consider the evolution of the cement medium [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF][START_REF] Mäder | Reactive transport modeling of cement-claystone interaction with application to a HLW repository in Opalinus Clay[END_REF]. De [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF] introduce a cement paste (without aggregate) with only three phases:

portlandite, ettringite and a 1.8 CSH. [START_REF] Mäder | Reactive transport modeling of cement-claystone interaction with application to a HLW repository in Opalinus Clay[END_REF] consider a complex concrete with portlandite, CSH (Ca/Si = 1.79), ettringite, hydrotalcite and hydrogarnet. The aggregate is quartz. As this last phase cannot be in equilibrium with the cement system, a dissolution kinetic control is applied. Combined modeling of the cement and clay media undeniably marks a significant progress.

Three models consider the surface reactions (ion exchange, surface complexing). Thus, de [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF] consider the ion exchange on three types of site for the 2:1 clays, one type of site for clinoptilolite and one surface complexing site for the CSH. Some of these sites may play a role in the buffer effect of the alkaline pH by liberating H + ions. [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] use a less complex ion exchange model based on the constants put forward by [START_REF] Fletcher | The chemical modelling of clay/electrolyte interactions for montmorillonite[END_REF] for the Wyoming montmorillonite; this model does not enable the pH to be buffered. Mäder and Traber (2005) use the ion exchange constants proposed by Appelo and Postma (1999) for Na, K, Ca, Mg. This choice is unfortunate because ion exchange constants were acquired specifically by [START_REF] Waber | Aqueous leachates and cation exchange properties of Mont Terri claystones. Annex A3 in "Mont Terri Project -Geochemistry of water in the Opalinus clay formation at the Mont Terri Rock laboratory[END_REF] for the Opalinus Clay considered in these models.

• Completeness of the considered mineralogy A major difference between the various articles on alkaline disturbance simulation is the completeness of the mineral list that was used. First of all, for the clay systems, one must accommodate all the mineral phases present. Then, in the context of modeling the disturbance, one must provide the model with a sufficient number of mineral phases so that it is not "forced" to accept a unique solution.

In this respect, the replacement of illite by muscovite is doubtless prejudicial to the representation of the phenomena in the articles by [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF], [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF][START_REF] Smellie | Executive summary: Maquarin analogue study : Phase III[END_REF][START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF]. The logK eq given for the muscovite is 11.02 for [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF] and Soler ( 2003), but 13.59 by [START_REF] Steefel | Multicomponent reactive transport in discrete fractures II: Infiltration of hyperalkaline groundwater at Maquarin, Jordan, a natural analogue site[END_REF], although in all cases the data were taken from the EQ3/6 database. These values are to be compared with the logK eq of illite which is 9.02 in this database. As the muscovite used by these authors is much more insoluble than illite, an artificial "resistance" is introduced for the clay barrier. [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF] also replace the rock's chlorite by kaolinite in their model. Again, this replacement is prejudicial because Mg-chlorite is stable in an alkaline medium (cf. §2) and can precipitate during the dissolution of montmorillonite by taking up Mg. The description of the reaction pathways is thus that much the poorer.

Supplying the chemical/transport code with a list of minerals that is too short can bias the response because it does not give the model any choice in the mineral phases. [START_REF] Savage | Modelling the interaction of bentonite with hyperalkaline fluids[END_REF] included only 12 minerals in their simulations, including leucite which is a volcanic mineral phase. [START_REF] Steefel | Multicomponent reactive transport in discrete fractures II: Infiltration of hyperalkaline groundwater at Maquarin, Jordan, a natural analogue site[END_REF] used a restricted list (16 minerals), but one which corresponds to the analogue they were modeling (except for the muscovite). The mineral lists of [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF][START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF][START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF] and [START_REF] Mäder | Reactive transport modeling of cement-claystone interaction with application to a HLW repository in Opalinus Clay[END_REF] consist of 18-20 phases that include a good number of calcic phases, but which are deficient in magnesian minerals. The number of considered clay phases is generally very low. The phase lists proposed by [START_REF] Vieillard | Alteration of the Callovo-Oxfordian clay from Meuse-Haute Marne Underground Laboratory (France) by alkaline solution: II. Modelling of mineral reactions[END_REF]35 minerals) and [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF]48 minerals) are much richer and leave the model to find the best solution. De [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF] show that when their model includes its maximum number of phases (CSH, zeolites, sepiolite), the pH is strongly buffered and is very different from the earlier simulations with less phases.

All the diffusion modeling carried out by the authors that we have cited show a succession of mineralogically contrasted zones. Starting outward from the concrete/clay interface, we pass through a zone of precipitation of cement phases, a zeolite zone, and then a zone in which the original clay minerals are altered. However, we shall only discuss the simulations carried out by [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] using the PHREEQC code [START_REF] Parkhurst | User's guide to PHREEQC (version 2) -A computer program for speciation, batch-reaction, one-dimensional transport, and inverse geochemical calculations[END_REF] because, in view of the large number of phases involved, they give a fairly complete picture of the expected reaction sequence (Figure 2). They model the diffusion of an evolved cement water of pH 12.5 within a barrier engineered in Wyoming bentonite MX80. The chemistry of the cement water is assumed to be constant in order to maximize the barrier degradation. From the intact barrier up to the bentonite/concrete interface we find

(1) a zone of accessory-mineral (calcite and cristabolite) dissolution with the appearance of potassic zeolites; ion exchange phenomena are intense in this zone with a conversion of Na-montmorillonite to Ca-montmorillonite (1'). This is followed by (2) a zone of smectite zeolitization and illitization, then (3) total dissolution of the clays in favour of zeolites and saponites (4'). At the interface contact (4), the zeolites disappear and we find purely cement phases of CSH (gyrolite, tobermorite, afwillite with an evolutionary sequence in their Ca/Si ratios), CASH (gismondine), hydrogarnet (katoite), carbonates (calcite and hydrotalcite) and sulfates (ettringite). There is an absence of hydroxides (portlandite and brucite) in the simulation results; although these phases are in the list of minerals likely to precipitate, they do not appear. The absence of portlandite can be explained by the pH being lower than 12.4. The absence of brucite is due to the presence of large amounts of Al and Si that hinder the formation of this phase, which has practically never been encountered under experimental conditions or during the study of natural analogues. The Mg of the smectites is thus reused to precipitate saponites, then Mg-chlorites and finally hydrotalcite, preventing brucite from reaching saturation. To be noted, however, is that the Mgchlorites (clinochlore) contain a "brucite" interlayer. Some authors force a precipitation of brucite in their models because they consider it to be practically the only phase for trapping the Mg in an alkaline medium, although they propose a number of phases for trapping the Ca [START_REF] De Windt | Coupled modeling of cement/claystone interactions and radionuclide migration[END_REF][START_REF] Smellie) Soler | Reactive transport modeling of the interaction between a high-pH plume and a fractured marl: the case of Wellenberg[END_REF][START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF]. This is unfortunate because montmorillonite liberates a lot of Mg on dissolution, and so the reaction dynamics of the Mg is not computed as well as it could be. This has consequences on the computation of the carbonate system (Ca, Mg, C) and thus on the manner in which the pCO 2 is fixed in the system, which appreciably modifies the buffer effect on the pH of a clay system "open" to the geological formation. In the simulations of [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF], the log pCO 2 is established at -2.4 bar at 25 °C within the unaltered MX80.

This value drops by several orders of magnitude in the alteration zone where the mineralogical buffer has been destroyed. The pCO 2 is a fundamental parameter for these simulations, but only [START_REF] Steefel | Diffusion and reaction in rock matrix bordering a hyperalkaline fluidfilled fracture[END_REF] and [START_REF] Gaucher | Modelling diffusion of an alkaline plume in a clay barrier[END_REF] discuss it in detail. As a complement to this description of the altered clay medium, the simulations by [START_REF] Mäder | Reactive transport modeling of cement-claystone interaction with application to a HLW repository in Opalinus Clay[END_REF] show the related alteration of the concrete. These authors note the disappearance of the portlandite and a sequence of CSH with decreasing Ca/Si ratios in the direction of the concrete/clay interface. Ettringite is also totally dissolved next to the interface.

Conclusion on the impact of the alkaline disturbance

Although it appears premature to conclude definitively on the consequences of an alkaline disturbance in a clay medium, analysis of the scientific literature in this field allows us to identify the following elements. The mineralogical consequences of an alkaline disturbance are fairly well known as a result of a large number of laboratory experiments. Efforts are nevertheless still required in order to improve our knowledge of the thermodynamics of the clays, zeolites and cement phases. Large uncertainties remain where our studies of the dissolution kinetics and mineral precipitations are concerned. Multiparameter experiments are still necessary to fix the dissolution kinetics laws of the montmorillonites, principally for constraining the inhibitor effects and taking into account the specific surfaces of the sheet edges. The studies made on natural analogues and in underground laboratories show a fairly limited spatial extension of the alkaline disturbance that is of the order of 4 cm per 100,000 years at Maqarin. All these studies have made it possible to numerically model of the phenomenon. The simulations will become increasingly representative inasmuch as we are able to take into the surface chemistry of the clays, zeolites and CSH, and to consider a mineralogical control of the pCO 2 and the evolution of the porosity. Combined modeling of the cement and clay media also appears to be a promising approach.

Acknowledgements

The work was financed by the BRGM-ANDRA partnership under the REFMAT Project (Dr. N. Michau, ANDRA) and the ALCOX Project (Dr. E. Jacquot, ANDRA). We would like to thank Prof. J.M. Cases for his review. [START_REF] Huertas | Kinetics of montmorillonite dissolution in granitic solutions[END_REF], 2004: FEBEX H 20 -70 °C;from Cama et al., 2000: FEBEX C 80 °C;and from Yamagushi et al., 2004: Kunigel Y 35 -80 °C).

Figure 2 :

 2 Figure 2: Composition of a clay barrier after 100,000 years of interaction with an effective diffusion coefficient of 10 -11 m 2 /s.

Table 1

 1

	lists the published experiments relating to the alkaline alteration of minerals present in engineered
	barriers. The synthesis of these observations on the mineralogical transformations has allowed us to formulate
	the following conclusions.

  studied the Roman mortar of Hadrian's Wall dating from 1800 years ago.They found cement paste in different states of preservation. The initial binder was an amorphous CASH gel sometimes exhibiting a fibrous texture. The gel appears to have evolved little at low temperature, and in places has been preserved from carbonatation. The authors emphasize the role of CO 2 gas and carbonate waters on the evolution of the concretes. Calcite precipitation is very present in Hadrian's Wall. Where in contact with flint, the CASH product is Si rich; the paste/flint contact is diffuse and its porosity has been filled. The Si-rich halos are more resistant to carbonatation than the cement paste. Where in contact with dolerite (feldspar, pyroxene, olivine, quartz), the paste has provided CASH and a C 4 AH n . C 4 AH n is known to be metastable with respect to hydrogarnet and in fact converts slowly to hydrogarnet during cement curing

Table 1 :

 1 Summary of literature data concerning the alkaline alteration of clay barrier minerals. Question marks report a doubt of the authors concerning the validity of an observation.

	Reference	Initial mineral (or rock)	Chemistry of the pore	Temperature	Time	Pressure	Resultant minerals	Evolution of the
			solution	(°C)	(days)	(atm)		CEC
	DE LA VILLA et al., 2001 Bentonite Febex (Spain)	pH 13.5; Na 0.17M,	35, 60,	30, 90,		1 Na-phillipsite
		93% montmorillonite, 2% quartz,	K 0.33M, Ca 4.07M	90	180, 360
		2% K-feldspar, 1% plagioclase, 2% calcite,
		1.5% volcanic glass, cristobalite.
	DE LA VILLA et al., 2001 Bentonite Febex (Spain) <2 µm	pH 13.5; Na 0.5M,	60, 90	30, 90,		1 Na-phillipsite, analcime
		montmorillonite	Ca 4.1M
	RAMIREZ et al., 2002	Bentonite Febex (Spain)	pH 13.5 to 10; several	30, 60,	7 to 365		1 Phillipsite, analcime, Mg-	Loss of Mg and Na
		93% montmorillonite, 2% quartz,	tests with Na, Ca, K at	90			smectite, CSH-gel phases	replaced by Ca and K.
		2% K-feldspar, 1% plagioclase, 2% calcite,	different concentrations.
		1.5% volcanic glass, cristobalite.
	CUEVAS, 2004	Bentonite Febex (Spain)	NaOH 0.1M, 0.25M,	25, 75,	30, 180,		Analcime, tobermorite or CSH-
		93% montmorillonite, 2% quartz,	0.5M + Ca(OH) 2 at	125, 200	365, 540		gel, gyrolite, phillipsite, saponite
		2% K-feldspar, 1% plagioclase, 2% calcite,	saturation
		1.5% volcanic glass, cristobalite.
	EBERL et al., 1993	MX80: montmorillonite, quartz, cristobalite,	KOH 3M	35	270		1 Illite (+25%)	diminution
		calcite, feldspar, pyrite, gypsum.
	EBERL et al., 1993	MX80: montmorillonite, quartz, cristobalite,	NaOH 0.5M	35	270		1 I/S R=0 in non-swelling sheets	diminution
		calcite, feldspar, pyrite, gypsum.
	BOUCHET et al., 2004	MX80: montmorillonite, quartz, cristobalite, calcite, feldspar, pyrite, gypsum.	NaOH 1M	60, 90, 120	1, 7	1 P >1 atm at 120 °C Analcime, beidellite	Increase from 75 to 110 meq/100 g
	BOUCHET et al., 2004	MX80: montmorillonite, quartz, cristobalite, calcite, feldspar, pyrite, gypsum.	KOH 1M	60, 90, 120	1, 7	1 P >1 atm at 120 °C Phillipsite, beidellite	Increase from 75 to 110 meq/100 g
	BOUCHET et al., 2004	MX80: montmorillonite, quartz, cristobalite, calcite, feldspar, pyrite, gypsum.	CaO 0.5M	60, 90, 120	1, 7	1 P >1 atm at 120 °C Portlandite, CSH-gel, gypsum, beidellite	Increase from 75 to 110 meq/100 g
	KARNLAND, 2004	MX80: montmorillonite, quartz, cristobalite,	NaOH 1.0 to 0.3M	23	70		1 Beidellite	Increase of the CEC
		calcite, feldspar, pyrite, gypsum.	NaCl 1.0 to 0.3M					from 74 to 94
								meq/100 g.
	BAUER AND BERGER,	Smectite (Ceca and Ibeco)	KOH >4M	35			1 Initial product (1) illite (+45%)	diminution
	1998						sequence (2): mica, phillipsite,
							K-feldspar, quartz
	BAUER AND BERGER,	Smectite (Ceca and Ibeco)	KOH >4M	80			1 Initial product (1) illite (+90%)	diminution
	1998						sequence (2): mica, phillipsite,
							K-feldspar, quartz

Figures

Figure

1:

Dissolution rate as a function of pH (data from