Changeset 16137 for issm/trunk/src/c/solutionsequences

Timestamp:

09/16/13 09:43:55 (12 years ago)

Author:

Mathieu Morlighem

Message:

merged trunk-jpl and trunk for revision 16135

Location:

issm/trunk

Files:

• . (modified) (2 props)
• src (modified) (1 prop)
• src/c (modified) (1 prop)
• src/c/solutionsequences (modified) (1 prop)
• src/c/solutionsequences/CMakeLists.txt (deleted)
• src/c/solutionsequences/convergence.cpp (modified) (1 diff)
• src/c/solutionsequences/solutionsequence_adjoint_linear.cpp (modified) (1 diff)
• src/c/solutionsequences/solutionsequence_hydro_nonlinear.cpp (modified) (10 diffs)
• src/c/solutionsequences/solutionsequence_linear.cpp (modified) (2 diffs)
• src/c/solutionsequences/solutionsequence_newton.cpp (modified) (4 diffs)
• src/c/solutionsequences/solutionsequence_nonlinear.cpp (modified) (5 diffs)
• src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp (modified) (6 diffs)
• src/c/solutionsequences/solutionsequence_thermal_nonlinear.cpp (modified) (2 diffs)
• src/c/solutionsequences/solutionsequences.h (modified) (1 diff)

issm/trunk

@@ +1 @@
+nightlylog
+configure.sh
 par
 ad

@@ +1 @@
+nightlylog
+configure.sh
 par
 ad

issm/trunk/src/c

@@ -14 +14 @@
 probe.results
 stXXXX*
-
+.deps
+.dirstamp

@@ -14 +14 @@
 probe.results
 stXXXX*
-
+.deps
+.dirstamp

issm/trunk/src/c/solutionsequences/convergence.cpp

@@ -40 +40 @@
 
         /*get convergence options*/
-        parameters->FindParam(&eps_res,DiagnosticRestolEnum);
-        parameters->FindParam(&eps_rel,DiagnosticReltolEnum);
-        parameters->FindParam(&eps_abs,DiagnosticAbstolEnum);
+        parameters->FindParam(&eps_res,StressbalanceRestolEnum);
+        parameters->FindParam(&eps_rel,StressbalanceReltolEnum);
+        parameters->FindParam(&eps_abs,StressbalanceAbstolEnum);
         parameters->FindParam(&yts,ConstantsYtsEnum);
 

issm/trunk/src/c/solutionsequences/solutionsequence_adjoint_linear.cpp

@@ -26 +26 @@
         femmodel->UpdateConstraintsx();
 
-        femmodel->SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL);
+        SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL,femmodel);
         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
         Reduceloadx(pf, Kfs, ys,true); delete Kfs; //true means spc = 0
         Solverx(&uf, Kff, pf, NULL, df, femmodel->parameters); delete Kff; delete pf; delete df;
         Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters,true); delete ys; //true means spc0
-        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
+        InputUpdateFromSolutionx(femmodel,ug);
         delete ug; delete uf;
 }

issm/trunk/src/c/solutionsequences/solutionsequence_hydro_nonlinear.cpp

@@ -10 +10 @@
 void solutionsequence_hydro_nonlinear(FemModel* femmodel){
         /*solution : */
-        Vector<IssmDouble>* ug_sed=NULL;
+        Vector<IssmDouble>* ug_sed=NULL; 
+        Vector<IssmDouble>* uf_sed=NULL; 
+        Vector<IssmDouble>* uf_sed_sub_iter=NULL; 
+        Vector<IssmDouble>* ug_sed_main_iter=NULL;
+
         Vector<IssmDouble>* ug_epl=NULL; 
-        Vector<IssmDouble>* uf=NULL;
-        Vector<IssmDouble>* uf_int_iter=NULL; 
-        Vector<IssmDouble>* ug_sed_main_iter=NULL; 
-        Vector<IssmDouble>* ug_epl_main_iter=NULL; 
+        Vector<IssmDouble>* uf_epl=NULL;
+        Vector<IssmDouble>* uf_epl_sub_iter=NULL; 
+        Vector<IssmDouble>* ug_epl_main_iter=NULL;
+
         Vector<IssmDouble>* ys=NULL; 
-        Vector<IssmDouble>* dug=NULL; 
-        Vector<IssmDouble>* old_ug=NULL; 
-        
+        Vector<IssmDouble>* dug=NULL;
+
         Matrix<IssmDouble>* Kff=NULL;
         Matrix<IssmDouble>* Kfs=NULL;
@@ -37 +40 @@
 
         /*Recover parameters: */
-        femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);//FIXME
+        femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
         femmodel->parameters->FindParam(&isefficientlayer,HydrologydcIsefficientlayerEnum);
         femmodel->parameters->FindParam(&eps_hyd,HydrologydcRelTolEnum);
