Index: /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/Container/Observations.cpp
===================================================================
--- /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/Container/Observations.cpp	(revision 12230)
+++ /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/Container/Observations.cpp	(revision 12231)
@@ -112,12 +112,12 @@
 
 	if(nobs==0){
 		/*No observation found, double range*/
-		printf("No observation found within range, doubling range\n");
+		//printf("No observation found within range, doubling range\n");
 		xfree((void**)&indices);
 		this->ObservationList(&x,&y,&obs,&nobs,x_interp,y_interp,range*2);
 	}
 	else{
-		if(nobs>1000) printf("Taking more than 1000 observations\n");
+		//if(nobs>1000) printf("Taking more than 1000 observations\n");
 		/*Allocate vectors*/
 		x   = (double*)xmalloc(nobs*sizeof(double));
 		y   = (double*)xmalloc(nobs*sizeof(double));
Index: /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.cpp
===================================================================
--- /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.cpp	(revision 12230)
+++ /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.cpp	(revision 12231)
@@ -15,28 +15,25 @@
 #endif
 
 #include "../../objects/Kriging/GaussianVariogram.h"
+/*FUNCTION Krigingx{{{*/
 int Krigingx(double** ppredictions,double* obs_x, double* obs_y, double* obs_list, int obs_length,double* x_interp,double* y_interp,int n_interp,Options* options){
 
 	/*output*/
 	double *predictions = NULL;
 
 	/*Intermediaries*/
-	int           i,j,n_obs;
 	double        range;
-	double        numerator,denominator,ratio;
-	double       *x            = NULL;
-	double       *y            = NULL;
-	double       *obs          = NULL;
-	double       *Gamma        = NULL;
-	double       *GinvG0       = NULL;
-	double       *Ginv1        = NULL;
-	double       *GinvZ        = NULL;
-	double       *gamma0       = NULL;
-	double       *ones         = NULL;
 	char         *output       = NULL;
 	Variogram    *variogram    = NULL;
 	Observations *observations = NULL;
 
+	/*threading: */
+	KrigingxThreadStruct gate;
+	int num=1;
+#ifdef _MULTITHREADING_
+	num=_NUMTHREADS_;
+#endif
+
 	/*Get Variogram from Options*/
 	ProcessVariogram(&variogram,options);
 	options->Get(&range,"searchrange",0.);
@@ -44,29 +41,88 @@
 	/*Process observation dataset*/
 	observations=new Observations(obs_list,obs_x,obs_y,obs_length,options);
 
-	/*Allocation output*/
+	/*Allocate output*/
 	predictions =(double*)xmalloc(n_interp*sizeof(double));
-	for(i=0;i<n_interp;i++) predictions[i]=0;
+	for(int i=0;i<n_interp;i++) predictions[i]=0;
 
 	/*Get output*/
-	options->Get(&output,"output","quadtree");
+	options->Get(&output,"output","prediction");
 
 	if(strcmp(output,"quadtree")==0){
 		observations->QuadtreeColoring(predictions,x_interp,y_interp,n_interp);
-		*ppredictions=predictions;
-		return 1;
 	}
-	if(strcmp(output,"variomap")==0){
+	else if(strcmp(output,"variomap")==0){
 		observations->Variomap(predictions,x_interp,n_interp);
-		*ppredictions=predictions;
-		return 1;
 	}
+	else if(strcmp(output,"prediction")==0){
 
-	/*Loop over all interpolations*/
-	printf("      interpolation progress:  %5.2lf %%",0.0);
-	for(int idx=0;idx<n_interp;idx++){
-		if(idx%10==0) printf("\b\b\b\b\b\b\b%5.2lf %%",(double)idx/n_interp*100);
+		/*initialize thread parameters: */
+		gate.n_interp     = n_interp;
+		gate.x_interp     = x_interp;
+		gate.y_interp     = y_interp;
+		gate.range        = range;
+		gate.variogram    = variogram;
+		gate.observations = observations;
+		gate.predictions     = predictions;
 
+		/*launch the thread manager with Krigingxt as a core: */
+		LaunchThread(Krigingxt,(void*)&gate,num);
+	}
+	else{
+		_error_("output '%s' not supported yet",output);
+	}
+
+	/*clean-up and Assign output pointer*/
+	delete variogram;
+	delete observations;
+	xfree((void**)&output);
+	*ppredictions=predictions;
+	return 1;
+}/*}}}*/
+/*FUNCTION Krigingxt{{{*/
+void* Krigingxt(void* vpthread_handle){
+
+	/*gate variables :*/
+	KrigingxThreadStruct *gate        = NULL;
+	pthread_handle       *handle      = NULL;
+	int my_thread;
+	int num_threads;
+	int i0,i1;
+
+	/*recover handle and gate: */
+	handle      = (pthread_handle*)vpthread_handle;
+	gate        = (KrigingxThreadStruct*)handle->gate;
+	my_thread   = handle->id;
+	num_threads = handle->num;
+
+	/*recover parameters :*/
+	int           n_interp     = gate->n_interp;
+	double       *x_interp     = gate->x_interp;
+	double       *y_interp     = gate->y_interp;
+	double        range        = gate->range;
+	Variogram    *variogram    = gate->variogram;
+	Observations *observations = gate->observations;
+	double       *predictions  = gate->predictions;
+
+	/*Intermediaries*/
+	int           i,j,n_obs;
+	double        numerator,denominator,ratio;
+	double       *x            = NULL;
+	double       *y            = NULL;
+	double       *obs          = NULL;
+	double       *Gamma        = NULL;
+	double       *GinvG0       = NULL;
+	double       *Ginv1        = NULL;
+	double       *GinvZ        = NULL;
+	double       *gamma0       = NULL;
+	double       *ones         = NULL;
+
+	/*partition loop across threads: */
+	if(my_thread==0) printf("      interpolation progress:  %5.2lf %%",0.0);
+	PartitionRange(&i0,&i1,n_interp,num_threads,my_thread);
+	for(int idx=i0;idx<i1;idx++){
+		if(my_thread==0 && idx%10==0) printf("\b\b\b\b\b\b\b%5.2lf %%",double(idx-i0)/double(i1-i0)*100);
+
 		/*Get list of observations for current point*/
 		observations->ObservationList(&x,&y,&obs,&n_obs,x_interp[idx],y_interp[idx],range);
 
@@ -88,9 +144,9 @@
 		for(i=0;i<n_obs;i++) gamma0[i] = variogram->SemiVariogram(x[i]-x_interp[idx],y[i]-y_interp[idx]);
 
 		/*Solve the three linear systems*/
-		GslSolve(&GinvG0,Gamma,gamma0,n_obs);       // Gamma^-1 gamma0
-		GslSolve(&Ginv1, Gamma,ones,n_obs);         // Gamma^-1 ones
-		GslSolve(&GinvZ, Gamma,obs,n_obs); // Gamma^-1 Z
+		GslSolve(&GinvG0,Gamma,gamma0,n_obs); // Gamma^-1 gamma0
+		GslSolve(&Ginv1, Gamma,ones,n_obs);   // Gamma^-1 ones
+		GslSolve(&GinvZ, Gamma,obs,n_obs);    // Gamma^-1 Z
 
 		/*Prepare predictor*/
 		numerator=-1.; denominator=0.;
@@ -112,15 +168,10 @@
 		xfree((void**)&Ginv1);
 		xfree((void**)&GinvZ);
 	}
-	printf("\b\b\b\b\b\b\b\b%5.2lf %%\n",100.0);
+	if(my_thread==0) printf("\b\b\b\b\b\b\b\b%5.2lf %%\n",100.0);
 
-	/*clean-up and Assign output pointer*/
-	delete variogram;
-	delete observations;
-	xfree((void**)&output);
-	*ppredictions=predictions;
-	return 1;
-}
+	return NULL;
+}/*}}}*/
 
 void ProcessVariogram(Variogram **pvariogram,Options* options){/*{{{*/
 
Index: /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.h
===================================================================
--- /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.h	(revision 12230)
+++ /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Krigingx/Krigingx.h	(revision 12231)
@@ -8,8 +8,23 @@
 #include "../../objects/objects.h"
 #include "../../toolkits/toolkits.h"
 
+class Observations;
+class Variogram;
+
 int  Krigingx(double** ppredictions,double* x, double* y, double* observations, int n_obs,double* x_interp,double* y_interp,int n_interp,Options* options);
 void ProcessVariogram(Variogram **pvariogram,Options* options);
 void GslSolve(double** pX,double* A,double* B,int n);
 
+/*threading: */
+typedef struct{
+	int           n_interp;
+	double       *x_interp;
+	double       *y_interp;
+	double        range;
+	Variogram    *variogram;
+	Observations *observations;
+	double       *predictions;
+}KrigingxThreadStruct;
+
+void* Krigingxt(void*);
 #endif /* _KRIGINGX_H */
Index: /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Shp2Kmlx/Shp2Kmlx.h
===================================================================
--- /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Shp2Kmlx/Shp2Kmlx.h	(revision 12230)
+++ /proj/ice/larour/issm-uci-clean/trunk-jpl/src/c/modules/Shp2Kmlx/Shp2Kmlx.h	(revision 12231)
@@ -21,9 +21,7 @@
 #include "../../objects/objects.h"
 
 /* local prototypes: */
-int Shp2Kmlx(char* filshp,char* filkml,
-			 int sgn);
-int Shp2Kmlx(char* filshp,char* filkml,
-			 int sgn,double cm,double sp);
+int Shp2Kmlx(char* filshp,char* filkml, int sgn);
+int Shp2Kmlx(char* filshp,char* filkml, int sgn,double cm,double sp);
 
 #endif  /* _SHP2KMLX_H */