Changeset 8803


Ignore:
Timestamp:
07/05/11 16:49:37 (14 years ago)
Author:
Eric.Larour
Message:

Modified API for modules, to take into account new constraint applications, without nodesets

Location:
issm/trunk/src
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/EnumDefinitions/EnumDefinitions.h

    r8798 r8803  
    375375        IsMacAyealPattynEnum,
    376376        IsStokesEnum,
    377         KffEnum,
    378377        LatentHeatEnum,
    379378        LowmemEnum,

  • issm/trunk/src/c/Makefile.am

    r8798 r8803  
    273273                                        ./objects/Params/StringParam.cpp\
    274274                                        ./objects/Params/StringParam.h\
    275                                         ./objects/NodeSets.cpp\
    276                                         ./objects/NodeSets.h\
    277275                                        ./Container/Container.h\
    278276                                        ./Container/Constraints.h\
    … …  
    406404                                        ./io/WriteDataToDisk.cpp\
    407405                                        ./io/IoModelFetchData.cpp\
    408                                         ./io/WriteNodeSets.cpp\
    409406                                        ./io/WriteParams.cpp\
    410407                                        ./io/FetchParams.cpp\
    411                                         ./io/FetchNodeSets.cpp\
    412408                                        ./io/OptionParse.cpp\
    413409                                        ./io/MatlabNArrayToNArray.cpp\
    … …  
    564560                                        ./modules/Orthx/Orthx.h\
    565561                                        ./modules/Orthx/Orthx.cpp\
     562                                        ./modules/UpdateSpcsx/UpdateSpcsx.h\
     563                                        ./modules/UpdateSpcsx/UpdateSpcsx.cpp\
    566564                                        ./modules/Gradjx/Gradjx.h\
    567565                                        ./modules/Gradjx/Gradjx.cpp\
    … …  
    594592                                        ./modules/ComputeStrainRatex/ComputeStrainRatex.h\
    595593                                        ./modules/ComputeStrainRatex/ComputeStrainRatex.cpp\
    596                                         ./modules/BuildNodeSetsx/BuildNodeSetsx.h\
    597                                         ./modules/BuildNodeSetsx/BuildNodeSetsx.cpp\
    598                                         ./modules/BuildNodeSetsx/PartitionSets.cpp\
    599594                                        ./modules/SpcNodesx/SpcNodesx.h\
    600595                                        ./modules/SpcNodesx/SpcNodesx.cpp\
    … …  
    634629                                        ./modules/Reducevectorgtofx/Reducevectorgtofx.cpp\
    635630                                        ./modules/Reducevectorgtofx/Reducevectorgtofx.h\
    636                                         ./modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp\
    637                                         ./modules/Reducematrixfromgtofx/Reducematrixfromgtofx.h\
    638                                         ./modules/Reduceloadfromgtofx/Reduceloadfromgtofx.h\
    639                                         ./modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp\
    640631                                        ./modules/Reduceloadx/Reduceloadx.h\
    641632                                        ./modules/Reduceloadx/Reduceloadx.cpp\
    … …  
    670661                                        ./modules/Solverx/Solverx.cpp\
    671662                                        ./modules/Solverx/Solverx.h\
     663                                        ./modules/VecMergex/VecMergex.cpp\
     664                                        ./modules/VecMergex/VecMergex.h\
    672665                                        ./modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp\
    673666                                        ./modules/Mergesolutionfromftogx/Mergesolutionfromftogx.h\
    … …  
    957950                                        ./objects/Params/StringParam.cpp\
    958951                                        ./objects/Params/StringParam.h\
    959                                         ./objects/NodeSets.cpp\
    960                                         ./objects/NodeSets.h\
    961952                                        ./Container/Container.h\
    962953                                        ./Container/Constraints.h\
    … …  
    10881079                                        ./io/WriteDataToDisk.cpp\
    10891080                                        ./io/IoModelFetchData.cpp\
    1090                                         ./io/WriteNodeSets.cpp\
    10911081                                        ./io/WriteParams.cpp\
    1092                                         ./io/FetchNodeSets.cpp\
    10931082                                        ./io/pfopen.cpp\
    10941083                                        ./io/pfclose.cpp\
    … …  
    12401229                                        ./modules/Orthx/Orthx.h\
    12411230                                        ./modules/Orthx/Orthx.cpp\
     1231                                        ./modules/UpdateSpcsx/UpdateSpcsx.h\
     1232                                        ./modules/UpdateSpcsx/UpdateSpcsx.cpp\
    12421233                                        ./modules/Gradjx/Gradjx.h\
    12431234                                        ./modules/Gradjx/Gradjx.cpp\
    … …  
    12701261                                        ./modules/ComputeStrainRatex/ComputeStrainRatex.h\
    12711262                                        ./modules/ComputeStrainRatex/ComputeStrainRatex.cpp\
    1272                                         ./modules/BuildNodeSetsx/BuildNodeSetsx.h\
    1273                                         ./modules/BuildNodeSetsx/BuildNodeSetsx.cpp\
    1274                                         ./modules/BuildNodeSetsx/PartitionSets.cpp\
    12751263                                        ./modules/SpcNodesx/SpcNodesx.h\
    12761264                                        ./modules/SpcNodesx/SpcNodesx.cpp\
    … …  
    13081296                                        ./modules/Reducevectorgtofx/Reducevectorgtofx.cpp\
    13091297                                        ./modules/Reducevectorgtofx/Reducevectorgtofx.h\
    1310                                         ./modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp\
    1311                                         ./modules/Reducematrixfromgtofx/Reducematrixfromgtofx.h\
    1312                                         ./modules/Reduceloadfromgtofx/Reduceloadfromgtofx.h\
    1313                                         ./modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp\
    13141298                                        ./modules/Reduceloadx/Reduceloadx.h\
    13151299                                        ./modules/Reduceloadx/Reduceloadx.cpp\
    … …  
    13391323                                        ./modules/Solverx/Solverx.h\
    13401324                                        ./modules/Solverx/DofTypesToIndexSet.cpp\
     1325                                        ./modules/VecMergex/VecMergex.cpp\
     1326                                        ./modules/VecMergex/VecMergex.h\
    13411327                                        ./modules/Scotchx/Scotchx.cpp\
    13421328                                        ./modules/Scotchx/Scotchx.h\

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

    r8799 r8803  
    111111                case PentaVertexInputEnum : return "PentaVertexInput";
    112112                case TriaVertexInputEnum : return "TriaVertexInput";
     113                case TriaVertexForcingEnum : return "TriaVertexForcing";
     114                case PentaVertexForcingEnum : return "PentaVertexForcing";
    113115                case ControlInputEnum : return "ControlInput";
    114116                case ParamEnum : return "Param";

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

    r8799 r8803  
    109109        else if (strcmp(name,"PentaVertexInput")==0) return PentaVertexInputEnum;
    110110        else if (strcmp(name,"TriaVertexInput")==0) return TriaVertexInputEnum;
     111        else if (strcmp(name,"TriaVertexForcing")==0) return TriaVertexForcingEnum;
     112        else if (strcmp(name,"PentaVertexForcing")==0) return PentaVertexForcingEnum;
    111113        else if (strcmp(name,"ControlInput")==0) return ControlInputEnum;
    112114        else if (strcmp(name,"Param")==0) return ParamEnum;

  • issm/trunk/src/c/solutions/ResetBoundaryConditions.cpp

    r6412 r8803  
    99void ResetBoundaryConditions(FemModel* femmodel, int analysis_type){
    1010       
     11        /*variables: */
    1112        Vec yg=NULL;
    1213        Vec ys=NULL;
    13         int analysis_counter;
    14                        
     14        Nodes* nodes=NULL;
     15        int i;
     16
    1517        _printf_(VerboseSolution(),"%s\n","   updating boundary conditions...");
    1618                       
    … …  
    1820        femmodel->SetCurrentConfiguration(analysis_type);
    1921
     22        /*recover nodes: */
     23        nodes=femmodel->nodes;
     24
     25        /*retrieve boundary conditions from element inputs :*/
    2026        GetSolutionFromInputsx( &yg, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,  femmodel->parameters);
     27        Reducevectorgtosx(&ys,yg,femmodel->nodes,femmodel->parameters);
    2128
    22         /*For this analysis_type, free existing boundary condition vector: */
    23         analysis_counter=femmodel->analysis_counter;
    24         VecFree(&femmodel->m_ys[analysis_counter]);
    25 
    26         //Reduce from g to s set
    27         Reducevectorgtosx(&ys,yg,femmodel->m_nodesets[analysis_counter],femmodel->parameters);
    28 
    29         /*Plug into femmodel->m_ys: */
    30         femmodel->m_ys[analysis_counter]=ys;
     29        /*update spcs using this new vector of constraints: */
     30        UpdateSpcsx(femmodel->nodes,femmodel->parameters,ys);
    3131
    3232        /*Free ressources:*/
     33        VecFree(&ys);
    3334        VecFree(&yg);
    3435}

  • issm/trunk/src/c/solutions/diagnostic_core.cpp

    r7638 r8803  
    2525        int    solution_type;
    2626
     27
    2728        /* recover parameters:*/
    2829        femmodel->parameters->FindParam(&dim,DimEnum);
    … …  
    4546        if(ishutter) surfaceslope_core(femmodel);
    4647        if(isstokes) bedslope_core(femmodel);
    47                
     48
    4849        if(ishutter){
    4950                       
    … …  
    6566                solver_nonlinear(femmodel,modify_loads);
    6667        }
    67        
     68
    6869        if (ismacayealpattyn && isstokes){
    6970

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

    r7391 r8803  
    1313
    1414        /*intermediary: */
    15         Mat  Kgg = NULL, Kff = NULL, Kfs = NULL;
     15        Mat  Kff = NULL, Kfs = NULL;
    1616        Vec  ug  = NULL, uf  = NULL;
    17         Vec  pg  = NULL, pf  = NULL;
    18         Vec  dg  = NULL, df  = NULL;
    19         bool kffpartitioning = false;
     17        Vec  pf  = NULL;
     18        Vec  df  = NULL;
     19        Vec  ys  = NULL;
     20        int  analysis_type;
    2021
    2122        /*Recover parameters: */
    22         femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
     23        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2324
    24         if(kffpartitioning){
    25                 SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    26                 Reduceloadx(pf, Kfs, femmodel->ys,true); MatFree(&Kfs); //true means spc = 0
    27         }
    28         else{
    29                 SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, &dg, NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    30                 Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
    31                 Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,true);VecFree(&pg); MatFree(&Kfs);//true means spc = 0
    32                 Reducevectorgtofx(&df, dg, femmodel->nodesets,femmodel->parameters); VecFree(&dg);
    33         }
    34 
     25        SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     26        CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     27        Reduceloadx(pf, Kfs, ys,true); MatFree(&Kfs); //true means spc = 0
    3528        Solverx(&uf, Kff, pf, NULL, df, femmodel->parameters); MatFree(&Kff); VecFree(&pf); VecFree(&df);
    36         Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,true); VecFree(&uf);//true means spc0
    37         InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf);
     29        Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters,true); VecFree(&uf);VecFree(&ys); //true means spc0
     30        InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf); 
    3831}

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

    r7391 r8803  
    1111
    1212        /*intermediary: */
    13         Mat  Kgg = NULL, Kff = NULL, Kfs   = NULL;
    14         Vec  ug  = NULL, uf  = NULL;
    15         Vec  pg  = NULL, pf  = NULL;
    16         Vec dg  = NULL, df  = NULL;
    17         bool kffpartitioning;
     13        Mat  Kff = NULL, Kfs   = NULL;
     14        Vec  ug  = NULL;
     15        Vec  uf  = NULL;
     16        Vec  pf  = NULL;
     17        Vec  df  = NULL;
     18        Vec  ys  = NULL;
     19        int  analysis_type;
    1820
    1921        /*Recover parameters: */
    20         femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
     22        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    2123
    22         if(kffpartitioning){
    23                 SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    24                 Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
    25         }
    26         else{
    27                 SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, &dg, NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    28                 Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
    29                 Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
    30                 Reducevectorgtofx(&df, dg, femmodel->nodesets,femmodel->parameters); VecFree(&dg);
    31         }
    32 
     24        SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     25        CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     26        Reduceloadx(pf, Kfs, ys); MatFree(&Kfs);
    3327        Solverx(&uf, Kff, pf, NULL, df, femmodel->parameters); MatFree(&Kff); VecFree(&pf); VecFree(&df);
    34         Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);VecFree(&uf);
     28        Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters);VecFree(&uf);VecFree(&ys);
    3529        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug); VecFree(&ug); VecFree(&uf);
    3630}

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

    r8404 r8803  
    1313
    1414        /*intermediary: */
    15         Mat Kgg = NULL, Kff = NULL, Kfs   = NULL;
    16         Vec ug  = NULL, uf  = NULL, old_ug= NULL, old_uf = NULL;
    17         Vec pg  = NULL, pf  = NULL;
    18         Vec dg  = NULL, df  = NULL;
     15        Mat Kff = NULL, Kfs   = NULL;
     16        Vec ug  = NULL, old_ug = NULL;
     17        Vec uf  = NULL, old_uf = NULL;
     18        Vec pf  = NULL;
     19        Vec df  = NULL;
     20        Vec ys  = NULL;
    1921       
    2022        Loads* loads=NULL;
    … …  
    2527
    2628        /*parameters:*/
    27         bool kffpartitioning=false;
    2829        int min_mechanical_constraints;
    2930        int max_nonlinear_iterations;
     31        int  analysis_type;
     32
    3033
    3134        /*Recover parameters: */
    32         femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    3335        femmodel->parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);
    3436        femmodel->parameters->FindParam(&max_nonlinear_iterations,MaxNonlinearIterationsEnum);
    35        
     37        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     38
    3639        /*Were loads requested as output? : */
    3740        if(conserve_loads) loads=(Loads*)femmodel->loads->Copy(); //protect loads from being modified by the solution
    … …  
    4346        /*Start non-linear iteration using input velocity: */
    4447        GetSolutionFromInputsx(&ug, femmodel->elements, femmodel->nodes, femmodel->vertices, loads, femmodel->materials, femmodel->parameters);
    45         Reducevectorgtofx(&uf, ug, femmodel->nodesets,femmodel->parameters);
     48        Reducevectorgtofx(&uf, ug, femmodel->nodes,femmodel->parameters);
    4649
    4750        //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    … …  
    5457                VecFree(&old_uf);old_uf=uf;
    5558
    56                 if(kffpartitioning){
    57                         SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf, NULL, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
    58                         Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
    59                 }
    60                 else{
    61                         SystemMatricesx(&Kgg, NULL, NULL, &pg,NULL, &dg, NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
    62                         Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
    63                         Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets); VecFree(&pg); MatFree(&Kfs);
    64                         Reducevectorgtofx(&df, dg, femmodel->nodesets,femmodel->parameters); VecFree(&dg);
    65                 }
    66                
     59                SystemMatricesx(&Kff, &Kfs, &pf, &df, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
     60                CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     61                Reduceloadx(pf, Kfs, ys); MatFree(&Kfs);
    6762                Solverx(&uf, Kff, pf, old_uf, df, femmodel->parameters);
    68                 Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);
     63                Mergesolutionfromftogx(&ug, uf,ys,femmodel->nodes,femmodel->parameters);VecFree(&ys);
    6964                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
    7065
    … …  
    9590        if(conserve_loads) delete loads;
    9691        VecFree(&uf);
    97         VecFree(&ug);
    9892        VecFree(&old_uf);
    99         VecFree(&old_ug);
    10093}

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

    r7391 r8803  
    1313
    1414        /*intermediary: */
    15         Mat Kgg_horiz = NULL, Kff_horiz = NULL, Kfs_horiz   = NULL;
    16         Vec ug_horiz  = NULL, uf_horiz  = NULL, old_ug_horiz= NULL, old_uf_horiz = NULL;
    17         Vec pg_horiz  = NULL, pf_horiz  = NULL;
    18         Vec dg_horiz  = NULL, df_horiz  = NULL;
    19         Mat Kgg_vert  = NULL, Kff_vert  = NULL, Kfs_vert    = NULL;
     15        Mat Kff_horiz = NULL, Kfs_horiz   = NULL;
     16        Vec ug_horiz  = NULL, uf_horiz  = NULL, old_uf_horiz = NULL;
     17        Vec pf_horiz  = NULL;
     18        Vec df_horiz  = NULL;
     19        Mat Kff_vert  = NULL, Kfs_vert    = NULL;
    2020        Vec ug_vert   = NULL, uf_vert   = NULL;
    21         Vec pg_vert   = NULL, pf_vert   = NULL;
    22         Vec dg_vert   = NULL, df_vert   = NULL;
     21        Vec pf_vert   = NULL;
     22        Vec df_vert   = NULL;
     23        Vec ys   = NULL;
    2324        int converged;
    2425        int constraints_converged;
    … …  
    2728
    2829        /*parameters:*/
    29         bool kffpartitioning=false;
    3030        int min_mechanical_constraints;
    3131        int max_nonlinear_iterations;
     32        int analysis_type;
    3233
    3334        /*Recover parameters: */
    34         femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    3535        femmodel->parameters->FindParam(&min_mechanical_constraints,MinMechanicalConstraintsEnum);
    3636        femmodel->parameters->FindParam(&max_nonlinear_iterations,MaxNonlinearIterationsEnum);
    … …  
    4242        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    4343        GetSolutionFromInputsx(&ug_horiz, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters);
    44         Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodesets,femmodel->parameters);
     44        Reducevectorgtofx(&uf_horiz, ug_horiz, femmodel->nodes,femmodel->parameters);
    4545
    4646        for(;;){
    … …  
    4949                /*First diagnostic horiz:*/
    5050                femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    51                
     51                femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     52       
    5253                //Update once again the solution to make sure that vx and vxold are similar (for next step in transient or steadystate)
    5354                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
    5455
    5556                //save pointer to old velocity
    56                 VecFree(&old_ug_horiz);old_ug_horiz=ug_horiz;
    5757                VecFree(&old_uf_horiz);old_uf_horiz=uf_horiz;
    5858
    59                 if(kffpartitioning){
    60                         SystemMatricesx(NULL,&Kff_horiz, &Kfs_horiz, NULL,&pf_horiz, NULL, &df_horiz, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    61                         Reduceloadx(pf_horiz, Kfs_horiz, femmodel->ys); MatFree(&Kfs_horiz);
    62                 }
    63                 else{
    64                         SystemMatricesx(&Kgg_horiz, NULL, NULL, &pg_horiz,NULL, &dg_horiz,NULL,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    65                         Reducematrixfromgtofx(&Kff_horiz,&Kfs_horiz,Kgg_horiz,femmodel->nodesets); MatFree(&Kgg_horiz);
    66                         Reduceloadfromgtofx(&pf_horiz, pg_horiz, Kfs_horiz, femmodel->ys, femmodel->nodesets); VecFree(&pg_horiz); MatFree(&Kfs_horiz);
    67                         Reducevectorgtofx(&df_horiz, dg_horiz, femmodel->nodesets,femmodel->parameters); VecFree(&dg_horiz);
    68                 }
    69                
     59                /*solve: */
     60                SystemMatricesx(&Kff_horiz, &Kfs_horiz, &pf_horiz, &df_horiz, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     61                CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     62                Reduceloadx(pf_horiz, Kfs_horiz, ys); MatFree(&Kfs_horiz);
    7063                Solverx(&uf_horiz, Kff_horiz, pf_horiz, old_uf_horiz, df_horiz,femmodel->parameters);
    71                 Mergesolutionfromftogx(&ug_horiz, uf_horiz,femmodel->ys,femmodel->nodesets);
     64                Mergesolutionfromftogx(&ug_horiz, uf_horiz,ys,femmodel->nodes,femmodel->parameters); VecFree(&ys);
    7265                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_horiz);
    7366
    … …  
    7669                /*Second compute vertical velocity: */
    7770                femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
    78                 if(kffpartitioning){
    79                         SystemMatricesx(NULL,&Kff_vert, &Kfs_vert, NULL,&pf_vert, NULL, &df_vert,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    80                         Reduceloadx(pf_vert, Kfs_vert, femmodel->ys); MatFree(&Kfs_vert);
    81                 }
    82                 else{
    83                         SystemMatricesx(&Kgg_vert, NULL, NULL, &pg_vert,NULL, &dg_horiz, NULL, NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    84                         Reducematrixfromgtofx(&Kff_vert,&Kfs_vert,Kgg_vert,femmodel->nodesets); MatFree(&Kgg_vert);
    85                         Reduceloadfromgtofx(&pf_vert, pg_vert, Kfs_vert, femmodel->ys, femmodel->nodesets);VecFree(&pg_vert); MatFree(&Kfs_vert);
    86                         Reducevectorgtofx(&df_vert, dg_vert, femmodel->nodesets,femmodel->parameters); VecFree(&dg_vert);
    87                 }
    88 
     71                femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
     72               
     73                /*solve: */
     74                SystemMatricesx(&Kff_vert, &Kfs_vert, &pf_vert,  &df_vert,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     75                CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     76                Reduceloadx(pf_vert, Kfs_vert, ys); MatFree(&Kfs_vert);
    8977                Solverx(&uf_vert, Kff_vert, pf_vert, NULL, df_vert,femmodel->parameters); MatFree(&Kff_vert); VecFree(&pf_vert); VecFree(&df_vert);
    90                 Mergesolutionfromftogx(&ug_vert, uf_vert,femmodel->ys,femmodel->nodesets);VecFree(&uf_vert);
     78                Mergesolutionfromftogx(&ug_vert, uf_vert,ys,femmodel->nodes,femmodel->parameters);VecFree(&uf_vert); VecFree(&ys);
    9179                InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug_vert); VecFree(&ug_vert); VecFree(&uf_vert);
    9280
    … …  
    10290        /*clean-up*/
    10391        VecFree(&uf_horiz);
    104         VecFree(&ug_horiz);
    10592        VecFree(&old_uf_horiz);
    106         VecFree(&old_ug_horiz);
     93        VecFree(&ys);
    10794}

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

    r8404 r8803  
    1414        Vec tf=NULL;
    1515        Vec tf_old=NULL;
     16        Vec ys=NULL;
    1617        double melting_offset;
    1718
    1819        /*intermediary: */
    19         Mat Kgg=NULL;
    2020        Mat Kff=NULL;
    2121        Mat Kfs=NULL;
    22         Vec pg=NULL;
    2322        Vec pf=NULL;
    24         Vec dg=NULL;
    2523        Vec df=NULL;
    2624
    … …  
    3533        int kflag,pflag;
    3634        bool lowmem=0;
    37         bool kffpartitioning;
     35        int  analysis_type;
     36
    3837
    3938        /*Recover parameters: */
    4039        kflag=1; pflag=1;
    41         femmodel->parameters->FindParam(&kffpartitioning,KffEnum);
    4240        femmodel->parameters->FindParam(&lowmem,LowmemEnum);
    4341        femmodel->parameters->FindParam(&min_thermal_constraints,MinThermalConstraintsEnum);
     42        femmodel->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    4443
    4544        count=1;
    … …  
    5150        for(;;){
    5251
    53                 if(kffpartitioning){
    54                         SystemMatricesx(NULL,&Kff, &Kfs, NULL,&pf,NULL, &df, &melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    55                         Reduceloadx(pf, Kfs, femmodel->ys); MatFree(&Kfs);
    56                 }
    57                 else{
    58                         SystemMatricesx(&Kgg,NULL, NULL, &pg,NULL, &dg, NULL, &melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
    59                         Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
    60                         Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
    61                         Reducevectorgtofx(&df, dg, femmodel->nodesets,femmodel->parameters); VecFree(&dg);
    62                 }
    63 
    64                 VecFree(&tf);
     52                SystemMatricesx(&Kff, &Kfs, &pf,&df, &melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
     53                CreateNodalConstraintsx(&ys,femmodel->nodes,analysis_type);
     54                Reduceloadx(pf, Kfs, ys); MatFree(&Kfs); VecFree(&tf);
    6555                Solverx(&tf, Kff, pf,tf_old, df, femmodel->parameters);
    6656                VecFree(&tf_old); VecDuplicatePatch(&tf_old,tf);
    6757                MatFree(&Kff);VecFree(&pf);VecFree(&tg); VecFree(&df);
    68 
    69                 Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets);
     58                Mergesolutionfromftogx(&tg, tf,ys,femmodel->nodes,femmodel->parameters); VecFree(&ys);
    7059                InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);
    7160
    … …  
    9079        VecFree(&tf);
    9180        VecFree(&tf_old);
     81        VecFree(&ys);
    9282}

  • issm/trunk/src/m/classes/version/7.6/model.m

    r8734 r8803  
    351351
    352352                 %solution parameters
    353                  kff=0;
    354353                 loadresults=0;
    355354
    … …  
    782781                         md.petscoptions=addoptions(md.petscoptions,DiagnosticVertAnalysisEnum,mumpsoptions);
    783782
    784                          %solution speed-up
    785                          md.kff=1;
    786 
    787783                         %hydrology:  from Johnson's 2002 thesis, section 3.5.4
    788784                         md.hydro_n=.02;

  • issm/trunk/src/m/classes/version/7.7/model.m

    r8734 r8803  
    351351
    352352                 %solution parameters
    353                  kff=0;
    354353                 loadresults=0;
    355354
    … …  
    854853                         md.petscoptions=addoptions(md.petscoptions,DiagnosticVertAnalysisEnum,mumpsoptions);
    855854
    856                          %solution speed-up
    857                          md.kff=1;
    858855
    859856                         %hydrology:  from Johnson's 2002 thesis, section 3.5.4

  • issm/trunk/src/m/model/marshall.m

    r8650 r8803  
    193193WriteData(fid,md.shelf_dampening,'Integer','shelf_dampening');
    194194WriteData(fid,md.waitonlock,'Scalar','waitonlock');
    195 WriteData(fid,md.kff,'Integer','kff');
    196195
    197196%Thermal parameters

  • issm/trunk/src/m/solutions/NewFemModel.m

    r8592 r8803  
    2121   
    2222        %Initialize some fiels with empty celils
    23         femmodel.m_nodesets=cell(nummodels,1);
    24         femmodel.m_ys=cell(nummodels,1);
    2523        femmodel.results=struct([]);
    2624
    … …  
    4442                [femmodel.nodes]=NodesDof(femmodel.nodes,femmodel.parameters);
    4543
    46                 issmprintf(VerboseMProcessor(),'%s','      create nodal constraints vector');
    47                 femmodel.m_ys{i}=CreateNodalConstraints(femmodel.nodes,analysis_type);
    48 
    49                 issmprintf(VerboseMProcessor(),'%s','      create node sets');
    50                 femmodel.m_nodesets{i}=BuildNodeSets(femmodel.nodes,analysis_type);
    51 
    5244                issmprintf(VerboseMProcessor(),'%s','      configuring elements and loads');
    5345                [femmodel.elements,femmodel.loads,femmodel.nodes,femmodel.parameters] = ConfigureObjects( femmodel.elements, femmodel.loads, femmodel.nodes, femmodel.vertices,femmodel.materials,femmodel.parameters);

  • issm/trunk/src/m/solutions/ResetBoundaryConditions.m

    r6323 r8803  
    1212        femmodel=SetCurrentConfiguration(femmodel,analysis_type);
    1313
     14        %recreate constraints vector for the current analysis
    1415        ug=GetSolutionFromInputs(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     16        ys=Reducevectorgtos(ug,femmode.nodes,femmodel.parameters);
    1517
    16         %For this analysis_type, free existing boundary condition vectors:
    17         analysis_counter=femmodel.parameters.AnalysisCounter+1; %matlab indexing on counter
    18         femmodel.m_ys{analysis_counter}=[];
    19 
    20         %Reduce from g to s set
    21         ys=Reducevectorgtos(ug,femmodel.m_nodesets{analysis_counter},femmodel.parameters);
    22 
    23         %in the s-set
    24         femmodel.m_ys{analysis_counter}=ys;
    25 
     18        %update values of spcs inside nodes
     19        femmodel.nodes=UpdateSpcs(femmodel.nodes,femmodel.parameters,ys);

  • issm/trunk/src/m/solutions/SetCurrentConfiguration.m

    r5776 r8803  
    3737        end
    3838       
    39         %activate matrices and vectors:
    40         femmodel.nodesets=femmodel.m_nodesets{found};
    41         femmodel.ys=femmodel.m_ys{found};
    42 
    4339        %Now, plug analysis_counter and analysis_type inside the parameters:
    4440        %set counter and analyse_type

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

    r7391 r8803  
    66
    77        %Get parameters
    8         kffpartitioning=femmodel.parameters.Kff;
     8        analysis_type=femmodel.parameters.AnalysisType;
    99
    10         if kffpartitioning,
    11                 [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    12                 p_f = Reduceload( p_f, K_fs, femmodel.ys,true);
    13 
    14         else
    15                 [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    16                 [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    17                 p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets,true);
    18                 df=Reducevectorgtof( dg, femmodel.nodesets,femmodel.parameters);
    19         end
     10        [K_ff,K_fs,p_f,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     11        ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     12        p_f = Reduceload( p_f, K_fs, ys,true);
    2013
    2114        issmprintf(VerboseSolver(),'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    2215        u_f=Solver(K_ff,p_f,[],df,femmodel.parameters);
    23         u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets,true);
     16        u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodes,femmodel.parameters,true);
    2417
    2518        [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_linear.m

    r7391 r8803  
    66
    77        %Get parameters
    8         kffpartitioning=femmodel.parameters.Kff;
     8        analysis_type=femmodel.parameters.AnalysisType;
    99
    10         if kffpartitioning,
    11                 [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    12                 p_f = Reduceload( p_f, K_fs, femmodel.ys);
    13         else
    14                 [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    15                 [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    16                 p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets);
    17                 df=Reducevectorgtof( dg, femmodel.nodesets,femmodel.parameters);
    18         end
     10        [K_ff,K_fs,p_f,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     11        ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     12        p_f = Reduceload( p_f, K_fs, ys);
    1913
    2014        issmprintf(VerboseSolver(),'%s%g','      condition number of stiffness matrix: ',condest(K_ff));
    2115        u_f=Solver(K_ff,p_f,[],df,femmodel.parameters);
    22         u_g= Mergesolutionfromftog( u_f, femmodel.ys, femmodel.nodesets);
    23 
     16        u_g= Mergesolutionfromftog( u_f, ys, femmodel.nodes,femmodel.parameters);
    2417        [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_nonlinear.m

    r8404 r8803  
    66
    77        %Branch on partitioning schema requested
    8         kffpartitioning=femmodel.parameters.Kff;
    98        min_mechanical_constraints=femmodel.parameters.MinMechanicalConstraints;
     9        analysis_type=femmodel.parameters.AnalysisType;
    1010
    1111        %keep a copy of loads for now
    … …  
    1717        %Start non-linear iteration using input velocity:
    1818        ug=GetSolutionFromInputs(femmodel.elements, femmodel.nodes, femmodel.vertices, loads, femmodel.materials, femmodel.parameters);
    19         uf=Reducevectorgtof( ug, femmodel.nodesets,femmodel.parameters);
     19        uf=Reducevectorgtof( ug, femmodel.nodes,femmodel.parameters);
    2020
    2121        %Update the solution to make sure that vx and vxold are similar
    … …  
    2828                old_uf=uf;
    2929
    30                 if kffpartitioning,
    31                         [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters);
    32                         p_f = Reduceload( p_f, K_fs, femmodel.ys);
    33                 else
    34                         [K_gg,K_ff,K_fs,p_g,p_f,dg,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters);
    35                         [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    36                         p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets);
    37                         df=Reducevectorgtof( dg, femmodel.nodesets,femmodel.parameters);
    38                 end
     30                [K_ff,K_fs,p_f,df,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters);
     31                ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     32                p_f = Reduceload( p_f, K_fs, femmodel.ys);
    3933
    4034                uf=Solver(K_ff,p_f,old_uf,df,femmodel.parameters);
    41                 ug= Mergesolutionfromftog( uf, femmodel.ys, femmodel.nodesets);
     35                ug= Mergesolutionfromftog( uf, ys, femmodel.nodes,femmodel.parameters);
    4236
    4337                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,loads,femmodel.materials,femmodel.parameters,ug);

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

    r7392 r8803  
    44%   Usage:
    55%      [femmodel]=solver_couplingstokes_nonlinear(femmodel,conserve_loads)
    6 
    7         %Get parameters
    8         kffpartitioning=femmodel.parameters.Kff;
    96
    107        %initialize solution vector
    … …  
    1411        femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum);
    1512        ug_horiz=GetSolutionFromInputs(femmodel.elements, femmodel.nodes, femmodel.vertices, femmodel.loads, femmodel.materials, femmodel.parameters);
    16         uf_horiz=Reducevectorgtof( ug_horiz, femmodel.nodesets,femmodel.parameters);
     13        uf_horiz=Reducevectorgtof( ug_horiz, femmodel.nodes,femmodel.parameters);
    1714
    1815        while(~converged),
    … …  
    2017                %First compute the horizontal velocity
    2118                femmodel=SetCurrentConfiguration(femmodel,DiagnosticHorizAnalysisEnum);
     19                analysis_type=femmodel.parameters.AnalysisType;
    2220
    2321                %Update the solution to make sure that vx and vxold are similar
    … …  
    2826                old_uf_horiz=uf_horiz;
    2927
    30                 if kffpartitioning,
    31                         [K_gg_horiz,K_ff_horiz,K_fs_horiz,p_g_horiz,p_f_horiz,d_g_horiz,d_f_horiz,kmax_horiz]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    32                         p_f_horiz = Reduceload( p_f_horiz, K_fs_horiz, femmodel.ys);
    33                 else
    34                         [K_gg_horiz,K_ff_horiz,K_fs_horiz,p_g_horiz,p_f_horiz,d_g_horiz,d_f_horiz,kmax]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    35                         [K_ff_horiz, K_fs_horiz] = Reducematrixfromgtof( K_gg_horiz, femmodel.nodesets);
    36                         p_f_horiz = Reduceloadfromgtof( p_g_horiz, K_fs_horiz, femmodel.ys, femmodel.nodesets);
    37                         d_f_horiz=Reducevectorgtof( d_g_horiz, femmodel.nodesets,femmodel.parameters);
    38 
    39                 end
     28                [K_ff_horiz,K_fs_horiz,p_f_horiz,d_f_horiz,kmax_horiz]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     29                ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     30                p_f_horiz = Reduceload( p_f_horiz, K_fs_horiz, ys);
    4031
    4132                uf_horiz=Solver(K_ff_horiz,p_f_horiz,old_uf_horiz,d_f_horiz,femmodel.parameters);
    42                 ug_horiz= Mergesolutionfromftog( uf_horiz, femmodel.ys, femmodel.nodesets);
     33                ug_horiz= Mergesolutionfromftog( uf_horiz, ys, femmodel.nodes,femmodel.parameters);
    4334
    4435                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ug_horiz);
    … …  
    4940                %Then compute vertical velocity
    5041                femmodel=SetCurrentConfiguration(femmodel,DiagnosticVertAnalysisEnum);
     42                analysis_type=femmodel.parameters.AnalysisType;
    5143
    52                 if kffpartitioning,
    53                         [K_gg_vert,K_ff_vert,K_fs_vert,p_g_vert,p_f_vert,d_g_vert,d_f_vert,kmax_vert]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    54                         p_f_vert = Reduceload( p_f_vert, K_fs_vert, femmodel.ys);
    55                 else
    56                         [K_gg_vert,K_ff_vert,K_fs_vert,p_g_vert,p_f_vert,d_g_vert,d_f_vert,kmax_vert]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    57                         [K_ff_vert, K_fs_vert] = Reducematrixfromgtof( K_gg_vert, femmodel.nodesets);
    58                         p_f_vert = Reduceloadfromgtof( p_g_vert, K_fs_vert, femmodel.ys, femmodel.nodesets);
    59                         d_f_vert=Reducevectorgtof( d_g_vert, femmodel.nodesets,femmodel.parameters);
    60                 end
     44                [K_ff_vert,K_fs_vert,p_f_vert,d_f_vert,kmax_vert]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     45                ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     46                p_f_vert = Reduceload( p_f_vert, K_fs_vert, ys);
    6147
    6248                uf_vert=Solver(K_ff_vert,p_f_vert,[],d_f_vert,femmodel.parameters);
    63                 ug_vert= Mergesolutionfromftog( uf_vert, femmodel.ys, femmodel.nodesets);
     49                ug_vert= Mergesolutionfromftog( uf_vert, ys, femmodel.nodes,femmodel.parameters);
    6450
    6551                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,ug_vert);

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

    r8404 r8803  
    1010
    1111        %Get parameters
    12         kffpartitioning=femmodel.parameters.Kff;
     12        analysis_type=femmodel.parameters.AnalysisType;
    1313
    1414        %stiffness and load generation only:
    … …  
    2323        while(~converged),
    2424
    25                 if kffpartitioning,
    26                         [K_gg,K_ff,K_fs,p_g,p_f,d_g,d_f,melting_offset]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    27                         p_f = Reduceload( p_f, K_fs, femmodel.ys);
    28                 else
    29                         [K_gg,K_ff,K_fs,p_g,p_f,d_g,d_f,melting_offset]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
    30                         [K_ff, K_fs] = Reducematrixfromgtof( K_gg, femmodel.nodesets);
    31                         p_f = Reduceloadfromgtof( p_g, K_fs, femmodel.ys, femmodel.nodesets);
    32                         d_f=Reducevectorgtof( d_g, femmodel.nodesets,femmodel.parameters);
    33 
    34                 end
     25                [K_ff,K_fs,p_f,d_f,melting_offset]=SystemMatrices(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters);
     26                ys=CreateNodalConstraints(femmodel.nodes,analysis_type);
     27                p_f = Reduceload( p_f, K_fs, ys);
    3528
    3629                issmprintf(VerboseSolver(),'%s%g','   condition number of stiffness matrix: ',condest(K_ff));
    3730                t_f=Solver(K_ff,p_f,[],d_f,femmodel.parameters);
    38                 t_g= Mergesolutionfromftog( t_f, femmodel.ys, femmodel.nodesets);
     31                t_g= Mergesolutionfromftog( t_f, ys, femmodel.nodes,femmodel.parameters);
    3932
    4033                [femmodel.elements,femmodel.materials]=InputUpdateFromSolution(femmodel.elements,femmodel.nodes,femmodel.vertices,femmodel.loads,femmodel.materials,femmodel.parameters,t_g);
Note: See TracChangeset for help on using the changeset viewer.