Changeset 16186


Ignore:
Timestamp:
09/19/13 14:23:51 (12 years ago)
Author:
Mathieu Morlighem
Message:

CHG: removed InputCreate which was doing the same thing as InputUpdateFromConstant

Location:
issm/trunk-jpl/src/c/classes
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/Elements/Element.h

    r16042 r16186  
    6666                virtual void   InputToResult(int enum_type,int step,IssmDouble time)=0;
    6767                virtual void   InputDuplicate(int original_enum,int new_enum)=0;
    68                 virtual void   InputCreate(IssmDouble scalar,int name,int code)=0;
    6968                virtual void   InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code)=0;
    7069                virtual void   RequestedOutput(int output_enum,int step,IssmDouble time)=0;

  • issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r16167 r16186  
    18591859        /*ArtificialNoise: */
    18601860        input->ArtificialNoise(min,max);
    1861 }
    1862 /*}}}*/
    1863 /*FUNCTION Penta::InputCreate(IssmDouble scalar,int enum,int code);{{{*/
    1864 void Penta::InputCreate(IssmDouble scalar,int name,int code){
    1865 
    1866         /*Check that name is an element input*/
    1867         if (!IsInput(name)) return;
    1868 
    1869         if ((code==5) || (code==1)){ //boolean
    1870                 this->inputs->AddInput(new BoolInput(name,reCast<bool,IssmDouble>(scalar)));
    1871         }
    1872         else if ((code==6) || (code==2)){ //integer
    1873                 this->inputs->AddInput(new IntInput(name,reCast<int,IssmDouble>(scalar)));
    1874         }
    1875         else if ((code==7) || (code==3)){ //IssmDouble
    1876                 this->inputs->AddInput(new DoubleInput(name,scalar));
    1877         }
    1878         else _error_("could not recognize nature of vector from code " << code);
    1879 
    18801861}
    18811862/*}}}*/

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r16125 r16186  
    9494                int    Sid();
    9595                void   InputArtificialNoise(int enum_type,IssmDouble min, IssmDouble max);
    96                 void   InputCreate(IssmDouble scalar,int name,int code);
    9796                void   InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    9897                void   InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r16184 r16186  
    14661466/*FUNCTION Tria::InputUpdateFromConstant(int value, int name);{{{*/
    14671467void  Tria::InputUpdateFromConstant(int constant, int name){
     1468
    14681469        /*Check that name is an element input*/
    1469         if (!IsInput(name)) return;
     1470        if(!IsInput(name)) return;
    14701471
    14711472        /*update input*/
    … …  
    14751476/*FUNCTION Tria::InputUpdateFromConstant(IssmDouble value, int name);{{{*/
    14761477void  Tria::InputUpdateFromConstant(IssmDouble constant, int name){
     1478
    14771479        /*Check that name is an element input*/
    1478         if (!IsInput(name)) return;
     1480        if(!IsInput(name)) return;
    14791481
    14801482        /*update input*/
    … …  
    14841486/*FUNCTION Tria::InputUpdateFromConstant(bool value, int name);{{{*/
    14851487void  Tria::InputUpdateFromConstant(bool constant, int name){
     1488
    14861489        /*Check that name is an element input*/
    1487         if (!IsInput(name)) return;
     1490        if(!IsInput(name)) return;
    14881491
    14891492        /*update input*/
    … …  
    17621765void  Tria::InputUpdateFromVector(IssmDouble* vector, int name, int type){
    17631766
    1764 
    17651767        /*Check that name is an element input*/
    17661768        if (!IsInput(name)) return;
    … …  
    18331835        xDelete<int>(doflist);
    18341836        xDelete<IssmDouble>(values);
    1835 
    1836 }
    1837 /*}}}*/
    1838 /*FUNCTION Tria::InputCreate(IssmDouble scalar,int enum,int code);{{{*/
    1839 void Tria::InputCreate(IssmDouble scalar,int name,int code){
    1840 
    1841         /*Check that name is an element input*/
    1842         if (!IsInput(name)) return;
    1843 
    1844         if ((code==5) || (code==1)){ //boolean
    1845                 this->inputs->AddInput(new BoolInput(name,reCast<bool>(scalar)));
    1846         }
    1847         else if ((code==6) || (code==2)){ //integer
    1848                 this->inputs->AddInput(new IntInput(name,reCast<int>(scalar)));
    1849         }
    1850         else if ((code==7) || (code==3)){ //IssmDouble
    1851                 this->inputs->AddInput(new DoubleInput(name,scalar));
    1852         }
    1853         else _error_("could not recognize nature of vector from code " << code);
    18541837
    18551838}

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r16146 r16186  
    9191                void        GetVectorFromResults(Vector<IssmDouble>* vector,int offset,int enum_in,int interp);
    9292                void        InputArtificialNoise(int enum_type,IssmDouble min, IssmDouble max);
    93                 void        InputCreate(IssmDouble scalar,int name,int code);
    9493                void        InputCreate(IssmDouble* vector, int index,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
    9594                void        InputDepthAverageAtBase(int enum_type,int average_enum_type,int object_enum=MeshElementsEnum);

  • issm/trunk-jpl/src/c/classes/IoModel.cpp

    r16164 r16186  
    10481048        IssmDouble  scalar;
    10491049        char       *string           = NULL;
    1050         IssmDouble *IssmDoublevector = NULL;
     1050        IssmDouble *doublearray = NULL;
    10511051        int         M,N;
    10521052
    … …  
    10601060                case 1: //boolean constant.  {{{
    10611061                        this->FetchData(&boolean,vector_enum);
    1062 
    1063                         /*Add boolean constant input to all elements: */
    1064                         counter=0;
    1065                         for (i=0;i<numberofelements;i++){
    1066                                 if(this->my_elements[i]){
    1067                                         Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1068                                         element->InputCreate((IssmDouble)boolean,vector_enum,code);
    1069                                         counter++;
    1070                                 }
     1062                        for(i=0;i<elements->Size();i++){
     1063                                Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1064                                element->InputUpdateFromConstant(boolean,vector_enum);
    10711065                        }
    10721066                        break; /*}}}*/
    10731067                case 2: //integer constant.  {{{
    10741068                        this->FetchData(&integer,vector_enum);
    1075 
    1076                         /*Add integer constant input to all elements: */
    1077                         counter=0;
    1078                         for (i=0;i<numberofelements;i++){
    1079                                 if(this->my_elements[i]){
    1080                                         Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1081                                         element->InputCreate((IssmDouble)integer,vector_enum,code);
    1082                                         counter++;
    1083                                 }
     1069                        for(i=0;i<elements->Size();i++){
     1070                                Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1071                                element->InputUpdateFromConstant(integer,vector_enum);
    10841072                        }
    10851073                        break; /*}}}*/
    10861074                case 3: //IssmDouble constant.  {{{
    10871075                        this->FetchData(&scalar,vector_enum);
    1088 
    1089                         /*Add IssmDouble constant input to all elements: */
    1090                         counter=0;
    1091                         for (i=0;i<numberofelements;i++){
    1092                                 if(this->my_elements[i]){
    1093                                         Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1094                                         element->InputCreate(scalar,vector_enum,code);
    1095                                         counter++;
    1096                                 }
     1076                        for(i=0;i<elements->Size();i++){
     1077                                Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(i));
     1078                                element->InputUpdateFromConstant(scalar,vector_enum);
    10971079                        }
    10981080                        break; /*}}}*/
    … …  
    11001082
    11011083                        /*Fetch vector:*/
    1102                         this->FetchData(&IssmDoublevector,&M,&N,vector_enum); //we still have a IssmDoublevector, because it might include times in transient mode
     1084                        this->FetchData(&doublearray,&M,&N,vector_enum); //we still have a doublearray, because it might include times in transient mode
    11031085                        /*Check we got something, otherwise fetch default: */
    1104                         if(IssmDoublevector){
     1086                        if(doublearray){
    11051087                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11061088                        }
    … …  
    11091091                                if(default_vector_enum!=NoneEnum){
    11101092                                        /*yes. fetch it: */
    1111                                         this->FetchData(&IssmDoublevector,&M,&N,default_vector_enum);
    1112                                         if(IssmDoublevector){
     1093                                        this->FetchData(&doublearray,&M,&N,default_vector_enum);
     1094                                        if(doublearray){
    11131095                                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11141096                                        }
    … …  
    11291111                                if(this->my_elements[i]){
    11301112                                        Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1131                                         if(defaulting) element->InputCreate(default_value,vector_enum,code);
    1132                                         else           element->InputCreate(IssmDoublevector,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
     1113                                        if(defaulting) element->InputUpdateFromConstant(reCast<bool>(default_value),vector_enum);
     1114                                        else           element->InputCreate(doublearray,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    11331115                                        counter++;
    11341116                                }
    … …  
    11381120
    11391121                        /*Fetch vector:*/
    1140                         this->FetchData(&IssmDoublevector,&M,&N,vector_enum); //we still have a IssmDoublevector, because it might include times in transient mode
     1122                        this->FetchData(&doublearray,&M,&N,vector_enum); //we still have a doublearray, because it might include times in transient mode
    11411123                        /*Check we got something, otherwise fetch default: */
    1142                         if(IssmDoublevector){
     1124                        if(doublearray){
    11431125                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11441126                        }
    … …  
    11471129                                if(default_vector_enum!=NoneEnum){
    11481130                                        /*yes. fetch it: */
    1149                                         this->FetchData(&IssmDoublevector,&M,&N,default_vector_enum);
    1150                                         if(IssmDoublevector){
     1131                                        this->FetchData(&doublearray,&M,&N,default_vector_enum);
     1132                                        if(doublearray){
    11511133                                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11521134                                        }
    … …  
    11671149                                if(this->my_elements[i]){
    11681150                                        Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1169                                         if(defaulting) element->InputCreate(default_value,vector_enum,code);
    1170                                         else           element->InputCreate(IssmDoublevector,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
     1151                                        if(defaulting) element->InputUpdateFromConstant(reCast<int>(default_value),vector_enum);
     1152                                        else           element->InputCreate(doublearray,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    11711153                                        counter++;
    11721154                                }
    … …  
    11761158
    11771159                        /*Fetch vector:*/
    1178                         this->FetchData(&IssmDoublevector,&M,&N,vector_enum);
     1160                        this->FetchData(&doublearray,&M,&N,vector_enum);
    11791161                        /*Check we got something, otherwise fetch default: */
    1180                         if(IssmDoublevector){
     1162                        if(doublearray){
    11811163                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11821164                        }
    … …  
    11851167                                if(default_vector_enum!=NoneEnum){
    11861168                                        /*yes. fetch it: */
    1187                                         this->FetchData(&IssmDoublevector,&M,&N,default_vector_enum);
    1188                                         if(IssmDoublevector){
     1169                                        this->FetchData(&doublearray,&M,&N,default_vector_enum);
     1170                                        if(doublearray){
    11891171                                                defaulting=false;  //we are not defaulting, because  we do have a vector
    11901172                                        }
    … …  
    12051187                                if(this->my_elements[i]){
    12061188                                        Element* element=dynamic_cast<Element*>(elements->GetObjectByOffset(counter));
    1207                                         if(defaulting) element->InputCreate(default_value,vector_enum,code);
    1208                                         else           element->InputCreate(IssmDoublevector,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
     1189                                        if(defaulting) element->InputUpdateFromConstant(default_value,vector_enum);
     1190                                        else           element->InputCreate(doublearray,i,this,M,N,vector_layout,vector_enum,code);//we need i to index into elements.
    12091191                                        counter++;
    12101192                                }
    … …  
    12181200        }
    12191201        /*Free ressources. Pay attention to not freeing an AD mode independent variable though!:*/
    1220         if (!this->independents[vector_enum] && !this->independents[default_vector_enum]) xDelete<IssmDouble>(IssmDoublevector);
     1202        if (!this->independents[vector_enum] && !this->independents[default_vector_enum]) xDelete<IssmDouble>(doublearray);
    12211203        xDelete<char>(string);
    12221204}
Note: See TracChangeset for help on using the changeset viewer.