@@ -43 +46 @@
         hydro_maxiter=150;
         hydrocount=1;
-
-        /*Iteration on the two layers*/
-        femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
-        GetSolutionFromInputsx(&ug_sed, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
+        hydroconverged=false;
+
+        /*Retrieve inputs as the initial state for the non linear iteration*/
+        //femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
+        GetSolutionFromInputsx(&ug_sed,femmodel);
+
         if(isefficientlayer) {
                 femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
-                GetSolutionFromInputsx(&ug_epl, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
+                GetSolutionFromInputsx(&ug_epl,femmodel);
         }
 
-        hydroconverged=false;
+        /*Iteration on the two layers*/
         for(;;){
                 sedcount=1;
                 eplcount=1;
                 //save pointer to old velocity
-                delete ug_sed_main_iter;
-                ug_sed_main_iter=ug_sed;
+                ug_sed_main_iter=ug_sed->Duplicate();
+                ug_sed->Copy(ug_sed_main_iter);
                 if(isefficientlayer){
-                        delete ug_epl_main_iter;
-                        ug_epl_main_iter=ug_epl;
+                        ug_epl_main_iter=ug_epl->Duplicate();
+                        ug_epl->Copy(ug_epl_main_iter);
                 }
 
                 femmodel->SetCurrentConfiguration(HydrologyDCInefficientAnalysisEnum);
-                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
-                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
+                InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
+                InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
                 femmodel->UpdateConstraintsx();
                 femmodel->parameters->SetParam(HydrologySedimentEnum,HydrologyLayerEnum);
@@ -74 +79 @@
                 for(;;){
                         femmodel->HydrologyTransferx();
-                        femmodel->SystemMatricesx(&Kff, &Kfs, &pf,&df, &sediment_kmax);
+                        SystemMatricesx(&Kff,&Kfs,&pf,&df,&sediment_kmax,femmodel);
                         CreateNodalConstraintsx(&ys,femmodel->nodes,HydrologyDCInefficientAnalysisEnum);
                         Reduceloadx(pf,Kfs,ys); delete Kfs;
-                        delete uf;
-                        Solverx(&uf, Kff, pf,uf_int_iter, df, femmodel->parameters);
-                        delete uf_int_iter; uf_int_iter=uf->Duplicate();
-                        if(sedcount>1)delete ug_sed; /*Not on first time to avoid deleting ug_sed_main_iter*/
+                        delete uf_sed;
+                        Solverx(&uf_sed,Kff,pf,uf_sed_sub_iter,df,femmodel->parameters);
                         delete Kff; delete pf; delete df;
-
-                        Mergesolutionfromftogx(&ug_sed,uf,ys,femmodel->nodes,femmodel->parameters); delete ys;
-                        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_sed);
-                        ConstraintsStatex(&constraints_converged,&num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
+                        delete uf_sed_sub_iter;
+                        uf_sed_sub_iter=uf_sed->Duplicate();
+                        uf_sed->Copy(uf_sed_sub_iter);
+                        delete ug_sed;
+                        Mergesolutionfromftogx(&ug_sed,uf_sed,ys,femmodel->nodes,femmodel->parameters); delete ys;
+                        InputUpdateFromSolutionx(femmodel,ug_sed);
+                        ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
 
                         if (!sedconverged){
@@ -98 +104 @@
                         if(sedconverged){
                                 femmodel->parameters->SetParam(sediment_kmax,HydrologySedimentKmaxEnum);
-                                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sedconverged,ConvergedEnum);
-                                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_sed);
-                                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sediment_kmax,HydrologySedimentKmaxEnum);
+                                InputUpdateFromConstantx(femmodel,sedconverged,ConvergedEnum);
+                                InputUpdateFromSolutionx(femmodel,ug_sed);
+                                InputUpdateFromConstantx(femmodel,sediment_kmax,HydrologySedimentKmaxEnum);
                                 break;
                         }
@@ -108 +114 @@
                 if(isefficientlayer){
                         femmodel->SetCurrentConfiguration(HydrologyDCEfficientAnalysisEnum);
-                        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
-                        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
+                        InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
+                        InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
                         femmodel->HydrologyEPLupdateDomainx();
                         femmodel->parameters->SetParam(HydrologyEfficientEnum,HydrologyLayerEnum);
+
+                        /*Iteration on the EPL layer*/
                         eplconverged = false;
-                        /*Iteration on the EPL layer*/
                         for(;;){
                                 femmodel->HydrologyTransferx();
-                                femmodel->SystemMatricesx(&Kff, &Kfs, &pf,&df,NULL);
+                                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
                                 CreateNodalConstraintsx(&ys,femmodel->nodes,HydrologyDCEfficientAnalysisEnum);
                                 Reduceloadx(pf,Kfs,ys); delete Kfs;
-                                delete uf;
-                                Solverx(&uf, Kff, pf,uf_int_iter, df, femmodel->parameters);
-                                delete uf_int_iter; uf_int_iter=uf->Duplicate();
-                                if(eplcount>1) delete ug_epl; 
-                                delete Kff;delete pf;
-                                delete df;
-                                Mergesolutionfromftogx(&ug_epl,uf,ys,femmodel->nodes,femmodel->parameters); delete ys;
-                                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_epl);
-                                ConstraintsStatex(&constraints_converged,&num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
+                                delete uf_epl;
+                                Solverx(&uf_epl,Kff,pf,uf_epl_sub_iter,df,femmodel->parameters);
+                                delete Kff; delete pf; delete df;
+                                delete uf_epl_sub_iter; 
+                                uf_epl_sub_iter=uf_epl->Duplicate();
+                                uf_epl->Copy(uf_epl_sub_iter);
+                                delete ug_epl; 
+                                Mergesolutionfromftogx(&ug_epl,uf_epl,ys,femmodel->nodes,femmodel->parameters); delete ys;
+                                InputUpdateFromSolutionx(femmodel,ug_epl);
+                                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
                                 femmodel->HydrologyEPLupdateDomainx();                  
-                                
+
                                 if (!eplconverged){
                                         if(VerboseConvergence()) _printf0_("   # EPL unstable constraints = " << num_unstable_constraints << "\n");
@@ -140 +148 @@
 
                                 if(eplconverged){
-                                        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,eplconverged,ConvergedEnum);
-                                        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,sediment_kmax,MeltingOffsetEnum);
-                                        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug_epl);
+                                        InputUpdateFromConstantx(femmodel,eplconverged,ConvergedEnum);
+                                        InputUpdateFromConstantx(femmodel,sediment_kmax,MeltingOffsetEnum);
+                                        InputUpdateFromSolutionx(femmodel,ug_epl);
                                         break;
                                 }
@@ -153 +161 @@
                         ug_sed_main_iter->Copy(dug);    
                         dug->AYPX(ug_sed,-1.0);
-                        ndu_sed=dug->Norm(NORM_TWO); nu_sed=ug_sed_main_iter->Norm(NORM_TWO);
+                        ndu_sed=dug->Norm(NORM_TWO); 
+                        delete dug;
+                        nu_sed=ug_sed_main_iter->Norm(NORM_TWO);
+                        delete ug_sed_main_iter;
                         if (xIsNan<IssmDouble>(ndu_sed) || xIsNan<IssmDouble>(nu_sed)) _error_("Sed convergence criterion is NaN!");
                         if (!xIsNan<IssmDouble>(eps_hyd)){
@@ -171 +182 @@
                                         dug->AYPX(ug_epl,-1.0);
                                         ndu_epl=dug->Norm(NORM_TWO); 
+                                        delete dug;
                                         nu_epl=ug_epl_main_iter->Norm(NORM_TWO);
-
+                                        delete ug_epl_main_iter;
                                         if (xIsNan<IssmDouble>(ndu_epl) || xIsNan<IssmDouble>(nu_epl)) _error_("EPL convergence criterion is NaN!");
                                         if (ndu_epl==0.0 && nu_epl==0.0) nu_epl=1.0e-6; /*Hacking the case where the EPL is used but empty*/
@@ -194 +206 @@
                 if(hydroconverged)break;
         }
-        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_sed);
-        if(isefficientlayer)InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_epl);
+
+        InputUpdateFromSolutionx(femmodel,ug_sed);
+        if(isefficientlayer)InputUpdateFromSolutionx(femmodel,ug_epl);
 
         /*Free ressources: */
         delete ug_epl;
         delete ug_sed;
