Changeset 14951

Timestamp:

05/07/13 16:19:58 (12 years ago)

Author:

Eric.Larour

Message:

CHG: de-entangle dependencies between Containers and shared/Elements

Location:

issm/trunk-jpl/src/c

Files:

• Container/Elements.cpp (modified) (1 diff)
• Container/Inputs.cpp (modified) (1 diff)
• Container/Inputs.h (modified) (1 diff)
• Container/Loads.cpp (modified) (1 diff)
• Container/Materials.cpp (modified) (1 diff)
• Container/Nodes.cpp (modified) (1 diff)
• Container/Parameters.cpp (modified) (1 diff)
• Container/Results.cpp (modified) (1 diff)
• Container/Vertices.cpp (modified) (1 diff)
• Makefile.am (modified) (2 diffs)
• classes/objects/Elements/Element.h (modified) (1 diff)
• classes/objects/Elements/PentaRef.h (modified) (1 diff)
• classes/objects/Inputs/BoolInput.h (modified) (1 diff)
• classes/objects/Inputs/ControlInput.h (modified) (1 diff)
• classes/objects/Inputs/DatasetInput.h (modified) (1 diff)
• classes/objects/Inputs/DoubleInput.h (modified) (1 diff)
• classes/objects/Inputs/Input.h (modified) (1 diff)
• classes/objects/Inputs/IntInput.h (modified) (1 diff)
• classes/objects/Inputs/PentaP1Input.h (modified) (1 diff)
• classes/objects/Inputs/TransientInput.h (modified) (1 diff)
• classes/objects/Inputs/TriaP1Input.h (modified) (1 diff)
• classes/objects/Loads/Friction.h (modified) (1 diff)
• classes/objects/Loads/Load.h (modified) (1 diff)
• classes/objects/Materials/Material.h (modified) (1 diff)
• classes/objects/Node.cpp (modified) (1 diff)
• classes/objects/Node.h (modified) (2 diffs)
• classes/objects/Profiler.cpp (modified) (1 diff)
• classes/objects/Vertex.cpp (modified) (1 diff)
• classes/objects/Vertex.h (modified) (1 diff)
• modules/ConfigureObjectsx/ConfigureObjectsx.cpp (modified) (1 diff)
• modules/GroundinglineMigrationx/GroundinglineMigrationx.cpp (modified) (1 diff)
• modules/InputControlUpdatex/InputControlUpdatex.cpp (modified) (1 diff)
• modules/InputConvergencex/InputConvergencex.cpp (modified) (1 diff)
• modules/InputDuplicatex/InputDuplicatex.cpp (modified) (1 diff)
• modules/InputScalex/InputScalex.cpp (modified) (1 diff)
• modules/InputToResultx/InputToResultx.cpp (modified) (1 diff)
• modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp (modified) (1 diff)
• modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp (modified) (1 diff)
• modules/ModelProcessorx/DistributeNumDofs.cpp (modified) (1 diff)
• shared/Elements/Arrhenius.cpp (modified) (1 diff)
• shared/Elements/ComputeDelta18oTemperaturePrecipitation.cpp (modified) (1 diff)
• shared/Elements/CoordinateSystemTransform.cpp (deleted)
• shared/Elements/GetGlobalDofList.cpp (deleted)
• shared/Elements/GetLocalDofList.cpp (deleted)
• shared/Elements/GetNumberOfDofs.cpp (deleted)
• shared/Elements/GetVerticesCoordinates.cpp (deleted)
• shared/Elements/Paterson.cpp (modified) (1 diff)
• shared/Elements/PddSurfaceMassBalance.cpp (modified) (1 diff)
• shared/Elements/PrintArrays.cpp (modified) (1 diff)
• shared/Elements/TransformInvStiffnessMatrixCoord.cpp (deleted)
• shared/Elements/TransformLoadVectorCoord.cpp (deleted)
• shared/Elements/TransformSolutionCoord.cpp (deleted)
• shared/Elements/TransformStiffnessMatrixCoord.cpp (deleted)
• shared/Elements/elements.h (modified) (2 diffs)
• shared/Exceptions/Exceptions.cpp (modified) (1 diff)

