Khaled Aslan

Nagham Alhadad
email: nagham.alhadad@univ-nantes.fr

Hala Skaf-Molli

Pascal Molli
email: pascal.molli@univ-nantes.fr

SCHO: An Ontology Based Model for Computing Divergence Awareness in Distributed Collaborative Systems

Multi-synchronous collaboration allows people to work concurrently on copies of a shared document which generates divergence. Divergence awareness allows to localize where divergence is located and estimate how much divergence exists among the copies. Existing divergence awareness metrics are highly coupled to their original applications and can not be used outside their original scope. In this paper, we propose the SCHO ontology: a unified formal ontology for constructing and sharing the causal history in a distributed collaborative system. Then we define the existing divergence metrics in a declarative way based on this model. We validate our work using real data extracted from software engineering development projects.

Introduction

Web 2.0 applications showed the importance of collaborative systems. These systems changed the internet users into web writers. Many collaboration tools are currently available like: Wikis, blogs, video-conferencing systems, version control systems. These collaboration tools are classified using Ellis matrix [START_REF] Ellis | Concurrency Control in Groupware Systems[END_REF]. This matrix is based on two dimensions; time and space. Users can be distributed in time and space. But there is another dimension which is working on different copies. This collaboration mode is called multi-synchronous [START_REF] Dourish | The Parting of the Ways: Divergence, Data Management and Collaborative Work[END_REF]. In this mode users replicate shared objects and they converge or diverge among each other. This divergence can be observed, measured and visualized. This is called divergence awareness.

Many previous work have addressed the measurement and the visualization of the divergence. Divergence awareness is provided in different systems with ad-hoc visualizations, such as State Treemap [START_REF] Molli | State Treemap: an Awareness Widget for Multi-Synchronous Groupware[END_REF], Palantir [START_REF] Sarma | Palantr: Raising Awareness among Configuration Management Workspaces[END_REF], Edit Profile [START_REF] Papadopoulou | Increasing Awareness in Collaborative Authoring through Edit Profiling[END_REF], Wooki [START_REF] Weiss | Wooki: a P2P Wiki-based Collaborative Writing Tool[END_REF], etc.

Existing systems define their own divergence metrics without a common formal definition. Metrics are coupled with the application and cannot be used outside their original scope. There is no previous work that tried to build a unified formal model for divergence awareness. Unified model for computing divergence opens the opportunity to build a middleware for distributed collaborative systems.

Multi-synchronous collaborative systems rely on optimistic replication models [START_REF] Rahhal | Multi-synchronous Collaborative Semantic Wikis[END_REF]. Optimistic replication models are based on history sharing which are application independent. We propose to conceptualize and formalize the sharing of causal history in distributed collaborative system. This allows to compute divergence metrics in a declarative way independently of the application.

In this paper, we use semantic web technology to define an ontology for constructing and sharing the causal history in a distributed collaborative system. Then we define the existing divergence metrics in a declarative way based on this model. We validate our work using real data extracted from software engineering development projects.

The paper is structured as follows. First section presents divergence metrics in distributed collaborative systems. The second section details the SCHO ontology. The third section presents the formal definition of divergence awareness metrics based on this ontology. The fourth section presents the validation of the proposed model using real data. The last section concludes the paper.

Divergence Metrics in Distributed Collaborative Systems

Divergence occurs when there are more than one copy of a shared document and participants can modify their copies in parallel. A cooperative work is a cycle of divergence and convergence. Divergence occurs when two activities have different views of a shared document. After divergence participants synchronize their activities to reestablish a common view of the document; further individual activities will cause divergence again, necessitating further synchronization and so on [START_REF] Dourish | The Parting of the Ways: Divergence, Data Management and Collaborative Work[END_REF]. State Treemap [START_REF] Molli | State Treemap: an Awareness Widget for Multi-Synchronous Groupware[END_REF], Palantir [START_REF] Sarma | Palantr: Raising Awareness among Configuration Management Workspaces[END_REF], Edit Profile [START_REF] Papadopoulou | Increasing Awareness in Collaborative Authoring through Edit Profiling[END_REF], Wooki [START_REF] Weiss | Wooki: a P2P Wiki-based Collaborative Writing Tool[END_REF] are examples of tools that provide the user with divergence awareness.

State Treemap

State Treemap [START_REF] Molli | State Treemap: an Awareness Widget for Multi-Synchronous Groupware[END_REF]) is a divergence awareness mechanism, it enables the participant to be aware of the differences among her documents and the others' documents by using the different document states:

• Locally Modified enables the participant to know that her own copy was modified where the others are not.

• Remotely Modified makes the participant aware of the changes that occur in the remote workspaces.

• Need Update means that a new version of the document is available.

• Potential Conflict means that more than one participant are updating the same document.

When a document has been modified by a participant, it will be marked as (Local Modified) in her own workspace, where in the others participants' workspaces it will be marked as (Remotely Modified).

Palantir

Palantir [START_REF] Sarma | Palantr: Raising Awareness among Configuration Management Workspaces[END_REF] is another awareness tool that provides software developers with insight into others' workspaces. It gives awareness information about concurrent modifications performed in isolation in the context of configuration management systems. Palantir captures a number of events, for instance, added, removed, changes in progress, changes committed, etc. The effect of the changes is computed and presented to the users by means of two metrics: the severity and impact metrics. The severity metric measures how much a component in a user's workspace has changed when compared to its latest checked version in the repository, or its version on the collaborators workspaces. It can be binary, indicating that a change of any kind occurred, or a number indicating the percentage of lines of code that were modified in any way. The impact measure takes into consideration the code dependencies and computes how much a component in a local workspace is affected by changes to related components in remote workspaces. Table I summarizes the awareness states defined in Palantir proposal.

Edit Profile

Edit Profile [START_REF] Papadopoulou | Increasing Awareness in Collaborative Authoring through Edit Profiling[END_REF] provides awareness at different levels: document, paragraph, sentence, word and character. The participant has the possibility to choose at which level she needs to be aware of the changes on a document. So the metrics are calculated based on the participant choice of details. The participant also has the possibility to choose which type of operations she is interested in. For example; insert or delete operations. The system assigns a different color for each participant to distinguish his/her contribution from the others. Wooki (Concurrent Modifications)

Wooki [START_REF] Weiss | Wooki: a P2P Wiki-based Collaborative Writing Tool[END_REF] is a P2P wiki composed of a P2P network of autonomous wiki servers. Each wiki page is replicated over the whole set of server. A change performed on a wiki server is immediately applied to the local copy and then propagated to the other sites. A remote change when received by a server is merged with local changes and then applied to the local copy. To avoid the conflicts, the redundancy or even the unreliable information that result from the merge, a concurrency awareness mechanism is used. This mechanism makes users aware of the status of the pages they access regarding concurrency: Has this page been merged automatically? In this case show me where concurrent changes occur since the last reviewed state? Existing systems such as State Treemap, Palantir, Edit Profile and Wooki; define their own divergence metrics without a common formal definition. Metrics are coupled with the application and cannot be used outside their original scope. In the next section, we propose a unified formal model for divergence awareness. This model allows to compute all existing divergence metrics.

SCHO: Shared Causal History Ontology

Divergence occurs when there are more than one copy of a shared document. Optimistic replication model [START_REF] Saito | Optimistic replication[END_REF] considers (N ) sites sharing copies of shared document. A document is modified by executing an operation on it. Any operation has the following life cycle:

1. Generated on one site and executed locally immediately, 2. broadcasted to the other sites, 3. received by other sites and re-executed.

The causality property is essential in a collaborative system to avoid users' confusion [START_REF] Sun | Achieving convergence, causality preservation, and intention preservation in real-time cooperative editing systems[END_REF]. Causality ensures that all operations are ordered by a precedence relation in the sense of the Lamport's happened-before relation [START_REF] Lamport | Times, Clocks, and the Ordering of Events in a Distributed System[END_REF]. Therefore they will be executed in same order on every site. Broadcast-ing operations is not fully determined in the general optimistic replication framework. But it is assumed that all operations should be eventually delivered to all sites. The causality and broadcasting are application independent.