-        delete uf;
-        delete uf_int_iter;
-        delete ug_sed_main_iter;
-        delete ug_epl_main_iter;
-        delete dug;
+        delete uf_sed;
+        delete uf_epl;
+        delete uf_sed_sub_iter;
+        delete uf_epl_sub_iter;
+        //delete dug;
 }

issm/trunk/src/c/solutionsequences/solutionsequence_linear.cpp

@@ -24 +24 @@
         femmodel->UpdateConstraintsx();
 
-        femmodel->SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL);
+        SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
         Reduceloadx(pf, Kfs, ys); delete Kfs;
@@ -35 +35 @@
 //#endif
         Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters);delete uf; delete ys;
-        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); 
+        InputUpdateFromSolutionx(femmodel,ug); 
         delete ug;  
 }

issm/trunk/src/c/solutionsequences/solutionsequence_newton.cpp

@@ -33 +33 @@
 
         /*Recover parameters: */
-        femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
+        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
-        femmodel->parameters->FindParam(&newton,DiagnosticIsnewtonEnum);
+        femmodel->parameters->FindParam(&newton,StressbalanceIsnewtonEnum);
         femmodel->UpdateConstraintsx();
 
@@ -42 +42 @@
 
         /*Start non-linear iteration using input velocity: */
-        GetSolutionFromInputsx(&ug,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
+        GetSolutionFromInputsx(&ug,femmodel);
         Reducevectorgtofx(&uf,ug,femmodel->nodes,femmodel->parameters);
 
         //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
-        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,converged,ConvergedEnum);
-        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
+        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
+        InputUpdateFromSolutionx(femmodel,ug);
 
         for(;;){
@@ -56 +56 @@
                 /*Solver forward model*/
                 if(count==1 || newton==2){
-                        femmodel->SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL);
+                        SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
                         CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
                         Reduceloadx(pf,Kfs,ys);delete Kfs;
                         Solverx(&uf,Kff,pf,old_uf,df,femmodel->parameters);delete df; delete Kff; delete pf;
                         Mergesolutionfromftogx(&ug,uf,ys,femmodel->nodes,femmodel->parameters);delete ys;
-                        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
+                        InputUpdateFromSolutionx(femmodel,ug);
                         delete old_ug;old_ug=ug;
                         delete old_uf;old_uf=uf;
@@ -68 +68 @@
 
                 /*Prepare next iteration using Newton's method*/
-                femmodel->SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL);delete df;
+                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);delete df;
                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
                 Reduceloadx(pf,Kfs,ys);delete Kfs;
 
                 pJf=pf->Duplicate();