issm/trunk-jpl/src/c/Container/Elements.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Elements/Element.h"
+#include "../classes/objects/ExternalResults/GenericExternalResult.h"
+#include "../classes/Patch.h"
+#include "../classes/toolkits/Vector.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Inputs.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Inputs/Input.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Inputs.h

@@ -3 +3 @@
 
 /*forward declarations */
-class Materials;
 class Parameters;
-class Elements;
-class Vertices;
-class Loads;
-class Nodes;
 class DataSet;
 class Input;
-class Node;
-class GaussTria;
-class GaussPenta;
 #include "../shared/Numerics/types.h"
 

issm/trunk-jpl/src/c/Container/Loads.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Loads/Load.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Materials.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Materials/Material.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Nodes.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Node.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Parameters.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/objects.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Results.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/ExternalResults/ExternalResult.h"
+#include "../classes/objects/ElementResults/ElementResult.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Container/Vertices.cpp

@@ -19 +19 @@
 #include "../shared/shared.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
+#include "../classes/objects/Vertex.h"
 
 using namespace std;

issm/trunk-jpl/src/c/Makefile.am

@@ -216 +216 @@
                                         ./shared/Elements/Paterson.cpp\
                                         ./shared/Elements/Arrhenius.cpp\
-                                        ./shared/Elements/GetVerticesCoordinates.cpp\
-                                        ./shared/Elements/GetLocalDofList.cpp\
-                                        ./shared/Elements/GetGlobalDofList.cpp\
-                                        ./shared/Elements/GetNumberOfDofs.cpp\
                                         ./shared/Elements/PrintArrays.cpp\
                                         ./shared/Elements/PddSurfaceMassBalance.cpp\
@@ -487 +483 @@
                                               ./modules/ModelProcessorx/DiagnosticHutter/CreateConstraintsDiagnosticHutter.cpp \
                                               ./modules/ModelProcessorx/DiagnosticHutter/CreateLoadsDiagnosticHutter.cpp \
-                                                  ./shared/Elements/CoordinateSystemTransform.cpp\
-                                                  ./shared/Elements/TransformLoadVectorCoord.cpp \
-                                                  ./shared/Elements/TransformStiffnessMatrixCoord.cpp \
-                                                  ./shared/Elements/TransformInvStiffnessMatrixCoord.cpp \
-                                                  ./shared/Elements/TransformSolutionCoord.cpp\
                                                   ./solutions/diagnostic_core.cpp\
                                                   ./solvers/solver_stokescoupling_nonlinear.cpp

issm/trunk-jpl/src/c/classes/objects/Elements/Element.h

@@ -11 +11 @@
 /*{{{*/
 #include "../Object.h"
+#include "../../Update.h"
 
 class DataSet;

issm/trunk-jpl/src/c/classes/objects/Elements/PentaRef.h

@@ -7 +7 @@
 #define _PENTAREF_H_
 
+class GaussPenta;
 class PentaRef{
 

issm/trunk-jpl/src/c/classes/objects/Inputs/BoolInput.h

@@ -10 +10 @@
 #include "./Input.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/ControlInput.h

@@ -10 +10 @@
 #include "./Input.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/DatasetInput.h

@@ -10 +10 @@
 #include "./Input.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/DoubleInput.h

@@ -10 +10 @@
 #include "./Input.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/Input.h

@@ -13 +13 @@
 class GaussTria;
 class Parameters;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/IntInput.h

@@ -10 +10 @@
 #include "./Input.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/PentaP1Input.h

@@ -11 +11 @@
 #include "../Elements/PentaRef.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/TransientInput.h

@@ -11 +11 @@
 class GaussTria;
 class Parameters;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Inputs/TriaP1Input.h

@@ -11 +11 @@
 #include "../Elements/TriaRef.h"
 class GaussTria;
+class GaussPenta;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Loads/Friction.h

@@ -10 +10 @@
 class Inputs;
 class Matpar;
+class GaussPenta;
+class GaussTria;
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Loads/Load.h

@@ -15 +15 @@
 
 #include "../Object.h"
+#include "../../Update.h"
 #include "../../../toolkits/toolkits.h"
 #include "../../../Container/Container.h"

issm/trunk-jpl/src/c/classes/objects/Materials/Material.h

@@ -10 +10 @@
 class Object;
 #include "../Object.h"
+#include "../../Update.h"
 #include "../../../toolkits/toolkits.h"
 /*}}}*/

issm/trunk-jpl/src/c/classes/objects/Node.cpp

@@ -955 +955 @@
 }
 /*}}}*/