We observed that divergence metrics on a document can be computed relying on the state of its operations according to the operation life cycle in the optimistic replication model. Our approach is to define an ontology to formalize concepts and relations that allow to build and to share causal histories. This ontology allows the formal definition of existing divergence metrics and to calculate them as semantic queries.

The broadcast is represented using the general approach of publish/subscribe that can be used by any distributed collaborative system [START_REF] Rahhal | Multi-synchronous Collaborative Semantic Wikis[END_REF]. The model is not application dependent. Consequently, we have to determine the underlying concepts required to exchange change sets i.e. set of operations. The publish/subscribe model works as follows:

• When a document is modified on a site, patches are generated. A patch is a set of operations related to one document.

• Several patches can be combined in one changeset that can be published into one or several channels called PushFeeds.

• An authorized site can create a PullFeed corresponding to an existing Push-Feed and pull changesets. Then the patches contained in the changesets can be re-executed locally. If needed, the integration process merges this modification with concurrent ones, generated either locally or received from a remote site.

Unified Shared Causal History Model (SCHO)

The Shared Causal History Ontology (SCHO) shown in Figure 1 represents all the concepts of SCHO: changesets, patches, push and pull feeds. This ontology enables the SCHO users to query the current state of the document and its complete history using semantic queries. This ontology is populated through the user interaction with the system using five basic operations: createPatch, createPush, push, createPull and pull. These operations are inspired by the Push/Pull/Clone model used in distributed version control systems such as Git, Mercurial and Bazaar [START_REF] Allen | ClearCase MultiSite: Supporting Geographically-Distributed Software Development[END_REF]. These operations create instances of the SCHO ontology. The details and the algorithms of each operation are presented in the following section.

Each site can perform five operations:

• createPatch: Generates operations

• createPush: Creates a topic (or feed) in the publish/subscribe model

• push: Publishes local operations on the feed

• createPull: Subscribes to a remote feed

• pull: Consumes remote operations.

These five operations enable the building and sharing of causal history. The OWL file for the Shared Causal History Ontology (SCHO) is provided in Appendix A.

The ontology defines basic concepts common to distributed version control systems such as ChangeSet, Patch, Previous, Operation, etc. It also defines more precise concepts such as PullFeed and PushFeed. These concepts allow the distinction between published/unpublished operations and consumed/unconsumed operations which is essential for computing divergence awareness.

• Site: a site has the following properties:

-siteID: This attribute contains the identifier of the site.

-hasPush, hasPull and hasDoc : The range of these properties are respectively a PushFeed, a PullFeed and a Document. A site has several PushFeeds, several PullFeeds and several Documents.

• Document: a document has the following properties:

-docID: This attribute contains the identifier of the document.

head: This property points to the last Patch applied to the document.

• Operation: This concept represents a change in a document. An operation has the following property:

-operationID: This attribute contains the unique identifier of the operation.

• Patch: A set of operations. A patch is calculated during the save of document.

A patch has the following properties:

-patchID: A unique identifier of the patch.

-onDoc: The range of this property is the Document where the patch was applied.

-hasOp: This property points to the Operations generated when the document was saved.

previous: Points to the precedent executed Patch on the local site.

• ChangeSet: A set of patches. This concept is important to support transactional changes. It allows to group patches generated on multiple documents. Therefore, it is possible to push modifications on multiple documents. it has the following properties:

-changSetID: A unique identifier of a ChangeSet.

-hasPatch: Points to the Patches generated since the last push.

-previousChangeSet: Points to the precedent ChangeSet.

-inPushFeed: The range of this property is a PushFeed. This property indicates the PushFeed that publishes the ChangeSet.

-inPullFeed: The range of this property is a PullFeed. This property indicates the PullFeed that pulls a ChangeSet.

• PushFeed: This concept is used to publish changes made on a site. It has the following properties:

-pushID: A unique identifier of the PushFeed.

-hasPushHead: This property points to the last published ChangeSet.

• PullFeed: This concept is used to receive the changes made on a remote Site. It has the following properties:

-pullID: A unique identifier of the PullFeed.

-hasPullHead: This property points to the last pulled ChangeSet.

The ontology is managed by the five operations mentioned earlier. The algorithms for these operations are presented in the following. These algorithms ensure that each site implements a causal reception [START_REF] Rahhal | Multi-synchronous Collaborative Semantic Wikis[END_REF]. Consequently, the proposed framework ensures causality.

Unified Shared Causal History Algorithms

The createPatch operation is called when a document is modified. It calls a diff function that computes the operations related to a particular type of document. The diff function is an application dependent function. The communication between sites is made through feeds. The createPush operation creates a PushFeed. A PushFeed is used to publish the changes. createPush(name : String, docs : set of Document ) :

PushFeed(name) hasPush(site, name) call Push(name)

The push operation creates a ChangeSet corresponding to the documents and adds it to the PushFeed. The "Integrate" function in the pull algorithm is an Commutative Replicated Data Type (CRDT) algorithm [START_REF] Weiss | Logoot-Undo: Distributed Collaborative Editing System on P2P Networks[END_REF] [START_REF] Weiss | Logoot : a Scalable Optimistic Replication Algorithm for Collaborative Editing on P2P Networks[END_REF] [START_REF] Preguica | A Commutative Replicated Data Type for Cooperative Editing[END_REF] Divergence Metrics in SCHO This section details the formal definition of existing divergence awareness metrics based on SCHO model. Divergence awareness metrics are calculated on a site for a given document. We use the following notations: LS to denote a local site on which divergence metrics are calculated. RS: to denote a remote site. We define the following formula:

• onSite(P,D,S): This means that a patch P belongs to a document D was generated on a site S.

onSite(P, D, S) ≡ ∃P ∃D∃S : P atch(P ) ∧ Document(D) ∧ Site(S) ∧ onDoc(P, D) ∧ hasDoc(S, D)

• inPushFeed(P,S): This means that a patch P is published by the site S.

inP ushF eed(P, S) ≡ ∃P ∃P F ∃S : P atch(P ) ∧ P ushF eed(P F ) ∧ Site(S) ∧ hasP ush(S, P F ) ∧ inP ushF eed(P, P F )

• inPullFeed(P,S) : This means that a patch P is consumed by the site S.

inP ullF eed(P, S) ≡ ∃P ∃P F ∃S : P atch(P ) ∧ P ullF eed(P F ) ∧ Site(S) ∧ hasP ull(S, P F ) ∧ inP ullF eed(P, P F )

State Treemap Divergence Awareness

To calculate the State Treemap metrics using the SCHO model, we made the following interpretations and defined the corresponding formula.

•

Palantir Divergence Awareness

We define the divergence awareness of Palantir detailled in the table I using SCHO ontology.

• Populated (Pop): A document has been created on a site. • Change Reverted: The document has returned to its original state.

ChangeReverted ≡ ∃U ndoOperation(LS)

• Severity Changed:

The number of patches has been done on a document.

P : P ∈ {LM (D, S)} P : P ∈ {RM (D, S)}
It is interesting to notice that the SCHO model allows to use State Treemap metrics to calculate Palantir metrics. This was not possible without the formal ontology.

Concurrent modification Divergence Awareness

The patches which were made locally in parallel with the patches which were made remotely. If we know the causal relation between patches on a document we could know the concurrent patches. The multi-synchronous environment satisfies the causality which ensures that all the operations are ordered by a previous relation. This means that the operations will be executed in same order on every site. The history in this approach will be causal graph. CM ≡ ∃D∃S∃P 1∃P 2 : Document(D) ∧ Site(S) ∧ hasDoc(S, D) ∧ onDoc(P 1, D) ∧ onDoc(P 2, D) ∧ ¬previous(P 1, P 2)