-                Kff->MatMult(uf,pJf);// delete Kff);
-                pJf->Scale(-1.0); pJf->AXPY(pf,+1.0);     //delete pf);
+                Kff->MatMult(uf,pJf);
+                pJf->Scale(-1.0); pJf->AXPY(pf,+1.0);
 
-                femmodel->CreateJacobianMatrixx(&Jff,kmax);
+                CreateJacobianMatrixx(&Jff,femmodel,kmax);
                 Solverx(&duf,Jff,pJf,NULL,NULL,femmodel->parameters); delete Jff; delete pJf;
                 uf->AXPY(duf, 1.0); delete duf;
                 Mergesolutionfromftogx(&ug,uf,ys,femmodel->nodes,femmodel->parameters);delete ys;
-                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ug);
+                InputUpdateFromSolutionx(femmodel,ug);
 
                 /*Check convergence*/

issm/trunk/src/c/solutionsequences/solutionsequence_nonlinear.cpp

@@ -33 +33 @@
 
         /*Recover parameters: */
-        femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum);
-        femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
+        femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
+        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
         femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
         femmodel->UpdateConstraintsx();
@@ -47 +47 @@
 
         /*Start non-linear iteration using input velocity: */
-        GetSolutionFromInputsx(&ug, femmodel->elements, femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
+        GetSolutionFromInputsx(&ug,femmodel);
         Reducevectorgtofx(&uf, ug, femmodel->nodes,femmodel->parameters);
 
         //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
-        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
-        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
+        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
+        InputUpdateFromSolutionx(femmodel,ug);
 
         for(;;){
@@ -60 +60 @@
                 delete ug;
 
-                femmodel->SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL);
+                SystemMatricesx(&Kff,&Kfs,&pf,&df,NULL,femmodel);
                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
                 Reduceloadx(pf, Kfs, ys); delete Kfs;
@@ -67 +67 @@
 
                 convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters); delete Kff; delete pf; delete df;
