Changeset 6580

Timestamp:

11/15/10 13:55:22 (14 years ago)

Author:

Mathieu Morlighem

Message:

Some cleaning: parameters not needed for verbose

Location:

issm/trunk/src/c

Files:

• modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp (modified) (1 diff)
• modules/Mergesolutionfromftogx/Mergesolutionfromftogx.h (modified) (1 diff)
• modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp (modified) (3 diffs)
• modules/Reduceloadfromgtofx/Reduceloadfromgtofx.h (modified) (1 diff)
• modules/Reduceloadx/Reduceloadx.cpp (modified) (1 diff)
• modules/Reduceloadx/Reduceloadx.h (modified) (1 diff)
• modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp (modified) (1 diff)
• modules/Reducematrixfromgtofx/Reducematrixfromgtofx.h (modified) (1 diff)
• modules/Reducevectorgtofx/Reducevectorgtofx.cpp (modified) (1 diff)
• solvers/solver_adjoint_linear.cpp (modified) (1 diff)
• solvers/solver_diagnostic_nonlinear.cpp (modified) (2 diffs)
• solvers/solver_linear.cpp (modified) (1 diff)
• solvers/solver_stokescoupling_nonlinear.cpp (modified) (3 diffs)
• solvers/solver_thermal_nonlinear.cpp (modified) (2 diffs)

issm/trunk/src/c/modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp

@@ -5 +5 @@
 #include "./Mergesolutionfromftogx.h"
 
-void    Mergesolutionfromftogx( Vec* pug, Vec uf, Vec ys, NodeSets* nodesets,Parameters* parameters,bool flag_ys0){
+void    Mergesolutionfromftogx( Vec* pug, Vec uf, Vec ys, NodeSets* nodesets,bool flag_ys0){
 
         /*output: */

issm/trunk/src/c/modules/Mergesolutionfromftogx/Mergesolutionfromftogx.h

@@ -9 +9 @@
 
 /* local prototypes: */
-void    Mergesolutionfromftogx( Vec* pug, Vec uf,Vec ys, NodeSets* nodesets,Parameters* parameters,bool flag_ys0=false);
+void    Mergesolutionfromftogx( Vec* pug, Vec uf,Vec ys, NodeSets* nodesets,bool flag_ys0=false);
 
 #endif  /* _MERGESOLUTIONFROMFTOGX_H */

issm/trunk/src/c/modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp

@@ -10 +10 @@
 #include "./Reduceloadfromgtofx.h"
 
-void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec y_s, NodeSets* nodesets,Parameters* parameters,bool flag_ys0){
+void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec y_s, NodeSets* nodesets,bool flag_ys0){
 
         /*output: */
@@ -23 +23 @@
 
         /*Parameters: */
-        bool kffpartition=false;
         bool fromlocalsize=true;
 
-        parameters->FindParam(&kffpartition,KffEnum);
         _printf_(VerboseModule(),"   Reducing Load vector from gset to fset\n");
 
-        if(!pg){
-                pf=NULL;
+        /* Reduce pg to pn:*/
+        VecDuplicate(pg,&pn);  
+        VecCopy(pg,pn);  
+
+        /*% Reduce pn to pf:*/
+
+        if (nodesets->GetSSize()){
+
+                if(nodesets->GetFSize()){
+                        VecPartition(&pf, pn, nodesets->GetPV_F(),nodesets->GetFSize(),false);
+
+                        /*pf = pf - Kfs * y_s;*/
+                        MatGetLocalSize(Kfs,&Kfsm,&Kfsn);
+                        Kfsy_s=NewVec(Kfsm,fromlocalsize);
+                        if (flag_ys0){
+
+                                /*Create y_s0, full of 0: */
+                                VecDuplicate(y_s,&y_s0);
+                                VecSet(y_s0,0.0);
+                                VecAssemblyBegin(y_s0);
+                                VecAssemblyEnd(y_s0);
+
+                                MatMultPatch(Kfs,y_s0,Kfsy_s);
+                        }
+                        else{
+                                MatMultPatch(Kfs,y_s,Kfsy_s);
+                        }
+
+                        a=-1;
+                        VecAXPY(pf,a,Kfsy_s);  
+                }
+                else{
+                        pf=NULL;
+                }
         }
         else{
-                /* Reduce pg to pn:*/
-                VecDuplicate(pg,&pn);  
-                VecCopy(pg,pn);  
-                
-                /*% Reduce pn to pf:*/
+                /*pf=pn*/
+                VecDuplicate(pn,&pf);  
+                VecCopy(pn,pf);  
+        }
 
-                if (nodesets->GetSSize()){
-
-                        if(nodesets->GetFSize()){
-                                VecPartition(&pf, pn, nodesets->GetPV_F(),nodesets->GetFSize(),kffpartition);
-
-                                /*pf = pf - Kfs * y_s;*/
-                                MatGetLocalSize(Kfs,&Kfsm,&Kfsn);
-                                Kfsy_s=NewVec(Kfsm,fromlocalsize);
-                                if (flag_ys0){
-
-                                        /*Create y_s0, full of 0: */
-                                        VecDuplicate(y_s,&y_s0);
-                                        VecSet(y_s0,0.0);
-                                        VecAssemblyBegin(y_s0);
-                                        VecAssemblyEnd(y_s0);
-
-                                        MatMultPatch(Kfs,y_s0,Kfsy_s);
-                                }
-                                else{
-                                        MatMultPatch(Kfs,y_s,Kfsy_s);
-                                }
-
-                                a=-1;
-                                VecAXPY(pf,a,Kfsy_s);  
-                        }
-                        else{
-                                pf=NULL;
-                        }
-                }
-                else{
-                        /*pf=pn*/
-                        VecDuplicate(pn,&pf);  
-                        VecCopy(pn,pf);  
-                }
-        }
-        
         
         /*Assign correct pointer*/
@@ -83 +76 @@
         VecFree(&pn);
         VecFree(&Kfsy_s);
-
 }

issm/trunk/src/c/modules/Reduceloadfromgtofx/Reduceloadfromgtofx.h

@@ -9 +9 @@
 
 /* local prototypes: */
-void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec ys, NodeSets* nodesets,Parameters* parameters, bool flag_ys0=false);
+void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec ys, NodeSets* nodesets,bool flag_ys0=false);
 
 #endif  /* _REDUCELOADFROMGTOFX_H */