Validation

In order to validate our approach we populated the SCHO ontology with the causal history data. We used git [START_REF] Git | Fast Version Control System[END_REF] repositories. git is a distributed version control system that supports a multi-synchronous collaboration. git repositories have rich sets of data with different size that can be used to compute divergence metrics.

To use git data, First we had to inject the git history data into a triple store to populate our ontology. We used the Jena TDB [START_REF]Open source Semantic Web framework for Java[END_REF] triple store, then we implemented a parser code which is responsible for the mapping between the concepts defined in git history and SCHO ontology. Figure 2 shows the history log of a sample git project.

We made the following assumptions when we parsed the git history: • We considered the project as one shared object, so any changeset we find is a modification to this object.

• Whenever we find a branch in the history we create a PushFeed and the corresponding Site.

• Whenever we find a merge changeset we create a PullFeed and the corresponding Site.

• Each site represents one user.

So for the sample project we will have: three Sites, two PullFeeds, two Push-Feeds and thirteen ChangeSets. Figure 3 shows the populated ontology resulting from parsing the git history. Figure 4 shows the same RDF graph but without the concepts for the sake of clarity.

Based on the assumptions mentioned above we were able to find the different sites and the push/pull interactions between the sites as it is shown in Figure 4.

Then we used the metrics described earlier to calculate the divergence between the sites using SPARQL (SPARQL, 2008) If a ChangeSet is not in one of these states i.e. not Published and not Remotely Modified then it will be in the state Locally Modified Table II shows the resulted states for State Treemap and Palantir for our sample project.

We plotted the corresponding divergence graph. Figure 5 shows the results we found for the sample git project. We can observe clearly the divergence and convergence phases. Then we used real git projects to validate the approach, such as reddit (Reddit, 2008), gollum [START_REF] Gollum | A wiki built on top of Git[END_REF]), CakePHP (CakePHP, 2005) and MongoDB (Mon-goDB, 2009). The reddit project has 424 changsets in its git history over 26 months. The gollum project has 554 changesets over 10 months. The CakePHP project has 7508 changesets over 64 months. The mongoDB has 11086 changesets over 38 months.

Table III shows the details of each project and the execution time for populating the ontology with the causal history of these projects that we used to validate our approach. Figures 6, 7 and 8 show the results obtained after calculating the divergence awareness metrics on the reddit, gollum and mongoDB projects respectively. The Y-axis represents the number of changesets, while the X-axis represents the time.

Project

Conclusion

Building a system that computes divergence awareness can be a very challenging task. Different propositions have been made to compute divergence awareness, like StateTreemap, Palantir, etc. Such divergence metrics are highly dependent on applications and cannot be reused outside of their original scope. In this work, we proposed a general framework that allow to capture and to share causal histories. We expressed this model using semantic technologies. Next, we demonstrated how it is possible to compute all existing divergence metrics on this framework using semantic queries. Thus, divergence metrics are no more dependent of application models. We validated this result by transforming the distributed version control systems history into this ontology and computing the divergence metrics on them.

In the future we plan to embed SCHO ontology inside distributed version control systems in order to allow users and developers to take advantage of divergence awareness and semantic technologies. We also plan to analyze more systems to characterize divergence evolution in time.