-                InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
-                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
+                InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
+                InputUpdateFromSolutionx(femmodel,ug);
 
-                ConstraintsStatex(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
+                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
                 if(VerboseConvergence()) _printf0_("   number of unstable constraints: " << num_unstable_constraints << "\n");
 
@@ -93 +93 @@
                         _printf0_("   maximum number of nonlinear iterations (" << max_nonlinear_iterations << ") exceeded\n"); 
                         converged=true;
-                        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
-                        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);               
+                        InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
+                        InputUpdateFromSolutionx(femmodel,ug);          
                         bool max_iteration_state=true;
                         int tempStep=1;

issm/trunk/src/c/solutionsequences/solutionsequence_stokescoupling_nonlinear.cpp

@@ -1 @@
-/*!\file: solutionsequence_stokescoupling_nonlinear.cpp
- * \brief: core of the coupling between stokes and macayealpattyn
+/*!\file: solutionsequence_FScoupling_nonlinear.cpp
+ * \brief: core of the coupling between FS and SSAHO
  */ 
 
@@ -9 +9 @@
 #include "../modules/modules.h"
 
-void solutionsequence_stokescoupling_nonlinear(FemModel* femmodel,bool conserve_loads){
+void solutionsequence_FScoupling_nonlinear(FemModel* femmodel,bool conserve_loads){
 
         /*intermediary: */
@@ -35 +35 @@
 
         /*Recover parameters: */
-        femmodel->parameters->FindParam(&min_mechanical_constraints,DiagnosticRiftPenaltyThresholdEnum);
-        femmodel->parameters->FindParam(&max_nonlinear_iterations,DiagnosticMaxiterEnum);
+        femmodel->parameters->FindParam(&min_mechanical_constraints,StressbalanceRiftPenaltyThresholdEnum);
+        femmodel->parameters->FindParam(&max_nonlinear_iterations,StressbalanceMaxiterEnum);
         femmodel->UpdateConstraintsx();
 
@@ -43 +43 @@
 
         /*First get ug_horiz:*/
-        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
-        GetSolutionFromInputsx(&ug_horiz, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters);
+        femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
+        GetSolutionFromInputsx(&ug_horiz,femmodel);
         Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodes,femmodel->parameters);
 
         for(;;){
 
-                /*First diagnostic horiz:*/
-                femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
+                /*First stressbalance horiz:*/
+                femmodel->SetCurrentConfiguration(StressbalanceAnalysisEnum);
                 femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
 
                 //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
-                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
+                InputUpdateFromSolutionx(femmodel,ug_horiz);
                 delete ug_horiz;
 
@@ -61 +61 @@
 
                 /*solve: */
-                femmodel->SystemMatricesx(&Kff_horiz, &Kfs_horiz, &pf_horiz, &df_horiz, NULL);
+                SystemMatricesx(&Kff_horiz, &Kfs_horiz, &pf_horiz, &df_horiz, NULL,femmodel);
                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
                 Reduceloadx(pf_horiz, Kfs_horiz, ys); delete Kfs_horiz;
                 Solverx(&uf_horiz, Kff_horiz, pf_horiz, old_uf_horiz, df_horiz,femmodel->parameters);
                 Mergesolutionfromftogx(&ug_horiz, uf_horiz,ys,femmodel->nodes,femmodel->parameters); delete ys;
-                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
+                InputUpdateFromSolutionx(femmodel,ug_horiz);
 
                 convergence(&converged,Kff_horiz,pf_horiz,uf_horiz,old_uf_horiz,femmodel->parameters); delete Kff_horiz; delete pf_horiz; delete df_horiz;
 
                 /*Second compute vertical velocity: */
-                femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
+                femmodel->SetCurrentConfiguration(StressbalanceVerticalAnalysisEnum);
                 femmodel->parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
 
                 /*solve: */
-                femmodel->SystemMatricesx(&Kff_vert, &Kfs_vert, &pf_vert,  &df_vert,NULL);
+                SystemMatricesx(&Kff_vert, &Kfs_vert, &pf_vert, &df_vert,NULL,femmodel);
                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
                 Reduceloadx(pf_vert, Kfs_vert, ys); delete Kfs_vert;
@@ -82 +82 @@
                 delete uf_vert; 
                 delete ys; 
-                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_vert);
+                InputUpdateFromSolutionx(femmodel,ug_vert);
                 delete ug_vert;
 

issm/trunk/src/c/solutionsequences/solutionsequence_thermal_nonlinear.cpp

@@ -41 +41 @@
         converged=false;
 
-        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,true,ResetPenaltiesEnum);
-        InputUpdateFromConstantx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,false,ConvergedEnum);
+        InputUpdateFromConstantx(femmodel,true,ResetPenaltiesEnum);
+        InputUpdateFromConstantx(femmodel,false,ConvergedEnum);
         femmodel->UpdateConstraintsx();
 
         for(;;){
 
-                femmodel->SystemMatricesx(&Kff, &Kfs, &pf,&df, &melting_offset);
+                delete tf_old; tf_old=tf;
+                SystemMatricesx(&Kff, &Kfs, &pf,&df, &melting_offset,femmodel);
                 CreateNodalConstraintsx(&ys,femmodel->nodes,configuration_type);
-                Reduceloadx(pf, Kfs, ys); delete Kfs; delete tf;
+                Reduceloadx(pf, Kfs, ys); delete Kfs;
                 Solverx(&tf, Kff, pf,tf_old, df, femmodel->parameters);
-                delete tf_old; tf_old=tf->Duplicate();
                 delete Kff;delete pf;delete tg; delete df;
                 Mergesolutionfromftogx(&tg, tf,ys,femmodel->nodes,femmodel->parameters); delete ys;
-                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,tg);
+                InputUpdateFromSolutionx(femmodel,tg);
 