issm/trunk/src/c/modules/Reduceloadx/Reduceloadx.cpp

@@ -11 +11 @@
 #include "./Reduceloadx.h"
 
-void    Reduceloadx( Vec pf, Mat Kfs, Vec y_s,Parameters* parameters,bool flag_ys0){
+void    Reduceloadx( Vec pf, Mat Kfs, Vec y_s,bool flag_ys0){
 
         /*intermediary*/

issm/trunk/src/c/modules/Reduceloadx/Reduceloadx.h

@@ -9 +9 @@
 
 /* local prototypes: */
-void    Reduceloadx( Vec pf, Mat Kfs, Vec ys,Parameters* parameters, bool flag_ys0=false);
+void    Reduceloadx( Vec pf, Mat Kfs, Vec ys,bool flag_ys0=false);
 
 #endif  /* _REDUCELOADX_H */

issm/trunk/src/c/modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp

@@ -4 +4 @@
 #include "./Reducematrixfromgtofx.h"
 
-void Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets,Parameters* parameters){
+void Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets){
 
         /*output: */

issm/trunk/src/c/modules/Reducematrixfromgtofx/Reducematrixfromgtofx.h

@@ -10 +10 @@
 
 /* local prototypes: */
-void    Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets,Parameters* parameters);
+void    Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets);
 
 #endif  /* _REDUCEMATRIXFROMGTOFX_H */

issm/trunk/src/c/modules/Reducevectorgtofx/Reducevectorgtofx.cpp

@@ -19 +19 @@
         if(nodesets){
 
-
                 if (nodesets->GetGSize() && nodesets->GetFSize()){
-
                         VecPartition(&uf,ug,nodesets->GetPV_F(),nodesets->GetFSize(),kffpartitioning);
-                
                 }
         }

issm/trunk/src/c/solvers/solver_adjoint_linear.cpp

@@ -23 +23 @@
         if(kffpartitioning){
                 SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                Reduceloadx(pf, Kfs, femmodel->ys,femmodel->parameters,true); MatFree(&Kfs); //true means spc = 0
+                Reduceloadx(pf, Kfs, femmodel->ys,true); MatFree(&Kfs); //true means spc = 0
         }
         else{
                 SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
-                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters,true);VecFree(&pg); MatFree(&Kfs);//true means spc = 0
+                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
+                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,true);VecFree(&pg); MatFree(&Kfs);//true means spc = 0
         }
 
         Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
-
-        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters,true); VecFree(&uf);//true means spc0
-
-        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf);
+        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,true); VecFree(&uf);//true means spc0
+        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf);
 }

issm/trunk/src/c/solvers/solver_diagnostic_nonlinear.cpp

@@ -54 +54 @@
                 if(kffpartitioning){
                         SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
-                        Reduceloadx(pf, Kfs, femmodel->ys,femmodel->parameters); MatFree(&Kfs);
+                        Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
                 }
                 else{
                         SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
-                        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
-                        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters); VecFree(&pg); MatFree(&Kfs);
+                        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
+                        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets); VecFree(&pg); MatFree(&Kfs);
                 }
                 
                 Solverx(&uf, Kff, pf, old_uf, femmodel->parameters);
-
-                Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters);
-
+                Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);
                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
 
@@ -72 +70 @@
 
                 convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters); MatFree(&Kff);VecFree(&pf);
-                
                 InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
 

issm/trunk/src/c/solvers/solver_linear.cpp