A SCHO Ontology described in OWL Namespace ( r d f = < h t t p : / / www. w3 . o r g / 1 9 9 9 / 0 2 / 2 2r d f -s y n t a x -n s #>) Namespace ( owl = < h t t p : / / www. w3 . o r g / 2 0 0 2 / 0 7 / owl #>) Namespace ( x s d = < h t t p : / / www. w3 . o r g / 2 0 0 1 / XMLSchema#>) Namespace ( r d f s = < h t t p : / / www. w3 . o r g / 2 0 0 0 / 0 1 / r d f -schema #>) Namespace ( a = < h t t p : / / www. s e m a n t i c w e b . o r g / o n t o l o g i e s / 2 0 0 9 / 4 / s c h o .

O n t o l o g y ( < h t t p : / / www. s e m a n t i c w e b . o r g / o n t o l o g i e s / 2 0 0 9 / 4 / s c h o . owl> C l a s s ( a : C h a n g e S e t p a r t i a l owl : T h i n g ) C l a s s ( a : Document p a r t i a l owl : T h i n g ) C l a s s ( a : O p e r a t i o n p a r t i a l owl : T h i n g ) C l a s s ( a : P a t c h p a r t i a l owl : T h i n g ) C l a s s ( a : P u l l F e e d p a r t i a l owl : T h i n g ) C l a s s ( a : P u s h F e e d p a r t i a l owl : T h i n g ) C l a s s ( a : S i t e p a r t i a l owl : T h i n g ) C l a s s ( owl : T h i n g p a r t i a l ) )

Figure 1 .

 1 Figure 1. Shared Causal History Ontology.

  Locally Modified(LM): There are new patches in a local site which are not published in its PushFeeds. LM (D, LS) ≡ ∃P ∃D∃LS : P atch(P ) ∧ Document(D) ∧ Site(LS) ∧ onSite(P, D, LS) ∧ ¬inP ushF eed(P, LS) • Remotely Modified(RM): There are new patches in remote sites which are not in the PullFeeds of the current site. RM (D, LS) ≡ ∃P ∃D∃LS∃RS : P atch(P ) ∧ Document(D) ∧ Site(LS) ∧ Site(RS) ∧ (LS = RS) ∧ onSite(P, D, RS) ∧ ¬inP ullF eed(P, LS) • Potential Conflict (PC): It is the state where the document is Locally Modified and Remotely Modified. This is the intersection of the two previous states. P C(D, LS) ≡ ∃D∃LS∃RS : Document(D) ∧ Site(LS) ∧ Site(RS) ∧ (LS = RS) ∧ LM (D, LS) ∧ RM (D, LS) • Need Update(LNU): There are PushFeed(s) in remote sites that were not pulled locally. LN U (D, LS) ≡ ∃P ∃D∃LS∃RS : P atch(P ) ∧ Document(D) ∧ Site(LS) ∧ Site(RS) ∧ (LS = RS) ∧ inP ushF eed(P, RS) ∧ ¬inP ullF eed(P, LS) • Will Conflict (WC): W C(D, LS) ≡ ∃D∃LS : Document(D) ∧ Site(LS) ∧ LN U (D, LS) ∧ LM (D, LS) • Locally Up To Date (UTD) U T D ≡ ∀D∀S : Document(D) ∧ Site(S) ∧ ¬LM (D, S) ∧ ¬RM (D, S)

P

  op ≡ ∃D∃LS∀RS : Document(D) ∧ Site(LS) ∧ Site(RS) ∧ (LS = RS) ∧ hasDoc(LS, D) ∧ ¬hasDoc(RS, D) • Change in progress (CP): This state is similar to the Locally-Modified or Remotely-Modified states already mentioned in State Treemap. CP ≡ ∃D∃S : Document(D) ∧ Site(S) ∧ (LM (D, S) ∨ RM (D, S))

Figure 2 .

 2 Figure 2. A sample project git history.

Figure 3 .

 3 Figure 3. A sample project equivalent RDF graph.

Figure 4 .

 4 Figure 4. A sample project equivalent RDF graph without the concepts.

Figure 5 .

 5 Figure 5. Divergence awareness for sample project.

Figure 6 .

 6 Figure 6. Divergence awareness for reddit project.

Figure 7 .

 7 Figure 7. Divergence awareness for gollum project.

Figure 8 .

 8 Figure 8. Divergence awareness for mongoDB project.

O

  b j e c t P r o p e r t y ( a : hasDoc domain ( a : S i t e ) r a n g e ( a : Document ) ) O b j e c t P r o p e r t y ( a : hasOp domain ( a : P a t c h ) r a n g e ( a : O p e r a t i o n ) ) O b j e c t P r o p e r t y ( a : h a s P a t c h domain ( a : C h a n g e S e t ) r a n g e ( a : P a t c h ) ) O b j e c t P r o p e r t y ( a : h a s P u l l domain ( a : S i t e ) r a n g e ( a : P u l l F e e d ) ) O b j e c t P r o p e r t y ( a : h a s P u l l H e a d domain ( a : P u l l F e e d ) r a n g e ( a : C h a n g e S e t ) ) O b j e c t P r o p e r t y ( a : h a s P u s h domain ( a : S i t e ) r a n g e ( a : P u s h F e e d ) ) O b j e c t P r o p e r t y ( a : h a s P u s h H e a d domain ( a : P u s h F e e d ) r a n g e ( a : C h a n g e S e t ) ) O b j e c t P r o p e r t y ( a : h e a d domain ( a : Document ) r a n g e ( a : P a t c h ) ) O b j e c t P r o p e r t y ( a : i n P u l l F e e d domain ( a : C h a n g e S e t ) r a n g e ( a : P u l l F e e d ) ) O b j e c t P r o p e r t y ( a : i n P u s h F e e d domain ( a : C h a n g e S e t ) r a n g e ( a : P u s h F e e d ) ) O b j e c t P r o p e r t y ( a : onDoc domain ( a : P a t c h ) r a n g e ( a : Document ) ) O b j e c t P r o p e r t y ( a : p r e v i o u s domain ( a : P a t c h ) r a n g e ( a : P a t c h ) ) O b j e c t P r o p e r t y ( a : p r e v i o u s C h a n g e S e t domain ( a : C h a n g e S e t ) r a n g e ( a : C h a n g e S e t ) )

  PullFeeds are created to pull changes from PushFeeds on remote sites to the local site. A PullFeed is related to a PushFeed. In the sense that it is impossible to pull unpublished data. The createPull operation perform this task.The pull operation fetches the published ChangeSets that have not been pulled yet. It adds these ChangeSets to the PullFeed and integrate them to the documents on the pulled site.

	pull(name : String) :
	cs = get(name.headPullFeed)
	while (cs = null)
	CS' = {∃x(ChangeSet(x)∧inPushFeed(x,name))}
	if cs / ∈ CS' then
	inPullFeed(cs, name)
	call Integrate(cs)
	endif
	cs = cs.previousChangeSet
	endwhile
	push(name : String) :
	ChangeSet(csid=concat(site.siteID, site.logicalClock++))
	inPushFeed(csid, name)
	published = {∃x∃y(Patch(x)∧Changeset(y)∧inPushFeed(y,name)∧hasPatch(y,x))}
	patches = { ∃x∃p (Patch(P)∧Document(x)∧onDoc(x,p))}
	foreach patch ∈ patches / published
	hasPatch(csid, patch)
	endfor
	previousChangeSet(csid, name.hasPushHead)
	hasPushHead(name, csid)
	createPull(name : String, pushID : int) :
	PullFeed(name);
	call Pull(name);

  queries. For example the following query returns the state Remotely Modified for a ChangeSet $CSid.

	SELECT ? p f WHERE {
	MS2W: $CSid MS2W: i n P u l l F e e d ? p f .
	MS2W: $CSid MS2W: d a t e ? d a t e .
	? p f MS2W: h a s P u l l H e a d ? CSHead
	MS2W: ? CSHead MS2W: d a t e ? h e a d D a t e .
	NOT EXISTS { MS2W: $CSid MS2W: p u b l i s h e d " t r u e " . }
	FILTER ( x s d : d a t e T i m e ( ? h e a d D a t e ) <= x s d : d a t e T i m e ( ? d a t e ) )
	}

Table II .

 II Divergence awareness results for the sample project.

	ChangeSet No.	State Treemap	Palantir
	1	Locally Modified	Populated
	2	Up to Date	Changes Committed
	3	Remotely Modified Change in Progress
	4	Remotely Modified Change in Progress
	5	Potential Conflict	Change in Progress
	6	Remotely Modified Changes Committed
	7	Remotely Modified Change in Progress
	8	Remotely Modified Change in Progress
	9	Potential Conflict	Change in Progress
	10	Potential Conflict	Change in Progress
	11	Potential Conflict	Change in Progress
	12	Locally Modified	Synchronized
	13	Locally Modified	Change in Progress

Table III .

 III Execution time for populating the SCHO ontology.

	name	#ChangeSets Project Lifespan (month) Execution time (ms)
	Sample project	13	-	2079
	Reddit	424	26	3549
	Gollum	554	10	7976
	CakePHP	7508	64	384409
	MongoDB	11086	38	783560


Khaled Aslan

Pascal Molli

Hala Skaf-Molli

Stéphane Weiss

Stephane Weiss

C-Set : a Commutative Replicated Data Type for Semantic Stores

Keywords: scalability, synchronisation, peer-to-peer, consistency, replication

Web 2.0 tools are currently evolving to embrace semantic web technologies. Blogs, CMS, Wikis, social networks and real-time notifications, integrate ways to provide semantic annotations and therefore contribute to the linked data and more generally to the semantic web vision. This evolution generates a lot of semantic datasets of different qualities, different trust levels and partially replicated. This raises the issue of managing the consistency among these replicas. This issue is challenging because semantic data-spaces can be very large, they can be managed by autonomous participants and the number of replicas is unknown. A new class of algorithms called Commutative Replicated Data Type are emerging for ensuring eventual consistency of highly dynamic content on P2P networks. In this paper, we define C-Set a CRDT specifically designed to be integrated in Triple-stores. C-Set allows efficient P2P synchronisation of an arbitrary number of autonomous semantic stores.

Introduction

Web 2.0 tools are currently evolving to embrace semantic web technologies. Blogs, CMS, Wikis, social networks and real-time notifications, integrate ways to provide semantic annotations and therefore contribute to the linked data [START_REF] Bizer | Linked Data -The Story So Far[END_REF] and more generally to the semantic web vision. This evolution generates a lot of semantic datasets of different qualities, different trust levels and partially replicated.

The problem of updating and synchronizing data in the semantic web has been raised by Berners-Lee in [START_REF] Tim | Delta: an ontology for the distribution of differences between RDF graphs[END_REF]. Efficient synchronization of semantic stores organized in a peer-to-peer network can leverage problems of scalability and allows different autonomous participant to collaboratively combine, improve and enrich semantic datasets.

Synchronizing semantic stores is challenging. Semantic data-spaces can be very large, they can be managed by autonomous participants and the number of replicas is unknown, potentially high. Only few replication algorithms can fulfill these constraints and they all belong to the optimistic replication class of algorithms [START_REF] Saito | Optimistic replication[END_REF]. An optimistic replication model considers an unknown number of sites, each site has a copy a shared object. An object can be modified by applying locally an operation. Next, this operation is broadcasted to other sites in order to be re-executed. The system is correct if it ensures the eventual consistency property [START_REF] Johnson | RFC677: The maintenance of duplicate databases[END_REF] i.e. all replicas are identical when the system is idle. Thomas write rule [START_REF] Johnson | RFC677: The maintenance of duplicate databases[END_REF] was the first algorithm to ensure eventual consistency in duplicated databases. However, Thomas write rule requires the knowledge of the number of participants (in order to provide a safe garbage collection scheme). This constraint is not compatible with our context.

Recently, a new class of optimistic replication algorithms called CRDTs is emerging [START_REF] Oster | Data Consistency for P2P Collaborative Editing[END_REF][START_REF] Weiss | Logoot-undo: Distributed collaborative editing system on p2p networks[END_REF]. CRDT stands for Commutative Replicated Data Types. CRDTs propose to define new abstract data type that provides commutative operations. CRDTs ensure eventual consistency regardless of the order of operations at reception. CRDT has been defined for arrays, linear sequence and tree.

In this paper, we define a specific data type for sets called C-Set that can be applied for a triple store and we prove that this type ensures eventual consistency. With a traditional set, operations insert/delete do not commute. C-Set provides commutative insert, delete operations, does not require causal reception of operation and can leverage some problems of garbage collection. C-Set is designed to be integrated within a semantic store in order to provide P2P synchronisation of autonomous semantic store.

The paper is organized as follow: Section 2 presents backgrounds and related works. Section 3 defines a new CRDT type for set designed for triple stores. Section 4 discusses our approach. Section 5 summarizes contributions and presents future work.

Background and related work

Many previous work on replication in semantic P2P systems focused on sharing RDF resources. They did not enable collaborative working for maintaining RDF stores. In the context of data sharing, some sites publish their RDF data while other sites consume this data. So there is no concurrent modifications and/or operations. While collaborative systems consider a shared object between the peers. This imply that the peers can modify the object concurrently and then they can run a consolidation algorithm to ensure the consistency of the shared object.

Tim Berners-Lee and Dan Connolly proposed an ontology for the distribution of differences between RDF graphs called Delta [START_REF] Tim | Delta: an ontology for the distribution of differences between RDF graphs[END_REF]. In their approach they rely on the standard serialization of RDF graphs into text files then running a diff between the resulted text files. However, the authors do not detail how eventual consistency can be efficiently reached by their algorithms.

RDFGrowth [START_REF] Tummarello | RDFGrowth, a P2P annotation exchange algorithm for scalable Semantic Web applications[END_REF] and Publish/Subscribe Networks [START_REF] Chirita | Publish/subscribe for rdf-based p2p networks[END_REF] focus on semantic data sharing where only one peer can modify the shared knowledge while others can read them. However, as it was mentioned earlier, sharing is different from collaboration. In sharing, some peers publish data while others can only read these data and concurrent updates are not managed. In collaborative working environments, some peers publish data, others can read and write these data and a synchronization algorithm integrates concurrent updates. Collaborative environments improve the quality of data, the experience of the collaborative Wikipedia demonstrates this.

Edutella [START_REF] Nejdl | EDUTELLA: a P2P networking infrastructure based on RDF[END_REF] proposes a RDF-based metadata infrastructure for P2P applications. It focuses on querying RDF metadata stored in distributed RDF repositories. The objective is providing access to distributed digital educational resources. Edutella distinguishes between two kinds of peers, simple and super peer. Simple peers provide data resource along with its schema. Super peers are used for several purposes, including data mediation, integration and query routing. Edutella proposes a replication service. However, it is not mentioned how to replicate and synchronize metadata.

RDFSync [START_REF] Tummarello | RDFSync: efficient remote synchronization of RDF models[END_REF] synchronizes a target RDF graph with a source one. RDF graphs are decomposed unequivocally into minimal subsets of triples (Minimum Self-Contained Graphs MSGs) and canonically represented by ordered lists of the identifiers (hashes) of its composing MSGs. The synchronization algorithm performs a diff between the source and the target of the ordered list of MSGs. RDFSync can perform three kinds of synchronization, in the Target Growth Sync (TGS) the target becomes equal to the merge of both graphs, in the Target Erase Sync (TES) the target deletes unknown information by the source and finally in Target Change Sync (TCS) the target becomes equal to the source. Figure 1 shows an example of RDF graph synchronization using RDFSync.

Fig. 1: RDF synchronization using RDFSync RDFPeers [START_REF] Cai | RDFPeers: a scalable distributed RDF repository based on a structured peer-to-peer network[END_REF] is a scalable distributed RDF repository. It is based on a structured P2P network. To enable faults tolerance, RDFPeers uses partial replication of RDF data. Every RDF triple is stored at three nodes of the network. However, it is not explicitly specified what happens in the case of concurrent updates on copies.

Thomas write rule [START_REF] Johnson | RFC677: The maintenance of duplicate databases[END_REF] present techniques by which a number of loosely coupled processes can maintain duplicate copies of a database, despite the unreliability of their only means of communication. The copies of the database can be kept consistent. However, in order to remove the old deleted entries "garbage collection" they propose the following scheme: each site could notify the other sites whenever it hears about a deletion. If these notifications are transmitted in order with the "normal" sequence of modifications, then upon receipt of such a notification a site can be sure that the sending site has delivered any outstanding assignments to the deleted entry, has marked it as deleted, and will not generate any new assignments to it. This implies the knowledge of all the sites in the system. This constraint is not compatible with the P2P networks context.

In summary, P2P Semantic Web replication researches focus on knowledge sharing and querying. No algorithm have been designed for collaborative editing of RDF graphs. Consequently, they do not take into account concurrent updates on RDF graphs. A CRDT is a data structure where all concurrent operations commute, so they do not require merge algorithms or integration procedure to enforce consistency. The replicas of a CRDT converge automatically, without complex concurrency control. Examples of algorithms that implement this data type are Woot [START_REF] Oster | Data Consistency for P2P Collaborative Editing[END_REF],

C-Set definition

TreeDoc [START_REF] Preguica | A Commutative Replicated Data Type for Cooperative Editing[END_REF], Logoot [START_REF] Weiss | Logoot : a scalable optimistic replication algorithm for collaborative editing on p2p networks[END_REF] and Logoot-Undo [START_REF] Weiss | Logoot-undo: Distributed collaborative editing system on p2p networks[END_REF]. None of the existing algorithms handles the set data type.

A set with operations insert(element) and delete(element) is not a CRDT. The counter-example is presented in figure 2. The example illustrates how three sites can receive operations op 1 , op 2 , op 3 in different order. Site 1 executes the sequence [op 1 ; op 2 ; op 3 ] while Site 3 executes the sequence [op 1 ; op 3 ; op 2 ]. If the execution of operations does not commute, then eventual consistency is violated i.e. the set on site 1 is empty while the set on site 3 contains {x}.

C-Set Data Structure

We want to define a CRDT for sets data type, where each element in this set corresponds to an RDF triple. We represent the set S of elements as a set of a couple of (e : element, x : Z). We define on this set four operations : ins(e : element), del(e : element), rins((e : element, k : Z)) and rdel((e : element, k : Z)) detailed in the following section.

C-Set Algorithms

The operation ins(e : element) can be executed locally immediately. It generates and sends remote insert operation rins((e : element, k : Z)) that is executed remotely. In our model we give the ins operation precedence over the del operation. So whenever an ins operation is executed it compensate the effect of all the previously received del operations. , , The proof that C-Set preserves eventual consistency is straightforward. On each site, C-Set generates sequence of additions of elements that belong to (Z, +). As addition in (Z, +) is commutative, C-Set converge. ) ) , ,