+
+
+/*Methods inherent to Node: */
+int* GetLocalDofList(Node** nodes,int numnodes,int setenum,int approximation){ /*{{{*/
+
+        int  i,j,count,numdof,numgdof;
+        int* ndof_list=NULL;
+        int* ngdof_list_cumulative=NULL;
+        int *doflist = NULL;
+
+        if(numnodes){
+                /*allocate: */
+                ndof_list=xNew<int>(numnodes);
+                ngdof_list_cumulative=xNew<int>(numnodes);
+
+                /*Get number of dofs per node, and total for this given set*/
+                numdof=0;
+                numgdof=0;
+                for(i=0;i<numnodes;i++){
+
+                        /*Cumulative list= number of dofs before node i*/
+                        ngdof_list_cumulative[i]=numgdof;
+
+                        /*Number of dofs for node i for given set and for the g set*/
+                        ndof_list[i]=nodes[i]->GetNumberOfDofs(approximation,setenum);
+                        numgdof    +=nodes[i]->GetNumberOfDofs(approximation,GsetEnum);
+                        numdof     +=ndof_list[i];
+                }
+
+                if(numdof){
+                        /*Allocate: */
+                        doflist=xNew<int>(numdof);
+
+                        /*Populate: */
+                        count=0;
+                        for(i=0;i<numnodes;i++){
+                                nodes[i]->GetLocalDofList(&doflist[count],approximation,setenum);
+                                count+=ndof_list[i];
+                        }
+
+                        /*We now have something like: [0 1 0 2 1 2]. Offset by gsize, to get something like: [0 1 2 4 6 7]:*/
+                        count=0;
+                        for(i=0;i<numnodes;i++){
+                                for(j=0;j<ndof_list[i];j++){
+                                        doflist[count+j]+=ngdof_list_cumulative[i];
+                                }
+                                count+=ndof_list[i];
+                        }
+                }
+                else doflist=NULL;
+        }
+
+        /*Free ressources:*/
+        xDelete<int>(ndof_list);
+        xDelete<int>(ngdof_list_cumulative);
+
+        /*CLean-up and return*/
+        return doflist;
+}
+/*}}}*/
+int* GetGlobalDofList(Node** nodes,int numnodes,int setenum,int approximation){/*{{{*/
+
+
+        int  i,numdof,count;
+        int* ndof_list=NULL;
+        int *doflist = NULL;
+
+        if(numnodes){
+
+                /*Allocate:*/
+                ndof_list=xNew<int>(numnodes);
+
+                /*First, figure out size of doflist: */
+                numdof=0;
+                for(i=0;i<numnodes;i++){
+                        ndof_list[i]=nodes[i]->GetNumberOfDofs(approximation,setenum);
+                        numdof+=ndof_list[i];
+                }
+
+                if(numdof){
+                        /*Allocate: */
+                        doflist=xNew<int>(numdof);
+
+                        /*Populate: */
+                        count=0;
+                        for(i=0;i<numnodes;i++){
+                                nodes[i]->GetDofList(&doflist[count],approximation,setenum);
+                                count+=ndof_list[i];
+                        }
+                }
+                else doflist=NULL;
+        }
+        /*Free ressources:*/
+        xDelete<int>(ndof_list);
+
+        return doflist;
+}
+/*}}}*/
+int GetNumberOfDofs(Node** nodes,int numnodes,int setenum,int approximation){/*{{{*/
+
+
+        /*output: */
+        int numberofdofs=0;
+
+        for(int i=0;i<numnodes;i++){
+                numberofdofs+=nodes[i]->GetNumberOfDofs(approximation,setenum);
+        }
+
+        return numberofdofs;
+}
+/*}}}*/
+#ifdef _HAVE_DIAGNOSTIC_
+void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum){/*{{{*/
+
+
+        int* cs_array=NULL;
+
+        /*All nodes have the same Coordinate System*/
+        cs_array=xNew<int>(numnodes);
+        for(int i=0;i<numnodes;i++) cs_array[i]=cs_enum;
+
+        /*Call core*/
+        TransformInvStiffnessMatrixCoord(Ke,nodes,numnodes,cs_array);
+
+        /*Clean-up*/
+        xDelete<int>(cs_array);
+}
+/*}}}*/
+void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array){/*{{{*/
+
+
+        int     i,j;
+        int     numdofs   = 0;
+        IssmDouble *transform = NULL;
+        IssmDouble *values    = NULL;
+
+        /*Get total number of dofs*/
+        for(i=0;i<numnodes;i++){
+                switch(cs_array[i]){
+                        case XYEnum:   numdofs+=2; break;
+                        case XYZPEnum: numdofs+=4; break;
+                        default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Copy current stiffness matrix*/
+        values=xNew<IssmDouble>(Ke->nrows*Ke->ncols);
+        for(i=0;i<Ke->nrows;i++) for(j=0;j<Ke->ncols;j++) values[i*Ke->ncols+j]=Ke->values[i*Ke->ncols+j];
+
+        /*Get Coordinate Systems transform matrix*/
+        CoordinateSystemTransform(&transform,nodes,numnodes,cs_array);
+
+        /*Transform matrix: R*Ke*R^T */
+        TripleMultiply(transform,numdofs,numdofs,0,
+                                values,Ke->nrows,Ke->ncols,0,
+                                transform,numdofs,numdofs,1,
+                                &Ke->values[0],0);
+
+        /*Free Matrix*/
+        xDelete<IssmDouble>(transform);
+        xDelete<IssmDouble>(values);
+}
+/*}}}*/
+void TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int cs_enum){/*{{{*/
+
+        int* cs_array=NULL;
+
+        /*All nodes have the same Coordinate System*/
+        cs_array=xNew<int>(numnodes);
+        for(int i=0;i<numnodes;i++) cs_array[i]=cs_enum;
+
+        /*Call core*/
+        TransformLoadVectorCoord(pe,nodes,numnodes,cs_array);
+
+        /*Clean-up*/
+        xDelete<int>(cs_array);
+}
+/*}}}*/
+void TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int* cs_array){/*{{{*/
+
+
+        int     i;
+        int     numdofs   = 0;
+        IssmDouble *transform = NULL;
+        IssmDouble *values    = NULL;
+
+        /*Get total number of dofs*/
+        for(i=0;i<numnodes;i++){
+                switch(cs_array[i]){
+                        case XYEnum:   numdofs+=2; break;
+                        case XYZPEnum: numdofs+=4; break;
+                        default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Copy current load vector*/
+        values=xNew<IssmDouble>(pe->nrows);
+        for(i=0;i<pe->nrows;i++) values[i]=pe->values[i];
+
+        /*Get Coordinate Systems transform matrix*/
+        CoordinateSystemTransform(&transform,nodes,numnodes,cs_array);
+
+        /*Transform matrix: R^T*pe */
+        MatrixMultiply(transform,numdofs,numdofs,1,
+                                values,pe->nrows,1,0,
+                                &pe->values[0],0);
+
+        /*Free Matrices*/
+        xDelete<IssmDouble>(transform);
+        xDelete<IssmDouble>(values);
+}
+/*}}}*/
+void TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int cs_enum){/*{{{*/
+
+
+        int* cs_array=NULL;
+
+        /*All nodes have the same Coordinate System*/
+        cs_array=xNew<int>(numnodes);
+        for(int i=0;i<numnodes;i++) cs_array[i]=cs_enum;
+
+        /*Call core*/
+        TransformSolutionCoord(solution,nodes,numnodes,cs_array);
+
+        /*Clean-up*/
+        xDelete<int>(cs_array);
+}
+/*}}}*/
+void TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int* cs_array){/*{{{*/
+
+
+        int     i;
+        int     numdofs   = 0;
+        IssmDouble *transform = NULL;
+        IssmDouble *values    = NULL;
+
+        /*Get total number of dofs*/
+        for(i=0;i<numnodes;i++){
+                switch(cs_array[i]){
+                        case XYEnum:   numdofs+=2; break;
+                        case XYZPEnum: numdofs+=4; break;
+                        default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Copy current solution vector*/
+        values=xNew<IssmDouble>(numdofs);
+        for(i=0;i<numdofs;i++) values[i]=solution[i];
+
+        /*Get Coordinate Systems transform matrix*/
+        CoordinateSystemTransform(&transform,nodes,numnodes,cs_array);
+
+        /*Transform matrix: R*U */
+        MatrixMultiply(transform,numdofs,numdofs,0,
+                                values,numdofs,1,0,
+                                &solution[0],0);
+
+        /*Free Matrices*/
+        xDelete<IssmDouble>(transform);
+        xDelete<IssmDouble>(values);
+}
+/*}}}*/
+void TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum){/*{{{*/
+
+
+        int* cs_array=NULL;
+
+        /*All nodes have the same Coordinate System*/
+        cs_array=xNew<int>(numnodes);
+        for(int i=0;i<numnodes;i++) cs_array[i]=cs_enum;
+
+        /*Call core*/
+        TransformStiffnessMatrixCoord(Ke,nodes,numnodes,cs_array);
+
+        /*Clean-up*/
+        xDelete<int>(cs_array);
+}
+/*}}}*/
+void TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array){/*{{{*/
+
+
+        int     i,j;
+        int     numdofs   = 0;
+        IssmDouble *transform = NULL;
+        IssmDouble *values    = NULL;
+
+        /*Get total number of dofs*/
+        for(i=0;i<numnodes;i++){
+                switch(cs_array[i]){
+                        case XYEnum:   numdofs+=2; break;
+                        case XYZPEnum: numdofs+=4; break;
+                        default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Copy current stiffness matrix*/
+        values=xNew<IssmDouble>(Ke->nrows*Ke->ncols);
+        for(i=0;i<Ke->nrows;i++) for(j=0;j<Ke->ncols;j++) values[i*Ke->ncols+j]=Ke->values[i*Ke->ncols+j];
+
+        /*Get Coordinate Systems transform matrix*/
+        CoordinateSystemTransform(&transform,nodes,numnodes,cs_array);
+
+        /*Transform matrix: R^T*Ke*R */
+        TripleMultiply(transform,numdofs,numdofs,1,
+                                values,Ke->nrows,Ke->ncols,0,
+                                transform,numdofs,numdofs,0,
+                                &Ke->values[0],0);
+
+        /*Free Matrix*/
+        xDelete<IssmDouble>(transform);
+        xDelete<IssmDouble>(values);
+}
+/*}}}*/
+void CoordinateSystemTransform(IssmDouble** ptransform,Node** nodes,int numnodes,int* cs_array){/*{{{*/
+
+
+        int     i,counter;
+        int     numdofs           = 0;
+        IssmDouble  norm;
+        IssmDouble *transform         = NULL;
+        IssmDouble *values            = NULL;
+        IssmDouble  coord_system[3][3];
+
+        /*Some checks in debugging mode*/
+        _assert_(numnodes && nodes);
+
+        /*Get total number of dofs*/
+        for(i=0;i<numnodes;i++){
+                switch(cs_array[i]){
+                        case XYEnum:   numdofs+=2; break;
+                        case XYZPEnum: numdofs+=4; break;
+                        default: _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Allocate and initialize transform matrix*/
+        transform=xNew<IssmDouble>(numdofs*numdofs);
+        for(i=0;i<numdofs*numdofs;i++) transform[i]=0.0;
+
+        /*Create transform matrix for all nodes (x,y for 2d and x,y,z for 3d). It is a block matrix
+         *for 3 nodes:
+
+         *     | T1 0  0 |
+         * Q = | 0  T2 0 |
+         *     | 0  0  T3|
+         *
+         * Where T1 is the transform matrix for node 1. It is a simple copy of the coordinate system
+         * associated to this node*/
+        counter=0;
+        for(i=0;i<numnodes;i++){
+                nodes[i]->GetCoordinateSystem(&coord_system[0][0]);
+                switch(cs_array[i]){
+                        case XYEnum:
+                                /*We remove the z component, we need to renormalize x and y: x=[x1 x2 0] y=[-x2 x1 0]*/
+                                norm = sqrt( coord_system[0][0]*coord_system[0][0] + coord_system[1][0]*coord_system[1][0]); _assert_(norm>1.e-4);
+                                transform[(numdofs)*(counter+0) + counter+0] =   coord_system[0][0]/norm;
+                                transform[(numdofs)*(counter+0) + counter+1] = - coord_system[1][0]/norm;
+                                transform[(numdofs)*(counter+1) + counter+0] =   coord_system[1][0]/norm;
+                                transform[(numdofs)*(counter+1) + counter+1] =   coord_system[0][0]/norm;
+                                counter+=2;
+                                break;
+                        case XYZPEnum:
+                                /*Only the first 3 coordinates are changed (x,y,z), leave the others (P) unchanged*/
+                                transform[(numdofs)*(counter+0) + counter+0] = coord_system[0][0];
+                                transform[(numdofs)*(counter+0) + counter+1] = coord_system[0][1];
+                                transform[(numdofs)*(counter+0) + counter+2] = coord_system[0][2];
+                                transform[(numdofs)*(counter+1) + counter+0] = coord_system[1][0];
+                                transform[(numdofs)*(counter+1) + counter+1] = coord_system[1][1];
+                                transform[(numdofs)*(counter+1) + counter+2] = coord_system[1][2];
+                                transform[(numdofs)*(counter+2) + counter+0] = coord_system[2][0];
+                                transform[(numdofs)*(counter+2) + counter+1] = coord_system[2][1];
+                                transform[(numdofs)*(counter+2) + counter+2] = coord_system[2][2];
+                                transform[(numdofs)*(counter+3) + counter+3] = 1.0;
+                                counter+=4;
+                                break;
+                        default:
+                                _error_("Coordinate system " << EnumToStringx(cs_array[i]) << " not supported yet");
+                }
+        }
+
+        /*Assign output pointer*/
+        *ptransform=transform;
+}
+/*}}}*/
+#endif

issm/trunk-jpl/src/c/classes/objects/Node.h

@@ -18 +18 @@
 template <class doubletype> class  Vector;
 template <class doubletype> class  Matrix;
+class ElementVector;
+class ElementMatrix;
 #include "../Update.h"
 /*}}}*/
@@ -100 +102 @@
 };
 
+/*Methods inherent to Node: */
+int* GetLocalDofList(Node** nodes,int numnodes,int setenum,int approximation);
+int* GetGlobalDofList(Node** nodes,int numnodes,int setenum,int approximation);
+int  GetNumberOfDofs(Node** nodes,int numnodes,int setenum,int approximation);
+#ifdef _HAVE_DIAGNOSTIC_
+void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
+void TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array);
+void TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int cs_enum);
+void TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int* cs_array);
+void TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int cs_enum);
+void TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int* cs_array);
+void TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
+void TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array);
+void CoordinateSystemTransform(IssmDouble** ptransform,Node** nodes,int numnodes,int* cs_array);
+#endif
+
 #endif  /* _NODE_H_ */

