From f4fec8584a0738224ee00564ce215bf343a8f618 Mon Sep 17 00:00:00 2001
From: Fabio Roberto Vitello <fabio.vitello@inaf.it>
Date: Wed, 17 Jul 2019 11:02:03 +0200
Subject: [PATCH] Base Version of CoreApp with MPI+openMP

---
 GaiaGsrParSim        |  Bin 318454 -> 0 bytes
 Makefile             |   80 +-
 Makefile.marconi_new |   38 -
 Makefile_marconi     |   81 -
 a                    |    1 -
 aprod.c              | 1118 ++++------
 lsqr.c               | 2511 +++++++++++-----------
 memRequest.c         |    0
 run_ppl.cmd          |   28 +
 solvergaiaSim.c      | 4769 +++++++++++++++++++-----------------------
 util.c               |    0
 util.h               |    1 -
 12 files changed, 3860 insertions(+), 4767 deletions(-)
 delete mode 100755 GaiaGsrParSim
 delete mode 100644 Makefile.marconi_new
 delete mode 100644 Makefile_marconi
 delete mode 100644 a
 mode change 100644 => 100755 memRequest.c
 create mode 100755 run_ppl.cmd
 mode change 100644 => 100755 util.c
 mode change 100644 => 100755 util.h

diff --git a/GaiaGsrParSim b/GaiaGsrParSim
deleted file mode 100755
index 0a6cb5c6896514f89dbcac26744e306710081b61..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 318454
zcmcG%4`5W)l|Mc(gQgmNgN>S6tW*1J$ATCQ)zqPNA`^WBZzO8e;6@XiBn>q{nhca$
zglH0FoIJ?3?6<Z{chi2^@6vwR!gtH=qNQXK0tE0+0;1uM8c}ct{1ZV<KqbG==e+mA
zBa&|S``zEbd-t7l?>+b5x#ygF?tL#y3-sH^jv3>!e`8(WcM-~&6cm(sce&Qg^9ama
z(3R)P!2K%M1lM_h#|e%xj0>I>CN0u-m?5z)mm8r_9BU!Q2F(X6oM1vI!Ti}ZWXST)
z{DRh_8FmKDdfK7O<&${kV_jWAs~y2|!Mm)m{#p}kz1Ixwe5@Yx_1$jf>$}~|XNNwk
z{&r}$kEwZ0u;M3-4FVz@WZ(+P{Y=QT{1qOKmGe26X<~wzW=cC;$&SO%4()t*A)mC*
zjQ&sWc0I4Jp7ZccQ?9Qrzpi@DyakJ{Ta<UxbvI3!TsMF6jZ%LvD6#MExYO(yyFV@g
zj%8=zVwD*G&sTi*+Xp+wzWi^yN~fQG@}Jh<_s7(~H6ZS9aeW2XOkB)!JuVfOAJ=ub
ztR}glc(#9!;-L!H;}+t32p8d6f~(ZRF}N7l9S-<@JkP^bZ{f-ie$#q>(h6_2!WmXr
zV1+BJun^(RxQZ?K0faxnH4B#y7k|rf<>Gpn0Df^?30#f1!nm4oJ%+0q*LQJE!^K~o
z8DRdL{ksd`k1f=<5I%wHDhp;%hif{n5?o)!6~px)t{^V{ev0cyxHvw}AN$|HH3!$z
zxTfM#aM`~WJWR&*LtK+A<ZV`{TOosca4o|%k%0AEY=xI1e9C&(5MG9>5?48{g}C^;
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

diff --git a/Makefile b/Makefile
index 60a1e38..aeaed93 100644
--- a/Makefile
+++ b/Makefile
@@ -1,89 +1,39 @@
 # Gaia GSRPar Makefile
 
-COMPILER = /opt/ompss/bin/mcc
-##COMPILER = /opt/openmpi_icc/bin/mpic++ 
-COMPILERCPP =  /opt/ompss/bin/mcxx --ompss -DOMP
-##COMPILERCPP =  /opt/openmpi_icc/bin/mpic++ 
+COMPILER = mpiicpc  -qopenmp -DOMP
+COMPILERCPP = mpiicpc -qopenmp -DOMP
 
-CC = $(COMPILERCPP)
+CC = $(COMPILER)
 CPP= $(COMPILERCPP)
 
 
-CFITSIOLIB=/opt/cfitsio3_1_0/lib
+CFITSIOLIB=/opt/cluster/cfitsio/intel/2017.1/lib/ 
 
+GAIAINC=/u/ubecciani/EuroExa/CoreApp7.2/src
 
-
-
-GAIAINC=/home-volume/ube/Gaia/ParallelCodeV7/src7.2
-
-
-
-GAIAGSR= aprod.o  lsqrblas.o  lsqr.o  solvergaia.o util.o  
 GAIAGSRSIM= aprod.o  lsqrblas.o  lsqr.o  solvergaiaSim.o util.o  
-GAIAGSRFits2Bin= fits2bin.o   util.o lsqrblas.o 
-GAIAGSRBin2Fits= bin2fits.o 
-GAIAGSRBin2Reduced= bin2reduced.o util.o lsqrblas.o 
-GAIAGSRCkEmptyCols= util.o ckemptycols.o lsqrblas.o 
-GAIAGSRBin2Asc=   bin2asc.o  
-GAIAGSRChTask= changeTask.o
-GAIAGSRRepairTask= ripristino.o
 MEMREQ= memRequest.o  
 
 
-
-INCLUDE = -I$(GAIAINC) -I/opt/local/include -I/opt/openmpi_icc/include/ -I/opt/cfitsio3_1_0/include/ -I/opt/openmpi/include -pthread
+##INCLUDE = -I$(GAIAINC) -I/opt/local/include -I/opt/local/include/mpich2  -I/opt/cluster/cfitsio/intel/2017.1/include/
+INCLUDE = -I$(GAIAINC)   -I/opt/cluster/cfitsio/intel/2017.1/include/
 #INCLUDE = -I$(GAIAINC) 
 #CFLAGS= $(INCLUDE)  -std=c99 
-CPPFLAGS= $(INCLUDE)   -g -fsanitize=address -mllvm -asan-stack
-CPPFLAGS= $(INCLUDE)    
-LIB = 	-pthread -L/usr/local/pbspro/lib -Wl,-rpath -Wl,/usr/local/pbspro/lib -Wl,-rpath -Wl,/opt/openmpi/lib -Wl,--enable-new-dtags -L/opt/openmpi/lib -lmpi	 -L$(CFITSIOLIB) -lcfitsio -lm
+#CPPFLAGS= $(INCLUDE) -g -fsanitize=address -mllvm -asan-stack
+#CPPFLAGS= $(INCLUDE)  -lirc -limf -lsvml
+CPPFLAGS= $(INCLUDE)  
+LIB = -L$(CFITSIOLIB) -lcfitsio -lm
 
-all:	GaiaGsrParSim
 
-####all: GaiaGsrPar MemReq GaiaGsrParSim GaiaFits2Bin GaiaBin2Fits GaiaBin2Reduced GaiaCkEmptyCols GaiaBin2Asc   GaiaChTask GaiaRepTask
+all:	MemReq GaiaGsrParSim
 ###all: GaiaGsrPar MemReq GaiaGsrParTest GaiaFits2Bin GaiaBin2Fits GaiaBin2Reduced 
 
-ckemptycols.o: ckemptycols.cpp
-	$(CPP) $(CPPFLAGS)  -c ckemptycols.cpp
-	
-bin2fits.o: bin2fits.cpp
-	$(CPP) $(CPPFLAGS)  -c bin2fits.cpp
-
-bin2asc.o: bin2asc.cpp
-	$(CPP) $(CPPFLAGS)  -c bin2asc.cpp
-
-
-
-GaiaGsrPar: $(GAIAGSR)
-	$(CPP) $(CPPFLAGS) -o GaiaGsrPar $(GAIAGSR) $(INCLUDE) $(LIB)
-
-MemReq: $(MEMREQ)
-	$(CPP) $(CPPFLAGS) -o MemReq $(MEMREQ) $(INCLUDE) $(LIB)
-
 GaiaGsrParSim: $(GAIAGSRSIM)
 	$(CPP) $(CPPFLAGS) -o GaiaGsrParSim $(GAIAGSRSIM) $(INCLUDE) $(LIB)
 
-GaiaFits2Bin: $(GAIAGSRFits2Bin)
-	$(CPP) $(CPPFLAGS) -o GaiaFits2Bin $(GAIAGSRFits2Bin) $(INCLUDE) $(LIB)
-
-GaiaBin2Fits: $(GAIAGSRBin2Fits)
-	$(CPP) $(CPPFLAGS) -o GaiaBin2Fits $(GAIAGSRBin2Fits) $(INCLUDE) $(LIB)
-	
-GaiaBin2Reduced: $(GAIAGSRBin2Reduced)
-	$(CPP) $(CPPFLAGS) -o GaiaBin2Reduced $(GAIAGSRBin2Reduced) $(INCLUDE) $(LIB)
-
-GaiaBin2Asc: $(GAIAGSRBin2Asc)
-	$(CPP) $(CPPFLAGS) -o GaiaBin2Asc $(GAIAGSRBin2Asc) $(INCLUDE) $(LIB)
-
-	
-GaiaCkEmptyCols: $(GAIAGSRCkEmptyCols)
-	$(CPP) $(CPPFLAGS) -o GaiaCkEmptyCols $(GAIAGSRCkEmptyCols)   $(LIB)
-
-GaiaChTask: $(GAIAGSRChTask)
-	$(CPP)  -o GaiaChTask $(GAIAGSRChTask)   $(LIB)
+MemReq: $(MEMREQ)
+	$(CPP) $(CPPFLAGS) -o MemReq $(MEMREQ) $(INCLUDE) $(LIB)
 
-GaiaRepTask: $(GAIAGSRRepairTask)
-	$(CPP) $(CPPFLAGS) -o GaiaRepairTask $(GAIAGSRRepairTask)   $(LIB)
-	
 clean:
 	rm -f *.o core
+
diff --git a/Makefile.marconi_new b/Makefile.marconi_new
deleted file mode 100644
index d5ce443..0000000
--- a/Makefile.marconi_new
+++ /dev/null
@@ -1,38 +0,0 @@
-# Gaia GSRPar Makefile
-
-COMPILER = mpiicpc  -qopenmp -DOMP
-COMPILERCPP = mpiicpc -qopenmp -DOMP
-
-CC = $(COMPILER)
-CPP= $(COMPILERCPP)
-
-CFITSIOLIB=$(CFITSIO_LIB)
-
-GAIAINC=.
-
-GAIAGSRSIM= aprod.o  lsqrblas.o  lsqr.o  solvergaiaSim.o util.o  
-MEMREQ= memRequest.o  
-
-
-##INCLUDE = -I$(GAIAINC) -I/opt/local/include -I/opt/local/include/mpich2  -I/opt/cluster/cfitsio/intel/2017.1/include/
-INCLUDE = -I$(GAIAINC) -I$(CFITSIO_INC)
-#INCLUDE = -I$(GAIAINC) 
-#CFLAGS= $(INCLUDE)  -std=c99 
-#CPPFLAGS= $(INCLUDE) -g -fsanitize=address -mllvm -asan-stack
-#CPPFLAGS= $(INCLUDE)  -lirc -limf -lsvml
-CPPFLAGS= $(INCLUDE) -DOMP= 
-LIB = -L$(CFITSIOLIB) -lcfitsio -lm
-
-
-all:	GaiaGsrParSim
-###all: GaiaGsrPar MemReq GaiaGsrParTest GaiaFits2Bin GaiaBin2Fits GaiaBin2Reduced 
-
-GaiaGsrParSim: $(GAIAGSRSIM)
-	$(CPP) $(CPPFLAGS) -o GaiaGsrParSim $(GAIAGSRSIM) $(INCLUDE) $(LIB)
-
-MemReq: $(MEMREQ)
-	$(CPP) $(CPPFLAGS) -o MemReq $(MEMREQ) $(INCLUDE) $(LIB)
-
-clean:
-	rm -f *.o core
-
diff --git a/Makefile_marconi b/Makefile_marconi
deleted file mode 100644
index 9e08b9f..0000000
--- a/Makefile_marconi
+++ /dev/null
@@ -1,81 +0,0 @@
-# Gaia GSRPar Makefile
-
-##COMPILER = mpiicpc  -g -traceback -O3 -qopenmp 
-##COMPILERCPP = mpiicpc -g -traceback -O3 -qopenmp  
-COMPILER = mpiicpc   -O3 -qopenmp 
-COMPILERCPP = mpiicpc  -O3 -qopenmp  
-
-CC = $(COMPILER)  
-CPP = $(COMPILERCPP)   
-
-
-# CFITSIOLIB=/opt/cfitsio/lib
-#CFITSIOLIB=/cineca/prod/opt/libraries/cfitsio/3.390/intel--pe-xe-2016--binary/lib/
-CFITSIOLIB=$(CFITSIO_LIB)
-
-GAIAINC=.
-
-
-GAIAGSR= aprod.o  lsqrblas.o  lsqr.o  solvergaia.o util.o  
-GAIAGSRSIM= aprod.o  lsqrblas.o  lsqr.o  solvergaiaSim.o util.o  
-GAIAGSRFits2Bin= fits2bin.o   util.o lsqrblas.o
-GAIAGSRBin2Fits= bin2fits.o 
-GAIAGSRBin2Reduced= bin2reduced.o util.o lsqrblas.o
-GAIAGSRCkEmptyCols= util.o ckemptycols.o  lsqrblas.o
-GAIAGSRBin2Asc=   bin2asc.o 
-GAIAGSRChTask= changeTask.o
-GAIAGSRRepairTask= ripristino.o
-MEMREQ= memRequest.o  
-
-
-# INCLUDE = -I$(GAIAINC) -I/opt/cfitsio/include
-#INCLUDE = -I$(GAIAINC) -I/cineca/prod/opt/libraries/cfitsio/3.390/intel--pe-xe-2016--binary/include/
-INCLUDE = -I$(GAIAINC) -I$(CFITSIO_INC)
-CPPFLAGS= $(INCLUDE)  -DOMP=
-LIB = -L$(CFITSIOLIB) -lcfitsio -lm
-
-all: GaiaGsrPar MemReq GaiaGsrParSim GaiaFits2Bin GaiaBin2Fits GaiaBin2Reduced GaiaCkEmptyCols GaiaBin2Asc GaiaChTask GaiaRepTask
-###all: GaiaGsrPar MemReq GaiaGsrParTest GaiaFits2Bin GaiaBin2Fits GaiaBin2Reduced 
-
-ckemptycols.o: ckemptycols.cpp
-	$(CPP) $(CPPFLAGS)  -c ckemptycols.cpp
-	
-bin2fits.o: bin2fits.cpp
-	$(CPP) $(CPPFLAGS)  -c bin2fits.cpp
-
-bin2asc.o: bin2asc.cpp
-	$(CPP) $(CPPFLAGS)  -c bin2asc.cpp
-
-GaiaGsrPar: $(GAIAGSR)
-	$(CPP) -o GaiaGsrPar $(GAIAGSR) $(INCLUDE) $(LIB)
-
-MemReq: $(MEMREQ)
-	$(CPP) -o MemReq $(MEMREQ) $(INCLUDE) $(LIB)
-
-GaiaGsrParSim: $(GAIAGSRSIM)
-	$(CPP) -o GaiaGsrParSim $(GAIAGSRSIM) $(INCLUDE) $(LIB)
-
-GaiaFits2Bin: $(GAIAGSRFits2Bin)
-	$(CPP) -o GaiaFits2Bin $(GAIAGSRFits2Bin) $(INCLUDE) $(LIB)
-
-GaiaBin2Fits: $(GAIAGSRBin2Fits)
-	$(CPP) -o GaiaBin2Fits $(GAIAGSRBin2Fits) $(INCLUDE) $(LIB)
-	
-GaiaBin2Reduced: $(GAIAGSRBin2Reduced)
-	$(CPP) -o GaiaBin2Reduced $(GAIAGSRBin2Reduced) $(INCLUDE) $(LIB)
-
-GaiaBin2Asc: $(GAIAGSRBin2Asc)
-	$(CPP) -o GaiaBin2Asc $(GAIAGSRBin2Asc) $(INCLUDE) $(LIB)
-
-GaiaChTask: $(GAIAGSRChTask)
-	$(CPP)  -o GaiaChTask $(GAIAGSRChTask)   $(LIB)
-
-GaiaCkEmptyCols: $(GAIAGSRCkEmptyCols)
-	$(CPP) -o GaiaCkEmptyCols $(GAIAGSRCkEmptyCols)   $(LIB)
-
-GaiaRepTask: $(GAIAGSRRepairTask)
-	$(CPP) $(CPPFLAGS) -o GaiaRepairTask $(GAIAGSRRepairTask)   $(LIB)
-	
-clean:
-	rm -f *.o core
-
diff --git a/a b/a
deleted file mode 100644
index 8243688..0000000
--- a/a
+++ /dev/null
@@ -1 +0,0 @@
-scp *.c *.cpp *.h ubecciani@ssh.hca.bsc.es:/home/ubecciani/AVU-GSR/OMP/src/
diff --git a/aprod.c b/aprod.c
index fa389f8..1e1507b 100644
--- a/aprod.c
+++ b/aprod.c
@@ -7,724 +7,458 @@
 //#include "pardef.h"
 #include "util.h"
 void aprod(int mode, long int m, long int n, double *vVect, double *knownTerms,
-           double *systemMatrix, long int *matrixIndex, int *instrCol, int *instrConstrIlung, struct comData comlsqr, time_t *ompSec)
+                              double *systemMatrix,long int *matrixIndex, int *instrCol,int *instrConstrIlung, struct comData comlsqr,time_t *ompSec)
 {
-    // Parallel definitions
-    int myid, nproc;
+// Parallel definitions
+    int myid,nproc;
     long int *mapNoss, *mapNcoeff;
-    int nthreads, tid, ntasks;
-    long **mapForThread;
-    ///    struct comData *comlsqr;
-    //
+	int nthreads, tid;
+	long **mapForThread;
+///    struct comData *comlsqr;
+//
 
-    FILE *fk, *fk0;
+	FILE *fk,*fk0;
 
-    double zero = 0.0;
-    double sum, yi;
-    long int l1, l2;
-    long int i, i1;
-    long int l, j, k;
-    int i2 = 0, j2 = 0, j3 = 0, na = 0;
+  	double zero=0.0;
+  	double sum, yi;
+  	long int l1,l2;
+  	long int i, i1; 
+  	long int l, j, k;
+  	int i2=0,j2=0,j3=0,na=0;
     int setBound[4];
+  
+  	double localSum;
+    short nAstroPSolved=comlsqr.nAstroPSolved;
 
-    double localSum;
-    short nAstroPSolved = comlsqr.nAstroPSolved;
-
-    long localAstro = comlsqr.VrIdAstroPDim * nAstroPSolved;
-    long localAstroMax = comlsqr.VrIdAstroPDimMax * nAstroPSolved;
-    //  Initialize.
-    myid = comlsqr.myid;
-    nproc = comlsqr.nproc;
-    mapNcoeff = comlsqr.mapNcoeff;
-    mapNoss = comlsqr.mapNoss;
-    nthreads = comlsqr.nthreads;
-    ntasks= comlsqr.ntasks;
+    long localAstro= comlsqr.VrIdAstroPDim*nAstroPSolved;
+  	long localAstroMax=comlsqr.VrIdAstroPDimMax*nAstroPSolved;  
+//  Initialize.
+myid=comlsqr.myid;
+nproc=comlsqr.nproc;
+mapNcoeff=comlsqr.mapNcoeff;
+mapNoss=comlsqr.mapNoss;
+nthreads=comlsqr.nthreads;
+mapForThread=comlsqr.mapForThread;
+int multMI=comlsqr.multMI;
+long nparam=comlsqr.parOss;
+short nAttAxes=comlsqr.nAttAxes;
+int numOfExtStar=comlsqr.numOfExtStar;
+int numOfBarStar=comlsqr.numOfBarStar;
+int numOfExtAttCol=comlsqr.numOfExtAttCol;
+long VrIdAstroPDimMax=comlsqr.VrIdAstroPDimMax;
+int startingAttColExtConstr=comlsqr.startingAttColExtConstr;
+int nOfElextObs=comlsqr.nOfElextObs;
+int nEqExtConstr=comlsqr.nEqExtConstr;
+int nOfElBarObs=comlsqr.nOfElBarObs;
+int nEqBarConstr=comlsqr.nEqBarConstr;
+int debugMode=comlsqr.debugMode;
+short nInstrPSolved=comlsqr.nInstrPSolved;
+int nOfInstrConstr=comlsqr.nOfInstrConstr;
+int nElemIC=comlsqr.nElemIC;
+short nAttP=comlsqr.nAttP;
+short nGlobP=comlsqr.nGlobP;
+    
+setBound[0]=comlsqr.setBound[0];
+    setBound[1]=comlsqr.setBound[1];
+    setBound[2]=comlsqr.setBound[2];
+    setBound[3]=comlsqr.setBound[3];
+    long nDegFreedomAtt=comlsqr.nDegFreedomAtt;
+    short nAttParAxis=comlsqr.nAttParAxis;
+    long offsetAttParam=comlsqr.offsetAttParam;
+    long offsetInstrParam=comlsqr.offsetInstrParam;
+    long offsetGlobParam=comlsqr.offsetGlobParam;
+    
+nthreads=1; 
+tid=0;
+    FILE *fp1,*fp2;
+//        fp1=fopen("test1_aprod","w");
+//        fp2=fopen("test2_aprod","w");
     
-    mapForThread = comlsqr.mapForThread;
-    int multMI = comlsqr.multMI;
-    long nparam = comlsqr.parOss;
-    short nAttAxes = comlsqr.nAttAxes;
-    int numOfExtStar = comlsqr.numOfExtStar;
-    int numOfBarStar = comlsqr.numOfBarStar;
-    int numOfExtAttCol = comlsqr.numOfExtAttCol;
-    long VrIdAstroPDimMax = comlsqr.VrIdAstroPDimMax;
-    int startingAttColExtConstr = comlsqr.startingAttColExtConstr;
-    int nOfElextObs = comlsqr.nOfElextObs;
-    int nEqExtConstr = comlsqr.nEqExtConstr;
-    int nOfElBarObs = comlsqr.nOfElBarObs;
-    int nEqBarConstr = comlsqr.nEqBarConstr;
-    int debugMode = comlsqr.debugMode;
-    short nInstrPSolved = comlsqr.nInstrPSolved;
-    int nOfInstrConstr = comlsqr.nOfInstrConstr;
-    int nElemIC = comlsqr.nElemIC;
-    short nAttP = comlsqr.nAttP;
-    short nGlobP = comlsqr.nGlobP;
-
-    setBound[0] = comlsqr.setBound[0];
-    setBound[1] = comlsqr.setBound[1];
-    setBound[2] = comlsqr.setBound[2];
-    setBound[3] = comlsqr.setBound[3];
-    long nDegFreedomAtt = comlsqr.nDegFreedomAtt;
-    short nAttParAxis = comlsqr.nAttParAxis;
-    long offsetAttParam = comlsqr.offsetAttParam;
-    long offsetInstrParam = comlsqr.offsetInstrParam;
-    long offsetGlobParam = comlsqr.offsetGlobParam;
 
-    //nthreads = 1;
-    tid = 0;
-    FILE *fp1, *fp2;
-    //        fp1=fopen("test1_aprod","w");
-    //        fp2=fopen("test2_aprod","w");
 
-    if (mode != 1 && mode != 2)
-    {
-        printf("ERROR: Invalid mode=%d in aprod function\n", mode);
-        exit(1);
-    }
-    l1 = 0;
-    l2 = 0;
-    myid = comlsqr.myid;
-    if (mode == 1)
+if(mode!=1 && mode !=2)
+{
+	printf("ERROR: Invalid mode=%d in aprod function\n",mode);
+	exit(1);
+}
+l1=0;
+l2=0;
+myid=comlsqr.myid;
+if(mode==1)
+{
+    time_t startTime=time(NULL);
+#pragma omp parallel private(myid, sum,  k, l1, l2, l, j,tid,nthreads,i2,na) shared(mapNoss,instrCol,comlsqr,vVect,systemMatrix,matrixIndex,knownTerms,j2)
     {
-        time_t startTime = time(NULL);
-////        #pragma omp parallel private(myid, sum, k, l1, l2, l, j, tid, nthreads, i2, na) shared(mapNoss, instrCol, comlsqr, vVect, systemMatrix, matrixIndex, knownTerms, j2)
+        myid=comlsqr.myid;
+        if(comlsqr.itn==1)
         {
-            myid = comlsqr.myid;
-            /*
-            //FV_ EDIT ompSs
-            if (comlsqr.itn == 1)
-            {
-                #ifdef OMP
-                tid = omp_get_thread_num();
-                nthreads = omp_get_num_threads();
-                #endif
-            }*/
-            if (comlsqr.itn == 1 && debugMode)
-                printf("PE=%d Aprod1 OpenMP num of threads =%d from thread =%d icycle=%ld  comlsqr.itn=%d\n", myid, nthreads, tid, i, comlsqr.itn);
-            long miValAstro = 0;
-            long miValAtt = 0;
-            long jstartAtt = 0;
-            long jstartAstro = 0;
-            long lset = 0;
-            long offLocalAstro = 0;
-            long offLocalAtt = 0;
-            long offLocalInstr = 0; //Offset on Instruments
-            long ixInstr = 0;
-            int nInstrVal = 0;
-            offLocalInstr = offsetInstrParam + (localAstroMax - offsetAttParam); //Offset on Instruments
-            nInstrVal = nAstroPSolved + nAttP;
-            offLocalAstro = comlsqr.mapStar[myid][0] * nAstroPSolved;               //Offset on my mstars
-            offLocalAtt = localAstroMax - offsetAttParam;                           //Offset on attitude
-            long offLocalGlob = offsetGlobParam + (localAstroMax - offsetAttParam); //Offset on GlobP
-            int nGlobVal = nAstroPSolved + nAttP + nInstrPSolved;
-            jstartAstro = miValAstro - offLocalAstro;
-
-            //FV_ EDIT ompSs
-          
-            
-            for(int nt=0; nt < ntasks; nt++ )
-            {
-                #pragma omp task //shared(matrixIndex,mapForThread,vVect,systemMatrix,knownTerms) in(nt,multMI,offLocalAstro, lset)
-                {
-                    for (long ix = mapForThread[nt][0]; ix < mapForThread[nt][2]; ix++)
-                    {
-                        sum = 0.;
-                        /////////////////////////////////////////////////////
-                        /// Mode 1 Astrometric Sect
-                        if (nAstroPSolved)
-                        {
-
-                            lset = ix * nparam;
-                            if (matrixIndex[multMI * ix] != miValAstro)
-                            {
-                                miValAstro = matrixIndex[multMI * ix];
-                                jstartAstro = miValAstro - offLocalAstro;
-                            }
-                            for (long jx = jstartAstro; jx < jstartAstro + nAstroPSolved; jx++)
-                            {
-                                sum = sum + systemMatrix[lset] * vVect[jx];
-                                lset++;
-                            }
-                        }
-                        //////////////////////////////////////////////////////
-                        /// Mode 1 Attitude Sect
-                        if (nAttP)
-                        {
-                            lset = ix * nparam + nAstroPSolved;
-                            miValAtt = matrixIndex[multMI * ix + (multMI - 1)];
-                            for (int nax = 0; nax < nAttAxes; nax++)
-                            {
-                                jstartAtt = miValAtt + offLocalAtt + nax * nDegFreedomAtt;
-                                for (long inpax = jstartAtt; inpax < jstartAtt + nAttParAxis; inpax++)
-                                {
-                                    sum = sum + systemMatrix[lset] * vVect[inpax];
-                                    lset++;
-                                }
-                            }
-                        }
-                        //////////////////////////////////////////////////////
-                        /// Mode 1 Instrument Sect
-                        if (nInstrPSolved)
-                        {
-
-                            lset = ix * nparam + nInstrVal;
-                            long iiVal = ix * nInstrPSolved;
-                            for (int inInstr = 0; inInstr < nInstrPSolved; inInstr++)
-                            {
-                                ixInstr = offLocalInstr + instrCol[iiVal + inInstr];
-                                sum = sum + systemMatrix[lset] * vVect[ixInstr];
-                                lset++;
-                            }
-                        }
-                        //////////////////////////////////////////////////////
-                        /// Mode 1 Global sect
-                        if (nGlobP)
-                        {
-                            lset = ix * nparam + nGlobVal;
-                            for (long inGlob = offLocalGlob; inGlob < offLocalGlob + nGlobP; inGlob++)
-                            {
-                                sum = sum + systemMatrix[lset] * vVect[inGlob];
-                                lset++;
-                            }
-                        }
-                        //////////////////////////////////////////////////////
-                        knownTerms[ix] += sum;
-                    } //for ix
-                }
-                #pragma omp taskwait
-
-            }
-
-            
-            
-            
-            
-            
-            
-            /*
-            //#pragma omp for
-            for (long ix = 0; ix < mapNoss[myid]; ix++)
-            {
-                sum = 0.;
-                /////////////////////////////////////////////////////
-                /// Mode 1 Astrometric Sect
-                if (nAstroPSolved)
-                {
-
-                    lset = ix * nparam;
-                    if (matrixIndex[multMI * ix] != miValAstro)
-                    {
-                        miValAstro = matrixIndex[multMI * ix];
-                        jstartAstro = miValAstro - offLocalAstro;
-                    }
-                    for (long jx = jstartAstro; jx < jstartAstro + nAstroPSolved; jx++)
-                    {
-                        sum = sum + systemMatrix[lset] * vVect[jx];
-                        lset++;
-                    }
-                }
-                //////////////////////////////////////////////////////
-                /// Mode 1 Attitude Sect
-                if (nAttP)
-                {
-                    lset = ix * nparam + nAstroPSolved;
-                    miValAtt = matrixIndex[multMI * ix + (multMI - 1)];
-                    for (int nax = 0; nax < nAttAxes; nax++)
-                    {
-                        jstartAtt = miValAtt + offLocalAtt + nax * nDegFreedomAtt;
-                        for (long inpax = jstartAtt; inpax < jstartAtt + nAttParAxis; inpax++)
-                        {
-                            sum = sum + systemMatrix[lset] * vVect[inpax];
-                            lset++;
-                        }
-                    }
-                }
-                //////////////////////////////////////////////////////
-                /// Mode 1 Instrument Sect
-                if (nInstrPSolved)
-                {
+#ifdef OMP
+            tid = omp_get_thread_num();
+            nthreads = omp_get_num_threads();
+#endif
+        }
+        if(comlsqr.itn==1 && debugMode)
+            printf("PE=%d Aprod1 OpenMP num of threads =%d from thread =%d icycle=%ld  comlsqr.itn=%d\n",myid, nthreads,tid,i,comlsqr.itn);
+    long miValAstro=0;
+    long miValAtt=0;
+    long jstartAtt=0;
+    long jstartAstro=0;
+    long lset=0;
+        long offLocalAstro=0;
+        long offLocalAtt=0;
+        long offLocalInstr=0; //Offset on Instruments
+        long ixInstr=0;
+        int nInstrVal=0;
+        offLocalInstr=offsetInstrParam+(localAstroMax-offsetAttParam); //Offset on Instruments
+        nInstrVal=nAstroPSolved+nAttP;
+        offLocalAstro=comlsqr.mapStar[myid][0]*nAstroPSolved; //Offset on my mstars
+        offLocalAtt=localAstroMax-offsetAttParam; //Offset on attitude
+        long offLocalGlob=offsetGlobParam+(localAstroMax-offsetAttParam); //Offset on GlobP
+        int nGlobVal=nAstroPSolved+nAttP+nInstrPSolved;
+        jstartAstro=miValAstro-offLocalAstro;
 
-                    lset = ix * nparam + nInstrVal;
-                    long iiVal = ix * nInstrPSolved;
-                    for (int inInstr = 0; inInstr < nInstrPSolved; inInstr++)
-                    {
-                        ixInstr = offLocalInstr + instrCol[iiVal + inInstr];
-                        sum = sum + systemMatrix[lset] * vVect[ixInstr];
-                        lset++;
-                    }
-                }
-                //////////////////////////////////////////////////////
-                /// Mode 1 Global sect
-                if (nGlobP)
-                {
-                    lset = ix * nparam + nGlobVal;
-                    for (long inGlob = offLocalGlob; inGlob < offLocalGlob + nGlobP; inGlob++)
-                    {
-                        sum = sum + systemMatrix[lset] * vVect[inGlob];
-                        lset++;
-                    }
-                }
-                //////////////////////////////////////////////////////
-                knownTerms[ix] += sum;
-            } //for ix
-            */
-            
-         
-            
-            
-            /// Mode 1 ExtConstr
-            if (nEqExtConstr)
-            {
-                long offExtAtt;
-                long offExtAttConstr = VrIdAstroPDimMax * nAstroPSolved + startingAttColExtConstr;
-                long vVIx;
-                long ktIx = mapNoss[myid];
-                long offExtConstr;
-                for (int iexc = 0; iexc < nEqExtConstr; iexc++)
-                {
-                    sum = 0.0;
-                    offExtConstr = mapNcoeff[myid] + iexc * nOfElextObs;
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (int j3 = 0; j3 < numOfExtStar * nAstroPSolved; j3++)
-                        sum += systemMatrix[offExtConstr + j3] * vVect[j3];
 
-                    for (int nax = 0; nax < nAttAxes; nax++)
-                    {
-                        offExtAtt = offExtConstr + numOfExtStar * nAstroPSolved + nax * numOfExtAttCol;
-                        vVIx = offExtAttConstr + nax * nDegFreedomAtt;
-                        //FV_ EDIT ompSs
-                        //#pragma omp for
-                        for (int j3 = 0; j3 < numOfExtAttCol; j3++)
-                            sum += systemMatrix[offExtAtt + j3] * vVect[vVIx + j3];
-                    }
-                    //FV_ EDIT ompSs
-                    //#pragma omp atomic
-                    knownTerms[ktIx + iexc] += sum;
-                } //for iexc
-            }
-            //////////////////////////////////////////////////////
-            /// Mode 1 BarConstr
-            if (nEqBarConstr)
-            {
-                long offBarConstr = mapNcoeff[myid] + nOfElextObs * nEqExtConstr;
-                long offBarConstrIx;
-                long ktIx = mapNoss[myid] + nEqExtConstr;
-                for (int iexc = 0; iexc < nEqBarConstr; iexc++)
-                {
-                    sum = 0.0;
-                    offBarConstrIx = offBarConstr + iexc * nOfElBarObs;
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (int j3 = 0; j3 < numOfBarStar * nAstroPSolved; j3++)
-                        sum += systemMatrix[offBarConstrIx + j3] * vVect[j3];
-                    //FV_ EDIT ompSs
-                    //#pragma omp atomic
-                    knownTerms[ktIx + iexc] += sum;
-                } //for iexc
-            }
-            //////////////////////////////////////////////////////
-            /// Mode 1 InstrConstr
-            if (nOfInstrConstr)
+#pragma omp for
+    for(long ix=0;ix<mapNoss[myid];ix++){
+        sum=0.;
+/////////////////////////////////////////////////////
+/// Mode 1 Astrometric Sect
+if (nAstroPSolved){
+    
+    lset=ix*nparam;
+        if(matrixIndex[multMI*ix]!= miValAstro){
+            miValAstro=matrixIndex[multMI*ix];
+            jstartAstro=miValAstro-offLocalAstro;
+        }
+        for(long jx=jstartAstro;jx<jstartAstro+nAstroPSolved;jx++){
+            sum=sum+systemMatrix[lset]*vVect[jx];
+            lset++;
+        }
+}
+//////////////////////////////////////////////////////
+/// Mode 1 Attitude Sect
+if (nAttP){
+    
+        lset=ix*nparam+nAstroPSolved;
+        miValAtt=matrixIndex[multMI*ix+(multMI-1)];
+        for(int nax=0;nax<nAttAxes;nax++){
+            jstartAtt=miValAtt+offLocalAtt+nax*nDegFreedomAtt;
+            for(long inpax=jstartAtt;inpax<jstartAtt+nAttParAxis;inpax++)
             {
-                long offSetInstr = 0;
-                long offSetInstrInc = 0;
-                long offSetInstrInc1 = 0;
-                long vVix = 0;
-                long offvV = 0;
-                long offSetInstrConstr = mapNcoeff[myid] + nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr;
-                long offSetInstrConstr1 = VrIdAstroPDimMax * nAstroPSolved + nDegFreedomAtt * nAttAxes;
-                long ktIx = mapNoss[myid] + nEqExtConstr + nEqBarConstr;
-                for (int i1 = myid; i1 < nOfInstrConstr; i1 = i1 + nproc)
-                {
-                    sum = 0.0;
-                    offSetInstrInc = offSetInstrConstr;
-                    offSetInstr = 0;
-                    for (int m = 0; m < i1; m++)
-                    {
-                        offSetInstrInc += instrConstrIlung[m];
-                        offSetInstr += instrConstrIlung[m];
-                    }
-                    offvV = mapNoss[myid] * nInstrPSolved + offSetInstr;
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (int j3 = 0; j3 < instrConstrIlung[i1]; j3++)
-                    {
-                        vVix = instrCol[offvV + j3];
-                        sum += systemMatrix[offSetInstrInc + j3] * vVect[offSetInstrConstr1 + vVix];
-                    }
-                    //FV_ EDIT ompSs
-                    //#pragma omp atomic
-                    knownTerms[ktIx + i1] += sum;
-                }
+                sum=sum+systemMatrix[lset]*vVect[inpax];
+                lset++;
             }
-            //////////////////////////////////////////////////////
-        } //pragma
-        *ompSec += time(NULL) - startTime;
-        if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-            printf("PE=%d AprodTiming: mode=1  OmpSec=%ld\n", myid, time(NULL) - startTime);
-    }
-    else //mode==2
-    {    //if(mode
-        time_t startTime = time(NULL);
-        //FV_ EDIT ompSs
-        //  #pragma omp parallel private(myid, yi, sum, k, l1, l2, l, j, localSum, i, tid, nthreads) shared(mapNoss, instrCol, comlsqr, vVect, systemMatrix, matrixIndex, knownTerms)
-        {
-            int count = 0;
-            myid = comlsqr.myid;
-           //qui lavorare
-           /*
-            #ifdef OMP
-            tid = omp_get_thread_num();
-            nthreads = omp_get_num_threads();
-            #endif
-            */
-            /////////////////////////////////////////////////////
-            /// Mode 2 Astrometric Sect
-            if (nAstroPSolved)
-            {
-                long offLocalAstro = comlsqr.mapStar[myid][0] * nAstroPSolved;
-//                for (long ix = mapForThread[tid][0]; ix < mapForThread[tid][2]; ix++)
-                long lset;
-                
-                for(int nt=0; nt < ntasks; nt++ )
-                {
-                    
-                   lset = mapForThread[nt][0] * nparam;
-
-                    #pragma omp task shared(matrixIndex,mapForThread,vVect) in(nt,multMI,offLocalAstro, lset)
-                    {
-                        double taskLocalSum;
-                        long jstartAstro = 0;
+        }
+}
+//////////////////////////////////////////////////////
+/// Mode 1 Instrument Sect
+if (nInstrPSolved){
 
-                        for (long ix = mapForThread[nt][0]; ix < mapForThread[nt][2]; ix++)
-                        {
-                            
-                            long miValAstro = 0;
-                            if (matrixIndex[multMI * ix] != miValAstro)
-                            {
-                                miValAstro = matrixIndex[multMI * ix];
-                                jstartAstro = miValAstro - offLocalAstro;
-                            }
-                            for (long jx = jstartAstro; jx < jstartAstro + nAstroPSolved; jx++)
-                            {
-                                taskLocalSum = systemMatrix[lset] * knownTerms[ix];
-                                vVect[jx] += taskLocalSum;
-                                lset++;
-                            } //for jx
-                            lset += nparam - nAstroPSolved;
-                        } //for ix 
-                    }
-                    #pragma omp taskwait
+        lset=ix*nparam+nInstrVal;
+        long iiVal=ix*nInstrPSolved;
+        for(int inInstr=0;inInstr<nInstrPSolved;inInstr++){
+            ixInstr=offLocalInstr+instrCol[iiVal+inInstr];
+            sum=sum+systemMatrix[lset]*vVect[ixInstr];
+            lset++;
+        }
+}
+//////////////////////////////////////////////////////
+/// Mode 1 Global sect
+if (nGlobP){
+        lset=ix*nparam+nGlobVal;
+        for(long inGlob=offLocalGlob;inGlob<offLocalGlob+nGlobP;inGlob++){
+            sum=sum+systemMatrix[lset]*vVect[inGlob];
+            lset++;
+        }
+}
+//////////////////////////////////////////////////////
+        knownTerms[ix]+=sum;
 
-                }
+} //for ix
+/// Mode 1 ExtConstr
+if(nEqExtConstr){
+    long offExtAtt;
+    long offExtAttConstr=VrIdAstroPDimMax*nAstroPSolved+startingAttColExtConstr;
+    long vVIx;
+    long ktIx=mapNoss[myid];
+    long offExtConstr;
+    for(int iexc=0;iexc<nEqExtConstr;iexc++ ){
+        sum=0.0;
+        offExtConstr=mapNcoeff[myid]+iexc*nOfElextObs;
+#pragma omp for
+        for(int j3=0;j3<numOfExtStar*nAstroPSolved;j3++)
+            sum+=systemMatrix[offExtConstr+j3]*vVect[j3];
                 
-                /*
-                for (long ix = 0; ix < comlsqr.mapNoss[myid]; ix++)
-                {
-                    long miValAstro = 0;
-                    if (matrixIndex[multMI * ix] != miValAstro)
-                    {
-                        miValAstro = matrixIndex[multMI * ix];
-                        jstartAstro = miValAstro - offLocalAstro;
-                    }
-                    for (long jx = jstartAstro; jx < jstartAstro + nAstroPSolved; jx++)
-                    {
-                        localSum = systemMatrix[lset] * knownTerms[ix];
-                        vVect[jx] += localSum;
-                        lset++;
-                    } //for jx
-                    lset += nparam - nAstroPSolved;
-                } //for ix
-                
-                */
+        for(int nax=0;nax<nAttAxes;nax++){
+            offExtAtt=offExtConstr+numOfExtStar*nAstroPSolved+nax*numOfExtAttCol;
+            vVIx=offExtAttConstr+nax*nDegFreedomAtt;
+#pragma omp for
+            for(int j3=0;j3<numOfExtAttCol;j3++)
+                sum+=systemMatrix[offExtAtt+j3]*vVect[vVIx+j3];
             }
-            /////////////////////////////////////////////////////
-        } //pragma
+#pragma omp atomic
+        knownTerms[ktIx+iexc]+=sum;
+    }//for iexc
+}
+//////////////////////////////////////////////////////
+/// Mode 1 BarConstr
+if(nEqBarConstr){
+    long offBarConstr=mapNcoeff[myid]+nOfElextObs*nEqExtConstr;
+    long offBarConstrIx;
+    long ktIx=mapNoss[myid]+nEqExtConstr;
+    for(int iexc=0;iexc<nEqBarConstr;iexc++ ){
+        sum=0.0;
+        offBarConstrIx=offBarConstr+iexc*nOfElBarObs;
+#pragma omp for
+        for(int j3=0;j3<numOfBarStar*nAstroPSolved;j3++)
+            sum+=systemMatrix[offBarConstrIx+j3]*vVect[j3];
+#pragma omp atomic
+        knownTerms[ktIx+iexc]+=sum;
+    }//for iexc
+}
+//////////////////////////////////////////////////////
+/// Mode 1 InstrConstr
+if(nOfInstrConstr){
+    long offSetInstr=0;
+    long offSetInstrInc=0;
+    long offSetInstrInc1=0;
+    long vVix=0;
+    long offvV=0;
+    long offSetInstrConstr=mapNcoeff[myid]+nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr;
+    long offSetInstrConstr1=VrIdAstroPDimMax*nAstroPSolved+nDegFreedomAtt*nAttAxes;
+    long ktIx=mapNoss[myid]+nEqExtConstr+nEqBarConstr;
+    for(int i1=myid;i1<nOfInstrConstr;i1=i1+nproc){
+        sum=0.0;
+        offSetInstrInc=offSetInstrConstr;
+        offSetInstr=0;
+        for(int m=0;m<i1;m++){
+            offSetInstrInc+=instrConstrIlung[m];
+            offSetInstr+=instrConstrIlung[m];
+        }
+        offvV=mapNoss[myid]*nInstrPSolved+offSetInstr;
+#pragma omp for
+        for(int j3=0;j3<instrConstrIlung[i1];j3++){
+            vVix=instrCol[offvV+j3];
+            sum+=systemMatrix[offSetInstrInc+j3]*vVect[offSetInstrConstr1+vVix];
+        }
+#pragma omp atomic
+         knownTerms[ktIx+i1]+=sum;
+    }
+}
+//////////////////////////////////////////////////////
+}//pragma
+*ompSec+=time(NULL)-startTime;
+if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1)) printf("PE=%d AprodTiming: mode=1  OmpSec=%ld\n",myid,time(NULL)-startTime);
+ }
+else  //mode==2
+{  //if(mode
+time_t startTime=time(NULL);
+#pragma omp parallel private(myid,yi, sum, k, l1, l2, l, j,localSum,i,tid,nthreads) shared(mapNoss,instrCol,comlsqr,vVect,systemMatrix,matrixIndex,knownTerms)
+{
+int count=0;
+myid=comlsqr.myid;
+#ifdef OMP
+	tid = omp_get_thread_num();
+    nthreads = omp_get_num_threads();
+#endif
+/////////////////////////////////////////////////////
+/// Mode 2 Astrometric Sect
+if (nAstroPSolved){
+    long offLocalAstro=comlsqr.mapStar[myid][0]*nAstroPSolved;
+    long jstartAstro=0;
+    long lset=mapForThread[tid][0]*nparam;
+    for(long ix=mapForThread[tid][0];ix<mapForThread[tid][2];ix++){
+        long miValAstro=0;
+        if(matrixIndex[multMI*ix]!= miValAstro){
+            miValAstro=matrixIndex[multMI*ix];
+            jstartAstro=miValAstro-offLocalAstro;
+        }
+        for(long jx=jstartAstro;jx<jstartAstro+nAstroPSolved;jx++){
+            localSum=systemMatrix[lset]*knownTerms[ix];
+            vVect[jx]+=localSum;
+            lset++;
+        }//for jx
+        lset+=nparam-nAstroPSolved;
+    }//for ix
+}
+/////////////////////////////////////////////////////
+} //pragma
+if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1) )printf("PE=%d AprodTiming: mode=2.1.AstroP  OmpSec=%ld\n",myid,time(NULL)-startTime);
 
-        /////////////////////////////////////////////////////
-        /// Mode 2 Attitude Sect
-        if (nAttP)
-        {
-           
-            long mix;
-            long offj = (localAstroMax - offsetAttParam);
-            long vVix;
-           
-            
-            for(int nt=0; nt < ntasks; nt++ )
-            {
-                long lset;
-               // #pragma omp task shared(nparam,nInstrPSolved,matrixIndex) in (nt) commutative(vVect)
-                #pragma omp task commutative(vVect)
-                {
-                    for (long ix = mapForThread[nt][0]; ix < mapForThread[nt][2]; ix++)
-                    {
-                        lset = nparam * ix + nAstroPSolved;
-                        mix = matrixIndex[multMI * ix + (multMI - 1)] + offj;
-                        for (int ly = 0; ly < nAttAxes; ly++)
-                        {
-                            vVix = mix + ly * nDegFreedomAtt;
-                            
-                            for (int lx = 0; lx < nAttParAxis; lx++)
-                            {
-                                localSum = systemMatrix[lset] * knownTerms[ix];
-                                ///#pragma omp atomic
-                                vVect[vVix] += localSum;
-                                lset++;
-                                vVix++;
-                            } //for lx
-                        }     //for ly
-                    } //for ix
-                }
-                #pragma omp taskwait
+/////////////////////////////////////////////////////
+/// Mode 2 Attitude Sect
+if (nAttP){
+    long lset;
+    long mix;
+    long offj=(localAstroMax-offsetAttParam);
+    long vVix;
+///#pragma omp for
+    for(long ix=0;ix<mapNoss[myid];ix++){
+        lset=nparam*ix+nAstroPSolved;
+        mix=matrixIndex[multMI*ix+(multMI-1)]+offj;
+        for(int ly=0;ly<nAttAxes;ly++){
+            vVix=mix+ly*nDegFreedomAtt;
+            for(int lx=0;lx<nAttParAxis;lx++){
+                localSum=systemMatrix[lset]*knownTerms[ix];
+///#pragma omp atomic
+                vVect[vVix]+=localSum;
+                lset++;
+                vVix++;
+            }//for lx
+        } //for ly
+    }//for ix
+}
+    if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1) )printf("PE=%d AprodTiming: mode=2.1.AttP  OmpSec=%ld\n",myid,time(NULL)-startTime);
+
+/////////////////////////////////////////////////////
+/// Mode 2 Instrument Sect
+if(nOfInstrConstr){
+    long lset;
+    int offLset=nAstroPSolved+nAttP;
+    long iix;
+    long offj=offsetInstrParam+(localAstroMax-offsetAttParam);
+    long vVix;
+///#pragma omp for
+    for(long ix=0;ix<mapNoss[myid];ix++){
+        lset=nparam*ix+offLset;
+        iix=ix*nInstrPSolved;
+        for(int ly=0;ly<nInstrPSolved;ly++){
+            vVix=offj+instrCol[iix+ly];
+            localSum=systemMatrix[lset]*knownTerms[ix];
+///#pragma omp atomic
+            vVect[vVix]+=localSum;
+            lset++;
+        }//for ly
+    }//for ix
+}
+if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1) )printf("PE=%d AprodTiming: mode=2.1.InstrP  OmpSec=%ld\n",myid,time(NULL)-startTime);
 
+/////////////////////////////////////////////////////
+///} //pragma
+*ompSec+=time(NULL)-startTime;
+if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1) )printf("PE=%d AprodTiming: mode=2.1  OmpSec=%ld\n",myid,time(NULL)-startTime);
+/////////////////////////////////////////////////////
+/// Mode 2 Global Sect
+if(nGlobP){
+    long lset;
+    int offLset=nAstroPSolved+nAttP+nInstrPSolved;
+    long offj=offsetGlobParam+(localAstroMax-offsetAttParam);
+    long vVix;
+    for(long ix=0;ix<mapNoss[myid];ix++){
+        lset=nparam*ix+offLset;
+        for(long ly=0;ly<nGlobP;ly++){
+            vVix=offj+ly;
+            localSum=systemMatrix[lset]*knownTerms[ix];
+            vVect[vVix]+=localSum;
+            lset++;
+        }//for ly
+    }//for ix
+}
+////////////////////////////////////////////////////
+    startTime=time(NULL);
+    
+#pragma omp parallel private(myid,yi,localSum,tid,nthreads,i2,j2,na) shared(mapNoss,vVect,systemMatrix,knownTerms,k,j3)
+{
+myid=comlsqr.myid;
+#ifdef OMP
+    tid = omp_get_thread_num();
+    nthreads = omp_get_num_threads();
+#endif
+    localSum=0.0;
+//////////////////////////////////////////////////////
+/// Mode 2 ExtConstr
+if(nEqExtConstr){
+    long offExtStarConstrEq;
+    long off2;
+    long off3;
+    for(int ix=0;ix<nEqExtConstr;ix++ ){  //stars
+        yi=knownTerms[mapNoss[myid]+ix];
+        offExtStarConstrEq=mapNcoeff[myid]+ix*nOfElextObs;//Star offset on the row ix (all the row)
+#pragma omp for
+        for(long yx=0;yx<numOfExtStar;yx++){
+            off3=yx*nAstroPSolved;
+            off2=offExtStarConstrEq+off3;
+            for(int j2=0;j2<nAstroPSolved;j2++){
+                localSum= systemMatrix[off2+j2]*yi;
+                vVect[j2+off3]+=localSum;
             }
-            
-            
-            /*
-            ///#pragma omp for
-            for (long ix = 0; ix < mapNoss[myid]; ix++)
-            {
-                lset = nparam * ix + nAstroPSolved;
-                mix = matrixIndex[multMI * ix + (multMI - 1)] + offj;
-                for (int ly = 0; ly < nAttAxes; ly++)
-                {
-                    vVix = mix + ly * nDegFreedomAtt;
-                    for (int lx = 0; lx < nAttParAxis; lx++)
-                    {
-                        localSum = systemMatrix[lset] * knownTerms[ix];
-                        ///#pragma omp atomic
-                        vVect[vVix] += localSum;
-                        lset++;
-                        vVix++;
-                    } //for lx
-                }     //for ly
-            }         //for ix
-            
-            */
         }
-        /////////////////////////////////////////////////////
-        /// Mode 2 Instrument Sect
-        if (nOfInstrConstr)
-        {
-          
-            int offLset = nAstroPSolved + nAttP;
-            long iix;
-            long offj = offsetInstrParam + (localAstroMax - offsetAttParam);
-            long vVix;
-            
-            for(int nt=0; nt < ntasks; nt++ )
-            {
-               // #pragma omp task shared(vVect,nparam,offLset,nInstrPSolved) in (nt)
-                #pragma omp task commutative(vVect)
-                {
-                    long lset;
-                    for (long ix = mapForThread[nt][0]; ix < mapForThread[nt][2]; ix++)
-                    {
-                        lset = nparam * ix + offLset;
-                        iix = ix * nInstrPSolved;
-                        for (int ly = 0; ly < nInstrPSolved; ly++)
-                        {
-                            vVix = offj + instrCol[iix + ly];
-                            localSum = systemMatrix[lset] * knownTerms[ix];
-                            ///#pragma omp atomic
-                            vVect[vVix] += localSum;
-                            lset++;
-                        } //for ly
-                    }     //for ix
-                }
-                #pragma omp taskwait
+#pragma omp barrier
+    } //for ix
+    
+    long offExtAttConstrEq;
+    long offExtUnk;
+    long off1=VrIdAstroPDimMax*nAstroPSolved+startingAttColExtConstr;
+    for(int ix=0;ix<nEqExtConstr;ix++ ){  //att
+        yi=knownTerms[mapNoss[myid]+ix];
+        offExtAttConstrEq=mapNcoeff[myid]+ix*nOfElextObs; //Att offset on the row ix (all the row)
+        offExtAttConstrEq+=numOfExtStar*nAstroPSolved; //Att offset inside ix row
+        for(int nax=0;nax<nAttAxes;nax++){
+            offExtUnk=off1+nax*nDegFreedomAtt;// Att offset for Unk array on extConstr
+            off2=offExtAttConstrEq+nax*numOfExtAttCol;
+#pragma omp for
+            for(int jx=0;jx<numOfExtAttCol;jx++){
+                localSum= systemMatrix[off2+jx]*yi;
+                vVect[offExtUnk+jx]+=localSum;
             }
-            /*
-            ///#pragma omp for
-            for (long ix = 0; ix < mapNoss[myid]; ix++)
-            {
-                lset = nparam * ix + offLset;
-                iix = ix * nInstrPSolved;
-                for (int ly = 0; ly < nInstrPSolved; ly++)
-                {
-                    vVix = offj + instrCol[iix + ly];
-                    localSum = systemMatrix[lset] * knownTerms[ix];
-                    ///#pragma omp atomic
-                    vVect[vVix] += localSum;
-                    lset++;
-                } //for ly
-            }     //for ix
-           
-            */
-        }
-        /////////////////////////////////////////////////////
-        ///} //pragma
-        *ompSec += time(NULL) - startTime;
-        if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-            printf("PE=%d AprodTiming: mode=2.1  OmpSec=%ld\n", myid, time(NULL) - startTime);
-        /////////////////////////////////////////////////////
-        /// Mode 2 Global Sect
-        if (nGlobP)
-        {
-            time_t startTime_nGlobP = time(NULL);
-            long lset;
-            int offLset = nAstroPSolved + nAttP + nInstrPSolved;
-            long offj = offsetGlobParam + (localAstroMax - offsetAttParam);
-            long vVix;
-            for (long ix = 0; ix < mapNoss[myid]; ix++)
-            {
-                lset = nparam * ix + offLset;
-                for (long ly = 0; ly < nGlobP; ly++)
-                {
-                    vVix = offj + ly;
-                    localSum = systemMatrix[lset] * knownTerms[ix];
-                    vVect[vVix] += localSum;
-                    lset++;
-                } //for ly
-            }     //for ix
-        
-            if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-                printf("\tPE=%d AprodTiming: nGlobP  sec=%ld\n", myid, time(NULL) - startTime_nGlobP);
+#pragma omp barrier
         }
-        ////////////////////////////////////////////////////
-        startTime = time(NULL);
-        //FV_ EDIT ompSs
-        //  #pragma omp parallel private(myid, yi, localSum, tid, nthreads, i2, j2, na) shared(mapNoss, vVect, systemMatrix, knownTerms, k, j3)
-        {
-            myid = comlsqr.myid;
-            //FV_ EDIT ompSs
-/*
-            //#ifdef OMP
-            tid = omp_get_thread_num();
-            nthreads = omp_get_num_threads();
-            #endif
-*/
-            localSum = 0.0;
-            //////////////////////////////////////////////////////
-            /// Mode 2 ExtConstr
-            if (nEqExtConstr)
-            {
-                time_t startTime_nEqExtConstr = time(NULL);
-                long offExtStarConstrEq;
-                long off2;
-                long off3;
-                for (int ix = 0; ix < nEqExtConstr; ix++)
-                { //stars
-                    yi = knownTerms[mapNoss[myid] + ix];
-                    offExtStarConstrEq = mapNcoeff[myid] + ix * nOfElextObs; //Star offset on the row ix (all the row)
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (long yx = 0; yx < numOfExtStar; yx++)
-                    {
-                        off3 = yx * nAstroPSolved;
-                        off2 = offExtStarConstrEq + off3;
-                        for (int j2 = 0; j2 < nAstroPSolved; j2++)
-                        {
-                            localSum = systemMatrix[off2 + j2] * yi;
-                            vVect[j2 + off3] += localSum;
-                        }
-                    }
-                    //FV_ EDIT ompSs
-                    //#pragma omp barrier
-                } //for ix
-
-                long offExtAttConstrEq;
-                long offExtUnk;
-                long off1 = VrIdAstroPDimMax * nAstroPSolved + startingAttColExtConstr;
-                for (int ix = 0; ix < nEqExtConstr; ix++)
-                { //att
-                    yi = knownTerms[mapNoss[myid] + ix];
-                    offExtAttConstrEq = mapNcoeff[myid] + ix * nOfElextObs; //Att offset on the row ix (all the row)
-                    offExtAttConstrEq += numOfExtStar * nAstroPSolved;      //Att offset inside ix row
-                    for (int nax = 0; nax < nAttAxes; nax++)
-                    {
-                        offExtUnk = off1 + nax * nDegFreedomAtt; // Att offset for Unk array on extConstr
-                        off2 = offExtAttConstrEq + nax * numOfExtAttCol;
-                        //FV_ EDIT ompSs
-                        //#pragma omp for
-                        for (int jx = 0; jx < numOfExtAttCol; jx++)
-                        {
-                            localSum = systemMatrix[off2 + jx] * yi;
-                            vVect[offExtUnk + jx] += localSum;
-                        }
-                        //FV_ EDIT ompSs
-                        //#pragma omp barrier
-                    }
-                }
-                if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-                    printf("\tPE=%d AprodTiming: nEqExtConstr  sec=%ld\n", myid, time(NULL) - startTime_nEqExtConstr);
-            }
-            //////////////////////////////////////////////////////
-            /// Mode 2 BarConstr
-            if (nEqBarConstr)
-            {
-                time_t startTime_nEqBarConstr = time(NULL);
-                localSum = 0.0;
-                long off3;
-                long off2;
-                for (int ix = 0; ix < nEqBarConstr; ix++)
-                { //stars
-                    yi = knownTerms[mapNoss[myid] + nEqExtConstr + ix];
-                    long offBarStarConstrEq = mapNcoeff[myid] + nEqExtConstr * nOfElextObs + ix * nOfElBarObs; //Star offset on the row i2 (all the row)
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (long yx = 0; yx < numOfBarStar; yx++)
-                    {
-                        off3 = yx * nAstroPSolved;
-                        off2 = offBarStarConstrEq + off3;
-                        for (int j2 = 0; j2 < nAstroPSolved; j2++)
-                        {
-                            localSum = systemMatrix[off2 + j2] * yi;
-                            vVect[j2 + off3] += localSum;
-                        }
-                    }
-                    //FV_ EDIT ompSs
-                    //#pragma omp barrier
-                } //for i2
-        
-                if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-                    printf("\tPE=%d AprodTiming: nEqBarConstr  sec=%ld\n", myid, time(NULL) - startTime_nEqBarConstr);
-
+    }
+}
+//////////////////////////////////////////////////////
+/// Mode 2 BarConstr
+if(nEqBarConstr){
+    localSum=0.0;
+    long off3;
+    long off2;
+    for(int ix=0;ix<nEqBarConstr;ix++ ){  //stars
+        yi=knownTerms[mapNoss[myid]+nEqExtConstr+ix];
+        long offBarStarConstrEq=mapNcoeff[myid]+nEqExtConstr*nOfElextObs+ix*nOfElBarObs;//Star offset on the row i2 (all the row)
+#pragma omp for
+        for(long yx=0;yx<numOfBarStar;yx++){
+            off3=yx*nAstroPSolved;
+            off2=offBarStarConstrEq+off3;
+            for(int j2=0;j2<nAstroPSolved;j2++){
+                localSum= systemMatrix[off2+j2]*yi;
+                vVect[j2+off3]+=localSum;
             }
-            //////////////////////////////////////////////////////
-            /// Mode 2 InstrConstr
-            if (nOfInstrConstr)
-            {
-                time_t startTime_nOfInstrConstr = time(NULL);
-
-                localSum = 0.0;
-                int offSetInstr;
-                long off1;
-                long offInstrUnk = VrIdAstroPDimMax * nAstroPSolved + nAttAxes * nDegFreedomAtt;
-                long off2 = mapNoss[myid] + nEqExtConstr + nEqBarConstr;
-                long off3 = mapNcoeff[myid] + nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr;
-                long off4 = mapNoss[myid] * nInstrPSolved;
-                long off5;
-                long off6;
-                for (int k1 = myid; k1 < nOfInstrConstr; k1 = k1 + nproc)
-                {
-                    yi = knownTerms[off2 + k1];
-                    offSetInstr = 0;
-                    for (int m = 0; m < k1; m++)
-                        offSetInstr += instrConstrIlung[m];
-
-                    off1 = off3 + offSetInstr;
-                    off5 = off4 + offSetInstr;
-                    //FV_ EDIT ompSs
-                    //#pragma omp for
-                    for (int j = 0; j < instrConstrIlung[k1]; j++)
-                    {
-                        localSum = systemMatrix[off1 + j] * yi;
-                        off6 = offInstrUnk + instrCol[off5 + j];
-                        vVect[off6] += localSum;
-                    }
-                }
-                
-                if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-                    printf("\tPE=%d AprodTiming: nOfInstrConstr  sec=%ld\n", myid, time(NULL) - startTime_nOfInstrConstr);
+        }
+#pragma omp barrier
+    } //for i2
+}
+//////////////////////////////////////////////////////
+/// Mode 2 InstrConstr
+if(nOfInstrConstr){
+    localSum=0.0;
+    int offSetInstr;
+    long off1;
+    long offInstrUnk=VrIdAstroPDimMax*nAstroPSolved+nAttAxes*nDegFreedomAtt;
+    long off2=mapNoss[myid]+nEqExtConstr+nEqBarConstr;
+    long off3=mapNcoeff[myid]+nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr;
+    long off4=mapNoss[myid]*nInstrPSolved;
+    long off5;
+    long off6;
+    for(int k1=myid;k1<nOfInstrConstr;k1=k1+nproc){
+        yi=knownTerms[off2+k1];
+        offSetInstr=0;
+        for(int m=0;m<k1;m++)
+            offSetInstr+=instrConstrIlung[m];
+            
+        off1=off3+offSetInstr;
+        off5=off4+offSetInstr;
+#pragma omp for
+            for(int j=0;j<instrConstrIlung[k1];j++){
+                localSum=systemMatrix[off1+j]*yi;
+                off6=offInstrUnk+instrCol[off5+j];
+                vVect[off6]+=localSum;
             }
-            ////////////
+        }
+}
+////////////
 
-        } //pragma
-        *ompSec += time(NULL) - startTime;
-        if (comlsqr.itn <= 2 && (myid == 0 || myid == nproc - 1 || debugMode == 1))
-            printf("PE=%d AprodTiming: mode=2.2  OmpSec=%ld\n", myid, time(NULL) - startTime);
-    } // else if(mode==2)
+} //pragma
+*ompSec+=time(NULL)-startTime;
+if(comlsqr.itn<=2 &&(myid==0 || myid==nproc-1 || debugMode==1)) printf("PE=%d AprodTiming: mode=2.2  OmpSec=%ld\n",myid,time(NULL)-startTime);
+}// else if(mode==2)
 }
+
diff --git a/lsqr.c b/lsqr.c
index f8ff3e9..346591d 100644
--- a/lsqr.c
+++ b/lsqr.c
@@ -32,10 +32,10 @@ Parallelized for ESA Gaia Mission. U. becciani A. Vecchiato 2013
 //  #include "cblas.h"
 //#endif
 
-#define ZERO 0.0
-#define ONE 1.0
+#define ZERO   0.0
+#define ONE    1.0
 void aprod(int mode, long int m, long int n, double x[], double y[],
-           double *ra, long int *matrixIndex, int *instrCol, int *instrConstrIlung, struct comData comlsqr, time_t *ompSec);
+                              double *ra,long int *matrixIndex, int *instrCol,int *instrConstrIlung, struct comData comlsqr,time_t *ompSec);
 // ---------------------------------------------------------------------
 // d2norm  returns  sqrt( a**2 + b**2 )  with precautions
 // to avoid overflow.
@@ -43,1445 +43,1328 @@ void aprod(int mode, long int m, long int n, double x[], double y[],
 // 21 Mar 1990: First version.
 // ---------------------------------------------------------------------
 static double
-d2norm(const double a, const double b)
+d2norm( const double a, const double b )
 {
     double scale;
     const double zero = 0.0;
 
-    scale = fabs(a) + fabs(b);
+    scale  = fabs( a ) + fabs( b );
     if (scale == zero)
         return zero;
     else
-        return scale * sqrt((a / scale) * (a / scale) + (b / scale) * (b / scale));
+        return scale * sqrt( (a/scale)*(a/scale) + (b/scale)*(b/scale) );
 }
 
 static void
-dload(const long int n, const double alpha, double x[])
-{
+dload( const long int n, const double alpha, double x[] )
+{    
     long int i;
-/// FV_ EDIT
-    ///#pragma omp for
-    for (i = 0; i < n; i++)
-        x[i] = alpha;
+#pragma omp for
+    for (i = 0; i < n; i++) x[i] = alpha;
     return;
 }
 
 // ---------------------------------------------------------------------
 // LSQR
 // ---------------------------------------------------------------------
-void lsqr(
-    long int m,
-    long int n,
-    //          void (*aprod)(int mode, int m, int n, double x[], double y[],
-    //                        void *UsrWrk),
-    double damp,
-    //          void   *UsrWrk,
-    double *knownTerms,    // len = m  reported as u
-    double *vVect,         // len = n reported as v
-    double *wVect,         // len = n  reported as w
-    double *xSolution,     // len = n reported as x
-    double *standardError, // len at least n.  May be NULL. reported as se
-    double atol,
-    double btol,
-    double conlim,
-    int itnlim,
-    // The remaining variables are output only.
-    int *istop_out,
-    int *itn_out,
-    double *anorm_out,
-    double *acond_out,
-    double *rnorm_out,
-    double *arnorm_out,
-    double *xnorm_out,
-    double *systemMatrix,  // reported as a
-    long int *matrixIndex, // reported as janew
-    int *instrCol,
-    int *instrConstrIlung,
-    double *preCondVect,
-    struct comData comlsqr)
-    {
-    //     ------------------------------------------------------------------
-    //
-    //     LSQR  finds a solution x to the following problems:
-    //
-    //     1. Unsymmetric equations --    solve  A*x = b
-    //
-    //     2. Linear least squares  --    solve  A*x = b
-    //                                    in the least-squares sense
-    //
-    //     3. Damped least squares  --    solve  (   A    )*x = ( b )
-    //                                           ( damp*I )     ( 0 )
-    //                                    in the least-squares sense
-    //
-    //     where A is a matrix with m rows and n columns, b is an
-    //     m-vector, and damp is a scalar.  (All quantities are real.)
-    //     The matrix A is intended to be large and sparse.  It is accessed
-    //     by means of subroutine calls of the form
-    //
-    //                aprod ( mode, m, n, x, y, UsrWrk )
-    //
-    //     which must perform the following functions:
-    //
-    //                If mode = 1, compute  y = y + A*x.
-    //                If mode = 2, compute  x = x + A(transpose)*y.
-    //
-    //     The vectors x and y are input parameters in both cases.
-    //     If  mode = 1,  y should be altered without changing x.
-    //     If  mode = 2,  x should be altered without changing y.
-    //     The parameter UsrWrk may be used for workspace as described
-    //     below.
-    //
-    //     The rhs vector b is input via u, and subsequently overwritten.
-    //
-    //
-    //     Note:  LSQR uses an iterative method to approximate the solution.
-    //     The number of iterations required to reach a certain accuracy
-    //     depends strongly on the scaling of the problem.  Poor scaling of
-    //     the rows or columns of A should therefore be avoided where
-    //     possible.
-    //
-    //     For example, in problem 1 the solution is unaltered by
-    //     row-scaling.  If a row of A is very small or large compared to
-    //     the other rows of A, the corresponding row of ( A  b ) should be
-    //     scaled up or down.
-    //
-    //     In problems 1 and 2, the solution x is easily recovered
-    //     following column-scaling.  Unless better information is known,
-    //     the nonzero columns of A should be scaled so that they all have
-    //     the same Euclidean norm (e.g., 1.0).
-    //
-    //     In problem 3, there is no freedom to re-scale if damp is
-    //     nonzero.  However, the value of damp should be assigned only
-    //     after attention has been paid to the scaling of A.
-    //
-    //     The parameter damp is intended to help regularize
-    //     ill-conditioned systems, by preventing the true solution from
-    //     being very large.  Another aid to regularization is provided by
-    //     the parameter acond, which may be used to terminate iterations
-    //     before the computed solution becomes very large.
-    //
-    //     Note that x is not an input parameter.
-    //     If some initial estimate x0 is known and if damp = 0,
-    //     one could proceed as follows:
-    //
-    //       1. Compute a residual vector     r0 = b - A*x0.
-    //       2. Use LSQR to solve the system  A*dx = r0.
-    //       3. Add the correction dx to obtain a final solution x = x0 + dx.
-    //
-    //     This requires that x0 be available before and after the call
-    //     to LSQR.  To judge the benefits, suppose LSQR takes k1 iterations
-    //     to solve A*x = b and k2 iterations to solve A*dx = r0.
-    //     If x0 is "good", norm(r0) will be smaller than norm(b).
-    //     If the same stopping tolerances atol and btol are used for each
-    //     system, k1 and k2 will be similar, but the final solution x0 + dx
-    //     should be more accurate.  The only way to reduce the total work
-    //     is to use a larger stopping tolerance for the second system.
-    //     If some value btol is suitable for A*x = b, the larger value
-    //     btol*norm(b)/norm(r0)  should be suitable for A*dx = r0.
-    //
-    //     Preconditioning is another way to reduce the number of iterations.
-    //     If it is possible to solve a related system M*x = b efficiently,
-    //     where M approximates A in some helpful way
-    //     (e.g. M - A has low rank or its elements are small relative to
-    //     those of A), LSQR may converge more rapidly on the system
-    //           A*M(inverse)*z = b,
-    //     after which x can be recovered by solving M*x = z.
-    //
-    //     NOTE: If A is symmetric, LSQR should not be used!
-    //     Alternatives are the symmetric conjugate-gradient method (cg)
-    //     and/or SYMMLQ.
-    //     SYMMLQ is an implementation of symmetric cg that applies to
-    //     any symmetric A and will converge more rapidly than LSQR.
-    //     If A is positive definite, there are other implementations of
-    //     symmetric cg that require slightly less work per iteration
-    //     than SYMMLQ (but will take the same number of iterations).
-    //
-    //
-    //     Notation
-    //     --------
-    //
-    //     The following quantities are used in discussing the subroutine
-    //     parameters:
-    //
-    //     Abar   =  (   A    ),          bbar  =  ( b )
-    //               ( damp*I )                    ( 0 )
-    //
-    //     r      =  b  -  A*x,           rbar  =  bbar  -  Abar*x
-    //
-    //     rnorm  =  sqrt( norm(r)**2  +  damp**2 * norm(x)**2 )
-    //            =  norm( rbar )
-    //
-    //     relpr  =  the relative precision of floating-point arithmetic
-    //               on the machine being used.  On most machines,
-    //               relpr is about 1.0e-7 and 1.0d-16 in single and double
-    //               precision respectively.
-    //
-    //     LSQR  minimizes the function rnorm with respect to x.
-    //
-    //
-    //     Parameters
-    //     ----------
-    //
-    //     m       input      m, the number of rows in A.
-    //
-    //     n       input      n, the number of columns in A.
-    //
-    //     aprod   external   See above.
-    //
-    //     damp    input      The damping parameter for problem 3 above.
-    //                        (damp should be 0.0 for problems 1 and 2.)
-    //                        If the system A*x = b is incompatible, values
-    //                        of damp in the range 0 to sqrt(relpr)*norm(A)
-    //                        will probably have a negligible effect.
-    //                        Larger values of damp will tend to decrease
-    //                        the norm of x and reduce the number of
-    //                        iterations required by LSQR.
-    //
-    //                        The work per iteration and the storage needed
-    //                        by LSQR are the same for all values of damp.
-    //
-    //     rw      workspace  Transit pointer to user's workspace.
-    //                        Note:  LSQR  does not explicitly use this
-    //                        parameter, but passes it to subroutine aprod for
-    //                        possible use as workspace.
-    //
-    //     u(m)    input      The rhs vector b.  Beware that u is
-    //                        over-written by LSQR.
-    //
-    //     v(n)    workspace
-    //
-    //     w(n)    workspace
-    //
-    //     x(n)    output     Returns the computed solution x.
-    //
-    //     se(*)   output     If m .gt. n  or  damp .gt. 0,  the system is
-    //             (maybe)    overdetermined and the standard errors may be
-    //                        useful.  (See the first LSQR reference.)
-    //                        Otherwise (m .le. n  and  damp = 0) they do not
-    //                        mean much.  Some time and storage can be saved
-    //                        by setting  se = NULL.  In that case, se will
-    //                        not be touched.
-    //
-    //                        If se is not NULL, then the dimension of se must
-    //                        be n or more.  se(1:n) then returns standard error
-    //                        estimates for the components of x.
-    //                        For each i, se(i) is set to the value
-    //                           rnorm * sqrt( sigma(i,i) / t ),
-    //                        where sigma(i,i) is an estimate of the i-th
-    //                        diagonal of the inverse of Abar(transpose)*Abar
-    //                        and  t = 1      if  m .le. n,
-    //                             t = m - n  if  m .gt. n  and  damp = 0,
-    //                             t = m      if  damp .ne. 0.
-    //
-    //     atol    input      An estimate of the relative error in the data
-    //                        defining the matrix A.  For example,
-    //                        if A is accurate to about 6 digits, set
-    //                        atol = 1.0e-6 .
-    //
-    //     btol    input      An estimate of the relative error in the data
-    //                        defining the rhs vector b.  For example,
-    //                        if b is accurate to about 6 digits, set
-    //                        btol = 1.0e-6 .
-    //
-    //     conlim  input      An upper limit on cond(Abar), the apparent
-    //                        condition number of the matrix Abar.
-    //                        Iterations will be terminated if a computed
-    //                        estimate of cond(Abar) exceeds conlim.
-    //                        This is intended to prevent certain small or
-    //                        zero singular values of A or Abar from
-    //                        coming into effect and causing unwanted growth
-    //                        in the computed solution.
-    //
-    //                        conlim and damp may be used separately or
-    //                        together to regularize ill-conditioned systems.
-    //
-    //                        Normally, conlim should be in the range
-    //                        1000 to 1/relpr.
-    //                        Suggested value:
-    //                        conlim = 1/(100*relpr)  for compatible systems,
-    //                        conlim = 1/(10*sqrt(relpr)) for least squares.
-    //
-    //             Note:  If the user is not concerned about the parameters
-    //             atol, btol and conlim, any or all of them may be set
-    //             to zero.  The effect will be the same as the values
-    //             relpr, relpr and 1/relpr respectively.
-    //
-    //     itnlim  input      An upper limit on the number of iterations.
-    //                        Suggested value:
-    //                        itnlim = n/2   for well-conditioned systems
-    //                                       with clustered singular values,
-    //                        itnlim = 4*n   otherwise.
-    //
-    //     nout    input      File number for printed output.  If positive,
-    //                        a summary will be printed on file nout.
-    //
-    //     istop   output     An integer giving the reason for termination:
-    //
-    //                0       x = 0  is the exact solution.
-    //                        No iterations were performed.
-    //
-    //                1       The equations A*x = b are probably
-    //                        compatible.  Norm(A*x - b) is sufficiently
-    //                        small, given the values of atol and btol.
-    //
-    //                2       damp is zero.  The system A*x = b is probably
-    //                        not compatible.  A least-squares solution has
-    //                        been obtained that is sufficiently accurate,
-    //                        given the value of atol.
-    //
-    //                3       damp is nonzero.  A damped least-squares
-    //                        solution has been obtained that is sufficiently
-    //                        accurate, given the value of atol.
-    //
-    //                4       An estimate of cond(Abar) has exceeded
-    //                        conlim.  The system A*x = b appears to be
-    //                        ill-conditioned.  Otherwise, there could be an
-    //                        error in subroutine aprod.
-    //
-    //                5       The iteration limit itnlim was reached.
-    //
-    //     itn     output     The number of iterations performed.
-    //
-    //     anorm   output     An estimate of the Frobenius norm of  Abar.
-    //                        This is the square-root of the sum of squares
-    //                        of the elements of Abar.
-    //                        If damp is small and if the columns of A
-    //                        have all been scaled to have length 1.0,
-    //                        anorm should increase to roughly sqrt(n).
-    //                        A radically different value for anorm may
-    //                        indicate an error in subroutine aprod (there
-    //                        may be an inconsistency between modes 1 and 2).
-    //
-    //     acond   output     An estimate of cond(Abar), the condition
-    //                        number of Abar.  A very high value of acond
-    //                        may again indicate an error in aprod.
-    //
-    //     rnorm   output     An estimate of the final value of norm(rbar),
-    //                        the function being minimized (see notation
-    //                        above).  This will be small if A*x = b has
-    //                        a solution.
-    //
-    //     arnorm  output     An estimate of the final value of
-    //                        norm( Abar(transpose)*rbar ), the norm of
-    //                        the residual for the usual normal equations.
-    //                        This should be small in all cases.  (arnorm
-    //                        will often be smaller than the true value
-    //                        computed from the output vector x.)
-    //
-    //     xnorm   output     An estimate of the norm of the final
-    //                        solution vector x.
-    //
-    //
-    //     Subroutines and functions used
-    //     ------------------------------
-    //
-    //     USER               aprod
-    //     CBLAS              dcopy, dnrm2, dscal (see Lawson et al. below)
-    //
-    //
-    //     References
-    //     ----------
-    //
-    //     C.C. Paige and M.A. Saunders,  LSQR: An algorithm for sparse
-    //          linear equations and sparse least squares,
-    //          ACM Transactions on Mathematical Software 8, 1 (March 1982),
-    //          pp. 43-71.
-    //
-    //     C.C. Paige and M.A. Saunders,  Algorithm 583, LSQR: Sparse
-    //          linear equations and least-squares problems,
-    //          ACM Transactions on Mathematical Software 8, 2 (June 1982),
-    //          pp. 195-209.
-    //
-    //     C.L. Lawson, R.J. Hanson, D.R. Kincaid and F.T. Krogh,
-    //          Basic linear algebra subprograms for Fortran usage,
-    //          ACM Transactions on Mathematical Software 5, 3 (Sept 1979),
-    //          pp. 308-323 and 324-325.
-    //     ------------------------------------------------------------------
-    //
-    //
-    //     LSQR development:
-    //     22 Feb 1982: LSQR sent to ACM TOMS to become Algorithm 583.
-    //     15 Sep 1985: Final F66 version.  LSQR sent to "misc" in netlib.
-    //     13 Oct 1987: Bug (Robert Davies, DSIR).  Have to delete
-    //                     if ( (one + dabs(t)) .le. one ) GO TO 200
-    //                  from loop 200.  The test was an attempt to reduce
-    //                  underflows, but caused w(i) not to be updated.
-    //     17 Mar 1989: First F77 version.
-    //     04 May 1989: Bug (David Gay, AT&T).  When the second beta is zero,
-    //                  rnorm = 0 and
-    //                  test2 = arnorm / (anorm * rnorm) overflows.
-    //                  Fixed by testing for rnorm = 0.
-    //     05 May 1989: Sent to "misc" in netlib.
-    //     14 Mar 1990: Bug (John Tomlin via IBM OSL testing).
-    //                  Setting rhbar2 = rhobar**2 + dampsq can give zero
-    //                  if rhobar underflows and damp = 0.
-    //                  Fixed by testing for damp = 0 specially.
-    //     15 Mar 1990: Converted to lower case.
-    //     21 Mar 1990: d2norm introduced to avoid overflow in numerous
-    //                  items like  c = sqrt( a**2 + b**2 ).
-    //     04 Sep 1991: wantse added as an argument to LSQR, to make
-    //                  standard errors optional.  This saves storage and
-    //                  time when se(*) is not wanted.
-    //     13 Feb 1992: istop now returns a value in [1,5], not [1,7].
-    //                  1, 2 or 3 means that x solves one of the problems
-    //                  Ax = b,  min norm(Ax - b)  or  damped least squares.
-    //                  4 means the limit on cond(A) was reached.
-    //                  5 means the limit on iterations was reached.
-    //     07 Dec 1994: Keep track of dxmax = max_k norm( phi_k * d_k ).
-    //                  So far, this is just printed at the end.
-    //                  A large value (relative to norm(x)) indicates
-    //                  significant cancellation in forming
-    //                  x  =  D*f  =  sum( phi_k * d_k ).
-    //                  A large column of D need NOT be serious if the
-    //                  corresponding phi_k is small.
-    //     27 Dec 1994: Include estimate of alfa_opt in iteration log.
-    //                  alfa_opt is the optimal scale factor for the
-    //                  residual in the "augmented system", as described by
-    //                  A. Bjorck (1992),
-    //                  Pivoting and stability in the augmented system method,
-    //                  in D. F. Griffiths and G. A. Watson (eds.),
-    //                  "Numerical Analysis 1991",
-    //                  Proceedings of the 14th Dundee Conference,
-    //                  Pitman Research Notes in Mathematics 260,
-    //                  Longman Scientific and Technical, Harlow, Essex, 1992.
-    //     14 Apr 2006: "Line-by-line" conversion to ISO C by
-    //                  Michael P. Friedlander.
-    //
-    //
-    //     Michael A. Saunders                  mike@sol-michael.stanford.edu
-    //     Dept of Operations Research          na.Msaunders@na-net.ornl.gov
-    //     Stanford University
-    //     Stanford, CA 94305-4022              (415) 723-1875
-    //-----------------------------------------------------------------------
-
-    //  Local copies of output variables.  Output vars are assigned at exit.
-
-
-    int istop = 0;
-    int itn = 0;
-
-
-double
-    anorm = ZERO,
-    acond = ZERO,
-    rnorm = ZERO,
-    arnorm = ZERO,
-    xnorm = ZERO;
+void lsqr( 
+          long int m,
+          long int n,
+//          void (*aprod)(int mode, int m, int n, double x[], double y[],
+//                        void *UsrWrk),
+          double damp,
+//          void   *UsrWrk,
+          double *knownTerms,     // len = m  reported as u
+          double *vVect,     // len = n reported as v
+          double *wVect,     // len = n  reported as w
+          double *xSolution,     // len = n reported as x
+          double *standardError,    // len at least n.  May be NULL. reported as se
+          double atol,
+          double btol,
+          double conlim,
+          int    itnlim,
+          // The remaining variables are output only.
+          int    *istop_out,
+          int    *itn_out,
+          double *anorm_out,
+          double *acond_out,
+          double *rnorm_out,
+          double *arnorm_out,
+          double *xnorm_out,
+      	  double *systemMatrix,  // reported as a
+          long int *matrixIndex, // reported as janew
+          int *instrCol,
+          int *instrConstrIlung,
+          double *preCondVect, 
+	  struct comData comlsqr)
+{ 
+//     ------------------------------------------------------------------
+//
+//     LSQR  finds a solution x to the following problems:
+//
+//     1. Unsymmetric equations --    solve  A*x = b
+//
+//     2. Linear least squares  --    solve  A*x = b
+//                                    in the least-squares sense
+//
+//     3. Damped least squares  --    solve  (   A    )*x = ( b )
+//                                           ( damp*I )     ( 0 )
+//                                    in the least-squares sense
+//
+//     where A is a matrix with m rows and n columns, b is an
+//     m-vector, and damp is a scalar.  (All quantities are real.)
+//     The matrix A is intended to be large and sparse.  It is accessed
+//     by means of subroutine calls of the form
+//
+//                aprod ( mode, m, n, x, y, UsrWrk )
+//
+//     which must perform the following functions:
+//
+//                If mode = 1, compute  y = y + A*x.
+//                If mode = 2, compute  x = x + A(transpose)*y.
+//
+//     The vectors x and y are input parameters in both cases.
+//     If  mode = 1,  y should be altered without changing x.
+//     If  mode = 2,  x should be altered without changing y.
+//     The parameter UsrWrk may be used for workspace as described
+//     below.
+//
+//     The rhs vector b is input via u, and subsequently overwritten.
+//
+//
+//     Note:  LSQR uses an iterative method to approximate the solution.
+//     The number of iterations required to reach a certain accuracy
+//     depends strongly on the scaling of the problem.  Poor scaling of
+//     the rows or columns of A should therefore be avoided where
+//     possible.
+//
+//     For example, in problem 1 the solution is unaltered by
+//     row-scaling.  If a row of A is very small or large compared to
+//     the other rows of A, the corresponding row of ( A  b ) should be
+//     scaled up or down.
+//
+//     In problems 1 and 2, the solution x is easily recovered
+//     following column-scaling.  Unless better information is known,
+//     the nonzero columns of A should be scaled so that they all have
+//     the same Euclidean norm (e.g., 1.0).
+//
+//     In problem 3, there is no freedom to re-scale if damp is
+//     nonzero.  However, the value of damp should be assigned only
+//     after attention has been paid to the scaling of A.
+//
+//     The parameter damp is intended to help regularize
+//     ill-conditioned systems, by preventing the true solution from
+//     being very large.  Another aid to regularization is provided by
+//     the parameter acond, which may be used to terminate iterations
+//     before the computed solution becomes very large.
+//
+//     Note that x is not an input parameter.
+//     If some initial estimate x0 is known and if damp = 0,
+//     one could proceed as follows:
+//
+//       1. Compute a residual vector     r0 = b - A*x0.
+//       2. Use LSQR to solve the system  A*dx = r0.
+//       3. Add the correction dx to obtain a final solution x = x0 + dx.
+//
+//     This requires that x0 be available before and after the call
+//     to LSQR.  To judge the benefits, suppose LSQR takes k1 iterations
+//     to solve A*x = b and k2 iterations to solve A*dx = r0.
+//     If x0 is "good", norm(r0) will be smaller than norm(b).
+//     If the same stopping tolerances atol and btol are used for each
+//     system, k1 and k2 will be similar, but the final solution x0 + dx
+//     should be more accurate.  The only way to reduce the total work
+//     is to use a larger stopping tolerance for the second system.
+//     If some value btol is suitable for A*x = b, the larger value
+//     btol*norm(b)/norm(r0)  should be suitable for A*dx = r0.
+//
+//     Preconditioning is another way to reduce the number of iterations.
+//     If it is possible to solve a related system M*x = b efficiently,
+//     where M approximates A in some helpful way
+//     (e.g. M - A has low rank or its elements are small relative to
+//     those of A), LSQR may converge more rapidly on the system
+//           A*M(inverse)*z = b,
+//     after which x can be recovered by solving M*x = z.
+//
+//     NOTE: If A is symmetric, LSQR should not be used!
+//     Alternatives are the symmetric conjugate-gradient method (cg)
+//     and/or SYMMLQ.
+//     SYMMLQ is an implementation of symmetric cg that applies to
+//     any symmetric A and will converge more rapidly than LSQR.
+//     If A is positive definite, there are other implementations of
+//     symmetric cg that require slightly less work per iteration
+//     than SYMMLQ (but will take the same number of iterations).
+//
+//
+//     Notation
+//     --------
+//
+//     The following quantities are used in discussing the subroutine
+//     parameters:
+//
+//     Abar   =  (   A    ),          bbar  =  ( b )
+//               ( damp*I )                    ( 0 )
+//
+//     r      =  b  -  A*x,           rbar  =  bbar  -  Abar*x
+//
+//     rnorm  =  sqrt( norm(r)**2  +  damp**2 * norm(x)**2 )
+//            =  norm( rbar )
+//
+//     relpr  =  the relative precision of floating-point arithmetic
+//               on the machine being used.  On most machines,
+//               relpr is about 1.0e-7 and 1.0d-16 in single and double
+//               precision respectively.
+//
+//     LSQR  minimizes the function rnorm with respect to x.
+//
+//
+//     Parameters
+//     ----------
+//
+//     m       input      m, the number of rows in A.
+//
+//     n       input      n, the number of columns in A.
+//
+//     aprod   external   See above.
+//
+//     damp    input      The damping parameter for problem 3 above.
+//                        (damp should be 0.0 for problems 1 and 2.)
+//                        If the system A*x = b is incompatible, values
+//                        of damp in the range 0 to sqrt(relpr)*norm(A)
+//                        will probably have a negligible effect.
+//                        Larger values of damp will tend to decrease
+//                        the norm of x and reduce the number of 
+//                        iterations required by LSQR.
+//
+//                        The work per iteration and the storage needed
+//                        by LSQR are the same for all values of damp.
+//
+//     rw      workspace  Transit pointer to user's workspace.
+//                        Note:  LSQR  does not explicitly use this
+//                        parameter, but passes it to subroutine aprod for
+//                        possible use as workspace.
+//
+//     u(m)    input      The rhs vector b.  Beware that u is
+//                        over-written by LSQR.
+//
+//     v(n)    workspace
+//
+//     w(n)    workspace
+//
+//     x(n)    output     Returns the computed solution x.
+//
+//     se(*)   output     If m .gt. n  or  damp .gt. 0,  the system is
+//             (maybe)    overdetermined and the standard errors may be
+//                        useful.  (See the first LSQR reference.)
+//                        Otherwise (m .le. n  and  damp = 0) they do not
+//                        mean much.  Some time and storage can be saved
+//                        by setting  se = NULL.  In that case, se will
+//                        not be touched.
+//
+//                        If se is not NULL, then the dimension of se must
+//                        be n or more.  se(1:n) then returns standard error
+//                        estimates for the components of x.
+//                        For each i, se(i) is set to the value
+//                           rnorm * sqrt( sigma(i,i) / t ),
+//                        where sigma(i,i) is an estimate of the i-th
+//                        diagonal of the inverse of Abar(transpose)*Abar
+//                        and  t = 1      if  m .le. n,
+//                             t = m - n  if  m .gt. n  and  damp = 0,
+//                             t = m      if  damp .ne. 0.
+//
+//     atol    input      An estimate of the relative error in the data
+//                        defining the matrix A.  For example,
+//                        if A is accurate to about 6 digits, set
+//                        atol = 1.0e-6 .
+//
+//     btol    input      An estimate of the relative error in the data
+//                        defining the rhs vector b.  For example,
+//                        if b is accurate to about 6 digits, set
+//                        btol = 1.0e-6 .
+//
+//     conlim  input      An upper limit on cond(Abar), the apparent
+//                        condition number of the matrix Abar.
+//                        Iterations will be terminated if a computed
+//                        estimate of cond(Abar) exceeds conlim.
+//                        This is intended to prevent certain small or
+//                        zero singular values of A or Abar from
+//                        coming into effect and causing unwanted growth
+//                        in the computed solution.
+//
+//                        conlim and damp may be used separately or
+//                        together to regularize ill-conditioned systems.
+//
+//                        Normally, conlim should be in the range
+//                        1000 to 1/relpr.
+//                        Suggested value:
+//                        conlim = 1/(100*relpr)  for compatible systems,
+//                        conlim = 1/(10*sqrt(relpr)) for least squares.
+//
+//             Note:  If the user is not concerned about the parameters
+//             atol, btol and conlim, any or all of them may be set
+//             to zero.  The effect will be the same as the values
+//             relpr, relpr and 1/relpr respectively.
+//
+//     itnlim  input      An upper limit on the number of iterations.
+//                        Suggested value:
+//                        itnlim = n/2   for well-conditioned systems
+//                                       with clustered singular values,
+//                        itnlim = 4*n   otherwise.
+//
+//     nout    input      File number for printed output.  If positive,
+//                        a summary will be printed on file nout.
+//
+//     istop   output     An integer giving the reason for termination:
+//
+//                0       x = 0  is the exact solution.
+//                        No iterations were performed.
+//
+//                1       The equations A*x = b are probably
+//                        compatible.  Norm(A*x - b) is sufficiently
+//                        small, given the values of atol and btol.
+//
+//                2       damp is zero.  The system A*x = b is probably
+//                        not compatible.  A least-squares solution has
+//                        been obtained that is sufficiently accurate,
+//                        given the value of atol.
+//
+//                3       damp is nonzero.  A damped least-squares
+//                        solution has been obtained that is sufficiently
+//                        accurate, given the value of atol.
+//
+//                4       An estimate of cond(Abar) has exceeded
+//                        conlim.  The system A*x = b appears to be
+//                        ill-conditioned.  Otherwise, there could be an
+//                        error in subroutine aprod.
+//
+//                5       The iteration limit itnlim was reached.
+//
+//     itn     output     The number of iterations performed.
+//
+//     anorm   output     An estimate of the Frobenius norm of  Abar.
+//                        This is the square-root of the sum of squares
+//                        of the elements of Abar.
+//                        If damp is small and if the columns of A
+//                        have all been scaled to have length 1.0,
+//                        anorm should increase to roughly sqrt(n).
+//                        A radically different value for anorm may
+//                        indicate an error in subroutine aprod (there
+//                        may be an inconsistency between modes 1 and 2).
+//
+//     acond   output     An estimate of cond(Abar), the condition
+//                        number of Abar.  A very high value of acond
+//                        may again indicate an error in aprod.
+//
+//     rnorm   output     An estimate of the final value of norm(rbar),
+//                        the function being minimized (see notation
+//                        above).  This will be small if A*x = b has
+//                        a solution.
+//
+//     arnorm  output     An estimate of the final value of
+//                        norm( Abar(transpose)*rbar ), the norm of
+//                        the residual for the usual normal equations.
+//                        This should be small in all cases.  (arnorm
+//                        will often be smaller than the true value
+//                        computed from the output vector x.)
+//
+//     xnorm   output     An estimate of the norm of the final
+//                        solution vector x.
+//
+//
+//     Subroutines and functions used              
+//     ------------------------------
+//
+//     USER               aprod
+//     CBLAS              dcopy, dnrm2, dscal (see Lawson et al. below)
+//
+//
+//     References
+//     ----------
+//
+//     C.C. Paige and M.A. Saunders,  LSQR: An algorithm for sparse
+//          linear equations and sparse least squares,
+//          ACM Transactions on Mathematical Software 8, 1 (March 1982),
+//          pp. 43-71.
+//
+//     C.C. Paige and M.A. Saunders,  Algorithm 583, LSQR: Sparse
+//          linear equations and least-squares problems,
+//          ACM Transactions on Mathematical Software 8, 2 (June 1982),
+//          pp. 195-209.
+//
+//     C.L. Lawson, R.J. Hanson, D.R. Kincaid and F.T. Krogh,
+//          Basic linear algebra subprograms for Fortran usage,
+//          ACM Transactions on Mathematical Software 5, 3 (Sept 1979),
+//          pp. 308-323 and 324-325.
+//     ------------------------------------------------------------------
+//
+//
+//     LSQR development:
+//     22 Feb 1982: LSQR sent to ACM TOMS to become Algorithm 583.
+//     15 Sep 1985: Final F66 version.  LSQR sent to "misc" in netlib.
+//     13 Oct 1987: Bug (Robert Davies, DSIR).  Have to delete
+//                     if ( (one + dabs(t)) .le. one ) GO TO 200
+//                  from loop 200.  The test was an attempt to reduce
+//                  underflows, but caused w(i) not to be updated.
+//     17 Mar 1989: First F77 version.
+//     04 May 1989: Bug (David Gay, AT&T).  When the second beta is zero,
+//                  rnorm = 0 and
+//                  test2 = arnorm / (anorm * rnorm) overflows.
+//                  Fixed by testing for rnorm = 0.
+//     05 May 1989: Sent to "misc" in netlib.
+//     14 Mar 1990: Bug (John Tomlin via IBM OSL testing).
+//                  Setting rhbar2 = rhobar**2 + dampsq can give zero
+//                  if rhobar underflows and damp = 0.
+//                  Fixed by testing for damp = 0 specially.
+//     15 Mar 1990: Converted to lower case.
+//     21 Mar 1990: d2norm introduced to avoid overflow in numerous
+//                  items like  c = sqrt( a**2 + b**2 ).
+//     04 Sep 1991: wantse added as an argument to LSQR, to make
+//                  standard errors optional.  This saves storage and
+//                  time when se(*) is not wanted.
+//     13 Feb 1992: istop now returns a value in [1,5], not [1,7].
+//                  1, 2 or 3 means that x solves one of the problems
+//                  Ax = b,  min norm(Ax - b)  or  damped least squares.
+//                  4 means the limit on cond(A) was reached.
+//                  5 means the limit on iterations was reached.
+//     07 Dec 1994: Keep track of dxmax = max_k norm( phi_k * d_k ).
+//                  So far, this is just printed at the end.
+//                  A large value (relative to norm(x)) indicates
+//                  significant cancellation in forming
+//                  x  =  D*f  =  sum( phi_k * d_k ).
+//                  A large column of D need NOT be serious if the
+//                  corresponding phi_k is small.
+//     27 Dec 1994: Include estimate of alfa_opt in iteration log.
+//                  alfa_opt is the optimal scale factor for the
+//                  residual in the "augmented system", as described by
+//                  A. Bjorck (1992),
+//                  Pivoting and stability in the augmented system method,
+//                  in D. F. Griffiths and G. A. Watson (eds.),
+//                  "Numerical Analysis 1991",
+//                  Proceedings of the 14th Dundee Conference,
+//                  Pitman Research Notes in Mathematics 260,
+//                  Longman Scientific and Technical, Harlow, Essex, 1992.
+//     14 Apr 2006: "Line-by-line" conversion to ISO C by
+//                  Michael P. Friedlander.
+//
+//
+//     Michael A. Saunders                  mike@sol-michael.stanford.edu
+//     Dept of Operations Research          na.Msaunders@na-net.ornl.gov
+//     Stanford University
+//     Stanford, CA 94305-4022              (415) 723-1875
+//-----------------------------------------------------------------------
 
+//  Local copies of output variables.  Output vars are assigned at exit.
+
+
+    int
+        istop  = 0,
+        itn    = 0;
+    double
+        anorm  = ZERO,
+        acond  = ZERO,
+        rnorm  = ZERO,
+        arnorm = ZERO,
+        xnorm  = ZERO;
+       
 //  Local variables
 
-const bool
-    extra = false, // true for extra printing below.
-    damped = damp > ZERO,
-    wantse = standardError != NULL;
-long int i;
-int
-    maxdx,
-    nconv, nstop;
-double
-    alfopt,
-    alpha, arnorm0, beta, bnorm,
-    cs, cs1, cs2, ctol,
-    delta, dknorm, dknormSum, dnorm, dxk, dxmax,
-    gamma, gambar, phi, phibar, psi,
-    res2, rho, rhobar, rhbar1,
-    rhs, rtol, sn, sn1, sn2,
-    t, tau, temp, test1, test2, test3,
-    theta, t1, t2, t3, xnorm1, z, zbar;
-char
-    enter[] = "Enter LSQR.  ",
-    exitLsqr[] = "Exit  LSQR.  ",
-    msg[6][100] =
+    const bool
+        extra  = false,       // true for extra printing below.
+        damped = damp > ZERO,
+        wantse = standardError != NULL;
+    long int i;
+    int
+        maxdx, nconv, nstop;
+    double
+        alfopt, alpha, arnorm0, beta, bnorm,
+        cs, cs1, cs2, ctol,
+        delta, dknorm, dknormSum, dnorm, dxk, dxmax,
+        gamma, gambar, phi, phibar, psi,
+        res2, rho, rhobar, rhbar1,
+        rhs, rtol, sn, sn1, sn2,
+        t, tau, temp, test1, test2, test3,
+        theta, t1, t2, t3, xnorm1, z, zbar;
+    char
+        enter[] = "Enter LSQR.  ",
+        exitLsqr[]  = "Exit  LSQR.  ",
+        msg[6][100] =
         {
             {"The exact solution is  x = 0"},
             {"A solution to Ax = b was found, given atol, btol"},
             {"A least-squares solution was found, given atol"},
             {"A damped least-squares solution was found, given atol"},
             {"Cond(Abar) seems to be too large, given conlim"},
-            {"The iteration limit was reached"}};
-char lsqrOut[] = "lsqr-output"; // (buffer flush problem)
-char wpath[1024];
-size_t sizePath = 1020;
-
+            {"The iteration limit was reached"}
+        };
+	char lsqrOut[] = "lsqr-output"; // (buffer flush problem)
+    char wpath[1024];
+    size_t sizePath=1020;
+    
 //-----------------------------------------------------------------------
 
 //  Format strings.
-char fmt_1000[] =
-    " %s        Least-squares solution of  Ax = b\n"
-    " The matrix  A  has %ld rows  and %ld columns\n"
-    " damp   = %-22.2e    wantse = %10i\n"
-    " atol   = %-22.2e    conlim = %10.2e\n"
-    " btol   = %-22.2e    itnlim = %10d\n\n";
-char fmt_1200[] =
-    "    Itn       x(1)           Function"
-    "     Compatible    LS      Norm A   Cond A\n";
-char fmt_1300[] =
-    "    Itn       x(1)           Function"
-    "     Compatible    LS      Norm Abar   Cond Abar\n";
-char fmt_1400[] =
-    "     phi    dknorm  dxk  alfa_opt\n";
-char fmt_1500_extra[] =
-    " %6d %16.9e %16.9e %9.2e %9.2e %8.1e %8.1e %8.1e %7.1e %7.1e %7.1e\n";
-char fmt_1500[] =
-    " %6d %16.9e %16.9e %9.2e %9.2e %8.1e %8.1e\n";
-char fmt_1550[] =
-    " %6d %16.9e %16.9e %9.2e %9.2e\n";
-char fmt_1600[] =
-    "\n";
-char fmt_2000[] =
-    "\n"
-    " %s       istop  = %-10d      itn    = %-10d\n"
-    " %s       anorm  = %11.5e     acond  = %11.5e\n"
-    " %s       vnorm  = %11.5e     xnorm  = %11.5e\n"
-    " %s       rnorm  = %11.5e     arnorm = %11.5e\n";
-char fmt_2100[] =
-    " %s       max dx = %7.1e occured at itn %-9d\n"
-    " %s              = %7.1e*xnorm\n";
-char fmt_3000[] =
-    " %s       %s\n";
+    char fmt_1000[] = 
+        " %s        Least-squares solution of  Ax = b\n"
+        " The matrix  A  has %ld rows  and %ld columns\n"
+        " damp   = %-22.2e    wantse = %10i\n"
+        " atol   = %-22.2e    conlim = %10.2e\n"
+        " btol   = %-22.2e    itnlim = %10d\n\n";
+    char fmt_1200[] =
+        "    Itn       x(1)           Function"
+        "     Compatible    LS      Norm A   Cond A\n";
+    char fmt_1300[] =
+        "    Itn       x(1)           Function"
+        "     Compatible    LS      Norm Abar   Cond Abar\n";
+    char fmt_1400[] =
+        "     phi    dknorm  dxk  alfa_opt\n";
+    char fmt_1500_extra[] =
+        " %6d %16.9e %16.9e %9.2e %9.2e %8.1e %8.1e %8.1e %7.1e %7.1e %7.1e\n";
+    char fmt_1500[] =
+        " %6d %16.9e %16.9e %9.2e %9.2e %8.1e %8.1e\n";
+    char fmt_1550[] =
+        " %6d %16.9e %16.9e %9.2e %9.2e\n";
+    char fmt_1600[] = 
+        "\n";
+    char fmt_2000[] =
+        "\n"
+        " %s       istop  = %-10d      itn    = %-10d\n"
+        " %s       anorm  = %11.5e     acond  = %11.5e\n"
+        " %s       vnorm  = %11.5e     xnorm  = %11.5e\n"
+        " %s       rnorm  = %11.5e     arnorm = %11.5e\n";
+    char fmt_2100[] =
+        " %s       max dx = %7.1e occured at itn %-9d\n"
+        " %s              = %7.1e*xnorm\n";
+    char fmt_3000[] =
+        " %s       %s\n";
 
 ///////////// Specific definitions
 
-time_t startCycleTime, endCycleTime, totTime, partialTime, CPRtimeStart, CPRtimeEnd, ompSec = 0;
-int writeCPR; //=0 no write CPR, =1 write CPR and continue, =2 write CPR and return
-int noCPR;
-int myid, nproc;
-long int *mapNoss, *mapNcoeff;
-MPI_Status status;
-long int nunkSplit, localAstro, localAstroMax, other;
-int nAstroElements;
-int debugMode;
-long VrIdAstroPDim, VrIdAstroPDimMax;
-long nDegFreedomAtt;
-int nAttAxes;
-int nAttParam, nInstrParam, nGlobalParam, itnTest, nAttP, numOfExtStar, numOfBarStar, numOfExtAttCol, nobs;
-long mapNossBefore;
-short nAstroPSolved, nInstrPsolved;
-double cycleStartMpiTime, cycleEndMpiTime;
-double *vAuxVect;
-int CPRCount;
-FILE *fpCPRend, *nout, *fpItnLimitNew;
-int nEqExtConstr, nEqBarConstr;
-int nElemIC, nOfInstrConstr;
-double *kAuxcopy;
-double *kcopy;
-int ntasks;
-int nthreads;
-////////////////////////////////
+    time_t startCycleTime,endCycleTime,totTime,partialTime,CPRtimeStart,CPRtimeEnd,ompSec=0;
+	int writeCPR; //=0 no write CPR, =1 write CPR and continue, =2 write CPR and return
+    int noCPR;
+    int myid,nproc;
+    long int *mapNoss, *mapNcoeff;
+    MPI_Status status;
+    long int nunkSplit, localAstro, localAstroMax, other; 
+    int nAstroElements;
+    int debugMode;
+    long VrIdAstroPDim, VrIdAstroPDimMax;
+    long nDegFreedomAtt;
+    int nAttAxes;
+    int nAttParam,nInstrParam,nGlobalParam,itnTest,nAttP,numOfExtStar,numOfBarStar,numOfExtAttCol,nobs;
+    long mapNossBefore;
+    short nAstroPSolved,nInstrPsolved;
+	double cycleStartMpiTime, cycleEndMpiTime;
+    double *vAuxVect;
+	int CPRCount;
+    FILE *fpCPRend, *nout, *fpItnLimitNew;
+    int nEqExtConstr,nEqBarConstr;
+    int nElemIC,nOfInstrConstr;
+    double *kAuxcopy;
+    double *kcopy;
+////////////////////////////////	
 //  Initialize.
-myid = comlsqr.myid;
-nproc = comlsqr.nproc;
-mapNcoeff = comlsqr.mapNcoeff;
-mapNoss = comlsqr.mapNoss;
-nAttParam = comlsqr.nAttParam;
-nInstrParam = comlsqr.nInstrParam;
-nGlobalParam = comlsqr.nGlobalParam;
-nunkSplit = comlsqr.nunkSplit;
-VrIdAstroPDim = comlsqr.VrIdAstroPDim;
-VrIdAstroPDimMax = comlsqr.VrIdAstroPDimMax;
-nAstroPSolved = comlsqr.nAstroPSolved;
-nEqExtConstr = comlsqr.nEqExtConstr;
-nEqBarConstr = comlsqr.nEqBarConstr;
-nDegFreedomAtt = comlsqr.nDegFreedomAtt;
-nAttAxes = comlsqr.nAttAxes;
-localAstro = VrIdAstroPDim * nAstroPSolved;
-localAstroMax = VrIdAstroPDimMax * nAstroPSolved;
-numOfExtStar = comlsqr.numOfExtStar;
-numOfBarStar = comlsqr.numOfBarStar;
-nAttP = comlsqr.nAttP;
-numOfExtAttCol = comlsqr.numOfExtAttCol;
-mapNossBefore = comlsqr.mapNossBefore;
-nobs = comlsqr.nobs;
-debugMode = comlsqr.debugMode;
-noCPR = comlsqr.noCPR;
-nElemIC = comlsqr.nElemIC;
-nOfInstrConstr = comlsqr.nOfInstrConstr;
-nInstrPsolved = comlsqr.nInstrPSolved;
-ntasks= comlsqr.ntasks;
-nthreads= comlsqr.nthreads;
-
-    other = (long)nAttParam + nInstrParam + nGlobalParam;
-if (nAstroPSolved)
-    vAuxVect = (double *)calloc(localAstroMax, sizeof(double));
-
-comlsqr.itn = itn;
-totTime = comlsqr.totSec;
-partialTime = comlsqr.totSec;
-
-if (debugMode)
-{
-    for (long i = 0; i < mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr; i++)
-    {
-        printf("PE=%d Knowterms[%d]=%e\n", myid, i, knownTerms[i]);
+myid=comlsqr.myid;
+nproc=comlsqr.nproc;
+mapNcoeff=comlsqr.mapNcoeff;
+mapNoss=comlsqr.mapNoss;
+nAttParam=comlsqr.nAttParam; 
+nInstrParam=comlsqr.nInstrParam; 
+nGlobalParam=comlsqr.nGlobalParam; 
+nunkSplit=comlsqr.nunkSplit;  
+VrIdAstroPDim=comlsqr.VrIdAstroPDim;  
+VrIdAstroPDimMax=comlsqr.VrIdAstroPDimMax; 
+nAstroPSolved=comlsqr.nAstroPSolved;
+nEqExtConstr=comlsqr.nEqExtConstr;
+nEqBarConstr=comlsqr.nEqBarConstr;
+nDegFreedomAtt=comlsqr.nDegFreedomAtt;
+nAttAxes=comlsqr.nAttAxes;
+localAstro= VrIdAstroPDim*nAstroPSolved;  
+localAstroMax=VrIdAstroPDimMax*nAstroPSolved;
+numOfExtStar=comlsqr.numOfExtStar;
+numOfBarStar=comlsqr.numOfBarStar;
+nAttP=comlsqr.nAttP;
+numOfExtAttCol=comlsqr.numOfExtAttCol;
+mapNossBefore=comlsqr.mapNossBefore;
+nobs=comlsqr.nobs;
+debugMode=comlsqr.debugMode;
+noCPR=comlsqr.noCPR;
+nElemIC=comlsqr.nElemIC;
+nOfInstrConstr=comlsqr.nOfInstrConstr;
+nInstrPsolved=comlsqr.nInstrPSolved;
+    
+other=(long)nAttParam + nInstrParam + nGlobalParam; 
+if(nAstroPSolved) vAuxVect=(double *) calloc(localAstroMax,sizeof(double)); 
+
+comlsqr.itn=itn;
+totTime=comlsqr.totSec;
+partialTime=comlsqr.totSec;
+
+    if(debugMode){
+    for(long i=0; i<mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr;i++){
+        printf("PE=%d Knowterms[%d]=%e\n",myid,i,knownTerms[i]);
     }
-    int nStar = comlsqr.nStar;
-    int c1 = 0;
-    int colix = 0;
-    for (int j = 0; j < mapNoss[myid]; j++)
-        for (int i = 0; i < nAstroPSolved + nAttP; i++)
-        {
-            if (i == 0)
-                colix = matrixIndex[j * 2];
-            else if (i == nAstroPSolved)
-                colix = matrixIndex[j * 2 + 1];
-            else if (i == nAstroPSolved + nAttP / nAttAxes)
-                colix = matrixIndex[j * 2 + 1] + nDegFreedomAtt;
-            else if (i == nAstroPSolved + 2 * nAttP / nAttAxes)
-                colix = matrixIndex[j * 2 + 1] + 2 * nDegFreedomAtt;
-            else
-                colix++;
-            printf("PE=%d systemMatrix[%ld][%d]=%f\n", myid, mapNossBefore + j, colix, systemMatrix[c1]);
+    int nStar=comlsqr.nStar;
+    int c1=0;
+    int colix=0;
+    for(int j=0;j<mapNoss[myid];j++)
+        for(int i=0; i<nAstroPSolved+nAttP;i++){
+            if(i==0) colix=matrixIndex[j*2];
+            else if(i==nAstroPSolved) colix=matrixIndex[j*2+1];
+            else if (i==nAstroPSolved+nAttP/nAttAxes) colix=matrixIndex[j*2+1]+nDegFreedomAtt;
+            else if (i==nAstroPSolved+2*nAttP/nAttAxes) colix=matrixIndex[j*2+1]+2*nDegFreedomAtt;
+            else colix++;
+            printf("PE=%d systemMatrix[%ld][%d]=%f\n",myid,mapNossBefore+j,colix,systemMatrix[c1]);
             c1++;
         }
-    for (int k = 0; k < nEqExtConstr; k++)
-        for (int i = 0; i < numOfExtStar * nAstroPSolved + numOfExtAttCol * nAttAxes; i++)
-        {
-            printf("PE=%d systemMatrix[%d][%ld]=%f\n", myid, nobs + k, i - mapNcoeff[myid], systemMatrix[c1]);
-            c1++;
-        }
-    for (int k = 0; k < nEqBarConstr; k++)
-        for (int i = 0; i < numOfBarStar * nAstroPSolved; i++)
-        {
-            printf("PE=%d systemMatrix[%d][%ld]=%f\n", myid, nobs + k, i - mapNcoeff[myid], systemMatrix[c1]);
+    for(int k=0;k<nEqExtConstr;k++)
+        for(int i=0; i<numOfExtStar*nAstroPSolved+numOfExtAttCol*nAttAxes;i++){
+            printf("PE=%d systemMatrix[%d][%ld]=%f\n",myid,nobs+k,i-mapNcoeff[myid],systemMatrix[c1]);
             c1++;
         }
-    int counter = 0;
-    for (int k = 0; k < nOfInstrConstr; k++)
-        for (int j = 0; j < instrConstrIlung[k]; j++)
-        {
-            printf("PE=%d systemMatrix[%d][%ld]=%f\n", myid, nobs + nEqExtConstr + k, instrCol[mapNoss[myid] * nInstrPsolved + counter], systemMatrix[c1]);
-            counter++;
+    for(int k=0;k<nEqBarConstr;k++)
+        for(int i=0; i<numOfBarStar*nAstroPSolved;i++){
+            printf("PE=%d systemMatrix[%d][%ld]=%f\n",myid,nobs+k,i-mapNcoeff[myid],systemMatrix[c1]);
             c1++;
         }
-}
-
-if (myid == 0)
+    int counter=0;
+    for(int k=0;k<nOfInstrConstr;k++)
+        for(int j=0;j<instrConstrIlung[k];j++){
+                printf("PE=%d systemMatrix[%d][%ld]=%f\n",myid,nobs+nEqExtConstr+k,instrCol[mapNoss[myid]*nInstrPsolved+counter],systemMatrix[c1]);
+                counter++;
+                c1++;
+            }
+    }
+    
+if(myid==0)
 {
-    nout = fopen(lsqrOut, "a");
+    nout=fopen(lsqrOut,"a");
     if (nout != NULL)
         fprintf(nout, fmt_1000,
                 enter, m, n, damp, wantse,
                 atol, conlim, btol, itnlim);
-    else
-    {
-        printf("Error while opening %s (1)\n", lsqrOut);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+	else {
+        printf("Error while opening %s (1)\n",lsqrOut);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
-    }
-    fclose(nout);
+	}
+	fclose(nout);
 }
 
-itn = 0;
-istop = 0;
-nstop = 0;
-maxdx = 0;
-ctol = ZERO;
-if (conlim > ZERO)
-    ctol = ONE / conlim;
-anorm = ZERO;
-acond = ZERO;
-dnorm = ZERO;
-dxmax = ZERO;
-res2 = ZERO;
-psi = ZERO;
-xnorm = ZERO;
-xnorm1 = ZERO;
-cs2 = -ONE;
-sn2 = ZERO;
-z = ZERO;
-
-CPRCount = 0;
+itn    =   0;
+istop  =   0;
+nstop  =   0;
+maxdx  =   0;
+ctol   =   ZERO;
+if (conlim > ZERO) ctol = ONE / conlim;
+anorm  =   ZERO;
+acond  =   ZERO;
+dnorm  =   ZERO;
+dxmax  =   ZERO;
+res2   =   ZERO;
+psi    =   ZERO;
+xnorm  =   ZERO;
+xnorm1 =   ZERO;
+cs2    = - ONE;
+sn2    =   ZERO;
+z      =   ZERO;
+ 	
+CPRCount=0;
 //  ------------------------------------------------------------------
 //  Set up the first vectors u and v for the bidiagonalization.
 //  These satisfy  beta*u = b,  alpha*v = A(transpose)*u.
 //  ------------------------------------------------------------------
-dload(nunkSplit, 0.0, vVect);
-dload(nunkSplit, 0.0, xSolution);
-if (wantse)
-    dload(nunkSplit, 0.0, standardError);
-alpha = ZERO;
+dload( nunkSplit, 0.0, vVect );
+dload( nunkSplit, 0.0, xSolution );
+if ( wantse )
+        dload( nunkSplit, 0.0, standardError );
+alpha  =   ZERO;
 // Find the maximum value on u
-double betaLoc;
-if (myid == 0)
-    betaLoc = cblas_dnrm2(mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr, knownTerms, 1);
-else
-    betaLoc = cblas_dnrm2(mapNoss[myid], knownTerms, 1);
+    double betaLoc;
+    if(myid==0)  betaLoc=cblas_dnrm2(mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr,knownTerms,1);
+    else betaLoc=cblas_dnrm2(mapNoss[myid],knownTerms,1);
 
-double betaLoc2 = betaLoc * betaLoc;
+double betaLoc2=betaLoc*betaLoc;
 double betaGlob;
-MPI_Allreduce(&betaLoc2, &betaGlob, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-beta = sqrt(betaGlob);
-if (beta > ZERO)
+MPI_Allreduce(&betaLoc2, &betaGlob,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+beta=sqrt(betaGlob);
+if (beta > ZERO) 
 {
-    cblas_dscal(mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr, (ONE / beta), knownTerms, 1);
-    MPI_Barrier(MPI_COMM_WORLD);
+    cblas_dscal ( mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr, (ONE / beta), knownTerms, 1 );
+    MPI_Barrier(MPI_COMM_WORLD);   
 //only processor 0 accumulate and distribute the v array
-////
-    
-    // FV EDIT 
-    //#pragma omp for
-    for (i = 0; i < localAstroMax; i++)
-    {
-        vAuxVect[i] = vVect[i];
-        vVect[i] = 0;
-    }
-    if (myid != 0)
+#pragma omp for
+    for(i=0;i<localAstroMax;i++) 
     {
-        // FV EDIT 
-        //#pragma omp for
-        for (i = localAstroMax; i < nunkSplit; i++)
-            vVect[i] = 0;
-    }
-    aprod(2, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol, instrConstrIlung, comlsqr, &ompSec);
-
-    MPI_Barrier(MPI_COMM_WORLD);
+     	vAuxVect[i]=vVect[i];
+       	vVect[i]=0;
+	}
+	if(myid!=0)
+	{
+#pragma omp for
+	    for(i=localAstroMax;i<nunkSplit;i++) vVect[i]=0;
+	}
+    aprod ( 2, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol,instrConstrIlung,comlsqr,&ompSec );
+
+	MPI_Barrier(MPI_COMM_WORLD);
 
     double *dcopy;
-    dcopy = (double *)calloc(comlsqr.nAttParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-    mpi_allreduce(&vVect[localAstroMax], dcopy, (long int)comlsqr.nAttParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    // FV EDIT 
-    //#pragma omp for
-    for (i = 0; i < comlsqr.nAttParam; i++)
+    dcopy=(double *)calloc(comlsqr.nAttParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    	mpi_allreduce(&vVect[localAstroMax],dcopy,(long int) comlsqr.nAttParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+#pragma omp for
+    for(i=0;i<comlsqr.nAttParam;i++) 
     {
-        vVect[localAstroMax + i] = dcopy[i];
-    }
-    free(dcopy);
-    dcopy = (double *)calloc(comlsqr.nInstrParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-
-    mpi_allreduce(&vVect[localAstroMax + comlsqr.nAttParam], dcopy, (long int)comlsqr.nInstrParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    // FV EDIT 
-    //#pragma omp for
-    for (i = 0; i < comlsqr.nInstrParam; i++)
+		vVect[localAstroMax+i]=dcopy[i];
+	}
+	free(dcopy);
+    dcopy=(double *)calloc(comlsqr.nInstrParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+
+    mpi_allreduce(&vVect[localAstroMax+comlsqr.nAttParam],dcopy,(long int) comlsqr.nInstrParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+#pragma omp for
+    for(i=0;i<comlsqr.nInstrParam;i++) 
     {
-        vVect[localAstroMax + comlsqr.nAttParam + i] = dcopy[i];
-    }
-    free(dcopy);
-    dcopy = (double *)calloc(comlsqr.nGlobalParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-    MPI_Allreduce(&vVect[localAstroMax + comlsqr.nAttParam + comlsqr.nInstrParam], dcopy, (int)comlsqr.nGlobalParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    // FV EDIT 
-    //#pragma omp for
-    for (i = 0; i < comlsqr.nGlobalParam; i++)
+		vVect[localAstroMax+comlsqr.nAttParam+i]=dcopy[i];
+	}
+	free(dcopy);
+    dcopy=(double *)calloc(comlsqr.nGlobalParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    MPI_Allreduce(&vVect[localAstroMax+comlsqr.nAttParam+comlsqr.nInstrParam],dcopy,(int) comlsqr.nGlobalParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+#pragma omp for
+    for(i=0;i<comlsqr.nGlobalParam;i++) 
     {
-        vVect[localAstroMax + comlsqr.nAttParam + comlsqr.nInstrParam + i] = dcopy[i];
-    }
-    free(dcopy);
-    if (nAstroPSolved)
-        SumCirc(vVect, comlsqr);
-    // FV EDIT 
-    //#pragma omp for
-    for (i = 0; i < localAstro; i++)
-    {
-        vVect[i] += vAuxVect[i];
-    }
-
-    nAstroElements = comlsqr.mapStar[myid][1] - comlsqr.mapStar[myid][0] + 1;
-    if (myid < nproc - 1)
+		vVect[localAstroMax+comlsqr.nAttParam+comlsqr.nInstrParam+i]=dcopy[i];
+	}
+	free(dcopy);
+	if(nAstroPSolved) SumCirc(vVect,comlsqr);
+#pragma omp for
+    for(i=0;i<localAstro;i++) 
     {
-        nAstroElements = comlsqr.mapStar[myid][1] - comlsqr.mapStar[myid][0] + 1;
-        if (comlsqr.mapStar[myid][1] == comlsqr.mapStar[myid + 1][0])
-            nAstroElements--;
-    }
-
-    double alphaLoc = 0;
-    if (nAstroPSolved)
-        alphaLoc = cblas_dnrm2(nAstroElements * comlsqr.nAstroPSolved, vVect, 1);
-    double alphaLoc2 = alphaLoc * alphaLoc;
-    if (myid == 0)
+        	vVect[i]+=vAuxVect[i];
+	}
+
+
+
+
+    nAstroElements=comlsqr.mapStar[myid][1]-comlsqr.mapStar[myid][0] +1;
+ 	if(myid<nproc-1)
+ 	{
+ 		nAstroElements=comlsqr.mapStar[myid][1]-comlsqr.mapStar[myid][0] +1;
+ 		if(comlsqr.mapStar[myid][1]==comlsqr.mapStar[myid+1][0]) nAstroElements--;
+ 	}	
+ 
+ 
+    double alphaLoc=0;
+    if(nAstroPSolved) alphaLoc=cblas_dnrm2(nAstroElements*comlsqr.nAstroPSolved,vVect,1);
+	double alphaLoc2=alphaLoc*alphaLoc;
+	if(myid==0) {
+		double alphaOther=cblas_dnrm2(comlsqr.nunkSplit-localAstroMax,&vVect[localAstroMax],1);
+		double alphaOther2=alphaOther*alphaOther;
+		alphaLoc2=alphaLoc2+alphaOther2;
+	}
+	double alphaGlob2=0;
+	MPI_Allreduce(&alphaLoc2, &alphaGlob2,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+	alpha=sqrt(alphaGlob2);
+
+   }
+
+    if (alpha > ZERO) 
     {
-        double alphaOther = cblas_dnrm2(comlsqr.nunkSplit - localAstroMax, &vVect[localAstroMax], 1);
-        double alphaOther2 = alphaOther * alphaOther;
-        alphaLoc2 = alphaLoc2 + alphaOther2;
+        cblas_dscal ( nunkSplit, (ONE / alpha), vVect, 1 );
+        cblas_dcopy ( nunkSplit, vVect, 1, wVect, 1 );
     }
-    double alphaGlob2 = 0;
-    MPI_Allreduce(&alphaLoc2, &alphaGlob2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    alpha = sqrt(alphaGlob2);
-}
-
-if (alpha > ZERO)
-{
-    cblas_dscal(nunkSplit, (ONE / alpha), vVect, 1);
-    cblas_dcopy(nunkSplit, vVect, 1, wVect, 1);
-}
 //	printf("LSQR T4: PE=%d alpha=%15.12lf beta=%15.12lf arnorm=%15.12lf\n",myid,alpha,beta,arnorm);
 
-arnorm = alpha * beta;
-arnorm0 = arnorm;
+    arnorm  = alpha * beta;
+    arnorm0 = arnorm;
 //	printf("LSQR T5: PE=%d alpha=%15.12lf beta=%15.12lf arnorm=%15.12lf\n",myid,alpha,beta,arnorm);
 
-if (arnorm == ZERO)
-    goto goto_800;
-rhobar = alpha;
-phibar = beta;
-bnorm = beta;
-rnorm = beta;
+    if (arnorm == ZERO) goto goto_800;
+    rhobar =   alpha;
+    phibar =   beta;
+    bnorm  =   beta;
+    rnorm  =   beta;
 
-if (myid == 0)
-{
-    nout = fopen(lsqrOut, "a");
-    if (nout != NULL)
-    {
-        if (damped)
-            fprintf(nout, fmt_1300);
-        else
-            fprintf(nout, fmt_1200);
-    }
-    else
+    if (myid==0)
     {
-        printf("Error while opening %s (2)\n", lsqrOut);
-        MPI_Abort(MPI_COMM_WORLD, 1);
-        exit(EXIT_FAILURE);
+		nout=fopen(lsqrOut,"a");
+		if ( nout != NULL) {
+			if ( damped )
+				fprintf(nout, fmt_1300);
+			else
+				fprintf(nout, fmt_1200);
+		} else {
+			printf("Error while opening %s (2)\n",lsqrOut);
+			MPI_Abort(MPI_COMM_WORLD,1);
+			exit(EXIT_FAILURE);
+		}
+
+        test1  = ONE;
+        test2  = alpha / beta;
+        
+        if ( extra )
+            fprintf(nout, fmt_1400);
+
+        fprintf(nout, fmt_1550, itn, xSolution[0], rnorm, test1, test2);
+        fprintf(nout, fmt_1600);
+		fclose(nout);
     }
 
-    test1 = ONE;
-    test2 = alpha / beta;
-
-    if (extra)
-        fprintf(nout, fmt_1400);
-
-    fprintf(nout, fmt_1550, itn, xSolution[0], rnorm, test1, test2);
-    fprintf(nout, fmt_1600);
-    fclose(nout);
-}
-
 //  ==================================================================
 //  CheckPointRestart
 //  ==================================================================
-
-if (!noCPR)
-    if (myid == 0)
-        printf("PE=%d  call restart setup\n", myid);
-restartSetup(&itn,
-             knownTerms,
-             &beta,
-             &alpha,
-             vVect,
-             &anorm,
-             &rhobar,
-             &phibar,
-             wVect,
-             xSolution,
-             standardError,
-             &dnorm,
-             &sn2,
-             &cs2,
-             &z,
-             &xnorm1,
-             &res2,
-             &nstop,
-             comlsqr);
-if (myid == 0)
-    printf("PE=%d  end restart setup\n", myid);
+ 
+	if(!noCPR)
+	if(myid==0) printf("PE=%d  call restart setup\n",myid);
+        restartSetup( &itn,
+				 knownTerms,
+				 &beta,
+				 &alpha,
+				 vVect, 
+				 &anorm,
+				 &rhobar,
+				 &phibar,
+				 wVect,
+				 xSolution,
+				 standardError,
+				 &dnorm,
+				 &sn2,
+				 &cs2,
+				 &z,
+				 &xnorm1,
+				 &res2,
+				 &nstop,
+				 comlsqr);
+	if(myid==0) printf("PE=%d  end restart setup\n",myid);
 
 //  ==================================================================
 //  Main iteration loop.
 //  ==================================================================
-if (myid == 0)
-{
-    startCycleTime = time(NULL);
-}
-////////////////////////  START ITERATIONS
-while (1)
-{
-    writeCPR = 0; // No write CPR
-    cycleStartMpiTime = MPI_Wtime();
-    itnTest = -1;
-    if (myid == 0)
-    {
-        fpItnLimitNew = NULL;
-        fpItnLimitNew = fopen("ITNLIMIT_NEW", "r");
-        if (fpItnLimitNew != NULL)
-        {
-            fscanf(fpItnLimitNew, "%d\n", &itnTest);
-            if (itnTest > 0)
+		if(myid==0)
+		{ 
+			startCycleTime=time(NULL);
+		}
+////////////////////////  START ITERATIONS		
+    while (1) {   
+		writeCPR=0;  // No write CPR
+        cycleStartMpiTime=MPI_Wtime();
+        itnTest=-1;
+        if(myid==0){
+          fpItnLimitNew=NULL;
+          fpItnLimitNew=fopen("ITNLIMIT_NEW","r");
+          if (fpItnLimitNew!=NULL)
+          {
+            fscanf(fpItnLimitNew, "%d\n",&itnTest);
+            if(itnTest>0)
             {
-                comlsqr.itnLimit = itnTest;
-                if (itnlim != itnTest)
-                {
-                    itnlim = itnTest;
-                    if (myid == 0)
-                        printf("itnLimit forced with ITNLIMIT_NEW file to value %d\n", itnlim);
+                comlsqr.itnLimit=itnTest;
+                if(itnlim != itnTest){
+                    itnlim=itnTest;
+                    if(myid==0) printf("itnLimit forced with ITNLIMIT_NEW file to value %d\n",itnlim);
                 }
             }
             fclose(fpItnLimitNew);
+          }
         }
-    }
-
-    if (myid == 0)
-    {
-        endCycleTime = time(NULL) - startCycleTime;
-        startCycleTime = time(NULL);
-        totTime = totTime + endCycleTime;
-        partialTime = partialTime + endCycleTime;
-        if (!noCPR)
+        
+        if(myid==0)
         {
-
-            if (partialTime > comlsqr.timeCPR * 60)
+			endCycleTime=time(NULL)-startCycleTime;
+			startCycleTime=time(NULL);
+			totTime=totTime+endCycleTime;
+			partialTime=partialTime+endCycleTime;
+            if(!noCPR){
+
+			if(partialTime>comlsqr.timeCPR*60)
+			{
+				writeCPR=1;
+				partialTime=0;
+			}
+			if(totTime+endCycleTime*2>comlsqr.timeLimit*60) writeCPR=2;
+			
+			if(CPRCount>0 && CPRCount%comlsqr.itnCPR==0) writeCPR=1;
+			if(CPRCount>0 && CPRCount==comlsqr.itnCPRstop) writeCPR=2;
+			if(CPRCount==itnlim) writeCPR=2;
+            fpCPRend=NULL;
+            fpCPRend=fopen("CPR_END","r");
+            if (fpCPRend!=NULL)
             {
-                writeCPR = 1;
-                partialTime = 0;
-            }
-            if (totTime + endCycleTime * 2 > comlsqr.timeLimit * 60)
-                writeCPR = 2;
-
-            if (CPRCount > 0 && CPRCount % comlsqr.itnCPR == 0)
-                writeCPR = 1;
-            if (CPRCount > 0 && CPRCount == comlsqr.itnCPRstop)
-                writeCPR = 2;
-            if (CPRCount == itnlim)
-                writeCPR = 2;
-            fpCPRend = NULL;
-            fpCPRend = fopen("CPR_END", "r");
-            if (fpCPRend != NULL)
-            {
-                itnTest = -1;
-                fscanf(fpCPRend, "%d\n", &itnTest);
-                if (itnTest > 0)
+                itnTest=-1;
+                fscanf(fpCPRend, "%d\n",&itnTest);
+                if(itnTest>0)
                 {
-                    if (comlsqr.itnCPRend != itnTest)
-                    {
-                        comlsqr.itnCPRend = itnTest;
-                        printf("itnCPRend forced with CPR_END file to value %d\n", comlsqr.itnCPRend);
+                    if(comlsqr.itnCPRend != itnTest){
+                        comlsqr.itnCPRend=itnTest;
+                        printf("itnCPRend forced with CPR_END file to value %d\n",comlsqr.itnCPRend);
                     }
                 }
                 fclose(fpCPRend);
             }
-            if (comlsqr.itnCPRend > 0 && comlsqr.itnCPRend <= itn)
+            if(comlsqr.itnCPRend>0 && comlsqr.itnCPRend<=itn)
             {
-                writeCPR = 2;
-                printf("itnCPRend condition triggered  to value %d. writeCPR set to 2.\n", comlsqr.itnCPRend);
+                writeCPR=2;
+                printf("itnCPRend condition triggered  to value %d. writeCPR set to 2.\n",comlsqr.itnCPRend);
             }
-        } //if(!noCPR)
-    }     //if(myid==0)
-    MPI_Barrier(MPI_COMM_WORLD);
-    MPI_Bcast(&writeCPR, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&itnlim, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&comlsqr.itnLimit, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    if (myid == 0)
-    {
-        printf("lsqr: Iteration number %d. Iteration seconds %ld. OmpSec %d Global Seconds %ld \n", itn, endCycleTime, ompSec, totTime);
-        if (writeCPR == 1)
-            printf("... writing CPR files\n");
-        if (writeCPR == 2)
-            printf("... writing CPR files and return\n");
-    }
-
-    if (writeCPR > 0)
-    {
-        if (myid == 0)
-            CPRtimeStart = time(NULL);
-        writeCheckPoint(itn,
-                        knownTerms,
-                        beta,
-                        alpha,
-                        vVect,
-                        anorm,
-                        rhobar,
-                        phibar,
-                        wVect,
-                        xSolution,
-                        standardError,
-                        dnorm,
-                        sn2,
-                        cs2,
-                        z,
-                        xnorm1,
-                        res2,
-                        nstop,
-                        comlsqr);
-
-        if (myid == 0)
-        {
-            CPRtimeEnd = time(NULL) - CPRtimeStart;
-            totTime += CPRtimeEnd;
-            partialTime += CPRtimeEnd;
-            printf("CPR: itn=%d writing CPR seconds %ld. Global Seconds %ld \n", itn, CPRtimeEnd, totTime);
+		    }//if(!noCPR)
+          }//if(myid==0)
+		  MPI_Barrier(MPI_COMM_WORLD);
+		  MPI_Bcast( &writeCPR, 1, MPI_INT, 0, MPI_COMM_WORLD);
+          MPI_Bcast( &itnlim, 1, MPI_INT, 0, MPI_COMM_WORLD);
+          MPI_Bcast( &comlsqr.itnLimit, 1, MPI_INT, 0, MPI_COMM_WORLD);
+          if(myid==0)
+          {
+        	printf("lsqr: Iteration number %d. Iteration seconds %ld. OmpSec %d Global Seconds %ld \n",itn,endCycleTime,ompSec,totTime);
+        	if(writeCPR==1) printf("... writing CPR files\n");
+        	if(writeCPR==2) printf("... writing CPR files and return\n");
+          }
+
+
+          if(writeCPR>0)
+          {
+            if(myid==0)
+                CPRtimeStart=time(NULL);
+          writeCheckPoint(itn, 
+				knownTerms,
+				beta,
+				alpha,
+				vVect, 
+				anorm,
+				rhobar,
+				phibar,
+				wVect,
+				xSolution,
+				standardError,
+				dnorm,
+				sn2,
+				cs2,
+				z,
+				xnorm1,
+				res2,
+				nstop,
+				comlsqr);
+            
+                if(myid==0){
+                    CPRtimeEnd=time(NULL)-CPRtimeStart;
+                    totTime+=CPRtimeEnd;
+                    partialTime+=CPRtimeEnd;
+                    printf("CPR: itn=%d writing CPR seconds %ld. Global Seconds %ld \n",itn,CPRtimeEnd, totTime);
+                }
+            
+				if(writeCPR==2)
+				{
+				    *istop_out  = 1000;
+    				 *itn_out    = itn;
+    				 if(nAstroPSolved) free(vAuxVect);
+     				 return;
+				}
+		if(myid==0) startCycleTime=time(NULL); 
         }
 
-        if (writeCPR == 2)
+          itn    = itn + 1;
+          comlsqr.itn=itn;
+          CPRCount++;
+//      ------------------------------------------------------------------
+//      Perform the next step of the bidiagonalization to obtain the
+//      next  beta, u, alpha, v.  These satisfy the relations
+//                 beta*u  =  A*v  -  alpha*u,
+//                alpha*v  =  A(transpose)*u  -  beta*v.
+//      ------------------------------------------------------------------
+        cblas_dscal ( mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr, (- alpha), knownTerms, 1 );
+        kAuxcopy=(double *) calloc(nEqExtConstr+nEqBarConstr+nOfInstrConstr, sizeof(double));
+        for (int kk=0;kk<nEqExtConstr+nEqBarConstr+nOfInstrConstr;kk++){
+            kAuxcopy[kk]=knownTerms[mapNoss[myid]+kk];
+            knownTerms[mapNoss[myid]+kk]=0.;
+        }
+        aprod ( 1, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol,instrConstrIlung, comlsqr,&ompSec );
+        kcopy=(double *) calloc(nEqExtConstr+nEqBarConstr+nOfInstrConstr, sizeof(double));
+        MPI_Allreduce(&knownTerms[mapNoss[myid]],kcopy,nEqExtConstr+nEqBarConstr+nOfInstrConstr,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+        for(i=0;i<nEqExtConstr+nEqBarConstr+nOfInstrConstr;i++)
         {
-            *istop_out = 1000;
-            *itn_out = itn;
-            if (nAstroPSolved)
-                free(vAuxVect);
-            return;
+            knownTerms[mapNoss[myid]+i]=kcopy[i]+kAuxcopy[i];
         }
-        if (myid == 0)
-            startCycleTime = time(NULL);
-    }
+        free(kAuxcopy);
+        free(kcopy);
+// 	beta   =   cblas_dnrm2 ( m, u, 1 );
 
-    itn = itn + 1;
-    comlsqr.itn = itn;
-    CPRCount++;
-    //      ------------------------------------------------------------------
-    //      Perform the next step of the bidiagonalization to obtain the
-    //      next  beta, u, alpha, v.  These satisfy the relations
-    //                 beta*u  =  A*v  -  alpha*u,
-    //                alpha*v  =  A(transpose)*u  -  beta*v.
-    //      ------------------------------------------------------------------
-    cblas_dscal(mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr, (-alpha), knownTerms, 1);
-    kAuxcopy = (double *)calloc(nEqExtConstr + nEqBarConstr + nOfInstrConstr, sizeof(double));
-    for (int kk = 0; kk < nEqExtConstr + nEqBarConstr + nOfInstrConstr; kk++)
-    {
-        kAuxcopy[kk] = knownTerms[mapNoss[myid] + kk];
-        knownTerms[mapNoss[myid] + kk] = 0.;
-    }
-    aprod(1, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol, instrConstrIlung, comlsqr, &ompSec);
-    kcopy = (double *)calloc(nEqExtConstr + nEqBarConstr + nOfInstrConstr, sizeof(double));
-    MPI_Allreduce(&knownTerms[mapNoss[myid]], kcopy, nEqExtConstr + nEqBarConstr + nOfInstrConstr, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    for (i = 0; i < nEqExtConstr + nEqBarConstr + nOfInstrConstr; i++)
-    {
-        knownTerms[mapNoss[myid] + i] = kcopy[i] + kAuxcopy[i];
-    }
-    free(kAuxcopy);
-    free(kcopy);
-    // 	beta   =   cblas_dnrm2 ( m, u, 1 );
 
-    if (myid == 0)
-        betaLoc = cblas_dnrm2(mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr, knownTerms, 1);
-    else
-        betaLoc = cblas_dnrm2(mapNoss[myid], knownTerms, 1);
-    betaLoc2 = betaLoc * betaLoc;
-    MPI_Allreduce(&betaLoc2, &betaGlob, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    beta = sqrt(betaGlob);
+        if(myid==0)  betaLoc=cblas_dnrm2(mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr,knownTerms,1);
+        else betaLoc=cblas_dnrm2(mapNoss[myid],knownTerms,1);
+	betaLoc2=betaLoc*betaLoc;
+	MPI_Allreduce(&betaLoc2, &betaGlob,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+	beta=sqrt(betaGlob);
 
-    //	printf("LSQR TP8 PE=%d itn=%d: alpha=%15.12lf beta=%15.12lf\n",myid,itn,alpha,beta);
+//	printf("LSQR TP8 PE=%d itn=%d: alpha=%15.12lf beta=%15.12lf\n",myid,itn,alpha,beta);
 
-    //      Accumulate  anorm = || Bk ||
-    //                        =  sqrt( sum of  alpha**2 + beta**2 + damp**2 ).
 
-    temp = d2norm(alpha, beta);
-    temp = d2norm(temp, damp);
-    anorm = d2norm(anorm, temp);
+//      Accumulate  anorm = || Bk ||
+//                        =  sqrt( sum of  alpha**2 + beta**2 + damp**2 ).
 
-    if (beta > ZERO)
-    {
-        cblas_dscal(mapNoss[myid] + nEqExtConstr + nEqBarConstr + nOfInstrConstr, (ONE / beta), knownTerms, 1);
-        cblas_dscal(nunkSplit, (-beta), vVect, 1);
-//only processor 0 accumulate and distribute the v array
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < localAstroMax; i++)
-        {
-            vAuxVect[i] = vVect[i];
-            vVect[i] = 0;
-        }
-        if (myid != 0)
-        {
-            // FV EDIT 
-            //#pragma omp for
-            for (i = localAstroMax; i < nunkSplit; i++)
-                vVect[i] = 0;
-        }
+        temp   =   d2norm( alpha, beta );
+        temp   =   d2norm( temp , damp );
+        anorm  =   d2norm( anorm, temp );
 
-        aprod(2, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol, instrConstrIlung, comlsqr, &ompSec);
-        MPI_Barrier(MPI_COMM_WORLD);
+        if (beta > ZERO) {
+            cblas_dscal ( mapNoss[myid]+nEqExtConstr+nEqBarConstr+nOfInstrConstr, (ONE / beta), knownTerms, 1 );
+            cblas_dscal ( nunkSplit, (- beta), vVect, 1 );
+//only processor 0 accumulate and distribute the v array
+#pragma omp for
+        for(i=0;i<localAstroMax;i++) {
+        	vAuxVect[i]=vVect[i];
+        	vVect[i]=0;
+		 }
+	    if(myid!=0) 
+	    {
+#pragma omp for
+	    	for(i=localAstroMax;i<nunkSplit;i++) 
+	      		vVect[i]=0;	
+		}
+ 	    
+        aprod ( 2, m, n, vVect, knownTerms, systemMatrix, matrixIndex, instrCol, instrConstrIlung, comlsqr,&ompSec);
+	    MPI_Barrier(MPI_COMM_WORLD);
+
+
+//////////////// TEST vVect
+/*
+if(nproc==2)
+{
+	printf("LSQR TP9 PE=%d itn=%d VrIdAstroPDim=%ld vVect[0-5]=%lf %lf %lf %lf %lf VrIdAstroPDim/2*5=%ld  vVect[..+4]=%lf %lf %lf %lf %lf VrIdAstroPDim-1*5=%ld  vVect[...+5]=%lf %lf %lf %lf %lf\n",myid,itn,VrIdAstroPDim,vVect[0],vVect[1],vVect[2],vVect[3],vVect[4],(VrIdAstroPDim/2)*5,vVect[(VrIdAstroPDim/2)*5],vVect[(VrIdAstroPDim/2)*5+1],vVect[(VrIdAstroPDim/2)*5+2],vVect[(VrIdAstroPDim/2)*5+3],vVect[(VrIdAstroPDim/2)*5+4],(VrIdAstroPDim-1)*5,vVect[(VrIdAstroPDim-1)*5],vVect[(VrIdAstroPDim-1)*5+1],vVect[(VrIdAstroPDim-1)*5+2],vVect[(VrIdAstroPDim-1)*5+3],vVect[(VrIdAstroPDim-1)*5+4]);
+}
+if(nproc==1)
+{
+	printf("LSQR TP9 PE=%d itn=%d VrIdAstroPDim=%ld vVect[0-5]=%lf %lf %lf %lf %lf VrIdAstroPDim/2*5=%ld  vVect[..+4]=%lf %lf %lf %lf %lf VrIdAstroPDim-1*5=%ld  vVect[...+5]=%lf %lf %lf %lf %lf\n",myid,itn,VrIdAstroPDim,vVect[0],vVect[1],vVect[2],vVect[3],vVect[4],(VrIdAstroPDim/2)*5,vVect[(VrIdAstroPDim/2)*5],vVect[(VrIdAstroPDim/2)*5+1],vVect[(VrIdAstroPDim/2)*5+2],vVect[(VrIdAstroPDim/2)*5+3],vVect[(VrIdAstroPDim/2)*5+4],(VrIdAstroPDim-1)*5,vVect[(VrIdAstroPDim-1)*5],vVect[(VrIdAstroPDim-1)*5+1],vVect[(VrIdAstroPDim-1)*5+2],vVect[(VrIdAstroPDim-1)*5+3],vVect[(VrIdAstroPDim-1)*5+4]);
+}
+*/
+//////////////////////////	    
+	    
 
-        //////////////// TEST vVect
-        /*
-        if(nproc==2)
-        {
-            printf("LSQR TP9 PE=%d itn=%d VrIdAstroPDim=%ld vVect[0-5]=%lf %lf %lf %lf %lf VrIdAstroPDim/2*5=%ld  vVect[..+4]=%lf %lf %lf %lf %lf VrIdAstroPDim-1*5=%ld  vVect[...+5]=%lf %lf %lf %lf %lf\n",myid,itn,VrIdAstroPDim,vVect[0],vVect[1],vVect[2],vVect[3],vVect[4],(VrIdAstroPDim/2)*5,vVect[(VrIdAstroPDim/2)*5],vVect[(VrIdAstroPDim/2)*5+1],vVect[(VrIdAstroPDim/2)*5+2],vVect[(VrIdAstroPDim/2)*5+3],vVect[(VrIdAstroPDim/2)*5+4],(VrIdAstroPDim-1)*5,vVect[(VrIdAstroPDim-1)*5],vVect[(VrIdAstroPDim-1)*5+1],vVect[(VrIdAstroPDim-1)*5+2],vVect[(VrIdAstroPDim-1)*5+3],vVect[(VrIdAstroPDim-1)*5+4]);
-        }
-        if(nproc==1)
-        {
-            printf("LSQR TP9 PE=%d itn=%d VrIdAstroPDim=%ld vVect[0-5]=%lf %lf %lf %lf %lf VrIdAstroPDim/2*5=%ld  vVect[..+4]=%lf %lf %lf %lf %lf VrIdAstroPDim-1*5=%ld  vVect[...+5]=%lf %lf %lf %lf %lf\n",myid,itn,VrIdAstroPDim,vVect[0],vVect[1],vVect[2],vVect[3],vVect[4],(VrIdAstroPDim/2)*5,vVect[(VrIdAstroPDim/2)*5],vVect[(VrIdAstroPDim/2)*5+1],vVect[(VrIdAstroPDim/2)*5+2],vVect[(VrIdAstroPDim/2)*5+3],vVect[(VrIdAstroPDim/2)*5+4],(VrIdAstroPDim-1)*5,vVect[(VrIdAstroPDim-1)*5],vVect[(VrIdAstroPDim-1)*5+1],vVect[(VrIdAstroPDim-1)*5+2],vVect[(VrIdAstroPDim-1)*5+3],vVect[(VrIdAstroPDim-1)*5+4]);
-        }
-        */
-        //////////////////////////
-
-        double *dcopy;
-        dcopy = (double *)calloc(comlsqr.nAttParam, sizeof(double));
-        if (!dcopy)
-            exit(err_malloc("dcopy", myid));
-        mpi_allreduce(&vVect[localAstroMax], dcopy, (long int)comlsqr.nAttParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < comlsqr.nAttParam; i++)
-        {
-            vVect[localAstroMax + i] = dcopy[i];
-        }
-        free(dcopy);
-        dcopy = (double *)calloc(comlsqr.nInstrParam, sizeof(double));
-        if (!dcopy)
-            exit(err_malloc("dcopy", myid));
-        mpi_allreduce(&vVect[localAstroMax + comlsqr.nAttParam], dcopy, (long int)comlsqr.nInstrParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < comlsqr.nInstrParam; i++)
-        {
-            vVect[localAstroMax + comlsqr.nAttParam + i] = dcopy[i];
-        }
-        free(dcopy);
-        dcopy = (double *)calloc(comlsqr.nGlobalParam, sizeof(double));
-        if (!dcopy)
-            exit(err_malloc("dcopy", myid));
-        mpi_allreduce(&vVect[localAstroMax + comlsqr.nAttParam + comlsqr.nInstrParam], dcopy, (long int)comlsqr.nGlobalParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-        for (i = 0; i < comlsqr.nGlobalParam; i++)
-        {
-            vVect[localAstroMax + comlsqr.nAttParam + comlsqr.nInstrParam + i] = dcopy[i];
-        }
-        free(dcopy);
-        if (nAstroPSolved)
-            SumCirc(vVect, comlsqr);
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < localAstroMax; i++)
-        {
-            vVect[i] += vAuxVect[i];
+    double *dcopy;
+    dcopy=(double *)calloc(comlsqr.nAttParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    mpi_allreduce(&vVect[localAstroMax],dcopy,(long int) comlsqr.nAttParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+#pragma omp for
+    for(i=0;i<comlsqr.nAttParam;i++) 
+    {
+		vVect[localAstroMax+i]=dcopy[i];
+	}
+	free(dcopy);
+    dcopy=(double *)calloc(comlsqr.nInstrParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    mpi_allreduce(&vVect[localAstroMax+comlsqr.nAttParam],dcopy,(long int) comlsqr.nInstrParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+#pragma omp for
+    for(i=0;i<comlsqr.nInstrParam;i++) 
+    {
+		vVect[localAstroMax+comlsqr.nAttParam+i]=dcopy[i];
+	}
+	free(dcopy);
+    dcopy=(double *)calloc(comlsqr.nGlobalParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    mpi_allreduce(&vVect[localAstroMax+comlsqr.nAttParam+comlsqr.nInstrParam],dcopy,(long int) comlsqr.nGlobalParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD); 
+    for(i=0;i<comlsqr.nGlobalParam;i++) 
+    {
+		vVect[localAstroMax+comlsqr.nAttParam+comlsqr.nInstrParam+i]=dcopy[i];
+	}
+	free(dcopy);
+	if(nAstroPSolved) SumCirc(vVect,comlsqr);
+#pragma omp for
+    for(i=0;i<localAstroMax;i++) {
+        	vVect[i]+=vAuxVect[i];
+		}
+
+    double alphaLoc=0;
+    if(nAstroPSolved) alphaLoc=cblas_dnrm2(nAstroElements*comlsqr.nAstroPSolved,vVect,1);
+	double alphaLoc2=alphaLoc*alphaLoc;
+	if(myid==0) {
+		double alphaOther=cblas_dnrm2(comlsqr.nunkSplit-localAstroMax,&vVect[localAstroMax],1);
+		double alphaOther2=alphaOther*alphaOther;
+		alphaLoc2=alphaLoc2+alphaOther2;
+	}
+	double alphaGlob2=0;
+	MPI_Allreduce(&alphaLoc2, &alphaGlob2,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+
+	alpha=sqrt(alphaGlob2);
+            if (alpha > ZERO) {
+                cblas_dscal ( nunkSplit, (ONE / alpha), vVect, 1 );
+            }
         }
 
-        double alphaLoc = 0;
-        if (nAstroPSolved)
-            alphaLoc = cblas_dnrm2(nAstroElements * comlsqr.nAstroPSolved, vVect, 1);
-        double alphaLoc2 = alphaLoc * alphaLoc;
-        if (myid == 0)
-        {
-            double alphaOther = cblas_dnrm2(comlsqr.nunkSplit - localAstroMax, &vVect[localAstroMax], 1);
-            double alphaOther2 = alphaOther * alphaOther;
-            alphaLoc2 = alphaLoc2 + alphaOther2;
+//      ------------------------------------------------------------------
+//      Use a plane rotation to eliminate the damping parameter.
+//      This alters the diagonal (rhobar) of the lower-bidiagonal matrix.
+//      ------------------------------------------------------------------
+        rhbar1 = rhobar;
+        if ( damped ) {
+            rhbar1 = d2norm( rhobar, damp );
+            cs1    = rhobar / rhbar1;
+            sn1    = damp   / rhbar1;
+            psi    = sn1 * phibar;
+            phibar = cs1 * phibar;
         }
-        double alphaGlob2 = 0;
-        MPI_Allreduce(&alphaLoc2, &alphaGlob2, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
 
-        alpha = sqrt(alphaGlob2);
-        if (alpha > ZERO)
-        {
-            cblas_dscal(nunkSplit, (ONE / alpha), vVect, 1);
+//      ------------------------------------------------------------------
+//      Use a plane rotation to eliminate the subdiagonal element (beta)
+//      of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix.
+//      ------------------------------------------------------------------
+        rho    =   d2norm( rhbar1, beta );
+        cs     =   rhbar1 / rho;
+        sn     =   beta   / rho;
+        theta  =   sn * alpha;
+        rhobar = - cs * alpha;
+        phi    =   cs * phibar;
+        phibar =   sn * phibar;
+        tau    =   sn * phi;
+
+//      ------------------------------------------------------------------
+//      Update  x, w  and (perhaps) the standard error estimates.
+//      ------------------------------------------------------------------
+        t1     =   phi   / rho;
+        t2     = - theta / rho;
+        t3     =   ONE   / rho;
+        dknorm =   ZERO;
+
+        for (i = 0; i < nAstroElements*comlsqr.nAstroPSolved; i++) {
+                t      =  wVect[i];
+                t      = (t3*t)*(t3*t);
+                dknorm =  t     +  dknorm;
         }
-    }
-
-    //      ------------------------------------------------------------------
-    //      Use a plane rotation to eliminate the damping parameter.
-    //      This alters the diagonal (rhobar) of the lower-bidiagonal matrix.
-    //      ------------------------------------------------------------------
-    rhbar1 = rhobar;
-    if (damped)
-    {
-        rhbar1 = d2norm(rhobar, damp);
-        cs1 = rhobar / rhbar1;
-        sn1 = damp / rhbar1;
-        psi = sn1 * phibar;
-        phibar = cs1 * phibar;
-    }
-
-    //      ------------------------------------------------------------------
-    //      Use a plane rotation to eliminate the subdiagonal element (beta)
-    //      of the lower-bidiagonal matrix, giving an upper-bidiagonal matrix.
-    //      ------------------------------------------------------------------
-    rho = d2norm(rhbar1, beta);
-    cs = rhbar1 / rho;
-    sn = beta / rho;
-    theta = sn * alpha;
-    rhobar = -cs * alpha;
-    phi = cs * phibar;
-    phibar = sn * phibar;
-    tau = sn * phi;
-
-    //      ------------------------------------------------------------------
-    //      Update  x, w  and (perhaps) the standard error estimates.
-    //      ------------------------------------------------------------------
-    t1 = phi / rho;
-    t2 = -theta / rho;
-    t3 = ONE / rho;
-    dknorm = ZERO;
-
-    for (i = 0; i < nAstroElements * comlsqr.nAstroPSolved; i++)
-    {
-        t = wVect[i];
-        t = (t3 * t) * (t3 * t);
-        dknorm = t + dknorm;
-    }
-    dknormSum = 0;
-    MPI_Allreduce(&dknorm, &dknormSum, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    dknorm = dknormSum;
-
-    if (wantse)
-    {
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < localAstro; i++)
-        {
-            t = wVect[i];
-            xSolution[i] = t1 * t + xSolution[i];
-            wVect[i] = t2 * t + vVect[i];
-            t = (t3 * t) * (t3 * t);
-            standardError[i] = t + standardError[i];
+ 		dknormSum=0;
+ 		MPI_Allreduce(&dknorm,&dknormSum,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+ 		dknorm=dknormSum;
+ 		
+        if ( wantse ) {
+#pragma omp for
+            for (i = 0; i < localAstro; i++) {
+                t      =  wVect[i];
+                xSolution[i]   =  t1*t  +  xSolution[i];
+                wVect[i]   =  t2*t  +  vVect[i];
+                t      = (t3*t)*(t3*t);
+                standardError[i]  =  t     +  standardError[i];
+            }
+#pragma omp for
+            for (i = localAstroMax; i < localAstroMax+other; i++) {
+                t      =  wVect[i];
+                xSolution[i]   =  t1*t  +  xSolution[i];
+                wVect[i]   =  t2*t  +  vVect[i];
+                t      = (t3*t)*(t3*t);
+                standardError[i]  =  t     +  standardError[i];
+            }
+            for (i = localAstroMax; i < localAstroMax+other; i++) {
+                t      =  wVect[i];
+                t      = (t3*t)*(t3*t);
+                dknorm =  t     +  dknorm;
+            }
         }
-        // FV EDIT 
-        //#pragma omp for
-        for (i = localAstroMax; i < localAstroMax + other; i++)
-        {
-            t = wVect[i];
-            xSolution[i] = t1 * t + xSolution[i];
-            wVect[i] = t2 * t + vVect[i];
-            t = (t3 * t) * (t3 * t);
-            standardError[i] = t + standardError[i];
+        else {
+#pragma omp for
+            for (i = 0; i < localAstro; i++) {
+                t      =  wVect[i];
+                xSolution[i]   =  t1*t  +  xSolution[i];
+                wVect[i]   =  t2*t  +  vVect[i];
+            }
+#pragma omp for
+            for (i = localAstroMax; i < localAstroMax+other; i++) {
+                t      =  wVect[i];
+                xSolution[i]   =  t1*t  +  xSolution[i];
+                wVect[i]   =  t2*t  +  vVect[i];
+            }
+            for (i = localAstroMax; i < localAstroMax+other; i++) {
+                t      =  wVect[i];
+                dknorm = (t3*t)*(t3*t)  +  dknorm;
+            }
         }
-        for (i = localAstroMax; i < localAstroMax + other; i++)
-        {
-            t = wVect[i];
-            t = (t3 * t) * (t3 * t);
-            dknorm = t + dknorm;
+
+//      ------------------------------------------------------------------
+//      Monitor the norm of d_k, the update to x.
+//      dknorm = norm( d_k )
+//      dnorm  = norm( D_k ),        where   D_k = (d_1, d_2, ..., d_k )
+//      dxk    = norm( phi_k d_k ),  where new x = x_k + phi_k d_k.
+//      ------------------------------------------------------------------
+        dknorm = sqrt( dknorm );
+        dnorm  = d2norm( dnorm, dknorm );
+        dxk    = fabs( phi * dknorm );
+        if (dxmax < dxk ) {
+            dxmax   =  dxk;
+            maxdx   =  itn;
         }
-    }
-    else
-    {
-        // FV EDIT 
-        //#pragma omp for
-        for (i = 0; i < localAstro; i++)
-        {
-            t = wVect[i];
-            xSolution[i] = t1 * t + xSolution[i];
-            wVect[i] = t2 * t + vVect[i];
+
+//      ------------------------------------------------------------------
+//      Use a plane rotation on the right to eliminate the
+//      super-diagonal element (theta) of the upper-bidiagonal matrix.
+//      Then use the result to estimate  norm(x).
+//      ------------------------------------------------------------------
+        delta  =   sn2 * rho;
+        gambar = - cs2 * rho;
+        rhs    =   phi    - delta * z;
+        zbar   =   rhs    / gambar;
+        xnorm  =   d2norm( xnorm1, zbar  );
+        gamma  =   d2norm( gambar, theta );
+        cs2    =   gambar / gamma;
+        sn2    =   theta  / gamma;
+        z      =   rhs    / gamma;
+        xnorm1 =   d2norm( xnorm1, z     );
+
+//      ------------------------------------------------------------------
+//      Test for convergence.
+//      First, estimate the norm and condition of the matrix  Abar,
+//      and the norms of  rbar  and  Abar(transpose)*rbar.
+//      ------------------------------------------------------------------
+        acond  =   anorm * dnorm;
+        res2   =   d2norm( res2 , psi    );
+        rnorm  =   d2norm( res2 , phibar );
+        arnorm =   alpha * fabs( tau );
+
+//      Now use these norms to estimate certain other quantities,
+//      some of which will be small near a solution.
+
+        alfopt =   sqrt( rnorm / (dnorm * xnorm) );
+        test1  =   rnorm /  bnorm;
+        test2  =   ZERO;
+        if (rnorm   > ZERO) test2 = arnorm / (anorm * rnorm);
+//      if (arnorm0 > ZERO) test2 = arnorm / arnorm0;  //(Michael Friedlander's modification)
+        test3  =   ONE   /  acond;
+        t1     =   test1 / (ONE  +  anorm * xnorm / bnorm);
+        rtol   =   btol  +  atol *  anorm * xnorm / bnorm;
+
+//      The following tests guard against extremely small values of
+//      atol, btol  or  ctol.  (The user may have set any or all of
+//      the parameters  atol, btol, conlim  to zero.)
+//      The effect is equivalent to the normal tests using
+//      atol = relpr,  btol = relpr,  conlim = 1/relpr.
+
+        t3     =   ONE + test3;
+        t2     =   ONE + test2;
+        t1     =   ONE + t1;
+//		printf("LSQR TP8 PE=%d itn=%d test1=%18.16lf, rnorm=%lf bnorm=%lf anorm=%lf xnorm=%lf rtol=%lf t1=%18.16lf\n",myid,itn,test1,rnorm,bnorm,anorm,xnorm,rtol,t1);
+
+        if (itn >= itnlim) istop = 5;
+        if (t3  <= ONE   ) istop = 4;
+        if (t2  <= ONE   ) istop = 2;
+        if (t1  <= ONE   ) istop = 1;
+//        if (t1  <= ONE   ) printf("PE=%d t1=%lf\n",myid,t1); 
+
+//      Allow for tolerances set by the user.
+
+        if (test3 <= ctol) istop = 4;
+        if (test2 <= atol) istop = 2;
+        if (test1 <= rtol) istop = 1;   //(Michael Friedlander had this commented out)
+//        if (test1 <= rtol) printf("PE=%d test1=%lf\n",myid,test1); 
+
+//      ------------------------------------------------------------------
+//      See if it is time to print something.
+//      ------------------------------------------------------------------
+//        if (nout  == NULL     ) goto goto_600; // Delete for buffer flush modification??? TBV
+        if (n     <= 40       ) goto goto_400;
+        if (itn   <= 10       ) goto goto_400;
+        if (itn   >= itnlim-10) goto goto_400;
+        if (itn % 10 == 0     ) goto goto_400;
+        if (test3 <=  2.0*ctol) goto goto_400;
+        if (test2 <= 10.0*atol) goto goto_400;
+        if (test1 <= 10.0*rtol) goto goto_400;
+        if (istop != 0        ) goto goto_400;
+        goto goto_600;
+
+//      Print a line for this iteration.
+//      "extra" is for experimental purposes.
+
+    goto_400:
+       if(!comlsqr.Test)
+        if(myid==0) {
+			nout=fopen(lsqrOut,"a");
+			if ( nout != NULL) {
+				if ( extra ) {
+					fprintf(nout, fmt_1500_extra,
+						itn, xSolution[0], rnorm, test1, test2, anorm,
+                    acond, phi, dknorm, dxk, alfopt);
+				} else {
+					fprintf(nout, fmt_1500,
+						itn, xSolution[0], rnorm, test1, test2, anorm, acond);
+				}
+				if (itn % 10 == 0) fprintf(nout, fmt_1600);
+			} else {
+				printf("Error while opening %s (3)\n",lsqrOut);
+				MPI_Abort(MPI_COMM_WORLD,1);
+				exit(EXIT_FAILURE);
+			}
+			fclose(nout);
         }
-        // FV EDIT 
-        //#pragma omp for
-        for (i = localAstroMax; i < localAstroMax + other; i++)
-        {
-            t = wVect[i];
-            xSolution[i] = t1 * t + xSolution[i];
-            wVect[i] = t2 * t + vVect[i];
+//      ------------------------------------------------------------------
+//      Stop if appropriate.
+//      The convergence criteria are required to be met on  nconv
+//      consecutive iterations, where  nconv  is set below.
+//      Suggested value:  nconv = 1, 2  or  3.
+//      ------------------------------------------------------------------
+    goto_600:
+        if (istop == 0) {
+            nstop  = 0;
         }
-        for (i = localAstroMax; i < localAstroMax + other; i++)
-        {
-            t = wVect[i];
-            dknorm = (t3 * t) * (t3 * t) + dknorm;
+        else {
+            nconv  = 1;
+            nstop  = nstop + 1;
+            if (nstop < nconv  &&  itn < itnlim) istop = 0;
         }
-    }
-
-    //      ------------------------------------------------------------------
-    //      Monitor the norm of d_k, the update to x.
-    //      dknorm = norm( d_k )
-    //      dnorm  = norm( D_k ),        where   D_k = (d_1, d_2, ..., d_k )
-    //      dxk    = norm( phi_k d_k ),  where new x = x_k + phi_k d_k.
-    //      ------------------------------------------------------------------
-    dknorm = sqrt(dknorm);
-    dnorm = d2norm(dnorm, dknorm);
-    dxk = fabs(phi * dknorm);
-    if (dxmax < dxk)
-    {
-        dxmax = dxk;
-        maxdx = itn;
-    }
-
-    //      ------------------------------------------------------------------
-    //      Use a plane rotation on the right to eliminate the
-    //      super-diagonal element (theta) of the upper-bidiagonal matrix.
-    //      Then use the result to estimate  norm(x).
-    //      ------------------------------------------------------------------
-    delta = sn2 * rho;
-    gambar = -cs2 * rho;
-    rhs = phi - delta * z;
-    zbar = rhs / gambar;
-    xnorm = d2norm(xnorm1, zbar);
-    gamma = d2norm(gambar, theta);
-    cs2 = gambar / gamma;
-    sn2 = theta / gamma;
-    z = rhs / gamma;
-    xnorm1 = d2norm(xnorm1, z);
-
-    //      ------------------------------------------------------------------
-    //      Test for convergence.
-    //      First, estimate the norm and condition of the matrix  Abar,
-    //      and the norms of  rbar  and  Abar(transpose)*rbar.
-    //      ------------------------------------------------------------------
-    acond = anorm * dnorm;
-    res2 = d2norm(res2, psi);
-    rnorm = d2norm(res2, phibar);
-    arnorm = alpha * fabs(tau);
-
-    //      Now use these norms to estimate certain other quantities,
-    //      some of which will be small near a solution.
-
-    alfopt = sqrt(rnorm / (dnorm * xnorm));
-    test1 = rnorm / bnorm;
-    test2 = ZERO;
-    if (rnorm > ZERO)
-        test2 = arnorm / (anorm * rnorm);
-    //      if (arnorm0 > ZERO) test2 = arnorm / arnorm0;  //(Michael Friedlander's modification)
-    test3 = ONE / acond;
-    t1 = test1 / (ONE + anorm * xnorm / bnorm);
-    rtol = btol + atol * anorm * xnorm / bnorm;
-
-    //      The following tests guard against extremely small values of
-    //      atol, btol  or  ctol.  (The user may have set any or all of
-    //      the parameters  atol, btol, conlim  to zero.)
-    //      The effect is equivalent to the normal tests using
-    //      atol = relpr,  btol = relpr,  conlim = 1/relpr.
-
-    t3 = ONE + test3;
-    t2 = ONE + test2;
-    t1 = ONE + t1;
-    //		printf("LSQR TP8 PE=%d itn=%d test1=%18.16lf, rnorm=%lf bnorm=%lf anorm=%lf xnorm=%lf rtol=%lf t1=%18.16lf\n",myid,itn,test1,rnorm,bnorm,anorm,xnorm,rtol,t1);
-
-    if (itn >= itnlim)
-        istop = 5;
-    if (t3 <= ONE)
-        istop = 4;
-    if (t2 <= ONE)
-        istop = 2;
-    if (t1 <= ONE)
-        istop = 1;
-    //        if (t1  <= ONE   ) printf("PE=%d t1=%lf\n",myid,t1);
-
-    //      Allow for tolerances set by the user.
-
-    if (test3 <= ctol)
-        istop = 4;
-    if (test2 <= atol)
-        istop = 2;
-    if (test1 <= rtol)
-        istop = 1; //(Michael Friedlander had this commented out)
-                   //        if (test1 <= rtol) printf("PE=%d test1=%lf\n",myid,test1);
-
-    //      ------------------------------------------------------------------
-    //      See if it is time to print something.
-    //      ------------------------------------------------------------------
-    //        if (nout  == NULL     ) goto goto_600; // Delete for buffer flush modification??? TBV
-    if (n <= 40)
-        goto goto_400;
-    if (itn <= 10)
-        goto goto_400;
-    if (itn >= itnlim - 10)
-        goto goto_400;
-    if (itn % 10 == 0)
-        goto goto_400;
-    if (test3 <= 2.0 * ctol)
-        goto goto_400;
-    if (test2 <= 10.0 * atol)
-        goto goto_400;
-    if (test1 <= 10.0 * rtol)
-        goto goto_400;
-    if (istop != 0)
-        goto goto_400;
-    goto goto_600;
-
-    //      Print a line for this iteration.
-    //      "extra" is for experimental purposes.
-
-goto_400:
-    if (!comlsqr.Test)
-        if (myid == 0)
+        
+        if(comlsqr.Test)
         {
-            nout = fopen(lsqrOut, "a");
-            if (nout != NULL)
-            {
-                if (extra)
-                {
-                    fprintf(nout, fmt_1500_extra,
-                            itn, xSolution[0], rnorm, test1, test2, anorm,
-                            acond, phi, dknorm, dxk, alfopt);
-                }
-                else
-                {
-                    fprintf(nout, fmt_1500,
-                            itn, xSolution[0], rnorm, test1, test2, anorm, acond);
-                }
-                if (itn % 10 == 0)
-                    fprintf(nout, fmt_1600);
-            }
-            else
-            {
-                printf("Error while opening %s (3)\n", lsqrOut);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            fclose(nout);
-        }
-    //      ------------------------------------------------------------------
-    //      Stop if appropriate.
-    //      The convergence criteria are required to be met on  nconv
-    //      consecutive iterations, where  nconv  is set below.
-    //      Suggested value:  nconv = 1, 2  or  3.
-    //      ------------------------------------------------------------------
-goto_600:
-    if (istop == 0)
-    {
-        nstop = 0;
+			if(itn<comlsqr.itnLimit) istop=0;
+			else (istop=5);
+		}
+		cycleEndMpiTime=MPI_Wtime();
+//		printf("lsqr: PE=%d MPI-iteration number %d. Iteration seconds %f\n",myid,itn,cycleEndMpiTime-cycleStartMpiTime);
+
+        if (istop != 0) break;
+        
     }
-    else
-    {
-        nconv = 1;
-        nstop = nstop + 1;
-        if (nstop < nconv && itn < itnlim)
-            istop = 0;
-    }
-
-    if (comlsqr.Test)
-    {
-        if (itn < comlsqr.itnLimit)
-            istop = 0;
-        else
-            (istop = 5);
-    }
-    cycleEndMpiTime = MPI_Wtime();
-    //		printf("lsqr: PE=%d MPI-iteration number %d. Iteration seconds %f\n",myid,itn,cycleEndMpiTime-cycleStartMpiTime);
-
-    if (istop != 0)
-        break;
-}
 //  ==================================================================
 //  End of iteration loop.
 //  ==================================================================
 //  Finish off the standard error estimates.
 
-if (wantse)
-{
-    t = ONE;
-    if (m > n)
-        t = m - n;
-    if (damped)
-        t = m;
-    t = rnorm / sqrt(t);
-
-    for (i = 0; i < nunkSplit; i++)
-        standardError[i] = t * sqrt(standardError[i]);
-}
+    if ( wantse ) {
+        t    =   ONE;
+        if (m > n)     t = m - n;
+        if ( damped )  t = m;
+        t    =   rnorm / sqrt( t );
+      
+        for (i = 0; i < nunkSplit; i++)
+            standardError[i]  = t * sqrt( standardError[i] );
+        
+    }
 
 //  Decide if istop = 2 or 3.
 //  Print the stopping condition.
-goto_800 : if (damped && istop == 2) istop = 3;
-if (myid == 0)
-{
-    nout = fopen(lsqrOut, "a");
-    if (nout != NULL)
-    {
-        fprintf(nout, fmt_2000,
-                exitLsqr, istop, itn,
-                exitLsqr, anorm, acond,
-                exitLsqr, bnorm, xnorm,
-                exitLsqr, rnorm, arnorm);
-        fprintf(nout, fmt_2100,
-                exitLsqr, dxmax, maxdx,
-                exitLsqr, dxmax / (xnorm + 1.0e-20));
-        fprintf(nout, fmt_3000,
-                exitLsqr, msg[istop]);
-    }
-    else
-    {
-        printf("Error while opening %s (4)\n", lsqrOut);
-        MPI_Abort(MPI_COMM_WORLD, 1);
-        exit(EXIT_FAILURE);
-    }
-    fclose(nout);
-}
+ goto_800:
+    if (damped  &&  istop == 2) istop = 3;
+	if (myid == 0) {
+		nout=fopen(lsqrOut,"a");
+		if (nout != NULL) {
+			fprintf(nout, fmt_2000,
+					exitLsqr, istop, itn,
+					exitLsqr, anorm, acond,
+					exitLsqr, bnorm, xnorm,
+					exitLsqr, rnorm, arnorm);
+			fprintf(nout, fmt_2100,
+					exitLsqr, dxmax, maxdx,
+					exitLsqr, dxmax/(xnorm + 1.0e-20));
+			fprintf(nout, fmt_3000,
+					exitLsqr, msg[istop]);
+		} else {
+			printf("Error while opening %s (4)\n",lsqrOut);
+			MPI_Abort(MPI_COMM_WORLD,1);
+			exit(EXIT_FAILURE);
+		}
+		fclose(nout);
+	}
 
 //  Assign output variables from local copies.
-*istop_out = istop;
-*itn_out = itn;
-*anorm_out = anorm;
-*acond_out = acond;
-*rnorm_out = rnorm;
-*arnorm_out = test2;
-*xnorm_out = xnorm;
-
-if (nAstroPSolved)
-    free(vAuxVect);
-return;
+    *istop_out  = istop;
+    *itn_out    = itn;
+    *anorm_out  = anorm;
+    *acond_out  = acond;
+    *rnorm_out  = rnorm;
+    *arnorm_out = test2;
+    *xnorm_out  = xnorm;
+
+    if(nAstroPSolved) free(vAuxVect);
+    return;
 }
+
+
diff --git a/memRequest.c b/memRequest.c
old mode 100644
new mode 100755
diff --git a/run_ppl.cmd b/run_ppl.cmd
new file mode 100755
index 0000000..636fd0f
--- /dev/null
+++ b/run_ppl.cmd
@@ -0,0 +1,28 @@
+#!/bin/bash
+#SBATCH --job-name=AVUGSR_OMP
+#SBATCH --time=0:30:00
+#SBATCH --out=out.log
+#SBATCH --err=err.log
+###SBATCH --nodes=2 --ntasks-per-node=2 --ntasks-per-socket=2
+#SBATCH --nodes=1
+#SBATCH --ntasks=2  
+#SBATCH --cpus-per-task=4
+#SBATCH --mem=100000
+#SBATCH --partition=merlin
+####SBATCH --account=INAF_GAIA14_3
+#
+#
+#
+###module load profile/astro
+##module load autoload intelmpi cfitsio
+export OMP_NUM_THREADS=4
+export KMP_AFFINITY=compact
+#
+cd /home/ubecciani/AVU-GSR/OMP/src/run
+
+srun  ../GaiaGsrParSim -auto
+
+exit 0 
+
+#
+#
diff --git a/solvergaiaSim.c b/solvergaiaSim.c
index 30b8f0a..d001f9a 100644
--- a/solvergaiaSim.c
+++ b/solvergaiaSim.c
@@ -16,6 +16,8 @@
  - version 5.0 - May 2013 from Ugo Becciani and Alberto Vecchiato
  */
 
+
+
 //#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -32,6 +34,7 @@
 
 #define MAX_CONSTR 1000
 
+
 long instr_hash(int FoV, int CCD, int PixelColumn, int TimeInterval);
 long randlong(long max);
 long randlong1(long min, long max);
@@ -39,570 +42,505 @@ int randint(int max);
 int randint1(int min, int max);
 int fill_extract(long *values, long *pos_min, long pos_max, long *number);
 
+
+
 /* Start of main program */
-int main(int argc, char **argv)
-{
-    int debugMode, wrsol;
+int main(int argc, char **argv) {
+    int debugMode,wrsol;
     int i;
-
-    int idtest = 0, precond = 1;
+    
+    int  idtest=0, precond=1;
     double srIDtest, pert;
-
-    int inputDirOpt = 0, outputDirOpt = 0, inputDirLen;
-    char inputDir[1024] = "", outputDir[1024] = "", wrfileDir[1024] = "";
+    
+    int inputDirOpt=0, outputDirOpt=0, inputDirLen;
+    char inputDir[1024]="", outputDir[1024]="",wrfileDir[1024]="";
     char wpath[1024];
-    size_t sizePath = 1020;
-
+    size_t sizePath=1020;
+    
     char filenameSolProps[150];
     char filenameSolPropsFinal[150];
-    char filenameAstroResults[150];  /* file storing the Astrometric Parameters */
-    char filenameAttResults[150];    /* file storing the Attitude Parameters */
-    char filenameInstrResults[150];  /* file storing the Instrument Parameters */
+    char filenameAstroResults[150]; /* file storing the Astrometric Parameters */
+    char filenameAttResults[150]; /* file storing the Attitude Parameters */
+    char filenameInstrResults[150]; /* file storing the Instrument Parameters */
     char filenameGlobalResults[150]; /* file storing the Global Parameters */
-
+    
     long ii, jj, kk;
     long sphereId; // Id of the sphere to be solved
-    long idum;     // variable to initialize the random number generator aggiunta la variabile per inizializzare ran2()
-
+    long idum; // variable to initialize the random number generator aggiunta la variabile per inizializzare ran2()
+    
     // LSQR input parameters
-    long itnlim;                     // maximum number of iteration allowed for the LSQR convergence
+    long itnlim; // maximum number of iteration allowed for the LSQR convergence
     double damp, atol, btol, conlim; // other LSQR input parameters
-    double aTol;                     //read by command line, overrides atol if >=0
-
+    double aTol; //read by command line, overrides atol if >=0
+    
     // LSQR output parameters
-    int istop;                                 // LSQR stopping condition
-    int itn;                                   // LSQR iteration number
+    int istop; // LSQR stopping condition
+    int itn; // LSQR iteration number
     double anorm, acond, rnorm, arnorm, xnorm; // other LSQR output parameters
-
+    
     // Properties of the system to be solved
     // Astrometric parameters:
-    long nStar;    // number of stars
-    short nAstroP; // number of astrometric parameters for each observation
-
-    short nAstroPSolved, nInstrPSolved; // number of astrometric and instrumental parameters taken as unknowns in the system of equations
-    int *mapAstroP;                     // indeces of the solved astrometric parameters
-    int lsInstrFlag, ssInstrFlag, nuInstrFlag, maInstrFlag;
-    int nElemIC = 0, nOfInstrConstr = 0;
-    int nOfInstrConstrLSAL = 0, nElemICLSAL = 0, nOfInstrConstrLSAC = 0, nElemICLSAC = 0, nOfInstrConstrSS = 0, nElemICSS = 0;
+    long nStar;      // number of stars
+    short nAstroP;   // number of astrometric parameters for each observation
+    
+    short nAstroPSolved,nInstrPSolved;	// number of astrometric and instrumental parameters taken as unknowns in the system of equations
+    int *mapAstroP;	 // indeces of the solved astrometric parameters
+    int lsInstrFlag,ssInstrFlag,nuInstrFlag,maInstrFlag;
+    int nElemIC=0,nOfInstrConstr=0;
+    int nOfInstrConstrLSAL=0, nElemICLSAL=0, nOfInstrConstrLSAC=0, nElemICLSAC=0 , nOfInstrConstrSS=0 ,nElemICSS=0;
 
     // Attitude parameters:
-
-    long nDegFreedomAtt = 0;         // number of degrees of freedom for each attitude axis
-    long cCDLSAACZP = 14;            // CCD light sensitive area AC zero point
-    short nAttAxes = 0, nAttParAxis; // number of attitude axes to be reconstructed, number of non-zero attitude coefficients per obs. & axis
-    short nAttP = 0;                 // number of attitude parameters for each observation
+    
+    
+    long nDegFreedomAtt=0; 	        // number of degrees of freedom for each attitude axis
+    long cCDLSAACZP=14;                 // CCD light sensitive area AC zero point
+    short nAttAxes=0, nAttParAxis;  // number of attitude axes to be reconstructed, number of non-zero attitude coefficients per obs. & axis
+    short nAttP=0;     // number of attitude parameters for each observation
     // Instrument parameters:
     long instrSetUp; // number coding the set up of the instrument in terms of: # of FoVs, # of CCDs, # of pixel columns, # of time intervals
     short nInstrP;   // number of instrument parameters for each observation
     // Global parameters:
-    short nGlobP; // number of global parameters
-
-    long nobs;                                                         // number of observations
-    long nConstrLong, nConstrLat, nConstrMuLong, nConstrMuLat;         // number of constraints for the astrometric parameters
+    short nGlobP;    // number of global parameters
+    
+    long nobs; // number of observations
+    long nConstrLong, nConstrLat, nConstrMuLong, nConstrMuLat; // number of constraints for the astrometric parameters
     long *constrLongId, *constrLatId, *constrMuLongId, *constrMuLatId; // arrays with the gsrIDs of the constrained sources
-    double *constrLongW, *constrLatW, *constrMuLongW, *constrMuLatW;   // arrays with the weights of the constraints
-    double extConstrW;                                                 // weight of the null space constraint equations
-    double barConstrW;                                                 // weight of the baricentric constraint equations
-    const double attExtConstrFact = -0.5;                              // the coefficients of the attitude part of the null space constraint equations must be multiplied by a factor -1/2
-
+    double *constrLongW, *constrLatW, *constrMuLongW, *constrMuLatW; // arrays with the weights of the constraints
+    double extConstrW; // weight of the null space constraint equations
+    double barConstrW; // weight of the baricentric constraint equations
+    const double attExtConstrFact=-0.5; // the coefficients of the attitude part of the null space constraint equations must be multiplied by a factor -1/2
+    
     // Variables to be read from the GsrSystemRows
-
+    
     // Internal variables
     long nAstroParam;
-    int nAttParam, nInstrParam, nGlobalParam, nInstrParamTot; // total number of unknowns for the Astrometric, Attitude, Instrument, and Global parameters respectively
-    int nparam;                                               // total number of unknowns
+    int nAttParam, nInstrParam, nGlobalParam,nInstrParamTot; // total number of unknowns for the Astrometric, Attitude, Instrument, and Global parameters respectively
+    int nparam; // total number of unknowns
     long nunk, nunkSplit, nConstr;
-    long ncoeff, ielem, global_ielem, precnofrows, global_precnofrows, ncolumn, nrowsToRead;
+    long ncoeff, ielem, global_ielem, precnofrows,global_precnofrows, ncolumn, nrowsToRead;
     long offsetAttParam, offsetInstrParam, offsetGlobParam, VroffsetAttParam; // offests for the Attitude, Instrument, and Global columns of the coefficient matrix
-    unsigned long int totmem, nElements;                                      // total required memory and temporary variable to store the memory being allocated
-    long VrIdAstroPDimMax = 0;                                                //
-    long VrIdAstroPDim = 0;                                                   //
+    unsigned long int totmem, nElements; // total required memory and temporary variable to store the memory being allocated
+    long VrIdAstroPDimMax=0; //
+    long VrIdAstroPDim=0; //
     long VrIdAstroPDimRecv;
     int offset;
     long nObsxStar, nobsOri;
-    int nfileProc = 3;
-    int addElementAtt = 0;
-    int addElementextStar = 0;
-    int addElementbarStar = 0;
-    int nOfElextObs = 0;
-    int nOfElBarObs = 0;
+    int nfileProc=3;
+    int addElementAtt=0;
+    int addElementextStar=0;
+    int addElementbarStar=0;
+   int nOfElextObs=0;
+    int nOfElBarObs=0;
     double *attNS;
 
+    
     // Array arguments of the LSQR function
     double *knownTerms, *vVect, *wVect, *xSolution, *standardError; // arrays containing the known terms (knownterms), the bidiagonalization (wVect, wVect), the unknowns (xSolution), and the estimated variances (standardError)
-    long int *matrixIndex;                                          // ia[i] contains the column number of the coefficient systemMatrix[i]
+    long int  *matrixIndex; // ia[i] contains the column number of the coefficient systemMatrix[i]
     int *instrConst;
-    int *instrCol;                      // columns on each observation for instumental Parameters
-    int *instrConstrIlung;              // vector containing the length of each instrConstr eq.
+   	int *instrCol;  // columns on each observation for instumental Parameters
+    int * instrConstrIlung; // vector containing the length of each instrConstr eq.
     double *systemMatrix, *preCondVect; // array of the non-zero coefficients of the system and of the column normalization respectively
-    int wgInstrCoeff = 1;
-
+    int wgInstrCoeff=1;
+    
     /////////////////////
     // Arrays containing the solution coming from the LSQR
-    double *xAstro, *standardErrorAstro;   // solution and standard errors for the Astrometric parameters
-    double *xAtt, *standardErrorAtt;       // solution and standard errors for the Attitude parameters
-    double *xInstr, *standardErrorInstr;   // solution and standard errors for the Instrument parameters
+    double *xAstro, *standardErrorAstro; // solution and standard errors for the Astrometric parameters
+    double *xAtt, *standardErrorAtt; // solution and standard errors for the Attitude parameters
+    double *xInstr, *standardErrorInstr; // solution and standard errors for the Instrument parameters
     double *xGlobal, *standardErrorGlobal; // solution and standard errors for the Global parameters
-
+    
+    
     // file pointers
-    FILE *fpSolProps, *fpSolPropsFinal, *fpSolPropsFileBin;
+    FILE *fpSolProps,*fpSolPropsFinal,*fpSolPropsFileBin;
     FILE *fpMI, *fpSM, *fpII, *fpKT, *fpCPR;
     FILE *fpAstroR, *fpAttR, *fpInstrR, *fpGlobR, *ffcont;
-
+    
     time_t seconds[10], tot_sec[10];
     seconds[0] = time(NULL);
     double timeToReadFiles;
-
+    
     //MPI definitions
-    int nproc, myid, namelen;
+    int  nproc, myid, namelen;
     char processor_name[MPI_MAX_PROCESSOR_NAME];
-    double startTime, endTime;
-
+    double startTime,endTime;
+    
     // Distributed array maps
-    long int *mapNcoeff, *mapNoss;
-    long int mapNcoeffBefore, mapNossBefore;
-    long int mapNcoeffAfter, mapNossAfter;
+    long int * mapNcoeff, * mapNoss;
+    long int   mapNcoeffBefore, mapNossBefore;
+    long int   mapNcoeffAfter, mapNossAfter;
     // struct to communicate with lsqr
-    int timeCPR, timeLimit, itnCPR, itnCPRstop = 1000000;
+    int timeCPR, timeLimit,itnCPR,itnCPRstop=1000000;
     int itnLimit; //read by command line, overrides itnlim if >0
     struct comData comlsqr;
     // serach for map
-    long lastStar = -1;
-    long firstStar = -1;
-    long lastStarConstr = -1;
-    long firstStarConstr = -1;
-    int seqStar = 1;
-    int withFile = 1;
-    int noConstr = 0;
-    int zeroAtt = 0, zeroInstr = 0, zeroGlob = 0, wrFilebin = 0;
+    long lastStar=-1;
+    long firstStar=-1;
+    long lastStarConstr=-1;
+    long firstStarConstr=-1;
+    int seqStar=1;
+    int withFile=1;
+    int noConstr=0;
+    int   zeroAtt=0, zeroInstr=0, zeroGlob=0, wrFilebin=0;
     int constraintFound[MAX_CONSTR][2]; // first: number of file of the constraint; second: row in file
-    int rowInFile = 0;
-    int noIter = 0;
-    int noCPR = 0;
-    int extConstraint = 0, nEqExtConstr = 0;
-    int barConstraint = 0, nEqBarConstr = 0;
-    int startingAttColExtConstr, endingAttColExtConstr, numOfExtAttCol, starOverlap = 0, numOfExtStar, numOfBarStar;
+    int rowInFile=0;
+    int noIter=0;
+    int noCPR=0;
+    int extConstraint=0, nEqExtConstr=0;
+    int barConstraint=0, nEqBarConstr=0;
+    int startingAttColExtConstr,endingAttColExtConstr,numOfExtAttCol,starOverlap=0,numOfExtStar,numOfBarStar;
     char constranitFoundFileName[MAX_CONSTR][256];
-    struct dirent **namelistMI;
+    struct dirent  **namelistMI;
     struct nullSpace nullSpaceCk;
     double nullSpaceAttfact;
-    int autoRun = 0;
-    float memGlobal = 0;
+    int autoRun=0;
+    float memGlobal=0;
     float memGB;
-    int nthreads=0;
-    int ntasks=0;
-
     ///////////////
-    for (int i = 1; i < argc - 1; i++)
+    for (int i=1;i<argc-1;i++)
     {
-        if (strcmp(argv[i], "-testXCode") == 0)
-            sleep(600);
+        if(strcmp (argv[i],"-testXCode") == 0)
+           sleep(600);
     }
 
     MPI_Init(&argc, &argv);
     MPI_Comm_size(MPI_COMM_WORLD, &nproc);
     MPI_Comm_rank(MPI_COMM_WORLD, &myid);
-    MPI_Get_processor_name(processor_name, &namelen);
-    startTime =0;// MPI_Wtime();
+    MPI_Get_processor_name(processor_name,&namelen);
+    startTime= MPI_Wtime();
     // Initialize the random number generator for each PE
-    idum = -((long)startTime + myid);
-
-    if (argc == 1)
-    {
-        if (myid == 0)
-        {
+    idum=-((long)startTime+myid);
+    
+    
+    if (argc == 1) {
+        if(myid==0){
             printf("Usage:  solvergaiaSim [-auto] [-memGlobal value]  [-IDtest [value]   -noFile -noConstr -numFilexproc nfileProc -Precond [on|off] -timeCPR hours -timelimit hours -itnCPR numberOfIterations -noCPR -itnlimit numberOfIterations   -atol value  -inputDir inputdir -outputDir outputdir      -zeroAtt -zeroInstr -zeroGlob -wgic value]] -wrfilebin writedir -wrsol -noiter  -extConstr weight -barConstr weight filename\n\n");
         }
         MPI_Finalize();
         exit(EXIT_FAILURE);
     }
-    debugMode = 0;
-    wrsol = 0;
-    int testTime = 0;
-    short testSolved = -1;
-    nAstroPSolved = -1;
-    idtest = 0;
-
+    debugMode=0;
+    wrsol=0;
+    int testTime=0;
+    short testSolved=-1;
+    nAstroPSolved=-1;
+    idtest=0;
+    
     //idtest=1;  // IDTest forced for the simulator
-
-    timeCPR = DEFAULT_TIMECPR;
-    timeLimit = DEFAULT_TIMELIMIT;
-    itnCPR = DEFAULT_ITNCPR;
-    itnLimit = 0;
-    aTol = -1.0;
-    if (strcmp(argv[1], "-auto") == 0)
-    {
+    
+    timeCPR=DEFAULT_TIMECPR;
+    timeLimit=DEFAULT_TIMELIMIT;
+    itnCPR=DEFAULT_ITNCPR;
+    itnLimit=0;
+    aTol=-1.0;
+    if(strcmp (argv[1],"-auto") == 0){
         printf(" solvergaiaSim -auto ");
-        idtest = 1;
-        srIDtest = 1;
-        withFile = 0;
-        noConstr = 1;
-        noCPR = 1;
-        itnLimit = 5;
-        wgInstrCoeff = 100;
-        barConstraint = 1;
-        nEqBarConstr = DEFAULT_BARCONSTROWS;
-        barConstrW = 10.0;
-        autoRun = 1;
-        for (int i = 2; i < argc - 1; i++)
-        {
-            if (strcmp(argv[i], "-memGlobal") == 0)
-            {
-                memGlobal = atof(argv[i + 1]);
-                printf("-memGlobal %f", memGlobal);
+        idtest=1;
+        srIDtest=1;
+        withFile=0;
+        noConstr=1;
+        noCPR=1;
+        itnLimit=20000;
+        wgInstrCoeff=100;
+        barConstraint=1;
+        nEqBarConstr=DEFAULT_BARCONSTROWS;
+        barConstrW=10.0;
+        autoRun=1;
+        for (int i=2;i<argc-1;i++){
+            if(strcmp (argv[i],"-memGlobal") == 0)
+            {
+                memGlobal=atof(argv[i+1]);
+                 printf("-memGlobal %f",memGlobal);
             }
+ 
         }
         printf("\n\n");
     }
-
-    for (int i = 1; i < argc - 1; i++)
-    {
-        if (strcmp(argv[i], "-IDtest") == 0)
-        {
-            idtest = 1;
-            srIDtest = atof(argv[i + 1]);
-        }
-        if (strcmp(argv[i], "-Precond") == 0)    // aggiunto precond on/off
-            if (strcmp(argv[i + 1], "off") == 0) // aggiunto precond on/off
-                precond = 0;
-
-        if (strcmp(argv[i], "-noFile") == 0)
-            withFile = 0;
-        if (strcmp(argv[i], "-noConstr") == 0)
-            noConstr = 1;
-
-        if (strcmp(argv[i], "-numFilexproc") == 0)
+    
+     for (int i=1;i<argc-1;i++)
+     {
+        if(strcmp (argv[i],"-IDtest") == 0)
         {
-            nfileProc = atoi(argv[i + 1]);
-            if (nfileProc <= 0)
-                nfileProc = 3;
+            idtest=1;
+            srIDtest=atof(argv[i+1]);
         }
-        if (strcmp(argv[i], "-timeCPR") == 0)
+        if(strcmp (argv[i],"-Precond") == 0)  // aggiunto precond on/off
+            if(strcmp (argv[i+1],"off") == 0)  // aggiunto precond on/off
+                precond=0;
+        
+        if(strcmp (argv[i],"-noFile") == 0) withFile=0;
+        if(strcmp (argv[i],"-noConstr") == 0) noConstr=1;
+        
+        
+        if(strcmp (argv[i],"-numFilexproc") == 0)
         {
-            testTime = atoi(argv[i + 1]);
-            if (testTime > 0)
-                timeCPR = testTime;
+            nfileProc=atoi(argv[i+1]);
+            if(nfileProc <=0) nfileProc=3;
         }
-        if (strcmp(argv[i], "-timelimit") == 0)
+        if(strcmp (argv[i],"-timeCPR") == 0)
         {
-            testTime = atoi(argv[i + 1]);
-            if (testTime > 0)
-                timeLimit = testTime;
+            testTime=atoi(argv[i+1]);
+            if(testTime >0) timeCPR=testTime;
         }
-
-        if (strcmp(argv[i], "-itnCPR") == 0)
+        if(strcmp (argv[i],"-timelimit") == 0)
         {
-            testTime = atoi(argv[i + 1]);
-            if (testTime > 0)
-                itnCPR = testTime;
+            testTime=atoi(argv[i+1]);
+            if(testTime >0) timeLimit=testTime;
         }
-        if (strcmp(argv[i], "-noCPR") == 0)
+        
+        if(strcmp (argv[i],"-itnCPR") == 0)
         {
-            noCPR = 1;
+            testTime=atoi(argv[i+1]);
+            if(testTime >0) itnCPR=testTime;
         }
-        if (strcmp(argv[i], "-itnlimit") == 0)
+        if(strcmp (argv[i],"-noCPR") == 0)
         {
-            testTime = atoi(argv[i + 1]);
-            if (testTime > 0)
-                itnLimit = testTime;
+            noCPR=1;
         }
-        if(strcmp (argv[i],"-tasks") == 0)
+        if(strcmp (argv[i],"-itnlimit") == 0)
         {
-            ntasks=atoi(argv[i+1]);
-            if(ntasks <=0) ntasks=0;
+            testTime=atoi(argv[i+1]);
+            if(testTime >0) itnLimit=testTime;
         }
-        if (strcmp(argv[i], "-atol") == 0)
+        if(strcmp (argv[i],"-atol") == 0)
         {
-            double dummy = atof(argv[i + 1]);
-            if (dummy >= 0)
-                aTol = dummy;
+            double dummy=atof(argv[i+1]);
+            if(dummy >=0) aTol=dummy;
         }
-        if (strcmp(argv[i], "-zeroAtt") == 0)
+        if(strcmp (argv[i],"-zeroAtt") == 0)
         {
-            zeroAtt = 1;
+            zeroAtt=1;
         }
-        if (strcmp(argv[i], "-zeroInstr") == 0)
+        if(strcmp (argv[i],"-zeroInstr") == 0)
         {
-            zeroInstr = 1;
+            zeroInstr=1;
         }
-        if (strcmp(argv[i], "-zeroGlob") == 0)
+        if(strcmp (argv[i],"-zeroGlob") == 0)
         {
-            zeroGlob = 1;
+            zeroGlob=1;
         }
-        if (strcmp(argv[i], "-wgic") == 0)
+        if(strcmp (argv[i],"-wgic") == 0)
         {
-            wgInstrCoeff = atoi(argv[i + 1]);
-            if (wgInstrCoeff <= 0)
-                wgInstrCoeff = 1;
+            wgInstrCoeff=atoi(argv[i+1]);
+            if(wgInstrCoeff<=0) wgInstrCoeff=1;
         }
 
         // inputDir e outputDir
-
-        if (strcmp(argv[i], "-inputDir") == 0)
+        
+        if(strcmp (argv[i],"-inputDir") == 0)
         {
-            sprintf(inputDir, "%s", argv[i + 1]);
-            inputDirOpt = 1;
+            sprintf(inputDir, "%s", argv[i+1]);
+            inputDirOpt=1;
         }
-
-        if (strcmp(argv[i], "-outputDir") == 0)
+        
+        if(strcmp (argv[i],"-outputDir") == 0)
         {
-            sprintf(outputDir, "%s", argv[i + 1]);
-            outputDirOpt = 1;
+            sprintf(outputDir, "%s", argv[i+1]);
+            outputDirOpt=1;
         }
-
+        
         // Fine input e output Dir
-
-        if (strcmp(argv[i], "-debug") == 0)
-            debugMode = 1;
-
-        if (strcmp(argv[i], "-wrsol") == 0)
-        {
-            wrsol = 1;
+        
+        if(strcmp (argv[i],"-debug") == 0)
+            debugMode=1;
+        
+        if(strcmp (argv[i],"-wrsol") == 0){
+            wrsol=1;
         }
-
-        if (strcmp(argv[i], "-noiter") == 0)
-        {
-            noIter = 1;
+        
+        if(strcmp (argv[i],"-noiter") == 0){
+            noIter=1;
         }
-
-        if (strcmp(argv[i], "-wrfilebin") == 0)
+        
+        if(strcmp (argv[i],"-wrfilebin") == 0)
         {
-            sprintf(wrfileDir, "%s", argv[i + 1]);
-            wrFilebin = 1;
+            sprintf(wrfileDir, "%s", argv[i+1]);
+            wrFilebin=1;
         }
-        if (strcmp(argv[i], "-extConstr") == 0)
+        if(strcmp (argv[i],"-extConstr") == 0)
         {
-            extConstraint = 1; //extendet external constraint
-            nEqExtConstr = DEFAULT_EXTCONSTROWS;
-            extConstrW = atof(argv[i + 1]);
-            if (extConstrW == 0.0)
-            {
-                printf("ERROR: PE=%d -extConstr option given with no value or zero value ==> %le. Aborting\n", myid, extConstrW);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            extConstraint=1; //extendet external constraint
+            nEqExtConstr=DEFAULT_EXTCONSTROWS;
+            extConstrW=atof(argv[i+1]);
+            if(extConstrW==0.0){
+                printf("ERROR: PE=%d -extConstr option given with no value or zero value ==> %le. Aborting\n",myid,extConstrW);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
         }
-        if (strcmp(argv[i], "-barConstr") == 0)
+        if(strcmp (argv[i],"-barConstr") == 0)
         {
-            barConstraint = 1; //extendet external constraint
-            nEqBarConstr = DEFAULT_BARCONSTROWS;
-            barConstrW = atof(argv[i + 1]);
-            if (barConstrW == 0.0)
-            {
-                printf("ERROR: PE=%d -barConstr option given with no value or zero value ==> %le. Aborting\n", myid, barConstrW);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            barConstraint=1; //extendet external constraint
+            nEqBarConstr=DEFAULT_BARCONSTROWS;
+            barConstrW=atof(argv[i+1]);
+            if(barConstrW==0.0){
+                printf("ERROR: PE=%d -barConstr option given with no value or zero value ==> %le. Aborting\n",myid,barConstrW);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
         }
+        
     }
-    if (extConstraint)
-        noConstr = 2;
-    if (barConstraint)
-        noConstr = 2;
-
-    if (myid == 0)
-    {
-        printf("Execution of solvergaia Simulator version %s on %d mpi-tasks\n solvergaiaSim ", VER, nproc);
-        if (idtest)
-            printf("-IDtest %le ", srIDtest);
-        if (precond)
-            printf("-Precond on");
-        else
-            printf("-Precond off");
-        if (nfileProc != 3)
-            printf("-numFilexproc %d ", nfileProc);
-        if (wrFilebin)
-            printf(" -wrfilebin %s ", wrfileDir);
-        if (!withFile)
-            printf(" -noFile ");
-        if (itnLimit > 0)
-            printf(" -itnlimit %d ", itnLimit);
-        if (noCPR > 0)
-            printf(" -noCPR ");
-        if (itnCPR != DEFAULT_ITNCPR)
-            printf(" -itnCPR %d ", itnCPR);
-        if (zeroAtt)
-            printf(" -zeroAtt ");
-        if (noConstr == 1)
-            printf(" -noConstr ");
-        if (zeroInstr)
-            printf(" -zeroInstr ");
-        if (zeroGlob)
-            printf(" -zeroGlob ");
-        if (inputDirOpt)
-            printf(" -inputDir %s  ", inputDir);
-        if (outputDirOpt)
-            printf(" -outputDir %s ", outputDir);
-        if (wrsol)
-            printf(" -wrsol ");
-        if (noIter)
-            printf(" -noiter ");
-        if (debugMode)
-            printf(" -debug ");
-        if(ntasks>0)
-            printf(" -tasks %d ",ntasks);
-        if (extConstraint)
-            printf("-extConstr %le ", extConstrW);
-        if (barConstraint)
-            printf("-barConstr %le ", barConstrW);
-        printf("-wgic %d", wgInstrCoeff);
-        if (!autoRun)
-            printf(" %s\n", argv[argc - 1]);
-        if (extConstraint && barConstraint)
-        {
+    if (extConstraint) noConstr=2;
+    if (barConstraint) noConstr=2;
+   
+    
+    if(myid==0)
+    {
+        printf("Execution of solvergaia Simulator version %s on %d mpi-tasks\n solvergaiaSim ",VER,nproc); 
+        if(idtest)printf ("-IDtest %le ", srIDtest);
+        if(precond)printf ("-Precond on");
+        else printf ("-Precond off");
+        if(nfileProc!=3) printf ("-numFilexproc %d ",nfileProc);
+       if(wrFilebin) printf(" -wrfilebin %s ",wrfileDir);
+        if(!withFile) printf(" -noFile ");
+        if(itnLimit>0) printf(" -itnlimit %d ",itnLimit);
+        if(noCPR>0) printf(" -noCPR ");
+        if(itnCPR!= DEFAULT_ITNCPR) printf(" -itnCPR %d ", itnCPR);
+        if(zeroAtt) printf(" -zeroAtt ");
+        if(noConstr==1) printf(" -noConstr ");
+        if(zeroInstr) printf(" -zeroInstr ");
+        if(zeroGlob) printf(" -zeroGlob ");
+        if(inputDirOpt) printf(" -inputDir %s  ", inputDir);
+        if(outputDirOpt) printf(" -outputDir %s ", outputDir);
+        if(wrsol) printf(" -wrsol ");
+        if(noIter) printf(" -noiter ");
+        if(debugMode) printf(" -debug ");
+        if(extConstraint)printf("-extConstr %le ",extConstrW);
+        if(barConstraint)printf("-barConstr %le ",barConstrW);
+		printf("-wgic %d", wgInstrCoeff);
+        if(!autoRun) printf(" %s\n",argv[argc-1]);
+        if(extConstraint && barConstraint) {
             printf("Error: baricentric anld null space constraints are mutually exclusive. Aborting\n");
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        if (wrFilebin && strcmp(inputDir, wrfileDir) == 0)
-        {
+        if(wrFilebin && strcmp(inputDir, wrfileDir)==0){
             printf("inputDir and wrfilebinDir are the same. Execution Aborted.\n");
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
+            
         }
-        printf ("\n");
     }
     /////////////////
-    getcwd(wpath, sizePath);
-    if (!inputDirOpt)
+    getcwd(wpath,sizePath);
+    if(!inputDirOpt)
         strcpy(inputDir, wpath);
-    printf("Process %d running on %s\n", myid, processor_name);
-////#ifdef OMP
-///#pragma omp task
+    printf("Process %d running on %s\n",myid,processor_name);
+#ifdef OMP
+#pragma omp parallel
     {
-    //    int tid = omp_get_thread_num();
-       /*
-        const char* s = getenv("NX_SMP_WORKERS");//? "":"1";
-        if(s ==NULL)
-        	s="1";
-        nthreads = atoi(s); //QUI** verifica che la chiamata ritorni il numero di tasks allocati!!
-        */
-        
-        //nthreads sono attuatori
-        // ntasks sono la mia suddivisione
-        nthreads=omp_get_num_threads();
-        if(ntasks==0) 
-            ntasks=nthreads;
-        printf("PE=%d  on processor %s total num of threads =%d, ntasks=%d\n",myid, processor_name,nthreads,ntasks);
+        int tid = omp_get_thread_num();
+        int nthreads = omp_get_num_threads();
+        printf("PE=%d  on processor %s total num of threads =%d   ID thread =%d \n",myid, processor_name,nthreads,tid);
+       	
     }
-////#pragma omp taskwait
-////#endif
-    nullSpaceAttfact = 1.0 * attExtConstrFact * extConstrW;
-    comlsqr.extConstrW = extConstrW;
-    comlsqr.nullSpaceAttfact = nullSpaceAttfact;
-    comlsqr.barConstrW = barConstrW;
-
-    if (inputDirOpt)
+#endif
+    nullSpaceAttfact=1.0*attExtConstrFact*extConstrW;
+    comlsqr.extConstrW=extConstrW;
+    comlsqr.nullSpaceAttfact=nullSpaceAttfact;
+    comlsqr.barConstrW=barConstrW;
+   
+    
+    if(inputDirOpt)
     {
-        if (myid == 0)
-            printf("Checking input directory %s ... ", inputDir);
-        if (!(chdir(inputDir) == 0))
-        {
+        if(myid==0) printf("Checking input directory %s ... ", inputDir);
+        if(!(chdir(inputDir)==0))  {
             printf("Input directory does not exist. Aborting\n");
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
         chdir(wpath);
-        if (myid == 0)
-            printf("success.\n");
+        if(myid==0) printf("success.\n");
     }
-    inputDirLen = strlen(inputDir);
-    sprintf(filenameSolProps, "%s", argv[argc - 1]);
-    sprintf(filenameSolPropsFinal, "GsrFinal_%s", argv[argc - 1]);
-
-    if (outputDirOpt)
+    inputDirLen=strlen(inputDir);
+    sprintf(filenameSolProps, "%s", argv[argc-1]);
+    sprintf(filenameSolPropsFinal,"GsrFinal_%s", argv[argc-1]);
+    
+    if(outputDirOpt)
     {
-        if (myid == 0)
-            printf("Checking output directory %s ...", outputDir);
-        if (!(chdir(outputDir) == 0))
-        {
+        if(myid==0) printf("Checking output directory %s ...", outputDir);
+        if(!(chdir(outputDir)==0)) {
             printf("Output directory does not exist on PE %d. Aborting\n", myid);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        if (myid == 0)
-            printf("success.\n");
+        if(myid==0) printf("success.\n");
     }
-
+  
     ///////////// Initialize the output filename
-    sprintf(filenameAstroResults, "%s", "GsrAstroParamSolution.bin");   // file storing the Astrometric Parameters
-    sprintf(filenameAttResults, "%s", "GsrAttitudeParamSolution.bin");  // file storing the Attitude Parameters
-    sprintf(filenameInstrResults, "%s", "GsrInstrParamSolution.bin");   // file storing the Instrument Parameters
-    sprintf(filenameGlobalResults, "%s", "GsrGlobalParamSolution.bin"); // file storing the Global Parameters
-
-    //    instrConst=(int *) calloc(DEFAULT_NINSTRINDEXES+1 , sizeof(int));
-    instrConst = (int *)calloc(DEFAULT_NINSTRINDEXES, sizeof(int));
-    nAttParAxis = 4;
+    sprintf(filenameAstroResults, "%s", "GsrAstroParamSolution.bin"); // file storing the Astrometric Parameters
+    sprintf(filenameAttResults, "%s","GsrAttitudeParamSolution.bin"); // file storing the Attitude Parameters
+    sprintf(filenameInstrResults, "%s","GsrInstrParamSolution.bin"); // file storing the Instrument Parameters
+    sprintf(filenameGlobalResults, "%s","GsrGlobalParamSolution.bin"); // file storing the Global Parameters
+    
+    
+//    instrConst=(int *) calloc(DEFAULT_NINSTRINDEXES+1 , sizeof(int));
+    instrConst=(int *) calloc(DEFAULT_NINSTRINDEXES , sizeof(int));
+    nAttParAxis=4;
     //START READING filenameSolProps
     //START READING filenameSolProps GsrSolProps.dat
-    if (myid == 0 && wrFilebin)
-    {
+    if(myid==0 && wrFilebin){
         chdir(wpath);
         chdir(wrfileDir);
-        fpSolPropsFileBin = fopen(filenameSolProps, "w");
+        fpSolPropsFileBin=fopen(filenameSolProps,"w");
     }
     chdir(wpath);
-    if (inputDirOpt)
-        chdir(inputDir);
-    if (myid == 0)
-    {
-        if (autoRun)
-        {
-            sphereId = 0;
-            atol = 0.000000;
-            btol = 0.000000;
-            conlim = 10000000000000.000000;
-            itnlim = 2000;
-            if (itnLimit > 0)
-                itnlim = itnLimit;
-            damp = 0.000000;
-            nStar = 10000;
-            nAstroP = 5;
-            nAstroPSolved = 5;
-            nConstrLat = 0;
-            nConstrLong = 0;
-            nConstrMuLat = 0;
-            nConstrMuLong = 0;
-            nDegFreedomAtt = 230489;
-            nAttAxes = 3;
-            instrConst[0] = 1;
-            instrConst[1] = 62;
-            instrConst[2] = 1966;
-            instrConst[3] = 22;
-            nInstrP = 6;
-            nInstrPSolved = 6;
-            lsInstrFlag = 1;
-            ssInstrFlag = 1;
-            nuInstrFlag = 1;
-            maInstrFlag = 1;
-            nOfInstrConstr = -1;
-            nElemIC = -1;
-            nGlobP = 0;
-            nobs = 2400000;
+    if(inputDirOpt) chdir(inputDir);
+    if(myid==0)
+    {
+        if (autoRun){
+            sphereId=0;
+            atol= 0.000000;
+            btol= 0.000000;
+            conlim= 10000000000000.000000;
+            itnlim= 2000;
+            if(itnLimit>0)
+                itnlim=itnLimit;
+            damp= 0.000000;
+            nStar= 10000;
+            nAstroP= 5;
+            nAstroPSolved= 5;
+            nConstrLat= 0;
+            nConstrLong= 0;
+            nConstrMuLat= 0;
+            nConstrMuLong= 0;
+            nDegFreedomAtt= 230489;
+            nAttAxes= 3;
+            instrConst[0]= 1;
+            instrConst[1]= 62;
+            instrConst[2]= 1966;
+            instrConst[3]= 22;
+            nInstrP= 6;
+            nInstrPSolved= 6;
+            lsInstrFlag= 1;
+            ssInstrFlag= 1;
+            nuInstrFlag= 1;
+            maInstrFlag= 1;
+            nOfInstrConstr= -1;
+            nElemIC= -1;
+            nGlobP= 0;
+            nobs= 2400000;
 
             nAstroParam = nStar * nAstroPSolved;
             nAttParam = nDegFreedomAtt * nAttAxes;
-            if (nDegFreedomAtt < 4)
-                nAttParAxis = nDegFreedomAtt;
-            if (nDegFreedomAtt)
-                nAttP = nAttAxes * nAttParAxis;
-            long nFoVs = 1 + instrConst[0];
-            long nCCDs = instrConst[1];
-            long nPixelColumns = instrConst[2];
-            long nTimeIntervals = instrConst[3];
+            if(nDegFreedomAtt<4) nAttParAxis=nDegFreedomAtt;
+            if(nDegFreedomAtt) nAttP = nAttAxes * nAttParAxis;
+            long nFoVs=1+instrConst[0];
+            long nCCDs=instrConst[1];
+            long nPixelColumns=instrConst[2];
+            long nTimeIntervals=instrConst[3];
             // tot. instr. param. = nCCDs (Cmag) + nFoVs*nCCDs (Cnu) + nCCDs*nPixelColumns (delta_eta) + 3*nFoVs*nCCDs*nTimeIntervals (Delta_eta) + nCCDs*nPixelColumns (delta_zeta) + 3*nFoVs*nCCDs*nTimeIntervals (Delta_zeta)
             // added flags switch on and off the appropriate kind of parameters
-            nInstrParam = maInstrFlag * nCCDs + nuInstrFlag * nFoVs * nCCDs + ssInstrFlag * 2 * nCCDs * nPixelColumns + lsInstrFlag * 2 * 3 * nFoVs * nCCDs * nTimeIntervals;
-            nInstrParamTot = nCCDs + nFoVs * nCCDs + 2 * nCCDs * nPixelColumns + 2 * 3 * nFoVs * nCCDs * nTimeIntervals;
-            if (nInstrP == 0)
-                nInstrParamTot = 0;
+            nInstrParam = maInstrFlag*nCCDs+nuInstrFlag*nFoVs*nCCDs+ssInstrFlag*2*nCCDs*nPixelColumns+lsInstrFlag*2*3*nFoVs*nCCDs*nTimeIntervals;
+            nInstrParamTot =  nCCDs+ nFoVs*nCCDs+ 2*nCCDs*nPixelColumns+2*3*nFoVs*nCCDs*nTimeIntervals;
+            if(nInstrP==0) nInstrParamTot=0;
             nGlobalParam = nGlobP;
-
+            
             nparam = nAstroPSolved + nAttP + nInstrPSolved + nGlobP;
-            if (memGlobal != 0)
-            {
-                memGB = simfullram(nStar, nobs, memGlobal, nparam, nAttParam, nInstrParam);
-                printf("Running with memory %f GB, nStar=%d nobs=%ld\n", memGB, nStar, nobs);
+            if(memGlobal!=0){
+                memGB=simfullram(nStar,nobs,memGlobal,nparam,nAttParam,nInstrParam);
+                printf("Running with memory %f GB, nStar=%d nobs=%ld\n",memGB, nStar,nobs);
             }
             printf("sphereId= %7ld\n", sphereId);
             printf("atol= %18.15lf\n", atol);
@@ -619,7 +557,7 @@ int main(int argc, char **argv)
             printf("nConstrMuLong= %5ld\n", nConstrMuLong);
             printf("nDegFreedomAtt= %7ld\n", nDegFreedomAtt);
             printf("nAttAxes= %7hd\n", nAttAxes);
-            printf("nFovs= %7d ", instrConst[0] + 1);
+            printf("nFovs= %7d ", instrConst[0]+1);
             printf("(instrConst[0])= %7d\n", instrConst[0]);
             printf("nCCDs= %7d\n", instrConst[1]);
             printf("nPixelColumns= %7d\n", instrConst[2]);
@@ -634,750 +572,616 @@ int main(int argc, char **argv)
             printf("nElemIC= %7d\n", nElemIC);
             printf("nGlobP= %7hd\n", nGlobP);
             printf("nObs= %10ld\n", nobs);
-            if (wrFilebin)
-            {
-                fprintf(fpSolPropsFileBin, "sphereId= %ld\n", sphereId);
-                fprintf(fpSolPropsFileBin, "atol= %lf\n", atol);
-                fprintf(fpSolPropsFileBin, "btol= %lf\n", btol);
-                fprintf(fpSolPropsFileBin, "conlim= %lf\n", conlim);
-                fprintf(fpSolPropsFileBin, "itnlim= %ld\n", itnlim);
-                fprintf(fpSolPropsFileBin, "damp= %lf\n", damp);
-                fprintf(fpSolPropsFileBin, "nStar= %ld\n", nStar);
-                fprintf(fpSolPropsFileBin, "nAstroP= %hd\n", nAstroP);
-                fprintf(fpSolPropsFileBin, "nAstroPSolved= %hd\n", nAstroPSolved);
-                fprintf(fpSolPropsFileBin, "nConstrLat= 0\n");
-                fprintf(fpSolPropsFileBin, "nConstrLong= 0\n");
-                fprintf(fpSolPropsFileBin, "nConstrMuLat= 0\n");
-                fprintf(fpSolPropsFileBin, "nConstrMuLong= 0\n");
-                fprintf(fpSolPropsFileBin, "nDegFreedomAtt= %ld\n", nDegFreedomAtt);
-                fprintf(fpSolPropsFileBin, "nAttAxes= %hd\n", nAttAxes);
-                fprintf(fpSolPropsFileBin, "nFoVs= %d\n", instrConst[0]);
-                fprintf(fpSolPropsFileBin, "nCCDs= %d\n", instrConst[1]);
-                fprintf(fpSolPropsFileBin, "nPixelColumns= %d\n", instrConst[2]);
-                fprintf(fpSolPropsFileBin, "nTimeIntervals= %d\n", instrConst[3]);
-                fprintf(fpSolPropsFileBin, "nInstrP= %hd\n", nInstrP);
-                fprintf(fpSolPropsFileBin, "nInstrPSolved= %hd\n", nInstrPSolved);
-                fprintf(fpSolPropsFileBin, "lsInstrFlag= %hd\n", lsInstrFlag);
-                fprintf(fpSolPropsFileBin, "ssInstrFlag= %hd\n", ssInstrFlag);
-                fprintf(fpSolPropsFileBin, "nuInstrFlag= %hd\n", nuInstrFlag);
-                fprintf(fpSolPropsFileBin, "maInstrFlag= %hd\n", maInstrFlag);
-                fprintf(fpSolPropsFileBin, "nOfInstrConstr= %d\n", nOfInstrConstr);
-                fprintf(fpSolPropsFileBin, "nElemIC= %d\n", nElemIC);
-                fprintf(fpSolPropsFileBin, "nGlobP= %hd\n", nGlobP);
-                fprintf(fpSolPropsFileBin, "nObs= %ld\n", nobs);
+            if(wrFilebin){
+                fprintf(fpSolPropsFileBin,"sphereId= %ld\n", sphereId);
+                fprintf(fpSolPropsFileBin,"atol= %lf\n", atol);
+                fprintf(fpSolPropsFileBin,"btol= %lf\n", btol);
+                fprintf(fpSolPropsFileBin,"conlim= %lf\n", conlim);
+                fprintf(fpSolPropsFileBin,"itnlim= %ld\n", itnlim);
+                fprintf(fpSolPropsFileBin,"damp= %lf\n", damp);
+                fprintf(fpSolPropsFileBin,"nStar= %ld\n", nStar);
+                fprintf(fpSolPropsFileBin,"nAstroP= %hd\n", nAstroP);
+                fprintf(fpSolPropsFileBin,"nAstroPSolved= %hd\n", nAstroPSolved);
+                fprintf(fpSolPropsFileBin,"nConstrLat= 0\n");
+                fprintf(fpSolPropsFileBin,"nConstrLong= 0\n");
+                fprintf(fpSolPropsFileBin,"nConstrMuLat= 0\n");
+                fprintf(fpSolPropsFileBin,"nConstrMuLong= 0\n");
+                fprintf(fpSolPropsFileBin,"nDegFreedomAtt= %ld\n", nDegFreedomAtt);
+                fprintf(fpSolPropsFileBin,"nAttAxes= %hd\n", nAttAxes);
+                fprintf(fpSolPropsFileBin,"nFoVs= %d\n", instrConst[0]);
+                fprintf(fpSolPropsFileBin,"nCCDs= %d\n", instrConst[1]);
+                fprintf(fpSolPropsFileBin,"nPixelColumns= %d\n", instrConst[2]);
+                fprintf(fpSolPropsFileBin,"nTimeIntervals= %d\n", instrConst[3]);
+                fprintf(fpSolPropsFileBin,"nInstrP= %hd\n", nInstrP);
+                fprintf(fpSolPropsFileBin,"nInstrPSolved= %hd\n", nInstrPSolved);
+                fprintf(fpSolPropsFileBin,"lsInstrFlag= %hd\n", lsInstrFlag);
+                fprintf(fpSolPropsFileBin,"ssInstrFlag= %hd\n", ssInstrFlag);
+                fprintf(fpSolPropsFileBin,"nuInstrFlag= %hd\n", nuInstrFlag);
+                fprintf(fpSolPropsFileBin,"maInstrFlag= %hd\n", maInstrFlag);
+                fprintf(fpSolPropsFileBin,"nOfInstrConstr= %d\n", nOfInstrConstr);
+                fprintf(fpSolPropsFileBin,"nElemIC= %d\n", nElemIC);
+                fprintf(fpSolPropsFileBin,"nGlobP= %hd\n", nGlobP);
+                fprintf(fpSolPropsFileBin,"nObs= %ld\n", nobs);
 
                 fclose(fpSolPropsFileBin);
             }
+        }else{
+        fpSolProps=fopen(filenameSolProps,"r");
+        if (!fpSolProps)
+        {
+            printf("Error while open %s\n",filenameSolProps);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        
+        if(fscanf(fpSolProps, "sphereId= %ld\n",&sphereId) != 1) {
+            printf("Error reading sphereId  %ld \n",sphereId);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("sphereId= %7ld\n", sphereId);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"sphereId= %ld\n", sphereId);
+        
+        if(fscanf(fpSolProps, "atol= %lf\n",&atol) != 1) {
+            printf("Error reading atol  %lf \n",atol);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(aTol >=0)
+            atol=aTol;
+        printf("atol= %18.15lf\n", atol);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"atol= %lf\n", atol);
+        
+        if(fscanf(fpSolProps, "btol= %lf\n",&btol) != 1) {
+            printf("Error reading btol  %lf \n",btol);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("btol= %18.15lf\n", btol);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"btol= %lf\n", btol);
+        
+        if(fscanf(fpSolProps, "conlim= %lf\n",&conlim) != 1) {
+            printf("Error reading conlim  %lf \n",conlim);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("conlim= %18.15le\n", conlim);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"conlim= %lf\n", conlim);
+        
+        if(fscanf(fpSolProps, "itnlim= %ld\n",&itnlim) != 1) {
+            printf("Error reading itnlim  %ld \n",itnlim);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(itnLimit>0)
+            itnlim=itnLimit;
+        printf("itnlim= %7ld\n", itnlim);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"itnlim= %ld\n", itnlim);
+        
+        if(fscanf(fpSolProps, "damp= %lf\n",&damp) != 1) {
+            printf("Error reading damp  %lf \n",damp);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("damp= %18.15lf\n", damp);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"damp= %lf\n", damp);
+        
+        if(fscanf(fpSolProps, "nStar= %ld\n",&nStar) != 1) {
+            printf("Error reading nStar  %ld \n",nStar);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nStar= %7ld\n", nStar);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nStar= %ld\n", nStar);
+        
+        if(fscanf(fpSolProps, "nAstroP= %hd\n",&nAstroP) != 1) {
+            printf("Error reading nAstroP  %hd \n",nAstroP);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nAstroP= %7hd\n", nAstroP);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nAstroP= %hd\n", nAstroP);
+        
+        if(fscanf(fpSolProps, "nAstroPSolved= %hd\n",&nAstroPSolved) != 1) {
+            printf("Error reading nAstroPSolved  %hd \n",nAstroPSolved);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
         }
-        else
+        printf("nAstroPSolved= %hd\n", nAstroPSolved);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nAstroPSolved= %hd\n", nAstroPSolved);
+        
+        if(fscanf(fpSolProps, "nConstrLat= %ld\n",&nConstrLat) != 1) {
+            printf("Error reading nConstrLat  %ld \n",nConstrLat);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nConstrLat= %5ld\n", nConstrLat);
+        if(wrFilebin){
+            if(noConstr) fprintf(fpSolPropsFileBin,"nConstrLat= 0\n");
+            else fprintf(fpSolPropsFileBin,"nConstrLat= %ld\n", nConstrLat);
+        }
+        if(nConstrLat>0)
         {
-            fpSolProps = fopen(filenameSolProps, "r");
-            if (!fpSolProps)
-            {
-                printf("Error while open %s\n", filenameSolProps);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-
-            if (fscanf(fpSolProps, "sphereId= %ld\n", &sphereId) != 1)
-            {
-                printf("Error reading sphereId  %ld \n", sphereId);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("sphereId= %7ld\n", sphereId);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "sphereId= %ld\n", sphereId);
-
-            if (fscanf(fpSolProps, "atol= %lf\n", &atol) != 1)
-            {
-                printf("Error reading atol  %lf \n", atol);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (aTol >= 0)
-                atol = aTol;
-            printf("atol= %18.15lf\n", atol);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "atol= %lf\n", atol);
-
-            if (fscanf(fpSolProps, "btol= %lf\n", &btol) != 1)
-            {
-                printf("Error reading btol  %lf \n", btol);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("btol= %18.15lf\n", btol);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "btol= %lf\n", btol);
-
-            if (fscanf(fpSolProps, "conlim= %lf\n", &conlim) != 1)
-            {
-                printf("Error reading conlim  %lf \n", conlim);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("conlim= %18.15le\n", conlim);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "conlim= %lf\n", conlim);
-
-            if (fscanf(fpSolProps, "itnlim= %ld\n", &itnlim) != 1)
-            {
-                printf("Error reading itnlim  %ld \n", itnlim);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (itnLimit > 0)
-                itnlim = itnLimit;
-            printf("itnlim= %7ld\n", itnlim);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "itnlim= %ld\n", itnlim);
-
-            if (fscanf(fpSolProps, "damp= %lf\n", &damp) != 1)
-            {
-                printf("Error reading damp  %lf \n", damp);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("damp= %18.15lf\n", damp);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "damp= %lf\n", damp);
-
-            if (fscanf(fpSolProps, "nStar= %ld\n", &nStar) != 1)
-            {
-                printf("Error reading nStar  %ld \n", nStar);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nStar= %7ld\n", nStar);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nStar= %ld\n", nStar);
-
-            if (fscanf(fpSolProps, "nAstroP= %hd\n", &nAstroP) != 1)
-            {
-                printf("Error reading nAstroP  %hd \n", nAstroP);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nAstroP= %7hd\n", nAstroP);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nAstroP= %hd\n", nAstroP);
-
-            if (fscanf(fpSolProps, "nAstroPSolved= %hd\n", &nAstroPSolved) != 1)
-            {
-                printf("Error reading nAstroPSolved  %hd \n", nAstroPSolved);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nAstroPSolved= %hd\n", nAstroPSolved);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nAstroPSolved= %hd\n", nAstroPSolved);
-
-            if (fscanf(fpSolProps, "nConstrLat= %ld\n", &nConstrLat) != 1)
-            {
-                printf("Error reading nConstrLat  %ld \n", nConstrLat);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nConstrLat= %5ld\n", nConstrLat);
-            if (wrFilebin)
-            {
-                if (noConstr)
-                    fprintf(fpSolPropsFileBin, "nConstrLat= 0\n");
-                else
-                    fprintf(fpSolPropsFileBin, "nConstrLat= %ld\n", nConstrLat);
-            }
-            if (nConstrLat > 0)
-            {
-                constrLatId = (long *)calloc(nConstrLat, sizeof(long));
-                for (i = 0; i < nConstrLat - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%ld ", &constrLatId[i]) != 1)
-                    {
-                        printf("Error reading constrLatId[%d]  %ld \n", i, constrLatId[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrLatId[%d]=%7ld ", i, constrLatId[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%ld ", constrLatId[i]);
-                }
-                if (fscanf(fpSolProps, "%ld\n", &constrLatId[nConstrLat - 1]) != 1)
-                {
-                    printf("Error reading constrLatId[nConstrLat-1] %ld \n", constrLatId[nConstrLat - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+            constrLatId = (long *) calloc(nConstrLat, sizeof(long));
+            for(i=0;i<nConstrLat-1;i++) {
+                if(fscanf(fpSolProps, "%ld ",&constrLatId[i]) != 1) {
+                    printf("Error reading constrLatId[%d]  %ld \n",i,constrLatId[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrLatId[nConstrLat-1]=%7ld\n", constrLatId[nConstrLat - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%ld\n", constrLatId[nConstrLat - 1]);
-
-                constrLatW = (double *)calloc(nConstrLat, sizeof(double));
-                for (i = 0; i < nConstrLat - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%lf ", &constrLatW[i]) != 1)
-                    {
-                        printf("Error reading constrLatW[%d]  %lf \n", i, constrLatW[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrLatW[%d]=%18.15le ", i, constrLatW[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%lf ", constrLatW[i]);
-                }
-                if (fscanf(fpSolProps, "%lf\n", &constrLatW[nConstrLat - 1]) != 1)
-                {
-                    printf("Error reading constrLatW[nConstrLat-1]  %lf \n", constrLatW[nConstrLat - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                if(debugMode) printf("constrLatId[%d]=%7ld ",i,constrLatId[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld ",constrLatId[i]);
+            }
+            if(fscanf(fpSolProps, "%ld\n",&constrLatId[nConstrLat-1]) != 1) {
+                printf("Error reading constrLatId[nConstrLat-1] %ld \n", constrLatId[nConstrLat-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
+                exit(EXIT_FAILURE);
+            }
+            if(debugMode) printf("constrLatId[nConstrLat-1]=%7ld\n",constrLatId[nConstrLat-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld\n",constrLatId[nConstrLat-1]);
+            
+            constrLatW = (double *) calloc(nConstrLat, sizeof(double));
+            for(i=0;i<nConstrLat-1;i++) {
+                if(fscanf(fpSolProps, "%lf ",&constrLatW[i]) != 1) {
+                    printf("Error reading constrLatW[%d]  %lf \n",i,constrLatW[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrLatW[nConstrLat-1]=%18.15lf\n", constrLatW[nConstrLat - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%lf\n", constrLatW[nConstrLat - 1]);
+                if(debugMode) printf("constrLatW[%d]=%18.15le ",i,constrLatW[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf ",constrLatW[i]);
             }
-
-            if (fscanf(fpSolProps, "nConstrLong= %ld\n", &nConstrLong) != 1)
-            {
-                printf("Error reading nConstrLong  %ld \n", nConstrLong);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            if(fscanf(fpSolProps, "%lf\n",&constrLatW[nConstrLat-1]) != 1) {
+                printf("Error reading constrLatW[nConstrLat-1]  %lf \n", constrLatW[nConstrLat-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            printf("nConstrLong= %5ld\n", nConstrLong);
-            if (wrFilebin)
-            {
-                if (noConstr)
-                    fprintf(fpSolPropsFileBin, "nConstrLong= 0\n");
-                else
-                    fprintf(fpSolPropsFileBin, "nConstrLong= %ld\n", nConstrLong);
-            }
-            if (nConstrLong > 0)
-            {
-                constrLongId = (long *)calloc(nConstrLong, sizeof(long));
-                for (i = 0; i < nConstrLong - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%ld ", &constrLongId[i]) != 1)
-                    {
-                        printf("Error reading constrLongId[%d]  %ld \n", i, constrLongId[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrLongId[%d]=%7ld ", i, constrLongId[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%ld ", constrLongId[i]);
-                }
-                if (fscanf(fpSolProps, "%ld\n", &constrLongId[nConstrLong - 1]) != 1)
-                {
-                    printf("Error reading constrLongId[nConstrLong-1]  %ld \n", constrLongId[nConstrLong - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+            if(debugMode) printf("constrLatW[nConstrLat-1]=%18.15lf\n",constrLatW[nConstrLat-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf\n",constrLatW[nConstrLat-1]);
+        }
+        
+        if(fscanf(fpSolProps, "nConstrLong= %ld\n",&nConstrLong) != 1) {
+            printf("Error reading nConstrLong  %ld \n",nConstrLong);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nConstrLong= %5ld\n", nConstrLong);
+        if(wrFilebin){
+            if(noConstr) fprintf(fpSolPropsFileBin,"nConstrLong= 0\n");
+            else fprintf(fpSolPropsFileBin,"nConstrLong= %ld\n", nConstrLong);
+        }
+        if(nConstrLong>0)
+        {
+            constrLongId = (long *) calloc(nConstrLong, sizeof(long));
+            for(i=0;i<nConstrLong-1;i++) {
+                if(fscanf(fpSolProps, "%ld ",&constrLongId[i]) != 1) {
+                    printf("Error reading constrLongId[%d]  %ld \n",i,constrLongId[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrLongId[nConstrLong-1]=%7ld\n", constrLongId[nConstrLong - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%ld\n", constrLongId[nConstrLong - 1]);
-
-                constrLongW = (double *)calloc(nConstrLong, sizeof(double));
-                for (i = 0; i < nConstrLong - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%lf ", &constrLongW[i]) != 1)
-                    {
-                        printf("Error reading constrLongW[%d]  %lf \n", i, constrLongW[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrLongW[%d]=%18.15le ", i, constrLongW[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%lf ", constrLongW[i]);
-                }
-                if (fscanf(fpSolProps, "%lf\n", &constrLongW[nConstrLong - 1]) != 1)
-                {
-                    printf("Error reading constrLongW[nConstrLong-1]  %lf \n", constrLongW[nConstrLong - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                if(debugMode) printf("constrLongId[%d]=%7ld ",i,constrLongId[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld ",constrLongId[i]);
+            }
+            if(fscanf(fpSolProps, "%ld\n",&constrLongId[nConstrLong-1]) != 1) {
+                printf("Error reading constrLongId[nConstrLong-1]  %ld \n", constrLongId[nConstrLong-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
+                exit(EXIT_FAILURE);
+            }
+            if(debugMode) printf("constrLongId[nConstrLong-1]=%7ld\n",constrLongId[nConstrLong-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld\n",constrLongId[nConstrLong-1]);
+            
+            constrLongW = (double *) calloc(nConstrLong, sizeof(double));
+            for(i=0;i<nConstrLong-1;i++) {
+                if(fscanf(fpSolProps, "%lf ",&constrLongW[i]) != 1) {
+                    printf("Error reading constrLongW[%d]  %lf \n",i,constrLongW[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrLongW[nConstrLong-1]=%18.15lf\n", constrLongW[nConstrLong - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%lf\n", constrLongW[nConstrLong - 1]);
+                if(debugMode) printf("constrLongW[%d]=%18.15le ",i,constrLongW[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf ",constrLongW[i]);
             }
-
-            if (fscanf(fpSolProps, "nConstrMuLat= %ld\n", &nConstrMuLat) != 1)
-            {
-                printf("Error reading nConstrMuLat  %ld \n", nConstrMuLat);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            if(fscanf(fpSolProps, "%lf\n",&constrLongW[nConstrLong-1]) != 1) {
+                printf("Error reading constrLongW[nConstrLong-1]  %lf \n", constrLongW[nConstrLong-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            printf("nConstrMuLat= %5ld\n", nConstrMuLat);
-            if (wrFilebin)
-            {
-                if (noConstr)
-                    fprintf(fpSolPropsFileBin, "nConstrMuLat= 0\n");
-                else
-                    fprintf(fpSolPropsFileBin, "nConstrMuLat= %ld\n", nConstrMuLat);
-            }
-
-            if (nConstrMuLat > 0)
-            {
-                constrMuLatId = (long *)calloc(nConstrMuLat, sizeof(long));
-                for (i = 0; i < nConstrMuLat - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%ld ", &constrMuLatId[i]) != 1)
-                    {
-                        printf("Error reading constrMuLatId[%d]  %ld \n", i, constrMuLatId[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrMuLatId[%d]=%7ld ", i, constrMuLatId[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%ld ", constrMuLatId[i]);
-                }
-                if (fscanf(fpSolProps, "%ld\n", &constrMuLatId[nConstrMuLat - 1]) != 1)
-                {
-                    printf("Error reading constrMuLatId[nConstrMuLat-1]  %ld \n", constrMuLatId[nConstrMuLat - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+            if(debugMode) printf("constrLongW[nConstrLong-1]=%18.15lf\n",constrLongW[nConstrLong-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf\n",constrLongW[nConstrLong-1]);
+        }
+        
+        if(fscanf(fpSolProps, "nConstrMuLat= %ld\n",&nConstrMuLat) != 1) {
+            printf("Error reading nConstrMuLat  %ld \n",nConstrMuLat);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nConstrMuLat= %5ld\n", nConstrMuLat);
+        if(wrFilebin){
+            if(noConstr) fprintf(fpSolPropsFileBin,"nConstrMuLat= 0\n");
+            else fprintf(fpSolPropsFileBin,"nConstrMuLat= %ld\n", nConstrMuLat);
+        }
+        
+        if(nConstrMuLat>0)
+        {
+            constrMuLatId = (long *) calloc(nConstrMuLat, sizeof(long));
+            for(i=0;i<nConstrMuLat-1;i++) {
+                if(fscanf(fpSolProps, "%ld ",&constrMuLatId[i]) != 1) {
+                    printf("Error reading constrMuLatId[%d]  %ld \n",i,constrMuLatId[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrMuLatId[nConstrMuLat-1]=%7ld\n", constrMuLatId[nConstrMuLat - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%ld\n", constrMuLatId[nConstrMuLat - 1]);
-
-                constrMuLatW = (double *)calloc(nConstrMuLat, sizeof(double));
-                for (i = 0; i < nConstrMuLat - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%lf ", &constrMuLatW[i]) != 1)
-                    {
-                        printf("Error reading constrMuLatW[%d]  %lf \n", i, constrMuLatW[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrMuLatW[%d]=%18.15le ", i, constrMuLatW[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%lf ", constrMuLatW[i]);
-                }
-                if (fscanf(fpSolProps, "%lf\n", &constrMuLatW[nConstrMuLat - 1]) != 1)
-                {
-                    printf("Error reading constrMuLatW[nConstrMuLat-1]  %lf \n", constrMuLatW[nConstrMuLat - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                if(debugMode) printf("constrMuLatId[%d]=%7ld ",i,constrMuLatId[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld ",constrMuLatId[i]);
+            }
+            if(fscanf(fpSolProps, "%ld\n",&constrMuLatId[nConstrMuLat-1]) != 1) {
+                printf("Error reading constrMuLatId[nConstrMuLat-1]  %ld \n", constrMuLatId[nConstrMuLat-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
+                exit(EXIT_FAILURE);
+            }
+            if(debugMode) printf("constrMuLatId[nConstrMuLat-1]=%7ld\n",constrMuLatId[nConstrMuLat-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld\n",constrMuLatId[nConstrMuLat-1]);
+            
+            constrMuLatW = (double *) calloc(nConstrMuLat, sizeof(double));
+            for(i=0;i<nConstrMuLat-1;i++) {
+                if(fscanf(fpSolProps, "%lf ",&constrMuLatW[i]) != 1) {
+                    printf("Error reading constrMuLatW[%d]  %lf \n",i,constrMuLatW[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrMuLatW[nConstrMuLat-1]=%18.15lf\n", constrMuLatW[nConstrMuLat - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%lf\n", constrMuLatW[nConstrMuLat - 1]);
+                if(debugMode) printf("constrMuLatW[%d]=%18.15le ",i,constrMuLatW[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf ",constrMuLatW[i]);
             }
-
-            if (fscanf(fpSolProps, "nConstrMuLong= %ld\n", &nConstrMuLong) != 1)
-            {
-                printf("Error reading nConstrMuLong  %ld \n", nConstrMuLong);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            if(fscanf(fpSolProps, "%lf\n",&constrMuLatW[nConstrMuLat-1]) != 1) {
+                printf("Error reading constrMuLatW[nConstrMuLat-1]  %lf \n", constrMuLatW[nConstrMuLat-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            printf("nConstrMuLong= %5ld\n", nConstrMuLong);
-            if (wrFilebin)
-            {
-                if (noConstr)
-                    fprintf(fpSolPropsFileBin, "nConstrMuLong= 0\n");
-                else
-                    fprintf(fpSolPropsFileBin, "nConstrMuLong= %ld\n", nConstrMuLong);
-            }
-            if (nConstrMuLong > 0)
-            {
-                constrMuLongId = (long *)calloc(nConstrMuLong, sizeof(long));
-                for (i = 0; i < nConstrMuLong - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%ld ", &constrMuLongId[i]) != 1)
-                    {
-                        printf("Error reading constrMuLongId[%d]  %ld \n", i, constrMuLongId[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrMuLongId[%d]=%7ld ", i, constrMuLongId[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%7ld ", constrMuLongId[i]);
-                }
-                if (fscanf(fpSolProps, "%ld\n", &constrMuLongId[nConstrMuLong - 1]) != 1)
-                {
-                    printf("Error reading constrMuLongId[nConstrMuLong-1]  %ld \n", constrMuLongId[nConstrMuLong - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+            if(debugMode) printf("constrMuLatW[nConstrMuLat-1]=%18.15lf\n",constrMuLatW[nConstrMuLat-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf\n",constrMuLatW[nConstrMuLat-1]);
+            
+        }
+        
+        if(fscanf(fpSolProps, "nConstrMuLong= %ld\n",&nConstrMuLong) != 1) {
+            printf("Error reading nConstrMuLong  %ld \n",nConstrMuLong);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nConstrMuLong= %5ld\n", nConstrMuLong);
+        if(wrFilebin){
+            if(noConstr) fprintf(fpSolPropsFileBin,"nConstrMuLong= 0\n");
+            else fprintf(fpSolPropsFileBin,"nConstrMuLong= %ld\n", nConstrMuLong);
+        }
+        if(nConstrMuLong>0)
+        {
+            constrMuLongId = (long *) calloc(nConstrMuLong, sizeof(long));
+            for(i=0;i<nConstrMuLong-1;i++) {
+                if(fscanf(fpSolProps, "%ld ",&constrMuLongId[i]) != 1) {
+                    printf("Error reading constrMuLongId[%d]  %ld \n",i,constrMuLongId[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrMuLongId[nConstrMuLong-1]=%7ld\n", constrMuLongId[nConstrMuLong - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%ld\n", constrMuLongId[nConstrMuLong - 1]);
-
-                constrMuLongW = (double *)calloc(nConstrMuLong, sizeof(double));
-                for (i = 0; i < nConstrMuLong - 1; i++)
-                {
-                    if (fscanf(fpSolProps, "%lf ", &constrMuLongW[i]) != 1)
-                    {
-                        printf("Error reading constrMuLongW[%d]  %lf \n", i, constrMuLongW[i]);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
-                        exit(EXIT_FAILURE);
-                    }
-                    if (debugMode)
-                        printf("constrMuLongW[%d]=%18.15le ", i, constrMuLongW[i]);
-                    if (wrFilebin && !noConstr)
-                        fprintf(fpSolPropsFileBin, "%lf ", constrMuLongW[i]);
-                }
-                if (fscanf(fpSolProps, "%lf\n", &constrMuLongW[nConstrMuLong - 1]) != 1)
-                {
-                    printf("Error reading constrMuLongW[nConstrMuLong-1]  %lf \n", constrMuLongW[nConstrMuLong - 1]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                if(debugMode) printf("constrMuLongId[%d]=%7ld ",i,constrMuLongId[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%7ld ",constrMuLongId[i]);
+            }
+            if(fscanf(fpSolProps, "%ld\n",&constrMuLongId[nConstrMuLong-1]) != 1) {
+                printf("Error reading constrMuLongId[nConstrMuLong-1]  %ld \n", constrMuLongId[nConstrMuLong-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
+                exit(EXIT_FAILURE);
+            }
+            if(debugMode) printf("constrMuLongId[nConstrMuLong-1]=%7ld\n",constrMuLongId[nConstrMuLong-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%ld\n",constrMuLongId[nConstrMuLong-1]);
+            
+            constrMuLongW = (double *) calloc(nConstrMuLong, sizeof(double));
+            for(i=0;i<nConstrMuLong-1;i++) {
+                if(fscanf(fpSolProps, "%lf ",&constrMuLongW[i]) != 1) {
+                    printf("Error reading constrMuLongW[%d]  %lf \n",i,constrMuLongW[i]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                if (debugMode)
-                    printf("constrMuLongW[nConstrMuLong-1]=%18.15lf\n", constrMuLongW[nConstrMuLong - 1]);
-                if (wrFilebin && !noConstr)
-                    fprintf(fpSolPropsFileBin, "%lf\n", constrMuLongW[nConstrMuLong - 1]);
-            }
-
-            if (fscanf(fpSolProps, "nDegFreedomAtt= %ld\n", &nDegFreedomAtt) != 1)
-            {
-                printf("Error reading nDegFreedomAtt  %ld \n", nDegFreedomAtt);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
+                if(debugMode) printf("constrMuLongW[%d]=%18.15le ",i,constrMuLongW[i]);
+                if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf ",constrMuLongW[i]);
             }
-            if (zeroAtt)
-                nDegFreedomAtt = 0;
-            printf("nDegFreedomAtt= %7ld\n", nDegFreedomAtt);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nDegFreedomAtt= %ld\n", nDegFreedomAtt);
-
-            if (fscanf(fpSolProps, "nAttAxes= %hd\n", &nAttAxes) != 1)
-            {
-                printf("Error reading nAttAxes  %hd \n", nAttAxes);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+            if(fscanf(fpSolProps, "%lf\n",&constrMuLongW[nConstrMuLong-1]) != 1) {
+                printf("Error reading constrMuLongW[nConstrMuLong-1]  %lf \n", constrMuLongW[nConstrMuLong-1]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            if (zeroAtt)
-                nAttAxes = 0;
-            printf("nAttAxes= %7hd\n", nAttAxes);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nAttAxes= %hd\n", nAttAxes);
-
-            if (fscanf(fpSolProps, "nFoVs= %d\n", &instrConst[0]) != 1)
-            {
-                printf("Error reading nFoVs  %d \n", instrConst[0]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroInstr)
-                instrConst[0] = 0;
-            // instrConst[0] must be  0 or 1 because nFoVs = 2 for Gaia and nFoVs=1+instrConst[0]
-            if (instrConst[0] < 0 || instrConst[0] > 1)
-            {
-                printf("Execution aborted  with invalid nFovs=%d\n", instrConst[0] + 1);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nFovs= %7d ", instrConst[0] + 1);
-            printf("(instrConst[0])= %7d\n", instrConst[0]);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nFoVs= %d\n", instrConst[0]);
-
-            if (fscanf(fpSolProps, "nCCDs= %d\n", &instrConst[1]) != 1)
-            {
-                printf("Error reading nCCDs  %d \n", instrConst[1]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroInstr)
-                instrConst[1] = 0;
-            printf("nCCDs= %7d\n", instrConst[1]);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nCCDs= %d\n", instrConst[1]);
-
-            if (fscanf(fpSolProps, "nPixelColumns= %d\n", &instrConst[2]) != 1)
-            {
-                printf("Error reading nPixelColumns  %d \n", instrConst[2]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroInstr)
-                instrConst[2] = 0;
-            printf("nPixelColumns= %7d\n", instrConst[2]);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nPixelColumns= %d\n", instrConst[2]);
-
-            if (fscanf(fpSolProps, "nTimeIntervals= %d\n", &instrConst[3]) != 1)
-            {
-                printf("Error reading nTimeIntervals  %d \n", instrConst[3]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroInstr)
-                instrConst[3] = 0;
-            printf("nTimeIntervals= %7d\n", instrConst[3]);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nTimeIntervals= %d\n", instrConst[3]);
-
-            if (fscanf(fpSolProps, "nInstrP= %hd\n", &nInstrP) != 1)
-            {
-                printf("Error reading nInstrP  %hd \n", nInstrP);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroInstr)
-                nInstrP = 0;
-            printf("nInstrP= %7hd\n", nInstrP);
-            if (nInstrP != 0 && nInstrP != 6)
-            {
-                printf("Execution aborted  with invalid nInstrP\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nInstrP= %hd\n", nInstrP);
-            if (fscanf(fpSolProps, "nInstrPSolved= %hd\n", &nInstrPSolved) != 1)
-            {
-                printf("Error reading nInstrPSolved  %hd \n", nInstrPSolved);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nInstrPSolved= %7hd\n", nInstrPSolved);
-
-            if (nInstrPSolved < 0 || nInstrPSolved > 6)
-            {
-                printf("Execution aborted  with invalid nInstrPSolved\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nInstrPSolved= %hd\n", nInstrPSolved);
-
-            if (fscanf(fpSolProps, "lsInstrFlag= %d\n", &lsInstrFlag) != 1)
-            {
-                printf("Error reading lsInstrFlag  %d \n", lsInstrFlag);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("lsInstrFlag= %7d\n", lsInstrFlag);
-
-            if (lsInstrFlag < 0 || lsInstrFlag > 1)
-            {
-                printf("Execution aborted  with invalid lsInstrFlag\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "lsInstrFlag= %hd\n", lsInstrFlag);
-            if (fscanf(fpSolProps, "ssInstrFlag= %d\n", &ssInstrFlag) != 1)
-            {
-                printf("Error reading ssInstrFlag  %d \n", ssInstrFlag);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("ssInstrFlag= %7d\n", ssInstrFlag);
-
-            if (ssInstrFlag < 0 || ssInstrFlag > 1)
-            {
-                printf("Execution aborted  with invalid ssInstrFlag\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "ssInstrFlag= %hd\n", ssInstrFlag);
-            if (fscanf(fpSolProps, "nuInstrFlag= %d\n", &nuInstrFlag) != 1)
-            {
-                printf("Error reading nuInstrFlag  %d \n", nuInstrFlag);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nuInstrFlag= %7d\n", nuInstrFlag);
-
-            if (nuInstrFlag < 0 || nuInstrFlag > 1)
-            {
-                printf("Execution aborted  with invalid lsInstrFlag\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nuInstrFlag= %hd\n", nuInstrFlag);
-            if (fscanf(fpSolProps, "maInstrFlag= %d\n", &maInstrFlag) != 1)
-            {
-                printf("Error reading maInstrFlag  %d \n", maInstrFlag);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("maInstrFlag= %7d\n", maInstrFlag);
-
-            if (maInstrFlag < 0 || maInstrFlag > 1)
-            {
-                printf("Execution aborted  with invalid maInstrFlag\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "maInstrFlag= %hd\n", maInstrFlag);
-
-            if (nInstrPSolved != maInstrFlag + nuInstrFlag + ssInstrFlag + 3 * lsInstrFlag)
-            {
-                printf("Execution aborted   invalid nInstrPSolved=%d. It should be =%d\n", nInstrPSolved, maInstrFlag + nuInstrFlag + ssInstrFlag + 3 * lsInstrFlag);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-
-            if (fscanf(fpSolProps, "nOfInstrConstr= %d\n", &nOfInstrConstr) != 1)
-            {
-                printf("Error reading nOfInstrConstr  %d \n", nOfInstrConstr);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nOfInstrConstr= %7d\n", nOfInstrConstr);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nOfInstrConstr= %d\n", nOfInstrConstr);
-
-            if (fscanf(fpSolProps, "nElemIC= %d\n", &nElemIC) != 1)
-            {
-                printf("Error reading nElemIC  %d \n", nElemIC);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nElemIC= %7d\n", nElemIC);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nElemIC= %d\n", nElemIC);
-
-            if (fscanf(fpSolProps, "nGlobP= %hd\n", &nGlobP) != 1)
-            {
-                printf("Error reading nGlobP  %hd \n", nGlobP);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            if (zeroGlob)
-                nGlobP = 0;
-            printf("nGlobP= %7hd\n", nGlobP);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nGlobP= %hd\n", nGlobP);
-
-            if (fscanf(fpSolProps, "nObs= %ld\n", &nobs) != 1)
-            {
-                printf("Error reading nObs  %ld \n", nobs);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
-            printf("nObs= %10ld\n", nobs);
-            if (wrFilebin)
-                fprintf(fpSolPropsFileBin, "nObs= %ld\n", nobs);
-
-            fclose(fpSolProps);
-            if (wrFilebin)
-                fclose(fpSolPropsFileBin);
-        } //if (autoRun) else
-    }
+            if(debugMode) printf("constrMuLongW[nConstrMuLong-1]=%18.15lf\n",constrMuLongW[nConstrMuLong-1]);
+            if(wrFilebin && !noConstr) fprintf(fpSolPropsFileBin,"%lf\n",constrMuLongW[nConstrMuLong-1]);
+        }
+        
+        if(fscanf(fpSolProps, "nDegFreedomAtt= %ld\n",&nDegFreedomAtt) != 1) {
+            printf("Error reading nDegFreedomAtt  %ld \n",nDegFreedomAtt);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroAtt) nDegFreedomAtt=0;
+        printf("nDegFreedomAtt= %7ld\n", nDegFreedomAtt);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nDegFreedomAtt= %ld\n", nDegFreedomAtt);
+        
+        if(fscanf(fpSolProps, "nAttAxes= %hd\n",&nAttAxes) != 1) {
+            printf("Error reading nAttAxes  %hd \n",nAttAxes);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroAtt) nAttAxes=0;
+        printf("nAttAxes= %7hd\n", nAttAxes);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nAttAxes= %hd\n", nAttAxes);
+        
+        if(fscanf(fpSolProps, "nFoVs= %d\n",&instrConst[0]) != 1) {
+            printf("Error reading nFoVs  %d \n",instrConst[0]);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroInstr) instrConst[0]=0;
+        // instrConst[0] must be  0 or 1 because nFoVs = 2 for Gaia and nFoVs=1+instrConst[0]
+        if(instrConst[0]<0 || instrConst[0]>1){
+            printf("Execution aborted  with invalid nFovs=%d\n",instrConst[0]+1);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+            
+        }
+        printf("nFovs= %7d ", instrConst[0]+1);
+        printf("(instrConst[0])= %7d\n", instrConst[0]);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nFoVs= %d\n", instrConst[0]);
+        
+        if(fscanf(fpSolProps, "nCCDs= %d\n",&instrConst[1]) != 1) {
+            printf("Error reading nCCDs  %d \n",instrConst[1]);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroInstr) instrConst[1]=0;
+        printf("nCCDs= %7d\n", instrConst[1]);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nCCDs= %d\n", instrConst[1]);
+        
+        if(fscanf(fpSolProps, "nPixelColumns= %d\n",&instrConst[2]) != 1) {
+            printf("Error reading nPixelColumns  %d \n",instrConst[2]);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroInstr) instrConst[2]=0;
+        printf("nPixelColumns= %7d\n", instrConst[2]);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nPixelColumns= %d\n", instrConst[2]);
+        
+        if(fscanf(fpSolProps, "nTimeIntervals= %d\n",&instrConst[3]) != 1) {
+            printf("Error reading nTimeIntervals  %d \n",instrConst[3]);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroInstr) instrConst[3]=0;
+        printf("nTimeIntervals= %7d\n", instrConst[3]);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nTimeIntervals= %d\n", instrConst[3]);
+        
+        if(fscanf(fpSolProps, "nInstrP= %hd\n",&nInstrP) != 1) {
+            printf("Error reading nInstrP  %hd \n",nInstrP);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroInstr) nInstrP=0;
+        printf("nInstrP= %7hd\n", nInstrP);
+        if(nInstrP!=0 && nInstrP !=6){
+            printf("Execution aborted  with invalid nInstrP\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nInstrP= %hd\n", nInstrP);
+        if(fscanf(fpSolProps, "nInstrPSolved= %hd\n",&nInstrPSolved) != 1)
+        {
+            printf("Error reading nInstrPSolved  %hd \n",nInstrPSolved);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nInstrPSolved= %7hd\n", nInstrPSolved);
+        
+        if(nInstrPSolved<0 || nInstrPSolved >6){
+            printf("Execution aborted  with invalid nInstrPSolved\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nInstrPSolved= %hd\n", nInstrPSolved);
+        
+        if(fscanf(fpSolProps, "lsInstrFlag= %d\n",&lsInstrFlag) != 1)
+        {
+            printf("Error reading lsInstrFlag  %d \n",lsInstrFlag);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("lsInstrFlag= %7d\n", lsInstrFlag);
+        
+        if(lsInstrFlag<0 || lsInstrFlag >1){
+            printf("Execution aborted  with invalid lsInstrFlag\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"lsInstrFlag= %hd\n", lsInstrFlag);
+        if(fscanf(fpSolProps, "ssInstrFlag= %d\n",&ssInstrFlag) != 1)
+        {
+            printf("Error reading ssInstrFlag  %d \n",ssInstrFlag);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("ssInstrFlag= %7d\n", ssInstrFlag);
+        
+        if(ssInstrFlag<0 || ssInstrFlag >1){
+            printf("Execution aborted  with invalid ssInstrFlag\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"ssInstrFlag= %hd\n", ssInstrFlag);
+       if(fscanf(fpSolProps, "nuInstrFlag= %d\n",&nuInstrFlag) != 1)
+        {
+            printf("Error reading nuInstrFlag  %d \n",nuInstrFlag);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nuInstrFlag= %7d\n", nuInstrFlag);
+        
+        if(nuInstrFlag<0 || nuInstrFlag >1){
+            printf("Execution aborted  with invalid lsInstrFlag\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nuInstrFlag= %hd\n", nuInstrFlag);
+        if(fscanf(fpSolProps, "maInstrFlag= %d\n",&maInstrFlag) != 1)
+        {
+            printf("Error reading maInstrFlag  %d \n",maInstrFlag);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("maInstrFlag= %7d\n", maInstrFlag);
+        
+        if(maInstrFlag<0 || maInstrFlag >1){
+            printf("Execution aborted  with invalid maInstrFlag\n");
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"maInstrFlag= %hd\n", maInstrFlag);
 
-    endTime = MPI_Wtime();
-    if ((nDegFreedomAtt == 0 && nAttAxes > 0) || (nDegFreedomAtt > 0 && nAttAxes == 0))
-    {
-        if (myid == 0)
+        if(nInstrPSolved != maInstrFlag+nuInstrFlag+ssInstrFlag+3*lsInstrFlag){
+            printf("Execution aborted   invalid nInstrPSolved=%d. It should be =%d\n",nInstrPSolved,maInstrFlag+nuInstrFlag+ssInstrFlag+3*lsInstrFlag);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+           
+        }
+        
+        if(fscanf(fpSolProps, "nOfInstrConstr= %d\n",&nOfInstrConstr) != 1)
         {
-            printf("inconsistent values for nDegFreedomAtt=%ld and nAttaxes=%d\n", nDegFreedomAtt, nAttAxes);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("Error reading nOfInstrConstr  %d \n",nOfInstrConstr);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nOfInstrConstr= %7d\n", nOfInstrConstr);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nOfInstrConstr= %d\n", nOfInstrConstr);
+        
+        if(fscanf(fpSolProps, "nElemIC= %d\n",&nElemIC) != 1)
+        {
+            printf("Error reading nElemIC  %d \n",nElemIC);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        printf("nElemIC= %7d\n", nElemIC);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nElemIC= %d\n", nElemIC);
+       
+        
+        if(fscanf(fpSolProps, "nGlobP= %hd\n",&nGlobP) != 1) {
+            printf("Error reading nGlobP  %hd \n",nGlobP);
+            MPI_Abort(MPI_COMM_WORLD,1);
+            exit(EXIT_FAILURE);
+        }
+        if(zeroGlob) nGlobP=0;
+        printf("nGlobP= %7hd\n", nGlobP);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nGlobP= %hd\n", nGlobP);
+        
+        if(fscanf(fpSolProps, "nObs= %ld\n",&nobs) != 1) {
+            printf("Error reading nObs  %ld \n",nobs);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
+        printf("nObs= %10ld\n", nobs);
+        if(wrFilebin) fprintf(fpSolPropsFileBin,"nObs= %ld\n", nobs);
+        
+        fclose(fpSolProps);
+        if(wrFilebin) fclose(fpSolPropsFileBin);
+      }//if (autoRun) else
     }
-
-    if (myid == 0)
-        printf("Time to read initial parameters =%f sec.\n", endTime - startTime);
-    // Start section for parameter broadcast
-    MPI_Bcast(&atol, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&btol, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&conlim, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&damp, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nAstroP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nAstroPSolved, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nInstrP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nInstrPSolved, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&lsInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&ssInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nuInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&maInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nElemIC, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nOfInstrConstr, 1, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nGlobP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&itnlim, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nStar, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nDegFreedomAtt, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nAttAxes, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&instrSetUp, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(instrConst, DEFAULT_NINSTRINDEXES, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nobs, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nConstrLat, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nConstrLong, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nConstrMuLat, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&nConstrMuLong, 1, MPI_LONG, 0, MPI_COMM_WORLD);
-    if (myid != 0)
-    {
-        constrLatId = (long *)calloc(nConstrLat, sizeof(long));
-        constrLatW = (double *)calloc(nConstrLat, sizeof(double));
-        constrLongId = (long *)calloc(nConstrLong, sizeof(long));
-        constrLongW = (double *)calloc(nConstrLong, sizeof(double));
-        constrMuLatId = (long *)calloc(nConstrMuLat, sizeof(long));
-        constrMuLatW = (double *)calloc(nConstrMuLat, sizeof(double));
-        constrMuLongId = (long *)calloc(nConstrMuLong, sizeof(long));
-        constrMuLongW = (double *)calloc(nConstrMuLong, sizeof(double));
+    
+    endTime=MPI_Wtime();
+    if((nDegFreedomAtt==0 && nAttAxes>0) || (nDegFreedomAtt>0 && nAttAxes==0) ){
+        if(myid==0){
+            printf("inconsistent values for nDegFreedomAtt=%ld and nAttaxes=%d\n",nDegFreedomAtt,nAttAxes);
+        MPI_Abort(MPI_COMM_WORLD, 1);
+        exit(EXIT_FAILURE);
+        }
     }
-    MPI_Bcast(constrLatId, nConstrLat, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrLatW, nConstrLat, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrLongId, nConstrLong, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrLongW, nConstrLong, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrMuLatId, nConstrMuLat, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrMuLatW, nConstrMuLat, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrMuLongId, nConstrMuLong, MPI_LONG, 0, MPI_COMM_WORLD);
-    MPI_Bcast(constrMuLongW, nConstrMuLong, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-
-    if (nInstrPSolved == 0)
-        zeroInstr = 1;
+ 
+    if(myid==0) printf("Time to read initial parameters =%f sec.\n",endTime-startTime);
+    // Start section for parameter broadcast
+    MPI_Bcast( &atol, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &btol, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &conlim, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &damp, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nAstroP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nAstroPSolved, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nInstrP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nInstrPSolved, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &lsInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &ssInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nuInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &maInstrFlag, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nElemIC, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nOfInstrConstr, 1, MPI_INT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nGlobP, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &itnlim, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nStar, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nDegFreedomAtt, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nAttAxes, 1, MPI_SHORT, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &instrSetUp, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( instrConst, DEFAULT_NINSTRINDEXES , MPI_INT, 0, MPI_COMM_WORLD); //  errore
+    MPI_Bcast( &nobs, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nConstrLat, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nConstrLong, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nConstrMuLat, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( &nConstrMuLong, 1, MPI_LONG, 0, MPI_COMM_WORLD);
+    if(myid !=0)
+    {
+        constrLatId=(long *) calloc(nConstrLat , sizeof(long));
+        constrLatW=(double *) calloc(nConstrLat , sizeof(double));
+        constrLongId=(long *) calloc(nConstrLong , sizeof(long));
+        constrLongW=(double *) calloc(nConstrLong , sizeof(double));
+        constrMuLatId=(long *) calloc(nConstrMuLat , sizeof(long));
+        constrMuLatW=(double *) calloc(nConstrMuLat , sizeof(double));
+        constrMuLongId=(long *) calloc(nConstrMuLong , sizeof(long));
+        constrMuLongW=(double *) calloc(nConstrMuLong , sizeof(double));
+    }
+    MPI_Bcast( constrLatId, nConstrLat, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrLatW, nConstrLat, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrLongId, nConstrLong, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrLongW, nConstrLong, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrMuLatId, nConstrMuLat, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrMuLatW, nConstrMuLat, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrMuLongId, nConstrMuLong, MPI_LONG, 0, MPI_COMM_WORLD);
+    MPI_Bcast( constrMuLongW, nConstrMuLong, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    
+    if(nInstrPSolved==0)
+        zeroInstr=1;
     /////////// Multiplicity of matrixIndex
-
+    
     int multMI;
-
-    if (nAstroPSolved)
-        multMI = 2;
-    else
-    {
-        multMI = 1;
-        extConstraint = 0;
-        barConstraint = 0;
+    
+    if(nAstroPSolved)
+        multMI=2;
+    else{
+        multMI=1;
+        extConstraint=0;
+        barConstraint=0;
     }
     nAstroParam = nStar * nAstroPSolved;
     nAttParam = nDegFreedomAtt * nAttAxes;
-    if (nDegFreedomAtt < 4)
-        nAttParAxis = nDegFreedomAtt;
-    if (nDegFreedomAtt)
-        nAttP = nAttAxes * nAttParAxis;
-    long nFoVs = 1 + instrConst[0];
-    long nCCDs = instrConst[1];
-    long nPixelColumns = instrConst[2];
-    long nTimeIntervals = instrConst[3];
+    if(nDegFreedomAtt<4) nAttParAxis=nDegFreedomAtt;
+    if(nDegFreedomAtt) nAttP = nAttAxes * nAttParAxis;
+    long nFoVs=1+instrConst[0];
+    long nCCDs=instrConst[1];
+    long nPixelColumns=instrConst[2];
+    long nTimeIntervals=instrConst[3];
     // tot. instr. param. = nCCDs (Cmag) + nFoVs*nCCDs (Cnu) + nCCDs*nPixelColumns (delta_eta) + 3*nFoVs*nCCDs*nTimeIntervals (Delta_eta) + nCCDs*nPixelColumns (delta_zeta) + 3*nFoVs*nCCDs*nTimeIntervals (Delta_zeta)
     // added flags switch on and off the appropriate kind of parameters
-    nInstrParam = maInstrFlag * nCCDs + nuInstrFlag * nFoVs * nCCDs + ssInstrFlag * 2 * nCCDs * nPixelColumns + lsInstrFlag * 2 * 3 * nFoVs * nCCDs * nTimeIntervals;
-    nInstrParamTot = nCCDs + nFoVs * nCCDs + 2 * nCCDs * nPixelColumns + 2 * 3 * nFoVs * nCCDs * nTimeIntervals;
+    nInstrParam = maInstrFlag*nCCDs+nuInstrFlag*nFoVs*nCCDs+ssInstrFlag*2*nCCDs*nPixelColumns+lsInstrFlag*2*3*nFoVs*nCCDs*nTimeIntervals;
+    nInstrParamTot =  nCCDs+ nFoVs*nCCDs+ 2*nCCDs*nPixelColumns+2*3*nFoVs*nCCDs*nTimeIntervals;
     nGlobalParam = nGlobP;
-
-    if (nElemIC < 0 || nOfInstrConstr < 0)
-    {
-        nOfInstrConstrLSAL = lsInstrFlag * nTimeIntervals;
-        nElemICLSAL = nFoVs * nCCDs;
-        nOfInstrConstrLSAC = lsInstrFlag * nFoVs * nTimeIntervals;
+    
+    if(nElemIC<0 || nOfInstrConstr <0){
+        
+        
+        nOfInstrConstrLSAL = lsInstrFlag*nTimeIntervals;
+        nElemICLSAL = nFoVs*nCCDs;
+        nOfInstrConstrLSAC = lsInstrFlag*nFoVs*nTimeIntervals;
         nElemICLSAC = nCCDs;
-        nOfInstrConstrSS = lsInstrFlag * ssInstrFlag * 2 * nCCDs * 3; // the factor 2 comes from the AL and AC constraint equations
+        nOfInstrConstrSS = lsInstrFlag*ssInstrFlag*2*nCCDs*3; // the factor 2 comes from the AL and AC constraint equations
         nElemICSS = nPixelColumns;
         nOfInstrConstr = nOfInstrConstrLSAL + nOfInstrConstrLSAC + nOfInstrConstrSS;
-        nElemIC = nOfInstrConstrLSAL * nElemICLSAL + nOfInstrConstrLSAC * nElemICLSAC + nOfInstrConstrSS * nElemICSS;
+        nElemIC = nOfInstrConstrLSAL*nElemICLSAL + nOfInstrConstrLSAC*nElemICLSAC + nOfInstrConstrSS*nElemICSS;
+        
     }
 
+    
     // Map the solved astrometric parameters, putting their indeces into an array of size nAstroPSolved
     // astroCoeff[0] -> parallax
     // astroCoeff[1] -> alpha
@@ -1388,1012 +1192,909 @@ int main(int argc, char **argv)
     //            nAstroPSolved=3 => parallax, alpha, delta, and the array is mapAstroP=[0,1,2]
     //            nAstroPSolved=4 => alpha, delta, mu alpha, mu delta and the array is mapAstroP=[1,2,3,4]
     //            nAstroPSolved=5 => parallax, alpha, delta, mu alpha, mu delta and the array is mapAstroP=[0,1,2,3,4]
-
-    int LatPos = -1, LongPos = -1, MuLatPos = -1, MuLongPos = -1;
-
-    if (nAstroPSolved)
-    {
-        mapAstroP = (int *)calloc(nAstroPSolved, sizeof(int));
-        switch (nAstroPSolved)
-        {
-        case 2:
-            mapAstroP[0] = 1;
-            mapAstroP[1] = 2;
-            LongPos = 0;
-            LatPos = 1;
-            MuLongPos = -1;
-            MuLatPos = -1;
-            nConstrMuLat = 0;
-            nConstrMuLong = 0;
-            if (extConstraint)
-                nEqExtConstr = 3;
-            if (barConstraint)
-                nEqBarConstr = 3;
-            break;
-        case 3:
-            mapAstroP[0] = 0;
-            mapAstroP[1] = 1;
-            mapAstroP[2] = 2;
-            LongPos = 1;
-            LatPos = 2;
-            MuLongPos = -1;
-            MuLatPos = -1;
-            nConstrMuLat = 0;
-            nConstrMuLong = 0;
-            if (extConstraint)
-                nEqExtConstr = 3;
-            if (barConstraint)
-                nEqBarConstr = 3;
-            break;
-        case 4:
-            mapAstroP[0] = 1;
-            mapAstroP[1] = 2;
-            mapAstroP[2] = 3;
-            mapAstroP[3] = 4;
-            LongPos = 0;
-            LatPos = 1;
-            MuLongPos = 2;
-            MuLatPos = 3;
-            break;
-        case 5:
-            mapAstroP[0] = 0;
-            mapAstroP[1] = 1;
-            mapAstroP[2] = 2;
-            mapAstroP[3] = 3;
-            mapAstroP[4] = 4;
-            LongPos = 1;
-            LatPos = 2;
-            MuLongPos = 3;
-            MuLatPos = 4;
-            break;
-        default:
-            if (myid == 0)
-            {
-                printf("nAstroPSolved=%d, invalid value. Aborting.\n", nAstroPSolved);
-                MPI_Abort(MPI_COMM_WORLD, 1);
-                exit(EXIT_FAILURE);
-            }
+    
+    int LatPos=-1, LongPos=-1,MuLatPos=-1, MuLongPos=-1;
+   
+    if(nAstroPSolved)
+    {
+        mapAstroP=(int *) calloc(nAstroPSolved, sizeof(int));
+        switch(nAstroPSolved) {
+            case 2:
+                mapAstroP[0] = 1;
+                mapAstroP[1] = 2;
+                LongPos=0;
+                LatPos=1;
+                MuLongPos=-1;
+                MuLatPos=-1;
+                nConstrMuLat=0;
+                nConstrMuLong=0;
+                if(extConstraint) nEqExtConstr=3;
+                if(barConstraint) nEqBarConstr=3;
+                break;
+            case 3:
+                mapAstroP[0] = 0;
+                mapAstroP[1] = 1;
+                mapAstroP[2] = 2;
+                LongPos=1;
+                LatPos=2;
+                MuLongPos=-1;
+                MuLatPos=-1;
+                nConstrMuLat=0;
+                nConstrMuLong=0;
+                if(extConstraint) nEqExtConstr=3;
+                if(barConstraint) nEqBarConstr=3;
+               break;
+            case 4:
+                mapAstroP[0] = 1;
+                mapAstroP[1] = 2;
+                mapAstroP[2] = 3;
+                mapAstroP[3] = 4;
+                LongPos=0;
+                LatPos=1;
+                MuLongPos=2;
+                MuLatPos=3;
+                break;
+            case 5:
+                mapAstroP[0] = 0;
+                mapAstroP[1] = 1;
+                mapAstroP[2] = 2;
+                mapAstroP[3] = 3;
+                mapAstroP[4] = 4;
+                LongPos=1;
+                LatPos=2;
+                MuLongPos=3;
+                MuLatPos=4;
+                break;
+            default:
+                if(myid==0) {
+                    printf("nAstroPSolved=%d, invalid value. Aborting.\n", nAstroPSolved);
+                    MPI_Abort(MPI_COMM_WORLD,1);
+                    exit(EXIT_FAILURE);
+                }
         }
     }
     // End map
+    
 
     /////////////////////// end broadcast section
-
+    
     // Initialize the values needed to dimension the vectors
     nConstr = nConstrLong + nConstrLat + nConstrMuLong + nConstrMuLat; // number of constraints to be generated
-
-    nObsxStar = nobs / nStar;
-    nobsOri = nobs;
-    if (noConstr)
+    
+    nObsxStar=nobs/nStar;
+    nobsOri=nobs;
+    if(noConstr)
     {
-        nConstr = 0;
-        nConstrLong = 0;
-        nConstrLat = 0;
-        nConstrMuLong = 0;
-        nConstrMuLat = 0;
-    }
-    else
+        nConstr=0;
+        nConstrLong=0;
+        nConstrLat=0;
+        nConstrMuLong=0;
+        nConstrMuLat=0;
+    } else
     {
-        for (int q = 0; q < nConstrLat; q++)
-            if (constrLatId[q] >= nStar)
+        for(int q=0;q<nConstrLat;q++)
+            if(constrLatId[q]>=nStar)
             {
-                printf("PE=%d Error invalit Lat Constraint %ld\n", myid, constrLatId[q]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error invalit Lat Constraint %ld\n",myid,constrLatId[q]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-
-        for (int q = 0; q < nConstrLong; q++)
-            if (constrLongId[q] >= nStar)
+        
+        for(int q=0;q<nConstrLong;q++)
+            if(constrLongId[q]>=nStar)
             {
-                printf("PE=%d Error invalit Long Constraint %ld\n", myid, constrLongId[q]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error invalit Long Constraint %ld\n",myid,constrLongId[q]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-        for (int q = 0; q < nConstrMuLat; q++)
-            if (constrMuLatId[q] >= nStar)
+        for(int q=0;q<nConstrMuLat;q++)
+            if(constrMuLatId[q]>=nStar)
             {
-                printf("PE=%d Error invalit MuLat Constraint %ld\n", myid, constrMuLatId[q]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error invalit MuLat Constraint %ld\n",myid,constrMuLatId[q]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-
-        for (int q = 0; q < nConstrMuLong; q++)
-            if (constrMuLongId[q] >= nStar)
+        
+        for(int q=0;q<nConstrMuLong;q++)
+            if(constrMuLongId[q]>=nStar)
             {
-                printf("PE=%d Error invalit MuLat Constraint %ld\n", myid, constrMuLongId[q]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error invalit MuLat Constraint %ld\n",myid,constrMuLongId[q]);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-
+        
         nConstr = nConstrLong + nConstrLat + nConstrMuLong + nConstrMuLat; // number of constraints to be generated
     }
-
-    nobs += nConstr;
-    nunk = ((long)nAstroParam) + nAttParam + nInstrParam + nGlobalParam; // number of unknowns (i.e. columns of the system matrix)
-    nparam = nAstroPSolved + nAttP + nInstrPSolved + nGlobP;             // number of non-zero coefficients for each observation (i.e. for each system row)
-    if (nparam == 0)
-    {
-        printf("Abort. Empty system nparam=0 . nAstroPSolved=%d nAttP=%d nInstrPSolved=%d nGlobP=%d\n", nAstroPSolved, nAttP, nInstrPSolved, nGlobP);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    
+    
+    nobs+=nConstr;
+    nunk = ((long) nAstroParam) + nAttParam + nInstrParam + nGlobalParam; // number of unknowns (i.e. columns of the system matrix)
+    nparam = nAstroPSolved + nAttP + nInstrPSolved + nGlobP; // number of non-zero coefficients for each observation (i.e. for each system row)
+    if(nparam==0){
+        printf("Abort. Empty system nparam=0 . nAstroPSolved=%d nAttP=%d nInstrPSolved=%d nGlobP=%d\n",nAstroPSolved,nAttP,nInstrPSolved,nGlobP);
+        MPI_Abort(MPI_COMM_WORLD,1);
     }
     ncoeff = nparam * nobs; // total number of non-zero coefficients of the system
-
-    if (nobs <= nunk)
-    {
-        printf("SEVERE ERROR: number of equations=%ld and number of unknown=%ld make solution unsafe\n", nobs, nunk);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    
+    if(nobs <=nunk){
+        printf("SEVERE ERROR: number of equations=%ld and number of unknown=%ld make solution unsafe\n",nobs,nunk);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
-    }
 
+    }
+    
     // Start map distributed array
-    mapNoss = (long int *)calloc(nproc, sizeof(long int));
-    mapNcoeff = (long int *)calloc(nproc, sizeof(long int));
-    mapNossAfter = 0;
-    mapNcoeffAfter = 0;
-    mapNossBefore = 0;
-    mapNcoeffBefore = 0;
-    for (i = 0; i < nproc; i++)
+    mapNoss=(long int *) calloc(nproc,sizeof(long int));
+    mapNcoeff=(long int *) calloc(nproc,sizeof(long int));
+    mapNossAfter=0;
+    mapNcoeffAfter=0;
+    mapNossBefore=0;
+    mapNcoeffBefore=0;
+    for(i=0;i<nproc;i++)
     {
-        mapNoss[i] = (nobs) / nproc;
-        if (nobs % nproc >= i + 1)
-            mapNoss[i]++;
-        mapNcoeff[i] = mapNoss[i] * nparam;
-        if (i < myid)
+        mapNoss[i]=(nobs)/nproc;
+        if(nobs % nproc >=i+1) mapNoss[i]++;
+        mapNcoeff[i]=mapNoss[i]*nparam;
+        if(i<myid)
         {
-            mapNossBefore += mapNoss[i];
-            mapNcoeffBefore += mapNcoeff[i];
+            mapNossBefore+=mapNoss[i];
+            mapNcoeffBefore+=mapNcoeff[i];
         }
-        if (i > myid)
+        if(i>myid)
         {
-            mapNossAfter += mapNoss[i];
-            mapNcoeffAfter += mapNcoeff[i];
+            mapNossAfter+=mapNoss[i];
+            mapNcoeffAfter+=mapNcoeff[i];
         }
     }
     ////////////////// Simulating the ... of NObsxStar file
-    if (extConstraint)
-    {
-        int *sumNObsxStar;
-        sumNObsxStar = (int *)calloc(nStar, sizeof(int));
-        int irest = nobs % nStar;
-        for (int i = 0; i < nStar; i++)
-        {
-            sumNObsxStar[i] = nobs / nStar;
-            if (i < irest)
-                sumNObsxStar[i]++;
-        }
-        if (wrFilebin && myid == 0)
-        {
+    if(extConstraint){
+        int * sumNObsxStar;
+        sumNObsxStar=(int *) calloc(nStar, sizeof(int));
+        int irest=nobs % nStar;
+        for(int i=0;i<nStar;i++){
+            sumNObsxStar[i]=nobs/nStar;
+            if(i<irest) sumNObsxStar[i]++;
+        }
+        if(wrFilebin && myid==0){
             chdir(wpath);
             chdir(wrfileDir);
             FILE *fpNObsxStar;
-            fpNObsxStar = fopen("NObsStar.bin", "wb");
-            fwrite(sumNObsxStar, sizeof(int), nStar, fpNObsxStar);
+            fpNObsxStar=fopen("NObsStar.bin","wb");
+            fwrite(sumNObsxStar,sizeof(int),nStar,fpNObsxStar);
             fclose(fpNObsxStar);
             chdir(wpath);
-        }
-        long counterObsxStar = 0;
-        for (int i = 0; i < nStar; i++)
-        {
-            counterObsxStar += sumNObsxStar[i];
-            if (counterObsxStar > mapNossBefore && firstStarConstr == -1)
-                firstStarConstr = i; //first star assigned in  extConstr
-            if (counterObsxStar >= mapNossBefore + mapNoss[myid] && lastStarConstr == -1)
-            {
-                lastStarConstr = i; //last star assigned in  extConstr (it will be eqaul to lastrStar-1 in case of overlap)
-                if (counterObsxStar > (mapNossBefore + mapNoss[myid]) && myid != (nproc - 1))
-                {
-                    starOverlap = 1;
+            
+        }
+        long counterObsxStar=0;
+        for(int i=0;i<nStar;i++){
+            counterObsxStar+=sumNObsxStar[i];
+            if(counterObsxStar>mapNossBefore && firstStarConstr==-1) firstStarConstr=i;  //first star assigned in  extConstr
+            if(counterObsxStar>=mapNossBefore+mapNoss[myid] && lastStarConstr==-1){
+                lastStarConstr=i; //last star assigned in  extConstr (it will be eqaul to lastrStar-1 in case of overlap)
+                if(counterObsxStar>(mapNossBefore+mapNoss[myid]) && myid!=(nproc-1)){
+                    starOverlap=1;
                     lastStarConstr--;
                 }
                 break;
             }
         }
-        numOfExtStar = lastStarConstr - firstStarConstr + 1; //number of stars computed in ext Constr
-
-        int counterAttCols = 0;
-        startingAttColExtConstr = 0; // numero di colonna di assetto escluso l'offset: la prima è 0 per il PE0 x asse
-        endingAttColExtConstr = 0;   // numero di colonna di assetto finale l'offset: la prima è nDegFreedomAtt/nproc-1 (+1 in caso di modulo) per il PE0 x asse
-        int attRes = nDegFreedomAtt % nproc;
-        startingAttColExtConstr = (nDegFreedomAtt / nproc) * myid;
-        if (myid < attRes)
-            startingAttColExtConstr += myid;
-        else
-            startingAttColExtConstr += attRes;
-        endingAttColExtConstr = startingAttColExtConstr + (nDegFreedomAtt / nproc) - 1;
-        if (myid < attRes)
-            endingAttColExtConstr++;
-
-        numOfExtAttCol = endingAttColExtConstr - startingAttColExtConstr + 1; //numeroi di colonne x asse
+        numOfExtStar=lastStarConstr-firstStarConstr+1;  //number of stars computed in ext Constr
+        
+        int counterAttCols=0;
+        startingAttColExtConstr=0;  // numero di colonna di assetto escluso l'offset: la prima è 0 per il PE0 x asse
+        endingAttColExtConstr=0; // numero di colonna di assetto finale l'offset: la prima è nDegFreedomAtt/nproc-1 (+1 in caso di modulo) per il PE0 x asse
+        int attRes=nDegFreedomAtt%nproc;
+        startingAttColExtConstr=(nDegFreedomAtt/nproc)*myid;
+        if(myid<attRes)startingAttColExtConstr+=myid;
+        else startingAttColExtConstr+=attRes;
+        endingAttColExtConstr=startingAttColExtConstr+(nDegFreedomAtt/nproc)-1;
+        if(myid<attRes)endingAttColExtConstr++;
+        
+        
+        numOfExtAttCol=endingAttColExtConstr-startingAttColExtConstr+1;  //numeroi di colonne x asse
     }
     //////////////////// barConstraint
-    if (barConstraint)
-    {
-        int *sumNObsxStar;
-        sumNObsxStar = (int *)calloc(nStar, sizeof(int));
-        int irest = nobs % nStar;
-        for (int i = 0; i < nStar; i++)
-        {
-            sumNObsxStar[i] = nobs / nStar;
-            if (i < irest)
-                sumNObsxStar[i]++;
-        }
-        if (wrFilebin && myid == 0)
-        {
+    if(barConstraint){
+        int * sumNObsxStar;
+        sumNObsxStar=(int *) calloc(nStar, sizeof(int));
+        int irest=nobs % nStar;
+        for(int i=0;i<nStar;i++){
+            sumNObsxStar[i]=nobs/nStar;
+            if(i<irest) sumNObsxStar[i]++;
+        }
+        if(wrFilebin && myid==0){
             chdir(wpath);
             chdir(wrfileDir);
             FILE *fpNObsxStar;
-            fpNObsxStar = fopen("NObsStar.bin", "wb");
-            fwrite(sumNObsxStar, sizeof(int), nStar, fpNObsxStar);
+            fpNObsxStar=fopen("NObsStar.bin","wb");
+            fwrite(sumNObsxStar,sizeof(int),nStar,fpNObsxStar);
             fclose(fpNObsxStar);
             chdir(wpath);
-        }
-        int counterObsxStar = 0;
-        for (int i = 0; i < nStar; i++)
-        {
-            counterObsxStar += sumNObsxStar[i];
-            if (counterObsxStar > mapNossBefore && firstStarConstr == -1)
-                firstStarConstr = i; //first star assigned in  barConstr
-            if (counterObsxStar >= mapNossBefore + mapNoss[myid] && lastStarConstr == -1)
-            {
-                lastStarConstr = i; //last star assigned in  barConstr (it will be eqaul to lastrStar-1 in case of overlap)
-                if (counterObsxStar > (mapNossBefore + mapNoss[myid]) && myid != (nproc - 1))
-                {
-                    starOverlap = 1;
+            
+        }
+        int counterObsxStar=0;
+        for(int i=0;i<nStar;i++){
+            counterObsxStar+=sumNObsxStar[i];
+            if(counterObsxStar>mapNossBefore && firstStarConstr==-1) firstStarConstr=i;  //first star assigned in  barConstr
+            if(counterObsxStar>=mapNossBefore+mapNoss[myid] && lastStarConstr==-1){
+                lastStarConstr=i; //last star assigned in  barConstr (it will be eqaul to lastrStar-1 in case of overlap)
+                if(counterObsxStar>(mapNossBefore+mapNoss[myid]) && myid!=(nproc-1)){
+                    starOverlap=1;
                     lastStarConstr--;
                 }
                 break;
             }
         }
-        numOfBarStar = lastStarConstr - firstStarConstr + 1; //number of stars computed in bar Constr
+        numOfBarStar=lastStarConstr-firstStarConstr+1;  //number of stars computed in bar Constr
+        
     }
     ////////////////////// comlsqr
-
-    comlsqr.nStar = nStar;
-    comlsqr.nAstroP = nAstroP;
-    comlsqr.nAstroPSolved = nAstroPSolved;
-    comlsqr.nAttP = nAttP;
-    comlsqr.nInstrP = nInstrP;
-    comlsqr.nInstrPSolved = nInstrPSolved;
-    comlsqr.nGlobP = nGlobP;
-    comlsqr.mapNossBefore = mapNossBefore;
-    comlsqr.mapNossAfter = mapNossAfter;
-    comlsqr.myid = myid;
-    comlsqr.nproc = nproc;
-    comlsqr.mapNoss = mapNoss;
-    comlsqr.mapNcoeff = mapNcoeff;
-    comlsqr.multMI = multMI;
-    comlsqr.debugMode = debugMode;
-    comlsqr.noCPR = noCPR;
-    comlsqr.nAttParam = nAttParam;
-    comlsqr.extConstraint = extConstraint;
-    comlsqr.nEqExtConstr = nEqExtConstr;
-    comlsqr.numOfExtStar = numOfExtStar;
-    comlsqr.barConstraint = barConstraint;
-    comlsqr.nEqBarConstr = nEqBarConstr;
-    comlsqr.numOfBarStar = numOfBarStar;
-    comlsqr.firstStarConstr = firstStarConstr;
-    comlsqr.lastStarConstr = lastStarConstr;
-    comlsqr.numOfExtAttCol = numOfExtAttCol;
-    comlsqr.startingAttColExtConstr = startingAttColExtConstr;
-    comlsqr.setBound[0] = 0;
-    comlsqr.setBound[1] = nAstroPSolved;
-    comlsqr.setBound[2] = nAstroPSolved + nAttP;
-    comlsqr.setBound[3] = nAstroPSolved + nAttP + nInstrPSolved;
-    comlsqr.nDegFreedomAtt = nDegFreedomAtt;
-    comlsqr.nAttParAxis = nAttParAxis;
-    comlsqr.nAttAxes = nAttAxes;
-    comlsqr.nobs = nobs;
-    comlsqr.lsInstrFlag = lsInstrFlag;
-    comlsqr.ssInstrFlag = ssInstrFlag;
-    comlsqr.nuInstrFlag = nuInstrFlag;
-    comlsqr.maInstrFlag = maInstrFlag;
-    comlsqr.myid = myid;
-    comlsqr.cCDLSAACZP = cCDLSAACZP;
-    comlsqr.nOfInstrConstr = nOfInstrConstr;
-    comlsqr.nElemIC = nElemIC;
-    comlsqr.nElemICLSAL = nElemICLSAL;
-    comlsqr.nElemICLSAC = nElemICLSAC;
-    comlsqr.nElemICSS = nElemICSS;
-    comlsqr.instrConst[0] = instrConst[0];
-    comlsqr.instrConst[1] = instrConst[1];
-    comlsqr.instrConst[2] = instrConst[2];
-    comlsqr.instrConst[3] = instrConst[3];
-    comlsqr.nInstrParam = nInstrParam;
-    comlsqr.nGlobalParam = nGlobalParam;
-    
-    comlsqr.nthreads= nthreads;
-    comlsqr.ntasks= ntasks;
     
+    
+    
+    comlsqr.nStar=nStar;
+    comlsqr.nAstroP=nAstroP;
+    comlsqr.nAstroPSolved=nAstroPSolved;
+    comlsqr.nAttP=nAttP;
+    comlsqr.nInstrP=nInstrP;
+    comlsqr.nInstrPSolved=nInstrPSolved;
+    comlsqr.nGlobP=nGlobP;
+    comlsqr.mapNossBefore=mapNossBefore;
+    comlsqr.mapNossAfter=mapNossAfter;
+    comlsqr.myid=myid;
+    comlsqr.nproc=nproc;
+    comlsqr.mapNoss=mapNoss;
+    comlsqr.mapNcoeff=mapNcoeff;
+    comlsqr.multMI=multMI;
+    comlsqr.debugMode=debugMode;
+    comlsqr.noCPR=noCPR;
+    comlsqr.nAttParam=nAttParam;
+    comlsqr.extConstraint=extConstraint;
+    comlsqr.nEqExtConstr=nEqExtConstr;
+    comlsqr.numOfExtStar=numOfExtStar;
+    comlsqr.barConstraint=barConstraint;
+    comlsqr.nEqBarConstr=nEqBarConstr;
+    comlsqr.numOfBarStar=numOfBarStar;
+    comlsqr.firstStarConstr=firstStarConstr;
+    comlsqr.lastStarConstr=lastStarConstr;
+    comlsqr.numOfExtAttCol=numOfExtAttCol;
+    comlsqr.startingAttColExtConstr=startingAttColExtConstr;
+    comlsqr.setBound[0]=0;
+    comlsqr.setBound[1]=nAstroPSolved;
+    comlsqr.setBound[2]=nAstroPSolved+nAttP;
+    comlsqr.setBound[3]=nAstroPSolved+nAttP+nInstrPSolved;
+    comlsqr.nDegFreedomAtt=nDegFreedomAtt;
+    comlsqr.nAttParAxis=nAttParAxis;
+    comlsqr.nAttAxes=nAttAxes;
+    comlsqr.nobs=nobs;
+    comlsqr.lsInstrFlag=lsInstrFlag;
+    comlsqr.ssInstrFlag=ssInstrFlag;
+    comlsqr.nuInstrFlag=nuInstrFlag;
+    comlsqr.maInstrFlag=maInstrFlag;
+    comlsqr.myid=myid;
+    comlsqr.cCDLSAACZP=cCDLSAACZP;
+    comlsqr.nOfInstrConstr=nOfInstrConstr;
+    comlsqr.nElemIC=nElemIC;
+    comlsqr.nElemICLSAL=nElemICLSAL;
+    comlsqr.nElemICLSAC=nElemICLSAC;
+    comlsqr.nElemICSS=nElemICSS;
+    comlsqr.instrConst[0]=instrConst[0];
+    comlsqr.instrConst[1]=instrConst[1];
+    comlsqr.instrConst[2]=instrConst[2];
+    comlsqr.instrConst[3]=instrConst[3];
+    comlsqr.nInstrParam=nInstrParam;
+    comlsqr.nGlobalParam=nGlobalParam;
 
     ///////////////////// end buidl map distributed arrays
-
+    
     // Allocate the memory for the vectors and compute the total memory allocated
     totmem = 0;
     nElements = mapNcoeff[myid];
-    if (extConstraint)
-    {
-        addElementextStar = (lastStarConstr - firstStarConstr + 1) * nAstroPSolved;
-        addElementAtt = numOfExtAttCol * nAttAxes;
+    if (extConstraint){
+        addElementextStar= (lastStarConstr-firstStarConstr+1)*nAstroPSolved;
+        addElementAtt=numOfExtAttCol*nAttAxes;
     }
-    if (barConstraint)
-    {
-        addElementbarStar = (lastStarConstr - firstStarConstr + 1) * nAstroPSolved;
+    if (barConstraint){
+        addElementbarStar= (lastStarConstr-firstStarConstr+1)*nAstroPSolved;
     }
-    nOfElextObs = addElementextStar + addElementAtt;
-    nOfElBarObs = addElementbarStar;
-    comlsqr.nOfElextObs = nOfElextObs;
-    comlsqr.nOfElBarObs = nOfElBarObs;
-
-    nElements += nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr + nElemIC;
+    nOfElextObs=addElementextStar+addElementAtt;
+    nOfElBarObs=addElementbarStar;
+    comlsqr.nOfElextObs=nOfElextObs;
+    comlsqr.nOfElBarObs=nOfElBarObs;
 
-    systemMatrix = (double *)calloc(nElements, sizeof(double));
+    nElements+=nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr+nElemIC;
+    
+    systemMatrix = (double *) calloc(nElements,sizeof(double));
     if (!systemMatrix)
-        exit(err_malloc("systemMatrix", myid));
-    totmem += nElements * sizeof(double);
-
-    nElements = mapNoss[myid] * multMI;
-    matrixIndex = (long int *)calloc(nElements, sizeof(long int));
+        exit(err_malloc("systemMatrix",myid));
+    totmem += nElements*sizeof(double);
+    
+    nElements = mapNoss[myid]*multMI;
+    matrixIndex = (long int *) calloc(nElements, sizeof(long int));
     if (!matrixIndex)
-        exit(err_malloc("matrixIndex", myid));
-    totmem += nElements * sizeof(long int);
-
-    nElements = mapNoss[myid] * nInstrPSolved + nElemIC;
-    instrCol = (int *)calloc(nElements, sizeof(int));
+        exit(err_malloc("matrixIndex",myid));
+    totmem += nElements* sizeof(long int);
+    
+    nElements = mapNoss[myid]*nInstrPSolved+nElemIC;
+    instrCol = (int *) calloc(nElements, sizeof(int));
     if (!instrCol)
-        exit(err_malloc("instrCol", myid));
-    totmem += nElements * sizeof(int);
+        exit(err_malloc("instrCol",myid));
+    totmem += nElements* sizeof(int);
 
     nElements = nOfInstrConstr;
-    instrConstrIlung = (int *)calloc(nElements, sizeof(int)); // it is the vectorr that for each observation (in this PE) save the INDEX for the values of instr
+    instrConstrIlung = (int *) calloc(nElements, sizeof(int)); // it is the vectorr that for each observation (in this PE) save the INDEX for the values of instr
     if (!instrConstrIlung)
-        exit(err_malloc("instrConstrIlung", myid));
-    totmem += nElements * sizeof(int);
-
+        exit(err_malloc("instrConstrIlung",myid));
+    totmem += nElements* sizeof(int);
+    
+    
     nElements = mapNoss[myid];
-    if (extConstraint)
-        nElements += nEqExtConstr;
-    if (barConstraint)
-        nElements += nEqBarConstr;
-    if (nOfInstrConstr > 0)
-        nElements += nOfInstrConstr;
-    knownTerms = (double *)calloc(nElements, sizeof(double));
+    if(extConstraint) nElements+=nEqExtConstr;
+    if(barConstraint) nElements+=nEqBarConstr;
+    if(nOfInstrConstr>0) nElements+=nOfInstrConstr;
+    knownTerms = (double *) calloc(nElements, sizeof(double));
     if (!knownTerms)
-        exit(err_malloc("knownTerms", myid));
-    totmem += nElements * sizeof(double);
-
+        exit(err_malloc("knownTerms",myid));
+    totmem += nElements* sizeof(double);
+    
     ielem = 0;
     offsetAttParam = nAstroParam;
     offsetInstrParam = offsetAttParam + nAttParam;
     offsetGlobParam = offsetInstrParam + nInstrParam;
-    comlsqr.offsetAttParam = offsetAttParam;
-
-    long rowsxFile = nobsOri / (nproc * nfileProc);
-
-    if (withFile)
-    {
-        char filenameSim_SM[128] = "SIM_PE_SM_";
-        char filenameSim_MI[128] = "SIM_PE_MI_";
-        char filenameSim_II[128] = "SIM_PE_II_";
-        char filenameSim_KT[128] = "SIM_PE_KT_";
-        char varpe[32] = "";
-        char varrows[32] = "";
-        sprintf(varpe, "%d", myid);
-        sprintf(varrows, "%ld", rowsxFile);
-        strcat(filenameSim_SM, varrows);
-        strcat(filenameSim_SM, "_");
-        strcat(filenameSim_SM, varpe);
-        strcat(filenameSim_SM, ".bin");
-        strcat(filenameSim_MI, varrows);
-        strcat(filenameSim_MI, "_");
-        strcat(filenameSim_MI, varpe);
-        strcat(filenameSim_MI, ".bin");
-        strcat(filenameSim_II, varrows);
-        strcat(filenameSim_II, "_");
-        strcat(filenameSim_II, varpe);
-        strcat(filenameSim_II, ".bin");
-        strcat(filenameSim_KT, varrows);
-        strcat(filenameSim_KT, "_");
-        strcat(filenameSim_KT, varpe);
-        strcat(filenameSim_KT, ".bin");
-
+    comlsqr.offsetAttParam=offsetAttParam;
+    
+    
+    long rowsxFile=nobsOri/(nproc*nfileProc);
+   
+    if(withFile)
+    {
+        char filenameSim_SM[128]="SIM_PE_SM_";
+        char filenameSim_MI[128]="SIM_PE_MI_";
+        char filenameSim_II[128]="SIM_PE_II_";
+        char filenameSim_KT[128]="SIM_PE_KT_";
+        char varpe[32]="";
+        char varrows[32]="";
+        sprintf(varpe,"%d",myid);
+        sprintf(varrows,"%ld",rowsxFile);
+        strcat(filenameSim_SM,varrows);
+        strcat(filenameSim_SM,"_");
+        strcat(filenameSim_SM,varpe);
+        strcat(filenameSim_SM,".bin");
+        strcat(filenameSim_MI,varrows);
+        strcat(filenameSim_MI,"_");
+        strcat(filenameSim_MI,varpe);
+        strcat(filenameSim_MI,".bin");
+        strcat(filenameSim_II,varrows);
+        strcat(filenameSim_II,"_");
+        strcat(filenameSim_II,varpe);
+        strcat(filenameSim_II,".bin");
+        strcat(filenameSim_KT,varrows);
+        strcat(filenameSim_KT,"_");
+        strcat(filenameSim_KT,varpe);
+        strcat(filenameSim_KT,".bin");
+        
         double *smsim;
-        smsim = (double *)calloc(rowsxFile * nparam, sizeof(double));
-        fpSM = fopen(filenameSim_SM, "wb");
-        fwrite(smsim, sizeof(double), rowsxFile * nparam, fpSM);
+        smsim=(double *)calloc(rowsxFile*nparam,sizeof(double));
+        fpSM=fopen(filenameSim_SM,"wb");
+        fwrite(smsim,sizeof(double),rowsxFile*nparam,fpSM);
         fclose(fpSM);
-        fpKT = fopen(filenameSim_KT, "wb");
-        fwrite(smsim, sizeof(double), rowsxFile, fpKT);
+        fpKT=fopen(filenameSim_KT,"wb");
+        fwrite(smsim,sizeof(double),rowsxFile,fpKT);
         fclose(fpKT);
         free(smsim);
         int *intsim;
-        intsim = (int *)calloc(rowsxFile * nInstrPSolved, sizeof(int));
-        fpII = fopen(filenameSim_II, "wb");
-        fwrite(intsim, sizeof(int), rowsxFile * nInstrPSolved, fpII);
+        intsim=(int *)calloc(rowsxFile*nInstrPSolved,sizeof(int));
+        fpII=fopen(filenameSim_II,"wb");
+        fwrite(intsim,sizeof(int),rowsxFile*nInstrPSolved,fpII);
         fclose(fpII);
         free(intsim);
         long *misim;
-        misim = (long *)calloc(rowsxFile * multMI, sizeof(long));
-        fpMI = fopen(filenameSim_MI, "wb");
-        fwrite(misim, sizeof(long), rowsxFile * multMI, fpMI);
+        misim=(long *)calloc(rowsxFile*multMI,sizeof(long));
+        fpMI=fopen(filenameSim_MI,"wb");
+        fwrite(misim,sizeof(long),rowsxFile*multMI,fpMI);
         fclose(fpMI);
         free(misim);
         long nrowToRead;
-        if (myid == 0)
-            printf(
-                "Found %d SM data files in the directory. Reading the coefficients...\n",
-                (nfileProc)*nproc);
-        timeToReadFiles = MPI_Wtime();
-
-        for (ii = 0; ii < nfileProc + 2; ii++)
-        {
-
-            if (ii == 0 && myid == 0)
-                printf("PE=%d Opening  %d  and reading %s  and associated files\n", myid, nfileProc, filenameSim_SM);
-
-            fpSM = fopen(filenameSim_SM, "rb");
+        if(myid==0) printf(
+                           "Found %d SM data files in the directory. Reading the coefficients...\n",
+                           (nfileProc)*nproc);
+        timeToReadFiles=MPI_Wtime();
+        
+        for(ii=0;ii<nfileProc+2;ii++) {
+            
+            if(ii==0 && myid==0) printf("PE=%d Opening  %d  and reading %s  and associated files\n",myid,nfileProc,filenameSim_SM);
+            
+            fpSM=fopen(filenameSim_SM,"rb");
             if (!fpSM)
             {
-                printf("PE=%d Error while open %s\n", myid, filenameSim_SM);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error while open %s\n",myid,filenameSim_SM);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            fpMI = fopen(filenameSim_MI, "rb");
+            fpMI=fopen(filenameSim_MI,"rb");
             if (!fpMI)
             {
-                printf("PE=%d Error while open %s\n", myid, filenameSim_MI);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error while open %s\n",myid,filenameSim_MI);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            fpII = fopen(filenameSim_II, "rb");
+            fpII=fopen(filenameSim_II,"rb");
             if (!fpII)
             {
-                printf("PE=%d Error while open %s\n", myid, filenameSim_II);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error while open %s\n",myid,filenameSim_II);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            fpKT = fopen(filenameSim_KT, "rb");
+            fpKT=fopen(filenameSim_KT,"rb");
             if (!fpSM)
             {
-                printf("PE=%d Error while open %s\n", myid, filenameSim_KT);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d Error while open %s\n",myid,filenameSim_KT);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-
+            
+            
             ///// Reading systemMatrix
-            if (ii == 0 || ii == nfileProc + 1)
-            {
-                if (ii == 0)
-                    fseek(fpSM, ((rowsxFile * nparam) / 2) * sizeof(double), SEEK_SET);
-                fread(systemMatrix, sizeof(double), ((rowsxFile * nparam) / 2) * sizeof(double), fpSM);
-                if (ii == 0)
-                    fseek(fpMI, ((rowsxFile * multMI) / 2) * sizeof(long), SEEK_SET);
-                fread(matrixIndex, sizeof(long), ((rowsxFile * multMI) / 2) * sizeof(double), fpMI);
-                if (ii == 0)
-                    fseek(fpII, ((rowsxFile * nInstrPSolved) / 2) * sizeof(long), SEEK_SET);
-                fread(instrCol, sizeof(int), ((rowsxFile * nInstrPSolved) / 2) * sizeof(int), fpII);
-                if (ii == 0)
-                    fseek(fpKT, ((rowsxFile) / 2) * sizeof(double), SEEK_SET);
-                fread(instrCol, sizeof(int), ((rowsxFile) / 2) * sizeof(double), fpKT);
-            }
-            else
-            {
-                fread(systemMatrix, sizeof(double), ((rowsxFile * nparam)) * sizeof(double), fpSM);
-                fread(matrixIndex, sizeof(long), ((rowsxFile * multMI)) * sizeof(double), fpMI);
-                fread(instrCol, sizeof(int), ((rowsxFile * nInstrPSolved)) * sizeof(int), fpII);
-                fread(systemMatrix, sizeof(double), ((rowsxFile)) * sizeof(double), fpKT);
+            if(ii==0 || ii==nfileProc+1)
+            {
+                if(ii==0) fseek(fpSM,((rowsxFile*nparam)/2)*sizeof(double),SEEK_SET);
+                fread(systemMatrix,sizeof(double),((rowsxFile*nparam)/2)*sizeof(double),fpSM);
+                if(ii==0) fseek(fpMI,((rowsxFile*multMI)/2)*sizeof(long),SEEK_SET);
+                fread(matrixIndex,sizeof(long),((rowsxFile*multMI)/2)*sizeof(double),fpMI);
+                if(ii==0) fseek(fpII,((rowsxFile*nInstrPSolved)/2)*sizeof(long),SEEK_SET);
+                fread(instrCol,sizeof(int),((rowsxFile*nInstrPSolved)/2)*sizeof(int),fpII);
+                if(ii==0) fseek(fpKT,((rowsxFile)/2)*sizeof(double),SEEK_SET);
+                fread(instrCol,sizeof(int),((rowsxFile)/2)*sizeof(double),fpKT);
+            } else{
+                fread(systemMatrix,sizeof(double),((rowsxFile*nparam))*sizeof(double),fpSM);
+                fread(matrixIndex,sizeof(long),((rowsxFile*multMI))*sizeof(double),fpMI);
+                fread(instrCol,sizeof(int),((rowsxFile*nInstrPSolved))*sizeof(int),fpII);
+                fread(systemMatrix,sizeof(double),((rowsxFile))*sizeof(double),fpKT);
             }
             fclose(fpSM);
             fclose(fpMI);
             fclose(fpII);
             fclose(fpKT);
-
+            
         } //for(ii)
         MPI_Barrier(MPI_COMM_WORLD);
-        timeToReadFiles = MPI_Wtime() - timeToReadFiles;
-        if (myid == 0)
-            printf("PE=%d time seconds=%lf TO READ %d Files\n", myid, timeToReadFiles, nfileProc);
-    } // if withFile (no  external and baricentric Contraint are simulated for reading time
-    timeToReadFiles = MPI_Wtime();
-
-    long startingStar = 0;
-    long obsTotal = 0;
-    int residual = 0; //represents the number of observation for the staring stars (if equal to zero  the number of observations for the starting  star is nObsxStar)
+        timeToReadFiles=MPI_Wtime()-timeToReadFiles;
+        if(myid==0) printf("PE=%d time seconds=%lf TO READ %d Files\n",myid, timeToReadFiles,nfileProc);
+    }// if withFile (no  external and baricentric Contraint are simulated for reading time
+    timeToReadFiles=MPI_Wtime();
+    
+    long startingStar=0;
+    long obsTotal=0;
+    int residual=0; //represents the number of observation for the staring stars (if equal to zero  the number of observations for the starting  star is nObsxStar)
     /////////
-    for (int p = 0; p < myid; p++)
+    for(int p=0;p<myid;p++)
     {
-        while (obsTotal < mapNoss[p])
+        while(obsTotal<mapNoss[p])
         {
-            if (residual == 0)
+            if(residual==0)
             {
-                obsTotal += nObsxStar;
-                if (startingStar < nobsOri % nStar)
-                    obsTotal++;
-                if (nConstr > 0)
+                obsTotal+=nObsxStar;
+                if(startingStar<nobsOri%nStar) obsTotal++;
+                if(nConstr>0)
                 {
-                    for (int q = 0; q < nConstrLat; q++)
-                        if (constrLatId[q] == startingStar)
-                            obsTotal++;
-                    for (int q = 0; q < nConstrLong; q++)
-                        if (constrLongId[q] == startingStar)
-                            obsTotal++;
-                    for (int q = 0; q < nConstrMuLat; q++)
-                        if (constrMuLatId[q] == startingStar)
-                            obsTotal++;
-                    for (int q = 0; q < nConstrMuLong; q++)
-                        if (constrMuLongId[q] == startingStar)
-                            obsTotal++;
+                    for(int q=0;q<nConstrLat;q++)
+                        if(constrLatId[q]==startingStar) obsTotal++;
+                    for(int q=0;q<nConstrLong;q++)
+                        if(constrLongId[q]==startingStar) obsTotal++;
+                    for(int q=0;q<nConstrMuLat;q++)
+                        if(constrMuLatId[q]==startingStar) obsTotal++;
+                    for(int q=0;q<nConstrMuLong;q++)
+                        if(constrMuLongId[q]==startingStar) obsTotal++;
                 }
-            }
-            else
-            { //if residual
-                obsTotal = residual;
-                residual = 0;
-            }
-
-            if (obsTotal <= mapNoss[p])
-                startingStar++;
-        } //while
-        residual = obsTotal - mapNoss[p];
-        obsTotal = 0;
+            } else { //if residual
+                obsTotal=residual;
+                residual=0;
+            }
+            
+            if(obsTotal<=mapNoss[p])startingStar++;
+        }//while
+        residual=obsTotal-mapNoss[p];
+        obsTotal=0;
     } // for in p
     //////////////////////////
-    if (debugMode)
-        printf("PE=%d mapNoss[myid]=%ld starting star %ld residual=%d\n", myid, mapNoss[myid], startingStar, residual);
-
+    if(debugMode) printf("PE=%d mapNoss[myid]=%ld starting star %ld residual=%d\n",myid,mapNoss[myid],startingStar,residual);
+   
     //////////////// filling the system
-    long currentStar = startingStar;
-    int obsStar = residual;
+    long currentStar=startingStar;
+    int obsStar=residual;
     int obsStarnow;
-    int numOfObslast = 0;
-    long startFreedom = (nDegFreedomAtt / nproc) * myid;
-    long endFreedom = startFreedom + (nDegFreedomAtt / nproc) + 1;
-    long lastFreedom = startFreedom;
-    int freedomReached = 0;
-    long instrStartFreedom = (nInstrParam / nproc) * myid;
-    long instrEndFreedom = instrStartFreedom + (nInstrParam / nproc) + 1;
-    if (myid == nproc - 1)
-        instrEndFreedom = nInstrParam - 1;
-    int instrFreedomReached = 0;
-    int isConstraint = 0;
-    int instrLastFreedom = instrStartFreedom;
+    int numOfObslast=0;
+    long startFreedom=(nDegFreedomAtt/nproc)*myid;
+    long endFreedom=startFreedom+(nDegFreedomAtt/nproc)+1;
+    long lastFreedom=startFreedom;
+    int freedomReached=0;
+    long instrStartFreedom=(nInstrParam/nproc)*myid;
+    long instrEndFreedom=instrStartFreedom+(nInstrParam/nproc)+1;
+    if(myid==nproc-1)
+        instrEndFreedom=nInstrParam-1;
+    int instrFreedomReached=0;
+    int isConstraint=0;
+    int instrLastFreedom=instrStartFreedom;
     srand(myid);
-    if (debugMode)
-        printf("PE=%d instrStartFreedom=%ld instrEndFreedom=%ld nInstrParam=%d\n", myid, instrStartFreedom, instrEndFreedom, nInstrParam);
-    if (obsStar == 0)
-    {
-        obsStar = nObsxStar;
-        if (currentStar < nobsOri % nStar)
-            obsStar++;
-        if (nConstr > 0)
-        {
-            for (int q = 0; q < nConstrLat; q++)
-                if (constrLatId[q] == currentStar)
-                    obsStar++;
-            for (int q = 0; q < nConstrLong; q++)
-                if (constrLongId[q] == currentStar)
-                    obsStar++;
-            for (int q = 0; q < nConstrMuLat; q++)
-                if (constrMuLatId[q] == currentStar)
-                    obsStar++;
-            for (int q = 0; q < nConstrLong; q++)
-                if (constrMuLongId[q] == currentStar)
-                    obsStar++;
+    if(debugMode)
+        printf("PE=%d instrStartFreedom=%ld instrEndFreedom=%ld nInstrParam=%d\n",myid,instrStartFreedom,instrEndFreedom,nInstrParam);
+    if(obsStar==0)
+    {
+        obsStar=nObsxStar;
+        if(currentStar<nobsOri%nStar) obsStar++;
+        if(nConstr>0)
+        {
+            for(int q=0;q<nConstrLat;q++)
+                if(constrLatId[q]==currentStar) obsStar++;
+            for(int q=0;q<nConstrLong;q++)
+                if(constrLongId[q]==currentStar) obsStar++;
+            for(int q=0;q<nConstrMuLat;q++)
+                if(constrMuLatId[q]==currentStar) obsStar++;
+            for(int q=0;q<nConstrLong;q++)
+                if(constrMuLongId[q]==currentStar) obsStar++;
         }
+        
     }
-    obsStarnow = obsStar;
-    if (nConstr > 0)
+    obsStarnow=obsStar;
+    if(nConstr>0)
     {
-        for (int q = 0; q < nConstrLat; q++)
-            if (constrLatId[q] == currentStar)
-                isConstraint++;
-        for (int q = 0; q < nConstrLong; q++)
-            if (constrLongId[q] == currentStar)
-                isConstraint++;
-        for (int q = 0; q < nConstrMuLat; q++)
-            if (constrMuLatId[q] == currentStar)
-                isConstraint++;
-        for (int q = 0; q < nConstrMuLong; q++)
-            if (constrMuLongId[q] == currentStar)
-                isConstraint++;
+        for(int q=0;q<nConstrLat;q++)
+            if(constrLatId[q]==currentStar) isConstraint++;
+        for(int q=0;q<nConstrLong;q++)
+            if(constrLongId[q]==currentStar) isConstraint++;
+        for(int q=0;q<nConstrMuLat;q++)
+            if(constrMuLatId[q]==currentStar) isConstraint++;
+        for(int q=0;q<nConstrMuLong;q++)
+            if(constrMuLongId[q]==currentStar) isConstraint++;
     }
-
-    int offsetConstraint = isConstraint - obsStar; // number of constraint alredy computed in the previous PE
-    if (offsetConstraint < 0)
-        offsetConstraint = 0;
-
-    int counterStarObs = 0;
-    rowInFile = -1;
-    int changedStar = 0;
-    int counterConstr = 0;
+    
+    int offsetConstraint=isConstraint-obsStar; // number of constraint alredy computed in the previous PE
+    if(offsetConstraint<0)offsetConstraint=0;
+    
+    
+    int counterStarObs=0;
+    rowInFile=-1;
+    int changedStar=0;
+    int counterConstr=0;
     /////////////////////////////////
     ///////////   RUNNING ON ALL OBSERVATIONS
     /////////////////////////////////
-    for (ii = 0; ii < mapNoss[myid]; ii++)
+    for(ii=0;ii<mapNoss[myid];ii++)
     {
         rowInFile++;
-        if (currentStar % 1000 == 0 && changedStar)
-        {
-            rowInFile = 0;
-            changedStar = 0;
+        if(currentStar%1000==0 && changedStar){
+            rowInFile=0;
+            changedStar=0;
         }
         ///////////// generate MatrixIndex
-        if (currentStar == nStar)
+        if(currentStar==nStar)
         {
-            printf("PE=%d Severe Error in currentStar=%ld ii=%ld\n", myid, currentStar, ii);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("PE=%d Severe Error in currentStar=%ld ii=%ld\n",myid,currentStar,ii);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
 
-        if (nAstroPSolved)
-            matrixIndex[ii * multMI] = currentStar * nAstroPSolved;
-
-        if (!freedomReached && nAstroPSolved)
+        if(nAstroPSolved) matrixIndex[ii*multMI]=currentStar*nAstroPSolved;
+        
+        if(!freedomReached && nAstroPSolved)
         {
-            if ((obsStar - counterStarObs) <= isConstraint)
-            { //constraint
-                matrixIndex[ii * multMI + (multMI - 1)] = offsetAttParam;
-                constraintFound[counterConstr][0] = currentStar / 1000;
-                constraintFound[counterConstr][1] = rowInFile;
+            if((obsStar-counterStarObs)<=isConstraint)
+            {  //constraint
+                matrixIndex[ii*multMI+(multMI-1)]=offsetAttParam;
+                constraintFound[counterConstr][0]=currentStar/1000;
+                constraintFound[counterConstr][1]=rowInFile;
                 counterConstr++;
-
-                if (counterConstr == MAX_CONSTR)
-                {
-                    printf("PE=%d Abort increase MAX_CONSTR and recompile =%d \n", myid, counterConstr);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                
+                if(counterConstr==MAX_CONSTR){
+                    printf("PE=%d Abort increase MAX_CONSTR and recompile =%d \n",myid,counterConstr);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
             }
-            else
-            {
-                if (lastFreedom >= nDegFreedomAtt - nAttParAxis)
-                    lastFreedom = nDegFreedomAtt - nAttParAxis;
-                matrixIndex[ii * multMI + (multMI - 1)] = offsetAttParam + lastFreedom;
-                if (lastFreedom >= endFreedom || lastFreedom >= nDegFreedomAtt - nAttParAxis)
-                    freedomReached = 1;
-                lastFreedom += nAttParAxis;
+            else{
+                if(lastFreedom>=nDegFreedomAtt-nAttParAxis) lastFreedom=nDegFreedomAtt-nAttParAxis;
+                matrixIndex[ii*multMI+(multMI-1)]=offsetAttParam+lastFreedom;
+                if(lastFreedom>=endFreedom || lastFreedom>=nDegFreedomAtt-nAttParAxis) freedomReached=1;
+                lastFreedom+=nAttParAxis;
             }
-        }
-        else
-        {
-            lastFreedom = (((double)rand()) / (((double)RAND_MAX))) * (nDegFreedomAtt - nAttParAxis + 1);
-            if (lastFreedom > nDegFreedomAtt - nAttParAxis)
-                lastFreedom = nDegFreedomAtt - nAttParAxis;
-            if ((obsStar - counterStarObs) <= isConstraint) //constraint
+        } else {
+            lastFreedom=( ( (double)rand() ) / ( ((double)RAND_MAX) ) ) * (nDegFreedomAtt-nAttParAxis+1);
+            if(lastFreedom>nDegFreedomAtt-nAttParAxis) lastFreedom=nDegFreedomAtt-nAttParAxis;
+            if((obsStar-counterStarObs)<=isConstraint) //constraint
             {
-                lastFreedom = 0;
-                constraintFound[counterConstr][0] = currentStar / 1000;
-                constraintFound[counterConstr][1] = rowInFile;
+                lastFreedom=0;
+                constraintFound[counterConstr][0]=currentStar/1000;
+                constraintFound[counterConstr][1]=rowInFile;
                 counterConstr++;
             }
-            matrixIndex[ii * multMI + (multMI - 1)] = offsetAttParam + lastFreedom;
+            matrixIndex[ii*multMI+(multMI-1)]=offsetAttParam+lastFreedom;
         }
         ///////////// generate InstrIndex
-
-        if (!instrFreedomReached && nInstrPSolved)
-        {
-            if ((obsStar - counterStarObs) <= isConstraint)
-            { //constraint
-                for (int kk = 0; kk < nInstrPSolved; kk++)
-                    instrCol[ii * nInstrPSolved + kk] = 0;
-            }
-            else
-            {
-                if (instrLastFreedom > instrEndFreedom)
-                    instrLastFreedom = instrEndFreedom;
-                instrCol[ii * nInstrPSolved] = instrLastFreedom;
-                for (int kk = 1; kk < nInstrPSolved; kk++)
-                    instrCol[ii * nInstrPSolved + kk] = (((double)rand()) / (((double)RAND_MAX))) * (nInstrParam - 1);
-                if (instrLastFreedom == instrEndFreedom)
-                    instrFreedomReached = 1;
+        
+        if(!instrFreedomReached  && nInstrPSolved)
+        {
+            if((obsStar-counterStarObs)<=isConstraint)
+            {  //constraint
+                for(int kk=0;kk<nInstrPSolved;kk++)
+                    instrCol[ii*nInstrPSolved+kk]=0;
+            }
+            else{
+                if(instrLastFreedom>instrEndFreedom) instrLastFreedom=instrEndFreedom;
+                instrCol[ii*nInstrPSolved]=instrLastFreedom;
+                for(int kk=1;kk<nInstrPSolved;kk++)
+                    instrCol[ii*nInstrPSolved+kk]=(((double)rand()) / (((double)RAND_MAX))) * (nInstrParam-1);
+                if(instrLastFreedom==instrEndFreedom)
+                    instrFreedomReached=1;
                 instrLastFreedom++;
             }
-        }
-        else
-        {
-            if ((obsStar - counterStarObs) <= isConstraint)
+        } else {
+            if((obsStar-counterStarObs)<=isConstraint)
             { //constraint
-                for (int kk = 0; kk < nInstrPSolved; kk++)
-                    instrCol[ii * nInstrPSolved + kk] = 0;
-            }
-            else
-            {
-                for (int kk = 0; kk < nInstrPSolved; kk++)
-                    instrCol[ii * nInstrPSolved + kk] = (((double)rand()) / (((double)RAND_MAX))) * (nInstrParam - 1);
+                for(int kk=0;kk<nInstrPSolved;kk++)
+                    instrCol[ii*nInstrPSolved+kk]=0;
+            }else{
+                for(int kk=0;kk<nInstrPSolved;kk++)
+                    instrCol[ii*nInstrPSolved+kk]=(((double)rand() ) / ( ((double)RAND_MAX) ) ) * (nInstrParam-1);
             }
         }
         ///////////// generate systemMatrix
-        if ((obsStar - counterStarObs) > isConstraint)
-        {
-            for (int q = 0; q < nAstroPSolved; q++)
-                systemMatrix[ii * nparam + q] = (((double)rand()) / RAND_MAX) * 2 - 1.0;
-            for (int q = 0; q < nAttP + nInstrPSolved + nGlobP; q++)
-                systemMatrix[ii * nparam + nAstroPSolved + q] = (((double)rand()) / RAND_MAX) * 2 - 1.0;
-        }
-        else // I add a Constraint
-        {
-            for (int q = 0; q < nAstroPSolved + nAttP + nInstrPSolved + nGlobP; q++)
-                systemMatrix[ii * nparam + q] = 0.;
-            if (nAstroPSolved > 0)
-            {
-                if (ii != 0)
-                    offsetConstraint = 0;
-                int foundedConstraint = (obsStar - counterStarObs) + offsetConstraint;
-                int itis = 0;
-                for (int q = 0; q < nConstrLong; q++)
-                    if (constrLongId[q] == currentStar)
-                    {
+        if((obsStar-counterStarObs)>isConstraint )
+        {
+            for(int q=0;q<nAstroPSolved;q++)
+                systemMatrix[ii*nparam+q]=(((double)rand())/RAND_MAX)*2 - 1.0;
+            for(int q=0;q<nAttP+nInstrPSolved+nGlobP;q++)
+                systemMatrix[ii*nparam+nAstroPSolved+q]=(((double)rand())/RAND_MAX)*2 - 1.0;
+        } else  // I add a Constraint
+        {
+            for(int q=0;q<nAstroPSolved+nAttP+nInstrPSolved+nGlobP;q++)
+                systemMatrix[ii*nparam+q]=0.;
+            if(nAstroPSolved>0)
+            {
+                if(ii!=0) offsetConstraint=0;
+                int foundedConstraint=(obsStar-counterStarObs)+offsetConstraint;
+                int itis=0;
+                for(int q=0;q<nConstrLong;q++)
+                    if(constrLongId[q]==currentStar){
                         itis++;
-                        if (itis == foundedConstraint)
-                            systemMatrix[ii * nparam + LongPos] = constrLongW[q];
+                        if(itis==foundedConstraint)
+                            systemMatrix[ii*nparam+LongPos]=constrLongW[q];
                     }
-                for (int q = 0; q < nConstrLat; q++)
-                    if (constrLatId[q] == currentStar)
-                    {
+                for(int q=0;q<nConstrLat;q++)
+                    if(constrLatId[q]==currentStar){
                         itis++;
-                        if (itis == foundedConstraint)
-                            systemMatrix[ii * nparam + LatPos] = constrLatW[q];
+                        if(itis==foundedConstraint)
+                            systemMatrix[ii*nparam+LatPos]=constrLatW[q];
                     }
-                for (int q = 0; q < nConstrMuLong; q++)
-                    if (constrMuLongId[q] == currentStar)
-                    {
+                for(int q=0;q<nConstrMuLong;q++)
+                    if(constrMuLongId[q]==currentStar){
                         itis++;
-                        if (itis == foundedConstraint)
-                            systemMatrix[ii * nparam + MuLongPos] = constrMuLongW[q];
+                        if(itis==foundedConstraint)
+                            systemMatrix[ii*nparam+MuLongPos]=constrMuLongW[q];
                     }
-                for (int q = 0; q < nConstrMuLat; q++)
-                    if (constrMuLatId[q] == currentStar)
-                    {
+                for(int q=0;q<nConstrMuLat;q++)
+                    if(constrMuLatId[q]==currentStar){
                         itis++;
-                        if (itis == foundedConstraint)
-                            systemMatrix[ii * nparam + MuLatPos] = constrMuLatW[q];
+                        if(itis==foundedConstraint)
+                            systemMatrix[ii*nparam+MuLatPos]=constrMuLatW[q];
                     }
             }
         }
         /////////////////////////
-        if ((obsStar - counterStarObs) <= isConstraint)
+        if((obsStar-counterStarObs)<=isConstraint )
         {
-            printf("PE=%d isConstraint=%d ii=%ld matrixIndex[ii*2]=%ld matrixIndex[ii*2+1]=%ld\n", myid, isConstraint, ii, matrixIndex[ii * 2], matrixIndex[ii * 2 + 1]);
-            for (int q = 0; q < nparam; q++)
-                printf("PE=%d systemMatrix[%ld]=%lf ", myid, ii * nparam + q, systemMatrix[ii * nparam + q]);
+            printf("PE=%d isConstraint=%d ii=%ld matrixIndex[ii*2]=%ld matrixIndex[ii*2+1]=%ld\n",myid,isConstraint,ii,matrixIndex[ii*2],matrixIndex[ii*2+1]);
+            for(int q=0;q<nparam;q++) printf("PE=%d systemMatrix[%ld]=%lf ",myid,ii*nparam+q,systemMatrix[ii*nparam+q]);
             printf("\n");
         }
-
+        
         /////////////////// Prepare next Obs
         counterStarObs++;
-        if (counterStarObs == obsStar)
+        if(counterStarObs==obsStar)
         {
-            if (myid == (nproc - 1))
-                numOfObslast = counterStarObs;
-            counterStarObs = 0;
+            if(myid==(nproc-1))
+                numOfObslast=counterStarObs;
+            counterStarObs=0;
             currentStar++;
-            changedStar = 1;
-            isConstraint = 0;
-            obsStar = nObsxStar;
-            if (currentStar < nobsOri % nStar)
-                obsStar++;
-            if (nConstr > 0)
-            {
-                for (int q = 0; q < nConstrLat; q++)
-                    if (constrLatId[q] == currentStar)
+            changedStar=1;
+            isConstraint=0;
+            obsStar=nObsxStar;
+            if(currentStar<nobsOri%nStar) obsStar++;
+            if(nConstr>0)
+            {
+                for(int q=0;q<nConstrLat;q++)
+                    if(constrLatId[q]==currentStar)
                     {
                         obsStar++;
                         isConstraint++;
                     }
-                for (int q = 0; q < nConstrLong; q++)
-                    if (constrLongId[q] == currentStar)
+                for(int q=0;q<nConstrLong;q++)
+                    if(constrLongId[q]==currentStar)
                     {
                         obsStar++;
                         isConstraint++;
                     }
-                for (int q = 0; q < nConstrMuLat; q++)
-                    if (constrMuLatId[q] == currentStar)
+                for(int q=0;q<nConstrMuLat;q++)
+                    if(constrMuLatId[q]==currentStar)
                     {
                         obsStar++;
                         isConstraint++;
                     }
-                for (int q = 0; q < nConstrMuLong; q++)
-                    if (constrMuLongId[q] == currentStar)
+                for(int q=0;q<nConstrMuLong;q++)
+                    if(constrMuLongId[q]==currentStar)
                     {
                         obsStar++;
                         isConstraint++;
                     }
+                
             }
         }
         ///////////////////////////////// Filling knownTerms  -1.. 1
-        if (!idtest)
-            knownTerms[ii] = (((double)rand()) / RAND_MAX) * 2.0 - 1.0; //show idtest=1  at the beginning instead of =0
+        if(!idtest) knownTerms[ii]=(((double) rand())/RAND_MAX)*2.0-1.0; //show idtest=1  at the beginning instead of =0
         /////////////////////////////////////////
-
+        
+        
         ///////////////////////////////////
     } // for ii=0 mapNoss[myid]
-
+    
     if (!freedomReached && !zeroAtt)
     {
-        printf("PE=%d Error ndegFreedomAtt not correctly generated\n", myid);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+        printf("PE=%d Error ndegFreedomAtt not correctly generated\n",myid);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
     }
     if (!instrFreedomReached && !zeroInstr)
     {
-        printf("PE=%d Error instrP not all generated instrLastFreedom=%d\n", myid, instrLastFreedom);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+        printf("PE=%d Error instrP not all generated instrLastFreedom=%d\n",myid,instrLastFreedom);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
+        
     }
     ////////////////////
     ///////////////////////// generate extConstr on systemMatrix
-    if (extConstraint)
-    {
+    if(extConstraint){
         double randVal;
         double *accumulator;
-        accumulator = (double *)calloc(nEqExtConstr, sizeof(double));
-        attNS = (double *)calloc(nDegFreedomAtt, sizeof(double));
+        accumulator=(double *) calloc(nEqExtConstr,sizeof(double));
+        attNS=(double *) calloc(nDegFreedomAtt,sizeof(double));
         if (!attNS)
-            exit(err_malloc("attNS", myid));
-        if (myid == 0)
-        {
-            for (int i = 0; i < nDegFreedomAtt; i++)
-                attNS[i] = (((double)rand()) / RAND_MAX) * 2 - 1.0;
-        }
-        MPI_Bcast(attNS, nDegFreedomAtt, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-
-        for (int j = 0; j < nEqExtConstr; j++)
-        {
-            for (int i = 0; i < addElementextStar + addElementAtt; i++)
-            {
-                randVal = (((double)rand()) / RAND_MAX) * 2 - 1.0;
-                if (i < addElementextStar)
-                {
-                    if (nAstroPSolved == 3 && i % nAstroPSolved == 0)
-                        randVal = 0.;
-                    if (nAstroPSolved == 4 && i % nAstroPSolved >= 2)
-                        randVal = 0.;
-                    if (nAstroPSolved == 5 && i % nAstroPSolved == 0)
-                        randVal = 0.;
-                    if (nAstroPSolved == 5 && i % nAstroPSolved > 2 && j < 3)
-                        randVal = 0.;
+            exit(err_malloc("attNS",myid));
+        if(myid==0){
+            for(int i=0;i<nDegFreedomAtt;i++)
+                attNS[i]=(((double)rand())/RAND_MAX)*2 - 1.0;
+        }
+        MPI_Bcast( attNS, nDegFreedomAtt, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+            
+        for(int j=0;j<nEqExtConstr;j++){
+            for(int i=0;i<addElementextStar+addElementAtt;i++){
+                randVal=(((double)rand())/RAND_MAX)*2 - 1.0;
+                if(i<addElementextStar){
+                    if(nAstroPSolved==3 && i%nAstroPSolved==0) randVal=0.;
+                    if(nAstroPSolved==4 && i%nAstroPSolved>=2) randVal=0.;
+                    if(nAstroPSolved==5 && i%nAstroPSolved==0) randVal=0.;
+                    if(nAstroPSolved==5 && i%nAstroPSolved>2 && j<3) randVal=0.;
                 }
-                if (i >= addElementextStar)
-                {
-                    if (j < 3)
-                        randVal = 1.0;
-                    if (j == 0 || j == 3)
-                    {
-                        if (i >= addElementextStar + addElementAtt / nAttAxes)
-                            randVal = 0.0;
+                if(i>=addElementextStar){
+                    if(j<3) randVal=1.0;
+                    if(j==0 || j==3){
+                        if(i>=addElementextStar+addElementAtt/nAttAxes) randVal=0.0;
                     }
-                    if (j == 1 || j == 4)
-                    {
-                        if (i < addElementextStar + addElementAtt / nAttAxes)
-                            randVal = 0.0;
-                        if (i >= addElementextStar + 2 * addElementAtt / nAttAxes)
-                            randVal = 0.0;
+                    if(j==1 || j==4){
+                        if(i<addElementextStar+addElementAtt/nAttAxes) randVal=0.0;
+                        if(i>=addElementextStar+2*addElementAtt/nAttAxes) randVal=0.0;
                     }
-                    if (j == 2 || j == 5)
-                    {
-                        if (i < addElementextStar + 2 * addElementAtt / nAttAxes)
-                            randVal = 0.0;
+                    if(j==2 || j==5){
+                        if(i<addElementextStar+2*addElementAtt/nAttAxes) randVal=0.0;
                     }
+                    
+                    
                 }
-                systemMatrix[mapNcoeff[myid] + i + j * nOfElextObs] = randVal * extConstrW;
-                accumulator[j] += randVal * extConstrW;
+                systemMatrix[mapNcoeff[myid]+i+j*nOfElextObs]=randVal*extConstrW;
+                accumulator[j]+=randVal*extConstrW;
+
             }
-            if (!idtest)
-                knownTerms[mapNoss[myid] + j] = 0.;
-        } // j=0
-        if (idtest)
+            if(!idtest)
+                  knownTerms[mapNoss[myid]+j]=0.;
+        }// j=0
+        if(idtest)
             MPI_Allreduce(accumulator, &knownTerms[mapNoss[myid]], nEqExtConstr, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
         free(accumulator);
     } //if(extConstr
-
+    
     ///////////////////////// generate barConstr on systemMatrix
-    if (barConstraint)
-    {
+    if(barConstraint){
         double randVal;
         double *accumulator;
-        accumulator = (double *)calloc(nEqBarConstr, sizeof(double));
-
-        for (int j = 0; j < nEqBarConstr; j++)
-        {
-            for (int i = 0; i < addElementbarStar; i++)
-            {
-                randVal = (((double)rand()) / RAND_MAX) * 2 - 1.0;
-                if (nAstroPSolved == 3 && i % nAstroPSolved == 0)
-                    randVal = 0.;
-                if (nAstroPSolved == 4 && i % nAstroPSolved >= 2)
-                    randVal = 0.;
-                if (nAstroPSolved == 5 && i % nAstroPSolved == 0)
-                    randVal = 0.;
-                if (nAstroPSolved == 5 && i % nAstroPSolved > 2 && j < 3)
-                    randVal = 0.;
-                systemMatrix[mapNcoeff[myid] + nEqExtConstr * nOfElextObs + i + j * nOfElBarObs] = randVal * barConstrW;
-                accumulator[j] += randVal * barConstrW;
-            }
-            if (!idtest)
-                knownTerms[mapNoss[myid] + nEqExtConstr + j] = 0.;
-        } // j=0
-        if (idtest)
-            MPI_Allreduce(accumulator, &knownTerms[mapNoss[myid] + nEqExtConstr], nEqBarConstr, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
+        accumulator=(double *) calloc(nEqBarConstr,sizeof(double));
+        
+        for(int j=0;j<nEqBarConstr;j++){
+            for(int i=0;i<addElementbarStar;i++){
+                randVal=(((double)rand())/RAND_MAX)*2 - 1.0;
+                if(nAstroPSolved==3 && i%nAstroPSolved==0) randVal=0.;
+                if(nAstroPSolved==4 && i%nAstroPSolved>=2) randVal=0.;
+                if(nAstroPSolved==5 && i%nAstroPSolved==0) randVal=0.;
+                if(nAstroPSolved==5 && i%nAstroPSolved>2 && j<3) randVal=0.;
+                systemMatrix[mapNcoeff[myid]+nEqExtConstr*nOfElextObs+i+j*nOfElBarObs]=randVal*barConstrW;
+                accumulator[j]+=randVal*barConstrW;
+                
+            }
+            if(!idtest)
+            knownTerms[mapNoss[myid]+nEqExtConstr+j]=0.;
+        }// j=0
+        if(idtest)
+        MPI_Allreduce(accumulator, &knownTerms[mapNoss[myid]+nEqExtConstr], nEqBarConstr, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
         free(accumulator);
     } //if(barConstr
-
+  
     ///////////////////////// generate instrConstr on systemMatrix
     // There are 1 AL + 2 AC constraint equations for each time interval for the large scale parameters (total=3*nTimeIntervals)
     // There are 1 AL + 1 AC constraint equations for each CCD and Legendre polinomial degree (total=2*nCCDs*3)
     // The equations are described by three arrays: instrCoeffConstr, instrColsConstr, instrConstrIlung, which contain the
     // coefficients, the column indexes and the length of the non-zero coefficients of each equation respectively.
 
-    comlsqr.offsetCMag = maInstrFlag * nCCDs;                                           // offest=0 if maInstrFlag=0
-    comlsqr.offsetCnu = comlsqr.offsetCMag + nuInstrFlag * nFoVs * nCCDs;               // offest=offsetCMag if nuInstrFlag=0
-    comlsqr.offsetCdelta_eta = comlsqr.offsetCnu + ssInstrFlag * nCCDs * nPixelColumns; // offest=offsetCnu if ssInstrFlag=0
-    comlsqr.offsetCDelta_eta_1 = comlsqr.offsetCdelta_eta + lsInstrFlag * nFoVs * nCCDs * nTimeIntervals;
-    comlsqr.offsetCDelta_eta_2 = comlsqr.offsetCdelta_eta + lsInstrFlag * 2 * nFoVs * nCCDs * nTimeIntervals;
-    comlsqr.offsetCDelta_eta_3 = comlsqr.offsetCdelta_eta + lsInstrFlag * 3 * nFoVs * nCCDs * nTimeIntervals;
-    comlsqr.offsetCdelta_zeta = comlsqr.offsetCDelta_eta_3 + ssInstrFlag * nCCDs * nPixelColumns;
-    comlsqr.offsetCDelta_zeta_1 = comlsqr.offsetCdelta_zeta + lsInstrFlag * nFoVs * nCCDs * nTimeIntervals;
-    comlsqr.offsetCDelta_zeta_2 = comlsqr.offsetCdelta_zeta + lsInstrFlag * 2 * nFoVs * nCCDs * nTimeIntervals;
-    comlsqr.nInstrPSolved = nInstrPSolved;
-
-    if (myid == 0 && lsInstrFlag && nElemIC != 0)
-    {
-        double *instrCoeffConstr;
-        instrCoeffConstr = (double *)calloc(nElemIC, sizeof(double));
-        int *instrColsConstr;
-        instrColsConstr = (int *)calloc(nElemIC, sizeof(int));
+    comlsqr.offsetCMag=maInstrFlag*nCCDs; // offest=0 if maInstrFlag=0
+    comlsqr.offsetCnu=comlsqr.offsetCMag+nuInstrFlag*nFoVs*nCCDs; // offest=offsetCMag if nuInstrFlag=0
+    comlsqr.offsetCdelta_eta=comlsqr.offsetCnu+ssInstrFlag*nCCDs*nPixelColumns; // offest=offsetCnu if ssInstrFlag=0
+    comlsqr.offsetCDelta_eta_1=comlsqr.offsetCdelta_eta+lsInstrFlag*nFoVs*nCCDs*nTimeIntervals;
+    comlsqr.offsetCDelta_eta_2=comlsqr.offsetCdelta_eta+lsInstrFlag*2*nFoVs*nCCDs*nTimeIntervals;
+    comlsqr.offsetCDelta_eta_3=comlsqr.offsetCdelta_eta+lsInstrFlag*3*nFoVs*nCCDs*nTimeIntervals;
+    comlsqr.offsetCdelta_zeta=comlsqr.offsetCDelta_eta_3+ssInstrFlag*nCCDs*nPixelColumns;
+    comlsqr.offsetCDelta_zeta_1=comlsqr.offsetCdelta_zeta+lsInstrFlag*nFoVs*nCCDs*nTimeIntervals;
+    comlsqr.offsetCDelta_zeta_2=comlsqr.offsetCdelta_zeta+lsInstrFlag*2*nFoVs*nCCDs*nTimeIntervals;
+    comlsqr.nInstrPSolved=nInstrPSolved;
 
-        if (!computeInstrConstr(comlsqr, instrCoeffConstr, instrColsConstr, instrConstrIlung))
+    
+    if(myid==0 && lsInstrFlag && nElemIC!=0 ){
+        double * instrCoeffConstr;
+        instrCoeffConstr=(double *) calloc(nElemIC, sizeof(double));
+        int * instrColsConstr;
+        instrColsConstr=(int *) calloc(nElemIC, sizeof(int));
+        
+        if(!computeInstrConstr(comlsqr, instrCoeffConstr, instrColsConstr, instrConstrIlung))
         {
             printf("SEVERE ERROR PE=0 computeInstrConstr failed\n");
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
         //////////////////////////
-        for (int k = 0; k < nElemIC; k++)
-            instrCoeffConstr[k] = instrCoeffConstr[k] * wgInstrCoeff;
+        for(int k=0;k<nElemIC;k++)
+            instrCoeffConstr[k]=instrCoeffConstr[k]*wgInstrCoeff;
         /////////////////////////
-        for (int j = 0; j < nElemIC; j++)
-        {
-            systemMatrix[mapNcoeff[myid] + nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr + j] = instrCoeffConstr[j];
-            instrCol[mapNoss[myid] * nInstrPSolved + j] = instrColsConstr[j];
-        }
-        int counter0 = 0;
-        for (int j = 0; j < nOfInstrConstr; j++)
-        {
-            double sumVal = 0.;
-            for (int k = 0; k < instrConstrIlung[j]; k++)
-            {
-                sumVal += systemMatrix[mapNcoeff[myid] + nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr + counter0];
+        for(int j=0;j<nElemIC;j++){
+            systemMatrix[mapNcoeff[myid]+nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr+j]=instrCoeffConstr[j];
+            instrCol[mapNoss[myid]*nInstrPSolved+j]=instrColsConstr[j];
+        }
+        int counter0=0;
+        for(int j=0;j<nOfInstrConstr;j++){
+            double sumVal=0.;
+            for(int k=0;k<instrConstrIlung[j];k++){
+               sumVal+= systemMatrix[mapNcoeff[myid]+nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr+counter0];
                 counter0++;
             }
-            if (idtest)
-            {
-                knownTerms[mapNoss[myid] + nEqExtConstr + nEqBarConstr + j] = sumVal;
-            }
-            else
-            {
-                knownTerms[mapNoss[myid] + nEqExtConstr + nEqBarConstr + j] = 0.;
+            if(idtest){
+            knownTerms[mapNoss[myid]+nEqExtConstr+nEqBarConstr+j]=sumVal;
+            } else{
+                knownTerms[mapNoss[myid]+nEqExtConstr+nEqBarConstr+j]=0.;
             }
         }
-        if (counter0 != nElemIC)
-        {
-            printf("SEVERE ERROR PE=0 counter0=%d != nElemIC=%d when computing knownTerms for InstrConstr\n", counter0, nElemIC);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+        if(counter0 != nElemIC){
+            printf("SEVERE ERROR PE=0 counter0=%d != nElemIC=%d when computing knownTerms for InstrConstr\n",counter0,nElemIC);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
 
         //..... write files
-        if (wrFilebin)
-        {
+        if(wrFilebin){
             chdir(wpath);
             chdir(wrfileDir);
-            FILE *fpICCoeff, *fpICCols, *fpICIlung;
-            fpICCoeff = fopen("instrConstrRows_Coeff.bin", "wb");
-            fpICCols = fopen("instrConstrRows_Cols.bin", "wb");
-            fpICIlung = fopen("instrConstrRows_Ilung.bin", "wb");
-
-            fwrite(instrConstrIlung, sizeof(int), nOfInstrConstr, fpICIlung);
-            fwrite(instrCoeffConstr, sizeof(double), nElemIC, fpICCoeff);
-            fwrite(instrColsConstr, sizeof(int), nElemIC, fpICCols);
-
+            FILE *fpICCoeff,*fpICCols,*fpICIlung;
+            fpICCoeff=fopen("instrConstrRows_Coeff.bin","wb");
+            fpICCols=fopen("instrConstrRows_Cols.bin","wb");
+            fpICIlung=fopen("instrConstrRows_Ilung.bin","wb");
+        
+            fwrite(instrConstrIlung,sizeof(int),nOfInstrConstr,fpICIlung);
+            fwrite(instrCoeffConstr,sizeof(double),nElemIC,fpICCoeff);
+            fwrite(instrColsConstr,sizeof(int),nElemIC,fpICCols);
+        
             fclose(fpICCoeff);
             fclose(fpICCols);
             fclose(fpICIlung);
@@ -2401,44 +2102,42 @@ int main(int argc, char **argv)
         }
         free(instrCoeffConstr);
         free(instrColsConstr);
-    } // if(myid==0)
-    MPI_Bcast(&systemMatrix[mapNcoeff[myid] + nOfElextObs * nEqExtConstr + nOfElBarObs * nEqBarConstr], nElemIC, MPI_DOUBLE, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&instrCol[mapNoss[myid] * nInstrPSolved], nElemIC, MPI_INT, 0, MPI_COMM_WORLD);
+     } // if(myid==0)
+    MPI_Bcast(&systemMatrix[mapNcoeff[myid]+nOfElextObs*nEqExtConstr+nOfElBarObs*nEqBarConstr], nElemIC, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&instrCol[mapNoss[myid]*nInstrPSolved], nElemIC, MPI_INT, 0, MPI_COMM_WORLD);
     MPI_Bcast(instrConstrIlung, nOfInstrConstr, MPI_INT, 0, MPI_COMM_WORLD);
-    MPI_Bcast(&knownTerms[mapNoss[myid] + nEqExtConstr + nEqBarConstr], nOfInstrConstr, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&knownTerms[mapNoss[myid]+nEqExtConstr+nEqBarConstr], nOfInstrConstr, MPI_DOUBLE, 0, MPI_COMM_WORLD);
 
     /////// Search for map
-    if (nAstroPSolved)
+    if(nAstroPSolved)
     {
-        firstStar = matrixIndex[0] / nAstroPSolved;
-        lastStar = matrixIndex[mapNoss[myid] * 2 - 2] / nAstroPSolved;
-        seqStar = lastStar - firstStar + 1;
+        firstStar=matrixIndex[0]/nAstroPSolved;
+        lastStar=matrixIndex[mapNoss[myid]*2-2]/nAstroPSolved;
+        seqStar=lastStar-firstStar+1;
     }
-    else
-    {
-        firstStar = 0;
-        lastStar = 0;
+    else{
+        firstStar=0;
+        lastStar=0;
     }
-    if (extConstraint && (firstStar != firstStarConstr || lastStar != lastStarConstr + starOverlap))
-    {
-        printf("PE=%d Error extConstraint:  firstStar=%ld firstStarConstr=%ld lastStar=%ld lastStarConstr=%ld\n", myid, firstStar, firstStarConstr, lastStar, lastStarConstr);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    if(extConstraint && (firstStar!=firstStarConstr || lastStar!=lastStarConstr+starOverlap)){
+        printf("PE=%d Error extConstraint:  firstStar=%ld firstStarConstr=%ld lastStar=%ld lastStarConstr=%ld\n",myid,firstStar,firstStarConstr,lastStar,lastStarConstr);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
+        
     }
-    if (barConstraint && (firstStar != firstStarConstr || lastStar != lastStarConstr + starOverlap))
-    {
-        printf("PE=%d Error barConstraint:  firstStar=%ld firstStarConstr=%ld lastStar=%ld lastStarConstr=%ld\n", myid, firstStar, firstStarConstr, lastStar, lastStarConstr);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+    if(barConstraint && (firstStar!=firstStarConstr || lastStar!=lastStarConstr+starOverlap)){
+        printf("PE=%d Error barConstraint:  firstStar=%ld firstStarConstr=%ld lastStar=%ld lastStarConstr=%ld\n",myid,firstStar,firstStarConstr,lastStar,lastStarConstr);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
+        
     }
-
+   
     ///////////////////////////////////////////////////////
-
+    
     ////////////////////////////////////////////////////////////////////
     chdir(wpath);
-    if (outputDirOpt)
-        chdir(outputDir); // go to output dir
-
+    if(outputDirOpt) chdir(outputDir); // go to output dir
+   
     //////////// Identity solution test
     // There are two possible IDtest modes: compatible and incompatible.
     // * in "compatible" mode the known term read from the input file is substituted by
@@ -2455,420 +2154,402 @@ int main(int argc, char **argv)
     //   (i.e. the sum of the coefficients since we are in IDtest mode). Therefore the
     //   perturbed known term is computed as
     //                KT_perturbed = KT_unperturbed*(1+x)
-
-    if (idtest) //if Identity test, overwrite the value of the knownterm
+    
+    
+    if(idtest)   //if Identity test, overwrite the value of the knownterm
     {
-        for (ii = 0; ii < mapNoss[myid]; ii++)
+        for(ii=0;ii<mapNoss[myid];ii++)
         {
-            knownTerms[ii] = 0.;
-            for (jj = 0; jj < nparam; jj++)
-                knownTerms[ii] += systemMatrix[ii * nparam + jj];
+            knownTerms[ii]=0.;
+            for(jj=0;jj<nparam;jj++)
+                knownTerms[ii] += systemMatrix[ii*nparam+jj];
         }
-        if (srIDtest != 0.)
+        if(srIDtest!=0.)
         {
-            for (ii = 0; ii < mapNoss[myid]; ii++)
+            for(ii=0;ii<mapNoss[myid];ii++)
             {
                 pert = gauss(0.0, srIDtest, idum);
-                knownTerms[ii] *= (1.0 + pert);
+                knownTerms[ii] *= (1.0+pert);
             }
         }
+        
     }
     //////////////////////////////////////
-    endTime = MPI_Wtime();
-    timeToReadFiles = MPI_Wtime() - timeToReadFiles;
-    printf("PE=%d time seconds=%lf to set system coefficients\n", myid, timeToReadFiles);
+    endTime=MPI_Wtime();
+    timeToReadFiles=MPI_Wtime()-timeToReadFiles;
+    printf("PE=%d time seconds=%lf to set system coefficients\n",myid, timeToReadFiles);
     /////  check, Fix map and dim
-    if (seqStar <= 1 && nAstroPSolved > 0)
+    if(seqStar<=1 && nAstroPSolved>0)
     {
-        printf("ERROR PE=%d Only %d star Run not allowed with this PE numbers .n", myid, seqStar);
+        printf("ERROR PE=%d Only %d star Run not allowed with this PE numbers .n",myid,seqStar);
         exit(EXIT_FAILURE);
     }
-    comlsqr.VrIdAstroPDim = seqStar;
-    long tempDimMax = comlsqr.VrIdAstroPDim;
+    comlsqr.VrIdAstroPDim=seqStar;
+    long tempDimMax=comlsqr.VrIdAstroPDim;
     long tempVrIdAstroPDimMax;
-    MPI_Allreduce(&tempDimMax, &tempVrIdAstroPDimMax, 1, MPI_LONG, MPI_MAX, MPI_COMM_WORLD);
-
-    comlsqr.VrIdAstroPDimMax = tempVrIdAstroPDimMax;
-
+    MPI_Allreduce(&tempDimMax,&tempVrIdAstroPDimMax,1,MPI_LONG,MPI_MAX,MPI_COMM_WORLD);
+   
+    comlsqr.VrIdAstroPDimMax=tempVrIdAstroPDimMax;
+    
     int **tempStarSend, **tempStarRecv;
-    tempStarSend = (int **)calloc(nproc, sizeof(int *));
-    for (int i = 0; i < nproc; i++)
-        tempStarSend[i] = (int *)calloc(2, sizeof(int));
-    tempStarRecv = (int **)calloc(nproc, sizeof(int *));
-    for (int i = 0; i < nproc; i++)
-        tempStarRecv[i] = (int *)calloc(2, sizeof(int));
-
+    tempStarSend=(int **) calloc(nproc,sizeof(int *));
+    for(int i=0;i<nproc;i++)
+        tempStarSend[i]=(int *) calloc(2,sizeof(int));
+    tempStarRecv=(int **) calloc(nproc,sizeof(int *));
+    for(int i=0;i<nproc;i++)
+        tempStarRecv[i]=(int *) calloc(2,sizeof(int));
+    
     int *testVectSend, *testVectRecv;
-    testVectSend = (int *)calloc(2 * nproc, sizeof(int));
-    testVectRecv = (int *)calloc(2 * nproc, sizeof(int));
-    testVectSend[2 * myid] = firstStar;
-    testVectSend[2 * myid + 1] = lastStar;
-
-    MPI_Allreduce(testVectSend, testVectRecv, 2 * nproc, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
-
-    comlsqr.mapStar = (int **)calloc(nproc, sizeof(int *));
-    for (int i = 0; i < nproc; i++)
-        comlsqr.mapStar[i] = (int *)calloc(2, sizeof(int));
-    for (int i = 0; i < nproc; i++)
+    testVectSend=(int *) calloc(2*nproc,sizeof(int));
+    testVectRecv=(int *) calloc(2*nproc,sizeof(int));
+    testVectSend[2*myid]=firstStar;
+    testVectSend[2*myid+1]=lastStar;
+    
+    MPI_Allreduce(testVectSend,testVectRecv,2*nproc,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
+  
+    
+    comlsqr.mapStar=(int **) calloc(nproc,sizeof(int *));
+    for(int i=0;i<nproc;i++)
+        comlsqr.mapStar[i]=(int *) calloc(2,sizeof(int));
+    for(int i=0;i<nproc;i++)
     {
-        comlsqr.mapStar[i][0] = testVectRecv[2 * i];
-        comlsqr.mapStar[i][1] = testVectRecv[2 * i + 1];
+        comlsqr.mapStar[i][0]=testVectRecv[2*i];
+        comlsqr.mapStar[i][1]=testVectRecv[2*i+1];
     }
-
-    for (int i = 0; i < nproc; i++)
-    {
+    
+    
+    for(int i=0;i<nproc;i++) {
         free(tempStarSend[i]);
         free(tempStarRecv[i]);
     }
-
+    
     free(tempStarSend);
     free(tempStarRecv);
-
-    if (comlsqr.mapStar[myid][0] == comlsqr.mapStar[myid][1] && nAstroPSolved > 0)
+    
+    if(comlsqr.mapStar[myid][0]==comlsqr.mapStar[myid][1] && nAstroPSolved>0)
     {
-        printf("PE=%d ERROR. Only one star in this PE: starting star=%d ending start=%d\n", myid, comlsqr.mapStar[myid][0], comlsqr.mapStar[myid][1]);
-        MPI_Abort(MPI_COMM_WORLD, 1);
+        printf("PE=%d ERROR. Only one star in this PE: starting star=%d ending start=%d\n",myid,comlsqr.mapStar[myid][0],comlsqr.mapStar[myid][1]);
+        MPI_Abort(MPI_COMM_WORLD,1);
         exit(EXIT_FAILURE);
+        
     }
 
-    if (myid == 0)
-        for (int i = 0; i < nproc; i++)
-            printf("mapStar[%d][0]=%d mapStar[%d][1]=%d\n", i, comlsqr.mapStar[i][0], i, comlsqr.mapStar[i][1]);
-
-    ////////  Check Null Space Vector
-    if (extConstraint)
-    {
+    if(myid==0)
+        for(int i=0;i<nproc;i++)printf("mapStar[%d][0]=%d mapStar[%d][1]=%d\n",i,comlsqr.mapStar[i][0],i,comlsqr.mapStar[i][1]);
+    
+    
+    
+     ////////  Check Null Space Vector
+    if(extConstraint){
         seconds[4] = time(NULL);
-
-        nullSpaceCk = cknullSpace(systemMatrix, matrixIndex, attNS, comlsqr);
-        if (myid == 0)
-        {
+        
+        nullSpaceCk=cknullSpace(systemMatrix,matrixIndex,attNS,comlsqr);
+        if(myid==0){
             printf("NullSpace check\n");
-            for (int j = 0; j < nEqExtConstr; j++)
-                printf("Eq. Constraint %d: Norm=%15.7f Min=%15.7f Max=%15.7f Avg=%15.7f Var=%15.7f\n", j, nullSpaceCk.vectNorm[j], nullSpaceCk.compMin[j], nullSpaceCk.compMax[j], nullSpaceCk.compAvg[j], nullSpaceCk.compVar[j]);
+            for(int j=0;j<nEqExtConstr;j++)
+                printf("Eq. Constraint %d: Norm=%15.7f Min=%15.7f Max=%15.7f Avg=%15.7f Var=%15.7f\n",j,nullSpaceCk.vectNorm[j],nullSpaceCk.compMin[j],nullSpaceCk.compMax[j],nullSpaceCk.compAvg[j],nullSpaceCk.compVar[j]);
         }
         seconds[5] = time(NULL);
         tot_sec[4] = seconds[5] - seconds[4];
-        if (myid == 0)
-            printf("Time to check nullspace: %ld\n", tot_sec[4]);
+        if(myid==0) printf("Time to check nullspace: %ld\n", tot_sec[4]);
         free(attNS);
     }
     ////////  WRITE BIN FILES and FileConstr_GsrSolProps.dat
     //////////
-    if (wrFilebin)
-    {
-        if (myid == 0)
-            printf("Writing bin files...\n");
-        writeBinFiles(systemMatrix, matrixIndex, instrCol, knownTerms, wrfileDir, wpath, comlsqr, debugMode);
+    if(wrFilebin){
+        if(myid==0) printf("Writing bin files...\n");
+        writeBinFiles(systemMatrix,matrixIndex,instrCol,knownTerms,wrfileDir,wpath,comlsqr,debugMode);
         MPI_Barrier(MPI_COMM_WORLD);
-        if (myid == 0)
-            printf(" finished.");
-
-        if (myid == 0)
-        {
-            FILE *fpFilePosConstr;
+        if(myid==0)	printf(" finished.");
+        
+        if(myid==0){
+            FILE* fpFilePosConstr;
             MPI_Status statusMpi;
             chdir(wpath);
             chdir(wrfileDir);
-            int fileNum = -1;
+            int fileNum=-1;
             int nFiles;
             nFiles = scandir(".", &namelistMI, selMI, alphasort);
-            if (debugMode)
-                for (ii = 0; ii < nFiles; ii++)
-                {
-                    printf("%s\n", namelistMI[ii]->d_name);
+            if(debugMode)
+                for(ii=0;ii<nFiles ;ii++){
+                    printf("%s\n",namelistMI[ii]->d_name);
                 }
-            if (nFiles <= 0)
+            if(nFiles <=0)
             {
-                printf("error on scandir n=%d\n", nFiles);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("error on scandir n=%d\n",nFiles);
+                MPI_Abort(MPI_COMM_WORLD,1);
             }
-
+            
             ////////////////// Writing FileConstr_GsrSolProps.dat
-            char fileConstr[512] = "";
+            char fileConstr[512]="";
             strcat(fileConstr, "FileConstr_");
             strcat(fileConstr, filenameSolProps);
-            fpFilePosConstr = fopen(fileConstr, "w");
-            for (int k = 0; k < counterConstr; k++)
-            {
-                fileNum = constraintFound[k][0];
-                fprintf(fpFilePosConstr, "%d %s %d\n", fileNum, namelistMI[fileNum]->d_name, constraintFound[k][1]);
-            }
-            if (debugMode)
-                for (int k = 0; k < counterConstr; k++)
-                {
-                    fileNum = constraintFound[k][0];
-                    printf("PE=%d %d %s %d\n", myid, fileNum, namelistMI[fileNum]->d_name, constraintFound[k][1]);
+            fpFilePosConstr=fopen(fileConstr,"w");
+            for(int k=0;k<counterConstr;k++){
+                fileNum=constraintFound[k][0];
+                fprintf(fpFilePosConstr,"%d %s %d\n", fileNum, namelistMI[fileNum]->d_name,constraintFound[k][1]);
+            }
+            if(debugMode)
+                for(int k=0;k<counterConstr;k++){
+                    fileNum=constraintFound[k][0];
+                    printf("PE=%d %d %s %d\n",myid, fileNum, namelistMI[fileNum]->d_name,constraintFound[k][1]);
                 }
-            for (int np = 1; np < nproc; np++)
-            {
-                MPI_Recv(&counterConstr, 1, MPI_INT, np, 0, MPI_COMM_WORLD, &statusMpi);
-                MPI_Recv(&constraintFound[0][0], counterConstr * 2, MPI_INT, np, 1, MPI_COMM_WORLD, &statusMpi);
-
-                for (int k = 0; k < counterConstr; k++)
-                {
-                    fileNum = constraintFound[k][0];
-                    fprintf(fpFilePosConstr, "%d %s %d\n", fileNum, namelistMI[fileNum]->d_name, constraintFound[k][1]);
+            for(int np=1;np<nproc;np++){
+                MPI_Recv(&counterConstr, 1, MPI_INT, np, 0, MPI_COMM_WORLD,&statusMpi);
+                MPI_Recv(&constraintFound[0][0], counterConstr*2, MPI_INT, np, 1, MPI_COMM_WORLD,&statusMpi);
+                
+                for(int k=0;k<counterConstr;k++){
+                    fileNum=constraintFound[k][0];
+                    fprintf(fpFilePosConstr,"%d %s %d\n", fileNum, namelistMI[fileNum]->d_name,constraintFound[k][1]);
                 }
-                if (debugMode)
-                    for (int k = 0; k < counterConstr; k++)
-                    {
-                        fileNum = constraintFound[k][0];
-                        printf("PE=%d %d %s %d\n", np, fileNum, namelistMI[fileNum]->d_name, constraintFound[k][1]);
+                if(debugMode)
+                    for(int k=0;k<counterConstr;k++){
+                        fileNum=constraintFound[k][0];
+                        printf("PE=%d %d %s %d\n",np, fileNum, namelistMI[fileNum]->d_name,constraintFound[k][1]);
                     }
             }
             fclose(fpFilePosConstr);
-        }
-        else
-        {
+        } else {
             MPI_Send(&counterConstr, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
-            MPI_Send(&constraintFound[0][0], counterConstr * 2, MPI_INT, 0, 1, MPI_COMM_WORLD);
+            MPI_Send(&constraintFound[0][0], counterConstr*2, MPI_INT, 0, 1, MPI_COMM_WORLD);
         }
     }
-
-    VrIdAstroPDimMax = comlsqr.VrIdAstroPDimMax;
-    VrIdAstroPDim = comlsqr.VrIdAstroPDim;
-    VroffsetAttParam = VrIdAstroPDimMax * nAstroPSolved;
-    comlsqr.VroffsetAttParam = VroffsetAttParam;
-
-    nunkSplit = VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam + nGlobalParam;
-    comlsqr.nunkSplit = nunkSplit;
-    nElements = nunkSplit;
-    preCondVect = (double *)calloc(nElements, sizeof(double));
+    
+    VrIdAstroPDimMax=comlsqr.VrIdAstroPDimMax;
+    VrIdAstroPDim=comlsqr.VrIdAstroPDim;
+    VroffsetAttParam = VrIdAstroPDimMax*nAstroPSolved;
+    comlsqr.VroffsetAttParam=VroffsetAttParam;
+    
+    nunkSplit =   VrIdAstroPDimMax*nAstroPSolved + nAttParam + nInstrParam + nGlobalParam;
+    comlsqr.nunkSplit=nunkSplit;
+    nElements = nunkSplit ;
+    preCondVect = (double *) calloc(nElements,sizeof(double));
     if (!preCondVect)
-        exit(err_malloc("preCondVect", myid));
-    totmem += nElements * sizeof(double);
-
+        exit(err_malloc("preCondVect",myid));
+    totmem += nElements*sizeof(double);
+    
     nElements = nunkSplit; //  the arrays v, w, x, and se require the same amount of memory (nunk * sizeof(double))
-    vVect = (double *)calloc(nElements, sizeof(double));
+    vVect = (double *) calloc(nElements, sizeof(double));
     if (!vVect)
-        exit(err_malloc("vVect", myid));
-    totmem += nElements * sizeof(double);
-
-    wVect = (double *)calloc(nElements, sizeof(double));
+        exit(err_malloc("vVect",myid));
+    totmem += nElements* sizeof(double);
+    
+    wVect = (double *) calloc(nElements, sizeof(double));
     if (!wVect)
-        exit(err_malloc("wVect", myid));
-    totmem += nElements * sizeof(double);
-
-    xSolution = (double *)calloc(nElements, sizeof(double));
+        exit(err_malloc("wVect",myid));
+    totmem += nElements* sizeof(double);
+    
+    xSolution = (double *) calloc(nElements, sizeof(double));
     if (!xSolution)
-        exit(err_malloc("xSolution", myid));
-    totmem += nElements * sizeof(double);
-
-    standardError = (double *)calloc(nElements, sizeof(double));
+        exit(err_malloc("xSolution",myid));
+    totmem += nElements* sizeof(double);
+    
+    standardError = (double *) calloc(nElements, sizeof(double));
     if (!standardError)
-        exit(err_malloc("standardError", myid));
-    totmem += nElements * sizeof(double);
-
-    totmem += nElements * sizeof(double); //dcopy+vAuxVect locally allocated on lsqr.c
-
-    totmem = totmem / (1024 * 1024); // mem in MB
-
+        exit(err_malloc("standardError",myid));
+    totmem += nElements* sizeof(double);
+    
+    totmem += nElements* sizeof(double);  //dcopy+vAuxVect locally allocated on lsqr.c
+    
+    totmem=totmem/(1024*1024);  // mem in MB
+    
     // Compute and write the total memory allocated
-    if (myid == 0)
+    if(myid==0)
     {
         printf("LOCAL %ld MB of memory allocated on each task.\n", totmem);
-        printf("TOTAL MB memory allocated= %ld\n", nproc * totmem);
+        printf("TOTAL MB memory allocated= %ld\n", nproc*totmem );
     }
-
+    
+    
     ///////////////////////////////
-
+    
+    
+    
+    
     MPI_Barrier(MPI_COMM_WORLD);
     // Compute the preconditioning vector for the system columns
-
-    long int aIndex = 0;
+    
+    
+    long int aIndex=0;
     long instrLongIndex[6];
-    long iIelem = 0;
-
-    for (ii = 0; ii < mapNoss[myid] * multMI; ii = ii + multMI)
+    long iIelem=0;
+    
+    
+    
+    for (ii = 0; ii < mapNoss[myid]*multMI; ii=ii+multMI)
     {
-        long int numOfStarPos = 0;
-        if (nAstroPSolved > 0)
-            numOfStarPos = matrixIndex[ii] / nAstroPSolved; // number of star associated to matrixIndex[ii]
-        long int numOfAttPos = matrixIndex[ii + (multMI - 1)];
-        long int VrIdAstroPValue = -1; //
-
-        VrIdAstroPValue = numOfStarPos - comlsqr.mapStar[myid][0];
-        if (VrIdAstroPValue == -1)
+        long int numOfStarPos=0;
+        if(nAstroPSolved>0) numOfStarPos=matrixIndex[ii]/nAstroPSolved; // number of star associated to matrixIndex[ii]
+        long int numOfAttPos=matrixIndex[ii+(multMI-1)];
+        long int VrIdAstroPValue=-1; //
+        
+        VrIdAstroPValue=numOfStarPos-comlsqr.mapStar[myid][0];
+        if(VrIdAstroPValue==-1)
         {
-            printf("PE=%d ERROR. Can't find gsrId for precondvect.\n", myid);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("PE=%d ERROR. Can't find gsrId for precondvect.\n",myid);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        for (int ns = 0; ns < nAstroPSolved; ns++)
+        for(int ns=0;ns<nAstroPSolved;ns++)
         {
-            ncolumn = VrIdAstroPValue * nAstroPSolved + ns;
+            ncolumn=VrIdAstroPValue*nAstroPSolved+ns;
             ////
             // ncolumn = numOfStarPos+ns; // cancellato
-            if (ncolumn >= nunkSplit || ncolumn < 0)
-            {
-                printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n", myid, ncolumn, ii,
+            if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n",myid, ncolumn, ii,
                        matrixIndex[ii]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-            if (preCondVect[ncolumn] == 0.0)
+            if(preCondVect[ncolumn]==0.0)
                 printf("Astrometric: preCondVect[%ld]=0.0\n", ncolumn);
             aIndex++;
         }
         //
-        for (int naxis = 0; naxis < nAttAxes; naxis++)
-            for (int ns = 0; ns < nAttParAxis; ns++)
+        for(int naxis=0;naxis<nAttAxes;naxis++)
+            for(int ns=0;ns<nAttParAxis;ns++)
             {
-                ncolumn = numOfAttPos + (VroffsetAttParam - offsetAttParam) + ns + naxis * nDegFreedomAtt;
-                if (ncolumn >= nunkSplit || ncolumn < 0)
-                {
-                    printf("ERROR. PE=%d numOfAttPos=%ld nStar*nAstroPSolved=%ld ncolumn=%ld ns=%d naxis=%d matrixIndex[ii+%d]=%ld\n", myid, numOfAttPos, nStar * nAstroPSolved, ncolumn, ns, naxis, multMI - 1, matrixIndex[ii + (multMI - 1)]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                ncolumn = numOfAttPos+(VroffsetAttParam-offsetAttParam)+ns+naxis*nDegFreedomAtt;
+                if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                    printf("ERROR. PE=%d numOfAttPos=%ld nStar*nAstroPSolved=%ld ncolumn=%ld ns=%d naxis=%d matrixIndex[ii+%d]=%ld\n",myid,numOfAttPos,nStar*nAstroPSolved,ncolumn, ns, naxis,multMI-1,matrixIndex[ii+(multMI-1)]);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
                 preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-                if (preCondVect[ncolumn] == 0.0)
-                    printf("Attitude: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n", myid, ncolumn, aIndex, systemMatrix[aIndex]); //   if aggiunto
+                if(preCondVect[ncolumn]==0.0)
+                    printf("Attitude: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n",myid, ncolumn,aIndex,systemMatrix[aIndex]); //   if aggiunto
                 aIndex++;
             }
         ///// End of Attitude preCondVect
-
-        if (nInstrPSolved > 0)
+        
+        
+        if(nInstrPSolved>0)
         {
-            for (int ns = 0; ns < nInstrPSolved; ns++)
+            for(int ns=0;ns<nInstrPSolved;ns++)
             {
-                ncolumn = offsetInstrParam + (VroffsetAttParam - offsetAttParam) + instrCol[(ii / multMI) * nInstrPSolved + ns];
-                if (ncolumn >= nunkSplit || ncolumn < 0)
+                ncolumn = offsetInstrParam+(VroffsetAttParam-offsetAttParam)+instrCol[(ii/multMI)*nInstrPSolved+ns];
+                if (ncolumn >= nunkSplit || ncolumn < 0 )
                 {
-                    printf("ERROR. PE=%d ii=%ld ", myid, ii);
-                    for (int ke = 0; ke < nInstrPSolved; ke++)
-                        printf("instrCol[%d]=%d ", ii / multMI + ke, instrCol[ii / multMI + ke]);
+                    printf("ERROR. PE=%d ii=%ld ",myid, ii);
+                    for(int ke=0;ke<nInstrPSolved;ke++)
+                        printf("instrCol[%d]=%d ",ii/multMI+ke, instrCol[ii/multMI+ke]);
                     printf("ncolumn=%ld   ns=%d\n", ncolumn, ns);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
-                //                if(ncolumn==55718+8000){
-                //                    printf("OSS BEFORE aindex=%ld SM[aindex]=%f preCondVect[%ld]=%f\n",aIndex,systemMatrix[aIndex],ncolumn,preCondVect[ncolumn]);
-                //                }
+//                if(ncolumn==55718+8000){
+//                    printf("OSS BEFORE aindex=%ld SM[aindex]=%f preCondVect[%ld]=%f\n",aIndex,systemMatrix[aIndex],ncolumn,preCondVect[ncolumn]);
+//                }
                 preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-                //                if(ncolumn==55718+8000){
-                //                    printf("OSS AFTER aindex=%ld SM[aindex]=%f preCondVect[%ld]=%f\n",aIndex,systemMatrix[aIndex],ncolumn,preCondVect[ncolumn]);
-                //                }
-                if (preCondVect[ncolumn] == 0.0)
-                    printf("Instrument: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n", myid, ncolumn, aIndex, systemMatrix[aIndex]); //   if aggiunto
+//                if(ncolumn==55718+8000){
+//                    printf("OSS AFTER aindex=%ld SM[aindex]=%f preCondVect[%ld]=%f\n",aIndex,systemMatrix[aIndex],ncolumn,preCondVect[ncolumn]);
+//                }
+                if(preCondVect[ncolumn]==0.0)
+                    printf("Instrument: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n",myid, ncolumn,aIndex,systemMatrix[aIndex]);//   if aggiunto
                 aIndex++;
             }
         }
         ////// End of Instruments preCondVect
-        for (int ns = 0; ns < nGlobP; ns++)
+        for(int ns=0;ns<nGlobP;ns++)
         {
-            ncolumn = offsetGlobParam + (VroffsetAttParam - offsetAttParam) + ns;
-            if (ncolumn >= nunkSplit || ncolumn < 0)
-            {
-                printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii+2]=%ld\n", myid, ncolumn, ii,
+            ncolumn = offsetGlobParam+(VroffsetAttParam-offsetAttParam)+ns;
+            if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii+2]=%ld\n",myid, ncolumn, ii,
                        matrixIndex[ii]);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-            if (preCondVect[ncolumn] == 0)
+            if(preCondVect[ncolumn]==0)
                 printf("Global: preCondVect[%ld]=0.0\n", ncolumn); //   if aggiunto
             aIndex++;
         }
     }
-
+    
     /////  precondvect for extConstr
-    if (extConstraint)
-    {
-        if (aIndex != mapNcoeff[myid])
-        {
-            printf("PE=%d. Error on aIndex=%ld  different of mapNcoeff[%d]=%ld\n", myid, aIndex, myid, mapNcoeff[myid]);
+    if(extConstraint){
+        if(aIndex!=mapNcoeff[myid]){
+            printf("PE=%d. Error on aIndex=%ld  different of mapNcoeff[%d]=%ld\n",myid,aIndex,myid,mapNcoeff[myid]);
             MPI_Abort(MPI_COMM_WORLD, 1);
             exit(EXIT_FAILURE);
         }
-        for (int i = 0; i < nEqExtConstr; i++)
-        {
-            long int numOfStarPos = 0;
-            if (nAstroPSolved > 0)
-                numOfStarPos = firstStarConstr; // number of star associated to matrixIndex[ii]
-            long int numOfAttPos = startingAttColExtConstr;
-            long int VrIdAstroPValue = -1; //
-
-            VrIdAstroPValue = numOfStarPos - comlsqr.mapStar[myid][0];
-            if (VrIdAstroPValue == -1)
+        for(int i=0;i<nEqExtConstr;i++){
+            long int numOfStarPos=0;
+            if(nAstroPSolved>0) numOfStarPos=firstStarConstr; // number of star associated to matrixIndex[ii]
+            long int numOfAttPos=startingAttColExtConstr;
+            long int VrIdAstroPValue=-1; //
+            
+            VrIdAstroPValue=numOfStarPos-comlsqr.mapStar[myid][0];
+            if(VrIdAstroPValue==-1)
             {
-                printf("PE=%d ERROR. Can't find gsrId for precondvect.\n", myid);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d ERROR. Can't find gsrId for precondvect.\n",myid);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            for (int ns = 0; ns < nAstroPSolved * numOfExtStar; ns++)
+            for(int ns=0;ns<nAstroPSolved*numOfExtStar;ns++)
             {
-                ncolumn = ns;
+                ncolumn=ns;
                 ////
                 // ncolumn = numOfStarPos+ns; // cancellato
-                if (ncolumn >= nunkSplit || ncolumn < 0)
-                {
-                    printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n", myid, ncolumn, ii,
+                if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                    printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n",myid, ncolumn, ii,
                            matrixIndex[ii]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
                 preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-                if (preCondVect[ncolumn] == 0.0)
+                if(preCondVect[ncolumn]==0.0)
                     printf("Astrometric: preCondVect[%ld]=0.0\n", ncolumn);
                 aIndex++;
             }
             //
-            for (int naxis = 0; naxis < nAttAxes; naxis++)
-            {
-                for (int j = 0; j < numOfExtAttCol; j++)
-                {
-                    ncolumn = VrIdAstroPDimMax * nAstroPSolved + startingAttColExtConstr + j + naxis * nDegFreedomAtt;
-                    if (ncolumn >= nunkSplit || ncolumn < 0)
-                    {
-                        printf("ERROR. PE=%d  ncolumn=%ld  naxis=%d j=%d\n", myid, ncolumn, naxis, j);
-                        MPI_Abort(MPI_COMM_WORLD, 1);
+            for(int naxis=0;naxis<nAttAxes;naxis++){
+                for(int j=0;j<numOfExtAttCol;j++){
+                    ncolumn = VrIdAstroPDimMax*nAstroPSolved+startingAttColExtConstr+j+naxis*nDegFreedomAtt;
+                    if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                        printf("ERROR. PE=%d  ncolumn=%ld  naxis=%d j=%d\n",myid,ncolumn, naxis,j);
+                        MPI_Abort(MPI_COMM_WORLD,1);
                         exit(EXIT_FAILURE);
                     }
-                    preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-                    //                    printf("%d %d %d %d\n",ncolumn, aIndex,j,naxis);
-                    if (preCondVect[ncolumn] == 0.0)
-                        printf("Attitude: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n", myid, ncolumn, aIndex, systemMatrix[aIndex]); //   if aggiunto
-                    aIndex++;
+                preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
+//                    printf("%d %d %d %d\n",ncolumn, aIndex,j,naxis);
+                if(preCondVect[ncolumn]==0.0)
+                    printf("Attitude: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n",myid, ncolumn,aIndex,systemMatrix[aIndex]); //   if aggiunto
+                aIndex++;
                 }
             }
         }
     }
     ///// end precondvect for extConstr
     /////  precondvect for barConstr
-    if (barConstraint)
-    {
-        for (int i = 0; i < nEqBarConstr; i++)
-        {
-            long int numOfStarPos = 0;
-            if (nAstroPSolved > 0)
-                numOfStarPos = firstStarConstr; // number of star associated to matrixIndex[ii]
-            long int VrIdAstroPValue = -1;      //
-
-            VrIdAstroPValue = numOfStarPos - comlsqr.mapStar[myid][0];
-            if (VrIdAstroPValue == -1)
+    if(barConstraint){
+        for(int i=0;i<nEqBarConstr;i++){
+            long int numOfStarPos=0;
+            if(nAstroPSolved>0) numOfStarPos=firstStarConstr; // number of star associated to matrixIndex[ii]
+            long int VrIdAstroPValue=-1; //
+            
+            VrIdAstroPValue=numOfStarPos-comlsqr.mapStar[myid][0];
+            if(VrIdAstroPValue==-1)
             {
-                printf("PE=%d ERROR. Can't find gsrId for precondvect.\n", myid);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("PE=%d ERROR. Can't find gsrId for precondvect.\n",myid);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            for (int ns = 0; ns < nAstroPSolved * numOfBarStar; ns++)
+            for(int ns=0;ns<nAstroPSolved*numOfBarStar;ns++)
             {
-                ncolumn = ns;
+                ncolumn=ns;
                 ////
                 // ncolumn = numOfStarPos+ns; // cancellato
-                if (ncolumn >= nunkSplit || ncolumn < 0)
-                {
-                    printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n", myid, ncolumn, ii,
+                if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                    printf("ERROR. PE=%d ncolumn=%ld ii=%ld matrixIndex[ii]=%ld\n",myid, ncolumn, ii,
                            matrixIndex[ii]);
-                    MPI_Abort(MPI_COMM_WORLD, 1);
+                    MPI_Abort(MPI_COMM_WORLD,1);
                     exit(EXIT_FAILURE);
                 }
                 preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-                if (preCondVect[ncolumn] == 0.0)
-                    printf("Astrometric: preCondVect[%ld]=0.0\n", ncolumn);
+                if(preCondVect[ncolumn]==0.0)
+                printf("Astrometric: preCondVect[%ld]=0.0\n", ncolumn);
                 aIndex++;
             }
             //
@@ -2877,328 +2558,291 @@ int main(int argc, char **argv)
     ///// end precondvect for barConstr
 
     /////  precondvect for instrConstr
-    if (nElemIC > 0)
-    {
-        for (int i = 0; i < nElemIC; i++)
-        {
-            ncolumn = offsetInstrParam + (VroffsetAttParam - offsetAttParam) + instrCol[mapNoss[myid] * nInstrPSolved + i];
-            if (ncolumn >= nunkSplit || ncolumn < 0)
-            {
-                printf("ERROR on instrConstr. PE=%d  ncolumn=%ld   i=%d\n", myid, ncolumn, i);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+    if(nElemIC>0){
+        for(int i=0;i<nElemIC;i++){
+            ncolumn=offsetInstrParam+(VroffsetAttParam-offsetAttParam)+instrCol[mapNoss[myid]*nInstrPSolved+i];
+            if (ncolumn >= nunkSplit || ncolumn < 0 ) {
+                printf("ERROR on instrConstr. PE=%d  ncolumn=%ld   i=%d\n",myid,ncolumn, i);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ncolumn] += systemMatrix[aIndex] * systemMatrix[aIndex];
-            if (preCondVect[ncolumn] == 0.0 && debugMode)
-                printf("Instrument: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n", myid, ncolumn, aIndex, systemMatrix[aIndex]);
+            if(preCondVect[ncolumn]==0.0 && debugMode)
+                printf("Instrument: PE=%d preCondVect[%ld]=0.0 aIndex=%ld systemMatrix[aIndex]=%12.9lf\n",myid, ncolumn,aIndex,systemMatrix[aIndex]);
             aIndex++;
+            
         }
     }
     ////////////////
-
+    
+    
     MPI_Barrier(MPI_COMM_WORLD);
-
+    
     // ACCUMULATE d
     //
     double *dcopy;
-    dcopy = (double *)calloc(nAttParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-    mpi_allreduce(&preCondVect[VrIdAstroPDimMax * nAstroPSolved], dcopy, (long int)nAttParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    for (i = 0; i < nAttParam; i++)
+    dcopy=(double *)calloc(nAttParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    mpi_allreduce(&preCondVect[ VrIdAstroPDimMax*nAstroPSolved],dcopy,(long int) nAttParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+    for(i=0;i<nAttParam;i++)
     {
-        preCondVect[VrIdAstroPDimMax * nAstroPSolved + i] = dcopy[i];
-        if (preCondVect[VrIdAstroPDimMax * nAstroPSolved + i] == 0.0)
-        {
-            printf("PE=%d preCondVect[%ld]=0!!\n", myid, VrIdAstroPDimMax * nAstroPSolved + i);
+        preCondVect[VrIdAstroPDimMax*nAstroPSolved+i]=dcopy[i];
+        if(preCondVect[VrIdAstroPDimMax*nAstroPSolved+i]==0.0){
+            printf("PE=%d preCondVect[%ld]=0!!\n", myid, VrIdAstroPDimMax*nAstroPSolved+i);
         }
     }
     free(dcopy);
-    dcopy = (double *)calloc(nInstrParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-    mpi_allreduce(&preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam], dcopy, (long int)nInstrParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    for (i = 0; i < nInstrParam; i++)
+    dcopy=(double *)calloc(nInstrParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    mpi_allreduce(&preCondVect[ VrIdAstroPDimMax*nAstroPSolved+nAttParam],dcopy,(long int) nInstrParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+    for(i=0;i<nInstrParam;i++)
     {
-        preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam + i] = dcopy[i];
-        if (preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam + i] == 0.0)
-            printf("PE=%d preCondVect[%d]=0!!\n", myid, i);
+        preCondVect[VrIdAstroPDimMax*nAstroPSolved+nAttParam+i]=dcopy[i];
+        if(preCondVect[ VrIdAstroPDimMax*nAstroPSolved+nAttParam+i]==0.0) printf("PE=%d preCondVect[%d]=0!!\n", myid, i);
     }
     free(dcopy);
-    dcopy = (double *)calloc(nGlobalParam, sizeof(double));
-    if (!dcopy)
-        exit(err_malloc("dcopy", myid));
-    MPI_Allreduce(&preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam], dcopy, (int)nGlobalParam, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
-    for (i = 0; i < nGlobalParam; i++)
+    dcopy=(double *)calloc(nGlobalParam,sizeof(double));
+    if(!dcopy) exit(err_malloc("dcopy",myid));
+    MPI_Allreduce(&preCondVect[VrIdAstroPDimMax*nAstroPSolved+nAttParam+nInstrParam],dcopy,(int) nGlobalParam,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
+    for(i=0;i<nGlobalParam;i++)
     {
-        preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam + i] = dcopy[i];
-        if (preCondVect[VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam + i] == 0.0)
-            printf("PE=%d preCondVect[%d]=0!!\n", myid, i);
+        preCondVect[VrIdAstroPDimMax*nAstroPSolved+nAttParam+nInstrParam+i]=dcopy[i];
+        if(preCondVect[VrIdAstroPDimMax*nAstroPSolved+nAttParam+nInstrParam+i]==0.0) printf("PE=%d preCondVect[%d]=0!!\n", myid, i);
     }
     free(dcopy);
-    if (nAstroPSolved)
-        SumCirc(preCondVect, comlsqr);
-
+    if(nAstroPSolved) SumCirc(preCondVect,comlsqr);
+    
+    
     ////////// TEST for NO ZERO Column on A matrix
-
-    if (precond)
-    {
-
-        if (myid == 0)
-            printf("Inverting preCondVect\n");
-        for (ii = 0; ii < VrIdAstroPDim * nAstroPSolved; ii++)
-        {
-            if (preCondVect[ii] == 0.0)
+    
+    
+    if(precond){
+        
+        if(myid==0) printf("Inverting preCondVect\n");
+        for (ii = 0; ii < VrIdAstroPDim*nAstroPSolved; ii++) {
+            if(preCondVect[ii]==0.0)
             {
-                if (ii - VrIdAstroPDimMax * nAstroPSolved < nAttParam)
-                    printf("ERROR Att ZERO column: PE=%d preCondVect[%ld]=0.0 AttParam=%ld \n", myid, ii, ii - VrIdAstroPDimMax * nAstroPSolved);
-                if (ii - VrIdAstroPDimMax * nAstroPSolved > nAttParam && ii - VrIdAstroPDimMax * nAstroPSolved < nAttParam + nInstrParam)
-                    printf("ERROR Instr ZERO column: PE=%d preCondVect[%ld]=0.0 InstrParam=%ld \n", myid, ii, ii - (VrIdAstroPDimMax * nAstroPSolved + nAttParam));
-                if (ii - VrIdAstroPDimMax * nAstroPSolved > nAttParam + nInstrParam)
-                    printf("ERROR Global ZERO column: PE=%d preCondVect[%ld]=0.0 GlobalParam=%ld \n", myid, ii, ii - (VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam));
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                if(ii-VrIdAstroPDimMax*nAstroPSolved<nAttParam)
+                    printf("ERROR Att ZERO column: PE=%d preCondVect[%ld]=0.0 AttParam=%ld \n",myid,ii, ii-VrIdAstroPDimMax*nAstroPSolved);
+                if(ii-VrIdAstroPDimMax*nAstroPSolved>nAttParam && ii-VrIdAstroPDimMax*nAstroPSolved<nAttParam+nInstrParam)
+                    printf("ERROR Instr ZERO column: PE=%d preCondVect[%ld]=0.0 InstrParam=%ld \n",myid,ii, ii-(VrIdAstroPDimMax*nAstroPSolved+nAttParam));
+                if(ii-VrIdAstroPDimMax*nAstroPSolved>nAttParam+nInstrParam)
+                    printf("ERROR Global ZERO column: PE=%d preCondVect[%ld]=0.0 GlobalParam=%ld \n",myid,ii, ii-(VrIdAstroPDimMax*nAstroPSolved+nAttParam+nInstrParam));
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ii] = 1.0 / sqrt(preCondVect[ii]);
         }
-        for (ii = VrIdAstroPDimMax * nAstroPSolved; ii < VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam + nGlobalParam; ii++)
-        {
-            if (preCondVect[ii] == 0.0)
+        for (ii = VrIdAstroPDimMax*nAstroPSolved; ii < VrIdAstroPDimMax*nAstroPSolved + nAttParam + nInstrParam + nGlobalParam; ii++) {
+            if(preCondVect[ii]==0.0)
             {
-                printf("ERROR non-Astrometric ZERO column: PE=%d preCondVect[%ld]=0.0\n", myid, ii);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("ERROR non-Astrometric ZERO column: PE=%d preCondVect[%ld]=0.0\n",myid,ii);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ii] = 1.0 / sqrt(preCondVect[ii]);
         }
-    }
-    else
-    {
-        if (myid == 0)
-            printf("Setting preCondVect to 1.0\n");
-        for (ii = 0; ii < VrIdAstroPDim * nAstroPSolved; ii++)
-        {
-            if (preCondVect[ii] == 0.0)
+    } else{
+        if(myid==0) printf("Setting preCondVect to 1.0\n");
+        for (ii = 0; ii < VrIdAstroPDim*nAstroPSolved; ii++) {
+            if(preCondVect[ii]==0.0)
             {
-                printf("ERROR Astrometric ZERO column: PE=%d preCondVect[%ld]=0.0 Star=%ld\n", myid, ii, ii / nAstroPSolved);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("ERROR Astrometric ZERO column: PE=%d preCondVect[%ld]=0.0 Star=%ld\n",myid,ii,ii/nAstroPSolved);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ii] = 1.0;
         }
-        for (ii = VrIdAstroPDimMax * nAstroPSolved; ii < VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam + nGlobalParam; ii++)
-        {
-            if (preCondVect[ii] == 0.0)
+        for (ii = VrIdAstroPDimMax*nAstroPSolved; ii < VrIdAstroPDimMax*nAstroPSolved + nAttParam + nInstrParam + nGlobalParam; ii++) {
+            if(preCondVect[ii]==0.0)
             {
-                if (ii - VrIdAstroPDimMax * nAstroPSolved < nAttParam)
-                    printf("ERROR Att ZERO column: PE=%d preCondVect[%ld]=0.0 AttParam=%ld \n", myid, ii, ii - VrIdAstroPDimMax * nAstroPSolved);
-                if (ii - VrIdAstroPDimMax * nAstroPSolved > nAttParam && ii - VrIdAstroPDimMax * nAstroPSolved < nAttParam + nInstrParam)
-                    printf("ERROR Instr ZERO column: PE=%d preCondVect[%ld]=0.0 InstrParam=%ld \n", myid, ii, ii - (VrIdAstroPDimMax * nAstroPSolved + nAttParam));
-                if (ii - VrIdAstroPDimMax * nAstroPSolved > nAttParam + nInstrParam)
-                    printf("ERROR Global ZERO column: PE=%d preCondVect[%ld]=0.0 GlobalParam=%ld \n", myid, ii, ii - (VrIdAstroPDimMax * nAstroPSolved + nAttParam + nInstrParam));
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                if(ii-VrIdAstroPDimMax*nAstroPSolved<nAttParam)
+                    printf("ERROR Att ZERO column: PE=%d preCondVect[%ld]=0.0 AttParam=%ld \n",myid,ii, ii-VrIdAstroPDimMax*nAstroPSolved);
+                if(ii-VrIdAstroPDimMax*nAstroPSolved>nAttParam && ii-VrIdAstroPDimMax*nAstroPSolved<nAttParam+nInstrParam)
+                    printf("ERROR Instr ZERO column: PE=%d preCondVect[%ld]=0.0 InstrParam=%ld \n",myid,ii, ii-(VrIdAstroPDimMax*nAstroPSolved+nAttParam));
+                if(ii-VrIdAstroPDimMax*nAstroPSolved>nAttParam+nInstrParam)
+                    printf("ERROR Global ZERO column: PE=%d preCondVect[%ld]=0.0 GlobalParam=%ld \n",myid,ii, ii-(VrIdAstroPDimMax*nAstroPSolved+nAttParam+nInstrParam));
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             preCondVect[ii] = 1.0;
         }
+        
     }
-
-    if (myid == 0)
+    
+    if(myid==0)
     {
         printf("Computation of the preconditioning vector finished.\n");
     }
-    comlsqr.nvinc = 0;
-    comlsqr.parOss = (long)nparam;
-    comlsqr.nunk = nunk;
-    comlsqr.offsetAttParam = offsetAttParam;
-    comlsqr.offsetInstrParam = offsetInstrParam;
-    comlsqr.offsetGlobParam = offsetGlobParam;
-    comlsqr.nAttParam = nAttParam;
-    comlsqr.instrConst[0] = instrConst[0];
-    comlsqr.instrConst[1] = instrConst[1];
-    comlsqr.instrConst[2] = instrConst[2];
-    comlsqr.instrConst[3] = instrConst[3];
-    comlsqr.timeCPR = timeCPR;
-    comlsqr.timeLimit = timeLimit;
-    comlsqr.itnCPR = itnCPR;
-    comlsqr.itnCPRstop = itnCPRstop;
-    comlsqr.itnLimit = itnlim;
-    comlsqr.Test = 0; //it is not a running test but a production run
-
-    initThread(matrixIndex, &comlsqr);
-
-    endTime = MPI_Wtime() - endTime;
+    comlsqr.nvinc=0;
+    comlsqr.parOss=(long) nparam;
+    comlsqr.nunk=nunk;
+    comlsqr.offsetAttParam=offsetAttParam;
+    comlsqr.offsetInstrParam=offsetInstrParam;
+    comlsqr.offsetGlobParam=offsetGlobParam;
+    comlsqr.nAttParam=nAttParam;
+    comlsqr.instrConst[0]=instrConst[0];
+    comlsqr.instrConst[1]=instrConst[1];
+    comlsqr.instrConst[2]=instrConst[2];
+    comlsqr.instrConst[3]=instrConst[3];
+    comlsqr.timeCPR=timeCPR;
+    comlsqr.timeLimit=timeLimit;
+    comlsqr.itnCPR=itnCPR;
+    comlsqr.itnCPRstop=itnCPRstop;
+    comlsqr.itnLimit=itnlim;
+    comlsqr.Test=0; //it is not a running test but a production run
+    
+    initThread(matrixIndex,&comlsqr);
+    
+    
+    endTime=MPI_Wtime()-endTime;
     MPI_Barrier(MPI_COMM_WORLD);
-
+    
     ////////  WRITE BIN FILES and FileConstr_GsrSolProps.dat
-
+    
     //////////////////////////// noiter
-    if (noIter)
-    {
-        if (myid == 0)
-            printf("\nEnd run: -noiter option givens.\n");
-
+    if(noIter){
+        if(myid==0) printf("\nEnd run: -noiter option givens.\n");
+        
         MPI_Finalize();
         exit(EXIT_SUCCESS);
-      
+        
     }
 
     /////////////// MAIN CALL
-
+    
     /////////////
     // This function computes the product of system matrix by precondVect. This avoids to compute the produsct in aprod for each iteration.
-    if (myid == 0 && debugMode)
+    if(myid==0 && debugMode)
     {
-        printf("TEST LSQR START nobs=%ld, nunk=%ld, damp=%f, knownTerms[0]=%f, knownTerms[%ld]=%f, atol=%f btol=%f conlim=%f itnlim=%ld systemMatrix[0]=%f, systemMatrix[%ld]=%f   matrixIndex[0]=%ld matrixIndex[%ld]=%ld  instrCol[0]=%d instrCol[%ld]=%d preCondVect[0]=%f preCondVect[%ld]=%f preCondVect[%ld]=%f  nunkSplit=%ld\n", nobs, nunk, damp, knownTerms[0], mapNoss[myid] - 1, knownTerms[mapNoss[myid] - 1], atol, btol, conlim, itnlim, systemMatrix[0], mapNcoeff[myid] - 1, systemMatrix[mapNcoeff[myid] - 1], matrixIndex[0], mapNoss[myid] * 2 - 1, matrixIndex[mapNoss[myid] * 2 - 1], instrCol[0], mapNoss[myid] * nInstrPSolved - 1, instrCol[mapNoss[myid] * nInstrPSolved - 1], preCondVect[0], VrIdAstroPDim * nAstroPSolved - 1, preCondVect[VrIdAstroPDim * nAstroPSolved - 1], VrIdAstroPDim * nAstroPSolved, preCondVect[VrIdAstroPDim * nAstroPSolved], nunkSplit);
+        printf("TEST LSQR START nobs=%ld, nunk=%ld, damp=%f, knownTerms[0]=%f, knownTerms[%ld]=%f, atol=%f btol=%f conlim=%f itnlim=%ld systemMatrix[0]=%f, systemMatrix[%ld]=%f   matrixIndex[0]=%ld matrixIndex[%ld]=%ld  instrCol[0]=%d instrCol[%ld]=%d preCondVect[0]=%f preCondVect[%ld]=%f preCondVect[%ld]=%f  nunkSplit=%ld\n",nobs,  nunk, damp, knownTerms[0], mapNoss[myid]-1,knownTerms[mapNoss[myid]-1], atol, btol,conlim,itnlim, systemMatrix[0],mapNcoeff[myid]-1,systemMatrix[mapNcoeff[myid]-1],  matrixIndex[0],mapNoss[myid]*2-1, matrixIndex[mapNoss[myid]*2-1], instrCol[0], mapNoss[myid]*nInstrPSolved -1,instrCol[mapNoss[myid]*nInstrPSolved -1], preCondVect[0],VrIdAstroPDim*nAstroPSolved-1, preCondVect[VrIdAstroPDim*nAstroPSolved-1], VrIdAstroPDim*nAstroPSolved, preCondVect[VrIdAstroPDim*nAstroPSolved], nunkSplit);
     }
 
-    precondSystemMatrix(systemMatrix, preCondVect, matrixIndex, instrCol, comlsqr);
+    precondSystemMatrix(systemMatrix, preCondVect, matrixIndex,instrCol,comlsqr);
 
     //systemMatrix is passed to lsqr already conditioned.
-    if (myid == 0)
-    {
+    if(myid==0) {
         printf("System built, ready to call LSQR.\nPlease wait. System solution is underway...");
     }
     ////////////////////
-    startTime = MPI_Wtime();
+    startTime=MPI_Wtime();
     seconds[1] = time(NULL);
     tot_sec[0] = seconds[1] - seconds[0];
-    comlsqr.totSec = tot_sec[0];
-    if (myid == 0)
-        printf("Starting lsqr after sec: %ld\n", tot_sec[0]);
+    comlsqr.totSec=tot_sec[0];
+    if(myid==0) printf("Starting lsqr after sec: %ld\n", tot_sec[0]);
     chdir(wpath);
-    if (outputDirOpt)
-        chdir(outputDir); // go to output dir
+    if(outputDirOpt) chdir(outputDir); // go to output dir
     lsqr(nobs, nunk, damp, knownTerms, vVect, wVect, xSolution, standardError, atol, btol, conlim,
-         (int)itnlim, &istop, &itn, &anorm, &acond, &rnorm, &arnorm,
-         &xnorm, systemMatrix, matrixIndex, instrCol, instrConstrIlung, preCondVect, comlsqr);
-
+         (int) itnlim, &istop, &itn, &anorm, &acond, &rnorm, &arnorm,
+         &xnorm, systemMatrix, matrixIndex, instrCol, instrConstrIlung,preCondVect,comlsqr);
+    
     ///////////////////////////
     MPI_Barrier(MPI_COMM_WORLD);
-    endTime = MPI_Wtime();
-    double clockTime = MPI_Wtime();
-    if (myid == 0)
-        printf("Global Time for lsqr =%f sec \n", endTime - startTime);
+    endTime=MPI_Wtime();
+    double clockTime=MPI_Wtime();
+    if(myid==0) printf("Global Time for lsqr =%f sec \n",endTime-startTime);
     seconds[2] = time(NULL);
     tot_sec[1] = seconds[2] - seconds[1];
-
-    long thetaCol = 0, muthetaCol = 0;
+    
+    long thetaCol=0, muthetaCol=0;
     ldiv_t res_ldiv;
-    long flagTheta = 0, flagMuTheta = 0;
-
-    if (nAstroPSolved == 2)
-    {
-        thetaCol = 1;
-        muthetaCol = 0;
+    long flagTheta=0, flagMuTheta=0;
+    
+    if(nAstroPSolved==2) {
+        thetaCol=1;
+        muthetaCol=0;
     }
-    else if (nAstroPSolved == 3)
-    {
-        thetaCol = 2;
-        muthetaCol = 0;
+    else if(nAstroPSolved==3) {
+        thetaCol=2;
+        muthetaCol=0;
     }
-    else if (nAstroPSolved == 4)
-    {
-        thetaCol = 1;
-        muthetaCol = 3;
+    else if(nAstroPSolved==4) {
+        thetaCol=1;
+        muthetaCol=3;
     }
-    else if (nAstroPSolved == 5)
-    {
-        thetaCol = 2;
-        muthetaCol = 4;
+    else if(nAstroPSolved==5) {
+        thetaCol=2;
+        muthetaCol=4;
     }
-
+    
     double epsilon;
-    double localSumX = 0, localSumXsq = 0, sumX = 0, sumXsq = 0, average = 0, rms = 0;
-    double dev = 0, localMaxDev = 0, maxDev = 0;
-
+    double localSumX=0, localSumXsq=0, sumX=0, sumXsq=0, average=0, rms=0;
+    double dev=0, localMaxDev=0, maxDev=0;
+    
     ///////// Each PE runs over the its Astrometric piece
-    if (muthetaCol == 0)
-        for (ii = 0; ii < VrIdAstroPDim * nAstroPSolved; ii++)
-        {
-            res_ldiv = ldiv((ii - thetaCol), nAstroPSolved);
-            flagTheta = res_ldiv.rem;
-            if (flagTheta == 0)
-            {
-                xSolution[ii] *= (-preCondVect[ii]);
-                if (idtest)
+    if(muthetaCol==0)
+        for(ii=0; ii<VrIdAstroPDim*nAstroPSolved; ii++) {
+            res_ldiv=ldiv((ii-thetaCol),nAstroPSolved);
+            flagTheta=res_ldiv.rem;
+            if(flagTheta==0)
+            {
+                xSolution[ii]*=(-preCondVect[ii]);
+                if(idtest)
                 {
-                    epsilon = xSolution[ii] + 1.0;
-                    localSumX -= epsilon;
-                    dev = fabs(epsilon);
-                    if (dev > localMaxDev)
-                        localMaxDev = dev;
+                    epsilon=xSolution[ii]+1.0;
+                    localSumX-=epsilon;
+                    dev=fabs(epsilon);
+                    if(dev>localMaxDev) localMaxDev=dev;
                 }
             }
             else
             {
-                xSolution[ii] *= preCondVect[ii]; // the corrections in theta are converted for consistency with the naming conventions in the Data Model to corrections in delta by a change of sign (Mantis Issue 0013081)
-                if (idtest)
+                xSolution[ii]*=preCondVect[ii]; // the corrections in theta are converted for consistency with the naming conventions in the Data Model to corrections in delta by a change of sign (Mantis Issue 0013081)
+                if(idtest)
                 {
-                    epsilon = xSolution[ii] - 1.0;
-                    localSumX += epsilon;
-                    dev = fabs(epsilon);
-                    if (dev > localMaxDev)
-                        localMaxDev = dev;
+                    epsilon=xSolution[ii]-1.0;
+                    localSumX+=epsilon;
+                    dev=fabs(epsilon);
+                    if(dev>localMaxDev) localMaxDev=dev;
                 }
+                
             }
-            if (idtest)
-                localSumXsq += epsilon * epsilon;
-            standardError[ii] *= preCondVect[ii];
+            if(idtest) localSumXsq+=epsilon*epsilon;
+            standardError[ii]*=preCondVect[ii];
         }
     else
-        for (ii = 0; ii < VrIdAstroPDim * nAstroPSolved; ii++)
-        {
-            res_ldiv = ldiv((ii - thetaCol), nAstroPSolved);
-            flagTheta = res_ldiv.rem;
-            res_ldiv = ldiv((ii - muthetaCol), nAstroPSolved);
-            flagMuTheta = res_ldiv.rem;
-            if ((flagTheta == 0) || (flagMuTheta == 0))
-            {
-                xSolution[ii] *= (-preCondVect[ii]);
-                if (idtest)
-                {
-                    epsilon = xSolution[ii] + 1.0;
-                    localSumX -= epsilon;
-                    dev = fabs(epsilon);
-                    if (dev > localMaxDev)
-                        localMaxDev = dev;
+        for(ii=0; ii<VrIdAstroPDim*nAstroPSolved; ii++) {
+            res_ldiv=ldiv((ii-thetaCol),nAstroPSolved);
+            flagTheta=res_ldiv.rem;
+            res_ldiv=ldiv((ii-muthetaCol),nAstroPSolved);
+            flagMuTheta=res_ldiv.rem;
+            if((flagTheta==0) || (flagMuTheta==0)) {
+                xSolution[ii]*=(-preCondVect[ii]);
+                if(idtest) {
+                    epsilon=xSolution[ii]+1.0;
+                    localSumX-=epsilon;
+                    dev=fabs(epsilon);
+                    if(dev>localMaxDev) localMaxDev=dev;
                 }
-            }
-            else
-            {
-                xSolution[ii] *= preCondVect[ii]; // the corrections in theta are converted for consistency with the naming conventions in the Data Model to corrections in delta by a change of sign (Mantis Issue 0013081)
-                if (idtest)
-                {
-                    epsilon = xSolution[ii] - 1.0;
-                    localSumX += epsilon;
-                    dev = fabs(epsilon);
-                    if (dev > localMaxDev)
-                        localMaxDev = dev;
+            } else {
+                xSolution[ii]*=preCondVect[ii]; // the corrections in theta are converted for consistency with the naming conventions in the Data Model to corrections in delta by a change of sign (Mantis Issue 0013081)
+                if(idtest) {
+                    epsilon=xSolution[ii]-1.0;
+                    localSumX+=epsilon;
+                    dev=fabs(epsilon);
+                    if(dev>localMaxDev) localMaxDev=dev;
                 }
             }
-            if (idtest)
-                localSumXsq += epsilon * epsilon;
-            standardError[ii] *= preCondVect[ii];
+            if(idtest) localSumXsq+=epsilon*epsilon;
+            standardError[ii]*=preCondVect[ii];
         }
     //////////// End of de-preconditioning for the Astrometric unknowns
-
+    
     //////////// Then only PE=0 runs over the shared unknowns (Attitude, Instrument, and Global)
-    if (myid == 0)
-        for (ii = VroffsetAttParam; ii < nunkSplit; ii++)
-        {
-            xSolution[ii] *= preCondVect[ii];
-            if (idtest)
-            {
-                localSumX += (xSolution[ii] - 1.0);
-                dev = fabs(1.0 - xSolution[ii]);
-                if (dev > localMaxDev)
-                    localMaxDev = dev;
-                localSumXsq += (xSolution[ii] - 1.0) * (xSolution[ii] - 1.0);
+    if(myid==0)
+        for(ii=VroffsetAttParam; ii<nunkSplit; ii++) {
+            xSolution[ii]*=preCondVect[ii];
+            if(idtest) {
+                localSumX+=(xSolution[ii]-1.0);
+                dev=fabs(1.0-xSolution[ii]);
+                if(dev>localMaxDev) localMaxDev=dev;
+                localSumXsq+=(xSolution[ii]-1.0)*(xSolution[ii]-1.0);
             }
-            standardError[ii] *= preCondVect[ii];
+            standardError[ii]*=preCondVect[ii];
         }
     //////////// End of de-preconditioning for the shared unknowns
-
+    
+    
     //////////////// TEST per verificare le somme di idtest.... da commentare/eliminare
     /*
      if(idtest)
@@ -3210,7 +2854,7 @@ int main(int argc, char **argv)
      }
      */
     //////////////// Fine TEST
-
+    
     free(systemMatrix);
     free(matrixIndex);
     free(instrCol);
@@ -3219,31 +2863,30 @@ int main(int argc, char **argv)
     free(wVect);
     free(preCondVect);
 
-    if (idtest)
+    if(idtest)
     {
-        MPI_Reduce(&localSumX, &sumX, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
-        MPI_Reduce(&localSumXsq, &sumXsq, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
-        MPI_Reduce(&localMaxDev, &maxDev, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
+        MPI_Reduce(&localSumX,&sumX,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD);
+        MPI_Reduce(&localSumXsq,&sumXsq,1,MPI_DOUBLE,MPI_SUM,0,MPI_COMM_WORLD);
+        MPI_Reduce(&localMaxDev,&maxDev,1,MPI_DOUBLE,MPI_MAX,0,MPI_COMM_WORLD);
     }
-
-    if (myid == 0)
+    
+    if(myid==0)
     {
-        if (idtest)
+        if(idtest)
         {
-            average = sumX / nunk;
-            rms = pow(sumXsq / nunk - pow(average, 2.0), 0.5);
+            average=sumX/nunk;
+            rms=pow(sumXsq/nunk-pow(average,2.0),0.5);
             printf("Average deviation from ID solution: %le.\n", average);
             printf("                               rms: %le.\n", rms);
             printf("Maximum deviation from ID solution: %le.\n", maxDev);
         }
     }
-
-    if (istop == 1000 && wrsol == 0)
+    
+    if(istop==1000 && wrsol==0)
     {
-        if (myid == 0)
-        {
-            printf("Reached  limit at itn=%d. Execution stopped. CPR written!\n", itn);
-            ffcont = fopen("CPR_CONT", "w");
+        if(myid==0){
+            printf("Reached  limit at itn=%d. Execution stopped. CPR written!\n",itn);
+            ffcont=fopen("CPR_CONT","w");
             fclose(ffcont);
         }
         MPI_Finalize();
@@ -3251,304 +2894,283 @@ int main(int argc, char **argv)
     }
     ///////////////
     ///////////// Initialize the output filename
-    if (istop == 1000)
-    {
-        sprintf(filenameAstroResults, "%s%d%s", "GsrAstroParamSolution_intermediate_", itn, ".bin");   // file storing the Astrometric Parameters
-        sprintf(filenameAttResults, "%s%d%s", "GsrAttitudeParamSolution_intermediate_", itn, ".bin");  // file storing the Attitude Parameters
-        sprintf(filenameInstrResults, "%s%d%s", "GsrInstrParamSolution_intermediate_", itn, ".bin");   // file storing the Instrument Parameters
-        sprintf(filenameGlobalResults, "%s%d%s", "GsrGlobalParamSolution_intermediate_", itn, ".bin"); // file storing the Global Parameters
-        sprintf(filenameSolPropsFinal, "GsrFinal_intermediate_%d_%s", itn, argv[argc - 1]);
-    }
-    else
-    {
-        if (myid == 0)
-        {
+    if(istop==1000){
+        sprintf(filenameAstroResults, "%s%d%s", "GsrAstroParamSolution_intermediate_",itn,".bin"); // file storing the Astrometric Parameters
+        sprintf(filenameAttResults, "%s%d%s","GsrAttitudeParamSolution_intermediate_",itn,".bin"); // file storing the Attitude Parameters
+        sprintf(filenameInstrResults, "%s%d%s","GsrInstrParamSolution_intermediate_",itn,".bin"); // file storing the Instrument Parameters
+        sprintf(filenameGlobalResults, "%s%d%s","GsrGlobalParamSolution_intermediate_",itn,".bin"); // file storing the Global Parameters
+        sprintf(filenameSolPropsFinal,"GsrFinal_intermediate_%d_%s",itn, argv[argc-1]);
+    } else{
+        if(myid==0){
             printf("Execution finished END_FILE written!\n");
             chdir(wpath);
-            ffcont = fopen("END_FILE", "w");
+            ffcont=fopen("END_FILE","w");
             fclose(ffcont);
             system("rm CPR_CONT");
-            if (outputDirOpt)
-                chdir(outputDir); // go to output dir
-        }
-        sprintf(filenameAstroResults, "%s", "GsrAstroParamSolution.bin");   // file storing the Astrometric Parameters
-        sprintf(filenameAttResults, "%s", "GsrAttitudeParamSolution.bin");  // file storing the Attitude Parameters
-        sprintf(filenameInstrResults, "%s", "GsrInstrParamSolution.bin");   // file storing the Instrument Parameters
-        sprintf(filenameGlobalResults, "%s", "GsrGlobalParamSolution.bin"); // file storing the Global Parameters
-        sprintf(filenameSolPropsFinal, "GsrFinal_%s", argv[argc - 1]);
+            if(outputDirOpt) chdir(outputDir); // go to output dir
+        }
+        sprintf(filenameAstroResults, "%s", "GsrAstroParamSolution.bin"); // file storing the Astrometric Parameters
+        sprintf(filenameAttResults, "%s","GsrAttitudeParamSolution.bin"); // file storing the Attitude Parameters
+        sprintf(filenameInstrResults, "%s","GsrInstrParamSolution.bin"); // file storing the Instrument Parameters
+        sprintf(filenameGlobalResults, "%s","GsrGlobalParamSolution.bin"); // file storing the Global Parameters
+        sprintf(filenameSolPropsFinal,"GsrFinal_%s", argv[argc-1]);
     }
-    if (debugMode && myid == 0)
-        printf("Output %s %s %s %s %s\n", filenameSolProps, filenameAstroResults, filenameAttResults, filenameInstrResults, filenameGlobalResults);
+    if(debugMode && myid==0) printf("Output %s %s %s %s %s\n",filenameSolProps,filenameAstroResults,	filenameAttResults, filenameInstrResults, filenameGlobalResults);
     /////////////////////////////////////////////
-
+    
     MPI_Status statusMpi;
     if (myid == 0)
     {
         printf("Processing finished.\n");
         fflush(stdout);
-        for (ii = 0; ii < 10; ii++)
-            printf("xSolution[%ld]=%16.12le \t standardError[%ld]=%16.12le\n", ii, xSolution[ii], ii, standardError[ii]);
+        for (ii = 0; ii < 10; ii++)  printf("xSolution[%ld]=%16.12le \t standardError[%ld]=%16.12le\n", ii, xSolution[ii],ii,standardError[ii]);
     }
-
+    
     ////////// Writing final solution
-
-    if (myid == 0)
+    
+    if(myid==0)
     {
-
+        
         ////////// Writing the raw results to the files GsrFinal_GsrSolProps.dat
-
-        fpSolPropsFinal = fopen(filenameSolPropsFinal, "w");
+        
+        
+        fpSolPropsFinal=fopen(filenameSolPropsFinal,"w");
         if (!fpSolPropsFinal)
         {
-            printf("Error while open %s\n", filenameSolPropsFinal);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("Error while open %s\n",filenameSolPropsFinal);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        fprintf(fpSolPropsFinal, "sphereId= %ld\n", sphereId);
-        fprintf(fpSolPropsFinal, "nStar= %ld\n", nStar);
-        fprintf(fpSolPropsFinal, "nAttParam= %d\n", nAttParam);
-        fprintf(fpSolPropsFinal, "nInstrParam= %d\n", nInstrParam);
-        fprintf(fpSolPropsFinal, "nInstrParamTot= %d\n", nInstrParamTot);
-        fprintf(fpSolPropsFinal, "nGlobalParam= %d\n", nGlobalParam);
-        fprintf(fpSolPropsFinal, "nAstroPSolved= %d\n", nAstroPSolved);
-        fprintf(fpSolPropsFinal, "nInstrPSolved= %d\n", nInstrPSolved);
-        fprintf(fpSolPropsFinal, "nFoVs= %d\n", nFoVs);
-        fprintf(fpSolPropsFinal, "nCCDs= %d\n", nCCDs);
-        fprintf(fpSolPropsFinal, "nPixelColumns= %d\n", nPixelColumns);
-        fprintf(fpSolPropsFinal, "nTimeIntervals= %d\n", nTimeIntervals);
-        fprintf(fpSolPropsFinal, "lSQRacond= %lf\n", acond);
-        fprintf(fpSolPropsFinal, "lSQRanorm= %lf\n", anorm);
-        fprintf(fpSolPropsFinal, "lSQRarnorm= %lf\n", arnorm);
-        fprintf(fpSolPropsFinal, "lSQRitNumb= %d\n", itn);
-        fprintf(fpSolPropsFinal, "lSQRrnorm= %lf\n", rnorm);
-        fprintf(fpSolPropsFinal, "lSQRstopCond= %d\n", istop);
-        fprintf(fpSolPropsFinal, "lSQRxnorm= %lf\n", xnorm);
+        fprintf(fpSolPropsFinal, "sphereId= %ld\n",sphereId) ;
+        fprintf(fpSolPropsFinal, "nStar= %ld\n",nStar) ;
+        fprintf(fpSolPropsFinal, "nAttParam= %d\n",nAttParam) ;
+        fprintf(fpSolPropsFinal, "nInstrParam= %d\n",nInstrParam) ;
+        fprintf(fpSolPropsFinal, "nInstrParamTot= %d\n",nInstrParamTot) ;
+        fprintf(fpSolPropsFinal, "nGlobalParam= %d\n",nGlobalParam) ;
+        fprintf(fpSolPropsFinal, "nAstroPSolved= %d\n",nAstroPSolved) ;
+        fprintf(fpSolPropsFinal, "nInstrPSolved= %d\n",nInstrPSolved) ;
+        fprintf(fpSolPropsFinal, "nFoVs= %d\n",nFoVs);
+        fprintf(fpSolPropsFinal, "nCCDs= %d\n",nCCDs);
+        fprintf(fpSolPropsFinal, "nPixelColumns= %d\n",nPixelColumns);
+        fprintf(fpSolPropsFinal, "nTimeIntervals= %d\n",nTimeIntervals);
+        fprintf(fpSolPropsFinal, "lSQRacond= %lf\n",acond) ;
+        fprintf(fpSolPropsFinal, "lSQRanorm= %lf\n",anorm) ;
+        fprintf(fpSolPropsFinal, "lSQRarnorm= %lf\n",arnorm) ;
+        fprintf(fpSolPropsFinal, "lSQRitNumb= %d\n",itn) ;
+        fprintf(fpSolPropsFinal, "lSQRrnorm= %lf\n",rnorm) ;
+        fprintf(fpSolPropsFinal, "lSQRstopCond= %d\n",istop) ;
+        fprintf(fpSolPropsFinal, "lSQRxnorm= %lf\n",xnorm) ;
         fclose(fpSolPropsFinal);
-
+        
         ////////////////////// Writing GsrAstroParamSolution.bin
-        if (nAstroPSolved)
+        if(nAstroPSolved)
         {
-            long testOnStars = 0;
-            fpAstroR = fopen(filenameAstroResults, "wb");
+            long testOnStars=0;
+            fpAstroR=fopen(filenameAstroResults,"wb");
             if (!fpAstroR)
             {
-                printf("Error while open %s\n", filenameAstroResults);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("Error while open %s\n",filenameAstroResults);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            fwrite(&sphereId, sizeof(long), 1, fpAstroR);
-            xAstro = (double *)calloc(VrIdAstroPDimMax * nAstroP, sizeof(double));
+            fwrite(&sphereId,sizeof(long),1,fpAstroR);
+            xAstro = (double *) calloc(VrIdAstroPDimMax*nAstroP, sizeof(double));
             if (!xAstro)
             {
                 printf("Error allocating xAstro\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            for (ii = 0; ii < VrIdAstroPDim; ii++)
+            for(ii=0; ii<VrIdAstroPDim; ii++)
             {
-                for (jj = 0; jj < nAstroPSolved; jj++)
+                for(jj=0; jj< nAstroPSolved;jj++)
                 {
-                    xAstro[ii * nAstroP + mapAstroP[jj]] = xSolution[ii * nAstroPSolved + jj];
+                    xAstro[ii*nAstroP+mapAstroP[jj]] = xSolution[ii*nAstroPSolved+jj];
                 }
             }
-            fwrite(xAstro, sizeof(double), VrIdAstroPDim * nAstroP, fpAstroR);
-            testOnStars += VrIdAstroPDim;
-            for (kk = 1; kk < nproc; kk++)
+            fwrite(xAstro,sizeof(double),VrIdAstroPDim*nAstroP,fpAstroR);
+            testOnStars+=VrIdAstroPDim;
+            for(kk=1;kk<nproc;kk++)
             {
-                offset = 0;
+                offset=0;
                 MPI_Recv(&VrIdAstroPDimRecv, 1, MPI_LONG, kk, 10, MPI_COMM_WORLD, &statusMpi);
-                mpi_recv(xSolution, VrIdAstroPDimRecv * nAstroPSolved, MPI_DOUBLE, kk, 11, MPI_COMM_WORLD, &statusMpi);
-                if (comlsqr.mapStar[kk][0] == comlsqr.mapStar[kk - 1][1])
-                    offset = 1;
-                for (ii = 0 + offset; ii < VrIdAstroPDimRecv; ii++)
+                mpi_recv(xSolution, VrIdAstroPDimRecv*nAstroPSolved, MPI_DOUBLE, kk, 11,MPI_COMM_WORLD, &statusMpi);
+                if(comlsqr.mapStar[kk][0]==comlsqr.mapStar[kk-1][1]) offset=1;
+                for(ii=0+offset; ii<VrIdAstroPDimRecv; ii++)
                 {
-                    for (jj = 0; jj < nAstroPSolved; jj++)
+                    for(jj=0; jj< nAstroPSolved;jj++)
                     {
-                        xAstro[(ii - offset) * nAstroP + mapAstroP[jj]] = xSolution[ii * nAstroPSolved + jj];
+                        xAstro[(ii-offset)*nAstroP+mapAstroP[jj]] = xSolution[ii*nAstroPSolved+jj];
                     }
                 }
-                fwrite(xAstro, sizeof(double), (VrIdAstroPDimRecv - offset) * nAstroP, fpAstroR);
-                testOnStars += VrIdAstroPDimRecv - offset;
+                fwrite(xAstro,sizeof(double),(VrIdAstroPDimRecv-offset)*nAstroP,fpAstroR);
+                testOnStars+=VrIdAstroPDimRecv-offset;
             }
             free(xAstro);
-
-            if (testOnStars != nStar)
+            
+            if(testOnStars!=nStar)
             {
-                printf("Error on xAstro testOnStar =%ld not equal to nmStar=%ld\n", testOnStars, nStar);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("Error on xAstro testOnStar =%ld not equal to nmStar=%ld\n",testOnStars,nStar);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            testOnStars = 0;
-            standardErrorAstro = (double *)calloc(VrIdAstroPDimMax * nAstroP, sizeof(double));
+            testOnStars=0;
+            standardErrorAstro = (double *) calloc(VrIdAstroPDimMax*nAstroP, sizeof(double));
             if (!standardErrorAstro)
             {
                 printf("Error allocating standardErrorAstro\n");
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
-            for (ii = 0; ii < VrIdAstroPDim; ii++)
+            for(ii=0; ii<VrIdAstroPDim; ii++)
             {
-                for (jj = 0; jj < nAstroPSolved; jj++)
+                for(jj=0; jj< nAstroPSolved;jj++)
                 {
-                    standardErrorAstro[ii * nAstroP + mapAstroP[jj]] = standardError[ii * nAstroPSolved + jj];
+                    standardErrorAstro[ii*nAstroP+mapAstroP[jj]] =standardError[ii*nAstroPSolved+jj];
                 }
             }
-            fwrite(standardErrorAstro, sizeof(double), VrIdAstroPDim * nAstroP, fpAstroR);
-            testOnStars += VrIdAstroPDim;
-            for (kk = 1; kk < nproc; kk++)
+            fwrite(standardErrorAstro,sizeof(double),VrIdAstroPDim*nAstroP,fpAstroR);
+            testOnStars+=VrIdAstroPDim;
+            for(kk=1;kk<nproc;kk++)
             {
-                offset = 0;
+                offset=0;
                 MPI_Recv(&VrIdAstroPDimRecv, 1, MPI_LONG, kk, 12, MPI_COMM_WORLD, &statusMpi);
-                MPI_Recv(standardError, VrIdAstroPDimRecv * nAstroPSolved, MPI_DOUBLE, kk, 13, MPI_COMM_WORLD, &statusMpi);
-                if (comlsqr.mapStar[kk][0] == comlsqr.mapStar[kk - 1][1])
-                    offset = 1;
-                for (ii = 0 + offset; ii < VrIdAstroPDimRecv; ii++)
+                MPI_Recv(standardError, VrIdAstroPDimRecv*nAstroPSolved , MPI_DOUBLE, kk, 13,MPI_COMM_WORLD, &statusMpi);
+                if(comlsqr.mapStar[kk][0]==comlsqr.mapStar[kk-1][1]) offset=1;
+                for(ii=0+offset; ii<VrIdAstroPDimRecv; ii++)
                 {
-                    for (jj = 0; jj < nAstroPSolved; jj++)
+                    for(jj=0; jj< nAstroPSolved;jj++)
                     {
-                        standardErrorAstro[(ii - offset) * nAstroP + mapAstroP[jj]] = standardError[ii * nAstroPSolved + jj];
+                        standardErrorAstro[(ii-offset)*nAstroP+mapAstroP[jj]] = standardError[ii*nAstroPSolved+jj];
                     }
                 }
-                fwrite(standardErrorAstro, sizeof(double), (VrIdAstroPDimRecv - offset) * nAstroP, fpAstroR);
-                testOnStars += VrIdAstroPDimRecv - offset;
+                fwrite(standardErrorAstro,sizeof(double),(VrIdAstroPDimRecv-offset)*nAstroP,fpAstroR);
+                testOnStars+=VrIdAstroPDimRecv-offset;
             }
             free(standardErrorAstro);
-            if (testOnStars != nStar)
+            if(testOnStars!=nStar)
             {
-                printf("Error on standardErrorAstro testOnStar =%ld not equal to nmStar=%ld\n", testOnStars, nStar);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                printf("Error on standardErrorAstro testOnStar =%ld not equal to nmStar=%ld\n",testOnStars,nStar);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
             fclose(fpAstroR);
             //////////////////////////////////////////////////////////
         }
         ////////////////////// writing  GsrAttitudeParamSolution.bin
-        fpAttR = fopen(filenameAttResults, "wb");
+        fpAttR=fopen(filenameAttResults,"wb");
         if (!fpAttR)
         {
-            printf("Error while open %s\n", filenameAttResults);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("Error while open %s\n",filenameAttResults);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        fwrite(&sphereId, sizeof(long), 1, fpAttR);
-        fwrite(&xSolution[VroffsetAttParam], sizeof(double), nAttParam, fpAttR);
-        fwrite(&standardError[VroffsetAttParam], sizeof(double), nAttParam, fpAttR);
+        fwrite(&sphereId,sizeof(long),1,fpAttR);
+        fwrite(&xSolution[VroffsetAttParam],sizeof(double),nAttParam,fpAttR);
+        fwrite(&standardError[VroffsetAttParam],sizeof(double),nAttParam,fpAttR);
         fclose(fpAttR);
         //////////////////////////////////////////////////////////
-
+        
         ////////////////////// writing GsrInstrParamSolution.bin
-        fpInstrR = fopen(filenameInstrResults, "wb");
+        fpInstrR=fopen(filenameInstrResults,"wb");
         if (!fpInstrR)
         {
-            printf("Error while open %s\n", filenameInstrResults);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("Error while open %s\n",filenameInstrResults);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        double *xInstr, *seInstr;
-        xInstr = (double *)calloc(nInstrParamTot, sizeof(double));
-        seInstr = (double *)calloc(nInstrParamTot, sizeof(double));
-        if (nInstrPSolved != nInstrP)
+        double *xInstr,*seInstr;
+        xInstr=(double *) calloc(nInstrParamTot, sizeof(double));
+        seInstr=(double *) calloc(nInstrParamTot, sizeof(double));
+        if(nInstrPSolved!=nInstrP)
         {
             int fixedOffsetCMag = nCCDs;
-            int fixedOffsetCnu = fixedOffsetCMag + nFoVs * nCCDs;
-            int fixedOffsetCdelta_eta = fixedOffsetCnu + nCCDs * nPixelColumns;
-            int fixedOffsetCDelta_eta = fixedOffsetCdelta_eta + 3 * nFoVs * nCCDs * nTimeIntervals;
-            int fixedOffsetCdelta_zeta = fixedOffsetCDelta_eta + nCCDs * nPixelColumns;
-
-            int counterInstr = 0;
-            if (maInstrFlag)
-            {
-                for (int k = 0; k < fixedOffsetCMag; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            int fixedOffsetCnu = fixedOffsetCMag+nFoVs*nCCDs;
+            int fixedOffsetCdelta_eta = fixedOffsetCnu+nCCDs*nPixelColumns;
+            int fixedOffsetCDelta_eta = fixedOffsetCdelta_eta+3*nFoVs*nCCDs*nTimeIntervals;
+            int fixedOffsetCdelta_zeta = fixedOffsetCDelta_eta+nCCDs*nPixelColumns;
+            
+            int counterInstr=0;
+            if(maInstrFlag){
+                for(int k=0;k<fixedOffsetCMag;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (nuInstrFlag)
-            {
-                for (int k = fixedOffsetCMag; k < fixedOffsetCnu; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            if(nuInstrFlag){
+                for(int k=fixedOffsetCMag;k<fixedOffsetCnu;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (ssInstrFlag)
-            {
-                for (int k = fixedOffsetCnu; k < fixedOffsetCdelta_eta; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            if(ssInstrFlag){
+                for(int k=fixedOffsetCnu;k<fixedOffsetCdelta_eta;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (lsInstrFlag)
-            {
-                for (int k = fixedOffsetCdelta_eta; k < fixedOffsetCDelta_eta; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            if(lsInstrFlag){
+                for(int k=fixedOffsetCdelta_eta;k<fixedOffsetCDelta_eta;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (ssInstrFlag)
-            {
-                for (int k = fixedOffsetCDelta_eta; k < fixedOffsetCdelta_zeta; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            if(ssInstrFlag){
+                for(int k=fixedOffsetCDelta_eta;k<fixedOffsetCdelta_zeta;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (lsInstrFlag)
-            {
-                for (int k = fixedOffsetCdelta_zeta; k < nInstrParamTot; k++)
-                {
-                    xInstr[k] = xSolution[VroffsetAttParam + nAttParam + counterInstr];
-                    seInstr[k] = standardError[VroffsetAttParam + nAttParam + counterInstr];
+            if(lsInstrFlag){
+                for(int k=fixedOffsetCdelta_zeta;k<nInstrParamTot;k++){
+                    xInstr[k]=xSolution[VroffsetAttParam+nAttParam+counterInstr];
+                    seInstr[k]=standardError[VroffsetAttParam+nAttParam+counterInstr];
                     counterInstr++;
                 }
             }
-            if (counterInstr != nInstrParam)
-            {
+            if(counterInstr!=nInstrParam) {
                 printf("SEVERE ERROR: counterInstr=%ld does not match nInstrParam=%ld while filling in xInstr and seInstr.\n", counterInstr, nInstrParam);
-                MPI_Abort(MPI_COMM_WORLD, 1);
+                MPI_Abort(MPI_COMM_WORLD,1);
                 exit(EXIT_FAILURE);
             }
         }
-        fwrite(&sphereId, sizeof(long), 1, fpInstrR);
-        fwrite(xInstr, sizeof(double), nInstrParamTot, fpInstrR);
-        fwrite(seInstr, sizeof(double), nInstrParamTot, fpInstrR);
+        fwrite(&sphereId,sizeof(long),1,fpInstrR);
+        fwrite(xInstr,sizeof(double),nInstrParamTot,fpInstrR);
+        fwrite(seInstr,sizeof(double),nInstrParamTot,fpInstrR);
         fclose(fpInstrR);
         free(xInstr);
         free(seInstr);
         //////////////////////////////////////////////////////////
-
+        
         ////////////////////// writing GsrGlobalParamSolution.bin
-        fpGlobR = fopen(filenameGlobalResults, "wb");
+        fpGlobR=fopen(filenameGlobalResults,"wb");
         if (!fpGlobR)
         {
-            printf("Error while open %s\n", filenameGlobalResults);
-            MPI_Abort(MPI_COMM_WORLD, 1);
+            printf("Error while open %s\n",filenameGlobalResults);
+            MPI_Abort(MPI_COMM_WORLD,1);
             exit(EXIT_FAILURE);
         }
-        fwrite(&sphereId, sizeof(long), 1, fpGlobR);
-        fwrite(&xSolution[VroffsetAttParam + nAttParam + nInstrParam], sizeof(double), nGlobalParam, fpGlobR);
-        fwrite(&standardError[VroffsetAttParam + nAttParam + nInstrParam], sizeof(double), nGlobalParam, fpGlobR);
+        fwrite(&sphereId,sizeof(long),1,fpGlobR);
+        fwrite(&xSolution[VroffsetAttParam+nAttParam+nInstrParam],sizeof(double),nGlobalParam,fpGlobR);
+        fwrite(&standardError[VroffsetAttParam+nAttParam+nInstrParam],sizeof(double),nGlobalParam,fpGlobR);
         fclose(fpGlobR);
         //////////////////////////////////////////////////////////
-
+        
     } //if (myid==0)
     else
     {
         //////////////// send for AstroResults.bin
-        if (nAstroPSolved)
+        if(nAstroPSolved)
         {
             MPI_Send(&VrIdAstroPDim, 1, MPI_LONG, 0, 10, MPI_COMM_WORLD);
-            mpi_send(xSolution, VrIdAstroPDim * nAstroPSolved, MPI_DOUBLE, 0, 11, MPI_COMM_WORLD);
+            mpi_send(xSolution, VrIdAstroPDim*nAstroPSolved, MPI_DOUBLE, 0, 11,MPI_COMM_WORLD);
             MPI_Send(&VrIdAstroPDim, 1, MPI_LONG, 0, 12, MPI_COMM_WORLD);
-            MPI_Send(standardError, VrIdAstroPDim * nAstroPSolved, MPI_DOUBLE, 0, 13, MPI_COMM_WORLD);
+            MPI_Send(standardError, VrIdAstroPDim*nAstroPSolved , MPI_DOUBLE, 0, 13,MPI_COMM_WORLD);
         }
         //////////////////////////////////////////////////////////
     }
@@ -3556,20 +3178,17 @@ int main(int argc, char **argv)
     //  tolti i free() mancanti
     free(xSolution);
     free(standardError);
-
-    if (myid == 0)
-        printf("\nEnd run.\n");
+    
+    if(myid==0) printf("\nEnd run.\n");
     seconds[3] = time(NULL);
     tot_sec[2] = seconds[3] - seconds[2];
     tot_sec[3] = seconds[3] - seconds[0];
-
-    if (myid == 0)
-        printf("time before lsqr in sec: %ld\ntime for lsqr: %ld\n", tot_sec[0],
-               tot_sec[1]);
-    if (myid == 0)
-        printf("time after lsqr in sec: %ld\ntime TOTAL: %ld\n", tot_sec[2],
-               tot_sec[3]);
-
+    
+    if(myid==0) printf("time before lsqr in sec: %ld\ntime for lsqr: %ld\n", tot_sec[0],
+                       tot_sec[1]);
+    if(myid==0) printf("time after lsqr in sec: %ld\ntime TOTAL: %ld\n", tot_sec[2],
+                       tot_sec[3]);
+    
     MPI_Finalize();
     exit(EXIT_SUCCESS);
 }
diff --git a/util.c b/util.c
old mode 100644
new mode 100755
diff --git a/util.h b/util.h
old mode 100644
new mode 100755
index ffdff59..d5ae47f
--- a/util.h
+++ b/util.h
@@ -103,7 +103,6 @@ struct comData {
     long offsetCMag,offsetCnu,offsetCdelta_eta,offsetCDelta_eta_1,offsetCDelta_eta_2;
     long offsetCDelta_eta_3,offsetCdelta_zeta,offsetCDelta_zeta_1,offsetCDelta_zeta_2;
 	int nthreads;
-	int ntasks;
 	long **mapForThread;
 	int nSubsetAtt, nSubsetInstr;
 	int NOnSubsetAtt, NOnSubsetInstr;
-- 
GitLab