Changeset 4085


Ignore:
Timestamp:
06/21/10 12:03:03 (15 years ago)
Author:
Eric.Larour
Message:

renamed UpdateInputsFromDakotax to InputUpdateFromDakotax

Location:
issm/trunk/src/c
Files:
60 edited

Legend:

Unmodified
Added
Removed

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

    r4082 r4085  
    430430                                        ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h\
    431431                                        ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp\
    432                                         ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h\
    433                                         ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp\
     432                                        ./modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.h\
     433                                        ./modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.cpp\
    434434                                        ./modules/GetSolutionFromInputsx/GetSolutionFromInputsx.h\
    435435                                        ./modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp\
    … …  
    953953                                        ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h\
    954954                                        ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp\
    955                                         ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h\
    956                                         ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp\
     955                                        ./modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.h\
     956                                        ./modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.cpp\
    957957                                        ./modules/GetSolutionFromInputsx/GetSolutionFromInputsx.h\
    958958                                        ./modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp\

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

    r4082 r4085  
    2929#include "./SystemMatricesx/SystemMatricesx.h"
    3030#include "./InputUpdateFromConstantx/InputUpdateFromConstantx.h"
    31 #include "./UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h"
     31#include "./InputUpdateFromSolutionx/InputUpdateFromSolutionx.h"
    3232#include "./InputUpdateFromDakotax/InputUpdateFromDakotax.h"
    3333#include "./UpdateInputsFromVectorx/UpdateInputsFromVectorx.h"

  • issm/trunk/src/c/objects/Constraints/Rgb.h

    r4079 r4085  
    4141                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4242                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4444
    4545

  • issm/trunk/src/c/objects/Constraints/Spc.h

    r4079 r4085  
    4545                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    47                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     47                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4848                bool    InAnalysis(int analysis_type);
    4949

  • issm/trunk/src/c/objects/DofVec.h

    r4079 r4085  
    5353                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    5454                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    55                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     55                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5656                Object* copy();
    5757

  • issm/trunk/src/c/objects/ElementResults/BeamVertexElementResult.h

    r4079 r4085  
    4444                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747
    4848                /*}}}*/

  • issm/trunk/src/c/objects/ElementResults/DoubleElementResult.h

    r4079 r4085  
    4646                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4747                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    48                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     48                void    InputUpdateFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4949
    5050                                /*}}}*/

  • issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.h

    r4079 r4085  
    4545                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    47                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     47                void    InputUpdateFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
    4949                /*}}}*/

  • issm/trunk/src/c/objects/ElementResults/SingVertexElementResult.h

    r4079 r4085  
    4444                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747
    4848                /*}}}*/

  • issm/trunk/src/c/objects/ElementResults/TriaVertexElementResult.h

    r4079 r4085  
    4444                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747
    4848                /*}}}*/

  • issm/trunk/src/c/objects/Elements/Beam.cpp

    r4076 r4085  
    137137}
    138138/*}}}*/
    139 /*FUNCTION Beam::UpdateInputsFromSolution {{{1*/
    140 void  Beam::UpdateInputsFromSolution(double* solution){
     139/*FUNCTION Beam::InputUpdateFromSolution {{{1*/
     140void  Beam::InputUpdateFromSolution(double* solution){
    141141        ISSMERROR(" not supported yet!");
    142142}

  • issm/trunk/src/c/objects/Elements/Beam.h

    r4079 r4085  
    6161                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution);
     63                void  InputUpdateFromSolution(double* solution);
    6464                void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r4079 r4085  
    631631}
    632632/*}}}*/
    633 /*FUNCTION Penta::UpdateInputsFromSolution {{{1*/
    634 void  Penta::UpdateInputsFromSolution(double* solution){
     633/*FUNCTION Penta::InputUpdateFromSolution {{{1*/
     634void  Penta::InputUpdateFromSolution(double* solution){
    635635
    636636        int analysis_type,sub_analysis_type;
    … …  
    640640        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    641641
    642         /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
     642        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    643643        if (analysis_type==ControlAnalysisEnum){
    644644               
    645                 UpdateInputsFromSolutionDiagnosticHoriz( solution);
     645                InputUpdateFromSolutionDiagnosticHoriz( solution);
    646646        }
    647647        else if (analysis_type==DiagnosticAnalysisEnum){
    … …  
    649649                if (sub_analysis_type==HorizAnalysisEnum){
    650650
    651                         UpdateInputsFromSolutionDiagnosticHoriz( solution);
     651                        InputUpdateFromSolutionDiagnosticHoriz( solution);
    652652                }
    653653                else if (sub_analysis_type==StokesAnalysisEnum){
    654654
    655                         UpdateInputsFromSolutionDiagnosticStokes( solution);
     655                        InputUpdateFromSolutionDiagnosticStokes( solution);
    656656                }
    657657                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    … …  
    660660        else if (analysis_type==SlopeAnalysisEnum){
    661661
    662                 UpdateInputsFromSolutionSlopeCompute( solution);
     662                InputUpdateFromSolutionSlopeCompute( solution);
    663663        }
    664664        else if (analysis_type==PrognosticAnalysisEnum){
    665665
    666                 UpdateInputsFromSolutionPrognostic( solution);
     666                InputUpdateFromSolutionPrognostic( solution);
    667667        }
    668668        else if (analysis_type==Prognostic2AnalysisEnum){
    669669
    670                 UpdateInputsFromSolutionPrognostic2(solution);
     670                InputUpdateFromSolutionPrognostic2(solution);
    671671        }
    672672        else if (analysis_type==BalancedthicknessAnalysisEnum){
    673673
    674                 UpdateInputsFromSolutionBalancedthickness( solution);
     674                InputUpdateFromSolutionBalancedthickness( solution);
    675675        }
    676676        else if (analysis_type==Balancedthickness2AnalysisEnum){
    677677
    678                 UpdateInputsFromSolutionBalancedthickness2( solution);
     678                InputUpdateFromSolutionBalancedthickness2( solution);
    679679        }
    680680        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    681681
    682                 UpdateInputsFromSolutionBalancedvelocities( solution);
     682                InputUpdateFromSolutionBalancedvelocities( solution);
    683683        }
    684684        else{
    … …  
    688688}
    689689/*Object functions*/
    690 /*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/
    691 void  Penta::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){
     690/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticHoriz {{{1*/
     691void  Penta::InputUpdateFromSolutionDiagnosticHoriz(double* solution){
    692692       
    693693       
    … …  
    749749
    750750/*}}}*/
    751 /*FUNCTION Penta::UpdateInputsFromSolutionDiagnosticStokes {{{1*/
    752 void  Penta::UpdateInputsFromSolutionDiagnosticStokes(double* solution){
     751/*FUNCTION Penta::InputUpdateFromSolutionDiagnosticStokes {{{1*/
     752void  Penta::InputUpdateFromSolutionDiagnosticStokes(double* solution){
    753753       
    754754       
    … …  
    806806
    807807/*}}}*/
    808 /*FUNCTION Penta::UpdateInputsFromSolutionSlopeCompute {{{1*/
    809 void  Penta::UpdateInputsFromSolutionSlopeCompute(double* solution){
     808/*FUNCTION Penta::InputUpdateFromSolutionSlopeCompute {{{1*/
     809void  Penta::InputUpdateFromSolutionSlopeCompute(double* solution){
    810810        ISSMERROR(" not supported yet!");
    811811}
    812812/*}}}*/
    813 /*FUNCTION Penta::UpdateInputsFromSolutionPrognostic {{{1*/
    814 void  Penta::UpdateInputsFromSolutionPrognostic(double* solution){
     813/*FUNCTION Penta::InputUpdateFromSolutionPrognostic {{{1*/
     814void  Penta::InputUpdateFromSolutionPrognostic(double* solution){
    815815        ISSMERROR(" not supported yet!");
    816816}
    817817/*}}}*/
    818 /*FUNCTION Penta::UpdateInputsFromSolutionPrognostic2 {{{1*/
    819 void  Penta::UpdateInputsFromSolutionPrognostic2(double* solution){
     818/*FUNCTION Penta::InputUpdateFromSolutionPrognostic2 {{{1*/
     819void  Penta::InputUpdateFromSolutionPrognostic2(double* solution){
    820820        ISSMERROR(" not supported yet!");
    821821}
    822822/*}}}*/
    823 /*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness {{{1*/
    824 void  Penta::UpdateInputsFromSolutionBalancedthickness(double* solution){
     823/*FUNCTION Penta::InputUpdateFromSolutionBalancedthickness {{{1*/
     824void  Penta::InputUpdateFromSolutionBalancedthickness(double* solution){
    825825        ISSMERROR(" not supported yet!");
    826826}
    827827/*}}}*/
    828 /*FUNCTION Penta::UpdateInputsFromSolutionBalancedthickness2 {{{1*/
    829 void  Penta::UpdateInputsFromSolutionBalancedthickness2(double* solution){
     828/*FUNCTION Penta::InputUpdateFromSolutionBalancedthickness2 {{{1*/
     829void  Penta::InputUpdateFromSolutionBalancedthickness2(double* solution){
    830830        ISSMERROR(" not supported yet!");
    831831}
    832832/*}}}*/
    833 /*FUNCTION Penta::UpdateInputsFromSolutionBalancedvelocities {{{1*/
    834 void  Penta::UpdateInputsFromSolutionBalancedvelocities(double* solution){
     833/*FUNCTION Penta::InputUpdateFromSolutionBalancedvelocities {{{1*/
     834void  Penta::InputUpdateFromSolutionBalancedvelocities(double* solution){
    835835        ISSMERROR(" not supported yet!");
    836836}
    … …  
    846846
    847847
    848         /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
     848        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    849849        if (analysis_type==DiagnosticAnalysisEnum){
    850850                if (sub_analysis_type==HorizAnalysisEnum){

  • issm/trunk/src/c/objects/Elements/Penta.h

    r4079 r4085  
    171171                /*updates: */
    172172                void  UpdateFromDakota(void* inputs);
    173                 void  UpdateInputsFromSolution(double* solutiong);
    174                 void  UpdateInputsFromSolutionDiagnosticHoriz( double* solutiong);
    175                 void  UpdateInputsFromSolutionDiagnosticStokes( double* solutiong);
    176                 void  UpdateInputsFromSolutionSlopeCompute( double* solutiong);
    177                 void  UpdateInputsFromSolutionPrognostic( double* solutiong);
    178                 void  UpdateInputsFromSolutionPrognostic2(double* solutiong);
    179                 void  UpdateInputsFromSolutionBalancedthickness( double* solutiong);
    180                 void  UpdateInputsFromSolutionBalancedthickness2( double* solutiong);
    181                 void  UpdateInputsFromSolutionBalancedvelocities( double* solutiong);
     173                void  InputUpdateFromSolution(double* solutiong);
     174                void  InputUpdateFromSolutionDiagnosticHoriz( double* solutiong);
     175                void  InputUpdateFromSolutionDiagnosticStokes( double* solutiong);
     176                void  InputUpdateFromSolutionSlopeCompute( double* solutiong);
     177                void  InputUpdateFromSolutionPrognostic( double* solutiong);
     178                void  InputUpdateFromSolutionPrognostic2(double* solutiong);
     179                void  InputUpdateFromSolutionBalancedthickness( double* solutiong);
     180                void  InputUpdateFromSolutionBalancedthickness2( double* solutiong);
     181                void  InputUpdateFromSolutionBalancedvelocities( double* solutiong);
    182182                void  UpdateInputsFromVector(double* vector, int name, int type);
    183183                void  UpdateInputsFromVector(int* vector, int name, int type);

  • issm/trunk/src/c/objects/Elements/Sing.cpp

    r4076 r4085  
    127127}
    128128/*}}}*/
    129 /*FUNCTION Sing::UpdateInputsFromSolution {{{1*/
    130 void  Sing::UpdateInputsFromSolution(double* solution){
     129/*FUNCTION Sing::InputUpdateFromSolution {{{1*/
     130void  Sing::InputUpdateFromSolution(double* solution){
    131131        ISSMERROR(" not supported yet!");
    132132}

  • issm/trunk/src/c/objects/Elements/Sing.h

    r4079 r4085  
    6161                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solutiong);
     63                void  InputUpdateFromSolution(double* solutiong);
    6464                void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};
    6565                void  InputToResult(int enum_type,int step,double time);

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r4079 r4085  
    550550}
    551551/*}}}*/
    552 /*FUNCTION Tria::UpdateInputsFromSolution {{{1*/
    553 void  Tria::UpdateInputsFromSolution(double* solution){
     552/*FUNCTION Tria::InputUpdateFromSolution {{{1*/
     553void  Tria::InputUpdateFromSolution(double* solution){
    554554
    555555        int analysis_type,sub_analysis_type;
    … …  
    559559        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    560560
    561         /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
     561        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    562562        if (analysis_type==ControlAnalysisEnum){
    563                 UpdateInputsFromSolutionDiagnosticHoriz( solution);
     563                InputUpdateFromSolutionDiagnosticHoriz( solution);
    564564        }
    565565        else if (analysis_type==DiagnosticAnalysisEnum){
    566566                if (sub_analysis_type==HorizAnalysisEnum){
    567                         UpdateInputsFromSolutionDiagnosticHoriz( solution);
     567                        InputUpdateFromSolutionDiagnosticHoriz( solution);
    568568                }
    569569                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    570570        }
    571571        else if (analysis_type==SlopeAnalysisEnum){
    572                 UpdateInputsFromSolutionSlopeCompute( solution);
     572                InputUpdateFromSolutionSlopeCompute( solution);
    573573        }
    574574        else if (analysis_type==PrognosticAnalysisEnum){
    575                 UpdateInputsFromSolutionPrognostic( solution);
     575                InputUpdateFromSolutionPrognostic( solution);
    576576        }
    577577        else if (analysis_type==Prognostic2AnalysisEnum){
    578                 UpdateInputsFromSolutionPrognostic2(solution);
     578                InputUpdateFromSolutionPrognostic2(solution);
    579579        }
    580580        else if (analysis_type==BalancedthicknessAnalysisEnum){
    581                 UpdateInputsFromSolutionBalancedthickness( solution);
     581                InputUpdateFromSolutionBalancedthickness( solution);
    582582        }
    583583        else if (analysis_type==Balancedthickness2AnalysisEnum){
    584                 UpdateInputsFromSolutionBalancedthickness2( solution);
     584                InputUpdateFromSolutionBalancedthickness2( solution);
    585585        }
    586586        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    587                 UpdateInputsFromSolutionBalancedvelocities( solution);
     587                InputUpdateFromSolutionBalancedvelocities( solution);
    588588        }
    589589        else{
    … …  
    592592}
    593593/*}}}*/
    594 /*FUNCTION Tria::UpdateInputsFromSolutionDiagnosticHoriz {{{1*/
    595 void  Tria::UpdateInputsFromSolutionDiagnosticHoriz(double* solution){
     594/*FUNCTION Tria::InputUpdateFromSolutionDiagnosticHoriz {{{1*/
     595void  Tria::InputUpdateFromSolutionDiagnosticHoriz(double* solution){
    596596       
    597597        int i;
    … …  
    652652
    653653/*}}}*/
    654 /*FUNCTION Tria::UpdateInputsFromSolutionSlopeCompute {{{1*/
    655 void  Tria::UpdateInputsFromSolutionSlopeCompute(double* solution){
     654/*FUNCTION Tria::InputUpdateFromSolutionSlopeCompute {{{1*/
     655void  Tria::InputUpdateFromSolutionSlopeCompute(double* solution){
    656656        ISSMERROR(" not supported yet!");
    657657}
    658658/*}}}*/
    659 /*FUNCTION Tria::UpdateInputsFromSolutionPrognostic {{{1*/
    660 void  Tria::UpdateInputsFromSolutionPrognostic(double* solution){
     659/*FUNCTION Tria::InputUpdateFromSolutionPrognostic {{{1*/
     660void  Tria::InputUpdateFromSolutionPrognostic(double* solution){
    661661
    662662        int i;
    … …  
    684684}
    685685/*}}}*/
    686 /*FUNCTION Tria::UpdateInputsFromSolutionPrognostic2 {{{1*/
    687 void  Tria::UpdateInputsFromSolutionPrognostic2(double* solution){
     686/*FUNCTION Tria::InputUpdateFromSolutionPrognostic2 {{{1*/
     687void  Tria::InputUpdateFromSolutionPrognostic2(double* solution){
    688688        ISSMERROR(" not supported yet!");
    689689}
    690690/*}}}*/
    691 /*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness {{{1*/
    692 void  Tria::UpdateInputsFromSolutionBalancedthickness(double* solution){
     691/*FUNCTION Tria::InputUpdateFromSolutionBalancedthickness {{{1*/
     692void  Tria::InputUpdateFromSolutionBalancedthickness(double* solution){
    693693
    694694        int i;
    … …  
    716716}
    717717/*}}}*/
    718 /*FUNCTION Tria::UpdateInputsFromSolutionBalancedthickness2 {{{1*/
    719 void  Tria::UpdateInputsFromSolutionBalancedthickness2(double* solution){
     718/*FUNCTION Tria::InputUpdateFromSolutionBalancedthickness2 {{{1*/
     719void  Tria::InputUpdateFromSolutionBalancedthickness2(double* solution){
    720720        ISSMERROR(" not supported yet!");
    721721}
    722722/*}}}*/
    723 /*FUNCTION Tria::UpdateInputsFromSolutionBalancedvelocities {{{1*/
    724 void  Tria::UpdateInputsFromSolutionBalancedvelocities(double* solution){
     723/*FUNCTION Tria::InputUpdateFromSolutionBalancedvelocities {{{1*/
     724void  Tria::InputUpdateFromSolutionBalancedvelocities(double* solution){
    725725        ISSMERROR(" not supported yet!");
    726726}
    … …  
    735735        parameters->FindParam(&sub_analysis_type,AnalysisTypeEnum);
    736736       
    737         /*Just branch to the correct UpdateInputsFromSolution generator, according to the type of analysis we are carrying out: */
     737        /*Just branch to the correct InputUpdateFromSolution generator, according to the type of analysis we are carrying out: */
    738738        if (analysis_type==DiagnosticAnalysisEnum){
    739739                if (sub_analysis_type==HorizAnalysisEnum){

  • issm/trunk/src/c/objects/Elements/Tria.h

    r4079 r4085  
    150150                /*FUNCTION updates{{{1*/
    151151                void  UpdateFromDakota(void* inputs);
    152                 void  UpdateInputsFromSolution(double* solutiong);
    153                 void  UpdateInputsFromSolutionDiagnosticHoriz( double* solution);
    154                 void  UpdateInputsFromSolutionSlopeCompute( double* solution);
    155                 void  UpdateInputsFromSolutionPrognostic( double* solution);
    156                 void  UpdateInputsFromSolutionPrognostic2(double* solution);
    157                 void  UpdateInputsFromSolutionBalancedthickness( double* solution);
    158                 void  UpdateInputsFromSolutionBalancedthickness2( double* solution);
    159                 void  UpdateInputsFromSolutionBalancedvelocities( double* solution);
     152                void  InputUpdateFromSolution(double* solutiong);
     153                void  InputUpdateFromSolutionDiagnosticHoriz( double* solution);
     154                void  InputUpdateFromSolutionSlopeCompute( double* solution);
     155                void  InputUpdateFromSolutionPrognostic( double* solution);
     156                void  InputUpdateFromSolutionPrognostic2(double* solution);
     157                void  InputUpdateFromSolutionBalancedthickness( double* solution);
     158                void  InputUpdateFromSolutionBalancedthickness2( double* solution);
     159                void  InputUpdateFromSolutionBalancedvelocities( double* solution);
    160160                void  UpdateInputsFromVector(double* vector, int name, int type);
    161161                void  UpdateInputsFromVector(int* vector, int name, int type);

  • issm/trunk/src/c/objects/ExternalResults/BoolExternalResult.h

    r4079 r4085  
    6161                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     63                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/
    6565                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/ExternalResults/DoubleExternalResult.h

    r4079 r4085  
    6161                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     63                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/
    6565                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/ExternalResults/DoubleVecExternalResult.h

    r4079 r4085  
    6060                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6161                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363                /*}}}*/
    6464                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/ExternalResults/IntExternalResult.h

    r4079 r4085  
    6161                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     63                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/
    6565                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/ExternalResults/PetscVecExternalResult.h

    r4079 r4085  
    5959                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6060                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                /*}}}*/
    6363                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/ExternalResults/StringExternalResult.h

    r4079 r4085  
    6060                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6161                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363                /*}}}*/
    6464                /*ExternalResult methods: {{{1*/

  • issm/trunk/src/c/objects/Inputs/BeamVertexInput.h

    r4079 r4085  
    4343                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     45                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/BoolInput.h

    r4079 r4085  
    4343                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/DoubleInput.h

    r4079 r4085  
    4444                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4545                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4747
    4848                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/IntInput.h

    r4079 r4085  
    4343                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    45                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4646
    4747                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.h

    r4079 r4085  
    4242                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    44                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/SingVertexInput.h

    r4079 r4085  
    4242                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    44                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.h

    r4079 r4085  
    4242                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4343                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545
    4646                Input* SpawnSingInput(int  index);

  • issm/trunk/src/c/objects/Loads/Icefront.cpp

    r4079 r4085  
    13761376}
    13771377/*}}}*/
    1378 /*FUNCTION Icefront::UpdateInputsFromSolution(double* solution) {{{1*/
    1379 void  Icefront::UpdateInputsFromSolution(double* solution){
     1378/*FUNCTION Icefront::InputUpdateFromSolution(double* solution) {{{1*/
     1379void  Icefront::InputUpdateFromSolution(double* solution){
    13801380        /*Nothing updated yet*/
    13811381}

  • issm/trunk/src/c/objects/Loads/Icefront.h

    r4079 r4085  
    5555                void  InputUpdateFromConstant(int constant, int name);
    5656                void  InputUpdateFromConstant(bool constant, int name);
    57                 void  UpdateInputsFromSolution(double* solution);
     57                void  InputUpdateFromSolution(double* solution);
    5858                bool  InAnalysis(int analysis_type);
    5959                /*}}}*/

  • issm/trunk/src/c/objects/Loads/Numericalflux.h

    r4079 r4085  
    5050                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    5151                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    52                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     52                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5353                bool    InAnalysis(int analysis_type);
    5454

  • issm/trunk/src/c/objects/Loads/Pengrid.cpp

    r4079 r4085  
    776776}
    777777/*}}}*/
    778 /*FUNCTION Pengrid::UpdateInputsFromSolution(double* solution) {{{1*/
    779 void  Pengrid::UpdateInputsFromSolution(double* solution){
     778/*FUNCTION Pengrid::InputUpdateFromSolution(double* solution) {{{1*/
     779void  Pengrid::InputUpdateFromSolution(double* solution){
    780780        /*Nothing updated yet*/
    781781}

  • issm/trunk/src/c/objects/Loads/Pengrid.h

    r4079 r4085  
    5656                void  InputUpdateFromConstant(int constant, int name);
    5757                void  InputUpdateFromConstant(bool constant, int name);
    58                 void  UpdateInputsFromSolution(double* solution);
     58                void  InputUpdateFromSolution(double* solution);
    5959                bool  InAnalysis(int analysis_type);
    6060

  • issm/trunk/src/c/objects/Loads/Penpair.h

    r4079 r4085  
    4747                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    4848                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    49                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     49                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5050                bool  InAnalysis(int analysis_type);
    5151                /*}}}*/

  • issm/trunk/src/c/objects/Loads/Riftfront.h

    r4079 r4085  
    6565                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    6666                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    67                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     67                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6868                bool    InAnalysis(int analysis_type);
    6969

  • issm/trunk/src/c/objects/Materials/Material.h

    r4043 r4085  
    2929                virtual void  UpdateInputsFromVector(int* vector, int name, int type)=0;
    3030                virtual void  UpdateInputsFromVector(bool* vector, int name, int type)=0;
    31                 virtual void  UpdateInputsFromSolution(double* solution)=0;
     31                virtual void  InputUpdateFromSolution(double* solution)=0;
    3232               
    3333};

  • issm/trunk/src/c/objects/Materials/Matice.cpp

    r4079 r4085  
    458458}
    459459/*}}}*/
    460 /*FUNCTION Matice::UpdateInputsFromSolution(double* solution) {{{1*/
    461 void  Matice::UpdateInputsFromSolution(double* solution){
    462         /*Nothing updated yet*/
    463 }
    464 /*}}}*/
     460/*FUNCTION Matice::InputUpdateFromSolution(double* solution) {{{1*/
     461void  Matice::InputUpdateFromSolution(double* solution){
     462        /*Nothing updated yet*/
     463}
     464/*}}}*/

  • issm/trunk/src/c/objects/Materials/Matice.h

    r4079 r4085  
    5050                void  InputUpdateFromConstant(int constant, int name);
    5151                void  InputUpdateFromConstant(bool constant, int name);
    52                 void  UpdateInputsFromSolution(double* solution);
     52                void  InputUpdateFromSolution(double* solution);
    5353
    5454};

  • issm/trunk/src/c/objects/Materials/Matpar.cpp

    r4079 r4085  
    309309}
    310310/*}}}*/
    311 /*FUNCTION Matpar::UpdateInputsFromSolution(double* solution) {{{1*/
    312 void   Matpar::UpdateInputsFromSolution(double* solution){
    313         /*Nothing updated yet*/
    314 }
    315 /*}}}*/
     311/*FUNCTION Matpar::InputUpdateFromSolution(double* solution) {{{1*/
     312void   Matpar::InputUpdateFromSolution(double* solution){
     313        /*Nothing updated yet*/
     314}
     315/*}}}*/

  • issm/trunk/src/c/objects/Materials/Matpar.h

    r4079 r4085  
    6262                void   InputUpdateFromConstant(int constant, int name);
    6363                void   InputUpdateFromConstant(bool constant, int name);
    64                 void   UpdateInputsFromSolution(double* solution);
     64                void   InputUpdateFromSolution(double* solution);
    6565
    6666

  • issm/trunk/src/c/objects/Node.h

    r4079 r4085  
    5959                void  InputUpdateFromConstant(int constant, int name);
    6060                void  InputUpdateFromConstant(bool constant, int name);
    61                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                bool  InAnalysis(int analysis_type);
    6363

  • issm/trunk/src/c/objects/Object.h

    r4079 r4085  
    3131                virtual void  InputUpdateFromConstant(int constant, int name)=0;
    3232                virtual void  InputUpdateFromConstant(bool constant, int name)=0;
    33                 virtual void  UpdateInputsFromSolution(double* solution)=0;
     33                virtual void  InputUpdateFromSolution(double* solution)=0;
    3434       
    3535};

  • issm/trunk/src/c/objects/Params/BoolParam.h

    r4079 r4085  
    5656                void  InputUpdateFromConstant(int constant, int name);
    5757                void  InputUpdateFromConstant(bool constant, int name);
    58                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     58                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5959
    6060                /*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleMatParam.h

    r4079 r4085  
    6060                void  InputUpdateFromConstant(bool constant, int name);
    6161
    62                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363
    6464                /*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleParam.h

    r4079 r4085  
    5858                void  InputUpdateFromConstant(bool constant, int name);
    5959
    60                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6161
    6262                /*}}}*/

  • issm/trunk/src/c/objects/Params/DoubleVecParam.h

    r4079 r4085  
    5858                void  InputUpdateFromConstant(bool constant, int name);
    5959
    60                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6161                /*}}}*/
    6262                /*Param methods: {{{1*/

  • issm/trunk/src/c/objects/Params/IntParam.h

    r4079 r4085  
    5757                void  InputUpdateFromConstant(int constant, int name);
    5858                void  InputUpdateFromConstant(bool constant, int name);
    59                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161                /*}}}*/

  • issm/trunk/src/c/objects/Params/PetscMatParam.h

    r4079 r4085  
    5757                void  InputUpdateFromConstant(int constant, int name);
    5858                void  InputUpdateFromConstant(bool constant, int name);
    59                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161                /*}}}*/

  • issm/trunk/src/c/objects/Params/PetscVecParam.h

    r4079 r4085  
    5757                void  InputUpdateFromConstant(int constant, int name);
    5858                void  InputUpdateFromConstant(bool constant, int name);
    59                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161                /*}}}*/

  • issm/trunk/src/c/objects/Params/StringArrayParam.h

    r4079 r4085  
    5959                void  InputUpdateFromConstant(int constant, int name);
    6060                void  InputUpdateFromConstant(bool constant, int name);
    61                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262
    6363                /*}}}*/

  • issm/trunk/src/c/objects/Params/StringParam.h

    r4079 r4085  
    5757                void  InputUpdateFromConstant(int constant, int name);
    5858                void  InputUpdateFromConstant(bool constant, int name);
    59                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161                /*}}}*/

  • issm/trunk/src/c/objects/SolPar.h

    r4079 r4085  
    4646                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4747
    48                 void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     48                void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4949
    5050                /*functionality: */

  • issm/trunk/src/c/objects/Vertex.h

    r4079 r4085  
    5757                void  InputUpdateFromConstant(bool constant, int name);
    5858
    59                 void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060
    6161

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

    r4055 r4085  
    7070        else femmodel->SetCurrentAnalysisAlias(DiagnosticHorizAnalysisEnum,AdjointAnalysisEnum);
    7171       
    72         UpdateInputsFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,adjoint_g);
     72        InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,adjoint_g);
    7373
    7474        /*Free ressources:*/

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

    r4079 r4085  
    102102
    103103                //Update inputs using new solution:
    104                 UpdateInputsFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
     104                InputUpdateFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
    105105
    106106                //Deal with penalty loads

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

    r4055 r4085  
    5656
    5757        //Update inputs using new solution:
    58         UpdateInputsFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
     58        InputUpdateFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
    5959
    6060        /*free ressources: */

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

    r4079 r4085  
    112112                //Update inputs using new solution:
    113113                UpdateInputsFromVectorx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,tg,TemperatureEnum,VertexEnum);
    114                 UpdateInputsFromSolutionx(fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,tg);
     114                InputUpdateFromSolutionx(fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,tg);
    115115
    116116                if (!converged){
Note: See TracChangeset for help on using the changeset viewer.