issm/trunk-jpl/src/c/classes/objects/Profiler.cpp

@@ -11 +11 @@
 
 #include "./Profiler.h"
+#include "./Params/DoubleParam.h"
 /*}}}*/
 

issm/trunk-jpl/src/c/classes/objects/Vertex.cpp

@@ -238 +238 @@
 }
 /*}}}*/
+
+/*Methods relating to Vertex, but not internal methods: */
+void GetVerticesCoordinates(IssmDouble* xyz,Vertex** vertices, int numvertices){ /*{{{*/
+
+        _assert_(vertices);
+        _assert_(xyz);
+
+        for(int i=0;i<numvertices;i++) {
+                xyz[i*3+0]=vertices[i]->GetX();
+                xyz[i*3+1]=vertices[i]->GetY();
+                xyz[i*3+2]=vertices[i]->GetZ();
+        }
+}/*}}}*/

issm/trunk-jpl/src/c/classes/objects/Vertex.h

@@ -59 +59 @@
                 void       VertexCoordinates(Vector<IssmDouble>* vx,Vector<IssmDouble>* vy,Vector<IssmDouble>* vz);
 };
+
+/*Methods relating to Vertex object: */
+void GetVerticesCoordinates(IssmDouble* xyz,Vertex** vertices, int numvertices);
+
 #endif  /* _VERTEX_H */

