Changeset 4079


Ignore:
Timestamp:
06/21/10 11:48:36 (15 years ago)
Author:
Eric.Larour
Message:

renamed UpdateInputsFromConstantx to InputUpdateFromConstantx

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

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/DataSet/DataSet.cpp

    r4064 r4079  
    10501050}
    10511051/*}}}*/
    1052 /*FUNCTION DataSet::UpdateInputsFromConstant{{{1*/
    1053 void  DataSet::UpdateInputsFromConstant(double constant, int name){
    1054 
    1055         vector<Object*>::iterator object;
    1056         for ( object=objects.begin() ; object < objects.end(); object++ ){
    1057                 (*object)->UpdateInputsFromConstant(constant,name);
    1058         }
    1059 }
    1060 /*}}}*/
    1061 /*FUNCTION DataSet::UpdateInputsFromConstant{{{1*/
    1062 void  DataSet::UpdateInputsFromConstant(int constant, int name){
    1063 
    1064         vector<Object*>::iterator object;
    1065         for ( object=objects.begin() ; object < objects.end(); object++ ){
    1066                 (*object)->UpdateInputsFromConstant(constant,name);
    1067         }
    1068 }
    1069 /*}}}*/
    1070 /*FUNCTION DataSet::UpdateInputsFromConstant{{{1*/
    1071 void  DataSet::UpdateInputsFromConstant(bool constant, int name){
    1072 
    1073         vector<Object*>::iterator object;
    1074         for ( object=objects.begin() ; object < objects.end(); object++ ){
    1075                 (*object)->UpdateInputsFromConstant(constant,name);
    1076         }
    1077 }
    1078 /*}}}*/
    10791052/*FUNCTION DataSet::UpdateInputsFromVector{{{1*/
    10801053void  DataSet::UpdateInputsFromVector(double* vec, int name, int type){

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

    r4064 r4079  
    6868                void  SetSorting(int* in_sorted_ids,int* in_id_offsets);
    6969                void  Sort();
    70                 void  UpdateInputsFromConstant(double constant, int name);
    71                 void  UpdateInputsFromConstant(int constant, int name);
    72                 void  UpdateInputsFromConstant(bool constant, int name);
    7370                void  UpdateInputsFromVector(double* vector,int name, int type);
    7471                void  UpdateInputsFromVector(int* vector,int name, int type);

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

    r4076 r4079  
    426426                                        ./modules/SplitSolutionVectorx/SplitSolutionVectorx.h\
    427427                                        ./modules/SplitSolutionVectorx/SplitSolutionVectorx.cpp\
    428                                         ./modules/UpdateInputsFromConstantx/UpdateInputsFromConstantx.h\
    429                                         ./modules/UpdateInputsFromConstantx/UpdateInputsFromConstantx.cpp\
     428                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.h\
     429                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.cpp\
    430430                                        ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h\
    431431                                        ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp\
    … …  
    947947                                        ./modules/SplitSolutionVectorx/SplitSolutionVectorx.h\
    948948                                        ./modules/SplitSolutionVectorx/SplitSolutionVectorx.cpp\
    949                                         ./modules/UpdateInputsFromConstantx/UpdateInputsFromConstantx.h\
    950                                         ./modules/UpdateInputsFromConstantx/UpdateInputsFromConstantx.cpp\
     949                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.h\
     950                                        ./modules/InputUpdateFromConstantx/InputUpdateFromConstantx.cpp\
    951951                                        ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h\
    952952                                        ./modules/UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.cpp\

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

    r4078 r4079  
    1 /*!\file UpdateInputsFromConstantx
     1/*!\file InputUpdateFromConstantx
    22 * \brief: update datasets using  parameter inputs
    33 */
    44
    5 #include "./UpdateInputsFromConstantx.h"
     5#include "./InputUpdateFromConstantx.h"
    66#include "../../shared/shared.h"
    77#include "../../include/include.h"
    … …  
    99#include "../../EnumDefinitions/EnumDefinitions.h"
    1010
    11 void UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,bool   constant, int name){
     11void InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,bool   constant, int name){
     12
     13        int i;
    1214
    1315        /*First, get elements and loads configured: */
    … …  
    1719        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    1820       
    19         /*Elements drive the update: */
    20         elements->UpdateInputsFromConstant(constant,name);
    21         loads->UpdateInputsFromConstant(constant,name);
     21        /*Elements and loads drive the update: */
     22        for(i=0;elements->Size();i++){
     23                Element* element=(Element*)elements->GetObjectByOffset(i);
     24                element->InputUpdateFromConstant(constant,name);
     25        }
     26
     27        for(i=0;loads->Size();i++){
     28                Load* load=(Load*)loads->GetObjectByOffset(i);
     29                load->InputUpdateFromConstant(constant,name);
     30        }
    2231}
    23 void UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,int    constant, int name){
     32void InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,int    constant, int name){
     33       
     34        int i;
    2435
    2536        /*First, get elements and loads configured: */
    … …  
    2940        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    3041
    31         /*Elements drive the update: */
    32         elements->UpdateInputsFromConstant(constant,name);
    33         loads->UpdateInputsFromConstant(constant,name);
     42        /*Elements and loads drive the update: */
     43        for(i=0;elements->Size();i++){
     44                Element* element=(Element*)elements->GetObjectByOffset(i);
     45                element->InputUpdateFromConstant(constant,name);
     46        }
     47
     48        for(i=0;loads->Size();i++){
     49                Load* load=(Load*)loads->GetObjectByOffset(i);
     50                load->InputUpdateFromConstant(constant,name);
     51        }
    3452}
    35 void UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double constant, int name){
     53void InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices, DataSet* loads, DataSet* materials, Parameters* parameters,double constant, int name){
     54
     55        int i;
    3656
    3757        /*First, get elements and loads configured: */
    … …  
    4161        parameters->Configure(elements,loads, nodes,vertices, materials,parameters);
    4262
    43         /*Elements drive the update: */
    44         elements->UpdateInputsFromConstant(constant,name);
    45         loads->UpdateInputsFromConstant(constant,name);
     63        /*Elements and loads drive the update: */
     64        for(i=0;elements->Size();i++){
     65                Element* element=(Element*)elements->GetObjectByOffset(i);
     66                element->InputUpdateFromConstant(constant,name);
     67        }
     68
     69        for(i=0;loads->Size();i++){
     70                Load* load=(Load*)loads->GetObjectByOffset(i);
     71                load->InputUpdateFromConstant(constant,name);
     72        }
    4673}

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

    r4078 r4079  
    1 /*!\file:  UpdateInputsFromConstantx.h
     1/*!\file:  InputUpdateFromConstantx.h
    22 * \brief header file for updating datasets from inputs
    33 */
    … …  
    1010
    1111/* local prototypes: */
    12 void            UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, bool   constant, int name);
    13 void            UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, int    constant, int name);
    14 void            UpdateInputsFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, double constant, int name);
     12void            InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, bool   constant, int name);
     13void            InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, int    constant, int name);
     14void            InputUpdateFromConstantx( DataSet* elements,DataSet* nodes, DataSet* vertices,DataSet* loads, DataSet* materials,  Parameters* parameters, double constant, int name);
    1515
    1616#endif  /* _UPDATEINPUTSFROMCONSTANTXX_H */

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

    r4076 r4079  
    2828#include "./ConfigureObjectsx/ConfigureObjectsx.h"
    2929#include "./SystemMatricesx/SystemMatricesx.h"
    30 #include "./UpdateInputsFromConstantx/UpdateInputsFromConstantx.h"
     30#include "./InputUpdateFromConstantx/InputUpdateFromConstantx.h"
    3131#include "./UpdateInputsFromSolutionx/UpdateInputsFromSolutionx.h"
    3232#include "./UpdateInputsFromDakotax/UpdateInputsFromDakotax.h"

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

    r4043 r4079  
    3838                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    3939                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    40                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     40                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4444

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

    r4043 r4079  
    4242                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4343                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4747                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4848                bool    InAnalysis(int analysis_type);

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

    r4043 r4079  
    5050                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5151                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    52                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    53                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    54                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     52                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     53                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     54                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    5555                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5656                Object* copy();

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

    r4050 r4079  
    4141                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4242                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747

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

    r4050 r4079  
    4343                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4444                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    47                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     47                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4848                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4949

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

    r4050 r4079  
    4242                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4343                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4747                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848

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

    r4050 r4079  
    4141                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4242                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747

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

    r4050 r4079  
    4141                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4242                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747

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

    r4076 r4079  
    5858                void  UpdateInputsFromVector(int* vector, int name, int type);
    5959                void  UpdateInputsFromVector(bool* vector, int name, int type);
    60                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6363                void  UpdateInputsFromSolution(double* solution);
    6464                void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};

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

    r4076 r4079  
    48424842}
    48434843/*}}}*/
    4844 /*FUNCTION Penta::UpdateInputsFromConstant(int value, int name);{{{1*/
    4845 void  Penta::UpdateInputsFromConstant(int constant, int name){
     4844/*FUNCTION Penta::InputUpdateFromConstant(int value, int name);{{{1*/
     4845void  Penta::InputUpdateFromConstant(int constant, int name){
    48464846        /*Nothing updated for now*/
    48474847}
    48484848/*}}}*/
    4849 /*FUNCTION Penta::UpdateInputsFromConstant(bool value, int name);{{{1*/
    4850 void  Penta::UpdateInputsFromConstant(bool constant, int name){
     4849/*FUNCTION Penta::InputUpdateFromConstant(bool value, int name);{{{1*/
     4850void  Penta::InputUpdateFromConstant(bool constant, int name){
    48514851        /*Nothing updated for now*/
    48524852}
    48534853/*}}}*/
    4854 /*FUNCTION Penta::UpdateInputsFromConstant(double value, int name);{{{1*/
    4855 void  Penta::UpdateInputsFromConstant(double constant, int name){
     4854/*FUNCTION Penta::InputUpdateFromConstant(double value, int name);{{{1*/
     4855void  Penta::InputUpdateFromConstant(double constant, int name){
    48564856        /*Nothing updated for now*/
    48574857}

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

    r4076 r4079  
    183183                void  UpdateInputsFromVector(int* vector, int name, int type);
    184184                void  UpdateInputsFromVector(bool* vector, int name, int type);
    185                 void  UpdateInputsFromConstant(double constant, int name);
    186                 void  UpdateInputsFromConstant(int constant, int name);
    187                 void  UpdateInputsFromConstant(bool constant, int name);
     185                void  InputUpdateFromConstant(double constant, int name);
     186                void  InputUpdateFromConstant(int constant, int name);
     187                void  InputUpdateFromConstant(bool constant, int name);
    188188               
    189189       

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

    r4076 r4079  
    5858                void  UpdateInputsFromVector(int* vector, int name, int type);
    5959                void  UpdateInputsFromVector(bool* vector, int name, int type);
    60                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6363                void  UpdateInputsFromSolution(double* solutiong);
    6464                void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};

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

    r4076 r4079  
    50015001}
    50025002/*}}}*/
    5003 /*FUNCTION Tria::UpdateInputsFromConstant(int value, int name);{{{1*/
    5004 void  Tria::UpdateInputsFromConstant(int constant, int name){
     5003/*FUNCTION Tria::InputUpdateFromConstant(int value, int name);{{{1*/
     5004void  Tria::InputUpdateFromConstant(int constant, int name){
    50055005        /*Nothing updated for now*/
    50065006}
    50075007/*}}}*/
    5008 /*FUNCTION Tria::UpdateInputsFromConstant(double value, int name);{{{1*/
    5009 void  Tria::UpdateInputsFromConstant(double constant, int name){
     5008/*FUNCTION Tria::InputUpdateFromConstant(double value, int name);{{{1*/
     5009void  Tria::InputUpdateFromConstant(double constant, int name){
    50105010        /*Nothing updated for now*/
    50115011}
    50125012/*}}}*/
    5013 /*FUNCTION Tria::UpdateInputsFromConstant(bool value, int name);{{{1*/
    5014 void  Tria::UpdateInputsFromConstant(bool constant, int name){
     5013/*FUNCTION Tria::InputUpdateFromConstant(bool value, int name);{{{1*/
     5014void  Tria::InputUpdateFromConstant(bool constant, int name){
    50155015        /*Nothing updated for now*/
    50165016}

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

    r4076 r4079  
    161161                void  UpdateInputsFromVector(int* vector, int name, int type);
    162162                void  UpdateInputsFromVector(bool* vector, int name, int type);
    163                 void  UpdateInputsFromConstant(double constant, int name);
    164                 void  UpdateInputsFromConstant(int constant, int name);
    165                 void  UpdateInputsFromConstant(bool constant, int name);
     163                void  InputUpdateFromConstant(double constant, int name);
     164                void  InputUpdateFromConstant(int constant, int name);
     165                void  InputUpdateFromConstant(bool constant, int name);
    166166                /*}}}*/
    167167

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

    r4050 r4079  
    5858                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5959                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6363                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/

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

    r4050 r4079  
    5858                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5959                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6363                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/

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

    r4050 r4079  
    5757                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5858                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    59                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363                /*}}}*/

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

    r4050 r4079  
    5858                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5959                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    62                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     62                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6363                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6464                /*}}}*/

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

    r4050 r4079  
    5656                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5757                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    58                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    59                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     58                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6161                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                /*}}}*/

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

    r4050 r4079  
    5757                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    5858                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    59                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    60                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    61                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     59                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     60                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     61                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6262                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6363                /*}}}*/

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

    r4057 r4079  
    3939                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4040                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    41                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    43                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     41                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     42                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     43                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    4545                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4057 r4079  
    3939                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4040                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    4545                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4057 r4079  
    4141                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4242                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4646                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4747

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

    r4057 r4079  
    3939                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4040                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444
    4545                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4057 r4079  
    3838                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    3939                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    40                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     40                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    4444                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4057 r4079  
    3838                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    3939                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    40                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     40                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4343
    4444                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4057 r4079  
    3939                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4040                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    41                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    42                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    43                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     41                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     42                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     43                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4444                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    4545

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

    r4043 r4079  
    13611361}
    13621362/*}}}*/
    1363 /*FUNCTION Icefront::UpdateInputsFromConstant(double constant, int name) {{{1*/
    1364 void  Icefront::UpdateInputsFromConstant(double constant, int name){
     1363/*FUNCTION Icefront::InputUpdateFromConstant(double constant, int name) {{{1*/
     1364void  Icefront::InputUpdateFromConstant(double constant, int name){
    13651365        /*Nothing updated yet*/
    13661366}
    13671367/*}}}*/
    1368 /*FUNCTION Icefront::UpdateInputsFromConstant(int constant, int name) {{{1*/
    1369 void  Icefront::UpdateInputsFromConstant(int constant, int name){
     1368/*FUNCTION Icefront::InputUpdateFromConstant(int constant, int name) {{{1*/
     1369void  Icefront::InputUpdateFromConstant(int constant, int name){
    13701370        /*Nothing updated yet*/
    13711371}
    13721372/*}}}*/
    1373 /*FUNCTION Icefront::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    1374 void  Icefront::UpdateInputsFromConstant(bool constant, int name){
     1373/*FUNCTION Icefront::InputUpdateFromConstant(bool constant, int name) {{{1*/
     1374void  Icefront::InputUpdateFromConstant(bool constant, int name){
    13751375        /*Nothing updated yet*/
    13761376}

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

    r4043 r4079  
    5252                void  UpdateInputsFromVector(int* vector, int name, int type);
    5353                void  UpdateInputsFromVector(bool* vector, int name, int type);
    54                 void  UpdateInputsFromConstant(double constant, int name);
    55                 void  UpdateInputsFromConstant(int constant, int name);
    56                 void  UpdateInputsFromConstant(bool constant, int name);
     54                void  InputUpdateFromConstant(double constant, int name);
     55                void  InputUpdateFromConstant(int constant, int name);
     56                void  InputUpdateFromConstant(bool constant, int name);
    5757                void  UpdateInputsFromSolution(double* solution);
    5858                bool  InAnalysis(int analysis_type);

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

    r4043 r4079  
    4747                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4848                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    49                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    50                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    51                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     49                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     50                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     51                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    5252                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5353                bool    InAnalysis(int analysis_type);

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

    r4050 r4079  
    748748}
    749749/*}}}*/
    750 /*FUNCTION Pengrid::UpdateInputsFromConstant(double constant, int name) {{{1*/
    751 void  Pengrid::UpdateInputsFromConstant(double constant, int name){
     750/*FUNCTION Pengrid::InputUpdateFromConstant(double constant, int name) {{{1*/
     751void  Pengrid::InputUpdateFromConstant(double constant, int name){
    752752        switch(name){
    753753
    … …  
    759759}
    760760/*}}}*/
    761 /*FUNCTION Pengrid::UpdateInputsFromConstant(int constant, int name) {{{1*/
    762 void  Pengrid::UpdateInputsFromConstant(int constant, int name){
     761/*FUNCTION Pengrid::InputUpdateFromConstant(int constant, int name) {{{1*/
     762void  Pengrid::InputUpdateFromConstant(int constant, int name){
    763763        /*Nothing updated yet*/
    764764}
    765765/*}}}*/
    766 /*FUNCTION Pengrid::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    767 void  Pengrid::UpdateInputsFromConstant(bool constant, int name){
     766/*FUNCTION Pengrid::InputUpdateFromConstant(bool constant, int name) {{{1*/
     767void  Pengrid::InputUpdateFromConstant(bool constant, int name){
    768768
    769769        switch(name){

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

    r4043 r4079  
    5353                void  UpdateInputsFromVector(int* vector, int name, int type);
    5454                void  UpdateInputsFromVector(bool* vector, int name, int type);
    55                 void  UpdateInputsFromConstant(double constant, int name);
    56                 void  UpdateInputsFromConstant(int constant, int name);
    57                 void  UpdateInputsFromConstant(bool constant, int name);
     55                void  InputUpdateFromConstant(double constant, int name);
     56                void  InputUpdateFromConstant(int constant, int name);
     57                void  InputUpdateFromConstant(bool constant, int name);
    5858                void  UpdateInputsFromSolution(double* solution);
    5959                bool  InAnalysis(int analysis_type);

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

    r4043 r4079  
    4444                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4545                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    46                 void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    47                 void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    48                 void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     46                void  InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     47                void  InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     48                void  InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4949                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5050                bool  InAnalysis(int analysis_type);

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

    r4043 r4079  
    6262                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    6363                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    64                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    65                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    66                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     64                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     65                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     66                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    6767                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6868                bool    InAnalysis(int analysis_type);

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

    r4043 r4079  
    443443}
    444444/*}}}*/
    445 /*FUNCTION Matice::UpdateInputsFromConstant(double constant, int name) {{{1*/
    446 void  Matice::UpdateInputsFromConstant(double constant, int name){
    447         /*Nothing updated yet*/
    448 }
    449 /*}}}*/
    450 /*FUNCTION Matice::UpdateInputsFromConstant(int constant, int name) {{{1*/
    451 void  Matice::UpdateInputsFromConstant(int constant, int name){
    452         /*Nothing updated yet*/
    453 }
    454 /*}}}*/
    455 /*FUNCTION Matice::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    456 void  Matice::UpdateInputsFromConstant(bool constant, int name){
     445/*FUNCTION Matice::InputUpdateFromConstant(double constant, int name) {{{1*/
     446void  Matice::InputUpdateFromConstant(double constant, int name){
     447        /*Nothing updated yet*/
     448}
     449/*}}}*/
     450/*FUNCTION Matice::InputUpdateFromConstant(int constant, int name) {{{1*/
     451void  Matice::InputUpdateFromConstant(int constant, int name){
     452        /*Nothing updated yet*/
     453}
     454/*}}}*/
     455/*FUNCTION Matice::InputUpdateFromConstant(bool constant, int name) {{{1*/
     456void  Matice::InputUpdateFromConstant(bool constant, int name){
    457457        /*Nothing updated yet*/
    458458}

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

    r4043 r4079  
    4747                void  UpdateInputsFromVector(int* vector, int name, int type);
    4848                void  UpdateInputsFromVector(bool* vector, int name, int type);
    49                 void  UpdateInputsFromConstant(double constant, int name);
    50                 void  UpdateInputsFromConstant(int constant, int name);
    51                 void  UpdateInputsFromConstant(bool constant, int name);
     49                void  InputUpdateFromConstant(double constant, int name);
     50                void  InputUpdateFromConstant(int constant, int name);
     51                void  InputUpdateFromConstant(bool constant, int name);
    5252                void  UpdateInputsFromSolution(double* solution);
    5353

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

    r4043 r4079  
    294294}
    295295/*}}}*/
    296 /*FUNCTION Matpar::UpdateInputsFromConstant(double constant, int name) {{{1*/
    297 void   Matpar::UpdateInputsFromConstant(double constant, int name){
    298         /*Nothing updated yet*/
    299 }
    300 /*}}}*/
    301 /*FUNCTION Matpar::UpdateInputsFromConstant(int constant, int name) {{{1*/
    302 void   Matpar::UpdateInputsFromConstant(int constant, int name){
    303         /*Nothing updated yet*/
    304 }
    305 /*}}}*/
    306 /*FUNCTION Matpar::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    307 void   Matpar::UpdateInputsFromConstant(bool constant, int name){
     296/*FUNCTION Matpar::InputUpdateFromConstant(double constant, int name) {{{1*/
     297void   Matpar::InputUpdateFromConstant(double constant, int name){
     298        /*Nothing updated yet*/
     299}
     300/*}}}*/
     301/*FUNCTION Matpar::InputUpdateFromConstant(int constant, int name) {{{1*/
     302void   Matpar::InputUpdateFromConstant(int constant, int name){
     303        /*Nothing updated yet*/
     304}
     305/*}}}*/
     306/*FUNCTION Matpar::InputUpdateFromConstant(bool constant, int name) {{{1*/
     307void   Matpar::InputUpdateFromConstant(bool constant, int name){
    308308        /*Nothing updated yet*/
    309309}

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

    r4043 r4079  
    5959                void   UpdateInputsFromVector(int* vector, int name, int type);
    6060                void   UpdateInputsFromVector(bool* vector, int name, int type);
    61                 void   UpdateInputsFromConstant(double constant, int name);
    62                 void   UpdateInputsFromConstant(int constant, int name);
    63                 void   UpdateInputsFromConstant(bool constant, int name);
     61                void   InputUpdateFromConstant(double constant, int name);
     62                void   InputUpdateFromConstant(int constant, int name);
     63                void   InputUpdateFromConstant(bool constant, int name);
    6464                void   UpdateInputsFromSolution(double* solution);
    6565

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

    r4055 r4079  
    855855}
    856856/*}}}*/
    857 /*FUNCTION Node::UpdateInputsFromConstant(double constant, int name){{{2*/
    858 void  Node::UpdateInputsFromConstant(double constant, int name){
     857/*FUNCTION Node::InputUpdateFromConstant(double constant, int name){{{2*/
     858void  Node::InputUpdateFromConstant(double constant, int name){
    859859
    860860        /*Nothing updated yet*/
    861861}
    862862/*}}}*/
    863 /*FUNCTION Node::UpdateInputsFromConstant(int constant, int name){{{2*/
    864 void  Node::UpdateInputsFromConstant(int constant, int name){
     863/*FUNCTION Node::InputUpdateFromConstant(int constant, int name){{{2*/
     864void  Node::InputUpdateFromConstant(int constant, int name){
    865865
    866866        /*Nothing updated yet*/
    867867}
    868868/*}}}*/
    869 /*FUNCTION Node::UpdateInputsFromConstant(bool constant, int name){{{2*/
    870 void  Node::UpdateInputsFromConstant(bool constant, int name){
     869/*FUNCTION Node::InputUpdateFromConstant(bool constant, int name){{{2*/
     870void  Node::InputUpdateFromConstant(bool constant, int name){
    871871
    872872        /*Nothing updated yet*/

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

    r4055 r4079  
    5656                void  UpdateInputsFromVector(int* vector, int name, int type);
    5757                void  UpdateInputsFromVector(bool* vector, int name, int type);
    58                 void  UpdateInputsFromConstant(double constant, int name);
    59                 void  UpdateInputsFromConstant(int constant, int name);
    60                 void  UpdateInputsFromConstant(bool constant, int name);
     58                void  InputUpdateFromConstant(double constant, int name);
     59                void  InputUpdateFromConstant(int constant, int name);
     60                void  InputUpdateFromConstant(bool constant, int name);
    6161                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262                bool  InAnalysis(int analysis_type);

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

    r4043 r4079  
    2828                virtual void  UpdateInputsFromVector(int* vector, int name, int type)=0;
    2929                virtual void  UpdateInputsFromVector(bool* vector, int name, int type)=0;
    30                 virtual void  UpdateInputsFromConstant(double constant, int name)=0;
    31                 virtual void  UpdateInputsFromConstant(int constant, int name)=0;
    32                 virtual void  UpdateInputsFromConstant(bool constant, int name)=0;
     30                virtual void  InputUpdateFromConstant(double constant, int name)=0;
     31                virtual void  InputUpdateFromConstant(int constant, int name)=0;
     32                virtual void  InputUpdateFromConstant(bool constant, int name)=0;
    3333                virtual void  UpdateInputsFromSolution(double* solution)=0;
    3434       

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

    r3834 r4079  
    159159}
    160160/*}}}*/
    161 /*FUNCTION BoolParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    162 void  BoolParam::UpdateInputsFromConstant(double constant, int name){
     161/*FUNCTION BoolParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     162void  BoolParam::InputUpdateFromConstant(double constant, int name){
    163163        /*Nothing updated yet*/
    164164}
    165165/*}}}*/
    166 /*FUNCTION BoolParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    167 void  BoolParam::UpdateInputsFromConstant(int constant, int name){
     166/*FUNCTION BoolParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     167void  BoolParam::InputUpdateFromConstant(int constant, int name){
    168168        /*Nothing updated yet*/
    169169}
    170170/*}}}*/
    171 /*FUNCTION BoolParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    172 void  BoolParam::UpdateInputsFromConstant(bool constant, int name){
     171/*FUNCTION BoolParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     172void  BoolParam::InputUpdateFromConstant(bool constant, int name){
    173173        /*Nothing updated yet*/
    174174}

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

    r4059 r4079  
    5353                void  UpdateInputsFromVector(int* vector, int name, int type);
    5454                void  UpdateInputsFromVector(bool* vector, int name, int type);
    55                 void  UpdateInputsFromConstant(double constant, int name);
    56                 void  UpdateInputsFromConstant(int constant, int name);
    57                 void  UpdateInputsFromConstant(bool constant, int name);
     55                void  InputUpdateFromConstant(double constant, int name);
     56                void  InputUpdateFromConstant(int constant, int name);
     57                void  InputUpdateFromConstant(bool constant, int name);
    5858                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    5959

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

    r4059 r4079  
    215215}
    216216/*}}}*/
    217 /*FUNCTION DoubleMatParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    218 void  DoubleMatParam::UpdateInputsFromConstant(double constant, int name){
    219         /*Nothing updated yet*/
    220 }
    221 /*}}}*/
    222 /*FUNCTION DoubleMatParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    223 void  DoubleMatParam::UpdateInputsFromConstant(int constant, int name){
    224         /*Nothing updated yet*/
    225 }
    226 /*}}}*/
    227 /*FUNCTION DoubleMatParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    228 void  DoubleMatParam::UpdateInputsFromConstant(bool constant, int name){
     217/*FUNCTION DoubleMatParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     218void  DoubleMatParam::InputUpdateFromConstant(double constant, int name){
     219        /*Nothing updated yet*/
     220}
     221/*}}}*/
     222/*FUNCTION DoubleMatParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     223void  DoubleMatParam::InputUpdateFromConstant(int constant, int name){
     224        /*Nothing updated yet*/
     225}
     226/*}}}*/
     227/*FUNCTION DoubleMatParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     228void  DoubleMatParam::InputUpdateFromConstant(bool constant, int name){
    229229        /*Nothing updated yet*/
    230230}

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

    r4059 r4079  
    5656                void  UpdateInputsFromVector(int* vector, int name, int type);
    5757                void  UpdateInputsFromVector(bool* vector, int name, int type);
    58                 void  UpdateInputsFromConstant(double constant, int name);
    59                 void  UpdateInputsFromConstant(int constant, int name);
    60                 void  UpdateInputsFromConstant(bool constant, int name);
     58                void  InputUpdateFromConstant(double constant, int name);
     59                void  InputUpdateFromConstant(int constant, int name);
     60                void  InputUpdateFromConstant(bool constant, int name);
    6161
    6262                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r3888 r4079  
    181181}
    182182/*}}}*/
    183 /*FUNCTION DoubleParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    184 void  DoubleParam::UpdateInputsFromConstant(double constant, int name){
     183/*FUNCTION DoubleParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     184void  DoubleParam::InputUpdateFromConstant(double constant, int name){
    185185        /*Nothing updated yet*/
    186186}
    187187/*}}}*/
    188 /*FUNCTION DoubleParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    189 void  DoubleParam::UpdateInputsFromConstant(int constant, int name){
     188/*FUNCTION DoubleParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     189void  DoubleParam::InputUpdateFromConstant(int constant, int name){
    190190        /*Nothing updated yet*/
    191191}
    192192/*}}}*/
    193 /*FUNCTION DoubleParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    194 void  DoubleParam::UpdateInputsFromConstant(bool constant, int name){
     193/*FUNCTION DoubleParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     194void  DoubleParam::InputUpdateFromConstant(bool constant, int name){
    195195        /*Nothing updated yet*/
    196196}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959
    6060                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4059 r4079  
    225225}
    226226/*}}}*/
    227 /*FUNCTION DoubleVecParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    228 void  DoubleVecParam::UpdateInputsFromConstant(double constant, int name){
    229         /*Nothing updated yet*/
    230 }
    231 /*}}}*/
    232 /*FUNCTION DoubleVecParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    233 void  DoubleVecParam::UpdateInputsFromConstant(int constant, int name){
    234         /*Nothing updated yet*/
    235 }
    236 /*}}}*/
    237 /*FUNCTION DoubleVecParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    238 void  DoubleVecParam::UpdateInputsFromConstant(bool constant, int name){
     227/*FUNCTION DoubleVecParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     228void  DoubleVecParam::InputUpdateFromConstant(double constant, int name){
     229        /*Nothing updated yet*/
     230}
     231/*}}}*/
     232/*FUNCTION DoubleVecParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     233void  DoubleVecParam::InputUpdateFromConstant(int constant, int name){
     234        /*Nothing updated yet*/
     235}
     236/*}}}*/
     237/*FUNCTION DoubleVecParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     238void  DoubleVecParam::InputUpdateFromConstant(bool constant, int name){
    239239        /*Nothing updated yet*/
    240240}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959
    6060                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r3834 r4079  
    160160}
    161161/*}}}*/
    162 /*FUNCTION IntParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    163 void  IntParam::UpdateInputsFromConstant(double constant, int name){
     162/*FUNCTION IntParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     163void  IntParam::InputUpdateFromConstant(double constant, int name){
    164164        /*Nothing updated yet*/
    165165}
    166166/*}}}*/
    167 /*FUNCTION IntParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    168 void  IntParam::UpdateInputsFromConstant(int constant, int name){
     167/*FUNCTION IntParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     168void  IntParam::InputUpdateFromConstant(int constant, int name){
    169169        /*Nothing updated yet*/
    170170}
    171171/*}}}*/
    172 /*FUNCTION IntParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    173 void  IntParam::UpdateInputsFromConstant(bool constant, int name){
     172/*FUNCTION IntParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     173void  IntParam::InputUpdateFromConstant(bool constant, int name){
    174174        /*Nothing updated yet*/
    175175}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060

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

    r4059 r4079  
    242242}
    243243/*}}}*/
    244 /*FUNCTION PetscMatParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    245 void  PetscMatParam::UpdateInputsFromConstant(double constant, int name){
    246         /*Nothing updated yet*/
    247 }
    248 /*}}}*/
    249 /*FUNCTION PetscMatParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    250 void  PetscMatParam::UpdateInputsFromConstant(int constant, int name){
    251         /*Nothing updated yet*/
    252 }
    253 /*}}}*/
    254 /*FUNCTION PetscMatParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    255 void  PetscMatParam::UpdateInputsFromConstant(bool constant, int name){
     244/*FUNCTION PetscMatParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     245void  PetscMatParam::InputUpdateFromConstant(double constant, int name){
     246        /*Nothing updated yet*/
     247}
     248/*}}}*/
     249/*FUNCTION PetscMatParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     250void  PetscMatParam::InputUpdateFromConstant(int constant, int name){
     251        /*Nothing updated yet*/
     252}
     253/*}}}*/
     254/*FUNCTION PetscMatParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     255void  PetscMatParam::InputUpdateFromConstant(bool constant, int name){
    256256        /*Nothing updated yet*/
    257257}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060

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

    r4059 r4079  
    236236}
    237237/*}}}*/
    238 /*FUNCTION PetscVecParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    239 void  PetscVecParam::UpdateInputsFromConstant(double constant, int name){
    240         /*Nothing updated yet*/
    241 }
    242 /*}}}*/
    243 /*FUNCTION PetscVecParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    244 void  PetscVecParam::UpdateInputsFromConstant(int constant, int name){
    245         /*Nothing updated yet*/
    246 }
    247 /*}}}*/
    248 /*FUNCTION PetscVecParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    249 void  PetscVecParam::UpdateInputsFromConstant(bool constant, int name){
     238/*FUNCTION PetscVecParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     239void  PetscVecParam::InputUpdateFromConstant(double constant, int name){
     240        /*Nothing updated yet*/
     241}
     242/*}}}*/
     243/*FUNCTION PetscVecParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     244void  PetscVecParam::InputUpdateFromConstant(int constant, int name){
     245        /*Nothing updated yet*/
     246}
     247/*}}}*/
     248/*FUNCTION PetscVecParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     249void  PetscVecParam::InputUpdateFromConstant(bool constant, int name){
    250250        /*Nothing updated yet*/
    251251}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060

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

    r4059 r4079  
    265265}
    266266/*}}}*/
    267 /*FUNCTION StringArrayParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    268 void  StringArrayParam::UpdateInputsFromConstant(double constant, int name){
    269         /*Nothing updated yet*/
    270 }
    271 /*}}}*/
    272 /*FUNCTION StringArrayParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    273 void  StringArrayParam::UpdateInputsFromConstant(int constant, int name){
    274         /*Nothing updated yet*/
    275 }
    276 /*}}}*/
    277 /*FUNCTION StringArrayParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    278 void  StringArrayParam::UpdateInputsFromConstant(bool constant, int name){
     267/*FUNCTION StringArrayParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     268void  StringArrayParam::InputUpdateFromConstant(double constant, int name){
     269        /*Nothing updated yet*/
     270}
     271/*}}}*/
     272/*FUNCTION StringArrayParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     273void  StringArrayParam::InputUpdateFromConstant(int constant, int name){
     274        /*Nothing updated yet*/
     275}
     276/*}}}*/
     277/*FUNCTION StringArrayParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     278void  StringArrayParam::InputUpdateFromConstant(bool constant, int name){
    279279        /*Nothing updated yet*/
    280280}

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

    r4059 r4079  
    5656                void  UpdateInputsFromVector(int* vector, int name, int type);
    5757                void  UpdateInputsFromVector(bool* vector, int name, int type);
    58                 void  UpdateInputsFromConstant(double constant, int name);
    59                 void  UpdateInputsFromConstant(int constant, int name);
    60                 void  UpdateInputsFromConstant(bool constant, int name);
     58                void  InputUpdateFromConstant(double constant, int name);
     59                void  InputUpdateFromConstant(int constant, int name);
     60                void  InputUpdateFromConstant(bool constant, int name);
    6161                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6262

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

    r4059 r4079  
    191191}
    192192/*}}}*/
    193 /*FUNCTION StringParam::UpdateInputsFromConstant(double constant, int name) {{{1*/
    194 void  StringParam::UpdateInputsFromConstant(double constant, int name){
    195         /*Nothing updated yet*/
    196 }
    197 /*}}}*/
    198 /*FUNCTION StringParam::UpdateInputsFromConstant(int constant, int name) {{{1*/
    199 void  StringParam::UpdateInputsFromConstant(int constant, int name){
    200         /*Nothing updated yet*/
    201 }
    202 /*}}}*/
    203 /*FUNCTION StringParam::UpdateInputsFromConstant(bool constant, int name) {{{1*/
    204 void  StringParam::UpdateInputsFromConstant(bool constant, int name){
     193/*FUNCTION StringParam::InputUpdateFromConstant(double constant, int name) {{{1*/
     194void  StringParam::InputUpdateFromConstant(double constant, int name){
     195        /*Nothing updated yet*/
     196}
     197/*}}}*/
     198/*FUNCTION StringParam::InputUpdateFromConstant(int constant, int name) {{{1*/
     199void  StringParam::InputUpdateFromConstant(int constant, int name){
     200        /*Nothing updated yet*/
     201}
     202/*}}}*/
     203/*FUNCTION StringParam::InputUpdateFromConstant(bool constant, int name) {{{1*/
     204void  StringParam::InputUpdateFromConstant(bool constant, int name){
    205205        /*Nothing updated yet*/
    206206}

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

    r4059 r4079  
    5454                void  UpdateInputsFromVector(int* vector, int name, int type);
    5555                void  UpdateInputsFromVector(bool* vector, int name, int type);
    56                 void  UpdateInputsFromConstant(double constant, int name);
    57                 void  UpdateInputsFromConstant(int constant, int name);
    58                 void  UpdateInputsFromConstant(bool constant, int name);
     56                void  InputUpdateFromConstant(double constant, int name);
     57                void  InputUpdateFromConstant(int constant, int name);
     58                void  InputUpdateFromConstant(bool constant, int name);
    5959                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    6060

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

    r4043 r4079  
    4242                void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    4343                void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    44                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    45                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     44                void    InputUpdateFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     45                void    InputUpdateFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     46                void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    4747
    4848                void    UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r3863 r4079  
    198198}
    199199/*}}}*/
    200 /*FUNCTION Vertex::UpdateInputsFromConstant(double constant, int name) {{{2*/
    201 void  Vertex::UpdateInputsFromConstant(double constant, int name){
    202         /*Nothing updated yet*/
    203 }
    204 /*}}}*/
    205 /*FUNCTION Vertex::UpdateInputsFromConstant(int constant, int name) {{{2*/
    206 void  Vertex::UpdateInputsFromConstant(int constant, int name){
    207         /*Nothing updated yet*/
    208 }
    209 /*}}}*/
    210 /*FUNCTION Vertex::UpdateInputsFromConstant(bool constant, int name) {{{2*/
    211 void  Vertex::UpdateInputsFromConstant(bool constant, int name){
     200/*FUNCTION Vertex::InputUpdateFromConstant(double constant, int name) {{{2*/
     201void  Vertex::InputUpdateFromConstant(double constant, int name){
     202        /*Nothing updated yet*/
     203}
     204/*}}}*/
     205/*FUNCTION Vertex::InputUpdateFromConstant(int constant, int name) {{{2*/
     206void  Vertex::InputUpdateFromConstant(int constant, int name){
     207        /*Nothing updated yet*/
     208}
     209/*}}}*/
     210/*FUNCTION Vertex::InputUpdateFromConstant(bool constant, int name) {{{2*/
     211void  Vertex::InputUpdateFromConstant(bool constant, int name){
    212212        /*Nothing updated yet*/
    213213}

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

    r4043 r4079  
    5353                void  UpdateInputsFromVector(int* vector, int name, int type);
    5454                void  UpdateInputsFromVector(bool* vector, int name, int type);
    55                 void  UpdateInputsFromConstant(double constant, int name);
    56                 void  UpdateInputsFromConstant(int constant, int name);
    57                 void  UpdateInputsFromConstant(bool constant, int name);
     55                void  InputUpdateFromConstant(double constant, int name);
     56                void  InputUpdateFromConstant(int constant, int name);
     57                void  InputUpdateFromConstant(bool constant, int name);
    5858
    5959                void  UpdateInputsFromSolution(double* solution){ISSMERROR("Not implemented yet!");}

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

    r4070 r4079  
    7070
    7171                _printf_("\n%s%i%s%i\n","   control method step ",n+1,"/",nsteps);
    72                 UpdateInputsFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,fit[n],FitEnum);
     72                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,fit[n],FitEnum);
    7373               
    7474                /*In case we are running a steady state control method, compute new temperature field using new parameter * distribution: */

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

    r4070 r4079  
    6767
    6868        /*Compute misfit for this velocity field.*/
    69         UpdateInputsFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,fit[n],FitEnum);
     69        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,fit[n],FitEnum);
    7070        CostFunctionx( &J, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    7171

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

    r4064 r4079  
    115115               
    116116                /*add converged to inputs: */
    117                 UpdateInputsFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,converged,ConvergedEnum);
     117                InputUpdateFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,converged,ConvergedEnum);
    118118
    119119                //rift convergence

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

    r4055 r4079  
    5656
    5757                if(count==1) reset_penalties=1; else reset_penalties=0;
    58                 UpdateInputsFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,reset_penalties,ResetPenaltiesEnum);
     58                InputUpdateFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,reset_penalties,ResetPenaltiesEnum);
    5959
    6060                //*Generate system matrices
Note: See TracChangeset for help on using the changeset viewer.