Changeset 5689


Ignore:
Timestamp:
09/07/10 12:02:39 (15 years ago)
Author:
Mathieu Morlighem
Message:

Clean up of solutions (verbose in modules)

Location:
issm/trunk/src
Files:
25 edited

Legend:

Unmodified
Added
Removed

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

    r5057 r5689  
    55#include "./Mergesolutionfromftogx.h"
    66
    7 void    Mergesolutionfromftogx( Vec* pug, Vec uf, Vec ys, NodeSets* nodesets,bool flag_ys0){
     7void    Mergesolutionfromftogx( Vec* pug, Vec uf, Vec ys, NodeSets* nodesets,Parameters* parameters,bool flag_ys0){
    88
    99        /*output: */
    1010        Vec ug=NULL;
    11         int  ug_local_size;
     11        Vec ys0=NULL;
     12        int ug_local_size;
     13       
     14        /*Display message*/
     15        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     16        if (verbose) printf("   Merging solution vector from fset to gset\n");
    1217
    13         /*intermediary*/
    14         Vec ys0=NULL;
    15        
    1618        /*Merge f set back into g set: */
    1719        ug=NewVec(nodesets->GetGSize());

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

    r5057 r5689  
    99
    1010/* local prototypes: */
    11 void    Mergesolutionfromftogx( Vec* pug, Vec uf,Vec ys, NodeSets* nodesets,bool flag_ys0=false);
     11void    Mergesolutionfromftogx( Vec* pug, Vec uf,Vec ys, NodeSets* nodesets,Parameters* parameters,bool flag_ys0=false);
    1212
    1313#endif  /* _MERGESOLUTIONFROMFTOGX_H */

  • issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp

    r4573 r5689  
    2323        int analysis_type;
    2424
     25        /*Display message*/
     26        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     27        if (verbose) printf("   Constraining penalties\n");
     28
    2529        /*recover parameters: */
    2630        parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);

  • issm/trunk/src/c/modules/PenaltySystemMatricesx/PenaltySystemMatricesx.cpp

    r5420 r5689  
    1515        double kmax;
    1616        Load* load=NULL;
    17        
    1817        int configuration_type;
     18
     19        /*Display message*/
     20        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     21        if (verbose) printf("   Generating penalty matrices\n");
    1922
    2023        /*retrive parameters: */

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

    r5057 r5689  
    88#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
    99#endif
    10 
    1110#include "./Reduceloadfromgtofx.h"
    1211
    13 void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec y_s, NodeSets* nodesets,bool flag_ys0){
     12void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec y_s, NodeSets* nodesets,Parameters* parameters,bool flag_ys0){
    1413
    1514        /*output: */
    … …  
    2221        int Kfsm,Kfsn;
    2322        PetscScalar a;
    24        
     23
     24        /*Display message*/
     25        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     26        if (verbose) printf("   Reducing Load vector from gset to fset\n");
    2527
    2628        if(!pg){
    … …  
    2830        }
    2931        else{
    30 
    3132                /* Reduce pg to pn:*/
    3233                VecDuplicate(pg,&pn); 

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

    r5057 r5689  
    99
    1010/* local prototypes: */
    11 void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec ys, NodeSets* nodesets, bool flag_ys0=false);
     11void    Reduceloadfromgtofx( Vec* ppf, Vec pg, Mat Kfs, Vec ys, NodeSets* nodesets,Parameters* parameters, bool flag_ys0=false);
    1212
    1313#endif  /* _REDUCELOADFROMGTOFX_H */

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

    r5057 r5689  
    22 * \brief reduce matrix from g set to f fset
    33 */
    4 
    54#include "./Reducematrixfromgtofx.h"
    65
    7 void Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets){
     6void Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets,Parameters* parameters){
    87
    98        /*output: */
    109        Mat Kff=NULL;
    1110        Mat Kfs=NULL;
     11
     12        /*Display message*/
     13        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     14        if (verbose) printf("   Reducing Stiffness Matrix from gset to fset\n");
    1215
    1316        //Reduce matrix from g-size to f-size

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

    r5057 r5689  
    1010
    1111/* local prototypes: */
    12 void    Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets);
     12void    Reducematrixfromgtofx( Mat* pKff, Mat* pKfs,Mat Kgg,NodeSets* nodesets,Parameters* parameters);
    1313
    1414#endif  /* _REDUCEMATRIXFROMGTOFX_H */

  • issm/trunk/src/c/modules/Solverx/Solverx.cpp

    r5686 r5689  
    2828        int solver_type;
    2929        char* solver_string=NULL;
     30
     31        /*Display message*/
     32        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     33        if (verbose) printf("   Solving\n");
    3034
    3135        /*First, check that f-set is not NULL, ie model is fully constrained: */

  • issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r5420 r5689  
    2626        int analysis_type;
    2727        int configuration_type;
     28
     29        /*Display message*/
     30        int verbose; parameters->FindParam(&verbose,VerboseEnum);
     31        if (verbose) printf("   Generating matrices\n");
    2832
    2933        /*retrive parameters: */

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

    r5686 r5689  
    1414        /*parameters:*/
    1515        int kflag,pflag;
    16         int verbose=0;
    1716
    1817        /*output: */
    … …  
    2726        Vec pf=NULL;
    2827
    29         /*Recover parameters: */
    3028        kflag=1; pflag=1;
    31         femmodel->parameters->FindParam(&verbose,VerboseEnum);
    32 
    33         //*Generate system matrices
    34         if(verbose)_printf_("   Generating matrices\n");
    3529        SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    36 
    37         if(verbose)_printf_("   Generating penalty matrices\n");
    38         //*Generate penalty system matrices
    3930        PenaltySystemMatricesx(Kgg, pg,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    4031
    41         /*!Reduce matrix from g to f size:*/
    42         if(verbose)_printf_("   reducing matrix from g to f set\n");
    43         Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
     32        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
     33        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters,true);VecFree(&pg); MatFree(&Kfs);//true means spc = 0
    4434
    45         /*!Reduce load from g to f size: */
    46         if(verbose)_printf_("   reducing load from g to f set\n"); //true means spc = 0
    47         Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,true);VecFree(&pg); MatFree(&Kfs);
    48 
    49         /*Solve: */
    50         if(verbose)_printf_("   solving\n");
    5135        Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
    5236
    53         //Merge back to g set
    54         if(verbose)_printf_("   merging solution from f to g set\n");//true means spc=0
    55         Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,true);VecFree(&uf);
     37        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters,true);VecFree(&uf);//true means spc0
    5638
    57         //Update inputs using new solution:
    5839        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
    5940
    60         /*free ressources: */
    6141        VecFree(&ug);
    6242        VecFree(&uf);

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

    r5686 r5689  
    3636        int kflag,pflag;
    3737        int verbose=0;
    38         int dim;
    3938
    4039        /*Recover parameters: */
    4140        kflag=1; pflag=1;
    42         femmodel->parameters->FindParam(&dim,DimEnum);
    4341        femmodel->parameters->FindParam(&verbose,VerboseEnum);
    4442        femmodel->parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);
    … …  
    6967                VecFree(&old_uf);old_uf=uf;
    7068
    71                 if(verbose)_printf_("   Generating matrices\n");
    7269                SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    73 
    74                 if(verbose)_printf_("   Generating penalty matrices\n");
    7570                PenaltySystemMatricesx(Kgg, pg,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    7671               
    77                 if(verbose)_printf_("   reducing matrix from g to f set\n");
    78                 Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets);
    79 
    80                 /*Free ressources: */
     72                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters);
    8173                MatFree(&Kgg);
    8274       
    83                 if(verbose)_printf_("   reducing load from g to f set\n");
    84                 Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);
    85 
    86                 //no need for pg and Kfs anymore
     75                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters);
    8776                VecFree(&pg);
    8877                MatFree(&Kfs);
    8978
    90                 if(verbose)_printf_("   solving\n");
    9179                Solverx(&uf, Kff, pf, old_uf, femmodel->parameters);
    9280
    93                 if(verbose)_printf_("   merging solution from f to g set\n");
    94                 Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);
     81                Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters);
    9582
    96                 //Update inputs using new solution:
    9783                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
    9884
    99                 if(verbose)_printf_("   penalty constraints\n");
    10085                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
    101 
    10286                if(verbose)_printf_("   number of unstable constraints: %i\n",num_unstable_constraints);
    10387
    104                 /*Figure out if convergence is reached.*/
    10588                convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters);
    10689                MatFree(&Kff);VecFree(&pf);
    10790               
    108                 /*add converged to inputs: */
    10991                InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,converged,ConvergedEnum);
    11092
    … …  
    126108        }
    127109
    128         /*Delete loads only if no ouput was requested: */
     110        /*clean-up*/
    129111        if(conserve_loads) delete loads;
    130 
    131         /*clean up*/
    132112        VecFree(&uf);
    133113        VecFree(&ug);

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

    r5686 r5689  
    2929        femmodel->parameters->FindParam(&verbose,VerboseEnum);
    3030
    31         //*Generate system matrices
    32         if(verbose)_printf_("   Generating matrices\n");
    3331        SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    34 
    35         if(verbose)_printf_("   Generating penalty matrices\n");
    36         //*Generate penalty system matrices
    3732        PenaltySystemMatricesx(Kgg, pg,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
    3833
    39         /*!Reduce matrix from g to f size:*/
    40         if(verbose)_printf_("   reducing matrix from g to f set\n");
    41         Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
     34        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters); MatFree(&Kgg);
     35        Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters);VecFree(&pg); MatFree(&Kfs);
    4236
    43         /*!Reduce load from g to f size: */
    44         if(verbose)_printf_("   reducing load from g to f set\n");
    45         Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
    46 
    47         /*Solve: */
    48         if(verbose)_printf_("   solving\n");
    4937        Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
    5038
    51         //Merge back to g set
    52         if(verbose)_printf_("   merging solution from f to g set\n");
    53         Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);VecFree(&uf);
     39        Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,femmodel->parameters);VecFree(&uf);
    5440
    55         //Update inputs using new solution:
    5641        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
    5742
    58         /*free ressources: */
    5943        VecFree(&ug);
    6044        VecFree(&uf);

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

    r5686 r5689  
    7575                }
    7676
    77                 /*!Reduce matrix from g to f size:*/
    78                 Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets);
     77                Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets,femmodel->parameters);
    7978
    8079                /*Free ressources: */
    8180                MatFree(&Kgg);
    8281       
    83                 if(verbose)_printf_("   reducing load from g to f set\n");
    84                 Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);
     82                Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,femmodel->parameters);
    8583
    8684                //no need for pg and Kfs anymore
    … …  
    8987
    9088                /*Solve: */
    91                 if(verbose)_printf_("%s\n","solving");
    9289                VecFree(&tf);
    9390                Solverx(&tf, Kff, pf,tf_old, femmodel->parameters);
    … …  
    9794                MatFree(&Kff);VecFree(&pf);VecFree(&tg);
    9895
    99                 if(verbose)_printf_("   merging solution from f to g set\n");
    100                 Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets);
     96                Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets,femmodel->parameters);
    10197
    102                 //Update inputs using new solution:
    103                 if (verbose) _printf_("   updating inputs\n");
    10498                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);
    10599
    106100                //Deal with penalty loads
    107                 if(verbose)_printf_("   penalty constraints\n");
    108101                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    109102

  • issm/trunk/src/m/solvers/solver_adjoint_linear.m

    r5631 r5689  
    55%      femmodel =solver_adjoint_linear(femmodel)
    66
    7         %stiffness and load generation only:
    87        femmodel.parameters.Kflag=1; femmodel.parameters.Pflag=1;
    98
    10         %system matrices
    119        [K_gg, p_g]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    1210        [K_gg, p_g,kmax]=PenaltySystemMatrices(K_gg,p_g,femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    1311       
    14         %Reduce tangent matrix from g size to f size
    15         [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
     12        [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets,femmodel.parameters);
    1613        %K_ff=transpose(K_ff);
     14        p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets,femmodel.parameters,true);
     15
    1716        displaystring(femmodel.parameters.Verbose>1,'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    18        
    19         %Reduce load from g size to f size
    20         p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets,true);
    21 
    22         %Solve 
    2317        u_f=Solver(K_ff,p_f,[],femmodel.parameters);
    2418       
    25         %Merge back to g set
    26         u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,true);
     19        u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,femmodel.parameters,true);
    2720
    28         %Update inputs using new solution
    2921        [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,u_g);
    30 

  • issm/trunk/src/m/solvers/solver_diagnostic_nonlinear.m

    r5609 r5689  
    3131                old_uf=uf;
    3232               
    33                 displaystring(femmodel.parameters.Verbose,'%s','   Generating matrices:');
    3433                [K_gg_nopenalty , p_g_nopenalty]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters);
    35        
    36                 displaystring(femmodel.parameters.Verbose,'%s','   Generating penalty matrices:');
    3734                [K_gg , p_g, kmax]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters);
    3835               
     36                [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets,femmodel.parameters);
     37                p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    3938
    40                 displaystring(femmodel.parameters.Verbose,'%s','   reducing matrix from g to f set');
    41                 [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    42                
    43                 displaystring(femmodel.parameters.Verbose,'%s','   reduce load from g size to f size');
    44                 p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets);
    45 
    46                 displaystring(femmodel.parameters.Verbose,'%s','   solving');
    4739                uf=Solver(K_ff,p_f,old_uf,femmodel.parameters);
    4840
    49                 displaystring(femmodel.parameters.Verbose,'%s','   merge back to g set');
    50                 ug= Mergesolutionfromftog( uf, femmodel.ys, femmodel.nodesets );
     41                ug= Mergesolutionfromftog( uf, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    5142
    52                 %Update inputs using new solution
    5343                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters,ug);
    54                
    55                 displaystring(femmodel.parameters.Verbose,'%s','   penalty constraints');
    5644                [loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints( femmodel.elements,femmodel.nodes,femmodel.vertices,loads, femmodel.materials,femmodel.parameters);
    5745               

  • issm/trunk/src/m/solvers/solver_linear.m

    r5195 r5689  
    55%      femmodel =solver_linear(femmodel)
    66
    7         %stiffness and load generation only:
    87        femmodel.parameters.Kflag=1; femmodel.parameters.Pflag=1;
    98
    10         %system matrices
    119        [K_gg, p_g]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    1210        [K_gg, p_g,kmax]=PenaltySystemMatrices(K_gg,p_g,femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    1311       
    14         %Reduce tangent matrix from g size to f size
    15         [K_ff, K_fs] = Reducematrixfromgtof( K_gg,  femmodel.nodesets);
     12        [K_ff, K_fs] = Reducematrixfromgtof( K_gg,  femmodel.nodesets,femmodel.parameters);
     13        p_f = Reduceloadfromgtof( p_g,  K_fs, femmodel.ys, femmodel.nodesets,femmodel.parameters);
     14
    1615        displaystring(femmodel.parameters.Verbose>1,'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    17        
    18         %Reduce load from g size to f size
    19         p_f = Reduceloadfromgtof( p_g,  K_fs, femmodel.ys, femmodel.nodesets);
    20 
    21         %Solve 
    2216        u_f=Solver(K_ff,p_f,[],femmodel.parameters);
    2317       
    24         %Merge back to g set
    25         u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets );
     18        u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    2619
    27         %Update inputs using new solution
    2820        [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,u_g);

  • issm/trunk/src/m/solvers/solver_thermal_nonlinear.m

    r5057 r5689  
    2727                [K_gg , p_g, melting_offset]=PenaltySystemMatrices(K_gg_nopenalty,p_g_nopenalty,femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    2828
    29                 %Reduce tangent matrix from g size to f size
    30                 [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    31 
    32                 %Reduce load from g size to f size
    33                 p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets);
     29                [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets,femmodel.parameters);
     30                p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    3431
    3532                displaystring(femmodel.parameters.Verbose,'%s%g','   condition number of stiffness matrix: ',condest(K_ff));
    3633                t_f=Solver(K_ff,p_f,[],femmodel.parameters);
    3734
    38                 displaystring(femmodel.parameters.Verbose,'%s',['   merging solution back to g set']);
    39                 t_g= Mergesolutionfromftog( t_f, femmodel.ys, femmodel.nodesets );
    40 
    41                 displaystring(femmodel.parameters.Verbose,'%s',['   updating inputs']);
     35                t_g= Mergesolutionfromftog( t_f, femmodel.ys, femmodel.nodesets,femmodel.parameters);
    4236                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,t_g);
    4337       
    44                 %penalty constraints
    45                 displaystring(femmodel.parameters.Verbose,'%s',['   penalty constraints']);
    4638                [femmodel.loads,constraints_converged,num_unstable_constraints] =PenaltyConstraints(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads, femmodel.materials,femmodel.parameters);
    4739       

  • issm/trunk/src/mex/Mergesolutionfromftog/Mergesolutionfromftog.cpp

    r5057 r5689  
    88
    99        /*input datasets: */
    10         bool flag_ys0;
    11         Vec uf=NULL;
    12         Vec ys=NULL;
    13         NodeSets* nodesets=NULL;
     10        bool        flag_ys0;
     11        Vec         uf         = NULL;
     12        Vec         ys         = NULL;
     13        NodeSets   *nodesets   = NULL;
     14        Parameters *parameters = NULL;
    1415
    1516        /* output datasets: */
    … …  
    2021
    2122        /*checks on arguments on the matlab side: */
    22         if((nlhs!=NLHS) || (nrhs!=3 && nrhs!=4)){
     23        if((nlhs!=NLHS) || (nrhs!=4 && nrhs!=5)){
    2324                MergesolutionfromftogUsage();
    2425                ISSMERROR(" usage. See above");
    … …  
    2930        FetchData(&ys,YS);
    3031        FetchNodeSets(&nodesets,NODESETS);
     32        FetchParams(&parameters,PARAMETERS);
    3133
    3234        /*!Reduce vector: */
    33         if (nrhs==3){
    34                 Mergesolutionfromftogx(&ug, uf,ys,nodesets);
     35        if (nrhs==4){
     36                Mergesolutionfromftogx(&ug, uf,ys,nodesets,parameters);
    3537        }
    3638        else{
    3739                FetchData(&flag_ys0,YSFLAG);
    38                 Mergesolutionfromftogx(&ug, uf,ys,nodesets,flag_ys0);
     40                Mergesolutionfromftogx(&ug, uf,ys,nodesets,parameters,flag_ys0);
    3941        }
    4042
    … …  
    4446        /*Free ressources: */
    4547        VecFree(&uf);
     48        VecFree(&ug);
    4649        VecFree(&ys);
    4750        delete nodesets;
    48         VecFree(&ug);
     51        delete parameters;
    4952
    5053        /*end module: */
    … …  
    5558{
    5659        _printf_("\n");
    57         _printf_("   usage: [ug] = %s(uf,ys,nodesets);\n",__FUNCT__);
     60        _printf_("   usage: [ug] = %s(uf,ys,nodesets,parameters);\n",__FUNCT__);
    5861        _printf_("\n");
    5962}

  • issm/trunk/src/mex/Mergesolutionfromftog/Mergesolutionfromftog.h

    r5057 r5689  
    2222#define YS (mxArray*)prhs[1]
    2323#define NODESETS (mxArray*)prhs[2]
    24 #define YSFLAG (mxArray*)prhs[3]
     24#define PARAMETERS (mxArray*)prhs[3]
     25#define YSFLAG (mxArray*)prhs[4]
    2526
    2627/* serial output macros: */
    … …  
    3132#define NLHS  1
    3233#undef NRHS
    33 #define NRHS  3
     34#define NRHS  5
    3435
    3536#endif  /* _MERGESOLUTIONFROMFTOG_H */
    36 

  • issm/trunk/src/mex/Reduceloadfromgtof/Reduceloadfromgtof.cpp

    r5057 r5689  
    88
    99        /*input datasets: */
    10         bool flag_ys0;
    11         Vec pg=NULL;
    12         Mat Kfs=NULL;
    13         Vec ys=NULL;
    14         NodeSets* nodesets=NULL;
     10        bool        flag_ys0;
     11        Vec         pg         = NULL;
     12        Mat         Kfs        = NULL;
     13        Vec         ys         = NULL;
     14        NodeSets   *nodesets   = NULL;
     15        Parameters *parameters = NULL;
    1516
    1617        /* output datasets: */
    … …  
    2122
    2223        /*checks on arguments on the matlab side: */
    23         if((nlhs!=NLHS) || (nrhs!=4 && nrhs!=5)){
     24        if((nlhs!=NLHS) || (nrhs!=5 && nrhs!=6)){
    2425                ReduceloadfromgtofUsage();
    2526                ISSMERROR(" usage. See above");
    … …  
    3132        FetchData(&ys,YS);
    3233        FetchNodeSets(&nodesets,NODESETS);
     34        FetchParams(&parameters,PARAMETERS);
    3335
    3436        /*!Reduce load from g to f size: */
    35         if (nrhs==4){
    36                 Reduceloadfromgtofx(&pf, pg, Kfs, ys, nodesets);
     37        if (nrhs==5){
     38                Reduceloadfromgtofx(&pf, pg, Kfs, ys, nodesets,parameters);
    3739        }
    3840        else{
    3941                FetchData(&flag_ys0,YSFLAG);
    40                 Reduceloadfromgtofx(&pf, pg, Kfs, ys, nodesets,flag_ys0);
     42                Reduceloadfromgtofx(&pf, pg, Kfs, ys, nodesets,parameters,flag_ys0);
    4143        }
    4244
    … …  
    5052        VecFree(&ys);
    5153        delete nodesets;
     54        delete parameters;
    5255
    5356        /*end module: */
    … …  
    5861{
    5962        _printf_("\n");
    60         _printf_("   usage: [pf] = %s(pg,Kfs,ys,nodesets);\n",__FUNCT__);
     63        _printf_("   usage: [pf] = %s(pg,Kfs,ys,nodesets,parameters);\n",__FUNCT__);
    6164        _printf_("\n");
    6265}

  • issm/trunk/src/mex/Reduceloadfromgtof/Reduceloadfromgtof.h

    r5057 r5689  
    2323#define YS (mxArray*)prhs[2]
    2424#define NODESETS (mxArray*)prhs[3]
    25 #define YSFLAG (mxArray*)prhs[4]
     25#define PARAMETERS (mxArray*)prhs[4]
     26#define YSFLAG (mxArray*)prhs[5]
    2627
    2728/* serial output macros: */
    … …  
    3233#define NLHS  1
    3334#undef NRHS
    34 #define NRHS  4
    35 
     35#define NRHS  5
    3636
    3737#endif  /* _REDUCELOADFROMGTOF_H */
    38 

  • issm/trunk/src/mex/Reducematrixfromgtof/Reducematrixfromgtof.cpp

    r5057 r5689  
    88
    99        /*input datasets: */
    10         Mat Kgg=NULL;
    11         NodeSets* nodesets=NULL;
     10        Mat         Kgg        = NULL;
     11        NodeSets   *nodesets   = NULL;
     12        Parameters *parameters = NULL;
    1213
    1314        /* output datasets: */
    14         Mat Kff=NULL;
    15         Mat Kfs=NULL;
     15        Mat Kff = NULL;
     16        Mat Kfs = NULL;
    1617
    1718        /*Boot module: */
    … …  
    2425        FetchData(&Kgg,KGG);
    2526        FetchNodeSets(&nodesets,NODESETS);
     27        FetchParams(&parameters,PARAMETERS);
    2628
    2729        /*!Reduce matrix from g to f size:*/
    28         Reducematrixfromgtofx(&Kff,&Kfs,Kgg,nodesets);
     30        Reducematrixfromgtofx(&Kff,&Kfs,Kgg,nodesets,parameters);
    2931
    3032        /*write output datasets: */
    … …  
    3436        /*Free ressources: */
    3537        delete nodesets;
     38        delete parameters;
    3639        MatFree(&Kgg);
    3740        MatFree(&Kff);
    … …  
    4548{
    4649        _printf_("\n");
    47         _printf_("   usage: [Kff,Kfs] = %s(Kgg,nodesets);\n",__FUNCT__);
     50        _printf_("   usage: [Kff,Kfs] = %s(Kgg,nodesets,parameters);\n",__FUNCT__);
    4851        _printf_("\n");
    4952}

  • issm/trunk/src/mex/Reducematrixfromgtof/Reducematrixfromgtof.h

    r5057 r5689  
    2121#define KGG (mxArray*)prhs[0]
    2222#define NODESETS (mxArray*)prhs[1]
     23#define PARAMETERS (mxArray*)prhs[2]
    2324
    2425/* serial output macros: */
    … …  
    3031#define NLHS  2
    3132#undef NRHS
    32 #define NRHS  2
    33 
     33#define NRHS  3
    3434
    3535#endif  /* _REDUCEMATRIXFROMGTOF_H */
    36 

  • issm/trunk/src/mex/SystemMatrices/SystemMatrices.cpp

    r5332 r5689  
    88
    99        /*input datasets: */
    10         Elements* elements=NULL;
    11         Nodes* nodes=NULL;
    12         Vertices* vertices=NULL;
    13         Loads* loads=NULL;
    14         Materials* materials=NULL;
    15         Parameters* parameters=NULL;
     10        Elements   *elements   = NULL;
     11        Nodes      *nodes      = NULL;
     12        Vertices   *vertices   = NULL;
     13        Loads      *loads      = NULL;
     14        Materials  *materials  = NULL;
     15        Parameters *parameters = NULL;
    1616        int         kflag,pflag;
    1717       
    … …  
    4242        nodes->     Configure(elements,loads, nodes,vertices, materials,parameters);
    4343        loads->     Configure(elements, loads, nodes,vertices, materials,parameters);
    44         materials->     Configure(elements, loads, nodes,vertices, materials,parameters);
     44        materials-> Configure(elements, loads, nodes,vertices, materials,parameters);
    4545
    4646        /*!Generate internal degree of freedom numbers: */
Note: See TracChangeset for help on using the changeset viewer.