issm/trunk-jpl/src/c/modules/ConfigureObjectsx/ConfigureObjectsx.cpp

@@ -8 +8 @@
 #include "../../shared/io/io.h"
 #include "../../toolkits/toolkits.h"
+#include "../../classes/classes.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"
 

issm/trunk-jpl/src/c/modules/GroundinglineMigrationx/GroundinglineMigrationx.cpp

@@ -8 +8 @@
 #include "../../EnumDefinitions/EnumDefinitions.h"
 #include "../../Container/Container.h"
+#include "../../classes/classes.h"
 #include "./GroundinglineMigrationx.h"
 

issm/trunk-jpl/src/c/modules/InputControlUpdatex/InputControlUpdatex.cpp

@@ -5 +5 @@
 #include "./InputControlUpdatex.h"
 #include "../../shared/shared.h"
+#include "../../classes/classes.h"
 #include "../../toolkits/toolkits.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"

issm/trunk-jpl/src/c/modules/InputConvergencex/InputConvergencex.cpp

@@ -5 +5 @@
 #include "../../shared/shared.h"
 #include "../../shared/io/io.h"
+#include "../../classes/classes.h"
 #include "../../toolkits/toolkits.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"

issm/trunk-jpl/src/c/modules/InputDuplicatex/InputDuplicatex.cpp