@@ -21 +21 @@
         if(kffpartitioning){
                 SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                Reduceloadx(pf, Kfs, femmodel->ys,femmodel->parameters); MatFree(&Kfs);
+                Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
         }
         else{
                 SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
-                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters);VecFree(&pg); MatFree(&Kfs);
+                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
+                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
         }
 
         Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
-        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters);VecFree(&uf);
-
+        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);VecFree(&uf);
         InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf);
 }

issm/trunk/src/c/solvers/solver_stokescoupling_nonlinear.cpp

@@ -42 +42 @@
         Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodesets,femmodel->parameters);
 
-
         for(;;){
 
@@ -58 +57 @@
                 if(kffpartitioning){
                         SystemMatricesx(NULL,&Kff_horiz, &Kfs_horiz, NULL,&pf_horiz, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reduceloadx(pf_horiz, Kfs_horiz, femmodel->ys,femmodel->parameters); MatFree(&Kfs_horiz);
+                        Reduceloadx(pf_horiz, Kfs_horiz, femmodel->ys); MatFree(&Kfs_horiz);
                 }
                 else{
                         SystemMatricesx(&Kgg_horiz, NULL, NULL, &pg_horiz,NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reducematrixfromgtofx(&Kff_horiz,&Kfs_horiz,Kgg_horiz,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg_horiz);
-                        Reduceloadfromgtofx(&pf_horiz, pg_horiz, Kfs_horiz, femmodel->ys, femmodel->nodesets,femmodel->parameters); VecFree(&pg_horiz); MatFree(&Kfs_horiz);
+                        Reducematrixfromgtofx(&Kff_horiz,&Kfs_horiz,Kgg_horiz,femmodel->nodesets); MatFree(&Kgg_horiz);
+                        Reduceloadfromgtofx(&pf_horiz, pg_horiz, Kfs_horiz, femmodel->ys, femmodel->nodesets); VecFree(&pg_horiz); MatFree(&Kfs_horiz);
                 }
                 
                 Solverx(&uf_horiz, Kff_horiz, pf_horiz, old_uf_horiz, femmodel->parameters);
-
-                Mergesolutionfromftogx(&ug_horiz, uf_horiz,femmodel->ys,femmodel->nodesets,femmodel->parameters);
-
+                Mergesolutionfromftogx(&ug_horiz, uf_horiz,femmodel->ys,femmodel->nodesets);
                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
 
@@ -78 +75 @@
                 if(kffpartitioning){
                         SystemMatricesx(NULL,&Kff_vert, &Kfs_vert, NULL,&pf_vert, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reduceloadx(pf_vert, Kfs_vert, femmodel->ys,femmodel->parameters); MatFree(&Kfs_vert);
+                        Reduceloadx(pf_vert, Kfs_vert, femmodel->ys); MatFree(&Kfs_vert);
                 }
                 else{
                         SystemMatricesx(&Kgg_vert, NULL, NULL, &pg_vert,NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reducematrixfromgtofx(&Kff_vert,&Kfs_vert,Kgg_vert,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg_vert);
-                        Reduceloadfromgtofx(&pf_vert, pg_vert, Kfs_vert, femmodel->ys, femmodel->nodesets,femmodel->parameters);VecFree(&pg_vert); MatFree(&Kfs_vert);
+                        Reducematrixfromgtofx(&Kff_vert,&Kfs_vert,Kgg_vert,femmodel->nodesets); MatFree(&Kgg_vert);
+                        Reduceloadfromgtofx(&pf_vert, pg_vert, Kfs_vert, femmodel->ys, femmodel->nodesets);VecFree(&pg_vert); MatFree(&Kfs_vert);
                 }
 
                 Solverx(&uf_vert, Kff_vert, pf_vert, NULL, femmodel->parameters); MatFree(&Kff_vert); VecFree(&pf_vert);
-                Mergesolutionfromftogx(&ug_vert, uf_vert,femmodel->ys,femmodel->nodesets,femmodel->parameters);VecFree(&uf_vert);
-
+                Mergesolutionfromftogx(&ug_vert, uf_vert,femmodel->ys,femmodel->nodesets);VecFree(&uf_vert);
                 InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_vert); VecFree(&ug_vert); VecFree(&uf_vert);
 

issm/trunk/src/c/solvers/solver_thermal_nonlinear.cpp

@@ -51 +51 @@
                 if(kffpartitioning){
                         SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf,&melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reduceloadx(pf, Kfs, femmodel->ys,femmodel->parameters); MatFree(&Kfs);
+                        Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
                 }
                 else{
                         SystemMatricesx(&Kgg,NULL, NULL, &pg,NULL, &melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
-                        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
-                        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters);VecFree(&pg); MatFree(&Kfs);
+                        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
+                        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
                 }
 
@@ -62 +62 @@
                 Solverx(&tf, Kff, pf,tf_old, femmodel->parameters);
                 VecFree(&tf_old); VecDuplicatePatch(&tf_old,tf);
-        
                 MatFree(&Kff);VecFree(&pf);VecFree(&tg);
 
-                Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets,femmodel->parameters);
+                Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets);
                 InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);