Changeset 4547


Ignore:
Timestamp:
07/13/10 08:48:54 (15 years ago)
Author:
Mathieu Morlighem
Message:

cosmetics (fold names)

Location:
issm/trunk/src/c/Container
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r4310 r4547  
    450450}
    451451/*}}}*/
    452 /*FUNCTION DataSet::GetEnum{{{1*/
     452/*FUNCTION DataSet::GetEnum(){{{1*/
    453453int  DataSet::GetEnum(){
    454454        return enum_type;

  • issm/trunk/src/c/Container/Inputs.cpp

    r4237 r4547  
    9797}
    9898/*}}}*/
     99/*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node, int enum_type){{{1*/
     100void Inputs::GetParameterValue(double* pvalue,Node* node,int enum_type){
     101
     102        /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
     103
     104        vector<Object*>::iterator object;
     105        Input* input=NULL;
     106        bool   found=false;
     107
     108        /*Go through inputs and check whether any input with the same name is already in: */
     109        for ( object=objects.begin() ; object < objects.end(); object++ ){
     110
     111                input=(Input*)(*object);
     112                if (input->EnumType()==enum_type){
     113                        found=true;
     114                        break;
     115                }
     116        }
     117
     118        if (!found){
     119                /*we could not find an input with the correct enum type. No defaults values were provided,
     120                 * error out: */
     121                ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
     122        }
     123
     124        /*Ok, we have an input if we made it here, request the input to return the values: */
     125        input->GetParameterValue(pvalue,node);
     126}
     127/*}}}*/
     128/*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node1, Node* node2,int enum_type){{{1*/
     129void Inputs::GetParameterValue(double* pvalue,Node* node1, Node* node2,double gauss_coord,int enum_type){
     130
     131        /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
     132
     133        vector<Object*>::iterator object;
     134        Input* input=NULL;
     135        bool   found=false;
     136
     137        /*Go through inputs and check whether any input with the same name is already in: */
     138        for ( object=objects.begin() ; object < objects.end(); object++ ){
     139
     140                input=(Input*)(*object);
     141                if (input->EnumType()==enum_type){
     142                        found=true;
     143                        break;
     144                }
     145        }
     146
     147        if (!found){
     148                /*we could not find an input with the correct enum type. No defaults values were provided,
     149                 * error out: */
     150                ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
     151        }
     152
     153        /*Ok, we have an input if we made it here, request the input to return the values: */
     154        input->GetParameterValue(pvalue,node1,node2,gauss_coord);
     155}
     156/*}}}*/
     157/*FUNCTION Inputs::GetParameterValue(bool* pvalue,int enum-type){{{1*/
     158void Inputs::GetParameterValue(bool* pvalue,int enum_type){
     159
     160        vector<Object*>::iterator object;
     161        Input* input=NULL;
     162        bool   found=false;
     163
     164        /*Go through inputs and check whether any input with the same name is already in: */
     165        for ( object=objects.begin() ; object < objects.end(); object++ ){
     166
     167                input=(Input*)(*object);
     168                if (input->EnumType()==enum_type){
     169                        found=true;
     170                        break;
     171                }
     172        }
     173
     174        if (!found){
     175                /*we could not find an input with the correct enum type. No defaults values were provided,
     176                 * error out: */
     177                ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
     178        }
     179
     180        /*Ok, we have an input if we made it here, request the input to return the value: */
     181        input->GetParameterValue(pvalue);
     182
     183}
     184/*}}}*/
     185/*FUNCTION Inputs::GetParameterValue(int* pvalue,int enum-type){{{1*/
     186void Inputs::GetParameterValue(int* pvalue,int enum_type){
     187
     188        vector<Object*>::iterator object;
     189        Input* input=NULL;
     190        bool   found=false;
     191
     192        /*Go through inputs and check whether any input with the same name is already in: */
     193        for ( object=objects.begin() ; object < objects.end(); object++ ){
     194
     195                input=(Input*)(*object);
     196                if (input->EnumType()==enum_type){
     197                        found=true;
     198                        break;
     199                }
     200        }
     201
     202        if (!found){
     203                /*we could not find an input with the correct enum type. No defaults values were provided,
     204                 * error out: */
     205                ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
     206        }
     207
     208        /*Ok, we have an input if we made it here, request the input to return the value: */
     209        input->GetParameterValue(pvalue);
     210
     211}
     212/*}}}*/
     213/*FUNCTION Inputs::GetParameterValue(double* pvalue,int enum-type){{{1*/
     214void Inputs::GetParameterValue(double* pvalue,int enum_type){
     215
     216        vector<Object*>::iterator object;
     217        Input* input=NULL;
     218        bool   found=false;
     219
     220        /*Go through inputs and check whether any input with the same name is already in: */
     221        for ( object=objects.begin() ; object < objects.end(); object++ ){
     222
     223                input=(Input*)(*object);
     224                if (input->EnumType()==enum_type){
     225                        found=true;
     226                        break;
     227                }
     228        }
     229
     230        if (!found){
     231                /*we could not find an input with the correct enum type. No defaults values were provided,
     232                 * error out: */
     233                ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
     234        }
     235
     236        /*Ok, we have an input if we made it here, request the input to return the value: */
     237        input->GetParameterValue(pvalue);
     238
     239}
     240/*}}}*/
    99241/*FUNCTION Inputs::GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type){{{1*/
    100242void Inputs::GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type){
    … …  
    125267}
    126268/*}}}*/
    127 /*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node, int enum_type){{{1*/
    128 void Inputs::GetParameterValue(double* pvalue,Node* node,int enum_type){
    129 
    130         /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
    131 
    132         vector<Object*>::iterator object;
    133         Input* input=NULL;
    134         bool   found=false;
    135 
    136         /*Go through inputs and check whether any input with the same name is already in: */
    137         for ( object=objects.begin() ; object < objects.end(); object++ ){
    138 
    139                 input=(Input*)(*object);
    140                 if (input->EnumType()==enum_type){
    141                         found=true;
    142                         break;
    143                 }
    144         }
    145 
    146         if (!found){
    147                 /*we could not find an input with the correct enum type. No defaults values were provided,
    148                  * error out: */
    149                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
    150         }
    151 
    152         /*Ok, we have an input if we made it here, request the input to return the values: */
    153         input->GetParameterValue(pvalue,node);
    154 }
    155 /*}}}*/
    156 /*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node1, Node* node2,int enum_type){{{1*/
    157 void Inputs::GetParameterValue(double* pvalue,Node* node1, Node* node2,double gauss_coord,int enum_type){
    158 
    159         /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
    160 
    161         vector<Object*>::iterator object;
    162         Input* input=NULL;
    163         bool   found=false;
    164 
    165         /*Go through inputs and check whether any input with the same name is already in: */
    166         for ( object=objects.begin() ; object < objects.end(); object++ ){
    167 
    168                 input=(Input*)(*object);
    169                 if (input->EnumType()==enum_type){
    170                         found=true;
    171                         break;
    172                 }
    173         }
    174 
    175         if (!found){
    176                 /*we could not find an input with the correct enum type. No defaults values were provided,
    177                  * error out: */
    178                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
    179         }
    180 
    181         /*Ok, we have an input if we made it here, request the input to return the values: */
    182         input->GetParameterValue(pvalue,node1,node2,gauss_coord);
    183 }
    184 /*}}}*/
    185269/*FUNCTION Inputs::GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type,double* defaultvalues){{{1*/
    186270void Inputs::GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type,double* defaultvalues){
    … …  
    211295}
    212296/*}}}*/
    213 /*FUNCTION Inputs::GetParameterAverage(double* pvalue,int enum-type){{{1*/
     297/*FUNCTION Inputs::GetParameterAverage{{{1*/
    214298void Inputs::GetParameterAverage(double* pvalue,int enum_type){
    215299
    … …  
    239323}
    240324/*}}}*/
    241 /*FUNCTION Inputs::GetParameterValue(bool* pvalue,int enum-type){{{1*/
    242 void Inputs::GetParameterValue(bool* pvalue,int enum_type){
    243 
    244         vector<Object*>::iterator object;
    245         Input* input=NULL;
    246         bool   found=false;
    247 
    248         /*Go through inputs and check whether any input with the same name is already in: */
    249         for ( object=objects.begin() ; object < objects.end(); object++ ){
    250 
    251                 input=(Input*)(*object);
    252                 if (input->EnumType()==enum_type){
    253                         found=true;
    254                         break;
    255                 }
    256         }
    257 
    258         if (!found){
    259                 /*we could not find an input with the correct enum type. No defaults values were provided,
    260                  * error out: */
    261                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
    262         }
    263 
    264         /*Ok, we have an input if we made it here, request the input to return the value: */
    265         input->GetParameterValue(pvalue);
    266 
    267 }
    268 /*}}}*/
    269 /*FUNCTION Inputs::GetParameterValue(int* pvalue,int enum-type){{{1*/
    270 void Inputs::GetParameterValue(int* pvalue,int enum_type){
    271 
    272         vector<Object*>::iterator object;
    273         Input* input=NULL;
    274         bool   found=false;
    275 
    276         /*Go through inputs and check whether any input with the same name is already in: */
    277         for ( object=objects.begin() ; object < objects.end(); object++ ){
    278 
    279                 input=(Input*)(*object);
    280                 if (input->EnumType()==enum_type){
    281                         found=true;
    282                         break;
    283                 }
    284         }
    285 
    286         if (!found){
    287                 /*we could not find an input with the correct enum type. No defaults values were provided,
    288                  * error out: */
    289                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
    290         }
    291 
    292         /*Ok, we have an input if we made it here, request the input to return the value: */
    293         input->GetParameterValue(pvalue);
    294 
    295 }
    296 /*}}}*/
    297 /*FUNCTION Inputs::GetParameterValue(double* pvalue,int enum-type){{{1*/
    298 void Inputs::GetParameterValue(double* pvalue,int enum_type){
    299 
    300         vector<Object*>::iterator object;
    301         Input* input=NULL;
    302         bool   found=false;
    303 
    304         /*Go through inputs and check whether any input with the same name is already in: */
    305         for ( object=objects.begin() ; object < objects.end(); object++ ){
    306 
    307                 input=(Input*)(*object);
    308                 if (input->EnumType()==enum_type){
    309                         found=true;
    310                         break;
    311                 }
    312         }
    313 
    314         if (!found){
    315                 /*we could not find an input with the correct enum type. No defaults values were provided,
    316                  * error out: */
    317                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumAsString(enum_type));
    318         }
    319 
    320         /*Ok, we have an input if we made it here, request the input to return the value: */
    321         input->GetParameterValue(pvalue);
    322 
    323 }
    324 /*}}}*/
    325 /*FUNCTION Inputs::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, double* gauss,int enum_type){{{1*/
     325/*FUNCTION Inputs::GetParameterDerivativeValue{{{1*/
    326326void Inputs::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, double* gauss,int enum_type){
    327327
    … …  
    350350}
    351351/*}}}*/
    352 /*FUNCTION Inputs::GetStrainRate2d(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum){{{1*/
     352/*FUNCTION Inputs::GetStrainRate2d{{{1*/
    353353void Inputs::GetStrainRate2d(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum){
    354354        /*Compute the 2d Strain Rate (3 components):
    … …  
    397397}
    398398/*}}}*/
    399 /*FUNCTION Inputs::GetStrainRate3d(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum, int vzenum){{{1*/
     399/*FUNCTION Inputs::GetStrainRate3d{{{1*/
    400400void Inputs::GetStrainRate3d(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum,int vzenum){
    401401        /*Compute the 3d Strain Rate (6 components):
    … …  
    456456}
    457457/*}}}*/
    458 /*FUNCTION Inputs::GetStrainRate3dPattyn(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum){{{1*/
     458/*FUNCTION Inputs::GetStrainRate3dPattyn{{{1*/
    459459void Inputs::GetStrainRate3dPattyn(double* epsilon,double* xyz_list, double* gauss, int vxenum, int vyenum){
    460460        /*Compute the 3d Blatter/PattynStrain Rate (5 components):

  • issm/trunk/src/c/Container/Nodes.cpp

    r4435 r4547  
    208208}
    209209/*}}}*/
    210 /*FUNCTION Nodes::NumberOfDofs(int analysis_type){{{1*/
     210/*FUNCTION Nodes::NumberOfDofs{{{1*/
    211211int   Nodes::NumberOfDofs(int analysis_type){
    212212
Note: See TracChangeset for help on using the changeset viewer.