op2 = ins(x) z z {(x, +1)} {(x, +1)} {(x, +1)} {(x, +2)} op3 = del(x) rdel(x,-1) u u {} {(x, +1)} {(x, +1)} site 1 {} site 2 {} site 3 {} op1 = ins(x) , , op2 = ins(x) z z / / {(x, +1)} {(x, +1)} {(x, +1)} {(x, +2)} {(x, +2)} op3 = del(x) rdel(x,-2) r r {} {}
{(x, +1)} {(x, +1)} {(x, +1)} op2 = del(x) rdel(-1) u u $ $ op3 = del(x) rdel(-1) u u {} {} {(x, -1)} {(x, -1)}
Fig. 4: C-Set and Tombstones C-Sets is a CRDT data type for sets that ensures eventual consistency. However, as shown in figure 4, C-Set, as the Thomas write rule, relies on tombstones. This means that a deleted element remains in the store. In the example in figure 4 the final value {(x, -1} is clearly a tombstone. Garbage collecting tombstones is a challenging issue in a dynamic P2P network as in our context. It requires each site to have knowledge about the state of all the others sites. Consequently it makes the synchronisation dependant of the number of sites and requires procedures to join and leave synchronisation groups.

An interesting property of C-Sets is that tombstones can be removed locally on one site without communication with others sites when counters associated to set elements are equal to 0. Tombstones will remain if same elements are concurrently deleted on several sites which is not the more frequent scenario. Extensive experimentation is needed to prove the efficiency of this hypothesis.

Conclusion and perspectives

In this paper we presented C-Set : a CRDT for sets that ensure eventual consistency. C-Set is designed to be integrated within a semantic store in order to provide P2P synchronisation of autonomous semantic store. C-Sets is more efficient than Thomas write rule, especially in managing the delete operations.

Future work will integrate C-Set within an existing semantic store. Next, we will be able to to evaluate the overhead of C-Sets using real-world semantic web data such as DBpedia [START_REF] Bizer | DBpedia -A crystallization point for the Web of Data[END_REF].

Fig. 2 :

 2 Fig. 2: A Traditional set counter-exemple

  Figure3shows an execution example of C-Sets. The first execution corresponds to the example presented in figure2. Site 1 executes sequence [op 1 ; op 2 ; op 3 ] which in fact executes [(+1) + (+1) + (-1)] on the counter associated to x value in the C-Set. When the same operations are executed in a different order on site 3, the sequence [op 1 ; op 3 ; op 2 ] force the computation of [(+1) + (-1) + (+1)] on the counter associated to x value in the C-Set. Of course both sites converges. An alternative execution is also presented in figure3. This execution illustrates how the operation op 3 can trigger the sending of operation rdel(x, -2).

Fig. 3 :

 3 Fig. 3: C-Set : Two convergent executions


Danh Toan Nguyen

Pierdomenico Paolino

M C Audry

Antoine Chateauminois

Christian Fretigny

Yohan Le Chenadec

M Portigliatti

E Barthel

SURFACE PRESSURE AND SHEAR STRESS FIELDS WITHIN A FRICTIONAL CONTACT ON RUBBER

Keywords: friction, rubber, local friction law, displacement field, linear sliding, torsional contacts

This paper addresses the issue of the determination of the frictional stress distribution from the inversion of the measured surface displacement field for sliding interfaces between a glass lens and a rubber (poly(dimethylsiloxane)) substrate. Experimental results show that high lateral strains are achieved at the periphery of the sliding contacts. As a consequence, an accurate inversion of the displacement field requires that finite strains and non linear response of the rubber substrate are taken into account. For that purpose, a Finite Element (FE) inversion procedure is implemented where the measured displacement field is applied as a boundary condition at the upper surface of a meshed body representing the rubber substrate.

Normal pressure is also determined by the same way, if non-diverging values are assumed at the contact edge. This procedure is applied to linearly sliding contacts as well as on twisting contacts.

Introduction

Due to practical applications as well as for fundamental issues, friction on elastomers has received a large attention over the years. However, the role played by adhesion, viscoelasticity and roughness in friction remains unclear. For the latter property, for example, it is generally assumed that the apparent contact area is not representative of the real contact area, but should be dependent on the normal load, the elasticity and the roughness parameters.

As a consequence, rough surface would exhibit local interfacial friction which depends on the actual contact area, and thus on the local normal pressure. Though qualitative evidences for these theories have been obtained (see for example references [START_REF] Persson | Theory of rubber friction and contact mechanics[END_REF][START_REF] Persson | On the nature of surface roughness with application to contact mechanics, sealing, rubber friction and adhesion[END_REF]), experimental data allowing a quantitative assessment of the models remains scarce. In most of the experimental friction studies, the friction force is measured for different normal loads, velocities, geometries… As total friction force is a property integrated over the whole contact area where the normal pressure is not homogeneous, evaluation of the different models is thus rather indirect.

In an effort to obtain a spatial resolution of the interfacial stress in the sliding contact of a rigid body on a flat rubber sample, we have recently developed a new technique, based on the measurement of the displacement field at the rubber surface 3, 4 . The distribution of the interfacial friction stress which causes the observed displacements is determined using a numerical inversion method. Field measurements methods are now very much used in the field of mechanics where they have emerged as a powerful technique to bridge the gap between experiments and simulations allowing for direct displacement and strain comparisons (for a review on that topic, see for example references [START_REF] Pan | Two dimensional digital image correlation for in plane displacment and strain measurement: a review[END_REF] and [START_REF] Hild | Digital image correlation: from displacement measurement to identification of elastic properties -a review[END_REF]). One of the most popular approaches is the so-called Digital Image Correlation Technique (DIC) which can be viewed as an extension of the Particle Image Velocimetry (PIV) experiments widely used in fluid mechanics. In DIC measurements, the surface displacement field is determined from a comparison of the grey intensity changes of the object surface before and after deformation.

As detailed in reference [START_REF] Hild | Digital image correlation: from displacement measurement to identification of elastic properties -a review[END_REF], various correlation algorithms can be implemented to determine the displacement field with progressive enrichment in mechanical information at the measurement stage. Field measurements are especially suitable in the case of heterogeneous mechanical measurements where spatial heterogeneities are not known a priori. In particular, they have been largely used in the field of fracture mechanics to investigate crack initiation and propagation. On the opposite, field measurements have only scarcely be applied to contact situations where spatial heterogeneities are also involved. One can mention a recent study by Scheibert et al 7, 8 , where DIC approaches have been developed to obtain spatially resolved information about the frictional behaviour at an interface between a glass lens and a rough rubber surface during the incipient stages of sliding.

In this paper, we address the issue of the determination of the local friction law from the inversion of the surface displacement field for a contact between a glass lens and a flat rubber substrate. The effect of large strains on the accuracy of the inversion is especially considered.

In the following, the experiments are briefly recalled. Two contact situations are considered:

(i) a classical linear sliding configuration where a glass lens is rubbed on the PDMS substrate, (ii) a less conventional torsional contact configuration where the glass lens is twisted. In a previous investigation 3 , we have established that torsional contacts are suitable for investigation of the failure of adhesion during stiction, i.e. incipient sliding stages. In the case of linear sliding, it is shown that, in order to obtain the surface shear stress field with a good accuracy, an hyperelastic model is to be used, as large deformations are involved in friction on rubber. The hyperelastic model is subsequently applied to the determination of the shear stress distribution during the stiction of twisting contacts.

Materials and friction experiments

A commercially available transparent poly(dimethylsiloxane) (PDMS) silicone (Sylgard 184, Dow Corning, Midland, MI) is used as an elastomer substrate. In order to monitor contact induced surface displacements, a square lattice of small cylindrical holes (diameter 8 μm, depth 11 μm) is produced on the PDMS surface by means of conventional micro-lithography techniques. Full details regarding the processing procedure are given in reference [START_REF] Chateauminois | Friction and shear fracture of an adhesive contact under torsion[END_REF]. Under transmitted light observation conditions, this pattern appears as a lattice of dark spots. Their positions are easily detected using image processing. For the purpose of linear and torsional friction experiments, two kinds of surface lattices are generated which differ in the center to center spacing of the holes (40 μm and 400 μm for torsional and linear sliding experiments, respectively). Before use, the PDMS specimens are thoroughly washed with isopropanol and subsequently dried under vacuum. Millimeter sized contacts are achieved between the PDMS substrates and plano-convex BK7 glass lenses (Melles Griott, France) with a radius of curvature of ranging from 5.2 to 14.8 mm. The r.m.s. roughness of the lenses is less than 2 nm, as measured by AFM.

Friction experiments are carried out using two home-made devices described in references [START_REF] Chateauminois | Friction and shear fracture of an adhesive contact under torsion[END_REF][START_REF] Chateauminois | Local friction at a sliding interface between an elastomer and a rigid spherical probe[END_REF]. Linear sliding experiments are performed under imposed normal load (between 1.3 N and 7.5 N) and velocity (between 0.01 and 1 mm s -1 ). The PDMS substrate is moved with respect to the fixed glass lens by means of a linear translation stage. Under steady state sliding, images of the deformed contact zone are continuously recorded through the transparent PDMS substrate using a zoom, a CCD camera and a frame grabber. This system is configured to a frame size of (1024x1024) pixels with frame rates ranging from 1 Hz to 10 Hz.

Contact torsion experiments are carried out under imposed normal displacement conditions (penetration depth δ=75±5 µm). During the experiments, the glass lens is rotated at imposed angular velocity (1 deg s -1 ) using a motorized rotation stage. Before twisting the lens, a contact dwell time of 10 minutes is systematically observed in order to allow for the development of adhesion. During torsion, images of the deformed contact zone are continuously recorded through the transparent PDMS substrate using the same optical equipment as for linear sliding experiments. In-plane displacement components u x and u y were determined from a measurement of the distortion of the surface holes lattice. Here y is the sliding axis and x is perpendicular. As detailed in reference [START_REF] Chateauminois | Local friction at a sliding interface between an elastomer and a rigid spherical probe[END_REF], image accumulation under steady state friction allows to generate a displacement field with a high signal to noise ratio and a considerably better spatial resolution (of the order of 7 μm) than the marker' spacing on the PDMS surface (400 μm). The distribution of the u y component reflects Poisson's effect: the PDMS surface is compressed along the sliding direction at the leading edge and stretched at the trailing edge.. In-plane strain components can be derived from the measured displacement field. In order to account for potential finite strains a deformation gradient tensor, F, is used which can be decomposed into the product of two second order tensors, R and V:

Results and discussion

Linear sliding

F =VR (1)
This decomposition relies on the fact that any transformation of an element from the undeformed to the deformed configuration may be obtained by first rotating by R the element and applying a subsequent stretch, V. The so-called left stretch tensor, V, was calculated from the measured in plane surface displacement components. In figure 2, the profile of the corresponding logarithmic strain along the sliding direction and on the symmetry axis is plotted for two experiments carried out using different lens radii and normal loads. As expected, compressive and tensile strains are achieved at the front edge and the leading edge of the contact, respectively. The important feature is that quite high strain values are achieved at the periphery of the contact. Strain as high as 0.4 can be induced, which falls well beyond the small strain hypothesis. In addition, these strain levels lie well within the non linear range of the mechanical response of the used PDMS, as indicated by conventional tensile experiments (see inset in figure 2).

At this stage, one may ask to what extent these non linear strains affect the accuracy of the inversion of the displacement field using a linear elastic approach such as the Green's tensor based procedure developed in reference [START_REF] Chateauminois | Local friction at a sliding interface between an elastomer and a rigid spherical probe[END_REF]. At first sight, one may argue that non linearities are confined to the periphery of the contact and that they should have only a limited impact on the determination of the shear stress distribution inside the contact zone. This issue was addressed by means of finite element (FE) simulations which are able to handle large strain calculations with neo-Hookean materials (details on the FE calculations are provided in the appendix). Using the FE method, a displacement field was simulated which corresponds to the application of a constant shear stress, τ 0 , on a circular disk (in the undeformed configuration) at the surface of a neo-Hookean body. Then, the calculated lateral surface displacement field was inverted using the Green's tensor, i.e. under the assumption of small strain behaviour.

When doing so, it emerges that the calculated shear stress distribution differs significantly from the constant shear distribution used to generate the displacement field (Figure 3). A clear dissymmetry is observed: shear stresses at the trailing edge are overestimated and, conversely, those at the leading edge are underestimated. Although localized at the periphery of the contact, large strains thus affect the whole contact response and the determination of shear stress inside the contact zone. One may consider that high strains at the edge of the contact result in the formation of an annular zone where the stiffness of the PDMS material is locally modified. As a result, the mechanical coupling between the external and inner parts of the contact is modified and the effects of large strain thus extend inside the contact zone.

These results of the FE analysis point out the need for a finite strain contact model in order to achieve a good accuracy in the determination of the frictional stress distribution from measured displacements. For that purpose, a FE inversion procedure of the displacement field was developed. The approach consists in prescribing the measured displacement field at the surface of a meshed FE body simulating the PDMS specimen and to retrieve the corresponding surface stress distribution under the assumption of large strain, neo-Hookean behaviour. Then, the local contact pressure and the frictional shear stress are calculated at every location within the contact zone from a projection of the components of the calculated surface stress tensor in a local Cartesian coordinate system. Its orientation is defined from the normal to the lens surface and from the actual sliding direction. As a consequence, the inversion procedure takes into account the contact geometry together with the measured sliding paths trajectories. In its spirit, this projection is similar to the flow line model developed by Lafaye et al 9 in the context of scratch experiments on polymer surfaces.

In a small strain situation, the inversion can be accurately carried out using only the in plane displacement components as it can be shown that the displacements induced by the normal and lateral loading components are fully decoupled in the case of an incompressible material 10

. This decoupling does not hold in the large strain regime and the FE inversion has therefore to be carried out using both vertical (u z ) and lateral (u x and u y ) surface displacements. Vertical displacements are not measured during sliding experiments, but they are prescribed within the contact zone by the known curvature of the lens and the unknown penetration depth, δ.

Interestingly, the later can be determined if some constraints are introduced regarding the normal stress distribution. Following some arguments by Savkoor 11, 12 , it can be assumed that sliding prevents adhesion to develop quasi-singular strains near the contact edge as it is the case for static contacts. Accordingly, one may expect that normal stress should vanish at the periphery of the frictional contact. Then, this hypothesis allows the penetration depth, δ, to be determined using an iterative procedure where the FE inversion of the displacement is carried out for a set of δ values until the calculated normal stress vanishes at the periphery of the contact. Figure 4 shows an example of the normal stress distributions along the y axis calculated for various indentation depths with the same measured lateral displacement field.

The normal stress is seen to vanish for an indentation depth which is close to the theoretical Hertzian value, δ=a 2 /R, where a is a typical value of the contact radius (the contact region is not perfectly circular) and R is the curvature radius of the slider. When the penetration depth is either decreased or increased from this value, a stress peak (either positive or negative) is calculated at the periphery of the contact. The later can be assimilated to the stress singularity induced by a flat punch displacement component. In that sense, it is equivalent to the flat punch term introduced in the JKR analysis to account for adhesion 13 . Interestingly, an

Hertzian value for the penetration depth was assumed by Savkoor in his description of the sliding contact.

question the accuracy of an inversion using a linear elastic analysis. Figure 9(II) shows the shear stress distribution obtained from the inversion of measured orthoradial displacement fields at various stages of the stiction process (radial displacements were found to be negligible). The inversion was carried out using FE hyperelastic calculations. In the friction zone, a nearly constant, pressure independent shear stress is achieved which is consistent with frictional behaviour under linear sliding. At the boundary between the stick and the slip zone, a stress overshoot is also retrieved which is indicative of the crack like nature of adhesive failure. These conclusions were already drawn using Green's tensor approach. This geometry appears particularly suitable for mode III crack propagation analysis. More detailed quantitative analysis of the experimental results is in progress.

Conclusions

A method for the determination of the local surface stresses in a sliding contact on rubber is presented. From the measurement of the surface displacement field, it is shown that FE calculation leads to a quantitative evaluation of both frictional shear stress and normal pressure. The high values of lateral strains which are measured for glass/rubber friction make it necessary to use of hyperelastic, finite deformation, calculations. This technique opens the way for a complete analysis of the local friction laws of rough contacts, which remains largely unexplored experimentally. It can also provide some insights into stiction processes of adhesive contacts. The usual route in the theoretical analysis of such a problem is to use a fracture mechanics approach where the boundary of the stick zone is assimilated to a crack.

The present analysis could help in identifying any interplay between normal pressure and mode II / mode III crack propagation at the periphery of this moving boundary between stick and slip zones. Figure 3: Normalized shear stress profiles obtained from the small strain inversion of a displacement field calculated by FEM in the case of a constant shear stress, τ 0 , applied over a circular region at the surface of a rubber substrate (see [START_REF] Chateauminois | Local friction at a sliding interface between an elastomer and a rigid spherical probe[END_REF] for details). FEM simulations were carried out under the assumption of (i) linear elasticity, case (a) and (ii) large strains and neo-Hookean behavior of the rubber, cases (b) τ 0 = 0.1 MPa, (c) τ 0 = 0.2 MPa and (d) τ 0 = 0.3 MPa. Shear stresses are normalized with respect to τ 0 . The dotted line corresponds to the prescribed shear stress profile. Deviations from this distribution point to the need to take into account large deformations and non linearity in the deconvolution procedure.

Figure 4

Contact pressure profiles along the y axis obtained from the FEM inversion of a surface displacement field using different assumptions regarding the value of the normal penetration depth, δ. Dotted line: δ=0.5 a 2 /R; plain line: δ= a 2 /R; thick line: δ= 1.5 a 2 /R, where R is the lens radius and a is a typical value of the contact radius (P=1.52 N, v=0.7 mm s -1 ).

Figure 5

Shear stress profiles along the sliding direction as obtained from FEM inversion of an experimental surface displacement field. Bold line: profile obtained using only the measured u x and u y components (u z =0). Plain line: profile obtained by specifying the three displacement components u x , u y and u z (P=1.52 N, R= 9.3 mm, v=0.7 mm s -1 ).

Figure 1

 1 Figure 1 shows an example of the surface displacement field under linear sliding condition.

Figure 1 :

 1 Figure 1: Measured surface displacement field for linear sliding. (a) displacement along the sliding direction u y , (b) displacement perpendicular to the sliding direction u x . Radius of the contact lens, R=9.3 mm, normal load, P=1.52 N, sliding velocity v=0.7 mm s -1 . The PDMS substrate is moved from bottom to top with respect to the fixed glass lens as indicated by the arrow.

Figure 2 :

 2 Figure 2: Profile of the logarithmic surface strain along the sliding direction and in the contact midplane for two different contact conditions. Thick line: R= 5.2 mm, P=1.67 N; plain line: R=9.3 mm, P=1.52 N (v=0.5 mm s -1 ). Inset: tensile behaviour of the PDMS rubber (crosshead speed: 0.08 mm s -1 ).

Figure 6 FE

 6 Figure6FE inversion of the surface displacement field within a sliding contact between a smooth glass sphere and a PDMS substrate (R=9.3 mm, P=1.52 N, v=0.7 mm s -1 ). (a) Distribution of the contact pressure and shear traction; (b) shear stress (bold line) and normal pressure (normal line) profiles across the contact zone and along the sliding direction.

Figure 7

 7 Figure 7 Surface shear stress profiles along the sliding direction for various sliding velocities. Dotted line: v=0.02 mm s -1 , plain line v= 0.1 mm s -1 , bold line: v=1 mm s -1 (P=1.52 N, R=9.3 mm).

Figure 8

 8 Figure 8 Contact pressure (a) and surface shear stress (b) profiles along the sliding direction for P=1.3 N (plain line) and P= 7.5 N (bold line). v=0.5 mm s -1 , R=9.33 mm.

Figure 9

 9 Figure 9 Inversion of the surface displacement field induced by the torsion of a glass lens. (I) Orthoradial displacement measured for various angles of twist, θ, during stiction. (II) Surface shear stress distribution obtained from the FEM inversion of the orthoradial displacement profiles. (a) θ=0.029 rad; (b) θ=0.087 rad; (c) θ=0.175 rad, (d) θ=0.262 rad, (e) θ=0.349 rad (angular displacement rate: 1 deg s -1 , R=14.8 mm).

Acknowledgements

Part of this work was supported by the National Research Agency (ANR) within the framework of the DYNALO project (project N° NT09_499845). We also acknowledge financial support from Saint Gobain Recherche, Aubervilliers, France. We are also indebted to A. Prevost, G. Debrégeas (Ecole Normale Supérieure, Paris) for stimulating discussions about this work.

The extent of coupling between normal and lateral contact components can be evaluated from a comparison of a set of two different inversions. The first one is carried out by prescribing the measured lateral displacement and u z =0. In the second one, the three displacement components are prescribed at the surface of the FE specimen. The results show (figure 5) that a distinct, although limited, coupling exists between the normal and lateral contact loading components.

The large strain inversion procedure was subsequently applied to the investigation of the normal load and sliding velocity dependence of the local shear stress at the interface between PDMS and the smooth glass lens. Within the investigated contact pressure and velocity range, shear stress distribution was systematically characterized by a dissymmetry between the front and the rear part of the contact: as shown in figure 6, shear stress in the rear part of the contact is slightly increased as compared to that in the front part. On the opposite, a much more limited dissymmetry is noted on the normal stress profile. This dissymmetry in the shear stress profile is enhanced when the sliding velocity is decreased (figure 7). This effect could tentatively be accounted for by some viscoelasticity within the PDMS substrate, even if linear viscoelastic measurements show almost perfect elastic response at room temperature for a loading frequency ν≈ v/2a, where v is the sliding velocity and a is the contact radius (tan δ = 0.04 at 25°C and 0.17 Hz). When the contact load is increased from 1.3 to 7.5 N (i.e. the mean contact pressure from 0.25 to 0.42 MPa), the shear stress distribution remains nearly unchanged (figure 8) which confirms previously reported results for a similar glass/PDMS contact 3, 4 . As a conclusion, the inversion of friction induced displacement field for a smooth glass/PDMS interface allows to identify a local friction law which is essentially independent on the contact pressure.

Torsional contacts

Surface displacement fields obtained under torsional contact conditions were detailed in a previous investigation. During the incipient stages of the frictional process, the stiction of the adhesive contact is associated with the progressive propagation of a slip annulus from the periphery of the contact This feature is shown in (Figure 9(I)) where the orthoradial displacements, u θ , is plotted as a function of the radial coordinate for various the twist angles.

During stiction (i.e. for twist angle less than less than about 0.35 rad), the partition of the contact zone in an inner adhesive zone (where u θ depends linearly on the radial coordinate, r) and an external micro-slip zone is clearly seen. Similarly to the linear sliding case, elevated shear strains (du θ /dr| r=a ≈ 0.4) are achieved at the vicinity of the contact edge which also

Appendix

A commercially available finite element code (Abaqus 6.9-EF1) is used for all the numerical contact simulations and the inversion of experimental displacement fields. The PDMS substrate was modeled as a parallelepiped with the size of the sample 60x30x15 mm 3 . Large strain simulations are carried out assuming a hyperelastic behaviour. Within the experimental strain range, tensile test showed that the behaviour of the PDMS material can be adequately described using a neo-Hookean's law. Accordingly, the later is used in the FEM simulations with the following two parameters: C10=0.45 MPa (i.e. half the shear modulus) and D1=0.001 MPa -1 (i.e. twice the compliance). In order to account for the quasiincompressibility of the material in the numerical analysis, linear hybrid quadrangular elements (C3D8RH) are used. The mesh was refined in the contact region where the surface element' size is 0.1x0.1x0.007 mm 3 . The dimensions of the elements were selected from a preliminary study of mesh's convergence. In the inversion procedure, experimental displacements are applied to surface' nodes within a restricted region with the size of the measurement field. Normal displacements are applied only to the nodes inside the contact zone. All the other nodes are free except those located on the bottom face of the PMDS model where the displacements are set to zero. The calculations are performed using a non linear static analysis.