-                ConstraintsStatex(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
+                ConstraintsStatex(&constraints_converged,&num_unstable_constraints,femmodel);
 
                 if (!converged){
@@ -68 +68 @@
                 count++;
 
-                InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
+                InputUpdateFromConstantx(femmodel,converged,ConvergedEnum);
 
                 if(converged)break;
         }
 
-        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);
-        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,melting_offset,MeltingOffsetEnum);
+        InputUpdateFromSolutionx(femmodel,tg);
+        InputUpdateFromConstantx(femmodel,melting_offset,MeltingOffsetEnum);
 
         /*Free ressources: */

issm/trunk/src/c/solutionsequences/solutionsequences.h

@@ -16 +16 @@
 void solutionsequence_nonlinear(FemModel* femmodel,bool conserve_loads);
 void solutionsequence_newton(FemModel* femmodel);
-void solutionsequence_stokescoupling_nonlinear(FemModel* femmodel,bool conserve_loads);
+void solutionsequence_FScoupling_nonlinear(FemModel* femmodel,bool conserve_loads);
 void solutionsequence_linear(FemModel* femmodel);
 void solutionsequence_adjoint_linear(FemModel* femmodel);

@@ +1 @@
+nightlylog
+configure.sh
 par
 ad

@@ -14 +14 @@
 probe.results
 stXXXX*
-
+.deps
+.dirstamp