@@ -5 +5 @@
 #include "./InputDuplicatex.h"
 #include "../../shared/shared.h"
+#include "../../classes/classes.h"
 #include "../../toolkits/toolkits.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"

issm/trunk-jpl/src/c/modules/InputScalex/InputScalex.cpp

@@ -6 +6 @@
 #include "../../shared/shared.h"
 #include "../../toolkits/toolkits.h"
+#include "../../classes/classes.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"
 

issm/trunk-jpl/src/c/modules/InputToResultx/InputToResultx.cpp

@@ -5 +5 @@
 #include "./InputToResultx.h"
 #include "../../shared/shared.h"
+#include "../../classes/classes.h"
 #include "../../toolkits/toolkits.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"

issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp

@@ -10 +10 @@
 
 #include "../../shared/shared.h"
+#include "../../classes/classes.h"
 #include "../../shared/io/io.h"
 #include "./ModelProcessorx.h"

issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp

@@ -11 +11 @@
 #include "../../shared/shared.h"
 #include "../../shared/io/io.h"
+#include "../../classes/classes.h"
 #include "./ModelProcessorx.h"
 

issm/trunk-jpl/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp

@@ -4 +4 @@
 
 #include "../../shared/shared.h"
+#include "../../classes/classes.h"
 #include "../../EnumDefinitions/EnumDefinitions.h"
 

issm/trunk-jpl/src/c/shared/Elements/Arrhenius.cpp

@@ -3 +3 @@
  */
 
+#include <math.h>
 #include "./elements.h"
-#include <math.h>
+#include "../Exceptions/exceptions.h"
 
 IssmDouble Arrhenius(IssmDouble temperature,IssmDouble depth,IssmDouble n){

issm/trunk-jpl/src/c/shared/Elements/ComputeDelta18oTemperaturePrecipitation.cpp

@@ -5 +5 @@
 
 #include "./elements.h"
+#include "../Numerics/numerics.h"
 
 void ComputeDelta18oTemperaturePrecipitation(IssmDouble Delta18oSurfacePresent, IssmDouble Delta18oSurfaceLgm, IssmDouble Delta18oSurfaceTime,

issm/trunk-jpl/src/c/shared/Elements/Paterson.cpp

@@ -7 +7 @@
 #include <math.h>
 
-#include "../../shared/Numerics/types.h"
+#include "../Numerics/types.h"
 
 IssmDouble Paterson(IssmDouble temperature){

issm/trunk-jpl/src/c/shared/Elements/PddSurfaceMassBalance.cpp

@@ -4 +4 @@
 
 #include "./elements.h"
+#include "../Numerics/numerics.h"
 
 IssmDouble PddSurfaceMassBlance(IssmDouble* monthlytemperatures, IssmDouble* monthlyprec, IssmDouble* pdds, IssmDouble* pds, IssmDouble signorm, IssmDouble yts, IssmDouble h, IssmDouble s, IssmDouble rho_ice, IssmDouble rho_water, IssmDouble desfac, IssmDouble s0p){ 

issm/trunk-jpl/src/c/shared/Elements/PrintArrays.cpp

@@ -1 +1 @@
 
 #include "./elements.h"
+#include "../io/Print/Print.h"
 using namespace std;
 

issm/trunk-jpl/src/c/shared/Elements/elements.h

@@ -6 +6 @@
 #define _SHARED_ELEMENTS_H_
 
-#include "../../classes/objects/objects.h"
-#include "../../Container/Container.h"
+#include "../Numerics/types.h"
 class ElementMatrix;
 class ElementVector;
 class Vertex;
+class Node;
 
 IssmDouble Paterson(IssmDouble temperature);
@@ -22 +22 @@
                                      IssmDouble* TemperaturesLgm, IssmDouble* TemperaturesPresentday, 
                                              IssmDouble* monthlytemperaturesout, IssmDouble* monthlyprecout);
-void   GetVerticesCoordinates(IssmDouble* xyz,Vertex** vertices,int numvertices);
-int    GetNumberOfDofs( Node** nodes,int numnodes,int setenum,int approximation_enum);
-int*   GetLocalDofList( Node** nodes,int numnodes,int setenum,int approximation_enum);
-int*   GetGlobalDofList(Node** nodes,int numnodes,int setenum,int approximation_enum);
-
-#ifdef _HAVE_DIAGNOSTIC_
-void   CoordinateSystemTransform(IssmDouble** ptransform,Node** nodes,int numnodes,int* cs_array);
-void   TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
-void   TransformInvStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array);
-void   TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int cs_enum);
-void   TransformStiffnessMatrixCoord(ElementMatrix* Ke,Node** nodes,int numnodes,int* cs_array);
-void   TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int cs_enum);
-void   TransformLoadVectorCoord(ElementVector* pe,Node** nodes,int numnodes,int* cs_array);
-void   TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int cs_enum);
-void   TransformSolutionCoord(IssmDouble* solution,Node** nodes,int numnodes,int* cs_array);
-#endif
 
 /*Print arrays*/

issm/trunk-jpl/src/c/shared/Exceptions/Exceptions.cpp

@@ -9 +9 @@
 #endif
 
-#include "../shared.h"
+#include "./exceptions.h"
+#include "../io/Print/Print.h"
+#include "../io/Comm/Comm.h"
 
 ErrorException::ErrorException(const string &what_arg){/*{{{*/